path: root/upload/xmodem.c

//////////////////////////////////////////////////////////////////////////////
//                                                                          //
//                                      _                                   //
//         __  __ _ __ ___    ___    __| |  ___  _ __ ___      ___          //
//         \ \/ /| '_ ` _ \  / _ \  / _` | / _ \| '_ ` _ \    / __|         //
//          >  < | | | | | || (_) || (_| ||  __/| | | | | | _| (__          //
//         /_/\_\|_| |_| |_| \___/  \__,_| \___||_| |_| |_|(_)\___|         //
//                                                                          //
//                                                                          //
//////////////////////////////////////////////////////////////////////////////
//                                                                          //
//          Copyright (c) 2012 by S.F.T. Inc. - All rights reserved         //
//  Use, copying, and distribution of this software are licensed according  //
//    to the GPLv2, LGPLv2, or BSD license, as appropriate (see COPYING)    //
//                                                                          //
//////////////////////////////////////////////////////////////////////////////

// XMODEM adapted for arduino and POSIX systems.  Windows code incomplete

#include "xmodem.h"

// special I/O when linked into 'SFTARDCAL' application
#ifdef SFTARDCAL
int my_read(SERIAL_TYPE iFile, void* pBuf, int cbBuf);
int my_write(SERIAL_TYPE iFile, const void* pBuf, int cbBuf);
void my_flush(SERIAL_TYPE iFile);
#endif  // SFTARDCAL

// internal structure definitions

// Windows requires a different way of specifying structure packing
#ifdef WIN32
#define PACKED
#pragma pack(push, 1)
#else  // POSIX, ARDUINO
#define PACKED __attribute__((__packed__))
#endif  // WIN32 vs THE REST OF THE WORLD

#define _SOH_ 1 /* start of packet - note XMODEM-1K uses '2' */
#define _EOT_ 4
#define _ENQ_ 5
#define _ACK_ 6
#define _NAK_ 21 /* NAK character */
#define _CAN_ 24 /* CAN character CTRL+X */

/** \file xmodem.c
  * \brief main source file for S.F.T. XMODEM library
  *
  * S.F.T. XMODEM library
**/

/** \ingroup xmodem_internal
  * \brief Structure defining an XMODEM CHECKSUM packet
  *
\code
typedef struct _XMODEM_BUF_
{
   char cSOH;                   // ** SOH byte goes here             **
   unsigned char aSEQ, aNotSEQ; // ** 1st byte = seq#, 2nd is ~seq#  **
   char aDataBuf[128];          // ** the actual data itself!        **
   unsigned char bCheckSum;     // ** checksum gets 1 byte           **
} PACKED XMODEM_BUF;
\endcode
  *
**/
typedef struct _XMODEM_BUF_ {
  char cSOH;                    ///< SOH byte goes here
  unsigned char aSEQ, aNotSEQ;  ///< 1st byte = seq#, 2nd is ~seq#
  char aDataBuf[128];           ///< the actual data itself!
  unsigned char bCheckSum;      ///< checksum gets 1 byte
} PACKED XMODEM_BUF;

/** \ingroup xmodem_internal
  * \brief Structure defining an XMODEM CRC packet
  *
\code
typedef struct _XMODEMC_BUF_
{
   char cSOH;                   // ** SOH byte goes here             **
   unsigned char aSEQ, aNotSEQ; // ** 1st byte = seq#, 2nd is ~seq#  **
   char aDataBuf[128];          // ** the actual data itself!        **
   unsigned short wCRC;         // ** CRC gets 2 bytes, high endian  **
} PACKED XMODEMC_BUF;
\endcode
  *
**/
typedef struct _XMODEMC_BUF_ {
  char cSOH;                    ///< SOH byte goes here
  unsigned char aSEQ, aNotSEQ;  ///< 1st byte = seq#, 2nd is ~seq#
  char aDataBuf[128];           ///< the actual data itself!
  unsigned short wCRC;          ///< CRC gets 2 bytes, high endian
} PACKED XMODEMC_BUF;

#ifdef WIN32
// restore default packing
#pragma pack(pop)
#endif  // WIN32

/** \ingroup xmodem_internal
  * \brief Structure that identifies the XMODEM communication state
  *
\code
typedef struct _XMODEM_
{
  SERIAL_TYPE ser;     // identifies the serial connection, data type is
OS-dependent
  FILE_TYPE file;      // identifies the file handle, data type is OS-dependent
  union
  {
    XMODEM_BUF xbuf;   // XMODEM CHECKSUM buffer
    XMODEMC_BUF xcbuf; // XMODEM CRC buffer
  } buf;               // union of both buffers, total length 133 bytes
  unsigned char bCRC;  // non-zero for CRC, zero for checksum
} XMODEM;
\endcode
  *
**/
typedef struct _XMODEM_ {
  SERIAL_TYPE
  ser;  ///< identifies the serial connection, data type is OS-dependent
  FILE_TYPE file;  ///< identifies the file handle, data type is OS-dependent

  union {
    XMODEM_BUF xbuf;    ///< XMODEM CHECKSUM buffer
    XMODEMC_BUF xcbuf;  ///< XMODEM CRC buffer
  } buf;                ///< union of both buffers, total length 133 bytes

  unsigned char bCRC;  ///< non-zero for CRC, zero for checksum

} XMODEM;

#ifdef DEBUG_CODE
static char szERR[32];  // place for error messages, up to 16 characters

const char* XMGetError(void) {
  return szERR;
}
#endif  // DEBUG_CODE

#if defined(STAND_ALONE) && defined(DEBUG_CODE)
void debug_dump_buffer(int iDir, const void* pBuf, int cbBuf) {
  int i1, i2;
  const unsigned char *p1, *p2;

  if (cbBuf <= 0) {
    return;
  }

  p1 = p2 = (const unsigned char*)pBuf;

  for (i1 = 0, i2 = 0; i1 <= cbBuf; i1++, p1++) {
    if (!i1 || i2 >= 16 || i1 == cbBuf) {
      if (i1) {
        while (i2 < 16) {
          fputs("    ", stderr);  // fill up spaces where data would be
          i2++;
        }

        fputs(" : ", stderr);

        while (p2 < p1) {
          if (*p2 >= 32 && *p2 <= 127) {
            fputc(*p2, stderr);
          } else {
            fputc('.', stderr);
          }

          p2++;
        }

        fputc('\n', stderr);
      }

      if (!i1 && iDir > 0) {
        fputs("--> ", stderr);
      } else if (!i1 && iDir < 0) {
        fputs("<-- ", stderr);
      } else {
        fputs("    ", stderr);
      }

      i2 = 0;
      p2 = p1;  // make sure
    }

    if (i1 < cbBuf) {
      if (!i2) {
        fprintf(stderr, "%02x: %02x", i1, *p1);
      } else {
        fprintf(stderr, ", %02x", *p1);
      }

      i2++;
    }
  }

  fputc('\n', stderr);
  fflush(stderr);
}
#endif  // STAND_ALONE, DEBUG_CODE

// char iBinaryTransfer = 0, iDisableRXOVER = 0;

/** \ingroup xmodem_internal
  * \brief Calculate checksum for XMODEM packet
  *
  * \param lpBuf A pointer to the XMODEM data buffer
  * \param cbBuf The length of the XMODEM data buffer (typically 128)
  * \return An unsigned char value to be assigned to the 'checksum' element in
  *the XMODEM packet
  *
**/
unsigned char CalcCheckSum(const char* lpBuf, short cbBuf) {
  short iC, i1;

  iC = 0;

  for (i1 = 0; i1 < cbBuf; i1++) {
    iC += lpBuf[i1];
  }

  return (unsigned char)(iC & 0xff);
}

