#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "windows.h"

#define BIGREAD 256000
unsigned char readbuff[BIGREAD];

int __cdecl main(int argc,char *argv[]) {

    HANDLE hFile;
    DCB MyDcb;
    char *MyPort = "COM1";
    DWORD NumberActuallyRead;
    DWORD NumberToRead = 0;
    DWORD UseBaud = 19200;
    COMMTIMEOUTS To;
    COMMPROP MyCommProp;
    DWORD numberReadSoFar;
    DWORD TotalCount;
    DWORD j;

    if (argc > 1) {

        sscanf(argv[1],"%d",&NumberToRead);

        if (argc > 2) {

            sscanf(argv[2],"%d",&UseBaud);

            if (argc > 3) {

                MyPort = argv[3];

            }

        }

    }

    printf("Will try to read %d characters.\n",NumberToRead);
    printf("Will try to read a %d baud.\n",UseBaud);
    printf("Using port %s\n",MyPort);

    if ((hFile = CreateFile(
                     MyPort,
                     GENERIC_READ | GENERIC_WRITE,
                     0,
                     NULL,
                     CREATE_ALWAYS,
                     FILE_ATTRIBUTE_NORMAL,
                     NULL
                     )) == ((HANDLE)-1)) {

        printf("Couldn't open the port - last error is: %d\n",GetLastError());
        exit(1);

    }


    printf("We successfully opened the %s port.\n",MyPort);

    To.ReadIntervalTimeout = 0;
    To.ReadTotalTimeoutMultiplier = ((1000+(((UseBaud+9)/10)-1))/((UseBaud+9)/10));
    if (!To.ReadTotalTimeoutMultiplier) {
        To.ReadTotalTimeoutMultiplier = 1;
    }
    printf("Multiplier is: %d\n",To.ReadTotalTimeoutMultiplier);
    To.ReadTotalTimeoutConstant = 5000;
    To.WriteTotalTimeoutMultiplier = 0;
    To.WriteTotalTimeoutConstant = 5000;

    if (!SetCommTimeouts(
            hFile,
            &To
            )) {

        printf("Couldn't set the timeouts - last error: %d\n",GetLastError());
        exit(1);

    }

    //
    // We've successfully opened the file.  Set the state of
    // the comm device.  First we get the old values and
    // adjust to our own.
    //

    if (!GetCommState(
             hFile,
             &MyDcb
             )) {

        printf("Couldn't get the comm state: %d\n",GetLastError());
        exit(1);

    }

    if (!GetCommProperties(
             hFile,
             &MyCommProp
             )) {

        printf("Couldn't get the comm prop: %d\n",GetLastError());
        exit(1);

    }

    //
    // Set the Xoff/xon limit so that it lowers the handshake
    // whenever we have more than 50 chars in our buffer,
    // and raises when we drop below 20.
    //

    MyDcb.XoffLim = MyCommProp.dwCurrentRxQueue - 50;
    MyDcb.XonLim = 20;

    MyDcb.BaudRate = UseBaud;
    MyDcb.ByteSize = 8;
    MyDcb.Parity = NOPARITY;
    MyDcb.StopBits = ONESTOPBIT;

    //
    // Make sure that the only flow control is input dtr.
    //

    MyDcb.fOutxDsrFlow = FALSE;
    MyDcb.fOutxCtsFlow = FALSE;
    MyDcb.fDsrSensitivity = FALSE;
    MyDcb.fOutX = FALSE;
    MyDcb.fInX = FALSE;
    MyDcb.fDtrControl = DTR_CONTROL_HANDSHAKE;
    MyDcb.fRtsControl = RTS_CONTROL_DISABLE;

    if (!SetCommState(
            hFile,
            &MyDcb
            )) {

        printf("Couldn't set the comm state - last error: %d\n",GetLastError());
        exit(1);

    }

    //
    // Read ten chars at a time until we get all the
    // chars or we get some kind of error.
    // We delay 100ms after each read to let the buffer
    // have a chance to fill up some.
    //

    for (
        numberReadSoFar = 0;
        numberReadSoFar < NumberToRead;

        ) {

        if (ReadFile(
                hFile,
                &readbuff[numberReadSoFar],
                10,
                &NumberActuallyRead,
                NULL
                )) {

            //
            // If there was no characters (timed out), then
            // we probably won't see anything.
            //

            if (!NumberActuallyRead) {

                printf("No chars - Timeout! number read so far: %d\n",numberReadSoFar);
                break;

            }
            numberReadSoFar += NumberActuallyRead;
            Sleep(100);

            continue;

        } else {

            //
            // Some kind of read error.
            //

            DWORD LastError;
            LastError = GetLastError();
            printf("Couldn't read the %s device.\n",MyPort);
            printf("Status of failed read is: %d\n",LastError);

            //
            // Get the error word from clear comm error.
            //

            if (!ClearCommError(
                     hFile,
                     &LastError,
                     NULL
                     )) {

                printf("Couldn't call clear comm error: %d\n",GetLastError());
                exit(1);

            } else {

                if (!LastError) {

                    printf("No LastError\n");

                } else {

                    if (LastError & CE_RXOVER) {

                        printf("Error: CE_RXOVER\n");

                    }

                    if (LastError & CE_OVERRUN) {

                        printf("Error: CE_OVERRUN\n");

                    }

                    if (LastError & CE_RXPARITY) {

                        printf("Error: CE_RXPARITY\n");

                    }

                    if (LastError & CE_FRAME) {

                        printf("Error: CE_FRAME\n");

                    }

                    if (LastError & CE_BREAK) {

                        printf("Error: CE_BREAK\n");

                    }
                    if (LastError & ~(CE_RXOVER |
                                   CE_OVERRUN |
                                   CE_RXPARITY |
                                   CE_FRAME |
                                   CE_BREAK)) {

                        printf("Unknown errors: %x\n",LastError);

                    }

                }

            }
            exit(1);

        }

    }

    for (
        TotalCount = 0;
        TotalCount < numberReadSoFar;
        ) {

        for (
            j = 0;
            j <= 9;
            j++
            ) {

            if (readbuff[TotalCount] != j) {

                printf("Bad data starting at: %d\n",TotalCount);
                goto donewithcheck;

            }

            TotalCount++;
            if (TotalCount >= numberReadSoFar) {

                break;

            }

        }

    }

donewithcheck:;

    exit(1);

}