int incomingByte = 0;

#define RELAY_IN 5
void setup()
{
    Serial.begin(9600);
    pinMode(RELAY_IN, OUTPUT);
}

void loop()
{
    if (Serial.available() > 0) {

        incomingByte = Serial.read();

        if (incomingByte == 'k') {
            Serial.print((char)incomingByte);
            Serial.print('\n');
            delay(500);
            digitalWrite(RELAY_IN, HIGH);
            delay(500);
            digitalWrite(RELAY_IN, LOW);
        }
    }
}

void usb_read_token(char* token)
{
    char* usb_dev = getenv("USB_DEV");

    struct pollfd fds[1];
    fds[0].fd = open(usb_dev, O_RDONLY | O_NONBLOCK);
    fds[0].events = POLLIN;

    if (fds[0].fd < 0) {
        printf("Error unable open for reading '%s'\n", usb_dev);
        exit(1);
    }

    char keys[100] = { 0, 1,
        '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', 12, 13, 14, 15,
        'q', 'w', 'e', 'r', 't', 'y', 'u', 'i', 'o', 'p', 26, 27, 28, 29,
        'a', 's', 'd', 'f', 'g', 'h', 'j', 'k', 'l', 39, 40, 41, 42, 43,
        'z', 'x', 'c', 'v', 'b', 'n', 'm' };

    struct input_event ev;
    int char_count = 0;

    char* pass = getenv("PASS");
    sprintf(token, "%s", pass);

    while (true) {
        int timeout_ms = 1000;
        int ret = poll(fds, 1, timeout_ms);

        if (ret > 0) {
            if (fds[0].revents) {
                ssize_t r = read(fds[0].fd, &ev, sizeof(ev));

                if (r < 0) {
                    printf("Error %d\n", (int)r);
                    break;
                } else {
                    if (ev.type == 1 && ev.value == 1) {
                        sprintf(token + strlen(token), "%c", keys[ev.code]);
                        char_count++;
                        if (char_count >= 44) {
                            sprintf(token + strlen(token), "\n");
                            break;
                        }
                    }
                }
            }
        }
    }

    close(fds[0].fd);
}

void serial_send_command()
{
    char* serial_dev = getenv("SERIAL_DEV");
    const char check_sym = 'k';

    int serial_port = open(serial_dev, O_RDWR);
    struct termios tty;

    if (tcgetattr(serial_port, &tty) != 0) {
        printf("Error %i from tcgetattr: %s\n", errno, strerror(errno));
        exit(1);
    }

    tty.c_cflag &= ~PARENB;
    tty.c_cflag &= ~CSTOPB;
    tty.c_cflag &= ~CSIZE;
    tty.c_cflag |= CS8;
    tty.c_cflag &= ~CRTSCTS;
    tty.c_cflag |= CREAD | CLOCAL;
    tty.c_lflag &= ~ICANON;
    tty.c_lflag &= ~ECHO;
    tty.c_lflag &= ~ECHOE;
    tty.c_lflag &= ~ECHONL;
    tty.c_lflag &= ~ISIG;
    tty.c_iflag &= ~(IXON | IXOFF | IXANY);
    tty.c_iflag &= ~(IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR | IGNCR | ICRNL);
    tty.c_oflag &= ~OPOST;
    tty.c_oflag &= ~ONLCR;

    tty.c_cc[VTIME] = 10;
    tty.c_cc[VMIN] = 0;

    cfsetispeed(&tty, B9600);
    cfsetospeed(&tty, B9600);

    if (tcsetattr(serial_port, TCSANOW, &tty) != 0) {
        printf("Error %i from tcsetattr: %s\n", errno, strerror(errno));
        exit(1);
    }

    unsigned char msg[] = { check_sym, '\r' };
    write(serial_port, msg, sizeof(msg));

    char read_buf[256];
    memset(&read_buf, '\0', sizeof(read_buf));

    int num_bytes = read(serial_port, &read_buf, sizeof(read_buf));

    if (num_bytes < 0) {
        printf("Error reading: %s", strerror(errno));
        exit(1);
    }

    if (read_buf[0] != check_sym) {
        printf("Wrong read data\n");
        printf("Read %i bytes. Received message: %s", num_bytes, read_buf);
        exit(1);
    }

    close(serial_port);
}

int main(int argc, char* argv[])
{
    int sockfd, connfd;
    struct sockaddr_in servaddr, cli;

    char token[100];

    uint32_t cli_len = sizeof(cli);

    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd == -1) {
        printf("socket creation failed...\n");
        exit(0);
    } else {
        printf("Socket successfully created..\n");
    }

    bzero(&servaddr, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    servaddr.sin_port = htons(atoi(getenv("PORT")));

    if ((bind(sockfd, (struct sockaddr*)&servaddr, sizeof(servaddr))) != 0) {
        printf("socket bind failed...\n");
        exit(0);
    } else {
        printf("Socket successfully binded..\n");
    }

    if ((listen(sockfd, 5)) != 0) {
        printf("Listen failed...\n");
        exit(0);
    } else {
        printf("Server listening..\n");
    }

    while (1) {
        connfd = accept(sockfd, (struct sockaddr*)&cli, &cli_len);
        if (connfd < 0) {
            printf("server accept failed...\n");
            exit(0);
        } else {
            printf("server accept the client...\n");
        }

        serial_send_command();

        usb_read_token(token);

        write(connfd, token, strlen(token));

        close(connfd);

        fflush(stdout);
    }

    close(sockfd);

    return 0;
}

#!/bin/sh /etc/rc.common
# Copyright (C) 2010-2015 OpenWrt.org

START=99

USE_PROCD=1
PROG=/usr/bin/yubikey-hack

start_service() {
	procd_open_instance
	procd_set_param command "$PROG"
	procd_set_param respawn
	procd_set_param stdout 1

	file=$(cat /etc/yubikey-hack/env)
	for line in $file; do
		procd_append_param env "$line"
	done

	procd_close_instance
}