/** \ingroup xmodem_internal
  * \brief Calculate checksum for XMODEM packet
  *
  * \param sVal An unsigned short integer to be made 'high endian' by flipping
  *bytes (as needed)
  * \return A (possibly) byte-flipped high-endian unsigned short integer
  *
  * This function assumes low-endian for Arduino, and performs a universal
  *operation
  * for 'indeterminate' architectures.
**/
static unsigned short my_htons(unsigned short sVal) {
  union {
    unsigned char aVal[2];
    unsigned short sVal;
  } a, b;

  // tweeked for size and speed.  enjoy.

  b.sVal = sVal;

#ifdef ARDUINO

  a.aVal[0] = b.aVal[1];  // no math involved, pre-optimized code
  a.aVal[1] = b.aVal[0];

#else

  a.aVal[0] = (unsigned char)(sVal >> 8);  // less optimized but universal code
  a.aVal[1] = (unsigned char)(sVal & 0xff);

#endif  // ARDUINO

  return a.sVal;
}

/** \ingroup xmodem_internal
  * \brief Calculate 16-bit CRC for XMODEM packet
  *
  * \param lpBuf A pointer to the XMODEM data buffer
  * \param cbBuf The length of the XMODEM data buffer (typically 128)
  * \return A high-endian 16-bit (unsigned short) value to be assigned to the
  *'CRC' element in the XMODEM packet
  *
  * This method uses the 'long way' which is SMALLER CODE for microcontrollers,
  *but eats up a bit more CPU.
  * Otherwise, you'd have to pre-build the 256 byte table and use "the table
  *lookup" method.
**/
unsigned short CalcCRC(const char* lpBuf, short cbBuf) {
  unsigned short wCRC;
  short i1, i2, iAX;
  char cAL;

  // ** this function returns 2-byte string containing
  // ** the CRC calculation result, as high endian

  wCRC = 0;

  for (i1 = 0; i1 < cbBuf; i1++) {
    cAL = lpBuf[i1];

    iAX = (unsigned short)cAL << 8;

    wCRC = iAX ^ wCRC;

    for (i2 = 0; i2 < 8; i2++) {
      iAX = wCRC;

      if (iAX & 0x8000) {
        wCRC <<= 1;
        wCRC ^= 0x1021;
      } else {
        wCRC <<= 1;
      }
    }
  }

  return my_htons(wCRC);
}

// void WaitASecond()
//{
//#ifdef ARDUINO
//  delay(1000);
//#elif defined(WIN32)
//  Sleep(1000);
//#else //
//  usleep(1000000);
//#endif // ARDUINO
//}

#ifndef ARDUINO
#ifdef WIN32
#define MyMillis GetTickCount
#else   // WIN32

/** \ingroup xmodem_internal
  * \brief Return internal 'milliseconds' value for timing purposes
  *
  * \return A calculated 'milliseconds' value as an unsigned long integer
  *
  * This function returns the 'unsigned long' integer value for elapsed time
  *based
  * on the result of the 'gettimeofday()' API function.  On 32-bit and Windows
  *systems
  * the value might wrap around, so you should be careful with your time
  *comparisons (see the
  * code _I_ wrote for the right way to do it). On 64-bit POSIX systems, this
  *value will
  * always increase.\n
  * NOTE:  Win32 defines this as a macro (see above) for the 'GetTickCount()'
  *api, which
  *        returns a 32-bit value.  POSIX x86 returns 32-bit, x64 returns
  *64-bit.  YMMV.
**/
unsigned long MyMillis(void) {
  struct timeval tv;

  gettimeofday(&tv, NULL);  // 2nd parameter is obsolete anyway

  // NOTE:  this won't roll over the way 'GetTickCount' does in WIN32 so I'll
  // truncate it
  //        down to a 32-bit value to make it happen.  Everything that uses
  //        'MyGetTickCount'
  //        must handle this rollover properly using 'int' and not 'long' (or
  //        cast afterwards)
  return ((unsigned int)((unsigned long)tv.tv_sec * 1000L +
                         (unsigned long)tv.tv_usec / 1000L));
}
#endif  // WIN32
#endif  // ARDUINO

// Function GenerateSEQ (wSeq%) As String
//
//   GenerateSEQ = Chr$(wSeq%) + Chr$(Not (wSeq%) And &HFF)
//
// End Function

/** \ingroup xmodem_internal
  * \brief Generate a sequence number pair, place into XMODEM_BUF
  *
  * \param pBuf A pointer to an XMODEM_BUF structure
  * \param bSeq An unsigned char, typically cast from an unsigned long 'block
  *number'
  *
  * This function generates the sequence pair for the XMODEM packet.  The 'block
  *number'
  * is initially assigned a value of '1', and increases by 1 for each successful
  *packet.
  * That value is 'truncated' to a single byte and assigned as a sequence number
  *for the
  * packet itself.
**/
void GenerateSEQ(XMODEM_BUF* pBuf, unsigned char bSeq) {
  pBuf->aSEQ = bSeq;
  pBuf->aNotSEQ = ~bSeq;
}

/** \ingroup xmodem_internal
  * \brief Generate a sequence number pair, place into XMODEMC_BUF (the CRC
  *version)
  *
  * \param pBuf A pointer to an XMODEM_BUF structure
  * \param bSeq An unsigned char, typically cast from an unsigned long 'block
  *number'
  *
  * This function generates the sequence pair for the XMODEM packet.  The 'block
  *number'
  * is initially assigned a value of '1', and increases by 1 for each successful
  *packet.
  * That value is 'truncated' to a single byte and assigned as a sequence number
  *for the
  * packet itself.
**/
void GenerateSEQC(XMODEMC_BUF* pBuf, unsigned char bSeq) {
  pBuf->aSEQ = bSeq;
  pBuf->aNotSEQ =
      (255 - bSeq);  //~bSeq; these should be the same but for now I do this...
}

/** \ingroup xmodem_internal
  * \brief Get an XMODEM block from the serial device
  *
  * \param ser A 'SERIAL_TYPE' identifier for the serial connection
  * \param pBuf A pointer to the buffer that receives the data
  * \param cbSize The number of bytes/chars to read
  * \return The number of bytes/chars read, 0 if timed out (no data), < 0 on
  *error
  *
  * Call this function to read data from the serial port, specifying the number
  *of
  * bytes to read.  This function times out after no data transferred (silence)
  *for
  * a period of 'SILENCE_TIMEOUT' milliseconds.  This allows spurious data
  *transfers
  * to continue as long as there is LESS THAN 'SILENCE_TIMEOUT' between bytes,
  *and
  * also allows VERY SLOW BAUD RATES (as needed).  However, if the transfer
  *takes longer
  * than '10 times SILENCE_TIMEOUT', the function will return the total number
  *of bytes
  * that were received within that time.\n
  * The default value of 5 seconds, extended to 50 seconds, allows a worst-case
  *baud
  * rate of about 20.  This should not pose a problem.  If it does, edit the
  *code.
**/
short GetXmodemBlock(SERIAL_TYPE ser, char* pBuf, short cbSize) {
  unsigned long ulCur;
  short cb1;
// ** This function obtains a buffer of 'cbSize' bytes,       **
// ** waiting a maximum of 5 seconds (of silence) to get it.  **
// ** It returns the data within 'pBuf', returning the actual **
// ** number of bytes transferred.                            **

#ifdef ARDUINO
  char* p1;
  short i1;

  p1 = pBuf;
  cb1 = 0;

  ulCur = millis();
  ser->setTimeout(SILENCE_TIMEOUT);  // 5 seconds [of silence]

  for (i1 = 0; i1 < cbSize; i1++) {
    if (ser->readBytes(p1, 1) !=
        1)  // 5 seconds of "silence" is what fails this
    {
      break;
    }

    cb1++;
    p1++;

    if ((millis() - ulCur) >
        (unsigned long)(10L * SILENCE_TIMEOUT))  // 10 times SILENCE TIMEOUT for
                                                 // TOTAL TIMEOUT
    {
      break;  // took too long, I'm going now
    }
  }

#elif defined(SFTARDCAL)
#ifndef WIN32
  struct pollfd aFD[2];
#endif  // WIN32
  int i1;
  unsigned long ulStart;

  ulStart = ulCur = MyMillis();

  cb1 = 0;

  do {
#ifndef WIN32
    aFD[0].fd = ser;
    aFD[0].events = POLLIN | POLLERR;
    aFD[0].revents = 0;

    i1 = poll(aFD, 1, 100);
    if (!i1) {
      continue;
    }

    if (i1 < 0) {
      fprintf(stderr, "poll error %d\n", errno);
      return -1;
    }
#endif  // WIN32

#ifdef WIN32
    if (my_pollin(ser) > 0)
#else   // WIN32
    if (aFD[0].revents & POLLIN)
#endif  // WIN32
    {
      i1 = my_read(ser, pBuf + cb1, cbSize - cb1);

      if (i1 > 0) {
        cb1 += i1;
        ulCur = MyMillis();
      }
    } else {
      MySleep(1);
    }
  } while (!QuitFlag() && cb1 < cbSize &&
           (MyMillis() - ulCur) < SILENCE_TIMEOUT &&
           (MyMillis() - ulStart) < (unsigned long)10L * SILENCE_TIMEOUT);

#elif defined(WIN32)

#error no win32 code yet

#else  // POSIX
  unsigned long ulStart;
  char* p1;
  int i1, i2;

  if (fcntl(ser, F_SETFL, O_NONBLOCK) == -1) {
    static int iFailFlag = 0;

    if (!iFailFlag) {
      fprintf(stderr, "Warning:  'fcntl(O_NONBLOCK)' failed, errno = %d\n",
              errno);
      fflush(stderr);
      iFailFlag = 1;
    }
  }

  p1 = pBuf;
  cb1 = 0;

  ulStart = ulCur = MyMillis();

  for (i1 = 0; i1 < cbSize; i1++) {
    while ((i2 = read(ser, p1, 1)) != 1) {
      if (i2 < 0 && errno != EAGAIN) {
        // read error - exit now
        //        return cb1; // how many bytes I actually read
        goto the_end;
      } else {
        usleep(1000);  // 1 msec

        if ((MyMillis() - ulCur) > SILENCE_TIMEOUT ||  // too much silence?
            (MyMillis() - ulStart) >
                10 * SILENCE_TIMEOUT)  // too long for transfer
        {
          //          return cb1; // finished (return how many bytes I actually
          //          read)
          goto the_end;
        }
      }
    }

    // here it succeeds

    cb1++;
    p1++;

    if ((MyMillis() - ulStart) >
        10 * SILENCE_TIMEOUT)  // 10 times SILENCE TIMEOUT for TOTAL TIMEOUT
    {
      break;  // took too long, I'm going now
    }
  }

the_end:

#if defined(STAND_ALONE) && defined(DEBUG_CODE)
  fprintf(stderr, "GetXmodemBlock - request %d, read %d  errno=%d\n", cbSize,
          cb1, errno);
  fflush(stderr);
  //#ifdef DEBUG_CODE
  debug_dump_buffer(-1, pBuf, cb1);
//#endif // DEBUG_CODE
#endif  // STAND_ALONE

#endif  // ARDUINO

  return cb1;  // what I actually read
}

