spice2x.github.io/src/spice2x/reader/reader.cpp

#include "reader.h"

#include <filesystem>
#include <thread>
#include <cstring>
#include <vector>

#include "util/logging.h"
#include "misc/eamuse.h"
#include "util/precise_timer.h"
#include "util/utils.h"
#include "structuredmessage.h"

static std::vector<std::thread *> READER_THREADS;
static bool READER_THREAD_RUNNING = false;

Reader::Reader(const std::string &port) : port(port) {

    // open port using an NT path to support COM ports past 9
    std::filesystem::path serial_path = fmt::format("\\\\.\\{}", this->port);
    this->serial_handle = CreateFileW(
            serial_path.c_str(),
            GENERIC_READ | GENERIC_WRITE,
            0,
            nullptr,
            OPEN_EXISTING,
            0,
            nullptr);

    // check if valid
    this->valid = this->serial_handle != INVALID_HANDLE_VALUE;
    if (!this->valid) {
        auto last_error = get_last_error_string();

        log_warning("reader", "{}: failed to open serial connection for reader: {}",
                this->port,
                last_error);
    }
}

Reader::~Reader() {
    if (this->serial_handle) {
        CloseHandle(this->serial_handle);
        log_info("reader", "closed reader on {}", this->port);
    }
}

bool Reader::is_valid() {
    return this->valid;
}

bool Reader::initialize() {
    if (!this->set_comm_state(CBR_57600) || !this->wait_for_handshake())
        return false;

    log_info("reader", "{}: card reader connected", this->port);

    // assign reader ID
    std::vector<uint8_t> set_id_data;
    set_id_data.push_back(0x00);
    if (this->msg_write_read(StructuredMessage(
            0,
            this->reinitialized,
            READER_CMD_SET_ID,
            this->gen_msg_id(),
            set_id_data)).empty())
        return false;

    // get version
    std::vector<Message> ret = this->msg_write_cmd_read(READER_CMD_VERSION);
    if (ret.empty())
        return false;

    // print version info
    std::vector<uint8_t> version_data = ret[ret.size() - 1].get_data();
    std::ostringstream model;
    model << version_data[13] << version_data[14] << version_data[15] << version_data[16];
    log_info("reader", "{}: card reader model: {}", this->port, model.str());
    std::ostringstream date;
    date << (const char *) &version_data[17];
    log_info("reader", "{}: card reader date:  {}", this->port, date.str());
    std::ostringstream clock;
    clock << (const char *) &version_data[33];
    log_info("reader", "{}: card reader clock: {}", this->port, clock.str());

    // init 2
    if (this->msg_write_cmd_read(READER_CMD_INIT2).empty())
        return false;

    // reinitialize
    this->reinitialized = 1;
    std::vector<uint8_t> reinitialize_data;
    reinitialize_data.push_back(0x00);
    if (this->msg_write_cmd_read(READER_CMD_REINITIALIZE, reinitialize_data).empty())
        return false;

    log_info("reader", "{}: card reader init done", this->port);
    return true;
}

bool Reader::init_crypt() {

    // generate game key
    std::vector<uint8_t> gk;
    for (int i = 0; i < 4; i++)
        gk.push_back((uint8_t) (rand() % 256));

    // reader crypt init
    std::vector<Message> ret = this->msg_write_cmd_read(READER_CMD_KEY_EXCHANGE, gk);
    if (ret.empty())
        return false;

    // validate message
    Message msg = ret[ret.size() - 1];
    std::vector<uint8_t> md = msg.get_data();
    if (md.size() != 9)
        return false;

    // convert keys to int32
    uint32_t game_key = gk[0] << 24 | gk[1] << 16 | gk[2] << 8 | gk[3];
    uint32_t reader_key = md[5] << 24 | md[6] << 16 | md[7] << 8 | md[8];
    log_info("reader", "{}: reader crypt client key: {}", this->port, bin2hex((char *) &gk[0], 4));
    log_info("reader", "{}: reader crypt reader key: {}", this->port, bin2hex((char *) &md[5], 4));

    // set crypt keys
    this->crypt.set_keys(reader_key, game_key);

    // crypt done
    log_info("reader", "{}: reader crypt init done", this->port);
    return true;
}

