/*
 * Copyright 2013, David Schmenk
 */
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <termios.h>
#include <string.h>
#include <netinet/in.h>
#include <time.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <linux/input.h>
#include <linux/uinput.h>

//char deftty[] = "/dev/ttyAMA0"; /* Default for Raspberry Pi */
char deftty[] = "/dev/serial0"; /* Default for Raspberry Pi */
#if defined(SETSERCLK) && defined(__ARMEL__)
#include "gpclk.c"
#endif

#define BAUDRATE B115200
#define _POSIX_SOURCE 1 /* POSIX compliant source */
#define FALSE 0
#define TRUE 1
#define die(str, args...) do { \
    prlog(str); \
    exit(-1); \
} while(0)
/*
 * Apple II request entry
 */
#define MAX_XFER        64
#define AWAIT_COMPLETE	0x100
struct a2request {
    int  idx;
    int  type;
    int  addr;
    int  count;
    int  xfer;
    char *buffer;
    struct a2request *next;
} *a2reqlist = NULL, *a2reqfree = NULL;
/*
 * Client info
 */
#define	CLIENT_OPEN	1
#define	CLIENT_CLOSING	2
#define	CLIENT_COUT	4
#define MAX_CLIENT	8

struct {
    int fd;
    int flags;
} a2client[MAX_CLIENT];
/*
 * Virtual drive info
 */
int vdrvfd[2];
/*
 * ASCII to scancode conversion
 */
#define MOD_FN          0x80
#define MOD_CTRL        0x8000
#define MOD_ALT         0x4000
#define MOD_SHIFT       0x2000
#define KEY_CODE        0x03FF
#define KEY_PRESS       0x80
#define KEY_ASCII       0x7F
#define KEYCODE_MAX	0x10000
#include	"kbmap.h"
/*
 * Daemon states.
 */
#define	RUN	0
#define	STOP	1
#define	RESET	2
volatile int state = RUN, isdaemon = FALSE;
void prlog(char *str)
{
    if (!isdaemon)
	puts(str);
}
static void sig_bye(int signo)
{
    /*
     * Exit gracefully
     */
    state = STOP;
}
/*****************************************************************\
*                                                                 *
*                         vdrv commands                           *
*                                                                 *
\*****************************************************************/
int vdrvopen(char *path)
{
    char filename[256];
    strcpy(filename, path);
    strcat(filename, "A2VD1.PO");
    //printf("vdrv: open %s\n", filename);
    if ((vdrvfd[0] = open(filename, O_RDWR, 0)) < 0)
        vdrvfd[0] = 0;
    strcpy(filename, path);
    strcat(filename, "A2VD2.PO");
    //printf("vdrv: open %s\n", filename);
    if ((vdrvfd[1] = open(filename, O_RDWR, 0)) < 0)
        vdrvfd[1] = 0;
    return vdrvfd[0] + vdrvfd[1];
}
void vdrvclose(void)
{
    if (vdrvfd[0]) close(vdrvfd[0]);
    if (vdrvfd[1]) close(vdrvfd[1]);
    vdrvfd[0] = vdrvfd[1] = 0;
}
unsigned char *prodos_time(void)
{
    static unsigned char time_buff[4];
    /*
     * Get ProDOS time.
     */
    time_t now = time(NULL);
    struct tm *tm = localtime(&now);
    int ptime =   (tm->tm_mday        & 0x1F)
              | (((tm->tm_mon  + 1)   & 0x0F) << 5)
              | (((tm->tm_year - 100) & 0x7F) << 9)
              |  ((tm->tm_min         & 0x3F) << 16)
              |  ((tm->tm_hour        & 0x1F) << 24);
    time_buff[0] = (unsigned char) ptime;
    time_buff[1] = (unsigned char) (ptime >> 8);
    time_buff[2] = (unsigned char) (ptime >> 16);
    time_buff[3] = (unsigned char) (ptime >> 24);
    return time_buff;
}
int vdrvtime(int afd)
{
    return write(afd, prodos_time(), 4);
}
int vdrvstat(int afd, int drive)
{
    struct stat vstat;
    unsigned char size_buff[2];
    
    if (vdrvfd[drive])
        fstat(vdrvfd[drive], &vstat);
    else
        vstat.st_size = 0;
    size_buff[0] = vstat.st_size >> 9;
    size_buff[1] = vstat.st_size >> 17;
    write(afd, size_buff, 2);
    return vdrvfd[drive] == 0 ? 0x28 : 0x00;
}
int vdrvread(int afd, int drive, int block)
{
    int err = 0, vfd = vdrvfd[drive];
    unsigned char block_buff[512];

    if (vfd)
    {
        lseek(vfd, block * 512, 0);
        if (read(vfd, block_buff, 512) != 512)
            err = 0x27; /* ProDOS I/O error */
    }
    else
        err = 0x28; /* ProDOS No device connected error */
    write(afd, block_buff, 512);
    return err;
}
int vdrvwrite(int afd, int drive, int block)
{
    int i, err = 0, vfd = vdrvfd[drive];
    unsigned char block_buff[512];

    for (i = 0; i < 512; i++)
        read(afd, &block_buff[i], 1);
    if (vfd)
    {
        lseek(vfd, block * 512, 0);
        if (write(vfd, block_buff, 512) != 512)
            err = 0x27; /* ProDOS I/O error */
        else
            fsync(vfd);
    }
    else
        err = 0x28; /* ProDOS No device connected error */
    return err;
}
/*****************************************************************\
*                                                                 *
*                      Input device handling                      *
*                                                                 *
\*****************************************************************/
struct input_event evkey, evrelx, evrely, evsync;