/** \ingroup xmodem_internal
  * \brief Write a single character to the serial device
  *
  * \param ser A 'SERIAL_TYPE' identifier for the serial connection
  * \param bVal The byte to send
  * \return The number of bytes/chars written, or < 0 on error
  *
  * Call this function to write one byte of data to the serial port.  Typically
  * this is used to send things like an ACK or NAK byte.
**/
int WriteXmodemChar(SERIAL_TYPE ser, unsigned char bVal) {
  int iRval;
#ifdef ARDUINO

  iRval = ser->write(bVal);
//  ser->flush(); // force sending it

#elif defined(SFTARDCAL)
  char buf[2];  // use size of '2' to avoid warnings about array size of '1'

  buf[0] = (char)bVal;
  return (short)my_write(ser, buf, 1);

#elif defined(WIN32)

#error no win32 code yet

#else  // POSIX
  char buf[2];  // use size of '2' to avoid warnings about array size of '1'

  if (fcntl(ser, F_SETFL, 0) == -1)  // set blocking mode
  {
    static int iFailFlag = 0;

    if (!iFailFlag) {
      fprintf(stderr, "Warning:  'fcntl(O_NONBLOCK)' failed, errno = %d\n",
              errno);
      iFailFlag = 1;
    }
  }

  buf[0] = bVal;  // in case args are passed by register

  iRval = write(ser, buf, 1);

#if defined(STAND_ALONE) && defined(DEBUG_CODE)
  fprintf(stderr, "WriteXmodemChar - returns %d\n", iRval);
  if (iRval > 0) {
    debug_dump_buffer(1, buf, 1);
  }
#endif  // STAND_ALONE, DEBUG_CODE
#endif  // ARDUINO

  return iRval;
}

/** \ingroup xmodem_internal
  * \brief Send an XMODEM block via the serial device
  *
  * \param ser A 'SERIAL_TYPE' identifier for the serial connection
  * \param pBuf A pointer to the buffer that receives the data
  * \param cbSize The number of bytes/chars to write
  * \return The number of bytes/chars written, < 0 on error
  *
  * Call this function to write data via the serial port, specifying the number
  *of
  * bytes to write.
**/
int WriteXmodemBlock(SERIAL_TYPE ser, const void* pBuf, int cbSize) {
  int iRval;
#ifdef ARDUINO

  iRval = ser->write((const uint8_t*)pBuf, cbSize);
//  ser->flush(); // force sending it before returning

#elif defined(SFTARDCAL)

  return (short)my_write(ser, pBuf, cbSize);

#elif defined(WIN32)

#error no win32 code yet

#else  // POSIX

  if (fcntl(ser, F_SETFL, 0) == -1)  // set blocking mode
  {
    static int iFailFlag = 0;

    if (!iFailFlag) {
      fprintf(stderr, "Warning:  'fcntl(O_NONBLOCK)' failed, errno = %d\n",
              errno);
      fflush(stderr);
      iFailFlag = 1;
    }
  }

  iRval = write(ser, pBuf, cbSize);

#if defined(STAND_ALONE) && defined(DEBUG_CODE)
  fprintf(stderr, "\r\nWriteXmodemBlock - returns %d\n", iRval);
  fflush(stderr);

  if (iRval > 0) {
    debug_dump_buffer(1, pBuf, cbSize);
  }
#endif  // STAND_ALONE, DEBUG_CODE
#endif

  return iRval;
}

/** \ingroup xmodem_internal
  * \brief Read all input from the serial port until there is 1 second of
  *'silence'
  *
  * \param ser A 'SERIAL_TYPE' identifier for the serial connection
  *
  * Call this function to read ALL data from the serial port, until there is a
  *period
  * with no data (i.e. 'silence') for 1 second.  At that point the function will
  *return.\n
  * Some operations require that any bad data be flushed out of the input to
  *prevent
  * synchronization problems.  By using '1 second of silence' it forces
  *re-synchronization
  * to occur in one shot, with the possible exception of VERY noisy lines.  The
  *down side
  * is that it may slow down transfers with a high data rate.
**/
void XModemFlushInput(SERIAL_TYPE ser) {
#ifdef ARDUINO
  unsigned long ulStart;

  ulStart = millis();

  do {
    if (ser->available()) {
      ser->read();         // don't care about the data
      ulStart = millis();  // reset time
    } else {
      delay(1);
    }

  } while ((millis() - ulStart) < 1000);

#elif defined(SFTARDCAL)

  my_flush(ser);

#elif defined(WIN32)

#error no win32 code yet

#else  // POSIX
  unsigned long ulStart;
  int i1;
#ifdef DEBUG_CODE
  unsigned char buf[16];
  int cbBuf;
#else   // DEBUG_CODE
  unsigned char buf[2];
#endif  // DEBUG_CODE

  if (fcntl(ser, F_SETFL, O_NONBLOCK) == -1) {
    static int iFailFlag = 0;

    if (!iFailFlag) {
      fprintf(stderr, "Warning:  'fcntl(O_NONBLOCK)' failed, errno = %d\n",
              errno);
      iFailFlag = 1;
    }
  }

  ulStart = MyMillis();
#ifdef DEBUG_CODE
  cbBuf = 0;
#endif  // DEBUG_CODE
  while ((MyMillis() - ulStart) < 1000) {
#ifdef DEBUG_CODE
    i1 = read(ser, &(buf[cbBuf]), 1);
#else   // DEBUG_CODE
    i1 = read(ser, buf, 1);
#endif  // DEBUG_CODE
    if (i1 == 1) {
#if defined(STAND_ALONE) && defined(DEBUG_CODE)
      cbBuf++;
      if (cbBuf >= sizeof(buf)) {
        debug_dump_buffer(-1, buf, cbBuf);
        cbBuf = 0;
      }
#endif  // STAND_ALONE, DEBUG_CODE
      ulStart = MyMillis();
    } else {
      usleep(1000);
    }
  }

#if defined(STAND_ALONE) && defined(DEBUG_CODE)
  if (cbBuf > 0) {
    debug_dump_buffer(-1, buf, cbBuf);
  }
#endif  // STAND_ALONE, DEBUG_CODE

#endif  // ARDUINO
}