bool Reader::read_card() {

    // read card UID
    std::vector<uint8_t> status_ruid_data;
    status_ruid_data.push_back(0x00);
    status_ruid_data.push_back(0x03);
    status_ruid_data.push_back(0xFF);
    status_ruid_data.push_back(0xFF);
    if (this->msg_write_cmd_read(READER_CMD_RFID_READ_UID, status_ruid_data).empty()) {
        this->valid = false;
        return false;
    }
    Sleep(200);

    // get reader status
    std::vector<uint8_t> status_req_data;
    status_req_data.push_back(0x10);
    std::vector<Message> ret = this->msg_write_cmd_read(READER_CMD_GET_STATUS_ENC, status_req_data);
    if (ret.empty()) {
        this->valid = false;
        return false;
    }

    // get data
    Message status_msg = ret[ret.size() - 1];
    std::vector<uint8_t> status_data = status_msg.get_data();
    if (status_data.size() != 23)
        return false;

    // decrypt data
    this->crypt.crypt(&status_data[5], 18);

    // check CRC
    uint16_t crc_old = status_data[21] << 8 | status_data[22];
    uint16_t crc_new = this->crypt.crc(&status_data[5], 16);
    if (crc_old != crc_new) {
        this->valid = false;
        return false;
    }

    // get keypad state
    this->keypad_started = status_data[16];
    this->keypad_state = status_data[19] << 8 | status_data[20];

    // check for card input
    if (status_data[5] == 2) {
        memcpy(this->card_uid, &status_data[7], 8);
        return true;
    }

    return false;
}

bool Reader::set_comm_state(DWORD BaudRate) {

    // settings
    DCB serial_params{};
    serial_params.DCBlength = sizeof(serial_params);
    if (!GetCommState(this->serial_handle, &serial_params)) {
        log_warning("reader", "{}: unable to get COM port state: 0x{:x}", this->port, GetLastError());
        return false;
    }

    serial_params.BaudRate = BaudRate;
    serial_params.ByteSize = 8;
    serial_params.StopBits = ONESTOPBIT;
    serial_params.Parity = NOPARITY;
    if (!SetCommState(this->serial_handle, &serial_params)) {
        log_warning("reader", "{}: unable to set COM port state: 0x{:x}", this->port, GetLastError());
        return false;
    }

    // timeouts
    COMMTIMEOUTS timeouts{};
    timeouts.ReadIntervalTimeout = 30;
    timeouts.ReadTotalTimeoutConstant = 30;
    timeouts.ReadTotalTimeoutMultiplier = 5;
    timeouts.WriteTotalTimeoutConstant = 30;
    timeouts.WriteTotalTimeoutMultiplier = 5;
    if (!SetCommTimeouts(this->serial_handle, &timeouts)) {
        log_warning("reader", "{}: unable to set COM port timeouts: 0x{:x}", this->port, GetLastError());
        return false;
    }

    return true;
}

bool Reader::wait_for_handshake() {
    timeutils::PreciseSleepTimer timer;

    // baud rates
    DWORD baud_rates[] = { CBR_57600, CBR_38400, CBR_19200, CBR_9600 };

    // variables
    DWORD bytes_written = 0;
    DWORD bytes_read = 0;
    uint8_t read_buffer[565];

    // generate handshake buffer
    uint8_t handshake_buffer[565];
    memset(handshake_buffer, 0, 525);
    memset(handshake_buffer + 525, 0xAA, 40);

    // try all the baud rates
    for (size_t i = 0; i < 4; i++) {

        this->set_comm_state(baud_rates[i]);

        // handshake loop
        for (size_t n = 0; n < 10; n++) {

            // write handshake
            if (!WriteFile(
                        this->serial_handle,
                        handshake_buffer,
                        sizeof(handshake_buffer),
                        &bytes_written,
                        nullptr))
            {
                break;
            }

            // read handshake
            bytes_read = 0;
            if (!ReadFile(
                        this->serial_handle,
                        read_buffer,
                        sizeof(read_buffer),
                        &bytes_read,
                        nullptr))
            {
                break;
            }

            // check handshake
            if (bytes_read > 0 && read_buffer[bytes_read - 1] == 0xAA) {
                return true;
            }

            // sleep
            timer.sleep(50);
        }

        log_warning("reader", "{}: no handshake received for {} baud", this->port, baud_rates[i]);
    }

    // no handshake on all baud rates
    log_warning("reader", "{}: no handshake received for any attempted baud rate", this->port);
    return false;
}

bool Reader::msg_write(Message msg) {

    // get message data
    std::vector<uint8_t> msg_encoded = msg.get_data_encoded();
    uint8_t chk_sum = msg.chk_sum();

    // create write buffer
    uint8_t write_buffer[512];
    DWORD write_buffer_len = 0;

    // fill write buffer
    write_buffer[write_buffer_len++] = 0xAA;
    for (const uint8_t c : msg_encoded) {
        write_buffer[write_buffer_len++] = c;
    }

    // write checksum
    if (chk_sum == 0xAA || chk_sum == 0xFF) {
        write_buffer[write_buffer_len++] = 0xFF;
        write_buffer[write_buffer_len++] = ~chk_sum;
    } else {
        write_buffer[write_buffer_len++] = chk_sum;
    }

    // write buffer
    DWORD bytes_written = 0;
    return WriteFile(this->serial_handle,
            write_buffer,
            write_buffer_len,
            &bytes_written,
            nullptr) != 0;
}

