FSh.cpp

Go to the documentation of this file.

/*

$Header$

*/

#include "Core.h"
#include "TcpConnection.h"
#include "Registry.h"

#include "FSh.h"

// Protected methods.

FSh::FSh(const ValueList &params) : Service<FSh>(params),
  _connection(NULL),
  _getLine(NULL),
  _telnet(NULL),
  _logErrors(false),
  _logErrorsRe("", RE_Options().set_caseless(true)),
  _logWarnings(false),
  _logWarningsRe("", RE_Options().set_caseless(true)),
  _logDebug(false),
  _logDebugRe("", RE_Options().set_caseless(true))
{
  BIND(colors__on);

  BIND(log__errors__on);
  BIND(log__errors__regexp);
  BIND(log__warnings__on);
  BIND(log__warnings__regexp);
  BIND(log__debug__on);
  BIND(log__debug__regexp);

  int res;

  if (params.size() < 1) {
    failure(ERROR(SERVICE_MSG_INVALID_PARAMS, CSTRING(NAME())));
    return;
  }

  ValueObject *obj = queryInterface<ValueObject>(params[0]);
  if (!obj || !(_connection = queryInterface<TcpConnection>(obj->get()))) {
    failure(ERROR(SERVICE_MSG_INVALID_PARAM_TYPE, CSTRING(NAME())));
    return;
  }

  if (FAILED(res = start())) {
    failure(ERROR_BACKTRACE(res));
    return;
  }
}

FSh::~FSh()
{
  if (_telnet)
    delete _telnet;
  if (_getLine)
    delete _getLine;
  if (_connection)
    delete _connection;
}

// Private methods.

int FSh::start()
{
  String re;
  bool yes;
  int res;

  if (FAILED(res = REGISTRY_GET(FSh, log__errors__on, yes, this)))
    return ERROR_BACKTRACE(res);
  if (FAILED(res = setLogErrorsEnabled(yes)))
    return ERROR_BACKTRACE(res);

  if (FAILED(res = REGISTRY_GET(FSh, log__errors__regexp, re, this)))
    return ERROR_BACKTRACE(res);
  if (FAILED(res = setLogErrorsRegexp(re)))
    return ERROR_BACKTRACE(res);

  if (FAILED(res = REGISTRY_GET(FSh, log__warnings__on, yes, this)))
    return ERROR_BACKTRACE(res);
  if (FAILED(res = setLogWarningsEnabled(yes)))
    return ERROR_BACKTRACE(res);

  if (FAILED(res = REGISTRY_GET(FSh, log__warnings__regexp, re, this)))
    return ERROR_BACKTRACE(res);
  if (FAILED(res = setLogWarningsRegexp(re)))
    return ERROR_BACKTRACE(res);

  if (FAILED(res = REGISTRY_GET(FSh, log__debug__on, yes, this)))
    return ERROR_BACKTRACE(res);
  if (FAILED(res = setLogDebugEnabled(yes)))
    return ERROR_BACKTRACE(res);

  if (FAILED(res = REGISTRY_GET(FSh, log__debug__regexp, re, this)))
    return ERROR_BACKTRACE(res);
  if (FAILED(res = setLogDebugRegexp(re)))
    return ERROR_BACKTRACE(res);

  if (FAILED(res = _connection->setNonBlock()))
    return ERROR_BACKTRACE(res);

  if (!(_getLine = new FShGetLine(this)))
    return ERROR(MSG_OBJECT_CANNOT_CREATE, "FShGetLine");
  if (FAILED(res = _getLine->failureCode()))
    return ERROR_BACKTRACE(res);

  if (!(_telnet = new Telnet(_connection, _getLine)))
    return ERROR(MSG_OBJECT_CANNOT_CREATE, "Telnet");
  if (FAILED(res = _telnet->failureCode()))
    return ERROR_BACKTRACE(res);

  if (FAILED(res = _telnet->iac(DO, TELOPT_NAWS, 0, 0, 0, 0)))
    return ERROR_BACKTRACE(res);
  if (FAILED(res = _telnet->iac(DO, TELOPT_TTYPE, 0, 0, 0, 0)))
    return ERROR_BACKTRACE(res);
  if (FAILED(res = _telnet->iac(WILL, TELOPT_ECHO, 0, 0, 0, 0)))
    return ERROR_BACKTRACE(res);
  if (FAILED(res = _telnet->iac(WILL, TELOPT_SGA, 0, 0, 0, 0)))
    return ERROR_BACKTRACE(res);

  if (FAILED(res = CONNECT(_connection, dataReady, this, FSh, dataReady)))
    return ERROR_BACKTRACE(res);

  if (FAILED(res = CONNECT(_connection, dead, this, FSh, die)))
    return ERROR_BACKTRACE(res);

  if (FAILED(res = CONNECT(colors__on(), set, this, FSh, setColorEnabled)))
    return ERROR_BACKTRACE(res);

  if (FAILED(res = CONNECT(log__errors__on(), set, this, FSh, setLogErrorsEnabled)))
    return ERROR_BACKTRACE(res);
  if (FAILED(res = CONNECT(log__errors__regexp(), set, this, FSh, setLogErrorsRegexp)))
    return ERROR_BACKTRACE(res);

  if (FAILED(res = CONNECT(log__warnings__on(), set, this, FSh, setLogWarningsEnabled)))
    return ERROR_BACKTRACE(res);
  if (FAILED(res = CONNECT(log__warnings__regexp(), set, this, FSh, setLogWarningsRegexp)))
    return ERROR_BACKTRACE(res);

  if (FAILED(res = CONNECT(log__debug__on(), set, this, FSh, setLogDebugEnabled)))
    return ERROR_BACKTRACE(res);
  if (FAILED(res = CONNECT(log__debug__regexp(), set, this, FSh, setLogDebugRegexp)))
    return ERROR_BACKTRACE(res);

  if (FAILED(res = CONNECT(ERR(), error, this, FSh, logError)))
    return ERROR_BACKTRACE(res);
  if (FAILED(res = CONNECT(ERR(), warning, this, FSh, logWarning)))
    return ERROR_BACKTRACE(res);
  if (FAILED(res = CONNECT(ERR(), debug, this, FSh, logDebug)))
    return ERROR_BACKTRACE(res);

  return OK;
}