/** \ingroup xmodem_internal
  * \brief Terminate the XMODEM connection
  *
  * \param pX A pointer to the 'XMODEM' object identifying the transfer
  *
  * Call this function prior to ending the XMODEM transfer.  Currently the only
  * thing it does is flush the input.
**/
void XmodemTerminate(XMODEM* pX) {
  XModemFlushInput(pX->ser);

  // TODO:  close files?
}

/** \ingroup xmodem_internal
  * \brief Validate the sequence number of a received XMODEM block
  *
  * \param pX A pointer to an 'XMODEM_BUF'
  * \param bSeq The expected sequence number (block & 255)
  * \return A zero value on success, non-zero otherwise
  *
  * Call this function to validate a packet's sequence number against the block
  *number
**/
short ValidateSEQ(XMODEM_BUF* pX, unsigned char bSeq) {
  return pX->aSEQ != 255 - pX->aNotSEQ ||  // ~(pX->aNotSEQ) ||
         pX->aSEQ != bSeq;                 // returns TRUE if not valid
}

/** \ingroup xmodem_internal
  * \brief Validate the sequence number of a received XMODEM block (CRC version)
  *
  * \param pX A pointer to an 'XMODEMC_BUF'
  * \param bSeq The expected sequence number (block & 255)
  * \return A zero value on success, non-zero otherwise
  *
  * Call this function to validate a packet's sequence number against the block
  *number
**/
short ValidateSEQC(XMODEMC_BUF* pX, unsigned char bSeq) {
  return pX->aSEQ != 255 - pX->aNotSEQ ||  // ~(pX->aNotSEQ) ||
         pX->aSEQ != bSeq;                 // returns TRUE if not valid
}

/** \ingroup xmodem_internal
  * \brief Generic function to receive a file via XMODEM (CRC or Checksum)
  *
  * \param pX A pointer to an 'XMODEM_BUF' with valid bCRC, ser, and file
  *members
  * \return A zero value on success, negative on error, positive on cancel
  *
  * The calling function will need to poll for an SOH from the server using 'C'
  *and 'NAK'
  * characters (as appropriate) until an SOH is received.  That value must be
  *assigned
  * to the 'buf' union (as appropriate), and the bCRC member assigned to
  *non-zero if
  * the server responded to 'C', or zero if it responded to 'NAK'.  With the
  *bCRC,
  * ser, and file members correctly assigned, call THIS function to receive
  *content
  * via XMODEM and write it to 'file'.\n
  * This function will return zero on success, a negative value on error, and a
  *positive
  * value if the transfer was canceled by the server.
**/
int ReceiveXmodem(XMODEM* pX) {
#ifdef WIN32
  DWORD cbWrote;
#endif  // WIN32
  int ecount, ec2;
  long etotal, filesize, block;
  unsigned char cY;  // the char to send in response to a packet
// NOTE:  to allow debugging the CAUSE of an xmodem block's failure, i1, i2, and
// i3
//        are assigned to function return values and reported in error messages.
#ifdef DEBUG_CODE
  short i1, i2, i3;
#define DEBUG_I1 i1 =
#define DEBUG_I2 i2 =
#define DEBUG_I3 i3 =
#else            // DEBUG_CODE
#define DEBUG_I1 /*normally does nothing*/
#define DEBUG_I2 /*normally does nothing*/
#define DEBUG_I3 /*normally does nothing*/
#endif           // DEBUG_CODE

  ecount = 0;
  etotal = 0;
  filesize = 0;
  block = 1;

  // ** already got the first 'SOH' character on entry to this function **

  //   Form2.Show 0      '** modeless show of form2 (CANSEND) **
  //   Form2!Label1.FloodType = 0
  //   Form2.Caption = "* XMODEM(Checksum) BINARY RECEIVE *"
  //   Form2!Label1.Caption = "Errors: 0  Bytes: 0"

  pX->buf.xbuf.cSOH = (char)1;  // assumed already got this, put into buffer

  do {
    if (!pX->bCRC &&
        ((DEBUG_I1 GetXmodemBlock(pX->ser, ((char*)&(pX->buf.xbuf)) + 1,
                                  sizeof(pX->buf.xbuf) - 1)) !=
             sizeof(pX->buf.xbuf) - 1 ||
         (DEBUG_I2 ValidateSEQ(&(pX->buf.xbuf), block & 255)) ||
         (DEBUG_I3 CalcCheckSum(pX->buf.xbuf.aDataBuf,
                                sizeof(pX->buf.xbuf.aDataBuf)) !=
          pX->buf.xbuf.bCheckSum))) {
// did not receive properly
// TODO:  deal with repeated packet, sequence number for previous packet

#ifdef DEBUG_CODE
      sprintf(szERR, "A%ld,%d,%d,%d,%d,%d", block, i1, i2, i3,
              pX->buf.xbuf.aSEQ, pX->buf.xbuf.aNotSEQ);
//#ifdef STAND_ALONE
//      fprintf(stderr, "TEMPORARY (csum):  seq=%x, ~seq=%x  i1=%d, i2=%d,
//      i3=%d\n", pX->buf.xbuf.aSEQ, pX->buf.xbuf.aNotSEQ, i1, i2, i3);
//#endif // STAND_ALONE
#endif  // DEBUG_CODE

      XModemFlushInput(pX->ser);  // necessary to avoid problems

      cY = _NAK_;  // send NAK (to get the checksum version)
      ecount++;    // for this packet
      etotal++;
    } else if (pX->bCRC &&
               ((DEBUG_I1 GetXmodemBlock(pX->ser, ((char*)&(pX->buf.xcbuf)) + 1,
                                         sizeof(pX->buf.xcbuf) - 1)) !=
                    sizeof(pX->buf.xcbuf) - 1 ||
                (DEBUG_I2 ValidateSEQC(&(pX->buf.xcbuf), block & 255)) ||
                (DEBUG_I3 CalcCRC(pX->buf.xcbuf.aDataBuf,
                                  sizeof(pX->buf.xbuf.aDataBuf)) !=
                 pX->buf.xcbuf.wCRC))) {
// did not receive properly
// TODO:  deal with repeated packet, sequence number for previous packet

#ifdef DEBUG_CODE
      sprintf(szERR, "B%ld,%d,%d,%d,%d,%d", block, i1, i2, i3,
              pX->buf.xcbuf.aSEQ, pX->buf.xcbuf.aNotSEQ);
//#ifdef STAND_ALONE
//      fprintf(stderr, "TEMPORARY (CRC):  seq=%x, ~seq=%x  i1=%d, i2=%d,
//      i3=%d\n", pX->buf.xcbuf.aSEQ, pX->buf.xcbuf.aNotSEQ, i1, i2, i3);
//#endif // STAND_ALONE
#endif  // DEBUG_CODE

      XModemFlushInput(pX->ser);  // necessary to avoid problems

      if (block > 1) {
        cY = _NAK_;  // TODO do I need this?
      } else {
        cY =
            'C';  // send 'CRC' NAK (the character 'C') (to get the CRC version)
      }
      ecount++;  // for this packet
      etotal++;
    } else {
#ifdef ARDUINO
      if (pX->file.write((const uint8_t*)&(pX->buf.xbuf.aDataBuf),
                         sizeof(pX->buf.xbuf.aDataBuf)) !=
          sizeof(pX->buf.xbuf.aDataBuf)) {
        return -2;  // write error on output file
      }
#elif defined(WIN32)
      cbWrote = 0;
      if (!WriteFile(pX->file, &(pX->buf.xbuf.aDataBuf),
                     sizeof(pX->buf.xbuf.aDataBuf), &cbWrote, NULL) ||
          cbWrote != sizeof(pX->buf.xbuf.aDataBuf)) {
        XmodemTerminate(pX);
        return -2;  // write error on output file
      }
#else              // ARDUINO
      if (write(pX->file, &(pX->buf.xbuf.aDataBuf),
                sizeof(pX->buf.xbuf.aDataBuf)) !=
          sizeof(pX->buf.xbuf.aDataBuf)) {
        XmodemTerminate(pX);
        return -2;  // write error on output file
      }
#endif             // ARDUINO
      cY = _ACK_;  // send ACK
      block++;
      filesize += sizeof(pX->buf.xbuf.aDataBuf);  // TODO:  need method to avoid
                                                  // extra crap at end of file
      ecount = 0;  // zero out error count for next packet
    }

#if defined(STAND_ALONE) || defined(SFTARDCAL)
    fprintf(stderr,
            "block %ld  %ld bytes  %d errors\r"
#ifndef SFTARDCAL
            "\n"
#endif  // SFTARDCAL
            ,
            block - 1, filesize, ecount);
#endif  // STAND_ALONE

    ec2 = 0;  //  ** error count #2 **

    while (ecount < TOTAL_ERROR_COUNT &&
           ec2 < ACK_ERROR_COUNT)  // ** loop to get SOH or EOT character **
    {
      WriteXmodemChar(pX->ser, cY);  // ** output appropriate command char **

      if (GetXmodemBlock(pX->ser, &(pX->buf.xbuf.cSOH), 1) == 1) {
        if (pX->buf.xbuf.cSOH == _CAN_)  // ** CTRL-X 'CAN' - terminate
        {
          XmodemTerminate(pX);
          return 1;                             // terminated
        } else if (pX->buf.xbuf.cSOH == _EOT_)  // ** EOT - end
        {
          WriteXmodemChar(
              pX->ser,
              _ACK_);  // ** send an ACK (most XMODEM protocols expect THIS)
          //          WriteXmodemChar(pX->ser, _ENQ_); // ** send an ENQ

          return 0;                             // I am done
        } else if (pX->buf.xbuf.cSOH == _SOH_)  // ** SOH - sending next packet
        {
          break;  // leave this loop
        } else {
          // TODO:  deal with repeated packet, i.e. previous sequence number

          XModemFlushInput(pX->ser);  // necessary to avoid problems (since the
                                      // character was unexpected)
          // if I was asking for the next block, and got an unexpected
          // character, do a NAK; otherwise,
          // just repeat what I did last time

          if (cY == _ACK_)  // ACK
          {
            cY = _NAK_;  // NACK
          }

          ec2++;
        }
      } else {
        ecount++;  // increase total error count, and try writing the 'ACK' or
                   // 'NACK' again
      }
    }

    if (ec2 >= ACK_ERROR_COUNT)  // wasn't able to get a packet
    {
      break;
    }

  } while (ecount < TOTAL_ERROR_COUNT);

  XmodemTerminate(pX);
  return 1;  // terminated
}

