/***************************************************************************
 *   fqterm, a terminal emulator for both BBS and *nix.                    *
 *   Copyright (C) 2008 fqterm development group.                          *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.               *
 ***************************************************************************/

#include <QApplication>
#include <QString>
#include <QFileDialog>
#include <QFileInfo>

#include "fqterm.h"
#include "fqterm_config.h"
#include "fqterm_param.h"
#include "fqterm_path.h"
#include "fqterm_telnet.h"
#include "fqterm_zmodem.h"
#include "fqterm_filedialog.h"

#ifdef FQTERM_ZMODEM_DEBUG
#include <sys/time.h>
#endif

namespace FQTerm {

static const uchar zeros[4] =	 {
  0, 0, 0, 0
};
 
static const char hexChars[] = "0123456789abcdef";
 
static const uchar AckStr[1] =  {
  ACK
};
static const uchar NakStr[1] =  {
  NAK
};
static const uchar CanStr[2] =  {
  CAN, CAN
};
static const uchar eotstr[1] =  {
  EOT
};


/*
 *  Crc calculation stuff
 */

/* crctab calculated by Mark G. Mendel, Network Systems Corporation */
unsigned short crctab[256] =  {
  0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7, 0x8108, 0x9129,
  0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef, 0x1231, 0x0210, 0x3273,
  0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6, 0x9339, 0x8318, 0xb37b, 0xa35a,
  0xd3bd, 0xc39c, 0xf3ff, 0xe3de, 0x2462, 0x3443, 0x0420, 0x1401, 0x64e6,
  0x74c7, 0x44a4, 0x5485, 0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf,
  0xc5ac, 0xd58d, 0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695,
  0x46b4, 0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc,
  0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823, 0xc9cc,
  0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b, 0x5af5, 0x4ad4,
  0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12, 0xdbfd, 0xcbdc, 0xfbbf,
  0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a, 0x6ca6, 0x7c87, 0x4ce4, 0x5cc5,
  0x2c22, 0x3c03, 0x0c60, 0x1c41, 0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a,
  0xbd0b, 0x8d68, 0x9d49, 0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32,
  0x1e51, 0x0e70, 0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59,
  0x8f78, 0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f,
  0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067, 0x83b9,
  0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e, 0x02b1, 0x1290,
  0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256, 0xb5ea, 0xa5cb, 0x95a8,
  0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d, 0x34e2, 0x24c3, 0x14a0, 0x0481,
  0x7466, 0x6447, 0x5424, 0x4405, 0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f,
  0xf77e, 0xc71d, 0xd73c, 0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676,
  0x4615, 0x5634, 0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a,
  0xa9ab, 0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3,
  0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a, 0x4a75,
  0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92, 0xfd2e, 0xed0f,
  0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9, 0x7c26, 0x6c07, 0x5c64,
  0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1, 0xef1f, 0xff3e, 0xcf5d, 0xdf7c,
  0xaf9b, 0xbfba, 0x8fd9, 0x9ff8, 0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93,
  0x3eb2, 0x0ed1, 0x1ef0
};

/*
 * updcrc macro derived from article Copyright (C) 1986 Stephen Satchell.
 *  NOTE: First argument must be in range 0 to 255.
 *        Second argument is referenced twice.
 *
 * Programmers may incorporate any or all code into their programs,
 * giving proper credit within the source. Publication of the
 * source routines is permitted so long as proper credit is given
 * to Stephen Satchell, Satchell Evaluations and Chuck Forsberg,
 * Omen Technology.
 */

#define updcrc(cp, crc) ( crctab[((crc >> 8) & 255)] ^ (crc << 8) ^ cp)

/*
 * Copyright (C) 1986 Gary S. Brown.  You may use this program, or
 * code or tables extracted from it, as desired without restriction.
 */

/* First, the polynomial itself and its table of feedback terms.  The  */
/* polynomial is                                                       */
/* X^32+X^26+X^23+X^22+X^16+X^12+X^11+X^10+X^8+X^7+X^5+X^4+X^2+X^1+X^0 */
/* Note that we take it "backwards" and put the highest-order term in  */
/* the lowest-order bit.  The X^32 term is "implied"; the LSB is the   */
/* X^31 term, etc.  The X^0 term (usually shown as "+1") results in    */
/* the MSB being 1.                                                    */

/* Note that the usual hardware shift register implementation, which   */
/* is what we're using (we're merely optimizing it by doing eight-bit  */
/* chunks at a time) shifts bits into the lowest-order term.  In our   */
/* implementation, that means shifting towards the right.  Why do we   */
/* do it this way?  Because the calculated CRC must be transmitted in  */
/* order from highest-order term to lowest-order term.  UARTs transmit */
/* characters in order from LSB to MSB.  By storing the CRC this way,  */
/* we hand it to the UART in the order low-byte to high-byte; the UART */
/* sends each low-bit to hight-bit; and the result is transmission bit */
/* by bit from highest- to lowest-order term without requiring any bit */
/* shuffling on our part.  Reception works similarly.                  */

/* The feedback terms table consists of 256, 32-bit entries.  Notes:   */
/*                                                                     */
/*     The table can be generated at runtime if desired; code to do so */
/*     is shown later.  It might not be obvious, but the feedback      */
/*     terms simply represent the results of eight shift/xor opera-    */
/*     tions for all combinations of data and CRC register values.     */
/*                                                                     */
/*     The values must be right-shifted by eight bits by the "updcrc"  */
/*     logic; the shift must be unsigned (bring in zeroes).  On some   */
/*     hardware you could probably optimize the shift in assembler by  */
/*     using byte-swap instructions.                                   */

unsigned long cr3tab[] =  {
  /* CRC polynomial 0xedb88320 */
  0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
      0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
      0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
      0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
      0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
      0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
      0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
      0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
      0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
      0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
      0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
      0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
      0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
      0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
      0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
      0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
      0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
      0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
      0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
      0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
      0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
      0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
      0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
      0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
      0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
      0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
      0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
      0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
      0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
      0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
      0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
      0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
      0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
      0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
      0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
      0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
      0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
      0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
      0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
      0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
      0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
      0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
      0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
      };

#define UPDC32(b, c) (cr3tab[((int)c ^ b) & 0xff] ^ ((c >> 8) & 0x00FFFFFF))

#define updcrc(cp, crc) ( crctab[((crc >> 8) & 255)] ^ (crc << 8) ^ cp)



#if 1
StateTable FQTermZmodem::RStartOps[] =  {
  {ZSINIT, &FQTermZmodem::GotSinit, 0, 1, RSinitWait},
      /* SINIT, wait for attn str */
  {ZFILE, &FQTermZmodem::GotFile, 0, 0, RFileName},
      /* FILE, wait for filename */
  {ZRQINIT, &FQTermZmodem::SendRinit, 0, 1, RStart},
      /* sender confused, resend */
  {ZFIN, &FQTermZmodem::GotFin, 1, 0, RFinish},
      /* sender shutting down */
  {ZNAK, &FQTermZmodem::SendRinit, 1, 0, RStart},
      /* RINIT was bad, resend */
  {ZFREECNT, &FQTermZmodem::GotFreecnt, 0, 0, RStart},
      /* sender wants free space */
  {ZCOMMAND, &FQTermZmodem::GotCommand, 0, 0, CommandData},
      /* sender wants command */
  {ZSTDERR, &FQTermZmodem::GotStderr, 0, 0, StderrData},
      /* sender wants to send msg */
  {ZRINIT, &FQTermZmodem::ZmodemTInit, 1, 1, TStart},
  {99, &FQTermZmodem::ZPF, 0, 0, RStart}
  /* anything else is an error */
};

StateTable FQTermZmodem::RSinitWaitOps[] =  {
  /* waiting for data */
  {
    99, &FQTermZmodem::ZPF, 0, 0, RSinitWait
  },
};

StateTable FQTermZmodem::RFileNameOps[] =  {
  /* waiting for file name */
  {
    99, &FQTermZmodem::ZPF, 0, 0, RFileName
  },
};

StateTable FQTermZmodem::RCrcOps[] =  {
  /* waiting for CRC */
  {
    ZCRC, &FQTermZmodem::GotFileCrc, 0, 0, RFile
  }, { /* sender sent it */
    ZNAK, &FQTermZmodem::ResendCrcReq, 0, 0, RCrc
  }, { /* ZCRC was bad, resend */
    ZRQINIT, &FQTermZmodem::SendRinit, 1, 1, RStart
  }, { /* sender confused, restart */
    ZFIN, &FQTermZmodem::GotFin, 1, 1, RFinish
  }, { /* sender signing off */
    99, &FQTermZmodem::ZPF, 0, 0, RCrc
  },
};


StateTable FQTermZmodem::RFileOps[] =  {
  /* waiting for ZDATA */
  {
    ZDATA, &FQTermZmodem::GotData, 0, 0, RData
  }, { /* got it */
    ZNAK, &FQTermZmodem::ResendRpos, 0, 0, RFile
  }, { /* ZRPOS was bad, resend */
    ZEOF, &FQTermZmodem::GotEof, 0, 0, RStart
  }, { /* end of file */
    ZRQINIT, &FQTermZmodem::SendRinit, 1, 1, RStart
  }, { /* sender confused, restart */
    ZFILE, &FQTermZmodem::ResendRpos, 0, 0, RFile
  }, { /* ZRPOS was bad, resend */
    ZFIN, &FQTermZmodem::GotFin, 1, 1, RFinish
  }, { /* sender signing off */
    99, &FQTermZmodem::ZPF, 0, 0, RFile
  },
};

/* waiting for data, but a packet could possibly arrive due
 * to error recovery or something
 */
StateTable FQTermZmodem::RDataOps[] =  {
  {
    ZRQINIT, &FQTermZmodem::SendRinit, 1, 1, RStart
  }, { /* sender confused, restart */
    ZFILE, &FQTermZmodem::GotFile, 0, 1, RFileName
  }, { /* start a new file (??) */
    ZNAK, &FQTermZmodem::ResendRpos, 1, 1, RFile
  }, { /* ZRPOS was bad, resend */
    ZFIN, &FQTermZmodem::GotFin, 1, 1, RFinish
  }, { /* sender signing off */
    ZDATA, &FQTermZmodem::GotData, 0, 1, RData
  }, { /* file data follows */
    ZEOF, &FQTermZmodem::GotEof, 1, 1, RStart
  }, { /* end of file */
    99, &FQTermZmodem::ZPF, 0, 0, RData
  },
};

/* here if we've sent ZFERR or ZABORT.  Waiting for ZFIN */

StateTable FQTermZmodem::RFinishOps[] =  {

  {
    ZRQINIT, &FQTermZmodem::SendRinit, 1, 1, RStart
  } , { /* sender confused, restart */
    ZFILE, &FQTermZmodem::GotFile, 1, 1, RFileName
  }, { /* start a new file */
    ZNAK, &FQTermZmodem::GotFin, 1, 1, RFinish
  }, { /* resend ZFIN */
    ZFIN, &FQTermZmodem::GotFin, 1, 1, RFinish
  }, { /* sender signing off */
    99, &FQTermZmodem::ZPF, 0, 0, RFinish
  },
};


/* sent ZRQINIT, waiting for response */
StateTable FQTermZmodem::TStartOps[] =  {
  {
    ZRINIT, &FQTermZmodem::GotRinit, 1, 1, TStart
  }, {
    ZCHALLENGE, &FQTermZmodem::AnswerChallenge, 1, 0, TStart
  }, {
    ZABORT, &FQTermZmodem::GotAbort, 1, 1, TFinish
  }, {
    ZFERR, &FQTermZmodem::GotAbort, 1, 1, TFinish
  }, {
    ZNAK, &FQTermZmodem::Ignore, 0, 0, TStart
  }, {
    ZCOMMAND, &FQTermZmodem::GotCommand, 0, 0, CommandData
  }, {
    ZSTDERR, &FQTermZmodem::GotStderr, 0, 0, StderrData
  }, {
    99, &FQTermZmodem::ZPF, 0, 0, TStart
  },
};

/* sent ZSINIT, waiting for response */
StateTable FQTermZmodem::TInitOps[] =  {
  {
    ZACK, &FQTermZmodem::RetDone, 1, 0, TInit
  }, {
    ZNAK, &FQTermZmodem::SendZSInit, 1, 0, TInit
  }, {
    ZRINIT, &FQTermZmodem::GotRinit, 1, 1, TInit
  }, { /* redundant, but who cares */
    ZCHALLENGE, &FQTermZmodem::AnswerChallenge, 1, 0, TInit
  }, {
    ZABORT, &FQTermZmodem::GotAbort, 1, 1, TFinish
  }, {
    ZFERR, &FQTermZmodem::GotAbort, 1, 1, TFinish
  }, {
    ZCOMMAND, &FQTermZmodem::GotCommand, 0, 0, CommandData
  }, {
    ZSTDERR, &FQTermZmodem::GotStderr, 0, 0, StderrData
  }, {
    99, &FQTermZmodem::ZPF, 0, 0, TInit
  },
};

/* sent ZFILE, waiting for response */
StateTable FQTermZmodem::FileWaitOps[] =  {
  {
    ZRPOS, &FQTermZmodem::SendFileData, 1, 1, Sending
  }, {
    ZSKIP, &FQTermZmodem::SkipFile, 1, 0, TStart
  }, {
    ZCRC, &FQTermZmodem::SendFileCrc, 1, 0, FileWait
  }, {
    ZNAK, &FQTermZmodem::sendFilename, 1, 0, FileWait
  }, {
    ZRINIT, &FQTermZmodem::sendFilename, 1, 1, FileWait
  }, { /* rcvr confused, retry file */
    ZABORT, &FQTermZmodem::GotAbort, 1, 1, TFinish
  }, {
    ZFERR, &FQTermZmodem::GotAbort, 1, 1, TFinish
  }, {
    ZCHALLENGE, &FQTermZmodem::AnswerChallenge, 1, 0, FileWait
  }, {
    ZCOMMAND, &FQTermZmodem::GotCommand, 0, 0, CommandData
  }, {
    ZSTDERR, &FQTermZmodem::GotStderr, 0, 0, StderrData
  }, {
    ZACK, &FQTermZmodem::SendFileData, 1, 0, Sending
  }, { // receiver always sends ZACK back
    99, &FQTermZmodem::ZPF, 0, 0, FileWait
  },
};

/* sent file CRC, waiting for response */
StateTable FQTermZmodem::CrcWaitOps[] =  {
  {
    ZRPOS, &FQTermZmodem::SendFileData, 1, 0, Sending
  }, {
    ZSKIP, &FQTermZmodem::SkipFile, 1, 0, FileWait
  }, {
    ZNAK, &FQTermZmodem::SendFileCrc, 1, 0, CrcWait
  }, {
    ZRINIT, &FQTermZmodem::sendFilename, 1, 1, FileWait
  }, { /* rcvr confused, retry file */
    ZABORT, &FQTermZmodem::GotAbort, 1, 1, TFinish
  }, {
    ZFERR, &FQTermZmodem::GotAbort, 1, 1, TFinish
  }, {
    ZCRC, &FQTermZmodem::SendFileCrc, 0, 0, CrcWait
  }, {
    ZCHALLENGE, &FQTermZmodem::AnswerChallenge, 0, 0, CrcWait
  }, {
    ZCOMMAND, &FQTermZmodem::GotCommand, 0, 0, CommandData
  }, {
    ZSTDERR, &FQTermZmodem::GotStderr, 0, 0, StderrData
  }, {
    99, &FQTermZmodem::ZPF, 0, 0, CrcWait
  },
};

/* sending data, interruptable */
StateTable FQTermZmodem::SendingOps[] =  {
  {
    ZACK, &FQTermZmodem::GotSendAck, 0, 0, Sending
  }, {
    ZRPOS, &FQTermZmodem::GotSendPos, 1, 1, Sending
  }, {
    ZSKIP, &FQTermZmodem::SkipFile, 1, 1, FileWait
  }, {
    ZNAK, &FQTermZmodem::GotSendNak, 1, 1, Sending
  }, {
    ZRINIT, &FQTermZmodem::sendFilename, 1, 1, FileWait
  },{ /* rcvr confused, retry file */
    ZABORT, &FQTermZmodem::GotAbort, 1, 1, TFinish
  }, {
    ZFERR, &FQTermZmodem::GotAbort, 1, 1, TFinish
  }, {
    99, &FQTermZmodem::ZPF, 0, 0, SendWait
  },
};

/* sent data, need to send EOF */
StateTable FQTermZmodem::SendDoneOps[] =  {
  {
    ZACK, &FQTermZmodem::GotSendDoneAck, 0, 0, SendWait
  }, {
    ZRPOS, &FQTermZmodem::GotSendPos, 1, 1, Sending
  }, {
    ZSKIP, &FQTermZmodem::SkipFile, 1, 1, FileWait
  }, {
    ZNAK, &FQTermZmodem::GotSendNak, 1, 1, Sending
  }, {
    ZRINIT, &FQTermZmodem::sendFilename, 1, 1, FileWait
  }, { /* rcvr confused, retry file */
    ZABORT, &FQTermZmodem::GotAbort, 1, 1, TFinish
  }, {
    ZFERR, &FQTermZmodem::GotAbort, 1, 1, TFinish
  }, {
    99, &FQTermZmodem::ZPF, 0, 0, SendWait
  },
};

/* sending data, waiting for ACK */
StateTable FQTermZmodem::SendWaitOps[] =  {
  {
    ZACK, &FQTermZmodem::GotSendWaitAck, 0, 0, Sending
  }, {
    ZRPOS, &FQTermZmodem::GotSendPos, 0, 0, SendWait
  }, {
    ZSKIP, &FQTermZmodem::SkipFile, 1, 1, FileWait
  }, {
    ZNAK, &FQTermZmodem::GotSendNak, 0, 0, Sending
  }, {
    ZRINIT, &FQTermZmodem::sendFilename, 1, 1, FileWait
  }, { /* rcvr confused, retry file */
    ZABORT, &FQTermZmodem::GotAbort, 1, 1, TFinish
  }, {
    ZFERR, &FQTermZmodem::GotAbort, 1, 1, TFinish
  }, {
    99, &FQTermZmodem::ZPF, 0, 0, SendWait
  },
};

/* sent ZEOF, waiting for new RINIT */
StateTable FQTermZmodem::SendEofOps[] =  {
  {
    ZRINIT, &FQTermZmodem::SkipFile, 1, 0, TFinish
  }, { /* successful completion */
    ZACK, &FQTermZmodem::Ignore, 0, 0, SendEof
  }, { /* probably ACK from last packet */
    ZRPOS, &FQTermZmodem::GotSendPos, 1, 1, SendWait
  }, {
    ZSKIP, &FQTermZmodem::SkipFile, 1, 1, TStart
  }, {
    ZNAK, &FQTermZmodem::ResendEof, 1, 0, SendEof
  }, {
    ZRINIT, &FQTermZmodem::sendFilename, 1, 1, FileWait
  }, { /* rcvr confused, retry file */
    ZABORT, &FQTermZmodem::GotAbort, 1, 1, TFinish
  }, {
    ZFERR, &FQTermZmodem::GotAbort, 1, 1, TFinish
  }, {
    99, &FQTermZmodem::ZPF, 0, 0, SendEof
  },
};

StateTable FQTermZmodem::TFinishOps[] =  {
  {
    ZFIN, &FQTermZmodem::OverAndOut, 1, 1, Done
  }, {
    ZNAK, &FQTermZmodem::ZmodemTFinish, 1, 1, TFinish
  }, {
    ZRINIT, &FQTermZmodem::ZmodemTFinish, 1, 1, TFinish
  }, {
    ZABORT, &FQTermZmodem::GotAbort, 1, 1, TFinish
  }, {
    ZFERR, &FQTermZmodem::GotAbort, 1, 1, TFinish
  }, {
    99, &FQTermZmodem::ZPF, 0, 0, TFinish
  },
};

StateTable FQTermZmodem::CommandDataOps[] =  {
  {
    99, &FQTermZmodem::ZPF, 0, 0, CommandData
  },
};

StateTable FQTermZmodem::CommandWaitOps[] =  {
  {
    99, &FQTermZmodem::ZPF, 0, 0, CommandWait
  },
};

StateTable FQTermZmodem::StderrDataOps[] =  {
  {
    99, &FQTermZmodem::ZPF, 0, 0, StderrData
  },
};

StateTable FQTermZmodem::DoneOps[] =  {
  {
    99, &FQTermZmodem::ZPF, 0, 0, Done
  },
};

StateTable *FQTermZmodem::tables[] =  {
  FQTermZmodem::RStartOps, FQTermZmodem::RSinitWaitOps, FQTermZmodem::RFileNameOps,
  FQTermZmodem::RCrcOps, FQTermZmodem::RFileOps, FQTermZmodem::RDataOps,
  FQTermZmodem::RDataOps,  /* RDataErr is the same as RData */
  FQTermZmodem::RFinishOps,

  FQTermZmodem::TStartOps, FQTermZmodem::TInitOps, FQTermZmodem::FileWaitOps,
  FQTermZmodem::CrcWaitOps, FQTermZmodem::SendingOps, FQTermZmodem::SendWaitOps,
  FQTermZmodem::SendDoneOps, FQTermZmodem::SendEofOps, FQTermZmodem::TFinishOps,

  FQTermZmodem::CommandDataOps, FQTermZmodem::CommandWaitOps,
  FQTermZmodem::StderrDataOps, FQTermZmodem::DoneOps,
};

const char *FQTermZmodem::hdrnames[] =  {
  "ZRQINIT", "ZRINIT", "ZSINIT", "ZACK", "ZFILE", "ZSKIP", "ZNAK", "ZABORT",
  "ZFIN", "ZRPOS", "ZDATA", "ZEOF", "ZFERR", "ZCRC", "ZCHALLENGE", "ZCOMPL",
  "ZCAN", "ZFREECNT", "ZCOMMAND", "ZSTDERR",
};

#endif

FQTermZmodem::FQTermZmodem(FQTermConfig *config, FQTermTelnet *netinterface, int type, int serverEncoding) {

  //now set network interface Telnet

  connectionType = type;

  serverEncodingID = serverEncoding;

  switch (connectionType) {
	case 0:
	case 1:
 	case 2:
	  telnet_ = netinterface;
	  break;
	default:
	  FQ_TRACE("zmodem", 0) << "connection type unknown! Expect segmentation fault!";
	  telnet_ =  netinterface;
	  break;
  }

  config_ = config;

  sending = false;

  transferstate = notransfer;

  zmodemTimer = new QTimer(this);
  FQ_VERIFY(connect(zmodemTimer, SIGNAL(timeout()), this, SLOT(ZmodemTimeout())));

#ifdef FQTERM_ZMODEM_DEBUG
  zmodemlogfile = fopen("zmodem.log", "w+");
  fprintf(zmodemlogfile, "%s", "\n================================\n");
  fclose(zmodemlogfile);
#endif


  //init struct INFO
  info.zrinitflags = CANFDX | CANOVIO | CANBRK | CANFC32;
  info.zsinitflags = 0;
  info.attn = NULL;
  info.bufsize = 0; /* full streaming */
  info.buffer = NULL;

  zerrno = 0;
  lastPullByte = 0;

  ZmodemReset(&info);
  // other init function not complete

}

FQTermZmodem::~FQTermZmodem(){}

int FQTermZmodem::ZmodemTInit(ZModem *info) {
  int err;
  int i;

  info->state = TStart;
  info->Protocol = ZMODEM;
  info->crc32 = 0;
  info->packetCount = 0;
  info->errCount = 0;
  info->escCtrl = info->escHibit = info->atSign = info->escape = 0;
  info->InputState = Idle;
  info->canCount = info->chrCount = 0;
  info->windowCount = 0;
  info->filename = NULL;
  info->bufsize = 0;
  info->interrupt = 0;
  info->waitflag = 0;

  //	if( info->packetsize <= 0 )
  info->packetsize = 8096;
  info->windowsize = 0;
  //we won't be receiving much data, pick a reasonable buffer
  // size (largest packet will do)
  //

  i = info->packetsize *2;

  if (info->buffer != NULL) {
    free(info->buffer);
    info->buffer = NULL;
  }
  //since in the constructor function buffer is malloc

  if (i < 1024) {
    i = 1024;
  }
  info->buffer = (uchar*)malloc(i);

  ZIFlush(info);

//  FQTermConfig *config = new FQTermConfig(getPath(USER_CONFIG) + "fqterm.cfg");
//  QString strPrevSave = config->getItemValue("global", "previous");

//  if (strPrevSave.isEmpty()) {
//	strFileList = QFileDialog::getOpenFileNames(0, "Choose the files",
//											getPath(USER_CONFIG), "All files(*)");
//  } else {
//	strFileList = QFileDialog::getOpenFileNames(0, "Choose the files",
//											strPrevSave, "All files(*)");
//  }
  FQTermFileDialog fileDialog(config_);
  strFileList = fileDialog.getOpenNames("Choose a file to upload", "");
  if (strFileList.count() != 0) {
    QStringList::Iterator itFile = strFileList.begin();
    QFileInfo fi(*itFile);
  }

  this->transferstate = transferstop;

  // optional: send "rz\r" to remote end 
  if (DoInitRZ) {
    if ((err = ZXmitStr((uchar*)"rz\r", 3, info))) {
      return err;
    }
  }

  if ((err = ZXmitHdr(ZRQINIT, ZHEX, zeros, info))) {
    // nudge receiver 
    return err;
  }

  info->timeout = 60;

  zmodemlog("ZmodemTInit[%s]: sent ZRQINIT\n", sname(info));

  return 0;
}


int FQTermZmodem::ZmodemTFile(char *file, char *rfile, uint f0, uint f1, uint f2,
                              uint f3, int filesRem, int bytesRem, ZModem *info) {
  if (file == NULL || (info->file = fopen(file, "rb")) == NULL) {
    return ZmErrCantOpen;
  }

  info->fileEof = 0;
  info->filename = file;
  if (rfile != NULL) {
    info->rfilename = rfile;
  } else {
    info->rfilename = strdup("noname");
  }
  info->filesRem = filesRem;
  info->bytesRem = bytesRem;
  info->fileFlags[3] = f0;
  info->fileFlags[2] = f1;
  info->fileFlags[1] = f2;
  info->fileFlags[0] = f3;
  info->offset = info->lastOffset = 0;
  info->len = info->date = info->fileType = info->mode = 0;
  if (info->filename != NULL) {
    struct stat buf;
    if (stat(info->filename, &buf) == 0) {
      info->len = buf.st_size;
      info->date = buf.st_mtime;
      info->fileType = 0;
      info->mode = (buf.st_mode &0777) | 0100000;
    }
  }

  if (info->Protocol == XMODEM) {
    return YSendData(info);
  }

  if (info->Protocol == YMODEM) {
    return YSendFilename(info);
  }

  info->state = FileWait;
  ZStatus(FileBegin, info->bytesRem, info->rfilename);
  zmodemlog("ZmodemTFile[%s]: send ZFILE(%s)\n", sname(info), info->rfilename);
  return sendFilename(info);
}


int FQTermZmodem::ZmodemTFinish(ZModem *info) {
  int i;
  if (info->Protocol == XMODEM) {
    return ZmDone;
  }

  if (info->Protocol == YMODEM) {
    return YSendFin(info);
  }

  info->state = TFinish;
  if (info->buffer != NULL) {
    free(info->buffer);
    info->buffer = NULL;
  }
  zmodemlog("ZmodemTFinish[%s]: send ZFIN\n", sname(info));
  i = ZXmitHdr(ZFIN, ZHEX, zeros, info);

  return i;
}



int FQTermZmodem::ZmodemAbort(ZModem *info) {
  uchar canistr[] =  {
    CAN, CAN, CAN, CAN, CAN, CAN, CAN, CAN, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0
  };
  info->state = Done;
  ZIFlush(info);
  ZOFlush(info);

  transferstate = transferstop; // transfer complete
  ZmodemReset(info); //Transfer complete, zmodem return to receive state

  zmodemlog("ZmodemAbort[%s]: send CAN\n", sname(info));
  return ZXmitStr(canistr, sizeof(canistr), info);
}


int FQTermZmodem::ZmodemRInit(ZModem *info) {
  info->packetCount = 0;
  info->offset = 0;
  info->errCount = 0;
  info->escCtrl = info->escHibit = info->atSign = info->escape = 0;
  info->InputState = Idle;
  info->canCount = info->chrCount = 0;
  info->filename = NULL;
  info->interrupt = 0;
  info->waitflag = 0;
  info->attn = NULL;
  info->file = NULL;

  if (info->buffer != NULL) {
    free(info->buffer);
    info->buffer = NULL;
  }

  info->buffer = (uchar*)malloc(1024);

  info->state = RStart;
  info->timeoutCount = 0;

  ZIFlush(info);

  /* Don't send ZRINIT right away, there might be a ZRQINIT in
   * the input buffer.  Instead, set timeout to zero and return.
   * This will allow ZmodemRcv() to check the input stream first.
   * If nothing found, a ZRINIT will be sent immediately.
   */
  info->timeout = 0;

  zmodemlog("ZmodemRInit[%s]: flush input, new state = RStart\n", sname(info));

  return 0;
}

int FQTermZmodem::ZmodemRcv(uchar *str, int len, ZModem *info,
                            int &consumed_bytes) {
  uchar c;
  int err;

  zmodemlog("zmodemRcv called");

  info->rcvlen = len;

  while (--info->rcvlen >= 0) {
    c =  *str++;

    if (c == CAN) {
      if (++info->canCount >= 5) {
        ZStatus(RmtCancel, 0, NULL);
        consumed_bytes = len - info->rcvlen - 1;
        return ZmErrCancel;
      }
    } else {
      info->canCount = 0;
    }

    if (info->InputState == Ysend) {
      if ((err = YsendChar(c, info))) {
        consumed_bytes = len - info->rcvlen - 1;
        return err;
      }
    } else if (info->InputState == Yrcv) {
      if ((err = YrcvChar(c, info))) {
        consumed_bytes = len - info->rcvlen - 1;
        return err;
      }
    } else if (c != XON && c != XOFF) {
      /* now look at what we have */
      switch (info->InputState) {
        case Idle:
          if ((err = IdleChar(c, info))) {
            consumed_bytes = len - info->rcvlen - 1;
            return err;
          }
          break;
        case Inhdr:
          if ((err = HdrChar(c, info))) {
            consumed_bytes = len - info->rcvlen - 1;            
            return err;
          }
          break;
        case Indata:
          if ((err = DataChar(c, info))) {
            consumed_bytes = len - info->rcvlen - 1;            
            return err;
          }
          break;
        case Finish:
          if ((err = FinishChar(c, info))) {
            consumed_bytes = len - info->rcvlen - 1;            
            return err;
          }
          break;
        default:
          break;
      }
    }
  }
  
  consumed_bytes = len - info->rcvlen - 1;
  return 0;
}




int FQTermZmodem::ZmodemTimeout( /*ZModem *info*/) {
  /* timed out while waiting for input */

  ++info.timeoutCount;

  zmodemlog("timeout %d [%s]\n", info.timeoutCount, sname(&info));

  switch (info.state) {
    /* receive */
    case RStart:
      /* waiting for INIT frame from other end */
      if (info.timeoutCount > 4) {
        return YmodemRInit(&info);
      }

    case RSinitWait:
    case RFileName:
      if (info.timeout > 0) {
        ZStatus(SndTimeout, info.timeoutCount, NULL);
      }
      if (info.timeoutCount > 4) {
        return ZmErrRcvTo;
      }
      info.state = RStart;
      return SendRinit(&info);

    case RCrc:
    case RFile:
    case RData:
      ZStatus(SndTimeout, info.timeoutCount, NULL);
      if (info.timeoutCount > 2) {
        info.timeoutCount = 0;
        info.state = RStart;
        return SendRinit(&info);
      }
      return info.state == RCrc ? ResendCrcReq(&info): ResendRpos(&info);

    case RFinish:
      ZStatus(SndTimeout, info.timeoutCount, NULL);
      return ZmDone;

    case YRStart:
    case YRDataWait:
    case YRData:
    case YREOF:
      return YrcvTimeout(&info);

      /* transmit */
    case TStart:
      /* waiting for INIT frame from other end */
    case TInit:
      /* sent INIT, waiting for ZACK */
    case FileWait:
      /* sent file header, waiting for ZRPOS */
    case CrcWait:
      /* sent file crc, waiting for ZRPOS */
    case SendWait:
      /* waiting for ZACK */
    case SendEof:
      /* sent EOF, waiting for ZACK */
    case TFinish:
      /* sent ZFIN, waiting for ZFIN */
    case YTStart:
    case YTFile:
    case YTDataWait:
    case YTData:
    case YTEOF:
    case YTFin:
      ZStatus(RcvTimeout, 0, NULL);
      return ZmErrRcvTo;

    case Sending:
      /* sending data subpackets, ready for int */
      return SendMoreFileData(&info);

      /* general */
    case CommandData:
      /* waiting for command data */
    case StderrData:
      /* waiting for stderr data */
      return ZmErrSndTo;
    case CommandWait:
      /* waiting for command to execute */
      return ZmErrCmdTo;
    case Done:
      return ZmDone;
    default:
      return 0;
  }
}



int FQTermZmodem::ZmodemAttention(ZModem *info) {
  /* attention received from remote end */
  if (info->state == Sending) {
    ZOFlush(info);
    info->interrupt = 1;
  }
  return 0;
}

int FQTermZmodem::YmodemTInit(ZModem *info) {
  info->state = YTStart;
  info->Protocol = YMODEM;
  info->errCount = 0;
  info->InputState = Ysend;
  info->canCount = info->chrCount = 0;
  info->windowCount = 0;
  info->filename = NULL;

  if (info->packetsize != 1024) {
    info->packetsize = 128;
  }

  info->buffer = (uchar*)malloc(1024);

  ZIFlush(info);
  ZFlowControl(0, info);

  info->timeout = 60;

  return 0;
}


int FQTermZmodem::XmodemTInit(ZModem *info) {
  (void)YmodemTInit(info);
  info->Protocol = XMODEM;
  return 0;
}


int FQTermZmodem::YmodemRInit(ZModem *info) {
  info->errCount = 0;
  info->InputState = Yrcv;
  info->canCount = info->chrCount = 0;
  info->noiseCount = 0;
  info->filename = NULL;
  info->file = NULL;

  if (info->buffer == NULL) {
    info->buffer = (uchar*)malloc(1024);
  }

  info->state = YRStart;
  info->packetCount = -1;
  info->timeoutCount = 0;
  info->timeout = 10;
  info->offset = 0;

  ZIFlush(info);

  return ZXmitStr((uchar*)"C", 1, info);
}


int FQTermZmodem::XmodemRInit(ZModem *info) {
#if 0
  int err;

  state = Start;
  protocol = prot;
  ymodem = prot == Ymodem || prot == YmodemG;

  if (ymodem) {
    strcpy(xmDefPath, file);
  } else {
    strcpy(xmFilename, file);
  }

  eotCount = errorCount = errorCount2 = 0;

  if (err = XmodemRStart()) {
    return err;
  }

  state = Init;
  packetId = ymodem ? 255 : 0;
  packetCount = 0;

  pktHdrLen = protocol == Xmodem ? 3 : 4;
#endif
  return 0;
}


ulong FQTermZmodem::FileCrc(char *name) {
  ulong crc;
  FILE *ifile = fopen(name, "rb");
  int i;

  if (ifile == NULL)
    /* shouldn't happen, since we did access(2) */ {
    return 0;
  }

  crc = 0xffffffff;

  while ((i = fgetc(ifile)) != EOF) {
    crc = UPDC32(i, crc);
  }

  fclose(ifile);
  return ~crc;
}



const char *FQTermZmodem::sname(ZModem *info) {
  return sname2(info->state);
}

const char *FQTermZmodem::sname2(ZMState state) {
  const char *names[] =  {
    "RStart", "RSinitWait", "RFileName", "RCrc", "RFile", "RData", "RDataErr",
	"RFinish", "TStart", "TInit", "FileWait", "CrcWait", "Sending", "SendWait",
	"SendDone", "SendEof", "TFinish", "CommandData", "CommandWait", "StderrData",
	"Done", "YTStart", "YTFile", "YTDataWait", "YTData", "YTEOF", "YTFin",
	"YRStart", "YRDataWait", "YRData", "YREOF"
  };

  return names[(int)state];

}


int FQTermZmodem::ZXmitChr(uchar c, ZModem *info) {
  // to be completed
  return 0;
}

int FQTermZmodem::ZXmitStr(const uchar *str, int len, ZModem *info) {
  //to be completed
  telnet_->write((const char*)str, (uint)len);
  return 0;
}

void FQTermZmodem::ZIFlush(ZModem *info) {
  //to be completed
}

void FQTermZmodem::ZOFlush(ZModem *info) {
  //to be completed
}

int FQTermZmodem::ZAttn(ZModem *info) {
  //to be completed
  return 0;
}

void FQTermZmodem::ZStatus(int type, int value, const char *status) {
  emit ZmodemState(type, value, status);
  switch (type) {
    case RcvByteCount:
      FQ_TRACE("zmodem", 5) << value << " bytes received.";
      break;
    case SndByteCount:
      FQ_TRACE("zmodem", 5) << value << " bytes sent.";
      break;
    case RcvTimeout:
      /* receiver did not respond, aborting */
      FQ_TRACE("zmodem", 0) << "Zmodem time out!";
      break;
    case SndTimeout:
      /* value is # of consecutive send timeouts */
      FQ_TRACE("zmodem", 0) << "Zmodem time out after trying "
                            << value << " times";
      break;
    case RmtCancel:
      /* remote end has cancelled */
      FQ_TRACE("zmodem", 1) << "Zmodem canceled by remote peer";
      break;
    case ProtocolErr:
      /* protocol error has occurred, val=hdr */
      FQ_TRACE("zmodem", 0) << "Unhandled header " << value
                            << " at state " << status;
      break;
    case RemoteMessage:
      /* message from remote end */
      FQ_TRACE("zmodem", 0) << "Message from remote peer: " << status;
      break;
    case DataErr:
      /* data error, val=error count */
      FQ_TRACE("zmodem", 0) << "Data errors " << value;
      break;
    case FileErr:
      /* error writing file, val=errno */
      FQ_TRACE("zmodem", 0) << "Falied to write file.";
      break;
    case FileBegin:
      /* file transfer begins, str=name */
      FQ_TRACE("zmodem", 0) << "Starting file: " << status;
      break;
    case FileEnd:
      /* file transfer ends, str=name */
      FQ_TRACE("zmodem", 0) << "Finishing file: " << status;
      break;
    case FileSkip:
      /* file being skipped, str=name */
      FQ_TRACE("zmodem", 0) << "Skipping file: " << status;
      break;
  }
}

FILE *FQTermZmodem::ZOpenFile(char *name, ulong crc, ZModem *info) {
  //to be complete
  FILE *rval;
  int apnd = 0;
  QString strText;
  strText = encoding2unicode(name, serverEncodingID);
  QString str = FQTermPref::getInstance()->zmodemDir_ + strText;

  QString zpath = QFileInfo(FQTermPref::getInstance()->zmodemDir_).absoluteFilePath();
  QString path = QFileInfo(str).absoluteFilePath();

  lastDownloadedFilename_ = path;

  if (path.startsWith(zpath)) {
    // Ensure that file is only saved under zmodemDir_.
    // TODO: lazy, should use bbs2unicode
    rval = fopen(str.toLocal8Bit(), apnd ? "ab" : "wb");
  } else {
    rval = NULL;
  }

  if (rval == NULL) {
    perror(name);
  }

  return rval;
}

int FQTermZmodem::ZXmitHdr(int type, int format, const uchar data[4], ZModem *info) {
  if (format == ZBIN && info->crc32) {
    format = ZBIN32;
  }

  switch (format) {
    case ZHEX:
      return ZXmitHdrHex(type, data, info);

    case ZBIN:
      return ZXmitHdrBin(type, data, info);

    case ZBIN32:
      return ZXmitHdrBin32(type, data, info);

    default:
      return 0;
  }
}


int FQTermZmodem::ZXmitHdrHex(int type, const uchar data[4], ZModem *info) {
  uchar buffer[128];
  uchar *ptr = buffer;
  uint crc;
  int i;

  zmodemlog("sending  %s: %2.2x %2.2x %2.2x %2.2x = %lx\n", hdrnames[type],
            data[0], data[1], data[2], data[3], ZDec4(data));

  *ptr++ = ZPAD;
  *ptr++ = ZPAD;
  *ptr++ = ZDLE;
  *ptr++ = ZHEX;

  ptr = putHex(ptr, type);
  crc = updcrc(type, 0);
  for (i = 4; --i >= 0; ++data) {
    ptr = putHex(ptr,  *data);
    crc = updcrc(*data, crc);
  }
  crc = updcrc(0, crc);
  crc = updcrc(0, crc);
  ptr = putHex(ptr, (crc >> 8) &0xff);
  ptr = putHex(ptr, crc &0xff);
  *ptr++ = '\r';
  *ptr++ = '\n';
  if (type != ZACK && type != ZFIN) {
    *ptr++ = XON;
  }

  return ZXmitStr(buffer, ptr - buffer, info);
}


int FQTermZmodem::ZXmitHdrBin(int type, const uchar data[4], ZModem *info) {
  uchar buffer[128];
  uchar *ptr = buffer;
  uint crc;
  int len;

  zmodemlog("sending  %s: %2.2x %2.2x %2.2x %2.2x = %lx\n", hdrnames[type],
            data[0], data[1], data[2], data[3], ZDec4(data));

  *ptr++ = ZPAD;
  *ptr++ = ZDLE;
  *ptr++ = ZBIN;

  ptr = putZdle(ptr, type, info);
  crc = updcrc(type, 0);
  for (len = 4; --len >= 0; ++data) {
    ptr = putZdle(ptr,  *data, info);
    crc = updcrc(*data, crc);
  }
  crc = updcrc(0, crc);
  crc = updcrc(0, crc);
  ptr = putZdle(ptr, (crc >> 8) &0xff, info);
  ptr = putZdle(ptr, crc &0xff, info);

  len = ptr - buffer;
  return ZXmitStr(buffer, len, info);
}

int FQTermZmodem::ZXmitHdrBin32(int type, const uchar data[4], ZModem *info) {
  uchar buffer[128];
  uchar *ptr = buffer;
  ulong crc;
  int len;

  zmodemlog("sending  %s: %2.2x %2.2x %2.2x %2.2x = %lx\n", hdrnames[type],
            data[0], data[1], data[2], data[3], ZDec4(data));

  *ptr++ = ZPAD;
  *ptr++ = ZDLE;
  *ptr++ = ZBIN32;
  ptr = putZdle(ptr, type, info);
  crc = UPDC32(type, 0xffffffffL);
  for (len = 4; --len >= 0; ++data) {
    ptr = putZdle(ptr,  *data, info);
    crc = UPDC32(*data, crc);
  }
  crc = ~crc;
  for (len = 4; --len >= 0; crc >>= 8) {
    ptr = putZdle(ptr, crc &0xff, info);
  }

  len = ptr - buffer;
  return ZXmitStr(buffer, len, info);
}


uchar *FQTermZmodem::putZdle(uchar *ptr, uchar c, ZModem *info) {
  uchar c2 = c &0177;

  if (c == ZDLE || c2 == 020 || c2 == 021 || c2 == 023 || c2 == 0177 || (c2 ==
                                                                         015 && connectionType == 0 /*&& info->atSign*/) ||
#ifdef COMMENT
      c2 == 035 || (c2 == '~' && info->lastCR) ||
#endif /* COMMENT */
      c2 == 035 || (c2 < 040 && info->escCtrl)) {
    *ptr++ = ZDLE;
    if (c == 0177) {
      *ptr = ZRUB0;
    } else if (c == 0377) {
      *ptr = ZRUB1;
    } else {
      *ptr = c ^ 0100;
    }
  } else {
    *ptr = c;
  }

  info->atSign = c2 == '@';
  info->lastCR = c2 == '\r';

  return ++ptr;
}


uchar *FQTermZmodem::ZEnc4(ulong n) {
  static uchar buf[4];
  buf[0] = n &0xff;
  n >>= 8;
  buf[1] = n &0xff;
  n >>= 8;
  buf[2] = n &0xff;
  n >>= 8;
  buf[3] = n &0xff;
  return buf;
}

ulong FQTermZmodem::ZDec4(const uchar buf[4]) {
  return buf[0] | (buf[1] << 8) | (buf[2] << 16) | (buf[3] << 24);
}




int FQTermZmodem::YrcvChar(char c, ZModem *info) {
  int err;

  if (info->canCount >= 2) {
    ZStatus(RmtCancel, 0, NULL);
    return ZmErrCancel;
  }

  switch (info->state) {
    case YREOF:
      if (c == EOT) {
        ZCloseFile(info);
        info->file = NULL;
        ZStatus(FileEnd, 0, info->filename);
        if (info->filename != NULL) {
          free(info->filename);
        }
        if ((err = acceptPacket(info)) != 0) {
          return err;
        }
        info->packetCount = -1;
        info->offset = 0;
        info->state = YRStart;
        return ZXmitStr((uchar*)"C", 1, info);
      }
      /* else, drop through */

    case YRStart:
    case YRDataWait:
      switch (c) {
        case SOH:
        case STX:
          info->pktLen = c == SOH ? (128+4): (1024+4);
          info->state = YRData;
          info->chrCount = 0;
          info->timeout = 1;
          info->noiseCount = 0;
          info->crc = 0;
          break;

        case EOT:
          /* ignore first EOT to protect against false eot */
          info->state = YREOF;
          return rejectPacket(info);

        default:
          if (++info->noiseCount > 135) {
            return ZXmitStr(NakStr, 1, info);
          }
          break;
      }
      break;

    case YRData:
      info->buffer[info->chrCount++] = c;
      if (info->chrCount >= info->pktLen) {
        return ProcessPacket(info);
      }
      break;

    default:
      break;
  }

  return 0;
}

int FQTermZmodem::YrcvTimeout(ZModem *info) {
  switch (info->state) {
    case YRStart:
      if (info->timeoutCount >= 10) {
        (void)ZXmitStr(CanStr, 2, info);
        return ZmErrInitTo;
      }
      return ZXmitStr((uchar*)"C", 1, info);

    case YRDataWait:
    case YREOF:
    case YRData:
      if (info->timeoutCount >= 10) {
        (void)ZXmitStr(CanStr, 2, info);
        return ZmErrRcvTo;
      }
      return ZXmitStr(NakStr, 1, info);
    default:
      return 0;
  }
}


void FQTermZmodem::ZIdleStr(uchar *buffer, int len, ZModem *info) {
  //to be completed
}


int FQTermZmodem::FinishChar(char c, ZModem *info) {
  if (c == 'O') {
    if (++info->chrCount >= 2) {
      return ZmDone;
    }
  } else {
    info->chrCount = 0;
  }
  return 0;
}



int FQTermZmodem::DataChar(uchar c, ZModem *info) {
  if (c == ZDLE) {
    info->escape = 1;
    return 0;
  }

  if (info->escape) {
    info->escape = 0;
    switch (c) {
      case ZCRCE:
      case ZCRCG:
      case ZCRCQ:
      case ZCRCW:
        info->PacketType = c;
        info->crcCount = (info->DataType == ZBIN32) ? 4 : 2;
        if (info->DataType == ZBIN) {
          info->crc = updcrc(c, info->crc);
        } else {
          info->crc = UPDC32(c, info->crc);
        }
        return 0;
      case ZRUB0:
        c = 0177;
        break;
      case ZRUB1:
        c = 0377;
        break;
      default:
        c ^= 0100;
        break;
    }
  }
  if (connectionType == 0) {
    if (lastPullByte == 0x0d && c == 0x00) {
      lastPullByte = 0;
      return 0;
    } else if (lastPullByte == 0xff && c == 0xff) {
      lastPullByte = 0;
      return 0;
    }
  }
  lastPullByte = c;

  switch (info->DataType) {
    /* TODO: are hex data packets ever used? */
    case ZBIN:
      info->crc = updcrc(c, info->crc);
      if (info->crcCount == 0) {
        info->buffer[info->chrCount++] = c;
      } else if (--info->crcCount == 0) {
        return ZDataReceived(info, (info->crc &0xffff) == 0);
      }
      break;


    case ZBIN32:
      info->crc = UPDC32(c, info->crc);
      if (info->crcCount == 0) {
        info->buffer[info->chrCount++] = c;
      } else if (--info->crcCount == 0) {
        return ZDataReceived(info, info->crc == 0xdebb20e3);
      }
      break;
  }
  return 0;
}


int FQTermZmodem::HdrChar(uchar c, ZModem *info) {
  int i;
  int crc = 0;

  if (c == ZDLE) {
    info->escape = 1;
    return 0;
  }

  if (info->escape) {
    info->escape = 0;
    switch (c) {
      case ZRUB0:
        c = 0177;
        break;
      case ZRUB1:
        c = 0377;
        break;
      default:
        c ^= 0100;
        break;
    }
  }

  if (info->chrCount == 0) {
    /* waiting for format */
    switch (c) {
      case ZHEX:
      case ZBIN:
      case ZBIN32:
        info->DataType = c;
        info->chrCount = 1;
        info->crc = (info->DataType != ZBIN32) ? 0 : 0xffffffffL;
        memset(info->hdrData, 0, sizeof(info->hdrData));
        break;
      default:
        info->InputState = Idle;
        info->chrCount = 0;
        return ZXmitHdrHex(ZNAK, zeros, info);
    }
    return 0;
  }


  switch (info->DataType) {
    /* hex header is 14 hex digits, cr, lf.  Optional xon is ignored */
    case ZHEX:
      if (info->chrCount <= 14 && !isxdigit(c)) {
        info->InputState = Idle;
        info->chrCount = 0;
        return ZXmitHdrHex(ZNAK, zeros, info);
      }

      if (info->chrCount <= 14) {
        i = (info->chrCount - 1) / 2;
        info->hdrData[i] = rcvHex(info->hdrData[i], c);
      }

      if (info->chrCount == 16) {
        crc = 0;
        for (i = 0; i < 7; ++i) {
          crc = updcrc(info->hdrData[i], crc);
        }
        info->InputState = Idle;
        info->chrCount = 0;
        if ((crc &0xffff) != 0) {
          return ZXmitHdrHex(ZNAK, zeros, info);
        } else {
          return ZProtocol(info);
        }
      }
      else {
        ++info->chrCount;
      }
      break;


    case ZBIN:
      /* binary header is type, 4 bytes data, 2 bytes CRC */
      info->hdrData[info->chrCount - 1] = c;
      info->crc = updcrc(c, info->crc);
      if (++info->chrCount > 7) {
        info->InputState = Idle;
        info->chrCount = 0;
        if ((crc &0xffff) != 0) {
          return ZXmitHdrHex(ZNAK, zeros, info);
        } else {
          return ZProtocol(info);
        }
      }
      break;


    case ZBIN32:
      /* binary32 header is type, 4 bytes data, 4 bytes CRC */
      info->hdrData[info->chrCount - 1] = c;
      info->crc = UPDC32(c, info->crc);
      if (++info->chrCount > 9) {
        info->InputState = Idle;
        info->chrCount = 0;
        if (info->crc != 0xdebb20e3)
          /* see note below */ {
          return ZXmitHdrHex(ZNAK, zeros, info);
        } else {
          return ZProtocol(info);
        }
      }
      break;
  }
  return 0;
}




int FQTermZmodem::IdleChar(uchar c, ZModem *info) {
  if (info->chrCount == 0) {
    if (c == ZPAD) {
      ++info->chrCount;
    } else if (info->state == Sending && ++info->noiseCount > MaxNoise) {
      info->waitflag = 1;
    } else if (info->state == TStart && (c == 'C' || c == 'G' || c == NAK)) {
      /* switch to ymodem */
      info->state = YTStart;
      info->InputState = Ysend;
      info->Protocol = YMODEM;
      return YsendChar(c, info);
    } else {
      ZIdleStr(&c, 1, info);
    }
  }

  else {
    switch (c) {
      case ZPAD:
        ++info->chrCount;
        break;
      case ZDLE:
        info->InputState = Inhdr;
        info->chrCount = 0;
        break;
      default:
        while (--info->chrCount >= 0) {
          ZIdleStr((uchar*)"*", 1, info);
        }
        info->chrCount = 0;
        break;
    }
  }
  return 0;
}



int FQTermZmodem::YsendChar(char c, ZModem *info) {
  int err;

  if (info->canCount >= 2) {
    ZStatus(RmtCancel, 0, NULL);
    return ZmErrCancel;
  }

  switch (info->state) {
    case YTStart:
      /* wait for 'G', 'C' or NAK */
      switch (c) {
        case 'G':
          /* streaming YModem */
        case 'C':
          /* CRC YModem */
        case NAK:
          /* checksum YModem */
          info->PacketType = c;
          return ZmDone;
        default:
          return 0;
      }

    case YTFile:
      /* sent filename, waiting for ACK or NAK */
      switch (c) {
        case NAK:
          /* resend */
        case 'C':
        case 'G':
          ZStatus(DataErr, ++info->errCount, NULL);
          return YSendFilename(info);
        case ACK:
          info->state = YTDataWait;
        default:
          return 0;
      }

    case YTDataWait:
      /* sent filename, waiting for G,C or NAK */
      switch (c) {
        case NAK:
        case 'C':
        case 'G':
          info->chrCount = 0;
          if (info->PacketType == 'G') {
            /* send it all at once */
            while (info->state == YTData) {
              if ((err = YSendData(info))) {
                return err;
              }
            }
            return 0;
          } else {
            return YSendData(info);
          }
          break;
        default:
          return 0;
      }

    case YTData:
      /* sent data, waiting for ACK or NAK */
      switch (c) {
        case 'C':
        case 'G':
          /* protocol failure, resend filename */
          if (info->Protocol == YMODEM) {
            ZStatus(DataErr, ++info->errCount, NULL);
            info->state = YTFile;
            rewind(info->file);
            return YSendFilename(info);
          }
          /* else XModem, treat it like a NAK */
        case NAK:
          ZStatus(DataErr, ++info->errCount, NULL);
          return YXmitData(info->buffer + info->bufp, info->ylen, info);
        case ACK:
          info->offset += info->ylen;
          info->bufp += info->ylen;
          info->chrCount -= info->ylen;
          ZStatus(SndByteCount, info->offset, NULL);
          return YSendData(info);
        default:
          return 0;
      }

    case YTEOF:
      /* sent EOF, waiting for ACK or NAK */
      switch (c) {
        case NAK:
          return ZXmitStr(eotstr, 1, info);
        case ACK:
          info->state = info->Protocol == YMODEM ? YTStart : Done;
          return ZmDone;
        default:
          return 0;
      }

    case YTFin:
      /* sent Fin, waiting for ACK or NAK */
      switch (c) {
        case NAK:
          return YSendFin(info);
        case ACK:
          return ZmDone;
        default:
          return 0;
      }
    default:
      return 0;
  }
}



int FQTermZmodem::ZProtocol(ZModem *info) {
  StateTable *table;

  zmodemlog("received %s: %2.2x %2.2x %2.2x %2.2x = %lx\n",
            hdrnames[info->hdrData[0]], info->hdrData[1], info->hdrData[2],
            info->hdrData[3], info->hdrData[4], ZDec4(info->hdrData + 1));

  /* Flags are sent in F3 F2 F1 F0 order.  Data is sent in P0 P1 P2 P3 */

  info->timeoutCount = 0;
  info->noiseCount = 0;

  //	zmodemTimer->start(info->timeout*1000);

  table = tables[(int)info->state];
  while (table->type != 99 && table->type != info->hdrData[0]) {
    ++table;
  }

  zmodemlog("  state %s => %s, iflush=%d, oflush=%d, call %x\n", sname(info),
            sname2(table->newstate), table->IFlush, table->OFlush, table->func);

  info->state = table->newstate;

  if (table->IFlush) {
    info->rcvlen = 0;
    ZIFlush(info);
  }
  if (table->OFlush) {
    ZOFlush(info);
  }
  return (this->*(table->func))(info);
}


int FQTermZmodem::ZDataReceived(ZModem *info, int crcGood) {
  switch (info->state) {
    case RSinitWait:
      return GotSinitData(info, crcGood);
    case RFileName:
      return GotFileName(info, crcGood);
    case RData:
      return GotFileData(info, crcGood);
    case CommandData:
      return GotCommandData(info, crcGood);
    case StderrData:
      return GotStderrData(info, crcGood);
    default:
      return ZPF(info);
  }
}


int FQTermZmodem::ZPF(ZModem *info) {
  info->waitflag = 1; /* pause any in-progress transmission */
  ZStatus(ProtocolErr, info->hdrData[0], sname(info));
  return 0;
}


int FQTermZmodem::Ignore(ZModem *info) {
  return 0;
}


int FQTermZmodem::AnswerChallenge(ZModem *info) {
  return ZXmitHdrHex(ZACK, info->hdrData + 1, info);
}


int FQTermZmodem::GotAbort(ZModem *info) {
  ZStatus(RmtCancel, 0, NULL);
  return ZXmitHdrHex(ZFIN, zeros, info);
}


int FQTermZmodem::GotCancel(ZModem *info) {
  return ZmErrCancel;
}


int FQTermZmodem::GotCommand(ZModem *info) {
  uchar rbuf[4];
  /* TODO: add command capability */


  /// EPERM not defined????????

  rbuf[0] = EPERM;
  rbuf[1] = rbuf[2] = rbuf[3] = 0;
  return ZXmitHdrHex(ZCOMPL, rbuf, info);
}

int FQTermZmodem::GotStderr(ZModem *info) {
  info->InputState = Indata;
  info->chrCount = 0;
  return 0;
}


int FQTermZmodem::RetDone(ZModem *info) {


  return ZmDone;
}


int FQTermZmodem::GotCommandData(ZModem *info, int crcGood) {
  /* TODO */
  return 0;
}


int FQTermZmodem::GotStderrData(ZModem *info, int crcGood) {
  info->buffer[info->chrCount] = '\0';
  ZStatus(RemoteMessage, info->chrCount, (char*)info->buffer);
  return 0;
}


int FQTermZmodem::GotFileName(ZModem *info, int crcGood) {
  info->InputState = Idle;
  info->chrCount = 0;

  if (!crcGood) {
    zmodemlog("GotFileName[%s]: bad crc, send ZNAK\n", sname(info));
    info->state = RStart;
    return ZXmitHdrHex(ZNAK, zeros, info);
  }

  parseFileName(info, (char*)info->buffer);

  if ((info->f1 &ZMMASK) == ZMCRC) {
    info->state = RCrc;
    return ZXmitHdrHex(ZCRC, zeros, info);
  }

  zmodemlog("GotFileName[%s]: good crc, call requestFile\n", sname(info));
  info->state = RFile;
  return requestFile(info, 0);
}


int FQTermZmodem::ResendCrcReq(ZModem *info) {
  zmodemlog("ResendCrcReq[%s]: send ZCRC\n", sname(info));
  return ZXmitHdrHex(ZCRC, zeros, info);
}


int FQTermZmodem::GotSinitData(ZModem *info, int crcGood) {
  info->InputState = Idle;
  info->chrCount = 0;
  info->state = RStart;

  zmodemlog("GotSinitData[%s]: crcGood=%d\n", sname(info), crcGood);

  if (!crcGood) {
    return ZXmitHdrHex(ZNAK, zeros, info);
  }

  if (info->attn != NULL) {
    free(info->attn);
  }
  info->attn = NULL;
  if (info->buffer[0] != '\0') {
    info->attn = strdup((char*)info->buffer);
  }
  return ZXmitHdrHex(ZACK, ZEnc4(SerialNo), info);
}


int FQTermZmodem::ResendRpos(ZModem *info) {
  zmodemlog("ResendRpos[%s]: send ZRPOS(%ld)\n", sname(info), info->offset);
  return ZXmitHdrHex(ZRPOS, ZEnc4(info->offset), info);
}


int FQTermZmodem::GotFileData(ZModem *info, int crcGood) {
  /* OK, now what?  Fushing the buffers and executing the
   * attn sequence has likely chopped off the input stream
   * mid-packet.  Now we switch to idle mode and treat all
   * incoming stuff like noise until we get a new valid
   * packet.
   */

  if (!crcGood) {
    /* oh bugger, an error. */
    zmodemlog("GotFileData[%s]: bad crc, send ZRPOS(%ld), new state = RFile\n",
              sname(info), info->offset);
    ZStatus(DataErr, ++info->errCount, NULL);
    if (info->errCount > MaxErrs) {
      ZmodemAbort(info);
      return ZmDataErr;
    } else {
      info->state = RFile;
      info->InputState = Idle;
      info->chrCount = 0;
      return fileError(info, ZRPOS, info->offset);
    }
  }

  if (ZWriteFile(info->buffer, info->chrCount, info->file, info)) {
    /* RED ALERT!  Could not write the file. */
    ZStatus(FileErr, zerrno, NULL);
    info->state = RFinish;
    info->InputState = Idle;
    info->chrCount = 0;
    return fileError(info, ZFERR, zerrno);
  }

  zmodemlog("GotFileData[%s]: %ld.%d,", sname(info), info->offset,
            info->chrCount);
  info->offset += info->chrCount;
  ZStatus(RcvByteCount, info->offset, NULL);

  /* if this was the last data subpacket, leave data mode */
  if (info->PacketType == ZCRCE || info->PacketType == ZCRCW) {
    zmodemlog("  ZCRCE|ZCRCW, new state RFile");
    info->state = RFile;
    info->InputState = Idle;
    info->chrCount = 0;
  } else {
    zmodemlog("  call dataSetup");
    (void)dataSetup(info);
  }

  if (info->PacketType == ZCRCQ || info->PacketType == ZCRCW) {
    zmodemlog(",  send ZACK\n");
    return ZXmitHdrHex(ZACK, ZEnc4(info->offset), info);
  } else {
    zmodemlog("\n");
  }

  return 0;
}

int FQTermZmodem::SendRinit(ZModem *info) {
  uchar dbuf[4];



#ifdef COMMENT
  if (info->timeoutCount >= 5)
	/* TODO: switch to Ymodem */
#endif /* COMMENT */
  {
    transferstate = transferstart;
  }
  //transfer would be active, it must be set to false when transfer complete or abort
  zmodemlog("SendRinit[%s]: send ZRINIT\n", sname(info));

  info->timeout = ResponseTime;
  dbuf[0] = info->bufsize &0xff;
  dbuf[1] = (info->bufsize >> 8) &0xff;
  dbuf[2] = 0;
  dbuf[3] = info->zrinitflags;
  return ZXmitHdrHex(ZRINIT, dbuf, info);
}


int FQTermZmodem::SendMoreFileData(ZModem *info) {
  int type;
  int qfull = 0;
  int err;
  int len; /* max # chars to send this packet */
  long pending; /* # of characters sent but not acknowledged */

  /* ZCRCE: CRC next, frame ends, header follows
   * ZCRCG: CRC next, frame continues nonstop
   * ZCRCQ: CRC next, send ZACK, frame continues nonstop
   * ZCRCW: CRC next, send ZACK, frame ends, header follows
   */

  if (info->interrupt) {
    /* Bugger, receiver sent an interrupt.  Enter a wait state
     * and see what they want.  Next header *should* be ZRPOS.
     */
    info->state = SendWait;
    info->timeout = 60;
    return 0;
  }

  /* Find out how many bytes we can transfer in the next packet */

  len = info->packetsize;

  pending = info->offset - info->lastOffset;

  if (info->windowsize != 0 && info->windowsize - pending <= len) {
    len = info->windowsize - pending;
    qfull = 1;
  }
  if (info->bufsize != 0 && info->bufsize - pending <= len) {
    len = info->bufsize - pending;
    qfull = 1;
  }

  if (len == 0) {
    /* window still full, keep waiting */
    info->state = SendWait;
    info->timeout = 60;
    return 0;
  }


  /* OK, we can safely transmit 'len' bytes of data.  Start reading
   * file until buffer is full.
   */

  len -= 10; /* Pre-deduct 10 bytes for trailing CRC */


  /* find out what kind of packet to send */
  if (info->waitflag) {
    type = ZCRCW;
    info->waitflag = 0;
  }
#ifdef COMMENT
  else if (info->fileEof) {
    type = ZCRCE;
  }
#endif /* COMMENT */
  else if (qfull) {
    type = ZCRCW;
  } else {
	switch (info->Streaming) {
      case Full:
      case Segmented:
        type = ZCRCG;
        break;

      case StrWindow:
        if ((info->windowCount += len) < info->windowsize / 4) {
          type = ZCRCG;
        } else {
          type = ZCRCQ;
          info->windowCount = 0;
        }
        break;

      default:
      case SlidingWindow:
        type = ZCRCQ;
        break;
	}
  }

  {
    int crc32 = info->crc32;
    int c = 0, c2, atSign = 0;
    ulong crc;
    uchar *ptr = info->buffer;

    crc = crc32 ? 0xffffffff : 0;

    /* read characters from file and put into buffer until buffer is
     * full or file is exhausted
     */


    while (len > 0 && (c = getc(info->file)) != EOF) {
      if (!crc32) {
        crc = updcrc(c, crc);
      } else {
        crc = UPDC32(c, crc);
      }

      /* zmodem protocol requires that CAN(ZDLE), DLE, XON, XOFF and
       * a CR following '@' be escaped.  In addition, I escape '^]'
       * to protect telnet, "<CR>~." to protect rlogin, and ESC for good
       * measure.
       */
      c2 = c &0177;
      if (c == ZDLE || c2 == 020 || c2 == 021 || c2 == 023 || c2 == 0177 || c2 ==
          '\r' || c2 == '\n' || c2 == 033 || c2 == 035 || (c2 < 040 && info->escCtrl)) {
        *ptr++ = ZDLE;
        if (c == 0177) {
          *ptr = ZRUB0;
        } else if (c == 0377) {
          *ptr = ZRUB1;
        } else {
          *ptr = c ^ 0100;
        }
        len -= 2;
      } else {
        *ptr = c;
        --len;
      }
      ++ptr;

      atSign = c2 == '@';
      ++info->offset;
    }

    /* if we've reached file end, a ZEOF header will follow.  If
     * there's room in the outgoing buffer for it, end the packet
     * with ZCRCE and append the ZEOF header.  If there isn't room,
     * we'll have to do a ZCRCW
     */
    if ((info->fileEof = (c == EOF))) {
      if (qfull || (info->bufsize != 0 && len < 24)) {
        type = ZCRCW;
      } else {
        type = ZCRCE;
      }
    }

    *ptr++ = ZDLE;
    if (!crc32) {
      crc = updcrc(type, crc);
    } else {
      crc = UPDC32(type, crc);
    }
    *ptr++ = type;

    if (!crc32) {
      crc = updcrc(0, crc);
      crc = updcrc(0, crc);
      ptr = putZdle(ptr, (crc >> 8) &0xff, info);
      ptr = putZdle(ptr, crc &0xff, info);
    } else {
      crc = ~crc;
      for (len = 4; --len >= 0; crc >>= 8) {
        ptr = putZdle(ptr, crc &0xff, info);
      }
    }

    len = ptr - info->buffer;
  }

  ZStatus(SndByteCount, info->offset, NULL);

  if ((err = ZXmitStr(info->buffer, len, info))) {
    return err;
  }

#ifdef COMMENT
  if ((err = ZXmitData(ZBIN, len, uchar(type), info->buffer, info))) {
    return err;
  }
#endif /* COMMENT */

  /* finally, do we want to wait after this packet? */

  switch (type) {
    case ZCRCE:
      info->state = SendEof;
      info->timeout = 60;
      return ZXmitHdrHex(ZEOF, ZEnc4(info->offset), info);
    case ZCRCW:
      info->state = info->fileEof ? SendDone : SendWait;
      info->timeout = 60;
      break;
    default:
      info->state = Sending;
      info->timeout = 0;
      break;
  }


#ifdef COMMENT
  if (info->fileEof) {
    /* Yes, file is done, send EOF and wait */
    info->state = SendEof;
    info->timeout = 60;
    return ZXmitHdrHex(ZEOF, ZEnc4(info->offset), info);
  } else if (type == ZCRCW) {
    info->state = SendWait;
    info->timeout = 60;
  } else {
    info->state = Sending;
    info->timeout = 0;
  }
#endif /* COMMENT */
  return 0;
}


uint FQTermZmodem::rcvHex(uint i, char c) {
  if (c <= '9') {
    c -= '0';
  } else if (c <= 'F') {
    c -= 'A' - 10;
  } else {
    c -= 'a' - 10;
  }
  return (i << 4) + c;
}


int FQTermZmodem::dataSetup(ZModem *info) {
  info->InputState = Indata;
  info->chrCount = 0;
  info->crcCount = 0;
  info->crc = (info->DataType != ZBIN32) ? 0 : 0xffffffffL;
  return 0;
}

int FQTermZmodem::ZWriteFile(uchar *buffer, int len, FILE *file, ZModem*) {
  return (int)fwrite(buffer, 1, len, file) == len ? 0 : ZmErrSys;
}

int FQTermZmodem::ZCloseFile(ZModem *info) {
  //to be completed
  fclose(info->file);
  return 0;
}

void FQTermZmodem::ZFlowControl(int onoff, ZModem *info) {
  //to be completed
}

int FQTermZmodem::GotSinit(ZModem *info) {
  zmodemlog("GotSinit[%s]: call dataSetup\n", sname(info));

  info->zsinitflags = info->hdrData[4];
  info->escCtrl = info->zsinitflags &TESCCTL;
  info->escHibit = info->zsinitflags &TESC8;
  ZFlowControl(1, info);
  return dataSetup(info);
}

int FQTermZmodem::GotFile(ZModem *info) {
  zmodemlog("GotFile[%s]: call dataSetup\n", sname(info));

  info->errCount = 0;
  info->f0 = info->hdrData[4];
  info->f1 = info->hdrData[3];
  info->f2 = info->hdrData[2];
  info->f3 = info->hdrData[1];
  return dataSetup(info);
}

int FQTermZmodem::GotFin(ZModem *info) {
  int i;
  zmodemlog("GotFin[%s]: send ZFIN\n", sname(info));
  info->InputState = Finish;
  info->chrCount = 0;
  if (info->filename != NULL) {
    free(info->filename);
  }
  i = ZXmitHdrHex(ZFIN, zeros, info);
  ZmodemReset(info);
  transferstate = transferstop; // transfer complete
  return i;
}


int FQTermZmodem::GotData(ZModem *info) {
  int err;

  zmodemlog("GotData[%s]:\n", sname(info));

  if (ZDec4(info->hdrData + 1) != info->offset) {
    if (info->attn != NULL && (err = ZAttn(info)) != 0) {
      return err;
    }
    zmodemlog("  bad, send ZRPOS(%ld)\n", info->offset);
    return ZXmitHdrHex(ZRPOS, ZEnc4(info->offset), info);
  }

  /* Let's do it! */
  zmodemlog("  call dataSetup\n");
  return dataSetup(info);
}

int FQTermZmodem::GotEof(ZModem *info) {
  zmodemlog("GotEof[%s]: offset=%ld\n", sname(info), info->offset);
  if (ZDec4(info->hdrData + 1) != info->offset) {
    zmodemlog("zdec4(info->hdrdata+1)=%ld\n", ZDec4(info->hdrData + 1));
    zmodemlog("  bad length, state = RFile\n");
    info->state = RFile;
    return 0; /* it was probably spurious */
  }

  /* TODO: if we can't close the file, send a ZFERR */

  ZCloseFile(info);
  info->file = NULL;
  ZStatus(FileEnd, 0, info->filename);
  if (info->filename != NULL) {
    free(info->filename);
    info->filename = NULL;
  }
  return SendRinit(info);
}

int FQTermZmodem::GotFreecnt(ZModem *info) {
  /* TODO: how do we find free space on system? */
  return ZXmitHdrHex(ZACK, ZEnc4(0xffffffff), info);
}


int FQTermZmodem::GotFileCrc(ZModem *info) {
  zmodemlog("GotFileCrc[%s]: call requestFile\n", sname(info));
  return requestFile(info, ZDec4(info->hdrData + 1));
}

int FQTermZmodem::requestFile(ZModem *info, ulong crc) {
  info->file = ZOpenFile((char*)info->buffer, crc, info);

  if (info->file == NULL) {
    zmodemlog("requestFile[%s]: send ZSKIP\n", sname(info));

    info->state = RStart;
    ZStatus(FileSkip, 0, info->filename);
    return ZXmitHdrHex(ZSKIP, zeros, info);
  } else {
    zmodemlog("requestFile[%s]: send ZRPOS(%ld)\n", sname(info), info->offset);
    info->offset = info->f0 == ZCRESUM ? ftell(info->file): 0;
    info->state = RFile;
    ZStatus(FileBegin, info->len, info->filename);
    return ZXmitHdrHex(ZRPOS, ZEnc4(info->offset), info);
  }
}

void FQTermZmodem::parseFileName(ZModem *info, char *fileinfo) {
  char *ptr;
  int serial = 0;

  info->len = info->mode = info->filesRem = info->bytesRem = info->fileType = 0;
  ptr = fileinfo + strlen(fileinfo) + 1;
  if (info->filename != NULL) {
    free(info->filename);
  }
  info->filename = strdup(fileinfo);
  sscanf(ptr, "%d %lo %o %o %d %d %d", &info->len, &info->date,  &info->mode,
         &serial, &info->filesRem, &info->bytesRem,  &info->fileType);
}



int FQTermZmodem::fileError(ZModem *info, int type, int data) {
  int err;

  info->InputState = Idle;
  info->chrCount = 0;

  if (info->attn != NULL && (err = ZAttn(info)) != 0) {
    return err;
  }
  return ZXmitHdrHex(type, ZEnc4(data), info);
}


int FQTermZmodem::ProcessPacket(ZModem *info) {
  int idx = (uchar)info->buffer[0];
  int idxc = (uchar)info->buffer[1];
  int crc0, crc1;
  int err;

  info->state = YRDataWait;

  if (idxc != 255-idx) {
    ZStatus(DataErr, ++info->errCount, NULL);
    return rejectPacket(info);
  }

  if (idx == (info->packetCount % 256))
    /* quietly ignore dup */ {
    return acceptPacket(info);
  }

  if (idx != (info->packetCount + 1) % 256) {
    /* out of sequence */
    (void)ZXmitStr(CanStr, 2, info);
    return ZmErrSequence;
  }

  crc0 = (uchar)info->buffer[info->pktLen - 2] << 8
         | (uchar)info->buffer[info->pktLen - 1];
  crc1 = calcCrc(info->buffer + 2, info->pktLen - 4);
  if (crc0 != crc1) {
    ZStatus(DataErr, ++info->errCount, NULL);
    return rejectPacket(info);
  }

  ++info->packetCount;

  if (info->packetCount == 0) {
    /* packet 0 is filename */
    if (info->buffer[2] == '\0') {
      /* null filename is FIN */
      (void)acceptPacket(info);
      return ZmDone;
    }

    parseFileName(info, (char*)info->buffer + 2);
    info->file = ZOpenFile(info->filename, 0, info);
    if (info->file == NULL) {
      (void)ZXmitStr(CanStr, 2, info);
      return ZmErrCantOpen;
    }
    if ((err = acceptPacket(info)) != 0) {
      return err;
    }
    return ZXmitStr((uchar*)"C", 1, info);
  }


  if (ZWriteFile(info->buffer + 2, info->pktLen - 4, info->file, info)) {
    ZStatus(FileErr, zerrno, NULL);
    (void)ZXmitStr(CanStr, 2, info);
    return ZmErrSys;
  }
  info->offset += info->pktLen - 4;
  ZStatus(RcvByteCount, info->offset, NULL);

  (void)acceptPacket(info);
  return 0;
}

int FQTermZmodem::rejectPacket(ZModem *info) {
  info->timeout = 10;
  return ZXmitStr(NakStr, 1, info);
}


int FQTermZmodem::acceptPacket(ZModem *info) {
  info->state = YRDataWait;
  info->timeout = 10;
  return ZXmitStr(AckStr, 1, info);
}


int FQTermZmodem::calcCrc(uchar *str, int len) {
  int crc = 0;
  while (--len >= 0) {
    crc = updcrc(*str++, crc);
  }
  crc = updcrc(0, crc);
  crc = updcrc(0, crc);
  return crc &0xffff;
}


char *FQTermZmodem::strdup(const char *str) {
  char *rval;
  int len = strlen(str) + 1;
  rval = (char*)malloc(len);
  strcpy(rval, str);
  return rval;
}


int FQTermZmodem::ZXmitData(int format, int len, uchar term, uchar *data, ZModem
                            *info) {
  uchar *ptr = info->buffer;
  uint crc;

  if (format == ZBIN && info->crc32) {
    format = ZBIN32;
  }

  zmodemlog("ZXmiteData: fmt=%c, len=%d, term=%c\n", format, len, term);

  crc = (format == ZBIN) ? 0 : 0xffffffff;

  while (--len >= 0) {
    if (format == ZBIN) {
      crc = updcrc(*data, crc);
    } else {
      crc = UPDC32(*data, crc);
    }
    ptr = putZdle(ptr,  *data++, info);
  }

  *ptr++ = ZDLE;
  if (format == ZBIN) {
    crc = updcrc(term, crc);
  } else {
    crc = UPDC32(term, crc);
  }
  *ptr++ = term;
  if (format == ZBIN) {
    crc = updcrc(0, crc);
    crc = updcrc(0, crc);
    ptr = putZdle(ptr, (crc >> 8) &0xff, info);
    ptr = putZdle(ptr, crc &0xff, info);
  } else {
    crc = ~crc;
    for (len = 4; --len >= 0; crc >>= 8) {
      ptr = putZdle(ptr, crc &0xff, info);
    }
  }

  return ZXmitStr(info->buffer, ptr - info->buffer, info);
}



int FQTermZmodem::YXmitData(uchar *buffer, int len, ZModem *info) {
  uchar hdr[3];
  uchar trail[2];
  ulong crc = 0;
  int i, err;

  hdr[0] = len == 1024 ? STX : SOH;
  hdr[1] = info->packetCount;
  hdr[2] = ~hdr[1];
  if ((err = ZXmitStr(hdr, 3, info)) || (err = ZXmitStr(buffer, len, info))) {
    return err;
  }

  if (info->PacketType == NAK) {
    /* checksum */
    for (i = 0; i < len; ++i) {
      crc += buffer[i];
    }
    trail[0] = crc % 256;
    return ZXmitStr(trail, 1, info);
  } else {
    for (i = 0; i < len; ++i) {
      crc = updcrc(buffer[i], crc);
    }
    crc = updcrc(0, crc);
    crc = updcrc(0, crc);
    trail[0] = crc / 256;
    trail[1] = crc % 256;
    return ZXmitStr(trail, 2, info);
  }
}


int FQTermZmodem::YSendFilename(ZModem *info) {
  int i, len;
  uchar obuf[1024];
  uchar *ptr = obuf;

  info->state = info->PacketType != 'G' ? YTFile : YTDataWait;
  info->packetCount = 0;
  info->offset = 0;

  i = strlen(info->rfilename);
  memcpy(ptr, info->rfilename, i + 1);
  ptr += i + 1;
  sprintf((char*)ptr, "%d %lo %o 0", info->len, info->date, info->mode);
  ptr += strlen((char*)ptr);
  *ptr++ = '\0';
  /* pad out to 128 bytes or 1024 bytes */
  i = ptr - obuf;
  len = i > 128 ? 1024 : 128;
  for (; i < len; ++i) {
    *ptr++ = '\0';
  }

  return YXmitData(obuf, len, info);
}

int FQTermZmodem::YSendData(ZModem *info) {
  int i;

  /* are there characters still in the read buffer? */

  if (info->chrCount <= 0) {
    info->bufp = 0;
    info->chrCount = fread(info->buffer, 1, info->packetsize, info->file);
    info->fileEof = feof(info->file);
  }

  if (info->chrCount <= 0) {
    fclose(info->file);
    info->state = YTEOF;
    return ZXmitStr(eotstr, 1, info);
  }

  /* pad out to 128 bytes if needed */
  if (info->chrCount < 128) {
    i = 128-info->chrCount;
    memset(info->buffer + info->bufp + info->chrCount, 0x1a, i);
    info->chrCount = 128;
  }

  info->ylen = info->chrCount >= 1024 ? 1024 : 128;
  ++info->packetCount;

  info->state = YTData;

  return YXmitData(info->buffer + info->bufp, info->ylen, info);
}


int FQTermZmodem::YSendFin(ZModem *info) {
  uchar obuf[128];

  info->state = YTFin;
  info->packetCount = 0;

  memset(obuf, 0, 128);

  return YXmitData(obuf, 128, info);
}

int FQTermZmodem::sendFilename(ZModem *info) {
  int err;
  int i;
  uchar obuf[2048];
  uchar *ptr = obuf;

  info->state = FileWait;

  if ((err = ZXmitHdr(ZFILE, ZBIN, info->fileFlags, info))) {
    return err;
  }

  i = strlen(info->rfilename);
  memcpy(ptr, info->rfilename, i + 1);
  ptr += i + 1;
  sprintf((char*)ptr, "%d %lo %o 0 %d %d 0", info->len, info->date, info->mode,
          info->filesRem, info->bytesRem);
  ptr += strlen((char*)ptr);
  *ptr++ = '\0';

  return ZXmitData(ZBIN, ptr - obuf, ZCRCW, obuf, info);
}

int FQTermZmodem::GotRinit(ZModem *info) {
  if (strFileList.count() == 0) {
    return ZmodemTFinish(info);
  }


  info->bufsize = info->hdrData[1] + info->hdrData[2] *256;
  info->zrinitflags = info->hdrData[4] + info->hdrData[3] *256;
  info->crc32 = info->zrinitflags &CANFC32;
  info->escCtrl = info->zrinitflags &ESCCTL;
  info->escHibit = info->zrinitflags &ESC8;

  /* Full streaming: If receiver can overlap I/O, and if
   * the sender can sample the reverse channel without hanging,
   * and the receiver has not specified a buffer size, then we
   * can simply blast away with ZCRCG packets.  If the receiver
   * detects an error, it sends an attn sequence and a new ZRPOS
   * header to restart the file where the error occurred.
   *
   * [note that zmodem8.doc does not define how much noise is
   * required to trigger a ZCRCW packet.  We arbitrarily choose
   * 64 bytes]
   *
   * If 'windowsize' is nonzero, and the receiver can do full
   * duplex, ZCRCQ packets are sent instead of ZCRCG, to keep track
   * of the number of characters in the queue.  If the queue fills
   * up, we pause and wait for a ZACK.
   *
   *
   * Full Streaming with Reverse Interrupt:  If sender cannot
   * sample the input stream, then we define an Attn sequence
   * that will be used to interrupt transmission.
   *
   *
   * Full Streaming with Sliding Window:  If sender cannot
   * sample input stream or respond to Attn signal, we send
   * several ZCRCQ packets until we're sure the receiver must
   * have sent back at least one ZACK.  Then we stop sending and
   * read that ZACK.  Then we send one more packet and so on.
   *
   *
   * Segmented Streaming:  If receiver cannot overlap I/O or can't do
   * full duplex and has specified a maximum receive buffer size,
   * whenever the buffer size is reached, we send a ZCRCW packet.
   *
   * TODO: what if receiver can't overlap, but hasn't set a buffer
   * size?
   *
   * ZCRCE: CRC next, frame ends, header follows
   * ZCRCG: CRC next, frame continues nonstop
   * ZCRCQ: CRC next, send ZACK, frame continues nonstop
   * ZCRCW: CRC next, send ZACK, frame ends, header follows
   */

  transferstate = transferstart;

  ZFlowControl(1, info);

  if ((info->zrinitflags &(CANFDX | CANOVIO)) == (CANFDX | CANOVIO) &&
      (SendSample || SendAttn) && info->bufsize == 0) {
    if (info->windowsize == 0) {
      info->Streaming = Full;
    } else {
      info->Streaming = StrWindow;
    }
  }

  else if ((info->zrinitflags &(CANFDX | CANOVIO)) == (CANFDX | CANOVIO) &&
           info->bufsize == 0) {
    info->Streaming = SlidingWindow;
  }

  else {
    info->Streaming = Segmented;
  }
  // get filenames to transfer
  zmodemlog("GotRinit[%s]\n", sname(info));

  if (AlwaysSinit || info->zsinitflags != 0 || info->attn != NULL) {
    SendZSInit(info);
  }


  itFile = strFileList.begin();
  QFileInfo fi(*itFile);
  FQ_TRACE("zmodem", 0) << "Number of files to be transferred: "
                        << strFileList.count();
  char *filename = strdup(fi.absoluteFilePath().toLatin1());
  char *rfilename = strdup(fi.fileName().toLatin1());
  ZmodemTFile(filename, rfilename, 0, 0, 0, 0, strFileList.count(), fi.size(),
              info);
  strFileList.erase(itFile);
  return ZmDone;
}


int FQTermZmodem::SendZSInit(ZModem *info) {
  char tmp = '\0';
  int err;
  //char	*at = (info->attn != NULL) ? info->attn : "" ;
  char *at;
  if (info->attn != NULL) {
    at = info->attn;
  } else {
    at = &tmp;
  }
  uchar fbuf[4];

  /* TODO: zmodem8.doc states: "If the ZSINIT header specifies
   * ESCCTL or ESC8, a HEX header is used, and the receiver
   * activates the specified ESC modes before reading the following
   * data subpacket." What does that mean?
   */

  zmodemlog("SendZSInit[%s]\n", sname(info));

  info->state = TInit;
  fbuf[0] = fbuf[1] = fbuf[2] = 0;
  fbuf[3] = info->zsinitflags;
  if ((err = ZXmitHdr(ZSINIT, ZBIN, fbuf, info)) || (err = ZXmitData(ZBIN,
                                                                     strlen(at) + 1, ZCRCW, (uchar*)at, info))) {
    return err;
  }
  return 0;
}


int FQTermZmodem::SendFileCrc(ZModem *info) {
  ulong crc;

  crc = FileCrc(info->filename);

  zmodemlog("SendFileCrc[%s]: %lx\n", sname(info), crc);

  return ZXmitHdrHex(ZCRC, ZEnc4(crc), info);
}

int FQTermZmodem::GotSendAck(ZModem *info) {
  ulong offset;

  offset = ZDec4(info->hdrData + 1);

  if (offset > info->lastOffset) {
    info->lastOffset = offset;
  }

  zmodemlog("GotSendAck[%s]: %lx\n", sname(info), info->offset);

  return 0; /* DONT send more data, that will happen
             * later anyway */
}

int FQTermZmodem::GotSendDoneAck(ZModem *info) {
  ulong offset;

  offset = ZDec4(info->hdrData + 1);

  if (offset > info->lastOffset) {
    info->lastOffset = offset;
  }

  zmodemlog("GotSendDoneAck[%s]: %ld\n", sname(info), info->offset);

  info->state = SendEof;
  info->timeout = 60;
  return ZXmitHdrHex(ZEOF, ZEnc4(info->offset), info);
}

int FQTermZmodem::GotSendNak(ZModem *info) {
  info->offset = info->zrposOffset;

  fseek(info->file, info->offset, 0);

  /* TODO: what if fseek fails?  Send EOF? */

  zmodemlog("GotSendNak[%s]: %ld\n", sname(info), info->offset);

  return SendMoreFileData(info);
}

int FQTermZmodem::GotSendWaitAck(ZModem *info) {

  ulong offset;
  int err;

  offset = ZDec4(info->hdrData + 1);

  FQ_TRACE("zmodem", 10) << "last = " << info->lastOffset
                         << ", now = " << offset;

  if (offset > info->lastOffset) {
    info->lastOffset = offset;
  }

  //receiver return -1 without setting this flag, kingson 00:07 14-07-04
  info->waitflag = 1;

  zmodemlog("GotSendWaitAck[%s]\n", sname(info), offset);

  if ((err = ZXmitHdr(ZDATA, ZBIN, info->hdrData + 1, info))) {
    return err;
  }
  return SendMoreFileData(info);
}

int FQTermZmodem::SkipFile(ZModem *info) {
  zmodemlog("SkipFile[%s]\n", sname(info));
  ZStatus(FileEnd, 0, info->rfilename);
  fclose(info->file);

  // stupid SMTH doesn't send further command, kick
  // lets send files in the list
  info->state = TStart;
  return GotRinit(info);
}

int FQTermZmodem::GotSendPos(ZModem *info) {
  ZStatus(DataErr, ++info->errCount, NULL);
  info->waitflag = 1; /* next pkt should wait, to resync */
  FQ_TRACE("zmodem", 9) << "GotSendPos, offset = " << info->offset;
  zmodemlog("GotSendPos[%s] %lx\n", sname(info), info->offset);
  return startFileData(info);
}

int FQTermZmodem::SendFileData(ZModem *info) {
  info->waitflag = 0;
  return startFileData(info);
}

int FQTermZmodem::ResendEof(ZModem *info) {
  return ZXmitHdrHex(ZEOF, ZEnc4(info->offset), info);
}

int FQTermZmodem::OverAndOut(ZModem *info) {
  zmodemlog("OverAndOut[%s]\n", sname(info));

  ZXmitStr((uchar*)"OO", 2, info);

  transferstate = transferstop; // transfer complete

  ZmodemReset(info); //Transfer complete, zmodem return to receive state

  return ZmDone;
}

int FQTermZmodem::startFileData(ZModem *info) {
  int err;

  info->offset = info->lastOffset = info->zrposOffset = ZDec4(info->hdrData + 1);

  fseek(info->file, info->offset, 0);

  /* TODO: what if fseek fails?  Send EOF? */

  zmodemlog("startFileData[%s]: %lx\n", sname(info), info->offset);

  if ((err = ZXmitHdr(ZDATA, ZBIN, ZEnc4(info->offset), info))) {
    return err;
  }
  return SendMoreFileData(info);
}

uchar *FQTermZmodem::putHex(uchar *ptr, uchar c) {
  *ptr++ = hexChars[(c >> 4) &0xf];
  *ptr++ = hexChars[c &0xf];
  return ptr;
}


int FQTermZmodem::ZmodemReset(ZModem *info) {
  zmodemlog("\nZmodemReset\n");

  ZmodemRInit(info);

  return 0;
}


void FQTermZmodem::zmodemlog(const char *fmt, ...) {
  // only for debug
#ifdef FQTERM_ZMODEM_DEBUG
  va_list ap;
  struct timeval tv;
  struct tm *tm;
  static int do_ts = 1;

  zmodemlogfile = fopen("zmodem.log", "a");

  if (zmodemlogfile == NULL) {
    return ;
  }

  if (do_ts) {
    gettimeofday(&tv, NULL);
    tm = localtime(&tv.tv_sec);
    fprintf(zmodemlogfile, "%2.2d:%2.2d:%2.2d.%2.2ld: ", tm->tm_hour, tm->tm_min,
            tm->tm_sec, tv.tv_usec / 10000);
  }
  do_ts = strchr(fmt, '\n') != NULL;

  va_start(ap, fmt);
  vfprintf(zmodemlogfile, fmt, ap);
  va_end(ap);

  fclose(zmodemlogfile);
#endif

}

void FQTermZmodem::zmodemCancel() {
  ZmodemAbort(&info);
}

}  // namespace FQTerm

#include "fqterm_zmodem.moc"