int FSh::dataReady()
{
  uint8_t ch;
  int res;

  if (FAILED(res = _connection->read((char *)&ch, sizeof(ch), 1))) {
    ERROR_BACKTRACE(res);
    if (FAILED(res = kill()))
      ERROR_BACKTRACE(res);
    return res;
  }

  if (ch == IAC) {
    int readCnt;

    if (FAILED(res = _telnet->parse(&readCnt)))
      return ERROR_BACKTRACE(res);
  } else
      if (FAILED(res = _getLine->pushChar(ch)))
        return ERROR_BACKTRACE(res);

  return OK;
}

int FSh::die()
{
  int res;
  if (FAILED(res = CORE()->kill(this)))
    return ERROR_BACKTRACE(res);
  return OK;
}

int FSh::setColorEnabled(const bool &yes)
{
  int res;
  if (FAILED(res = String::setColorEnabled(yes)))
    return ERROR_BACKTRACE(res);

  return OK;
}

int FSh::setLogErrorsEnabled(const bool &yes)
{
  _logErrors = yes;
  return OK;
}

int FSh::setLogErrorsRegexp(const String &re)
{
  if (_logErrorsRe.pattern() != re)
    _logErrorsRe = re;
  return OK;
}

int FSh::setLogWarningsEnabled(const bool &yes)
{
  _logWarnings = yes;
  return OK;
}

int FSh::setLogWarningsRegexp(const String &re)
{
  if (_logWarningsRe.pattern() != re)
    _logWarningsRe = re;
  return OK;
}

int FSh::setLogDebugEnabled(const bool &yes)
{
  _logDebug = yes;
  return OK;
}

int FSh::setLogDebugRegexp(const String &re)
{
  if (_logDebugRe.pattern() != re)
    _logDebugRe = re;
  return OK;
}

int FSh::logError(const String &timestamp, const String &fileName,
                  const unsigned int lineNum, const String &functionName, const String &msg)
{
  if (!_logErrors)
    return OK;
#ifdef DEBUG_MODE
  String str;
  str.sprintf("%s [%s] [file: %s, line: %u, function: %s]: %s%s",
             CSTRING(COLOR_ERROR()), CSTRING(timestamp),
             CSTRING(fileName), lineNum, CSTRING(functionName), CSTRING(msg),
             String::eol());
#else
  String str;
  str.sprintf("%s: %s%s",
             CSTRING(COLOR_ERROR()), CSTRING(msg),
             String::eol());
#endif
  int res;
  if (_logErrorsRe.PartialMatch(str))
    if (FAILED(res = FORTH()->printf(CSTRING(str))))
      return ERROR_BACKTRACE(res);
  return OK;
}

int FSh::logWarning(const String &timestamp, const String &fileName,
                    const unsigned int lineNum, const String &functionName, const String &msg)
{
  if (!_logWarnings)
    return OK;
#ifdef DEBUG_MODE
  String str;
  str.sprintf("%s [%s] [file: %s, line: %u, function: %s]: %s%s",
             CSTRING(COLOR_WARNING()), CSTRING(timestamp),
             CSTRING(fileName), lineNum, CSTRING(functionName), CSTRING(msg),
             String::eol());
#else
  String str;
  str.sprintf("%s: %s%s",
             CSTRING(COLOR_WARNING()), CSTRING(msg),
             String::eol());
#endif
  int res;
  if (_logWarningsRe.PartialMatch(str))
    if (FAILED(res = FORTH()->printf(CSTRING(str))))
      return ERROR_BACKTRACE(res);
  return OK;
}

int FSh::logDebug(const String &timestamp, const String &fileName,
                  const unsigned int lineNum, const String &functionName, const String &msg)
{
  if (!_logDebug)
    return OK;
#ifdef DEBUG_MODE
  String str;
  str.sprintf("%s [%s] [file: %s, line: %u, function: %s]: %s%s",
             CSTRING(COLOR_DEBUG()), CSTRING(timestamp),
             CSTRING(fileName), lineNum, CSTRING(functionName), CSTRING(msg),
             String::eol());
#else
  String str;
  str.sprintf("%s: %s%s",
             CSTRING(COLOR_DEBUG()), CSTRING(msg),
             String::eol());
#endif
  int res;
  if (_logDebugRe.PartialMatch(str))
    if (FAILED(res = FORTH()->printf(CSTRING(str))))
      return ERROR_BACKTRACE(res);
  return OK;
}

---