/** \ingroup xmodem_internal
  * \brief Generic function to send a file via XMODEM (CRC or Checksum)
  *
  * \param pX A pointer to an 'XMODEM_BUF' with valid ser, and file members, and
  *the polled
  * 'NAK' value assigned to the cSOH member (first byte) within the 'buf' union.
  * \return A zero value on success, negative on error, positive on cancel
  *
  * The calling function will need to poll for a 'C' or NAK from the client (as
  *appropriate)
  * and assign that character to the cSOH member in the 'buf' union (either xbuf
  *or xcbuf since
  * the 'cSOH' will always be the first byte).  Then call this function to send
  *content
  * via XMODEM from 'file'.\n
  * It is important to record the NAK character before calling this function
  *since the 'C' or
  * 'NAK' value will be used to determine whether to use CRC or CHECKSUM.\n
  * This function will return zero on success, a negative value on error, and a
  *positive
  * value if the transfer was canceled by the receiver.
**/
int SendXmodem(XMODEM* pX) {
#ifdef WIN32
  DWORD cbRead;
#endif  // WIN32
  int ecount, ec2;
  short i1;
  long etotal, filesize, filepos, block;

  ecount = 0;
  etotal = 0;
  filesize = 0;
  filepos = 0;
  block = 1;

  pX->bCRC =
      0;  // MUST ASSIGN TO ZERO FIRST or XMODEM-CHECKSUM may not work properly

// ** already got first 'NAK' character on entry as pX->buf.xbuf.cSOH  **

#ifdef ARDUINO

  filesize = pX->file.size();

#else  // ARDUINO

#ifdef WIN32
  filesize = (long)SetFilePointer(pX->file, 0, NULL, FILE_END);
#else   // WIN32
  filesize = (long)lseek(pX->file, 0, SEEK_END);
#endif  // WIN32
  if (filesize < 0)  // not allowed
  {
#ifdef STAND_ALONE
    fputs("SendXmodem fail (file size)\n", stderr);
#endif  // STAND_ALONE
    return -1;
  }

#ifdef WIN32
  SetFilePointer(pX->file, 0, NULL, FILE_BEGIN);
#else   // WIN32
  lseek(pX->file, 0, SEEK_SET);  // position at beginning
#endif  // WIN32

#endif  // ARDUINO

  do {
    // ** depending on type of transfer, place the packet
    // ** into pX->buf with all fields appropriately filled.

    if (filepos >= filesize)  // end of transfer
    {
      for (i1 = 0; i1 < 8; i1++) {
        WriteXmodemChar(pX->ser,
                        _EOT_);  // ** send an EOT marking end of transfer

        if (GetXmodemBlock(pX->ser, &(pX->buf.xbuf.cSOH), 1) !=
            1)  // this takes up to 5 seconds
        {
          // nothing returned - try again?
          // break; // for now I loop, uncomment to bail out
        } else if (pX->buf.xbuf.cSOH ==
                       _ENQ_  // an 'ENQ' (apparently some expect this)
                   || pX->buf.xbuf.cSOH == _ACK_   // an 'ACK' (most XMODEM
                                                   // implementations expect
                                                   // this)
                   || pX->buf.xbuf.cSOH == _CAN_)  // CTRL-X = TERMINATE
        {
          // both normal and 'abnormal' termination.
          break;
        }
      }

      XmodemTerminate(pX);

#if defined(STAND_ALONE) && defined(DEBUG_CODE)
      fprintf(stderr, "SendXmodem return %d\n", i1 >= 8 ? 1 : 0);
#endif                         // STAND_ALONE
      return i1 >= 8 ? 1 : 0;  // return 1 if receiver choked on the 'EOT'
                               // marker, else 0 for 'success'
    }

//  TODO:  progress indicator [can be LCD for arduino, blinky lights, ???  and
//  of course stderr for everyone else]
//  If filesize& <> 0 Then Form2!Label1.FloodPercent = 100 * filepos& /
//  filesize&

#if defined(STAND_ALONE) || defined(SFTARDCAL)
    fprintf(stderr,
            "block %ld  %ld of %ld bytes  %d errors\r"
#ifndef SFTARDCAL
            "\n"
#endif  // SFTARDCAL
            ,
            block, filepos, filesize, ecount);
#endif  // STAND_ALONE

    if (pX->buf.xbuf.cSOH != 'C'              // XMODEM CRC
        && pX->buf.xbuf.cSOH != (char)_NAK_)  // NAK
    {
      // increase error count, bail if it's too much

      ec2++;
    }

#ifdef ARDUINO
    pX->file.seek(filepos);  // in case I'm doing a 'retry' and I have to
                             // re-read part of the file
#elif defined(WIN32)
    SetFilePointer(pX->file, filepos, NULL, FILE_BEGIN);
#else  // ARDUINO
    lseek(pX->file, filepos, SEEK_SET);  // same reason as above
#endif  // ARDUINO

    // fortunately, xbuf and xcbuf are the same through the end of 'aDataBuf' so
    // I can read the file NOW using 'xbuf' for both CRC and CHECKSUM versions

    if ((filesize - filepos) >= sizeof(pX->buf.xbuf.aDataBuf)) {
#ifdef ARDUINO
      i1 = pX->file.read(pX->buf.xbuf.aDataBuf, sizeof(pX->buf.xcbuf.aDataBuf));
#elif defined(WIN32)
      cbRead = 0;
      if (!ReadFile(pX->file, pX->buf.xbuf.aDataBuf,
                    sizeof(pX->buf.xbuf.aDataBuf), &cbRead, NULL)) {
        i1 = -1;
      } else {
        i1 = (int)cbRead;
      }
#else   // ARDUINO
      i1 =
          read(pX->file, pX->buf.xbuf.aDataBuf, sizeof(pX->buf.xcbuf.aDataBuf));
#endif  // ARDUINO

      if (i1 != sizeof(pX->buf.xcbuf.aDataBuf)) {
        // TODO:  read error - send a ctrl+x ?
      }
    } else {
      memset(pX->buf.xcbuf.aDataBuf, '\x1a',
             sizeof(pX->buf.xcbuf.aDataBuf));  // fill with ctrl+z which is what
                                               // the spec says
#ifdef ARDUINO
      i1 = pX->file.read(pX->buf.xbuf.aDataBuf, filesize - filepos);
#elif defined(WIN32)
      cbRead = 0;
      if (!ReadFile(pX->file, pX->buf.xbuf.aDataBuf, filesize - filepos,
                    &cbRead, NULL)) {
        i1 = -1;
      } else {
        i1 = (int)cbRead;
      }
#else  // ARDUINO
      i1 = read(pX->file, pX->buf.xbuf.aDataBuf, filesize - filepos);
#endif  // ARDUINO

      if (i1 != (filesize - filepos)) {
        // TODO:  read error - send a ctrl+x ?
      }
    }

    if (pX->buf.xbuf.cSOH ==
            'C' ||  // XMODEM CRC 'NAK' (first time only, typically)
        ((pX->buf.xbuf.cSOH == _ACK_ || pX->buf.xbuf.cSOH == _NAK_) &&
         pX->bCRC))  // identifies ACK/NACK with XMODEM CRC
    {
      pX->bCRC = 1;  // make sure (only matters the first time, really)

      // calculate the CRC, assign to the packet, and then send it

      pX->buf.xcbuf.cSOH = 1;  // must send SOH as 1st char
      pX->buf.xcbuf.wCRC =
          CalcCRC(pX->buf.xcbuf.aDataBuf, sizeof(pX->buf.xcbuf.aDataBuf));

      GenerateSEQC(&(pX->buf.xcbuf), (unsigned char)block);

      // send it

      i1 = WriteXmodemBlock(pX->ser, &(pX->buf.xcbuf), sizeof(pX->buf.xcbuf));
      if (i1 != sizeof(pX->buf.xcbuf))  // write error
      {
        // TODO:  handle write error (send ctrl+X ?)
      }
    } else if (pX->buf.xbuf.cSOH == _NAK_ ||  // 'NAK' (checksum method, may
                                              // also be with CRC method)
               (pX->buf.xbuf.cSOH == _ACK_ &&
                !pX->bCRC))  // identifies ACK with XMODEM CHECKSUM
    {
      pX->bCRC = 0;  // make sure (this ALSO allows me to switch modes on error)

      // calculate the CHECKSUM, assign to the packet, and then send it

      pX->buf.xbuf.cSOH = 1;  // must send SOH as 1st char
      pX->buf.xbuf.bCheckSum =
          CalcCheckSum(pX->buf.xbuf.aDataBuf, sizeof(pX->buf.xbuf.aDataBuf));

      GenerateSEQ(&(pX->buf.xbuf), (unsigned char)block);

      // send it

      i1 = WriteXmodemBlock(pX->ser, &(pX->buf.xbuf), sizeof(pX->buf.xbuf));
      if (i1 != sizeof(pX->buf.xbuf))  // write error
      {
        // TODO:  handle write error (send ctrl+X ?)
      }
    }

    ec2 = 0;

    while (ecount < TOTAL_ERROR_COUNT &&
           ec2 < ACK_ERROR_COUNT)  // loop to get ACK or NACK
    {
      if (GetXmodemBlock(pX->ser, &(pX->buf.xbuf.cSOH), 1) == 1) {
        if (pX->buf.xbuf.cSOH == _CAN_)  // ** CTRL-X - terminate
        {
          XmodemTerminate(pX);

          return 1;                               // terminated
        } else if (pX->buf.xbuf.cSOH == _NAK_ ||  // ** NACK
                   pX->buf.xbuf.cSOH == 'C')      // ** CRC NACK
        {
          break;  // exit inner loop and re-send packet
        } else if (pX->buf.xbuf.cSOH == _ACK_)  // ** ACK - sending next packet
        {
          filepos += sizeof(pX->buf.xbuf.aDataBuf);
          block++;  // increment file position and block count

          break;  // leave inner loop, send NEXT packet
        } else {
          XModemFlushInput(pX->ser);  // for now, do this here too
          ec2++;
        }
      } else {
        ecount++;  // increase total error count, then loop back and re-send
                   // packet
        break;
      }
    }

    if (ec2 >= ACK_ERROR_COUNT) {
      break;  // that's it, I'm done with this
    }

  } while (
      ecount <
      TOTAL_ERROR_COUNT /* * 2 */);  // twice error count allowed for sending

  // TODO: progress indicator
  //   If filesize& <> 0 And filepos& <= filesize& Then
  //      Form2!Label1.FloodPercent = 100 * filepos& / filesize&
  //   Else
  //      Form2!Label1.FloodPercent = 100
  //   End If

  // ** at this point it is important to indicate the errors
  // ** and flush all buffers, and terminate process!

  XmodemTerminate(pX);
#ifdef STAND_ALONE
  fputs("SendXmodem fail (total error count)\n", stderr);
#endif        // STAND_ALONE
  return -2;  // exit on error
}