void sendkeycodedown(int fd, int code)
{
    /*
     * press keys
     */
    evkey.value = 1;
    if (code & MOD_ALT)
    {
        evkey.code = KEY_LEFTALT;
        write(fd, &evkey, sizeof(evkey));
    }
    if (code & MOD_CTRL)
    {
        evkey.code = KEY_LEFTCTRL;
        write(fd, &evkey, sizeof(evkey));
    }
    if (code & MOD_SHIFT)
    {
        evkey.code = KEY_LEFTSHIFT;
        write(fd, &evkey, sizeof(evkey));
    }
    evkey.code = code & KEY_CODE;
    write(fd, &evkey,  sizeof(evkey));
    write(fd, &evsync, sizeof(evsync));
}
void sendkeycodeup(int fd, int code)
{
    /*
     * release keys
     */
    evkey.code  = code & KEY_CODE;
    evkey.value = 0;
    write(fd, &evkey, sizeof(evkey));
    if (code & MOD_SHIFT)
    {
        evkey.code  = KEY_LEFTSHIFT;
        write(fd, &evkey, sizeof(evkey));
    }
    if (code & MOD_CTRL)
    {
        evkey.code  = KEY_LEFTCTRL;
        write(fd, &evkey, sizeof(evkey));
    }
    if (code & MOD_ALT)
    {
        evkey.code  = KEY_LEFTALT;
        write(fd, &evkey, sizeof(evkey));
    }
    write(fd, &evsync, sizeof(evsync));
}
static int prevkeycode = -1;
void sendkey(int fd, int mod, int key)
{
    int code = keycode[(mod & MOD_FN) | (key & KEY_ASCII)] | ((mod << 8) & MOD_ALT);

    if (prevkeycode >= 0)
    {
        sendkeycodeup(fd, prevkeycode);
        if (!(key & KEY_PRESS) && ((code & KEY_CODE) != (prevkeycode & KEY_CODE)))
            /*
             * missed a key down event
             * synthesize one
             */
            sendkeycodedown(fd, code);
        (key & KEY_PRESS) ? sendkeycodedown(fd, code) : sendkeycodeup(fd, code);
    }
    else
    {
        if (code != -prevkeycode) /* key may have been released before client call */
        {
            sendkeycodedown(fd, code);
            if (!(key & KEY_PRESS))
                /*
                 * missed a key down event
                 * already synthesized one
                 */
                sendkeycodeup(fd, code);
        }
    }
    prevkeycode = (key & KEY_PRESS) ? code : -KEYCODE_MAX;
}
void sendbttn(int fd, int mod, int bttn)
{
    static int lastbtn = 0;

    if (bttn)
    {
        lastbtn = evkey.code = (mod == 0) ? BTN_LEFT
                                          : (mod & 0x40) ? BTN_RIGHT
                                                         : BTN_MIDDLE;
        evkey.value = 1;
    }
    else
    {
        evkey.code  = lastbtn;
        evkey.value = 0;
    }
    write(fd, &evkey, sizeof(evkey));
    write(fd, &evsync, sizeof(evsync));
}
void sendrelxy(int fd, int x, int y)
{
#if 0
    static int accel[32] = { 0,  1,  4,  8,  9,  10,  11,  12, 13, 14, 15, 16, 17, 18, 19, 20,
        -21, -20, -19, -18, -17, -16, -15, -14, -13, -12, -11, -10, -9, -8, -4, -1};
    x = ((x > 4) || (x < -4)) ? x * 2 : accel[x & 0x1F];
    y = ((y > 4) || (y < -4)) ? y * 2 : accel[y & 0x1F];
#else
    x = ((x > 1) || (x < -1)) ? x * 2 : x;
    y = ((y > 1) || (y < -1)) ? y * 2 : y;
#endif
    evrelx.value = x;
    evrely.value = y;
    write(fd, &evrelx, sizeof(evrelx));
    write(fd, &evrely, sizeof(evrely));
    write(fd, &evsync, sizeof(evsync));
}
/*****************************************************************\
 *                                                                 *
*                    Request queue management                     *
*                                                                 *
\*****************************************************************/
int writeword(int fd, int word, char ack)
{
    char rwchar;

    rwchar = word;  /* send low byte of word */
    write(fd, &rwchar, 1);
    if ((read(fd, &rwchar, 1) == 1) && (rwchar == ack))      /* receive ack */
    {
        rwchar = word >> 8;  /* send high byte of word */
        write(fd, &rwchar, 1);
        if ((read(fd, &rwchar, 1) == 1) && (rwchar == ack))      /* receive ack */
            return TRUE;
    }
    return FALSE;
}
struct a2request *addreq(int a2fd, int clidx, int type, int addr, int count, char *buffer)
{
    char rwchar;
    struct a2request *a2req = a2reqfree;
    if (a2req == NULL)
        a2req = malloc(sizeof(struct a2request));
    else
        a2reqfree = a2reqfree->next;
    a2req->idx    = clidx;
    a2req->type   = type;
    a2req->addr   = addr;
    a2req->count  = count;
    a2req->xfer   = 0;
    a2req->buffer = buffer;
    a2req->next   = NULL;
    if (a2reqlist == NULL)
    {
        /*
         * Initiate request.
         */
        a2reqlist = a2req;
        rwchar    = a2req->type;
        write(a2fd, &rwchar, 1);
    }
    else
    {
        /*
         * Add to end of request list.
         */
        struct a2request *a2reqnext = a2reqlist;
        while (a2reqnext->next != NULL)
            a2reqnext = a2reqnext->next;
        a2reqnext->next = a2req;
    }
    return a2req;
}
void finreq(int a2fd, int status, int result)
{
    char finbuf[2];
    struct a2request *a2req = a2reqlist;
    if (a2req->next)
    {
        /*
         * Initiate next request.
         */
        finbuf[0] = a2req->next->type;
        write(a2fd, finbuf, 1);
    }
    /*
     * Send result to socket.
     */
    if (a2client[a2req->idx].flags & CLIENT_OPEN)
    {
        if (a2req->type == 0x90) /* read bytes */
            write(a2client[a2req->idx].fd, a2req->buffer, a2req->count);
        finbuf[0] = status;
        finbuf[1] = result;
        write(a2client[a2req->idx].fd, finbuf, 2);
    }
    if (a2req->buffer)
    {
        free(a2req->buffer);
        a2req->buffer = NULL;
    }
    /*
     * Update lists.
     */
    a2reqlist   = a2req->next;
    a2req->next = a2reqfree;
    a2reqfree   = a2req;
}
void flushreqs(int a2fd, int clidx, int status, int result)
{
    char finbuf[2];
    struct a2request *a2req = a2reqlist, *a2reqprev = NULL;
    while (a2req)
    {
        if (clidx < 0 || clidx == a2req->idx)
        {
            /*
             * Send result to socket.
             */
            if (a2client[a2req->idx].flags & CLIENT_OPEN)
            {
                if (a2req->type == 0x90) /* read bytes */
                    write(a2client[a2req->idx].fd, a2req->buffer, a2req->count);
                finbuf[0] = status;
                finbuf[1] = result;
                write(a2client[a2req->idx].fd, finbuf, 2);
            }
            if (a2req->buffer)
            {
                free(a2req->buffer);
                a2req->buffer = NULL;
            }
            /*
             * Update lists.
             */
            if (a2req == a2reqlist)
            {
                a2reqlist   = a2req->next;
                a2req->next = a2reqfree;
                a2reqfree   = a2req;
                a2req       = a2reqlist;
            }
            else
            {
                a2reqprev->next = a2req->next;
                a2req->next     = a2reqfree;
                a2reqfree       = a2req;
                a2req           = a2reqprev->next;
            }
        }
        else
        {
            a2reqprev = a2req;
            a2req     = a2req->next;
        }
    }
}
/*****************************************************************\
*                                                                 *
*                           Main entrypoint                       *
*                                                                 *
\*****************************************************************/
void main(int argc, char **argv)
{
    struct uinput_user_dev uidev;
    struct termios oldtio,newtio;
    unsigned char iopkt[16];
    int i, c, rdycnt, vdrvactive;
    int a2fd, kbdfd, moufd, srvfd, maxfd;
    struct sockaddr_in servaddr;
    fd_set readset, openset;
    char *devtty  = deftty;
    char *vdrvdir = "/usr/share/a2pi/"; /* default vdrv image directory */

    /*
     * Parse arguments
     */
    if (argc > 1)
    {
        /*
         * Are we running as a daemon?
         */
        if (strcmp(argv[1], "--daemon") == 0)
        {
            if (daemon(0, 0) != 0)
                die("a2pid: daemon() failure");
            isdaemon = TRUE;
            /*
             * Another argument must be tty device
             */
            if (argc > 2)
                devtty = argv[2];
        }
        else
            /*
             * Must be tty device
             */
            devtty = argv[1];
    }
    /*
     * Add signal handlers.
     */
    if (signal(SIGTERM, sig_bye) == SIG_ERR)
        die("signal");
    if (signal(SIGINT, sig_bye) == SIG_ERR)
        die("signal");
    if (signal(SIGHUP, sig_bye) == SIG_ERR)
        die("signal");
    /*
     * Create keyboard input device
     */
    prlog("a2pid: Create keyboard input device\n");
    kbdfd = open("/dev/uinput", O_WRONLY | O_NONBLOCK);
    if (kbdfd < 0)
        die("error: uinput open");
    if (ioctl(kbdfd, UI_SET_EVBIT, EV_KEY) < 0)
        die("error: uinput ioctl EV_KEY");
    if (ioctl(kbdfd, UI_SET_EVBIT, EV_REP) < 0)
        die("error: uinput ioctl EV_REP");
    for (i = KEY_ESC; i <= KEY_F10; i++)
        if (ioctl(kbdfd, UI_SET_KEYBIT, i) < 0)
            die("error: uinput ioctl SET_KEYBITs");
    for (i = KEY_HOME; i <= KEY_DELETE; i++)
        if (ioctl(kbdfd, UI_SET_KEYBIT, i) < 0)
            die("error: uinput ioctl SET_KEYBITs");
    if (ioctl(kbdfd, UI_SET_EVBIT, EV_SYN) < 0)
        die("error: ioctl EV_SYN");
    bzero(&uidev, sizeof(uidev));
    snprintf(uidev.name, UINPUT_MAX_NAME_SIZE, "Apple2 Pi Keyboard");
    uidev.id.bustype = BUS_RS232;
    uidev.id.vendor  = 0x05ac;      /* apple */
    uidev.id.product = 0x2e;
    uidev.id.version = 1;
    write(kbdfd, &uidev, sizeof(uidev));
    if (ioctl(kbdfd, UI_DEV_CREATE) < 0)
        die("error: ioctl DEV_CREATE");
    /*
     * Set repeat delay values that make sense.
     */
    bzero(&evkey,  sizeof(evkey));
    evkey.type  = EV_REP;
    evkey.code  = REP_DELAY;
    evkey.value = 500;      /* 0.5 sec delay */
    if (write(kbdfd, &evkey, sizeof(evkey)) < 0)
        die("error: REP_DELAY");
    evkey.type  = EV_REP;
    evkey.code  = REP_PERIOD;
    evkey.value = 67;      /* 15 reps/sec */
    if (write(kbdfd, &evkey, sizeof(evkey)) < 0)
        die("error: REP_PERIOD");
    /*
     * Create mouse input device
     */
    prlog("a2pid: Create mouse input device\n");
    moufd = open("/dev/uinput", O_WRONLY | O_NONBLOCK);
    if (moufd < 0)
        die("error: uinput open");
    if (ioctl(moufd, UI_SET_EVBIT, EV_KEY) < 0)
        die("error: uinput ioctl EV_KEY");
    if (ioctl(moufd, UI_SET_KEYBIT, BTN_LEFT) < 0)
        die("error: uinput ioctl BTN_LEFT");
    if (ioctl(moufd, UI_SET_KEYBIT, BTN_RIGHT) < 0)
        die("error: uinput ioctl BTN_RIGHT");
    if (ioctl(moufd, UI_SET_KEYBIT, BTN_MIDDLE) < 0)
        die("error: uinput ioctl BTN_MIDDLE");
    if (ioctl(moufd, UI_SET_EVBIT, EV_REL) < 0)
        die("error: ioctl EV_REL");
    if (ioctl(moufd, UI_SET_RELBIT, REL_X) < 0)
        die("error: ioctl REL_X");
    if (ioctl(moufd, UI_SET_RELBIT, REL_Y) < 0)
        die("error: ioctl REL_Y");
    if (ioctl(moufd, UI_SET_EVBIT, EV_SYN) < 0)
        die("error: ioctl EV_SYN");
    bzero(&uidev, sizeof(uidev));
    snprintf(uidev.name, UINPUT_MAX_NAME_SIZE, "Apple2 Pi Mouse");
    uidev.id.bustype = BUS_RS232;
    uidev.id.vendor  = 0x05ac;      /* apple */
    uidev.id.product = 0x2e;
    uidev.id.version = 1;
    write(moufd, &uidev, sizeof(uidev));
    if (ioctl(moufd, UI_DEV_CREATE) < 0)
        die("error: ioctl DEV_CREATE");
    /*
     * Initialize event structures.
     */
    bzero(&evkey,  sizeof(evkey));
    bzero(&evsync, sizeof(evsync));
    bzero(&evrelx, sizeof(evrelx));
    bzero(&evrely, sizeof(evrely));
    evkey.type  = EV_KEY;
    evrelx.type = EV_REL;
    evrelx.code = REL_X;
    evrely.type = EV_REL;
    evrely.code = REL_Y;
    evsync.type = EV_SYN;
    /*
     * Get vdrv images.
     */
    vdrvactive = vdrvopen(vdrvdir);
#if defined(SETSERCLK) && defined(__ARMEL__)
    /*
     * Initialize ACIA clock for Apple II Pi card
     */
    if (devtty == deftty)
        gpclk(271); /* divisor for ~1.8 MHz => (500/271) MHz */
#endif
    /*
     * Open serial port.
     */
    prlog("a2pid: Open serial port\n");
    a2fd = open(devtty, O_RDWR | O_NOCTTY);
    if (a2fd < 0)
        die("error: serial port open");
    tcflush(a2fd, TCIFLUSH);
    tcgetattr(a2fd, &oldtio); /* save current port settings */
    bzero(&newtio, sizeof(newtio));
    newtio.c_cflag     = BAUDRATE /*| CRTSCTS*/ | CS8 | CLOCAL | CREAD;
    newtio.c_iflag     = IGNPAR;
    newtio.c_oflag     = 0;
    newtio.c_lflag     = 0; /* set input mode (non-canonical, no echo,...) */
    newtio.c_cc[VTIME] = 0; /* inter-character timer unused */
    newtio.c_cc[VMIN]  = 1; /* blocking read until 1 char received */
    cfsetispeed(&newtio, B115200);
    cfsetospeed(&newtio, B115200);
    tcsetattr(a2fd, TCSANOW, &newtio);
    prlog("a2pid: Waiting to connect to Apple II...\n");
    iopkt[0] = 0x80;  /* request re-sync if Apple II already running */
    write(a2fd, iopkt, 1);
    if (read(a2fd, iopkt, 1) == 1)
    {
        if (iopkt[0] == 0x80)   /* receive sync */
        {
            prlog("a2pid: Connected.\n");
            iopkt[0] = 0x81;  /* acknowledge */
            write(a2fd, iopkt, 1);
        }
        else if (iopkt[0] == 0x9F)     /* bad request from Apple II */
        {
            prlog("a2pi: Bad Connect Request.\n");
            tcflush(a2fd, TCIFLUSH);
        }
        else
        {
            prlog("a2pi: Bad Sync ACK\n");
            state = RESET;
        }
    }
    newtio.c_cc[VMIN] = 3; /* blocking read until 3 chars received */
    tcsetattr(a2fd, TCSANOW, &newtio);
    /*
     * Open socket.
     */
    prlog("a2pid: Open server socket\n");
    bzero(&servaddr, sizeof(servaddr));
    servaddr.sin_family      = AF_INET;
    servaddr.sin_port        = htons(6551);
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    srvfd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (srvfd < 0)
        die("error: socket create");
    if (bind(srvfd,(struct sockaddr *)&servaddr, sizeof(servaddr)) < 0)
        die("error: bind socket");
    if (listen(srvfd, MAX_CLIENT - 1) < 0)
        die("error: listen socket");
    /*
     * Come basck here on RESET.
     */
reset:
    state = RUN;
    for (i = 0; i < MAX_CLIENT; i++)
    {
        a2client[i].fd    = 0;
        a2client[i].flags = 0;
    }
    maxfd = 0;
    FD_ZERO(&openset);
    FD_SET(a2fd,  &openset);
    FD_SET(srvfd, &openset);
    /*
     * Event loop
     */
    prlog("a2pid: Enter event loop\n");
    while (state == RUN)
    {
        if (maxfd == 0)
        {
            maxfd = a2fd > srvfd ? a2fd : srvfd;
            for (i = 0; i < MAX_CLIENT; i++)
                maxfd = a2client[i].fd > maxfd ? a2client[i].fd : maxfd;
        }
        memcpy(&readset, &openset, sizeof(openset));
        if ((rdycnt = select(maxfd + 1, &readset, NULL, NULL, NULL)) > 0)
        {
            /*
             * Serial port to Apple II transaction.
             */
            if (FD_ISSET(a2fd, &readset))
            {
                rdycnt--;
                if (read(a2fd, iopkt, 3) == 3)
                {
                    // printf("a2pi: A2 Event [0x%02X] [0x%02X] [0x%02X]\n", iopkt[0], iopkt[1], iopkt[2]);
                    switch (iopkt[0])
                    {
                        case 0x80: /* sync */
                            prlog("a2pid: Re-Connected.\n");
                            iopkt[0] = 0x81;  /* acknowledge */
                            write(a2fd, iopkt, 1);
                            tcflush(a2fd, TCIFLUSH);
                            flushreqs(a2fd, 0, -1, -1);
                            break;
                        case 0x82: /* keyboard event */
                            // printf("Keyboard Event: 0x%02X:%c\n", iopkt[1], iopkt[2] & 0x7F);
                            sendkey(kbdfd, iopkt[1], iopkt[2]);
                            //if (iopkt[2] == 0x9B && iopkt[1] == 0xC0)
                            //state = STOP;
                            break;
                        case 0x84: /* mouse move event */
                            //printf("Mouse XY Event: %d,%d\n", (signed char)iopkt[1], (signed char)iopkt[2]);
                            sendrelxy(moufd, (signed char)iopkt[1], (signed char)iopkt[2]);
                            break;
                        case 0x86: /* mouse button event */
                            // printf("Mouse Button %s Event 0x%02X\n", iopkt[2] ? "[PRESS]" : "[RELEASE]", iopkt[1]);
                            sendbttn(moufd, iopkt[1], iopkt[2]);
                            break;
                        case 0x90: /* acknowledge read bytes request*/
                            if (a2reqlist) /* better have an outstanding request */
                            {
                                //printf("a2pid: read %d of %d bytes from 0x%04X\n", a2reqlist->xfer, a2reqlist->count, a2reqlist->addr);
                                newtio.c_cc[VMIN]  = 1; /* blocking read until 1 char received */
                                tcsetattr(a2fd, TCSANOW, &newtio);
                                c = a2reqlist->count - a2reqlist->xfer > MAX_XFER
                                    ? MAX_XFER
                                    : a2reqlist->count - a2reqlist->xfer;
                                if (writeword(a2fd, a2reqlist->addr + a2reqlist->xfer, 0x91) && writeword(a2fd, c, 0x91))
                                {
                                    for (i = 0; i < c; i++)
                                    {
                                        if (read(a2fd, iopkt, 1) == 1)
                                            a2reqlist->buffer[a2reqlist->xfer++] = iopkt[0];
                                        else
                                        {
                                            state = RESET;
                                            break;
                                        }
                                    }
                                }
                                else
                                    state = RESET;
                                newtio.c_cc[VMIN]  = 3; /* blocking read until 3 chars received */
                                tcsetattr(a2fd, TCSANOW, &newtio);
                            }
                            else
                                state = RESET;
                            break;
                        case 0x92: /* acknowledge write bytes */
                            if (a2reqlist) /* better have an outstanding request */
                            {
                                //printf("a2pid: wrote %d of %d bytes to 0x%04X\n", a2reqlist->xfer, a2reqlist->count, a2reqlist->addr);
                                newtio.c_cc[VMIN]  = 1; /* blocking read until 1 char received */
                                tcsetattr(a2fd, TCSANOW, &newtio);
                                c = a2reqlist->count - a2reqlist->xfer > MAX_XFER
                                    ? MAX_XFER
                                    : a2reqlist->count - a2reqlist->xfer;
                                if (writeword(a2fd, a2reqlist->addr + a2reqlist->xfer, 0x93) && writeword(a2fd, c, 0x93))
                                {
                                    if (write(a2fd, a2reqlist->buffer + a2reqlist->xfer, c) == c)
                                        a2reqlist->xfer += c;
                                    else
                                        state = RESET;
                                }
                                else
                                    state = RESET;
                                newtio.c_cc[VMIN]  = 3; /* blocking read until 3 chars received */
                                tcsetattr(a2fd, TCSANOW, &newtio);
                            }
                            else
                                state = RESET;
                            break;
                        case 0x9A: /* acknowledge call with keyboard flush*/
                            if (prevkeycode >= 0) /* flush keyboard if going away for awhile */
                            {
                                sendkeycodeup(kbdfd, prevkeycode);
                                prevkeycode = -prevkeycode;
                            }
                        case 0x94: /* acknowledge call */
                            if (a2reqlist) /* better have an outstanding request */
                            {
                                //printf("a2pid: call address 0x%04X\n", a2reqlist->addr);
                                newtio.c_cc[VMIN]  = 1; /* blocking read until 1 char received */
                                tcsetattr(a2fd, TCSANOW, &newtio);
                                if (!writeword(a2fd, a2reqlist->addr, iopkt[0] + 1))
                                    state = RESET;
                                newtio.c_cc[VMIN]  = 3; /* blocking read until 3 chars received */
                                tcsetattr(a2fd, TCSANOW, &newtio);
                                a2reqlist->type |= AWAIT_COMPLETE;
                            }
                            else
                                state = RESET;
                            break;
                        case 0x96: /* send input char to Apple II */
                            if (a2reqlist) /* better have an outstanding request */
                            {
                                //printf("a2pid: call address 0x%04X\n", a2reqlist->addr);
                                newtio.c_cc[VMIN]  = 1; /* blocking read until 1 char received */
                                tcsetattr(a2fd, TCSANOW, &newtio);
                                if (!writeword(a2fd, a2reqlist->addr, 0x97))
                                    state = RESET;
                                newtio.c_cc[VMIN]  = 3; /* blocking read until 3 chars received */
                                tcsetattr(a2fd, TCSANOW, &newtio);
                                a2reqlist->type |= AWAIT_COMPLETE;
                            }
                            else
                                state = RESET;
                            break;
                        case 0x98: /* get output char from Apple II */
                            for (i = 0; i < MAX_CLIENT; i++)
                                if (a2client[i].flags & CLIENT_COUT)
                                    write(a2client[i].fd, iopkt, 2);

                            break;
                        case 0x9E: /* request complete ok */
                        case 0x9F: /* request complete error */
                            if (a2reqlist) /* better have an outstanding request */
                            {
                                //printf("a2pid: complete request 0x%02X:0x%02X\n", (unsigned char)iopkt[0], (unsigned char)iopkt[1]);
                                if ((a2reqlist->type == 0x90 || a2reqlist->type == 0x92)
                                    && (a2reqlist->count > a2reqlist->xfer))
                                {
                                    iopkt[0] = a2reqlist->type;
                                    write(a2fd, iopkt, 1);
                                }
                                else
                                {
                                    //printf("a2pid: finish request 0x%02X:0x%02X\n", (unsigned char)iopkt[0], (unsigned char)iopkt[1]);
                                    finreq(a2fd, (unsigned char)iopkt[0], (unsigned char)iopkt[1]);
                                }
                            }
                            else
                                state = RESET;
                            break;
                        case 0xA0: /* virtual drive 1 STATUS call */
                        case 0xA2: /* virtual drive 2 STATUS call */
                            //printf("vdrive: STATUS unit:%d\n", (iopkt[0] >> 1) & 0x01);
                            iopkt[3] = iopkt[0] + 1; /* ack */
                            write(a2fd, &iopkt[3], 1);
                            iopkt[0] = vdrvstat(a2fd, (iopkt[0] >> 1) & 0x01);
                            write(a2fd, iopkt, 1);
                            if (a2reqlist && !(a2reqlist->type & AWAIT_COMPLETE)) /* resend last request */
                            {
                                iopkt[0] = a2reqlist->type;
                                write(a2fd, iopkt, 1);
				//printf("vdrive: status resend request %04X\n", a2reqlist->type);
                            }
                            break;
                        case 0xA4: /* virtual drive 1 READ call */
                        case 0xA6: /* virtual drive 2 READ call */
                            //printf("vdrive: READ unit:%d block:%d\n", (iopkt[0] >> 1) & 0x01, iopkt[1] | (iopkt[2] << 8));
                            iopkt[3] = iopkt[0] + 1; /* ack */
                            write(a2fd, &iopkt[3], 1);
                            iopkt[0] = vdrvread(a2fd, (iopkt[0] >> 1) & 0x01, iopkt[1] | (iopkt[2] << 8));
                            write(a2fd, iopkt, 1);
                            if (a2reqlist && !(a2reqlist->type & AWAIT_COMPLETE)) /* resend last request */
                            {
                                iopkt[0] = a2reqlist->type;
                                write(a2fd, iopkt, 1);
				//printf("vdrive: read resend request %04X\n", a2reqlist->type);
                            }
                            break;
                        case 0xA8: /* virtual drive 1 WRITE call */
                        case 0xAA: /* virtual drive 2 WRITE call */
                            //printf("vdrive: WRITE unit:%d block:%d\n", (iopkt[0] >> 1) & 0x01, iopkt[1] | (iopkt[2] << 8));
                            iopkt[3] = iopkt[0] + 1; /* ack */
                            write(a2fd, &iopkt[3], 1);
                            newtio.c_cc[VMIN] = 1; /* blocking read until command packet received */
                            tcsetattr(a2fd, TCSANOW, &newtio);
                            iopkt[0] = vdrvwrite(a2fd, (iopkt[0] >> 1) & 0x01, iopkt[1] | (iopkt[2] << 8));
                            write(a2fd, iopkt, 1);
                            newtio.c_cc[VMIN]  = 3; /* blocking read until 3 chars received */
                            tcsetattr(a2fd, TCSANOW, &newtio);
                            if (a2reqlist && !(a2reqlist->type & AWAIT_COMPLETE)) /* resend last request */
                            {
                                iopkt[0] = a2reqlist->type;
                                write(a2fd, iopkt, 1);
				//printf("vdrive: write resend request %04X\n", a2reqlist->type);
                            }
                            break;
                        case 0xAC: /* virtual clock TIME call */
                            //printf("vclock: TIME\n");
                            iopkt[0] = 0xAD; /* ack */
                            write(a2fd, iopkt, 1);
                            write(a2fd, prodos_time(), 4);
                            if (a2reqlist && !(a2reqlist->type & AWAIT_COMPLETE)) /* resend last request */
                            {
                                iopkt[0] = a2reqlist->type;
                                write(a2fd, iopkt, 1);
				//printf("vclock: resend request %04X\n", a2reqlist->type);
                            }
                            break;
                        default:
                            prlog("a2pid: Unknown Event\n");
                            tcflush(a2fd, TCIFLUSH);
                            //stop = TRUE;
                    }
                }
                else
                {
                    prlog("a2pid: error read serial port ????\n");
                    state = STOP;
                }
            }
            /*
             * Open client connection.
             */
            if (FD_ISSET(srvfd, &readset))
            {
                rdycnt--;
                int clientfd = accept(srvfd, NULL, NULL);
                if (clientfd >= 0)
                {
                    for (i = 0; i < MAX_CLIENT; i++)
                    {
                        if (a2client[i].flags == 0)
                        {
                            a2client[i].fd    = clientfd;
                            a2client[i].flags = CLIENT_OPEN;
                            FD_SET(a2client[i].fd, &openset);
                            maxfd = a2client[i].fd > maxfd ? a2client[i].fd : maxfd;
                            prlog("a2pi: Client Connect\n");
                            break;
                        }
                    }
                    if (i >= MAX_CLIENT)
                        /*
                         * Out of client structures.
                         */
                        close(clientfd);
                }
                else
                    prlog("a2pid: error accept");
            }
            /*
             * Socket client request.
             */
            for (i = 0; rdycnt > 0 && i < MAX_CLIENT; i++)
            {
                if (a2client[i].flags && FD_ISSET(a2client[i].fd, &readset))
                {
                    int addr, count;
                    char *databuf;
                    rdycnt--;
                    if (read(a2client[i].fd, iopkt, 1) == 1)
                    {
                        // printf("a2pi: Client Request [0x%02X]\n", iopkt[0]);
                        switch (iopkt[0])
                        {
                            case 0x90: /* read bytes */
                                if (read(a2client[i].fd, iopkt, 4) == 4)
                                {
                                    addr  = (unsigned char)iopkt[0] | ((unsigned char)iopkt[1] << 8);
                                    count = (unsigned char)iopkt[2] | ((unsigned char)iopkt[3] << 8);
                                    if (count)
                                    {
                                        databuf = malloc(count);
                                        addreq(a2fd, i, 0x90, addr, count, databuf);
                                    }
                                    else
                                    {
                                        iopkt[0] = 0x9E;
                                        iopkt[1] = 0x00;
                                        write(a2client[i].fd, iopkt, 2);
                                    }
                                }
                                break;
                            case 0x92: /* write bytes */
                                if (read(a2client[i].fd, iopkt, 4) == 4)
                                {
                                    addr  = (unsigned char)iopkt[0] | ((unsigned char)iopkt[1] << 8);
                                    count = (unsigned char)iopkt[2] | ((unsigned char)iopkt[3] << 8);
                                    if (count)
                                    {
                                        databuf = malloc(count);
                                        if (read(a2client[i].fd, databuf, count) == count)
                                            addreq(a2fd, i, 0x92, addr, count, databuf);
                                    }
                                    else
                                    {
                                        iopkt[0] = 0x9E;
                                        iopkt[1] = 0x00;
                                        write(a2client[i].fd, iopkt, 2);
                                    }
                                }
                                break;
                            case 0x94: /* call */
                            case 0x9A: /* call with keyboard flush */
                                if (read(a2client[i].fd, iopkt + 1, 2) == 2)
                                {
                                    addr  = (unsigned char)iopkt[1] | ((unsigned char)iopkt[2] << 8);
                                    addreq(a2fd, i, iopkt[0], addr, 0, NULL);
                                }
                                break;
                            case 0x96: /* send input char to Apple II */
                                if (read(a2client[i].fd, iopkt, 1) == 1)
                                    addreq(a2fd, i, 0x96, iopkt[0], 0, NULL);
                                break;
                            case 0x98: /* get output chars from Apple II */
                                a2client[i].flags |= CLIENT_COUT;
                                break;
                            case 0xC0: /* reconnect vdrvs */
                                vdrvclose();
                                vdrvactive = vdrvopen(vdrvdir);
                                iopkt[0]++; /* ack */
                                write(a2client[i].fd, iopkt, 1);
                                break;
                            case 0xC2: /* disconnect vdrvs */
                                vdrvclose();
                                vdrvactive = 0;
                                iopkt[0]++; /* ack */
                                write(a2client[i].fd, iopkt, 1);
                                break;
                            case 0xFF: /* close */
                                a2client[i].flags = CLIENT_CLOSING;
                                break;
                            default:
                                prlog("a2pid: Unknown Request\n");
                        }
                    }
                    else
                    {
                        /*
                         * Close client socket connection.
                         */
                        FD_CLR(a2client[i].fd, &openset);
                        close(a2client[i].fd);
                        if (a2client[i].fd >= maxfd)
                            maxfd = 0;
                        a2client[i].fd    = 0;
                        a2client[i].flags = 0;
                        flushreqs(a2fd, i, -1, -1);
                    }
                }
            }
        }
    }
    flushreqs(a2fd, -1, -1, -1);
    for (i = 0; i < MAX_CLIENT; i++)
        if (a2client[i].flags)
            close(a2client[i].fd);
    if (state == RESET)
        goto reset;
    vdrvclose();
    shutdown(srvfd, SHUT_RDWR);
    close(srvfd);
    tcsetattr(a2fd, TCSANOW, &oldtio);
    tcflush(a2fd, TCIFLUSH);
    close(a2fd);
    ioctl(moufd, UI_DEV_DESTROY);
    ioctl(kbdfd, UI_DEV_DESTROY);
    close(moufd);
    close(kbdfd);
}