move to my github.

6 files changed, 6388 insertions, 0 deletions

diff --git a/src/terminal/internal/fqterm_decode.cpp b/src/terminal/internal/fqterm_decode.cpp
new file mode 100644
index 0000000..cb7bc9a
--- /dev/null
+++ b/src/terminal/internal/fqterm_decode.cpp
@@ -0,0 +1,1279 @@
+/***************************************************************************
+ *   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 <QByteArray>
+
+#include "fqterm.h"
+#include "fqterm_telnet.h"
+#include "fqterm_decode.h"
+#include "fqterm_buffer.h"
+#include "fqwcwidth.h"
+
+namespace FQTerm {
+
+#define MODE_MouseX11	0
+
+/************************************************************************/
+// state for FSM
+// please read ANSI decoding
+StateOption FQTermDecode::VT100StateMachine::normal_state_[] =  {
+  {
+    CHAR_CR, &FQTermDecode::cr, normal_state_
+  }, {
+    CHAR_LF, &FQTermDecode::lf, normal_state_
+  }, {
+    CHAR_VT, &FQTermDecode::lf, normal_state_
+  }, {
+    CHAR_ESC, 0, esc_state_
+  }, {
+    CHAR_FF, &FQTermDecode::ff, normal_state_
+  }, {
+    CHAR_TAB, &FQTermDecode::tab, normal_state_
+  }, {
+    CHAR_BS, &FQTermDecode::bs, normal_state_
+  }, {
+    CHAR_BELL, &FQTermDecode::bell, normal_state_
+  }, {
+    CHAR_SO, &FQTermDecode::g1, normal_state_
+  }, {
+    CHAR_SI, &FQTermDecode::g0, normal_state_
+  }, {
+    CHAR_CAN, 0, normal_state_ // should be ignored
+  }, {
+    CHAR_DEL, &FQTermDecode::del, normal_state_ 
+  }, {
+    CHAR_NUL, 0, normal_state_ // should be ignored
+  }, {
+    CHAR_ENQ, &FQTermDecode::enq, normal_state_
+  }, {
+    CHAR_NORMAL, &FQTermDecode::normalInput, normal_state_
+  }
+};
+
+// state after a ESC_CHAR
+StateOption FQTermDecode::VT100StateMachine::esc_state_[] =  {
+  {
+    '7', &FQTermDecode::saveCursor, normal_state_
+  }, {
+    '8', &FQTermDecode::restoreCursor, normal_state_
+  }, {
+    '[', &FQTermDecode::clearParam, bracket_state_
+  }, {
+    ']', &FQTermDecode::clearParam, title_state_
+  }, {
+    '(', 0, select_g0_charset_state_
+  }, {
+    ')', 0, select_g1_charset_state_
+  }, {
+    'D', &FQTermDecode::moveCursorDown, normal_state_
+  }, {
+    'E', &FQTermDecode::nextLine, normal_state_
+  }, {
+    'H', &FQTermDecode::addTabStop, normal_state_
+  }, {
+    'M', &FQTermDecode::moveCursorUp, normal_state_
+  }, {
+    '>', &FQTermDecode::setNumericKeypad, normal_state_
+  }, {
+    '=', &FQTermDecode::setAppKeypad, normal_state_
+  }, {
+    '<', &FQTermDecode::test, normal_state_
+  }, {
+    '#', 0, sharp_state_
+  }, {
+    CHAR_NORMAL, 0, normal_state_
+  }
+};
+
+// state after ESC [
+StateOption FQTermDecode::VT100StateMachine::bracket_state_[] =  {
+  {
+    '0', &FQTermDecode::paramDigit, bracket_state_
+  }, {
+    '1', &FQTermDecode::paramDigit, bracket_state_
+  }, {
+    '2', &FQTermDecode::paramDigit, bracket_state_
+  }, {
+    '3', &FQTermDecode::paramDigit, bracket_state_
+  }, {
+    '4', &FQTermDecode::paramDigit, bracket_state_
+  }, {
+    '5', &FQTermDecode::paramDigit, bracket_state_
+  }, {
+    '6', &FQTermDecode::paramDigit, bracket_state_
+  }, {
+    '7', &FQTermDecode::paramDigit, bracket_state_
+  }, {
+    '8', &FQTermDecode::paramDigit, bracket_state_
+  }, {
+    '9', &FQTermDecode::paramDigit, bracket_state_
+  }, {
+    ';', &FQTermDecode::nextParam, bracket_state_
+  }, {
+    '?', &FQTermDecode::clearParam, private_state_
+  }, {
+    'A', &FQTermDecode::cursorUp, normal_state_
+  }, {
+    'B', &FQTermDecode::cursorDown, normal_state_
+  }, {
+    'C', &FQTermDecode::cursorRight, normal_state_
+  }, {
+    'D', &FQTermDecode::cursorLeft, normal_state_
+  }, {
+    'H', &FQTermDecode::cursorPosition, normal_state_
+  }, {
+    'J', &FQTermDecode::eraseScreen, normal_state_
+  }, {
+    'K', &FQTermDecode::eraseLine, normal_state_
+  }, {
+    'L', &FQTermDecode::insertLine, normal_state_
+  }, {
+    'M', &FQTermDecode::deleteLine, normal_state_
+  }, {
+    'P', &FQTermDecode::deleteStr, normal_state_
+  }, {
+    'X', &FQTermDecode::eraseStr, normal_state_
+  }, {
+    'f', &FQTermDecode::cursorPosition, normal_state_
+  }, {
+    'g', &FQTermDecode::clearTabStop, normal_state_
+  }, {
+    'h', &FQTermDecode::setMode, normal_state_
+  }, {
+    'l', &FQTermDecode::resetMode, normal_state_
+  }, {
+    'm', &FQTermDecode::setAttr, normal_state_
+  }, {
+    'q', 0, normal_state_  // ignore LED-related commands.
+  }, {
+    'r', &FQTermDecode::setMargins, normal_state_
+  }, {
+    's', &FQTermDecode::saveCursor, normal_state_
+  }, {
+    'u', &FQTermDecode::restoreCursor, normal_state_
+  }, {
+    '@', &FQTermDecode::insertStr, normal_state_
+  }, {
+    CHAR_CR, &FQTermDecode::cr, bracket_state_
+  }, {
+    CHAR_LF, &FQTermDecode::lf, bracket_state_
+  }, {
+    CHAR_VT, &FQTermDecode::lf, bracket_state_
+  }, {
+    CHAR_FF, &FQTermDecode::ff, bracket_state_
+  }, {
+    CHAR_TAB, &FQTermDecode::tab, bracket_state_
+  }, {
+    CHAR_BS, &FQTermDecode::bs, bracket_state_
+  }, {
+    CHAR_BELL, &FQTermDecode::bell, bracket_state_
+  }, {
+    CHAR_NORMAL, 0, normal_state_
+  }
+};
+
+// state after ESC (
+StateOption FQTermDecode::VT100StateMachine::select_g0_charset_state_[] =  {
+  {
+    'A', &FQTermDecode::selectG0A, normal_state_
+  }, {
+    'B', &FQTermDecode::selectG0B, normal_state_
+  }, {
+    '0', &FQTermDecode::selectG00, normal_state_
+  }, {
+    '1', &FQTermDecode::selectG01, normal_state_
+  }, {
+    '2', &FQTermDecode::selectG02, normal_state_
+  }, {
+    CHAR_NORMAL, 0, normal_state_
+  }
+};
+  
+// state after ESC )
+StateOption FQTermDecode::VT100StateMachine::select_g1_charset_state_[] =  {
+  {
+    'A', &FQTermDecode::selectG1A, normal_state_
+  }, {
+    'B', &FQTermDecode::selectG1B, normal_state_
+  }, {
+    '0', &FQTermDecode::selectG10, normal_state_
+  }, {
+    '1', &FQTermDecode::selectG11, normal_state_
+  }, {
+    '2', &FQTermDecode::selectG12, normal_state_
+  }, {
+    CHAR_NORMAL, 0, normal_state_
+  }
+};
+
+// state after ESC [ ?
+StateOption FQTermDecode::VT100StateMachine::private_state_[] =  {
+  {
+    '0', &FQTermDecode::paramDigit, private_state_
+  }, {
+    '1', &FQTermDecode::paramDigit, private_state_
+  }, {
+    '2', &FQTermDecode::paramDigit, private_state_
+  }, {
+    '3', &FQTermDecode::paramDigit, private_state_
+  }, {
+    '4', &FQTermDecode::paramDigit, private_state_
+  }, {
+    '5', &FQTermDecode::paramDigit, private_state_
+  }, {
+    '6', &FQTermDecode::paramDigit, private_state_
+  }, {
+    '7', &FQTermDecode::paramDigit, private_state_
+  }, {
+    '8', &FQTermDecode::paramDigit, private_state_
+  }, {
+    '9', &FQTermDecode::paramDigit, private_state_
+  }, {
+    ';', &FQTermDecode::nextParam, private_state_
+  }, {
+    'h', &FQTermDecode::setDecPrivateMode, normal_state_
+  }, {
+    'l', &FQTermDecode::resetDecPrivateMode, normal_state_
+  }, {
+    's', &FQTermDecode::saveMode, normal_state_
+  }, {
+    'r', &FQTermDecode::restoreMode, normal_state_
+  }, {
+    CHAR_NORMAL, 0, normal_state_
+  }
+};
+
+// state after ESC #
+StateOption FQTermDecode::VT100StateMachine::sharp_state_[] =  {
+  {
+    '8', &FQTermDecode::fillScreen, normal_state_
+  }, {
+    CHAR_NORMAL, 0, normal_state_
+  }
+};
+
+// state after ESC ]
+// to change the terminal title dynamically.
+// Dynamic titles
+// Many people find it useful to set the title of a terminal to reflect dynamic information, 
+// such as the name of the host the user is logged into, the current working directory, etc.
+// This may be done by using XTerm escape sequences. The following sequences are useful in this respect:
+//  ESC]0;stringBEL    Set icon name and window title to string
+//  ESC]1;stringBEL    Set icon name to string
+//  ESC]2;stringBEL    Set window title to string
+// where ESC is the escape character (\033), and BEL is the bell character (\007).
+// Currently we just ignore this.
+StateOption FQTermDecode::VT100StateMachine::title_state_[] =  {
+  {
+    '0', &FQTermDecode::paramDigit, title_state_
+  }, {
+    '1', &FQTermDecode::paramDigit, title_state_
+  }, {
+    '2', &FQTermDecode::paramDigit, title_state_
+  }, {
+    '4', &FQTermDecode::paramDigit, title_state_
+  }, {
+    '5', &FQTermDecode::paramDigit, title_state_
+  }, {
+    '6', &FQTermDecode::paramDigit, title_state_
+  }, {
+    ';', &FQTermDecode::clearText, title_text_state_
+  }, {
+    CHAR_NORMAL, 0, normal_state_
+  }
+};
+
+StateOption FQTermDecode::VT100StateMachine::title_text_state_[] = {
+  {
+    CHAR_ESC, 0, esc_state_
+  }, {
+    CHAR_BELL, &FQTermDecode::setTitle, normal_state_
+  }, {
+    CHAR_NORMAL, &FQTermDecode::collectText, title_state_
+  }
+};
+
+const char *FQTermDecode::getStateName(const StateOption *state) {
+  if (state == VT100StateMachine::normal_state_) {
+    return "VT100StateMachine::normal_state_";
+  } else if (state == VT100StateMachine::esc_state_) {
+    return "VT100StateMachine::esc_state_";
+  } else if (state == VT100StateMachine::bracket_state_) {
+    return "VT100StateMachine::bracket_state_";
+  } else if (state == VT100StateMachine::private_state_) {
+    return "VT100StateMachine::private_state_";
+  } else if (state == VT100StateMachine::title_state_) {
+    return "VT100StateMachine::title_state_";
+  } else {
+    return "Unknow";
+  }
+}
+
+
+FQTermDecode::FQTermDecode(FQTermBuffer *buffer, int server_encoding) {
+  leftToDecode_.clear();
+  termBuffer_ = buffer;
+
+  interrupt_decode_ = false;
+  
+  current_state_ =  VT100StateMachine::normal_state_;
+
+  default_color_ = NO_COLOR;
+  default_attr_ = NO_ATTR;
+
+  current_color_ = default_color_;
+  current_attr_ = default_attr_;
+  
+  isBell_ = false;
+
+  termBuffer_->setCurrentAttr(current_color_, current_attr_);
+
+  // TODO_UTF16: please create a encoding enum.
+  server_encoding_ = server_encoding;
+
+  currentMode_[MODE_MouseX11] = savedMode_[MODE_MouseX11] = false;
+  FQ_VERIFY(connect(termBuffer_, SIGNAL(caretChangeRow()), this, SLOT(onCaretChangeRow())));
+}
+
+FQTermDecode::~FQTermDecode() {
+  
+}
+
+// precess input string from telnet socket
+//void FQTermDecode::ansiDecode( const QCString &cstr, int length )
+int FQTermDecode::decode(const char *cstr, int length) {
+  inputData_ = cstr;
+  inputLength_ = length; //inputData.length();
+
+  dataIndex_ = 0;
+  isBell_ = false;
+
+  interrupt_decode_ = false;
+
+  int i;
+  StateOption *lastState;
+
+  termBuffer_->startDecode();
+
+  // here we use FSM to ANSI decoding
+  // use switch case is ok too
+  // but i think use function pointer array can make this clear
+  // you can see the defination at the beginning
+  while (dataIndex_ < inputLength_) {
+    // current state always be initialized to point to the deginning of three structures
+    // ( normalState, escState, bracketState )
+    i = 0;
+    while (current_state_[i].byte != CHAR_NORMAL && current_state_[i].byte !=
+           inputData_[dataIndex_]) {
+      i++;
+    }
+
+    // action must be allowed to redirect state change
+    // get current state with input character i ( hehe, current now become last one )
+    lastState = current_state_ + i; // good !!
+
+    bool trace_state = true;
+    if (current_state_ == VT100StateMachine::normal_state_ 
+        && lastState->nextState == VT100StateMachine::normal_state_) {
+      trace_state = false;
+    }
+
+    if (trace_state) {
+      FQ_TRACE("ansi", 10) << "Current state: " << getStateName(current_state_);
+      FQ_TRACE("ansi", 10) << dumpHexString << std::string("") + inputData_[dataIndex_] 
+                        << dumpNormalString << " " << inputData_[dataIndex_];
+    }
+
+    if (lastState->action != 0) {
+      (this->*(lastState->action))();
+    } else {
+      if (trace_state) FQ_TRACE("ansi", 10) << "No action";
+    }
+    if (trace_state) FQ_TRACE("ansi", 10) << "Next state: " << getStateName(lastState->nextState);
+
+    // reinit current state
+    current_state_ = lastState->nextState;
+
+    dataIndex_++;
+
+    if (interrupt_decode_) {
+      break;
+    }
+  }
+  termBuffer_->endDecode();
+
+  return dataIndex_;
+}
+
+
+QString FQTermDecode::bbs2unicode(const QByteArray &text) {
+  return encoding2unicode(text, server_encoding_);
+}
+
+///////////////////////////////////
+//helper function to decode utf8//
+//////////////////////////////////
+static int utf8_expected_byte_count(char first_byte)
+{
+  char expected = 0;
+  if (!(first_byte & 0x80)) 
+    return 0; //1 byte ascii
+  else
+    expected++;
+  if (!(first_byte & 0x40))
+  {
+    return -1;  //not a leading byte.
+  }
+  if (!(first_byte & 0x20))
+    return expected;
+  else
+    expected++;
+  if (!(first_byte & 0x10))
+    return expected;
+  else
+    expected++;
+  if (!(first_byte & 0x08))
+    return expected;
+  return -1;
+}
+
+///////////////////////////////////
+//helper function to decode utf8//
+//////////////////////////////////
+static int gdbnbig5_expected_byte_count(char first_byte)
+{
+  char expected = 0;
+  if (!(first_byte & 0x80)) 
+    return 0; //1 byte ascii
+  else
+    expected++;
+  return expected;
+}
+
+int FQTermDecode::processInput(QByteArray& result)
+{
+  int charstate = FQTermTextLine::NORMAL;
+  int expect_bytes = 0;
+  if (leftToDecode_.size())
+  {
+    switch(server_encoding_)
+    {
+    case FQTERM_ENCODING_GBK:
+    case FQTERM_ENCODING_BIG5:
+    case FQTERM_ENCODING_HKSCS:
+    case FQTERM_ENCODING_UAO:
+      expect_bytes = gdbnbig5_expected_byte_count(leftToDecode_[0]);
+      break;
+    case FQTERM_ENCODING_UTF8:
+      expect_bytes = utf8_expected_byte_count(leftToDecode_[0]);
+      break;
+    }
+  }
+
+  //TODO: error.
+  if (expect_bytes < 0) {
+    expect_bytes = 0;
+  }
+  
+
+  int n = 0;
+  int last_char_index = n;
+  while (((dataIndex_ + n) < inputLength_) && (signed(inputData_[dataIndex_ + n]) >= 0x20
+    || signed(inputData_[dataIndex_ + n]) < 0x00)) {
+
+      if (expect_bytes != 0) {
+        expect_bytes--;
+      } else {
+        last_char_index = n;
+        switch(server_encoding_)
+        {
+        case FQTERM_ENCODING_GBK:
+        case FQTERM_ENCODING_BIG5:
+        case FQTERM_ENCODING_HKSCS:
+        case FQTERM_ENCODING_UAO:
+          expect_bytes = gdbnbig5_expected_byte_count(inputData_[dataIndex_ + n]);
+          break;
+        case FQTERM_ENCODING_UTF8:
+          expect_bytes = utf8_expected_byte_count(inputData_[dataIndex_ + n]);
+          break;
+        }
+        //TODO: error.
+        if (expect_bytes < 0) {
+          expect_bytes = 0;
+        }
+
+        
+      }
+
+      n++;
+  }
+
+  if (expect_bytes) {
+    if(dataIndex_ + n == inputLength_) {
+      interrupt_decode_ = true;
+    } 
+  }
+
+  result.clear();
+  result.reserve(n + 1);
+  if (leftToDecode_.size()) {
+    result += leftToDecode_;
+    switch(server_encoding_)
+    {
+    case FQTERM_ENCODING_GBK:
+    case FQTERM_ENCODING_BIG5:
+    case FQTERM_ENCODING_HKSCS:
+    case FQTERM_ENCODING_UAO:
+      charstate |= FQTermTextLine::SECONDPART;
+      break;
+    case FQTERM_ENCODING_UTF8:
+      break;
+    }
+    leftToDecode_.clear();
+  }
+  int real_n = n;
+  if (expect_bytes) {
+    real_n = last_char_index;
+    leftToDecode_ = QByteArray(inputData_ + dataIndex_ + last_char_index, n - last_char_index);
+  }
+
+  result.push_back(QByteArray(inputData_ + dataIndex_, real_n));
+  if (expect_bytes) {
+    switch(server_encoding_)
+    {
+    case FQTERM_ENCODING_GBK:
+    case FQTERM_ENCODING_BIG5:
+    case FQTERM_ENCODING_HKSCS:
+    case FQTERM_ENCODING_UAO:
+      result.push_back('?');  //make sure the attr is recorded,
+      //since last -1 operation can make cstr to be empty
+      charstate |= FQTermTextLine::FIRSTPART;
+      break;
+    case FQTERM_ENCODING_UTF8:
+      break;
+    }
+  }
+
+  n--;
+  dataIndex_ += n;
+
+  return charstate;
+}
+
+
+// fill letters into char buffer
+// TODO: this function may contain bug, need double-check.
+//       1. input should be ascii-compitable encoding.
+void FQTermDecode::normalInput() {
+
+  FQ_FUNC_TRACE("ansi", 8);
+
+  // TODO_UTF16: check ascii-incompitable encoding.
+  if (signed(inputData_[dataIndex_]) < 0x20 && signed(inputData_[dataIndex_]) >= 0x00) {
+	// not print char
+    return ;
+  }
+  
+  QByteArray cstr;
+  int charstate = processInput(cstr);
+  
+
+
+  QString str = bbs2unicode(cstr);
+  FQ_TRACE("normal_input", 9) << "hex: " << dumpHexString
+                               << str.toLocal8Bit().constData() ;  
+  FQ_TRACE("normal_input", 9) << "text: " << str;
+  termBuffer_->writeText(str, charstate);
+
+}
+
+// non-printing characters functions
+void FQTermDecode::cr() {
+  FQ_FUNC_TRACE("ansi", 8);
+  // FIXME: dirty
+  termBuffer_->carriageReturn();
+}
+
+void FQTermDecode::lf() {
+  FQ_FUNC_TRACE("ansi", 8);
+  termBuffer_->lineFeed();
+}
+
+void FQTermDecode::ff() {
+  FQ_FUNC_TRACE("ansi", 8);
+  termBuffer_->eraseEntireTerm();
+
+  termBuffer_->moveCaretTo(0, 0);
+}
+
+void FQTermDecode::tab() {
+  FQ_FUNC_TRACE("ansi", 8);
+  termBuffer_->tab();
+}
+
+void FQTermDecode::bs() {
+  FQ_FUNC_TRACE("ansi", 8);
+  termBuffer_->moveCaretOffset(-1, 0);
+}
+
+void FQTermDecode::bell() {
+  FQ_FUNC_TRACE("ansi", 8);
+  isBell_ = true;
+}
+
+void FQTermDecode::del() {
+  FQ_FUNC_TRACE("ansi", 8);
+  termBuffer_->moveCaretOffset(-1, 0);
+  //termBuffer_->deleteText(1);
+}
+
+void FQTermDecode::g0() {
+  FQ_FUNC_TRACE("ansi", 8);
+  termBuffer_->invokeCharset(true);
+}
+
+void FQTermDecode::g1() {
+  FQ_FUNC_TRACE("ansi", 8);
+  termBuffer_->invokeCharset(false);
+}
+
+void FQTermDecode::enq() {
+  emit enqReceived();
+}
+
+void FQTermDecode::addTabStop() {
+  FQ_FUNC_TRACE("ansi", 8);
+  termBuffer_->addTabStop();
+}
+
+void FQTermDecode::clearTabStop() {
+  FQ_FUNC_TRACE("ansi", 8);
+  logParam();
+
+  if (param_[0] == 0) {
+    termBuffer_->clearTabStop(false);
+  } else if (param_[0] == 3) {
+    termBuffer_->clearTabStop(true);
+  }
+}
+
+void FQTermDecode::setMargins() {
+  FQ_FUNC_TRACE("ansi", 8);
+  logParam();
+  
+  if (isParamAvailable_) {
+    termBuffer_->setMargins(param_[0] - 1, param_[1] - 1);
+  } else {
+    termBuffer_->setMargins(0, termBuffer_->getNumRows() - 1);
+  }
+}
+
+// parameters functions
+void FQTermDecode::clearParam() {
+  FQ_FUNC_TRACE("ansi", 9);
+  paramIndex_ = 0;
+  memset(param_, 0, sizeof(param_));
+  isParamAvailable_ = false;
+}
+
+// for performance, this grabs all digits
+void FQTermDecode::paramDigit() {
+  FQ_FUNC_TRACE("ansi", 10);
+  isParamAvailable_ = true;
+
+  // make stream into number
+  // ( e.g. this input character is '1' and this param is 4
+  // after the following sentence this param is changed to 41
+  param_[paramIndex_] = param_[paramIndex_] *10+inputData_[dataIndex_] - '0';
+}
+
+void FQTermDecode::nextParam() {
+  FQ_FUNC_TRACE("ansi", 9);
+  paramIndex_++;
+}
+
+void FQTermDecode::saveCursor() {
+  FQ_FUNC_TRACE("ansi", 8);
+  termBuffer_->saveCaret();
+}
+
+void FQTermDecode::restoreCursor() {
+  FQ_FUNC_TRACE("ansi", 8);
+  termBuffer_->restoreCaret();
+}
+
+void FQTermDecode::cursorPosition() {
+  FQ_FUNC_TRACE("ansi", 8);
+  logParam();
+  
+  int x = param_[1];
+  int y = param_[0];
+
+  if (x == 0) {
+    x = 1;
+  }
+  if (y == 0) {
+    y = 1;
+  }
+
+  termBuffer_->changeCaretPosition(x - 1, y - 1);
+}
+
+void FQTermDecode::cursorLeft() {
+  FQ_FUNC_TRACE("ansi", 8);
+  logParam();
+  
+  int n = param_[0];
+
+  if (n < 1) {
+    n = 1;
+  }
+
+  termBuffer_->moveCaretOffset(-n, 0);
+}
+
+void FQTermDecode::cursorRight() {
+  FQ_FUNC_TRACE("ansi", 8);
+  logParam();
+  
+  int n = param_[0];
+
+  if (n < 1) {
+    n = 1;
+  }
+
+  termBuffer_->moveCaretOffset(n, 0);
+}
+
+void FQTermDecode::cursorUp() {
+  FQ_FUNC_TRACE("ansi", 8);
+  logParam();
+  
+  int n = param_[0];
+
+  if (n < 1) {
+    n = 1;
+  }
+
+  termBuffer_->moveCaretOffset(0, -n);
+}
+
+void FQTermDecode::cursorDown() {
+  FQ_FUNC_TRACE("ansi", 8);
+  logParam();
+  
+  int n = param_[0];
+
+  if (n < 1) {
+    n = 1;
+  }
+
+  termBuffer_->moveCaretOffset(0, n);
+}
+
+void FQTermDecode::moveCursorUp() {
+  FQ_FUNC_TRACE("ansi", 8);
+  termBuffer_->scrollTerm(-1);//moveCaretOffset(0, -1, true);
+}
+
+void FQTermDecode::moveCursorDown() {
+  FQ_FUNC_TRACE("ansi", 8);
+  termBuffer_->scrollTerm(1);//moveCaretOffset(0, 1, true);
+}
+
+void FQTermDecode::nextLine() {
+  FQ_FUNC_TRACE("ansi", 8);
+  termBuffer_->carriageReturn();
+  termBuffer_->moveCaretOffset(0, 1, true);
+}
+
+void FQTermDecode::selectG0A() {
+  FQ_FUNC_TRACE("ansi", 8);  
+  termBuffer_->SelectVtCharacterSet(FQTermBuffer::UNITED_KINGDOM_SET, true);
+}
+
+void FQTermDecode::selectG0B() {
+  FQ_FUNC_TRACE("ansi", 8);  
+  termBuffer_->SelectVtCharacterSet(FQTermBuffer::ASCII_SET, true);
+}
+
+void FQTermDecode::selectG00() {
+  FQ_FUNC_TRACE("ansi", 8);  
+  termBuffer_->SelectVtCharacterSet(FQTermBuffer::SPECIAL_GRAPHICS, true);
+}
+
+void FQTermDecode::selectG01() {
+  FQ_FUNC_TRACE("ansi", 8);  
+  termBuffer_->SelectVtCharacterSet(
+      FQTermBuffer::ALTERNATE_CHARACTER_ROM_STANDARD_CHARACTER_SET, true);
+}
+
+void FQTermDecode::selectG02() {
+  FQ_FUNC_TRACE("ansi", 8);  
+  termBuffer_->SelectVtCharacterSet(
+      FQTermBuffer::ALTERNATE_CHARACTER_ROM_SPECIAL_GRAPHICS, true);
+}
+
+void FQTermDecode::selectG1A() {
+  FQ_FUNC_TRACE("ansi", 8);  
+  termBuffer_->SelectVtCharacterSet(FQTermBuffer::UNITED_KINGDOM_SET, false);
+}
+
+void FQTermDecode::selectG1B() {
+  FQ_FUNC_TRACE("ansi", 8);  
+  termBuffer_->SelectVtCharacterSet(FQTermBuffer::ASCII_SET, false);
+}
+
+void FQTermDecode::selectG10() {
+  FQ_FUNC_TRACE("ansi", 8);  
+  termBuffer_->SelectVtCharacterSet(FQTermBuffer::SPECIAL_GRAPHICS, false);
+}
+
+void FQTermDecode::selectG11() {
+  FQ_FUNC_TRACE("ansi", 8);  
+  termBuffer_->SelectVtCharacterSet(
+      FQTermBuffer::ALTERNATE_CHARACTER_ROM_STANDARD_CHARACTER_SET, false);
+}
+
+void FQTermDecode::selectG12() {
+  FQ_FUNC_TRACE("ansi", 8);  
+  termBuffer_->SelectVtCharacterSet(
+      FQTermBuffer::ALTERNATE_CHARACTER_ROM_SPECIAL_GRAPHICS, false);
+}
+
+// erase functions
+void FQTermDecode::eraseStr() {
+  FQ_FUNC_TRACE("ansi", 8);
+  logParam();
+  
+  int n = param_[0];
+
+  if (n < 1) {
+    n = 1;
+  }
+
+  termBuffer_->eraseText(n);
+}
+
+// insert functions
+void FQTermDecode::insertStr() {
+  FQ_FUNC_TRACE("ansi", 8);
+  logParam();
+  
+  int n = param_[0];
+
+  if (n < 1) {
+    n = 1;
+  }
+
+  termBuffer_->insertSpaces(n);
+}
+
+// delete functions
+void FQTermDecode::deleteStr() {
+  FQ_FUNC_TRACE("ansi", 8);
+  logParam();
+  
+  int n = param_[0];
+
+  if (n < 1) {
+    n = 1;
+  }
+
+  termBuffer_->deleteText(n);
+}
+
+void FQTermDecode::eraseLine() {
+  FQ_FUNC_TRACE("ansi", 8);
+  logParam();
+  
+  switch (param_[0]) {
+    case 0:
+      termBuffer_->eraseToLineEnd();
+      break;
+    case 1:
+      termBuffer_->eraseToLineBegin();
+      break;
+    case 2:
+      termBuffer_->eraseEntireLine();
+      break;
+    default:
+      break;
+  }
+}
+
+void FQTermDecode::insertLine() {
+  FQ_FUNC_TRACE("ansi", 8);
+  logParam();
+
+  int n = param_[0];
+
+  if (n < 1) {
+    n = 1;
+  }
+
+  termBuffer_->insertLines(n);
+}
+
+void FQTermDecode::deleteLine() {
+  FQ_FUNC_TRACE("ansi", 8);
+  logParam();
+  
+  int n = param_[0];
+
+  if (n < 1) {
+    n = 1;
+  }
+
+  termBuffer_->deleteLines(n);
+}
+
+void FQTermDecode::eraseScreen() {
+  FQ_FUNC_TRACE("ansi", 8);
+  logParam();
+  
+  switch (param_[0]) {
+    case 0:
+      termBuffer_->eraseToTermEnd();
+      break;
+    case 1:
+      termBuffer_->eraseToTermBegin();
+      break;
+    case 2:
+      termBuffer_->eraseEntireTerm();
+      break;
+    case 3:
+      break;
+  }
+}
+
+void FQTermDecode::setAttr() {
+  FQ_FUNC_TRACE("ansi", 8);
+  logParam();
+  
+  // get all attributes of character
+  if (!paramIndex_ && param_[0] == 0) {
+    current_color_ = default_color_;
+    current_attr_ = default_attr_;
+
+    termBuffer_->setCurrentAttr(current_color_, current_attr_);
+    return ;
+  }
+
+  unsigned char cp = current_color_;
+  unsigned char ea = current_attr_;
+  for (int n = 0; n <= paramIndex_; n++) {
+    if (param_[n] / 10 == 4) {
+      // background color
+      cp = cp &~BGMASK;
+      cp += SETBG(param_[n] % 10);
+    } else if (param_[n] / 10 == 3) {
+      // front color
+      cp = cp &~FGMASK;
+      cp += SETFG(param_[n] % 10);
+    } else {
+      switch (param_[n]) {
+        case 0:
+          // attr off
+          cp = default_color_; //NO_COLOR;
+          ea = default_attr_; //NO_ATTR;
+          break;
+        case 1:
+          // bright
+          ea = SETBRIGHT(ea);
+          break;
+        case 2:
+          // dim
+          ea = SETDIM(ea);
+          break;
+        case 4:
+          // underline
+          ea = SETUNDERLINE(ea);
+          break;
+        case 5:
+          // blink
+          ea = SETBLINK(ea);
+          break;
+        case 7:
+          // reverse
+          ea = SETREVERSE(ea);
+          break;
+        case 8:
+          // invisible
+          ea = SETINVISIBLE(ea);
+          break;
+        default:
+          break;
+      }
+    }
+  }
+
+  current_color_ = cp;
+  current_attr_ = ea;
+
+  termBuffer_->setCurrentAttr(current_color_, current_attr_);
+}
+
+void FQTermDecode::setMode() {
+  FQ_FUNC_TRACE("ansi", 8);
+  logParam();
+
+  for (int i = 0; i <= paramIndex_; i++) {
+    int n = param_[i];
+    switch (n) {
+      case 4:
+        termBuffer_->setMode(FQTermBuffer::INSERT_MODE);
+        break;
+      case 20:
+        termBuffer_->setMode(FQTermBuffer::NEWLINE_MODE);
+        break;
+      default:
+        break;
+    }
+  }
+}
+
+void FQTermDecode::resetMode() {
+  //TODO: more modes here.
+  FQ_FUNC_TRACE("ansi", 8);
+  logParam();
+  
+  for (int i = 0; i <= paramIndex_; i++) {
+    int n = param_[i];
+    switch (n) {
+      case 4:
+        termBuffer_->resetMode(FQTermBuffer::INSERT_MODE);
+        break;
+      case 20:
+        termBuffer_->resetMode(FQTermBuffer::NEWLINE_MODE);
+        break;
+      default:
+        break;
+    }
+  }
+}
+
+void FQTermDecode::setDecPrivateMode() {
+  FQ_FUNC_TRACE("ansi", 8);
+  logParam();
+  
+  for (int i = 0; i <= paramIndex_; i++) {
+    int n = param_[i];
+    switch (n) {
+      case 1:
+        termBuffer_->setMode(FQTermBuffer::CURSOR_MODE);
+        break;
+      case 2:
+        termBuffer_->setMode(FQTermBuffer::ANSI_MODE);
+        break;
+      case 3:
+	  termBuffer_->setTermSize(132, 24);
+        break;
+      case 4:
+        // smooth scrolling mode
+        // nothing to do.
+        break;
+      case 5:
+        termBuffer_->setMode(FQTermBuffer::LIGHTBG_MODE);
+        break;
+      case 6:
+        termBuffer_->setMode(FQTermBuffer::ORIGIN_MODE);
+        break;
+      case 7:
+        termBuffer_->setMode(FQTermBuffer::AUTOWRAP_MODE);
+        break;
+      case 8:
+        termBuffer_->setMode(FQTermBuffer::AUTOREPEAT_MODE);
+        break;
+      case 9:
+        // Interlace mode
+        // nothing to do.
+        break;
+      case 1000:
+      case 1001:
+        emit mouseMode(true);
+        currentMode_[MODE_MouseX11] = true;
+        break;
+      default:
+        break;
+    }
+  }
+}
+
+void FQTermDecode::resetDecPrivateMode() {
+  FQ_FUNC_TRACE("ansi", 8);
+  logParam();
+  
+  for (int i = 0; i <= paramIndex_; i++) {
+    int n = param_[i];
+    switch (n) {
+      case 1:
+        termBuffer_->resetMode(FQTermBuffer::CURSOR_MODE);
+        break;
+      case 2:
+        termBuffer_->resetMode(FQTermBuffer::ANSI_MODE);
+        break;
+      case 3:
+        termBuffer_->setTermSize(80, 24);
+        break;
+      case 4:
+        // jump scrolling mode
+        // nothing to do.
+        break;
+      case 5:
+        termBuffer_->resetMode(FQTermBuffer::LIGHTBG_MODE);
+        break;
+      case 6:
+        termBuffer_->resetMode(FQTermBuffer::ORIGIN_MODE);
+        break;
+      case 7:
+        termBuffer_->resetMode(FQTermBuffer::AUTOWRAP_MODE);
+        break;
+      case 8:
+        termBuffer_->resetMode(FQTermBuffer::AUTOREPEAT_MODE);
+        break;
+      case 9:
+        // Interlace mode
+        // nothing to do.
+        break;
+      case 1000:
+      case 1001:
+        currentMode_[MODE_MouseX11] = false;
+        emit mouseMode(false);
+        break;
+      default:
+        break;
+    }
+  }
+}
+
+void FQTermDecode::setNumericKeypad() {
+  FQ_FUNC_TRACE("ansi", 8);
+  termBuffer_->setMode(FQTermBuffer::NUMERIC_MODE);
+}
+
+void FQTermDecode::setAppKeypad() {
+  FQ_FUNC_TRACE("ansi", 8);
+  termBuffer_->resetMode(FQTermBuffer::NUMERIC_MODE);
+}
+
+void FQTermDecode::saveMode() {
+  FQ_FUNC_TRACE("ansi", 8);
+  logParam();
+
+  for (int i = 0; i <= paramIndex_; i++) {
+    int n = param_[i];
+    switch (n) {
+      case 1000:
+      case 1001:
+        savedMode_[MODE_MouseX11] = currentMode_[MODE_MouseX11];
+        break;
+      default:
+        break;
+    }
+  }
+}
+
+void FQTermDecode::restoreMode() {
+  FQ_FUNC_TRACE("ansi", 8);
+  logParam();
+  
+  for (int i = 0; i <= paramIndex_; i++) {
+    int n = param_[i];
+    switch (n) {
+      case 1000:
+      case 1001:
+        currentMode_[MODE_MouseX11] = savedMode_[MODE_MouseX11];
+        emit mouseMode(currentMode_[MODE_MouseX11]);
+        break;
+      default:
+        break;
+    }
+  }
+}
+
+void FQTermDecode::fillScreen() {
+  FQ_FUNC_TRACE("ansi", 8);
+
+  termBuffer_->fillScreenWith('E');
+}
+
+void FQTermDecode::test() {
+  FQ_FUNC_TRACE("ansi", 8);
+}
+
+void FQTermDecode::logParam() const {
+  if (isParamAvailable_) {
+    for (int i = 8; i <= paramIndex_; ++i) {
+      FQ_TRACE("ansi", 8) << "Parameter[" << i << "] = " << param_[i];
+    }
+  } else {
+    FQ_TRACE("ansi", 8) << "No parameter.";
+  }
+}
+
+void FQTermDecode::onCaretChangeRow() {
+  leftToDecode_.clear();
+}
+
+void FQTermDecode::setTitle() {
+  if (!isParamAvailable_) {
+    return;
+  }
+  switch(param_[0])
+  {
+  case 0:
+    //icon and text
+    break;
+  case 1:
+    //icon
+    break;
+  case 2:
+    //text
+    emit onTitleSet(bbs2unicode(textParam_));
+    break;
+  case 46:
+    //log file
+    break;
+  case 50:
+    //font
+    break;
+  default:
+    break;
+  }
+}
+
+void FQTermDecode::collectText() {
+  FQ_FUNC_TRACE("ansi", 10);
+  if (textParam_.length() < 4096)
+    textParam_ += inputData_[dataIndex_];
+}
+
+void FQTermDecode::clearText() {
+  FQ_FUNC_TRACE("ansi", 10);
+  textParam_.clear();
+}
+
+
+
+
+}  // namespace FQTerm
+
+#include "fqterm_decode.moc"
diff --git a/src/terminal/internal/fqterm_decode.h b/src/terminal/internal/fqterm_decode.h
new file mode 100644
index 0000000..5f3f46d
--- /dev/null
+++ b/src/terminal/internal/fqterm_decode.h
@@ -0,0 +1,194 @@
+/***************************************************************************
+ *   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.               *
+ ***************************************************************************/
+
+#ifndef FQTERM_DECODE_H
+#define FQTERM_DECODE_H
+
+#include <QObject>
+#include "fqterm_text_line.h"
+
+namespace FQTerm {
+
+class FQTermDecode;
+class FQTermBuffer;
+class FQTermTelnet;
+
+// this for FSM
+typedef void(FQTermDecode:: *StateFunc)();
+
+struct StateOption {
+  int byte; // char value to look for; -1==end/default
+  StateFunc action;
+  StateOption *nextState;
+};
+
+class FQTermDecode: public QObject {
+  Q_OBJECT;
+ public:
+  FQTermDecode(FQTermBuffer *, int server_encoding);
+  ~FQTermDecode();
+
+
+  // translate data from telnet socket to our own buffer
+  // return how many bytes are processed.
+  int decode(const char *cstr, int length);
+
+  bool bellReceive() {
+    return isBell_;
+  }
+
+  void setServerEncoding(int encoding) {
+    server_encoding_ = encoding;
+  }
+
+
+  //signals:
+  //	void decodeFinished();
+ signals:
+  void mouseMode(bool);
+  void enqReceived();
+  void onTitleSet(const QString&);
+  public slots:
+    void onCaretChangeRow();
+ private:
+  // escape sequence actions
+  // you'd better see FSM structure array in FQTermDecode.cpp
+
+  void setAttr();
+  void setMargins();
+
+  // char screen functions
+  void deleteStr();
+  void deleteLine();
+  void insertStr();
+  void insertLine();
+  void eraseStr();
+  void eraseLine();
+  void eraseScreen();
+
+  // cursor functions
+  void saveCursor();
+  void restoreCursor();
+  void cursorPosition();
+
+  // Move cursor, stop at boundary.
+  void cursorLeft();
+  void cursorDown();
+  void cursorRight();
+  void cursorUp();
+
+  // Move cursor, scroll at boundary.
+  void moveCursorUp();
+  void moveCursorDown();
+  void nextLine();
+
+  void selectG0A();
+  void selectG0B();
+  void selectG00();
+  void selectG01();
+  void selectG02();
+
+  void selectG1A();
+  void selectG1B();
+  void selectG10();
+  void selectG11();
+  void selectG12();
+
+  // other escape sequence actions
+  void normalInput();
+
+  //title settings
+  void setTitle();
+  void collectText();
+  void clearText();
+
+  // action parameters
+  void clearParam();
+  void paramDigit();
+  void nextParam();
+
+  // non-printing characters
+  void cr(), lf(), ff(), bell(), tab(), bs(), del(), g0(), g1(), enq();
+
+  void addTabStop();
+  void clearTabStop();
+  
+  void setMode();
+  void resetMode();
+  void setDecPrivateMode();
+  void resetDecPrivateMode();
+  void setNumericKeypad();
+  void setAppKeypad();
+
+  void saveMode();
+  void restoreMode();
+
+  // video alignment test - fill screen with E's.
+  void fillScreen();
+
+  void test();
+
+ private:
+
+  bool isBell_;
+  // short currentAttr_, defaultAttr_;
+  unsigned char current_color_, default_color_;
+  unsigned char current_attr_, default_attr_;
+
+  // ********** ansi decoder states ****************
+  StateOption *current_state_;
+
+  struct VT100StateMachine {
+    static StateOption normal_state_[], esc_state_[], bracket_state_[];
+    static StateOption private_state_[], sharp_state_[];
+    static StateOption title_state_[], title_text_state_[];
+    static StateOption select_g0_charset_state_[], select_g1_charset_state_[];
+  };
+
+  static const char *getStateName(const StateOption *state);
+
+  void logParam() const;
+  
+
+  bool interrupt_decode_;
+
+  // ********** decoder		*****************
+  const char *inputData_;
+  int inputLength_, dataIndex_;
+
+  int paramIndex_, param_[30];
+  bool isParamAvailable_;
+
+  QByteArray textParam_;
+
+  bool savedMode_[30];
+  bool currentMode_[30];
+
+  FQTermBuffer *termBuffer_;
+  int server_encoding_;
+
+  QString bbs2unicode(const QByteArray &text);
+  int processInput(QByteArray& result);
+  QByteArray leftToDecode_;
+};
+
+}  // namespace FQTerm
+
+#endif  // FQTERM_DECODE_H
diff --git a/src/terminal/internal/fqterm_telnet.cpp b/src/terminal/internal/fqterm_telnet.cpp
new file mode 100644
index 0000000..2446b8a
--- /dev/null
+++ b/src/terminal/internal/fqterm_telnet.cpp
@@ -0,0 +1,1041 @@
+/***************************************************************************
+ *   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 <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+
+#include <QAbstractSocket>
+
+#include "fqterm.h"
+#include "fqterm_telnet.h"
+#include "fqterm_socket.h"
+
+#ifndef _NO_SSH_COMPILED
+#include "fqterm_ssh_socket.h"
+#endif
+
+/* TELNET Command Codes: */
+/* Hints: These NVT control characters are sent from client to server, So
+   the client side will not receive these commands */
+#define TCSB		(u_char)250	/* Start Subnegotiation		*/
+#define TCSE		(u_char)240	/* End Of Subnegotiation	*/
+#define TCNOP		(u_char)241	/* No Operation			*/
+#define TCDM		(u_char)242	/* Data Mark (for Sync)		*/
+#define TCBRK		(u_char)243	/* NVT Character BRK		*/
+#define TCIP		(u_char)244	/* Interrupt Process		*/
+#define TCAO		(u_char)245	/* Abort Output			*/
+#define TCAYT		(u_char)246	/* "Are You There?" Function	*/
+#define TCEC		(u_char)247	/* Erase Character		*/
+#define TCEL		(u_char)248	/* Erase Line			*/
+#define TCGA		(u_char)249	/* "Go Ahead" Function		*/
+#define TCWILL		(u_char)251	/* Desire/Confirm Will Do Option*/
+#define TCWONT		(u_char)252	/* Refusal To Do Option		*/
+#define TCDO		(u_char)253	/* Request To Do Option		*/
+#define TCDONT		(u_char)254	/* Request NOT To Do Option	*/
+#define TCIAC		(u_char)255	/* Interpret As Command Escape	*/
+
+/* Telnet Option Codes: */
+#define TOTXBINARY	(u_char)  0	/* TRANSMIT-BINARY option	*/
+#define TOECHO		(u_char)  1	/* ECHO Option			*/
+#define TONOGA		(u_char)  3	/* Suppress Go-Ahead Option	*/
+#define TOTERMTYPE	(u_char) 24	/* Terminal-Type Option		*/
+#define TONAWS		(u_char) 31	/* Window  Size */
+
+/* Network Virtual Printer Special Characters: */
+/* In normal situations, these characters will to translated into local
+   control characters , then pass to upper layer term. But in our situation,
+   we can pass them to term directly */
+
+#define VPLF		'\n'	/* Line Feed				*/
+#define VPCR		'\r'	/* Carriage Return			*/
+#define VPBEL		'\a'	/* Bell (attention signal)		*/
+#define VPBS		'\b'	/* Back Space				*/
+#define VPHT		'\t'	/* Horizontal Tab			*/
+#define VPVT		'\v'	/* Vertical Tab				*/
+#define VPFF		'\f'	/* Form Feed				*/
+
+/* Keyboard Command Characters: */
+
+/* Option Subnegotiation Constants: */
+#define TT_IS		0	/* TERMINAL_TYPE option "IS" command	*/
+#define TT_SEND		1	/* TERMINAL_TYPE option "SEND" command	*/
+
+/* Telnet Socket-Input FSM States: */
+#define TSDATA		 0	/* normal data processing		*/
+#define TSIAC		 1	/* have seen IAC			*/
+#define TSWOPT		 2	/* have seen IAC-{WILL/WONT}		*/
+#define TSDOPT		 3	/* have seen IAC-{DO/DONT}		*/
+#define TSSUBNEG	 4	/* have seen IAC-SB			*/
+#define TSSUBIAC	 5	/* have seen IAC-SB-...-IAC		*/
+// if any state added here, please update NTSTATES (currently 6).
+
+// Telnet Option Subnegotiation FSM States:
+#define SS_START	0		// initial state
+#define SS_TERMTYPE	1		// TERMINAL_TYPE option subnegotiation
+#define SS_END		2		// state after all legal input
+// if any state added here, please update NSSTATES (currently 3).
+
+#define FSINVALID	0xff		// an invalid state number
+#define TCANY		(NCHRS+1)	// match any character
+
+#define TINVALID	0xff		// an invalid transition index
+
+namespace FQTerm {
+
+struct fsm_trans FQTermTelnet::ttstab[] =  {
+  /* State	Input		Next State	Action	*/
+  /* ------	------		-----------	-------	*/
+  {
+    TSDATA, TCIAC, TSIAC, &FQTermTelnet::no_op
+  }, {
+    TSDATA, TCANY, TSDATA, &FQTermTelnet::ttputc
+  }, {
+    TSIAC, TCIAC, TSDATA, &FQTermTelnet::ttputc
+  }, {
+    TSIAC, TCSB, TSSUBNEG, &FQTermTelnet::no_op
+  }, {/* Telnet Commands */
+    TSIAC, TCNOP, TSDATA, &FQTermTelnet::no_op
+  }, {
+    TSIAC, TCDM, TSDATA, &FQTermTelnet::tcdm
+  }, {  /* Option Negotiation */
+    TSIAC, TCWILL, TSWOPT, &FQTermTelnet::recopt
+  }, {
+    TSIAC, TCWONT, TSWOPT, &FQTermTelnet::recopt
+  }, {
+    TSIAC, TCDO, TSDOPT, &FQTermTelnet::recopt
+  }, {
+    TSIAC, TCDONT, TSDOPT, &FQTermTelnet::recopt
+  }, {
+    TSIAC, TCANY, TSDATA, &FQTermTelnet::no_op
+  }, { /* Option Subnegotion */
+    TSSUBNEG, TCIAC, TSSUBIAC, &FQTermTelnet::no_op
+  }, {
+    TSSUBNEG, TCANY, TSSUBNEG, &FQTermTelnet::subopt
+  }, {
+    TSSUBIAC, TCSE, TSDATA, &FQTermTelnet::subend
+  }, {
+    TSSUBIAC, TCANY, TSSUBNEG, &FQTermTelnet::subopt
+  }, {
+    TSWOPT, TOECHO, TSDATA, &FQTermTelnet::do_echo
+  }, {
+    TSWOPT, TONOGA, TSDATA, &FQTermTelnet::do_noga
+  }, {
+    TSWOPT, TOTXBINARY, TSDATA, &FQTermTelnet::do_txbinary
+  }, {
+    TSWOPT, TCANY, TSDATA, &FQTermTelnet::do_notsup
+  },{
+    TSDOPT, TONAWS, TSDATA, &FQTermTelnet::will_naws
+  }, {
+    TSDOPT, TOTERMTYPE, TSDATA, &FQTermTelnet::will_termtype
+  }, {
+    TSDOPT, TOTXBINARY, TSDATA, &FQTermTelnet::will_txbinary
+  }, {
+    TSDOPT, TCANY, TSDATA, &FQTermTelnet::will_notsup
+  }, {
+    FSINVALID, TCANY, FSINVALID, &FQTermTelnet::tnabort
+  },
+};
+
+
+struct fsm_trans FQTermTelnet::substab[] =  {
+  /* State        Input           Next State      Action  */
+  /* ---------------------------------------------------- */
+  {
+    SS_START, TOTERMTYPE, SS_TERMTYPE, &FQTermTelnet::no_op
+  }, {
+    SS_START, TCANY, SS_END, &FQTermTelnet::no_op
+  }, {
+    SS_TERMTYPE, TT_SEND, SS_END, &FQTermTelnet::subtermtype
+  }, {
+    SS_TERMTYPE, TCANY, SS_END, &FQTermTelnet::no_op
+  }, {
+    SS_END, TCANY, SS_END, &FQTermTelnet::no_op
+  }, {
+    FSINVALID, TCANY, FSINVALID, &FQTermTelnet::tnabort
+  },
+};
+
+
+
+/*------------------------------------------------------------------------
+ * Constructor
+ *------------------------------------------------------------------------
+ */
+FQTermTelnet::FQTermTelnet(const QString &strTermType, int rows, int columns,
+                           int protocolType, int hostType, const char *sshuser, const char *sshpasswd)
+    : from_socket(),
+      to_ansi(),
+      from_ansi(),
+      to_socket(),
+      hostType_(hostType),
+      protocolType_(protocolType) {
+  term = new char[21];
+  memset(term, 0, sizeof(term));
+  // TODO: clean up, need???
+#ifdef WIN32
+  _snprintf(term, sizeof(term), "%s", strTermType.toLatin1().constData());
+#else
+  strncpy(term,strTermType.toLatin1(),20);
+#endif
+
+  wx = columns;
+  wy = rows;
+  wsize = 0;
+  done_naws = 0;
+  synching = 0;
+  doecho = 0;
+  sndbinary = 0;
+  rcvbinary = 0;
+  noga = 0;
+  termtype = 0;
+  naws = 0;
+  server_sent_do_naws = 0;
+  raw_size = 0;
+
+#ifndef _NO_SSH_COMPILED
+  if (protocolType == 1 || protocolType == 2) {
+    socket = new FQTermSSHSocket(columns, rows, strTermType, sshuser, sshpasswd);
+    FQ_VERIFY(connect(socket, SIGNAL(sshAuthOK()),
+		      this, SIGNAL(onSSHAuthOK())));
+  } else if (protocolType == 3) {
+    socket = new FQTermLocalSocket("");
+  } else {
+    socket = new FQTermTelnetSocket();
+  }
+#else
+  socket = new FQTermTelnetSocket();
+#endif
+
+  // connect signal and slots
+  FQ_VERIFY(connect(socket, SIGNAL(connected()), this, SLOT(connected())));
+  FQ_VERIFY(connect(socket, SIGNAL(readyRead()), this, SLOT(socketReadyRead())));
+  FQ_VERIFY(connect(socket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(showError(QAbstractSocket::SocketError))));
+  FQ_VERIFY(connect(socket, SIGNAL(hostFound()), this, SLOT(hostFound())));
+  FQ_VERIFY(connect(socket, SIGNAL(delayedCloseFinished()),
+                    this, SLOT(delayCloseFinished())));
+  FQ_VERIFY(connect(socket, SIGNAL(connectionClosed()), this, SLOT(closed())));
+  FQ_VERIFY(connect(socket, SIGNAL(socketState(int)), this, SIGNAL(TelnetState(int))));
+
+  FQ_VERIFY(connect(socket, SIGNAL(requestUserPwd(QString *, QString *, bool *)), 
+                    this, SIGNAL(requestUserPwd(QString *, QString *, bool *))));
+
+  FQ_VERIFY(connect(socket, SIGNAL(errorMessage(QString)), this, SIGNAL(errorMessage(QString))));
+
+  // Init telnet, mainly the FSMs
+  init_telnet();
+}
+
+/*------------------------------------------------------------------------
+ * destructor
+ *------------------------------------------------------------------------
+ */
+FQTermTelnet::~FQTermTelnet() {
+  // delete objects
+  delete [] term;
+  delete socket;
+}
+
+
+
+/*------------------------------------------------------------------------
+ * init_telnet
+ *------------------------------------------------------------------------
+ */
+void FQTermTelnet::init_telnet() {
+  fsmbuild(); /* setup FSMs */
+}
+
+
+/*------------------------------------------------------------------------
+ * fsmbuild - build the Finite State Machine data structures
+ *------------------------------------------------------------------------
+ */
+void FQTermTelnet::fsmbuild() {
+  fsminit(ttfsm, ttstab, NTSTATES);
+  ttstate = TSDATA;
+
+  fsminit(subfsm, substab, NSSTATES);
+  substate = SS_START;
+
+}
+
+/*------------------------------------------------------------------------
+ * fsminit - Finite State Machine initializer
+ *------------------------------------------------------------------------
+ */
+void FQTermTelnet::fsminit(u_char fsm[][NCHRS], struct fsm_trans ttab[], int
+                           nstates) {
+  struct fsm_trans *pt;
+  int sn, ti, cn;
+
+  for (cn = 0; cn < NCHRS; ++cn) {
+    for (ti = 0; ti < nstates; ++ti) {
+      fsm[ti][cn] = TINVALID;
+    }
+  }
+
+  for (ti = 0; ttab[ti].ft_state != FSINVALID; ++ti) {
+    pt = &ttab[ti];
+    sn = pt->ft_state;
+    if (pt->ft_char == TCANY) {
+      for (cn = 0; cn < NCHRS; ++cn) {
+        if (fsm[sn][cn] == TINVALID) {
+          fsm[sn][cn] = ti;
+        }
+      }
+    } else {
+      fsm[sn][pt->ft_char] = ti;
+    }
+  }
+
+  /* set all uninitialized indices to an invalid transition */
+  for (cn = 0; cn < NCHRS; ++cn) {
+    for (ti = 0; ti < nstates; ++ti) {
+      if (fsm[ti][cn] == TINVALID) {
+        fsm[ti][cn] = ti;
+      }
+    }
+  }
+
+}
+
+/*------------------------------------------------------------------------
+ * connect to host
+ *------------------------------------------------------------------------
+ */
+void FQTermTelnet::connectHost(const QString &hostname, quint16 portnumber) {
+  done_naws = 0;
+  synching = 0;
+  doecho = 0;
+  sndbinary = 0;
+  rcvbinary = 0;
+  noga = 0;
+  termtype = 0;
+  naws = 0;
+
+  socket->connectToHost(hostname, portnumber);
+  // host name resolving
+  emit TelnetState(TSRESOLVING);
+}
+
+void FQTermTelnet::windowSizeChanged(int x, int y) {
+  wx = x;
+  wy = y;
+  if (bConnected) {
+    if (hostType_ == 1 && (protocolType_ == 1 || protocolType_ == 2)) {
+      //This is a *nix host, with ssh connection.
+      socket->setTermSize(x, y);
+      return;
+    }
+    naws = 0;
+
+    QByteArray cmd(10, 0);
+    cmd[0] = (char)TCIAC;
+    cmd[1] = (char)TCSB;
+    cmd[2] = (char)TONAWS;
+    cmd[3] = (char)(short(wx) >> 8);
+    cmd[4] = (char)(short(wx) & 0xff);
+    cmd[5] = (char)(short(wy) >> 8);
+    cmd[6] = (char)(short(wy) & 0xff);
+    cmd[7] = (char)TCIAC;
+    cmd[8] = (char)TCSE;
+    socket->writeBlock(cmd);
+
+  }
+}
+
+/*------------------------------------------------------------------------
+ * set proxy
+ *-----------------------------------------------------------------------
+ */
+void FQTermTelnet::setProxy(int nProxyType, bool bAuth, const QString
+                            &strProxyHost, quint16 uProxyPort,
+                            const QString &strProxyUsr,
+                            const QString &strProxyPwd) {
+  socket->setProxy(nProxyType, bAuth, strProxyHost,
+                   uProxyPort, strProxyUsr, strProxyPwd);
+}
+
+/*------------------------------------------------------------------------
+ * close connection
+ *-----------------------------------------------------------------------
+ */
+
+void FQTermTelnet::close() {
+  socket->close();
+}
+
+/*------------------------------------------------------------------------
+ * SLOT connected
+ *------------------------------------------------------------------------
+ */
+void FQTermTelnet::connected() {
+  bConnected = true;
+  emit TelnetState(TSHOSTCONNECTED);
+}
+
+/*------------------------------------------------------------------------
+ * SLOT closed
+ *------------------------------------------------------------------------
+ */
+
+void FQTermTelnet::closed() {
+  bConnected = false;
+  emit TelnetState(TSCLOSED);
+}
+
+/*------------------------------------------------------------------------
+ * SLOT delayCloseFinished
+ *------------------------------------------------------------------------
+ */
+
+void FQTermTelnet::delayCloseFinished() {
+  bConnected = false;
+  emit TelnetState(TSCLOSEFINISH);
+}
+
+/*------------------------------------------------------------------------
+ * SLOT hostFound
+ *------------------------------------------------------------------------
+ */
+void FQTermTelnet::hostFound() {
+  emit TelnetState(TSHOSTFOUND);
+}
+
+/*------------------------------------------------------------------------
+ * SLOT error
+ *------------------------------------------------------------------------
+ */
+void FQTermTelnet::showError(QAbstractSocket::SocketError index) {
+
+  switch (index) {
+    case QAbstractSocket::ConnectionRefusedError: emit TelnetState(TSREFUSED);
+      break;
+    case QAbstractSocket::HostNotFoundError: emit TelnetState(TSHOSTNOTFOUND);
+      break;
+      //FIXME: am I right
+    case QAbstractSocket::SocketAccessError: emit TelnetState(TSREADERROR);
+      break;
+    case QAbstractSocket::RemoteHostClosedError: emit TelnetState(TSCLOSED);
+      break;
+    default:
+      emit TelnetState(TSERROR);
+      ;
+      break;
+  }
+
+}
+
+/*------------------------------------------------------------------------
+ * SLOOT socketReadyRead -
+ * 	when socket has data to upload, it send out readyRead() signal, it
+ * 	invokes this SLOT to read data in, do telnet decode job, and send out
+ * 	readyRead() SIGNAL to upper layer
+ *------------------------------------------------------------------------
+ */
+void FQTermTelnet::socketReadyRead() {
+  int nbytes, nread;
+  // TODO_UTF16: check this function.
+  
+  // get the data size
+  nbytes = socket->bytesAvailable();
+  if (nbytes <= 0) {
+    return ;
+  }
+
+  raw_size = nbytes;
+
+  //resize input buffer
+  from_socket.resize(0);
+
+  //read data from socket to from_socket
+  from_socket = socket->readBlock(nbytes);
+  nread = from_socket.size();
+  //do some checks
+  if (nread <= 0) {
+    FQ_TRACE("telnet", 8) << "Failed to read socket: " << nread << " <= 0.";
+    return ;
+  }
+  if (nread > nbytes) {
+    FQ_TRACE("telnet", 0) << "Overflow when reading socket: "
+                          << " nread = " << nread
+                          << " > nbytes = " << nbytes;
+    return ;
+  }
+
+  //resize output buffer
+  to_ansi.resize(2 *nread);
+  to_socket.resize(4 *nread);
+
+  rsize = 0;
+  wsize = 0;
+
+  // do telnet decode job...
+  struct fsm_trans *pt;
+  int i, ti;
+
+  u_char c;
+  for (i = 0; i < nread; ++i) {
+    c = (u_char)(from_socket[i]);
+    ti = ttfsm[ttstate][c];
+    pt = &ttstab[ti];
+    (this->*(pt->ft_action))((int)c);
+    ttstate = pt->ft_next;
+  }
+
+  // flush the to_socket buffer, it contain response to server
+  if (wsize > 0) {
+    socket->writeBlock(to_socket.left(wsize));
+    socket->flush();
+  }
+
+  /* send SIGNAL readyRead() with the size of data available*/
+  if (rsize > 0 || raw_size > 0) {
+    emit readyRead(rsize, raw_size);
+  }
+
+}
+
+int FQTermTelnet::raw_len() {
+  return raw_size;
+}
+
+/*------------------------------------------------------------------------
+ * actions
+ *------------------------------------------------------------------------
+ */
+int FQTermTelnet::read_raw(char *data, uint maxlen) {
+  //do some checks
+  if (data == 0) {
+    FQ_TRACE("telnet", 0) << "NULL pointer.";
+    return -1;
+  }
+  if ((long)maxlen < raw_size) {
+    /* we need all data be read out in one read */
+    FQ_TRACE("telnet", 0) << "The upper layer's buffer is too small.";
+    return -1;
+  }
+
+  //do it, memcpy( destination, source, size)
+  memcpy(data, from_socket.data(), raw_size);
+  return raw_size;
+}
+
+
+/*------------------------------------------------------------------------
+ * actions
+ *------------------------------------------------------------------------
+ */
+int FQTermTelnet::read(char *data, uint maxlen) {
+  //do some checks
+  if (data == 0) {
+    FQ_TRACE("telent", 0) << "NULL pointer.";
+    return -1;
+  }
+  if (maxlen < rsize) {
+    /* we need all data be read out in one read */
+    FQ_TRACE("telnet", 0) << "The upper layer's buffer is too small.";
+    return -1;
+  }
+
+  //do it, memcpy( destination, source, size)
+  memcpy(data, to_ansi.data(), rsize);
+
+  FQ_TRACE("telnet", 8) << "read " << rsize << " bytes:\n"
+                        << dumpHexString << std::string(data, rsize);
+
+  return rsize;
+}
+
+/*------------------------------------------------------------------------
+ * actions
+ *------------------------------------------------------------------------
+ */
+
+
+/*------------------------------------------------------------------------
+ * writeBlock
+ * 	write data from data-> to socket, the length of data is len
+ *------------------------------------------------------------------------
+ */
+int FQTermTelnet::write(const char *data, uint len) {
+  // TODO: accept data, (This seems can be removed????)
+  from_ansi.resize(len);
+  memcpy(from_ansi.data(), data, len);
+
+  // resize output buffer
+  to_socket.resize(2 *len);
+  wsize = 0;
+
+  // process keyboard input
+  // because we use GUI, there is no need to support a "command mode"
+  // So the keyboard-input FSM isnt' necessary.
+
+  uint i;
+
+  u_char c; // TODO: for gcc's happy :)
+  for (i = 0; i < len; ++i) {
+    c = (u_char)(from_ansi[i]);
+    soputc((int)c);
+  }
+
+  FQ_TRACE("telnet", 2) << "write " << len << " bytes:\n" 
+                        << dumpHexString << std::string(data, len);
+
+  //flush socket
+  socket->writeBlock(to_socket.left(wsize));
+  socket->flush();
+
+  emit TelnetState(TSWRITED);
+  return 0;
+}
+
+
+/*------------------------------------------------------------------------
+ * Trans functions
+ * All trans functions use from_socket, to_ansi, to_socket buffers, and
+ * rsize, wsize .
+ *------------------------------------------------------------------------
+ */
+
+/*------------------------------------------------------------------------
+ * tcdm - handle the telnet "DATA MARK" command (marks end of SYNCH)
+ *------------------------------------------------------------------------
+ */
+int FQTermTelnet::tcdm(int) {
+  if (synching > 0) {
+    synching--;
+  }
+  return 0;
+}
+
+/*------------------------------------------------------------------------
+ * rcvurg - receive urgent data input (indicates a telnet SYNCH)
+ *------------------------------------------------------------------------
+ */
+/*
+  int FQTermTelnet::rcvurg(int sig)
+  {
+  synching++;
+  }
+*/
+
+/*------------------------------------------------------------------------
+ * recopt - record option type
+ *------------------------------------------------------------------------
+ */
+
+int FQTermTelnet::recopt(int c) {
+  option_cmd = c;
+  return 0;
+}
+
+/*------------------------------------------------------------------------
+ * no_op - do nothing
+ *------------------------------------------------------------------------
+ */
+
+int FQTermTelnet::no_op(int) {
+  return 0;
+}
+
+
+/*------------------------------------------------------------------------
+ * do_echo - handle TELNET WILL/WON'T ECHO option
+ *------------------------------------------------------------------------
+ */
+int FQTermTelnet::do_echo(int c) {
+  if (doecho) {
+    if (option_cmd == TCWILL) {
+      return 0;
+    }
+    /* already doing ECHO		*/
+  } else if (option_cmd == TCWONT) {
+    return 0;
+  }
+  /* already NOT doing ECHO	*/
+
+  doecho = !doecho;
+
+  putc_down(TCIAC);
+  if (doecho) {
+    putc_down(TCDO);
+  } else {
+    putc_down(TCDONT);
+  }
+  putc_down((char)c);
+  return 0;
+}
+
+/*------------------------------------------------------------------------
+ * putc_down - put a character in to_socket buffer.
+ * wsize represent the number of bytes in to_socket buffer, and the buffer
+ * is addressed from 0, NOT 1.
+ *------------------------------------------------------------------------
+ */
+void FQTermTelnet::putc_down(u_char c) {
+  // check overflow
+  if ((long)(wsize + 1) > to_socket.size()) {
+    FQ_TRACE("telnet", 0) << "Buffer to_socket overflow.";
+    return ;
+  }
+  // put it in the buffer
+  //to_socket->replace(wsize, 1, (const char *)&c);
+  to_socket[wsize] = c;
+
+  wsize++;
+  return ;
+}
+
+/*------------------------------------------------------------------------
+ * do_notsup - handle an unsupported telnet "will/won't" option
+ *------------------------------------------------------------------------
+ */
+
+int FQTermTelnet::do_notsup(int c) {
+  putc_down(TCIAC);
+  putc_down(TCDONT);
+  putc_down((char)c);
+  return 0;
+}
+
+/*------------------------------------------------------------------------
+ * do_noga - don't do telnet Go-Ahead's
+ *------------------------------------------------------------------------
+ */
+
+int FQTermTelnet::do_noga(int c) {
+  if (noga) {
+    if (option_cmd == TCWILL) {
+      return 0;
+    }
+  } else if (option_cmd == TCWONT) {
+    return 0;
+  }
+
+  noga = !noga;
+
+  putc_down(TCIAC);
+  if (noga) {
+    putc_down(TCDO);
+  } else {
+    putc_down(TCDONT);
+  }
+  putc_down((char)c);
+  return 0;
+}
+
+/*------------------------------------------------------------------------
+ * do_txbinary - handle telnet "will/won't" TRANSMIT-BINARY option
+ *------------------------------------------------------------------------
+ */
+
+int FQTermTelnet::do_txbinary(int c) {
+  if (rcvbinary) {
+    if (option_cmd == TCWILL) {
+      return 0;
+    }
+  } else if (option_cmd == TCWONT) {
+    return 0;
+  }
+
+  rcvbinary = !rcvbinary;
+
+  putc_down(TCIAC);
+  if (rcvbinary) {
+    putc_down(TCDO);
+  } else {
+    putc_down(TCDONT);
+  }
+  putc_down((char)c);
+  return 0;
+}
+
+/*------------------------------------------------------------------------
+ * will_notsup - handle an unsupported telnet "do/don't" option
+ *------------------------------------------------------------------------
+ */
+
+int FQTermTelnet::will_notsup(int c) {
+  putc_down(TCIAC);
+  putc_down(TCWONT);
+  putc_down((char)c);
+  return 0;
+}
+
+/*------------------------------------------------------------------------
+ * will_txbinary - handle telnet "do/don't" TRANSMIT-BINARY option
+ *------------------------------------------------------------------------
+ */
+
+int FQTermTelnet::will_txbinary(int c) {
+  if (sndbinary) {
+    if (option_cmd == TCDO) {
+      return 0;
+    }
+  } else if (option_cmd == TCDONT) {
+    return 0;
+  }
+
+  sndbinary = !sndbinary;
+
+  putc_down(TCIAC);
+  if (sndbinary) {
+    putc_down(TCWILL);
+  } else {
+    putc_down(TCWONT);
+  }
+  putc_down((char)c);
+  return 0;
+}
+
+/*------------------------------------------------------------------------
+ * will_termtype - handle telnet "do/don't" TERMINAL-TYPE option
+ *------------------------------------------------------------------------
+ */
+int FQTermTelnet::will_termtype(int c) {
+  if (termtype) {
+    if (option_cmd == TCDO) {
+      return 0;
+    }
+  } else if (option_cmd == TCDONT) {
+    return 0;
+  }
+
+  termtype = !termtype;
+
+  putc_down(TCIAC);
+
+  if (termtype) {
+    putc_down(TCWILL);
+  } else {
+    putc_down(TCWONT);
+  }
+
+  putc_down((char)c);
+
+  // TODO: Do NOT use this assume! some foolish BBS not response the request
+  /* The client expects that once the remote application receives
+     terminal type information it will send control sequences for
+     the terminal, which cannot be sent using the NVT encoding, So
+     change the transfer mode to binary in both directions */
+  /* set up binary data path; send WILL, DO */
+  /*	if (termtype) {
+        option_cmd = TCWILL;
+        do_txbinary(TOTXBINARY);
+        option_cmd = TCDO;
+        will_txbinary(TOTXBINARY);
+        }
+  */
+  return 0;
+}
+
+int FQTermTelnet::will_naws(int c) {
+  if (naws) {
+    if (option_cmd == TCDO)
+      return 0;
+  } else if (option_cmd == TCDONT)
+    return 0;
+
+
+  naws = !naws;
+
+  putc_down(TCIAC);
+  if (naws)
+    putc_down(TCWILL);
+  else
+    putc_down(TCWONT);
+  putc_down((char)c);
+
+  putc_down(TCIAC);
+  putc_down(TCSB);
+  putc_down(TONAWS);
+  putc_down((char)(short(wx) >> 8));
+  putc_down((char)(short(wx)&0xff));
+  putc_down((char)(short(wy) >> 8));
+  putc_down((char)(short(wy)&0xff));
+  putc_down(((char)TCIAC));
+  putc_down((char)TCSE);
+
+  return 0;
+}
+
+/*------------------------------------------------------------------------
+ * subopt - do option subnegotiation FSM transitions
+ *------------------------------------------------------------------------
+ */
+int FQTermTelnet::subopt(int c) {
+  struct fsm_trans *pt;
+  int ti;
+
+  ti = subfsm[substate][c];
+  pt = &substab[ti];
+  (this->*(pt->ft_action))(c);
+  substate = pt->ft_next;
+  return 0;
+}
+
+/*------------------------------------------------------------------------
+ * subtermtype - do terminal type option subnegotation
+ *------------------------------------------------------------------------
+ */
+
+int FQTermTelnet::subtermtype(int) {
+  char *i;
+  /* have received IAC.SB.TERMTYPE.SEND */
+
+  putc_down(TCIAC);
+  putc_down(TCSB);
+  putc_down(TOTERMTYPE);
+  putc_down(TT_IS);
+
+  //write term type string
+  //fputs(term, sfp);
+  for (i = term; (*i) != '\000'; i++) {
+    putc_down(*i);
+  }
+
+  putc_down(TCIAC);
+  putc_down(TCSE);
+  return 0;
+}
+
+/*------------------------------------------------------------------------
+ * subend - end of an option subnegotiation; reset FSM
+ *------------------------------------------------------------------------
+ */
+
+int FQTermTelnet::subend(int) {
+  substate = SS_START;
+  return 0;
+}
+
+/*------------------------------------------------------------------------
+ * soputc - move a character from the keyboard to the socket
+ * 	    convert an character into the NVT encoding and send it
+ *	    through the socket to the server.
+ *------------------------------------------------------------------------
+ */
+
+int FQTermTelnet::soputc(int c) {
+  if (sndbinary) {
+    if (c == TCIAC) {
+      putc_down(TCIAC);
+    }
+    /* byte-stuff IAC	*/
+    putc_down(c);
+    return 0;
+  }
+
+  //c &= 0x7f;	/* 7-bit ASCII only ???*/
+  // Convert local special characters to NVT characters
+  /* TODO: // BBS don't need control signals
+     if (c == t_intrc || c == t_quitc) {	// Interrupt
+     putc_down(TCIAC);
+     putc_down(TCIP);
+     } else if (c == sg_erase) {		// Erase Char
+     putc_down(TCIAC);
+     putc_down(TCEC);
+     } else if (c == sg_kill) {		// Erase Line
+     putc_down(TCIAC);
+     putc_down(TCEL);
+     } else if (c == t_flushc) {		// Abort Output
+     putc_down(TCIAC);
+     putc_down(TCAO);
+     } else  */
+  putc_down((char)c);
+
+  return 0;
+}
+
+/*------------------------------------------------------------------------
+ * xputc - putc to upper layer with optional file scripting
+ *------------------------------------------------------------------------
+ */
+int FQTermTelnet::xputc_up(char ch) {
+  if ((long)(rsize + 1) > to_ansi.size()) {
+    FQ_TRACE("telnet", 0) << "Buffer to_ansi overflow.";
+    return - 1;
+  }
+  //to_ansi->replace(wsize, 1, &ch);
+  to_ansi[rsize] = u_char(ch);
+  rsize++;
+
+  return 0;
+}
+
+/*------------------------------------------------------------------------
+ * xfputs - fputs with optional file scripting
+ *------------------------------------------------------------------------
+ */
+int FQTermTelnet::xputs_up(char *str) {
+  /*if (scrfp)
+	fputs(str, scrfp);*/
+
+  char *i;
+  for (i = str; (*i) != '\000'; i++) {
+    xputc_up(*i);
+  }
+  return 0;
+}
+
+/*------------------------------------------------------------------------
+ * ttputc - print a single character on a Network Virtual Terminal
+ *------------------------------------------------------------------------
+ */
+int FQTermTelnet::ttputc(int c) {
+  if (rcvbinary) {
+    xputc_up((char)c); /* print uninterpretted	*/
+    return 0;
+  }
+  /* no data, if in SYNCH	*/
+  /*
+	if (synching)
+	return 0;
+  */
+  /* TODO: FQTermTelnet doesnot interpret NVT code, provide datas to upper
+     layer directly. So, <cr><lf>	will not be replaced with <lf>
+  */
+  xputc_up((char)c);
+
+  return 0;
+}
+
+/*------------------------------------------------------------------------
+ * invalid state reached, aborted
+ *------------------------------------------------------------------------
+ */
+int FQTermTelnet::tnabort(int) {
+  FQ_VERIFY(false); // "invalid state reached, aborted";
+  //	exit(-1);
+  return -1;
+}
+
+bool FQTermTelnet::readyForInput()
+{
+  return socket->readyForInput();
+}
+
+
+
+}  // namespace FQTerm
+
+#include "fqterm_telnet.moc"
diff --git a/src/terminal/internal/fqterm_telnet.h b/src/terminal/internal/fqterm_telnet.h
new file mode 100644
index 0000000..33e8c6e
--- /dev/null
+++ b/src/terminal/internal/fqterm_telnet.h
@@ -0,0 +1,195 @@
+/***************************************************************************
+ *   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.               *
+ ***************************************************************************/
+
+#ifndef FQTERM_TELNET_H
+#define FQTERM_TELNET_H
+
+#include <QAbstractSocket>
+#include <QByteArray>
+
+namespace FQTerm {
+
+#ifndef u_char
+#define u_char uchar
+#endif
+
+#define NTSTATES	 6	    // # of Telnet Socket-Input FSM States
+#define NSSTATES	3		// # of Telnet Option Subnegotiation FSM States
+#define NCHRS		256		// # of valid characters
+
+//  decleration
+class FQTermTelnet;
+// actionFunc is a pointer, point to a FQTermTelnet's func
+typedef int(FQTermTelnet:: *ptrActionFunc)(int c);
+
+//fsm struct
+struct fsm_trans {
+  u_char ft_state; // current state
+  short ft_char; // input character
+  u_char ft_next; // next state
+  ptrActionFunc ft_action; // action to take
+};
+
+
+/*------------------------------------------------------------------------------
+ *	FQTermTelnet class definition
+ *-------------------------------------------------------------------------------
+ */
+class FQTermSocket;
+
+// Telnet connection, a wrapper of socket.
+// It will translate raw NVT data from low level socket to ansi data,
+// and then upper level application can read it.
+// It also can send ascii data (0~127).
+class FQTermTelnet: public QObject {
+  Q_OBJECT;
+ public:
+  FQTermTelnet(const QString &termtype, int rows, int numColumns, int protocolType, int hostType, const
+              char *sshuser = NULL, const char *sshpasswd = NULL);
+  ~FQTermTelnet();
+
+  void setProxy(int nProxyType,  //0-no proxy; 1-wingate; 2-sock4; 3-socks5
+                bool bAuth,  // if authentation needed
+                const QString &strProxyHost, quint16 uProxyPort, const QString &strProxyUsr,
+                const QString &strProxyPwd);
+  void connectHost(const QString &hostname, quint16 portnumber);
+
+  // Read ansi data.
+  int read(char *data, uint maxlen);
+
+  // Write data raw data
+  int write(const char *data, uint len);
+
+  void close(); // User close the connection
+
+  int raw_len();
+  int read_raw(char *data, uint maxlen);
+
+  bool readyForInput();
+
+
+ signals:
+  void readyRead(int, int); // There are datas to be read out
+  void TelnetState(int); // The  state telnet, defined as TSXXXX in fqterm.h
+  void requestUserPwd(QString *user, QString *pwd, bool *isOK);
+  void errorMessage(QString);
+
+ public slots:
+  void windowSizeChanged(int, int);
+
+ private slots:
+  // Retrieve data from socket, translate NVT data to ansi data,
+  // then notify data ready.
+  void socketReadyRead();
+
+  void connected();
+  void showError(QAbstractSocket::SocketError);
+  void hostFound();
+  void delayCloseFinished();
+  void closed();
+ protected:
+  //init structure fsm
+  void init_telnet();
+  void fsmbuild();
+  void fsminit(u_char fsm[][NCHRS], struct fsm_trans ttab[], int nstates);
+
+  //actions
+  int tcdm(int);
+  int recopt(int);
+  int no_op(int);
+  int do_echo(int);
+  int do_notsup(int);
+  int do_noga(int);
+  int do_txbinary(int);
+  int will_notsup(int);
+  int will_txbinary(int);
+  int will_termtype(int);
+  int will_naws(int);
+  int subopt(int);
+  int subtermtype(int);
+  int subend(int);
+  int soputc(int);
+  int ttputc(int);
+  int tnabort(int);
+
+  //utility functions
+  int xputc_up(char);
+  int xputs_up(char*);
+  void putc_down(u_char);
+
+signals:
+  
+  void onSSHAuthOK();
+
+ private:
+  // Boolean Flags
+  char synching, doecho, sndbinary, rcvbinary;
+  char noga;
+  char naws;
+  char server_sent_do_naws;
+  u_char option_cmd; // has value WILL, WONT, DO, or DONT
+
+  char termtype; // non-zero if received "DO TERMTYPE"
+  char *term; // terminal name
+
+  /* // TODO: BBS don't need control signals
+  // Special keys - Terminal control characters
+  // need work...
+  static const char t_flushc=FQTERM_CTRL('S'); // Abort Output		i.e:(^S)
+  static const char t_intrc=FQTERM_CTRL('C');  // Interrupt		i.e:(^C)
+  static const char t_quitc=FQTERM_CTRL('\\'); // Quit			i.e:(^\)
+  static const char sg_erase=FQTERM_CTRL('?'); // Erase a character	i.e:(^?)
+  static const char sg_kill=FQTERM_CTRL('U');  // Kill a line		i.e:(^U)
+  */
+
+  // FSM stuffs
+  static struct fsm_trans ttstab[];
+  int ttstate;
+  u_char ttfsm[NTSTATES][NCHRS];
+
+  static struct fsm_trans substab[];
+  int substate;
+  u_char subfsm[NSSTATES][NCHRS];
+
+  // socket stuffs
+  FQTermSocket *socket;
+
+  //Pointers to internal buffers
+  //
+  //             |-->from_socket-->process-->to_ansi-->|
+  //  socket<--->                                      <---> ansi decode
+  //             |<---to_socket<--process<--from_ansi--|
+  //
+  QByteArray from_socket, to_ansi, from_ansi, to_socket;
+  uint rsize; // size of to_ansi buffer
+  uint wsize; // size of to_socket buffer
+
+  // for test
+  int wx, wy;
+  int done_naws;
+  bool bConnected;
+  int raw_size;
+  int hostType_;
+  int protocolType_;
+};
+
+}  // namespace FQTerm
+
+#endif  // FQTERM_TELNET_H
diff --git a/src/terminal/internal/fqterm_zmodem.cpp b/src/terminal/internal/fqterm_zmodem.cpp
new file mode 100644
index 0000000..afb99c9
--- /dev/null
+++ b/src/terminal/internal/fqterm_zmodem.cpp
@@ -0,0 +1,3056 @@
+/***************************************************************************
+ *   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); //Tranfer 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) {
+  register 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, register 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, register ZModem *info) {
+  if (c == 'O') {
+    if (++info->chrCount >= 2) {
+      return ZmDone;
+    }
+  } else {
+    info->chrCount = 0;
+  }
+  return 0;
+}
+
+
+
+int FQTermZmodem::DataChar(uchar c, register 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, register 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, register 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(register ZModem *info) {
+  register 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(register 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(register ZModem *info) {
+  return ZXmitHdrHex(ZACK, info->hdrData + 1, info);
+}
+
+
+int FQTermZmodem::GotAbort(register 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(register ZModem *info) {
+  info->InputState = Indata;
+  info->chrCount = 0;
+  return 0;
+}
+
+
+int FQTermZmodem::RetDone(ZModem *info) {
+
+
+  return ZmDone;
+}
+
+
+int FQTermZmodem::GotCommandData(register ZModem *info, int crcGood) {
+  /* TODO */
+  return 0;
+}
+
+
+int FQTermZmodem::GotStderrData(register 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(register 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 transfered: "
+                        << 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 doesnt 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); //Tranfer 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"
+
diff --git a/src/terminal/internal/fqterm_zmodem.h b/src/terminal/internal/fqterm_zmodem.h
new file mode 100644
index 0000000..bd1f4f4
--- /dev/null
+++ b/src/terminal/internal/fqterm_zmodem.h
@@ -0,0 +1,623 @@
+/***************************************************************************
+ *   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.               *
+ ***************************************************************************/
+
+#ifndef FQTERM_ZMODEM_H
+#define FQTERM_ZMODEM_H
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include <ctype.h>
+#include <time.h>
+#include <errno.h>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include <QByteArray>
+#include <QObject>
+#include <QTimer>
+#include <QFile>
+#include <QStringList>
+
+namespace FQTerm {
+
+/* PARAMETERS
+ *
+ * The following #defines control the behavior of the Zmodem
+ * package.  Note that these may be replaced with variables
+ * if you like.  For example, "#define DoInitRZ" may be replaced
+ * with "extern int DoInitRz" to use a global variable, or with
+ * "#define DoInitRZ (info->doInitRz)" to use a variable you
+ * add to the ZModem structure.
+ *
+ * It is assumed that the compiler is good enough to optimize
+ * "if( 0 )" and "if( 1 )" cases.  If not, you may wish to modify
+ * the source code to use #ifdef instead.
+ */
+
+#define DoInitRZ	1	/* send initial "rz\r" when transmitting */
+#define AllowCommand	0	/* allow remote end to execute commands */
+#define SendSample	1	/* sender can sample reverse channel */
+#define SendAttn	1	/* sender can be interrupted with Attn signal */
+#define ResponseTime	10	/* reasonable response time for sender to
+                             * respond to requests from receiver */
+#define SerialNo	1	/* receiver serial # */
+#define MaxNoise	64	/* max "noise" characters before transmission
+                         * pauses */
+#define MaxErrs		30	/* Max receive errors before cancel */
+#define AlwaysSinit	1	/* always send ZSINIT header, even if not
+                         * needed, this makes protocol more robust */
+
+#define SendOnly	0	/* compiles smaller version for send only */
+#define RcvOnly		0	/* compiles smaller version for receive only */
+
+enum enum_InputState {
+  Idle, Padding, Inhdr, Indata, Finish, Ysend, Yrcv
+};
+enum enum_Protocol {
+  XMODEM, YMODEM, ZMODEM
+};
+enum enum_Streaming {
+  Full, StrWindow, SlidingWindow, Segmented
+};
+enum enum_transferstate {
+  notransfer, transferstart, transferstop
+};
+
+
+/* Internal State */
+
+typedef enum zmstate {
+  /* receive */
+  RStart,  /* sent RINIT, waiting for ZFILE or SINIT */
+  RSinitWait,  /* got SINIT, waiting for data */
+  RFileName,  /* got ZFILE, waiting for filename & info */
+  RCrc,  /* got filename, want crc too */
+  RFile,  /* got filename, ready to read */
+  RData,  /* reading data */
+  RDataErr,  /* encountered error, ignoring input */
+  RFinish,  /* sent ZFIN, waiting for 'OO' */
+
+  /* transmit */
+  TStart,  /* waiting for INIT frame from other end */
+  TInit,  /* received INIT, sent INIT, waiting for ZACK */
+  FileWait,  /* sent file header, waiting for ZRPOS */
+  CrcWait,  /* sent file crc, waiting for ZRPOS */
+  Sending,  /* sending data subpackets, ready for int */
+  SendWait,  /* waiting for ZACK */
+  SendDone,  /* file finished, need to send EOF */
+  SendEof,  /* sent EOF, waiting for ZACK */
+  TFinish,  /* sent ZFIN, waiting for ZFIN */
+
+  /* general */
+  CommandData,  /* waiting for command data */
+  CommandWait,  /* waiting for command to execute */
+  StderrData,  /* waiting for stderr data */
+  Done,
+
+  /* x/ymodem transmit */
+  YTStart,  /* waiting for 'G', 'C' or NAK */
+  YTFile,  /* sent filename, waiting for ACK */
+  YTDataWait,  /* ready to send data, waiting for 'C' */
+  YTData,  /* sent data, waiting for ACK */
+  YTEOF,  /* sent eof, waiting for ACK */
+  YTFin,  /* sent null filename, waiting for ACK */
+
+  /* x/ymodem receive */
+  YRStart,  /* sent 'C', waiting for filename */
+  YRDataWait,  /* received filename, waiting for data */
+  YRData,  /* receiving filename or data */
+  YREOF /* received first EOT, waiting for 2nd */
+
+} ZMState;
+
+
+
+
+typedef struct {
+  int ifd; /* input fd, for use by caller's routines */
+  int ofd; /* output fd, for use by caller's routines */
+  FILE *file; /* file being transfered */
+  int zrinitflags; /* receiver capabilities, see below */
+  int zsinitflags; /* sender capabilities, see below */
+  char *attn; /* attention string, see below */
+  int timeout; /* timeout value, in seconds */
+  int bufsize; /* receive buffer size, bytes */
+  int packetsize; /* preferred transmit packet size */
+  int windowsize; /* max window size */
+
+  /* file attributes: read-only */
+
+  int filesRem, bytesRem;
+  uchar f0, f1, f2, f3; /* file flags */
+  int len, mode, fileType; /* file flags */
+  ulong date; /* file date */
+
+  /* From here down, internal to Zmodem package */
+
+  ZMState state; /* protocol internal state */
+  char *filename; /* filename */
+  char *rfilename; /* remote filename */
+  int crc32; /* use 32-bit crc */
+  int pktLen; /* length of this packet */
+  int DataType; /* input data type */
+  int PacketType; /* type of this packet */
+  int rcvlen;
+  int chrCount; /* chars received in current header/buffer */
+  int crcCount; /* crc characters remaining at end of buffer */
+  int canCount; /* how many CAN chars received? */
+  int noiseCount; /* how many noise chars received? */
+  int errorFlush; /* ignore incoming data because of error */
+  uchar *buffer; /* data buffer */
+  ulong offset; /* file offset */
+  ulong lastOffset; /* last acknowledged offset */
+  ulong zrposOffset; /* last offset specified w/zrpos */
+  int ylen, bufp; /* len,location of last Ymodem packet */
+  int fileEof; /* file eof reached */
+  int packetCount; /* # packets received */
+  int errCount; /* how many data errors? */
+  int timeoutCount; /* how many times timed out? */
+  int windowCount; /* how much data sent in current window */
+  int atSign; /* last char was '@' */
+  int lastCR; /* last char was CR */
+  int escCtrl; /* other end requests ctrl chars be escaped */
+  int escHibit; /* other end requests hi bit be escaped */
+  int escape; /* next character is escaped */
+  int interrupt; /* received attention signal */
+  int waitflag; /* next send should wait */
+  /* parser state */
+  //	  enum enum_InputState {Idle, Padding, Inhdr, Indata, Finish, Ysend, Yrcv} InputState ;
+  enum_InputState InputState;
+  //	  enum enum_Protocol {XMODEM, YMODEM, ZMODEM} Protocol ;
+  enum_Protocol Protocol;
+  uchar hdrData[9]; /* header type and data */
+  uchar fileFlags[4]; /* file xfer flags */
+  ulong crc; /* crc of incoming header/data */
+  //	  enum enum_Streaming {Full, StrWindow, SlidingWindow, Segmented} Streaming ;
+  enum_Streaming Streaming;
+} ZModem;
+
+
+
+/* ZRINIT flags.  Describe receiver capabilities */
+
+#define CANFDX	1	/* Rx is Full duplex */
+#define CANOVIO	2	/* Rx can overlap I/O */
+#define CANBRK	4	/* Rx can send a break */
+#define CANCRY	010	/* Rx can decrypt */
+#define CANLZW	020	/* Rx can uncompress */
+#define CANFC32	040	/* Rx can use 32-bit crc */
+#define ESCCTL	0100	/* Rx needs control chars escaped */
+#define ESC8	0200	/* Rx needs 8th bit escaped. */
+
+/* ZSINIT flags.  Describe sender capabilities */
+
+#define TESCCTL	0100	/* Tx needs control chars escaped */
+#define TESC8	0200	/* Tx needs 8th bit escaped. */
+
+
+/* ZFILE transfer flags */
+
+/* F0 */
+#define ZCBIN	1	/* binary transfer */
+#define ZCNL	2	/* convert NL to local eol convention */
+#define ZCRESUM	3	/* resume interrupted file xfer, or append to a
+                       growing file. */
+
+/* F1 */
+#define ZMNEWL	1	/* transfer if source newer or longer */
+#define ZMCRC	2	/* transfer if different CRC or length */
+#define ZMAPND	3	/* append to existing file, if any */
+#define ZMCLOB	4	/* replace existing file */
+#define ZMNEW	5	/* transfer if source is newer */
+#define ZMDIFF	6	/* transfer if dates or lengths different */
+#define ZMPROT	7	/* protect: transfer only if dest doesn't exist */
+#define ZMCHNG	8	/* change filename if destination exists */
+#define ZMMASK	037	/* mask for above. */
+#define ZMSKNOLOC 0200	/* skip if not present at Rx end */
+
+/* F2 */
+#define ZTLZW	1	/* lzw compression */
+#define ZTRLE	3	/* run-length encoding */
+
+/* F3 */
+#define ZCANVHDR 1	/* variable headers ok */
+#define ZRWOVR	4	/* byte position for receive window override/256 */
+#define ZXSPARS	64	/* encoding for sparse file ops. */
+
+
+
+/* ATTN string special characters.  All other characters sent verbose */
+
+#define ATTNBRK	'\335'	/* send break signal */
+#define ATTNPSE	'\336'	/* pause for one second */
+
+/* error code definitions [O] means link still open */
+
+#define ZmDone		-1	/* done */
+#define ZmErrInt	-2	/* internal error */
+#define ZmErrSys	-3	/* system error, see errno */
+#define ZmErrNotOpen	-4	/* communication channel not open */
+#define ZmErrCantOpen	-5	/* can't open file, see errno [O] */
+#define ZmFileTooLong	-6	/* remote filename too long [O] */
+#define ZmFileCantWrite	-7	/* could not write file, see errno */
+#define ZmDataErr	-8	/* too many data errors */
+#define ZmErrInitTo	-10	/* transmitter failed to respond to init req. */
+#define ZmErrSequence	-11	/* packet received out of sequence */
+#define ZmErrCancel	-12	/* cancelled by remote end */
+#define ZmErrRcvTo	-13	/* remote receiver timed out during transfer */
+#define ZmErrSndTo	-14	/* remote sender timed out during transfer */
+#define ZmErrCmdTo	-15	/* remote command timed out */
+
+
+
+/* ZModem character definitions */
+
+#define ZDLE	030	/* zmodem escape is CAN */
+#define ZPAD	'*'	/* pad */
+#define ZBIN	'A'	/* introduces 16-bit crc binary header */
+#define ZHEX	'B'	/* introduces 16-bit crc hex header */
+#define ZBIN32	'C'	/* introduces 32-bit crc binary header */
+#define ZBINR32	'D'	/* introduces RLE packed binary frame w/32-bit crc */
+#define ZVBIN	'a'	/* alternate ZBIN */
+#define ZVHEX	'b'	/* alternate ZHEX */
+#define ZVBIN32	'c'	/* alternate ZBIN32 */
+#define ZVBINR32 'd'	/* alternate ZBINR32 */
+#define ZRESC	0177	/* RLE flag/escape character */
+
+
+
+/* ZModem header type codes */
+
+#define ZRQINIT	0	/* request receive init */
+#define ZRINIT	1	/* receive init */
+#define ZSINIT	2	/* send init sequence, define Attn */
+#define ZACK	3	/* ACK */
+#define ZFILE	4	/* file name, from sender */
+#define ZSKIP	5	/* skip file command, from receiver */
+#define ZNAK	6	/* last packet was garbled */
+#define ZABORT	7	/* abort */
+#define ZFIN	8	/* finish session */
+#define ZRPOS	9	/* resume file from this position, from receiver */
+#define ZDATA	10	/* data packets to follow, from sender */
+#define ZEOF	11	/* end of file, from sender */
+#define ZFERR	12	/* fatal i/o error, from receiver */
+#define ZCRC	13	/* request for file crc, from receiver */
+#define ZCHALLENGE 14	/* "send this number back to me", from receiver */
+#define ZCOMPL	15	/* request is complete */
+#define ZCAN	16	/* other end cancelled with CAN-CAN-CAN-CAN-CAN */
+#define ZFREECNT 17	/* request for free bytes on filesystem */
+#define ZCOMMAND 18	/* command, from sending program */
+#define ZSTDERR	19	/* output this message to stderr */
+
+
+/* ZDLE escape sequences */
+
+
+#define ZCRCE	'h'	/* CRC next, frame ends, header follows */
+#define ZCRCG	'i'	/* CRC next, frame continues nonstop */
+#define ZCRCQ	'j'	/* CRC next, send ZACK, frame continues nonstop */
+#define ZCRCW	'k'	/* CRC next, send ZACK, frame ends */
+#define ZRUB0	'l'	/* translate to 0177 */
+#define ZRUB1	'm'	/* translate to 0377 */
+
+
+/* ascii definitions */
+
+#define SOH	1	/* ^A */
+#define STX	2	/* ^B */
+#define EOT	4	/* ^D */
+#define ACK	6	/* ^F */
+#define DLE	16	/* ^P */
+#define XON	17	/* ^Q */
+#define XOFF	19	/* ^S */
+#define NAK	21	/* ^U */
+#define SYN	22	/* ^V */
+#define CAN	24	/* ^X */
+
+
+/* state table entry.  There is one row of the table per
+ * possible state.  Each row is a row of all reasonable
+ * inputs for this state.  The entries are sorted so that
+ * the most common inputs occur first, to reduce search time
+ * Unexpected input is reported and ignored, as it might be
+ * caused by echo or something.
+ *
+ * Extra ZRINIT headers are the receiver trying to resync.
+ */
+class FQTermConfig;
+
+class FQTermZmodem;
+
+class FQTermTelnet;
+
+class FQTermFileDialog;
+
+typedef int(FQTermZmodem:: *ActionFunc)(ZModem*);
+
+typedef struct {
+  int type; /* frame type */
+  //	  int	(*func)(ZModem *) ;	/* transition function */
+  ActionFunc func;
+  int IFlush; /* flag: flush input first */
+  int OFlush; /* flag: flush output first */
+  ZMState newstate; /* new state.  May be overridden by func */
+} StateTable;
+
+//class FQTermTelnet;
+
+class FQTermZmodem: public QObject {
+  Q_OBJECT;
+ public:
+  FQTermZmodem(FQTermConfig *config, FQTermTelnet *netinterface, int type, int serverEncoding);
+  ~FQTermZmodem();
+
+  /* zmodem-supplied functions: */
+  int ZmodemTInit(ZModem *info);
+  int ZmodemTFile(char *file, char *rmtname, uint f0, uint f1, uint f2, uint f3,
+                  int filesRem, int bytesRem, ZModem *info);
+  int ZmodemTFinish(ZModem *info);
+  int ZmodemAbort(ZModem *info);
+  int ZmodemRInit(ZModem *info);
+  int ZmodemRcv(uchar *str, int len, ZModem *info, int &consumed_bytes);
+  int ZmodemAttention(ZModem *info);
+
+  int ZmodemReset(ZModem *info);
+
+  int YmodemTInit(ZModem *info);
+  int XmodemTInit(ZModem *info);
+  int YmodemRInit(ZModem *info);
+  int XmodemRInit(ZModem *info);
+
+  ulong FileCrc(char *name);
+  const char *sname(ZModem*);
+  const char *sname2(ZMState);
+
+  /* caller-supplied functions: */
+  int ZXmitChr(uchar c, ZModem *info);
+  int ZXmitStr(const uchar *str, int len, ZModem *info);
+  void ZIFlush(ZModem *info);
+  void ZOFlush(ZModem *info);
+  int ZAttn(ZModem *info);
+  void ZStatus(int type, int value, const char *status);
+  FILE *ZOpenFile(char *name, ulong crc, ZModem *info);
+
+  int ZWriteFile(uchar *buffer, int len, FILE *, ZModem*);
+  int ZCloseFile(ZModem *info);
+  void ZFlowControl(int onoff, ZModem *info);
+
+  /* end caller-supplied functions */
+
+  int ZXmitHdr(int type, int format, const uchar data[4], ZModem *info);
+  int ZXmitHdrHex(int type, const uchar data[4], ZModem *info);
+  int ZXmitHdrBin(int type, const uchar data[4], ZModem *info);
+  int ZXmitHdrBin32(int type, const uchar data[4], ZModem *info);
+  uchar *putZdle(uchar *ptr, uchar c, ZModem *info);
+  uchar *putHex(uchar *ptr, uchar c);
+
+  uchar *ZEnc4(ulong n);
+  ulong ZDec4(const uchar buf[4]);
+
+  int YrcvChar(char c, register ZModem *info);
+  int YrcvTimeout(register ZModem *info);
+  void ZIdleStr(uchar *buffer, int len, ZModem *info);
+
+  /* LEXICAL BOX: handle characters received from remote end.
+   * These may be header, data or noise.
+   *
+   * This section is a finite state machine for parsing headers
+   * and reading input data.  The info->chrCount field is effectively
+   * the state variable.
+   */
+
+  int FinishChar(char c, register ZModem *info);
+  int DataChar(uchar c, register ZModem *info);
+  int HdrChar(uchar c, register ZModem *info);
+  int IdleChar(uchar c, register ZModem *info);
+
+  int YsendChar(char c, ZModem *info);
+
+  int ZPF(ZModem *info);
+  int Ignore(ZModem *info);
+  int AnswerChallenge(register ZModem *info);
+  int GotAbort(register ZModem *info);
+  int GotCancel(ZModem *info);
+  int GotCommand(ZModem *info);
+  int GotStderr(register ZModem *info);
+  int RetDone(ZModem *info);
+  int GotCommandData(register ZModem *info, int crcGood);
+  int GotStderrData(register ZModem *info, int crcGood);
+
+  int GotFileName(ZModem *info, int crcGood);
+  int ResendCrcReq(ZModem *info);
+  int GotSinitData(ZModem *info, int crcGood);
+  int ResendRpos(ZModem *info);
+  int GotFileData(ZModem *info, int crcGood);
+  int SendRinit(ZModem *info);
+
+  int GotSinit(ZModem *info);
+  int GotFile(ZModem *info);
+  int GotFin(ZModem *info);
+  int GotData(ZModem *info);
+  int GotEof(ZModem *info);
+  int GotFreecnt(ZModem *info);
+  int GotFileCrc(ZModem *info);
+
+  int GotRinit(ZModem*);
+  int SendZSInit(ZModem*);
+  int SendFileCrc(ZModem*);
+  int GotSendAck(ZModem*);
+  int GotSendDoneAck(ZModem*);
+  int GotSendNak(ZModem*);
+  int GotSendWaitAck(ZModem*);
+  int SkipFile(ZModem*);
+  int GotSendPos(ZModem*);
+
+  int requestFile(ZModem *info, ulong crc);
+  void parseFileName(ZModem *info, char *fileinfo);
+  int fileError(ZModem *info, int type, int data);
+
+  int ProcessPacket(ZModem *info);
+  int rejectPacket(ZModem *info);
+  int acceptPacket(ZModem *info);
+
+  int calcCrc(uchar *str, int len);
+
+  char *strdup(const char *str);
+
+  int SendMoreFileData(ZModem *info);
+
+  uint rcvHex(uint i, char c);
+
+  int ZDataReceived(register ZModem *info, int crcGood);
+  int dataSetup(register ZModem *info);
+  int ZProtocol(register ZModem *info);
+
+  int ZXmitData(int, int, uchar, uchar *data, ZModem*);
+  int YXmitData(uchar *, int, ZModem*);
+
+  int YSendFilename(ZModem*);
+  int YSendData(ZModem*);
+  int YSendFin(ZModem*);
+
+  int sendFilename(ZModem*);
+  int SendFileData(ZModem*);
+  int ResendEof(ZModem*);
+
+  int OverAndOut(ZModem*);
+
+  int startFileData(ZModem *info);
+
+  void zmodemlog(const char *fmt, ...);
+
+  // interface function
+  // all not completed
+  void transferTimeOut(void*);
+  void upload(char*);
+  void uploadNext(char*);
+  void transferFinish();
+  void xferCancel();
+
+  /* data received from remote, pass it to Zmodem funcs */
+  void transferSendData(char *, int);
+  void TransferCancel();
+
+#if 1
+  static StateTable RStartOps[];
+  static StateTable RSinitWaitOps[];
+  static StateTable RFileNameOps[];
+  static StateTable RCrcOps[];
+  static StateTable RFileOps[];
+  static StateTable RDataOps[];
+  static StateTable RFinishOps[];
+
+
+  static StateTable TStartOps[];
+  static StateTable TInitOps[];
+  static StateTable FileWaitOps[];
+  static StateTable CrcWaitOps[];
+  static StateTable SendingOps[];
+  static StateTable SendDoneOps[];
+  static StateTable SendWaitOps[];
+  static StateTable SendEofOps[];
+  static StateTable TFinishOps[];
+
+  static StateTable CommandDataOps[];
+  static StateTable CommandWaitOps[];
+  static StateTable StderrDataOps[];
+  static StateTable DoneOps[];
+
+  static StateTable *tables[];
+  static const char *hdrnames[];
+#endif
+
+#if 0
+  StateTable RStartOps[];
+  StateTable RSinitWaitOps[];
+  StateTable RFileNameOps[];
+  StateTable RCrcOps[];
+  StateTable RFileOps[];
+  StateTable RDataOps[];
+  StateTable RFinishOps[];
+
+
+  StateTable TStartOps[];
+  StateTable TInitOps[];
+  StateTable FileWaitOps[];
+  StateTable CrcWaitOps[];
+  StateTable SendingOps[];
+  StateTable SendDoneOps[];
+  StateTable SendWaitOps[];
+  StateTable SendEofOps[];
+  StateTable TFinishOps[];
+
+  StateTable CommandDataOps[];
+  StateTable CommandWaitOps[];
+  StateTable StderrDataOps[];
+  StateTable DoneOps[];
+
+  StateTable *tables[];
+  char *hdrnames[];
+#endif
+  FQTermTelnet *telnet_;
+  FQTermConfig *config_;
+  //  Dialog
+  //	QDialog *zmodemDialog, uploadListDialog;
+
+  bool sending;
+
+  enum_transferstate transferstate;
+
+  ZModem info;
+
+  //  connection type, e.g. telnet or ssh , 0=telnet, 1=ssh
+
+  int connectionType;
+
+  // Timer
+  QTimer *zmodemTimer;
+
+  //log file
+  FILE *zmodemlogfile;
+
+  int zerrno;
+  uchar lastPullByte;
+
+  QStringList strFileList;
+  QStringList::Iterator itFile;
+
+  int serverEncodingID;
+
+  QString lastDownloadedFilename_;
+
+  // end Member
+ signals:
+  void ZmodemState(int, int, const char *);
+
+ public slots:
+  void zmodemCancel();
+  int ZmodemTimeout();
+};
+
+}  // namespace FQTerm
+
+#endif  // FQTERM_ZMODEM_H