/** \ingroup xmodem_internal
  * \brief Calling function for ReceiveXmodem
  *
  * \param pX A pointer to an 'XMODEM_BUF' with valid ser, and file members
  * \return A zero value on success, negative on error, positive on cancel
  *
  * This is a generic 'calling function' for ReceiveXmodem that checks for
  * a response to 'C' and 'NAK' characters, and sets up the XMODEM transfer
  * for either CRC or CHECKSUM mode.\n
  * This function will return zero on success, a negative value on error, and a
  *positive
  * value if the transfer was canceled by the receiver.
**/
int XReceiveSub(XMODEM* pX) {
  int i1;

  // start with CRC mode [try 8 times to get CRC]

  pX->bCRC = 1;

  for (i1 = 0; i1 < 8; i1++) {
    WriteXmodemChar(pX->ser, 'C');  // start with NAK for XMODEM CRC

    if (GetXmodemBlock(pX->ser, &(pX->buf.xbuf.cSOH), 1) == 1) {
      if (pX->buf.xbuf.cSOH == _SOH_)  // SOH - packet is on its way
      {
        return ReceiveXmodem(pX);
      } else if (pX->buf.xbuf.cSOH ==
                 _EOT_)  // an EOT [blank file?  allow this?]
      {
        return 0;                             // for now, do this
      } else if (pX->buf.xbuf.cSOH == _CAN_)  // cancel
      {
        return 1;  // canceled
      }
    }
  }

  pX->bCRC = 0;

  // try again, this time using XMODEM CHECKSUM
  for (i1 = 0; i1 < 8; i1++) {
    WriteXmodemChar(pX->ser, _NAK_);  // switch to NAK for XMODEM Checksum

    if (GetXmodemBlock(pX->ser, &(pX->buf.xbuf.cSOH), 1) == 1) {
      if (pX->buf.xbuf.cSOH == _SOH_)  // SOH - packet is on its way
      {
        return ReceiveXmodem(pX);
      } else if (pX->buf.xbuf.cSOH ==
                 _EOT_)  // an EOT [blank file?  allow this?]
      {
        return 0;                             // for now, do this
      } else if (pX->buf.xbuf.cSOH == _CAN_)  // cancel
      {
        return 1;  // canceled
      }
    }
  }

  XmodemTerminate(pX);

  return -3;  // fail
}