std::vector<Message> Reader::msg_write_read(Message msg) {
    this->msg_write(msg);
    return this->msg_read();
}

std::vector<Message> Reader::msg_write_cmd_read(uint8_t cmd) {
    return this->msg_write_cmd_read(cmd, std::vector<uint8_t>());
}

std::vector<Message> Reader::msg_write_cmd_read(uint8_t cmd, std::vector<uint8_t> data) {
    this->msg_write(StructuredMessage(
            this->node,
            this->reinitialized,
            cmd,
            this->gen_msg_id(),
            data
    ));
    return this->msg_read();
}

std::vector<Message> Reader::msg_read() {

    // create buffer
    std::vector<Message> msgs;
    uint8_t read_buffer[4096];
    DWORD read_buffer_len = 0;

    // read to buffer
    if (ReadFile(
                this->serial_handle,
                read_buffer,
                sizeof(read_buffer),
                &read_buffer_len,
                nullptr) && read_buffer_len > 0)
    {
        std::vector<uint8_t> msg_data;
        size_t msg_remaining = 0;
        bool escape = false;
        for (size_t i = 0; i < read_buffer_len; i++) {
            uint8_t b = read_buffer[i];
            if (msg_remaining > 0) {

                // add msg data length
                if (msg_data.size() < 6 && msg_remaining == 1)
                    msg_remaining += msg_data[4];

                if (escape) { // escaped byte
                    b = ~b;
                    msg_data.push_back(b);
                    msg_remaining--;
                    escape = false;
                } else if (b == 0xAA) { // message start
                    msg_remaining = 6;
                    msg_data.clear();
                } else if (b == 0xFF) { // escape
                    escape = true;
                } else { // normal data
                    msg_data.push_back(b);
                    msg_remaining--;
                }
            } else if (b == 0xAA) { // message start
                msg_remaining = 6;
                msg_data.clear();
            }

            if (msg_remaining == 0 && msg_data.size() >= 6) { // message done
                std::vector<uint8_t> msg_ext_data;
                for (size_t n = 0; n < msg_data[4] && n < msg_data.size() - 6; n++) {
                    msg_ext_data.push_back(msg_data[5 + n]);
                }
                StructuredMessage msg(
                        msg_data[0],
                        msg_data[1],
                        msg_data[2],
                        msg_data[3],
                        msg_ext_data
                );
                if (msg.chk_sum() == msg_data[msg_data.size() - 1]) {
                    msgs.push_back(msg);
                }
                msg_data.clear();
            }
        }
    }

    // return message buffer
    return msgs;
}

void start_reader_thread(const std::string &port, int id) {
    READER_THREAD_RUNNING = true;
    READER_THREADS.push_back(new std::thread([port, id]() {
        log_info("reader", "{}: starting reader thread", port);
        timeutils::PreciseSleepTimer timer;

        while (READER_THREAD_RUNNING) {

            // create reader
            Reader reader(port);

            // check if serial handle is still valid
            if (!reader.is_valid()) {
                log_warning("reader", "{}: serial handle no longer valid", port);
            } else if (!reader.initialize()) {
                log_warning("reader", "{}: unable to initialize reader", port);
            } else if (reader.init_crypt()) {

                // reader loop
                while (READER_THREAD_RUNNING && reader.is_valid()) {
                    bool did_read_card = reader.read_card();

                    if (did_read_card) {
                        const uint8_t *uid = reader.get_card_uid();
                        log_info("reader", "{}: reader input: {}", port, bin2hex(uid, 8));
                        if (id >= 0) {
                            eamuse_card_insert(id, uid);
                        } else {
                            eamuse_card_insert(GetKeyState(VK_NUMLOCK) & 1, uid);
                        }
                    }

                    if (reader.keypad_started > 0) {
                        if (id >= 0) {
                            eamuse_set_keypad_overrides_reader(id, reader.keypad_state);
                        } else {
                            auto unit = GetKeyState(VK_NUMLOCK) & 1;
                            eamuse_set_keypad_overrides_reader(unit, reader.keypad_state);
                        }
                    }

                    if (did_read_card) {
                        timer.sleep(2500);
                    }

                    timer.sleep(20);
                }
            }

            // sleep between reader connection retries
            if (READER_THREAD_RUNNING)
                timer.sleep(5000);
        }
    }));

    // wait for thread to start
    timeutils::PreciseSleepTimer timer;
    timer.sleep(10);
}

void stop_reader_thread() {

    // stop threads
    if (READER_THREAD_RUNNING) {
        READER_THREAD_RUNNING = false;
    }

    // kill threads
    while (!READER_THREADS.empty()) {
        delete READER_THREADS.back();
        READER_THREADS.pop_back();
    }
}