/** \ingroup xmodem_internal
  * \brief Calling function for SendXmodem
  *
  * \param pX A pointer to an 'XMODEM_BUF' with valid ser, and file members
  * \return A zero value on success, negative on error, positive on cancel
  *
  * This is a generic 'calling function' for SendXmodem that checks for polls by
  *the
  * receiver, and places the 'NAK' or 'C' character into the 'buf' member of the
  *XMODEM
  * structure so that SendXmodem can use the correct method, either CRC or
  *CHECKSUM mode.\n
  * This function will return zero on success, a negative value on error, and a
  *positive
  * value if the transfer was canceled by the receiver.
**/
int XSendSub(XMODEM* pX) {
  unsigned long ulStart;

// waiting up to 30 seconds for transfer to start.  this is part of the spec?

#ifdef ARDUINO
  ulStart = millis();
#else   // ARDUINO
  ulStart = MyMillis();
#endif  // ARDUINO

  do {
    if (GetXmodemBlock(pX->ser, &(pX->buf.xbuf.cSOH), 1) == 1) {
      if (pX->buf.xbuf.cSOH == 'C' ||  // XMODEM CRC
          pX->buf.xbuf.cSOH == _NAK_)  // NAK - XMODEM CHECKSUM
      {
#if defined(STAND_ALONE) && defined(DEBUG_CODE)
        fprintf(stderr, "Got %d, continuing\n", pX->buf.xbuf.cSOH);
#endif  // STAND_ALONE
        return SendXmodem(pX);
      } else if (pX->buf.xbuf.cSOH == _CAN_)  // cancel
      {
#ifdef STAND_ALONE
        fputs("XSendSub fail (cancel)\n", stderr);
#endif             // STAND_ALONE
        return 1;  // canceled
      }
    }
  }
#ifdef ARDUINO
  while ((short)(millis() - ulStart) < 30000);  // 30 seconds
#else   // ARDUINO
  while ((int)(MyMillis() - ulStart) < 30000);
#endif  // ARDUINO

  XmodemTerminate(pX);

#ifdef STAND_ALONE
  fputs("XSendSub fail (timeout)\n", stderr);
#endif        // STAND_ALONE
  return -3;  // fail
}

// typedef struct _XMODEM_
//{
//  SERIAL_TYPE ser;
//  FILE_TYPE file;
//
//  union
//  {
//    XMODEM_BUF xbuf;
//    XMODEMC_BUF xcbuf;
//  } buf; // 133 bytes
//
//  unsigned char bCRC; // non-zero for CRC, zero for checksum
//
//}  __attribute__((__packed__)) XMODEM;

#ifdef ARDUINO

short XReceive(SDClass* pSD, HardwareSerial* pSer, const char* szFilename) {
  short iRval;
  XMODEM xx;

  memset(&xx, 0, sizeof(xx));

  xx.ser = pSer;

  if (pSD->exists((char*)szFilename)) {
    pSD->remove((char*)szFilename);
  }

  xx.file = pSD->open((char*)szFilename, FILE_WRITE);
  if (!xx.file) {
    return -9;  // can't create file
  }

  iRval = XReceiveSub(&xx);

  xx.file.close();

  if (iRval) {
    WriteXmodemChar(pSer, _CAN_);  // cancel (make sure)

    pSD->remove((char*)szFilename);  // delete file on error
  }

  return iRval;
}

int XSend(SDClass* pSD, HardwareSerial* pSer, const char* szFilename) {
  short iRval;
  XMODEM xx;

  memset(&xx, 0, sizeof(xx));

  xx.ser = pSer;

  xx.file = pSD->open(szFilename, FILE_READ);
  if (!xx.file) {
    return -9;  // can't open file
  }

  iRval = XSendSub(&xx);

  xx.file.close();

  return iRval;
}

#else  // ARDUINO

int XReceive(SERIAL_TYPE hSer, const char* szFilename, int nMode) {
  int iRval;
  XMODEM xx;
#if !defined(ARDUINO) && !defined(WIN32)
  int iFlags;
#endif  // !ARDUINO

#ifdef DEBUG_CODE
  szERR[0] = 0;
#endif  // DEBUG_CODE
  memset(&xx, 0, sizeof(xx));

  xx.ser = hSer;

#ifdef WIN32
  DeleteFile(szFilename);

  nMode = nMode;  // to avoid unused parameter warnings
  // TODO:  translate 'nMode' into file attributes?  for now ignore it
  xx.file = CreateFile(szFilename, GENERIC_READ | GENERIC_WRITE, 0, NULL,
                       CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);

  if (xx.file == INVALID_HANDLE_VALUE)
#else   // WIN32
  unlink(szFilename);            // make sure it does not exist, first
  xx.file = open(szFilename, O_CREAT | O_TRUNC | O_WRONLY, nMode);

  if (xx.file == -1)  // bad file handle on POSIX systems
#endif  // WIN32
  {
#ifdef STAND_ALONE
    fprintf(stderr, "XReceive fail \"%s\"  errno=%d\n", szFilename, errno);
#endif  // STAND_ALONE
    return -9;  // can't create file
  }

#if !defined(ARDUINO) && !defined(WIN32)
  iFlags = fcntl(hSer, F_GETFL);
#endif  // !ARDUINO

  iRval = XReceiveSub(&xx);

#if !defined(ARDUINO) && !defined(WIN32)
  if (iFlags == -1 || fcntl(hSer, F_SETFL, iFlags) == -1) {
    fprintf(stderr,
            "Warning:  'fcntl' call to restore flags failed, errno=%d\n",
            errno);
  }
#endif  // !ARDUINO

#ifdef WIN32
  CloseHandle(xx.file);
#else   // WIN32
  close(xx.file);
#endif  // WIN32

  if (iRval) {
#ifdef WIN32
    DeleteFile(szFilename);
#else   // WIN32
    unlink(szFilename);  // delete file on error
#endif  // WIN32
  }

#if defined(STAND_ALONE) && defined(DEBUG_CODE)
  fprintf(stderr, "XReceive returns %d\n", iRval);
#endif  // STAND_ALONE
  return iRval;
}

int XSend(SERIAL_TYPE hSer, const char* szFilename) {
  int iRval;
  XMODEM xx;
#if !defined(ARDUINO) && !defined(WIN32)
  int iFlags;
#endif  // !ARDUINO

#ifdef DEBUG_CODE
  szERR[0] = 0;
#endif  // DEBUG_CODE
  memset(&xx, 0, sizeof(xx));

  xx.ser = hSer;

#ifdef WIN32
  xx.file =
      CreateFile(szFilename, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL);

  if (xx.file == INVALID_HANDLE_VALUE)
#else   // WIN32
  xx.file = open(szFilename, O_RDONLY, 0);

  if (xx.file == -1)  // bad file handle on POSIX systems
#endif  // WIN32
  {
#ifdef STAND_ALONE
    fprintf(stderr, "XSend fail \"%s\"  errno=%d\n", szFilename, errno);
#endif  // STAND_ALONE
    return -9;  // can't open file
  }

#if !defined(ARDUINO) && !defined(WIN32)
  iFlags = fcntl(hSer, F_GETFL);
#endif  // !ARDUINO

  iRval = XSendSub(&xx);

#if !defined(ARDUINO) && !defined(WIN32)
  if (iFlags == -1 || fcntl(hSer, F_SETFL, iFlags) == -1) {
    fprintf(stderr,
            "Warning:  'fcntl' call to restore flags failed, errno=%d\n",
            errno);
  }
#endif  // !ARDUINO

#ifdef WIN32
  CloseHandle(xx.file);
#else   // WIN32
  close(xx.file);
#endif  // WIN32

#if defined(STAND_ALONE) && defined(DEBUG_CODE)
  fprintf(stderr, "XSend returning %d\n", iRval);
#endif  // STAND_ALONE
  return iRval;
}

#endif  // ARDUINO

#if defined(STAND_ALONE) && !defined(SFTARDCAL)

static const char szSER[] = "/dev/ttyU0";

#include <termios.h>

/** \ingroup xmodem_standalone
  * \brief Terminal configuration (POSIX only)
  *
  * \param iFile The open file handle for the serial connection
  * \param iBaud The baud rate for the connection
  * \param iParity The parity, < 0 for even, > 0 for odd, 0 for none
  * \param iBits The number of bits (5, 6, 7, 8)
  * \param iStop The number of stop bits (1 or 2)
  *
  * This is a sample tty config function to CORRECTLY set up a serial connection
  * to allow XMODEM transfer.  The important details here are the use of the
  * 'termios' structure and utility functions to DISABLE all of the things that
  * would otherwise cause trouble, like CRLF translation, CTRL+C handling, etc.
**/
void ttyconfig(int iFile, int iBaud, int iParity, int iBits, int iStop) {
  int i1;
  struct termios sIOS;

  i1 = fcntl(iFile, F_GETFL);

  i1 |= O_NONBLOCK;  // i1 &= ~O_NONBLOCK); // turn OFF non-blocking?

  fcntl(iFile, F_SETFL, i1);

  if (!tcgetattr(iFile, &sIOS)) {
    cfsetspeed(&sIOS, iBaud);
    sIOS.c_cflag &= ~(CSIZE | PARENB | CS5 | CS6 | CS7 | CS8);
    sIOS.c_cflag |=
        iBits == 5 ? CS5 : iBits == 6 ? CS6 : iBits == 7 ? CS7
                                                         : CS8;  // 8 is default
    if (iStop == 2) {
      sIOS.c_cflag |= CSTOPB;
    } else {
      sIOS.c_cflag &= ~CSTOPB;
    }

    sIOS.c_cflag &=
        ~CRTSCTS;  // hardware flow control _DISABLED_ (so I can do the reset)
    sIOS.c_cflag |= CLOCAL;  // ignore any modem status lines

    if (!iParity) {
      sIOS.c_cflag &= ~(PARENB | PARODD);
    } else if (iParity > 0)  // odd
    {
      sIOS.c_cflag |= (PARENB | PARODD);
    } else  // even (negative)
    {
      sIOS.c_cflag &= PARODD;
      sIOS.c_cflag |= PARENB;
    }

    //    sIOS.c_iflag |= IGNCR; // ignore CR

    // do not translate characters or xon/xoff and ignore break
    sIOS.c_iflag &= ~(IGNBRK | INLCR | IGNCR | ICRNL | IXON | IXOFF | IXANY |
                      IMAXBEL | ISTRIP);  // turn these off

#if defined(__FreeBSD__)
    sIOS.c_oflag &= ~(OPOST | ONLCR | OCRNL | TABDLY | ONOEOT | ONOCR |
                      ONLRET);  // FreeBSD version
#else                           // Linux? YMMV
    sIOS.c_oflag &= ~(OPOST | ONLCR | OCRNL | TABDLY | ONOCR |
                      ONLRET);  // turn these off too (see man termios)
#endif                          // FBSD vs Linux

// make sure echoing is disabled and control chars aren't translated or omitted
#if defined(__FreeBSD__)
    sIOS.c_lflag &= ~(ECHO | ECHOKE | ECHOE | ECHONL | ECHOPRT | ECHOCTL |
                      ICANON | IEXTEN | ISIG | ALTWERASE);
#else                      // Linux? YMMV
    sIOS.c_lflag &= ~(ECHO | ECHOKE | ECHOE | ECHONL | ECHOPRT | ECHOCTL |
                      ICANON | IEXTEN | ISIG);
#endif                     // FBSD vs Linux
    sIOS.c_cc[VMIN] = 0;   // ensures no 'grouping' of input
    sIOS.c_cc[VTIME] = 0;  // immediate return

    if (tcsetattr(iFile, TCSANOW, &sIOS)) {
      fprintf(stderr, "error %d setting attributes\n", errno);
    }
  } else {
    fprintf(stderr, "error %d getting attributes\n", errno);
  }
}

/** \ingroup xmodem_standalone
  * \brief Arduino 'reset' function
  *
  * \param iFile The open file handle for the serial connection
  *
  * The Arduino serial port typically has the DTR/RTS lines configured so that
  * a proper 'pulse' will cause a hardware reset of the device.  This function
  *will
  * send that pulse to the Arduino, and wait for a short time afterwards for the
  * hardware reset to take place.
**/
void reset_arduino(int iFile) {
  unsigned int sFlags;
  unsigned long ulStart;
  int i1;

  // toggle the RTS and DTR high, low, then high - so much easier via
  // POSIX-compatible OS!

  ioctl(iFile, TIOCMGET, &sFlags);

  sFlags &= ~(TIOCM_DTR | TIOCM_RTS);  // the high to low transition discharges
                                       // the capacitor (signal is inverted on
                                       // board)
  if (ioctl(iFile, TIOCMSET, &sFlags) < 0) {
    fprintf(stderr, "WARNING:  ioctl() returns < 0, errno=%d (%xH)\n", errno,
            errno);
  }

  usleep(
      250000);  // avrdude does this for 50 msecs, my change has it at 50msecs

  sFlags |= TIOCM_DTR | TIOCM_RTS;  // leave it in THIS state when I'm done
  if (ioctl(iFile, TIOCMSET, &sFlags) < 0) {
    fprintf(stderr, "WARNING:  ioctl() returns < 0, errno=%d (%xH)\n", errno,
            errno);
  }

  usleep(50000);  // avrdude does this for 50 msecs (no change)

  ulStart = MyMillis();

  // flush whatever is there, (5 seconds)

  while ((MyMillis() - ulStart) < 5000) {
    i1 = read(iFile, &i1, 1);
    if (i1 == 1) {
      ulStart = MyMillis();
    } else {
      usleep(1000);
    }
  }
}

int main(int argc, char* argv[]) {
  int hSer;
  char tbuf[256];
  int i1, iSR = 0;

  if (argc < 3) {
    fputs("Usage:  [prog] [S|R] filename\n", stderr);
    return 1;
  }

  if (argv[1][0] == 'R' || argv[1][1] == 'r') {
    iSR = -1;
  } else if (argv[1][0] == 'S' || argv[1][1] == 's') {
    iSR = 1;
  } else if (argv[1][0] == 'X' || argv[1][1] == 'x') {
    iSR = 0;  // test function
  } else {
    fputs("Usage:  [prog] [S|R] filename     (b)\n", stderr);
    return 1;
  }

  hSer = open(szSER, (O_RDWR | O_NONBLOCK), 0);
  if (hSer == -1) {
    fprintf(stderr, "Unable to open \"%s\" errno=%d\n", szSER, errno);
    return 3;
  }

  fputs("TTYCONFIG\n", stderr);
  ttyconfig(hSer, 9600, 0, 8, 1);

  reset_arduino(hSer);

  fprintf(stderr, "Sleeping for 10 seconds to allow reset\n");

  //  usleep(10000000);
  for (i1 = 0; i1 < 10; i1++) {
    XModemFlushInput(hSer);
  }

  for (i1 = 0; i1 < 3; i1++) {
    sprintf(tbuf, "X%c%s", argv[1][0], argv[2]);

    fprintf(stderr, "writing: \"%s\"\n", tbuf);
    strcat(tbuf, "\r");
    WriteXmodemBlock(hSer, tbuf, strlen(tbuf));

    fputs("flush input\n", stderr);
    XModemFlushInput(hSer);

    // wait for an LF response

    if (iSR > 0) {
      fputs("XSEND\n", stderr);
      if (XSend(hSer, argv[2])) {
        fputs("ERROR\n", stderr);
      } else {
        fputs("SUCCESS!\n", stderr);
        i1 = 0;
        break;
      }
    } else if (iSR < 0) {
      fputs("XRECEIVE\n", stderr);
      if (XReceive(hSer, argv[2], 0664)) {
        fputs("ERROR\n", stderr);
      } else {
        fputs("SUCCESS!\n", stderr);
        i1 = 0;
        break;
      }
    } else {
      // test function
      XModemFlushInput(hSer);  // continue doing this
      break;                   // done (once only)
    }
  }

  fputs("EXIT\n", stderr);
  close(hSer);

  return i1 ? 1 : -1;
}
#endif  // STAND_ALONE