예제 #1
0
ActionItemPtr
ActionLog::AddRemoteAction(shared_ptr<Data> actionData)
{
  Name name = actionData->getName();
  // action name: /<device_name>/<appname>/action/<shared-folder>/<action-seq>

  uint64_t seqno = name.get(-1).toNumber();
  std::string sharedFolder = name.get(-2).toUri();

  if (sharedFolder != m_sharedFolderName) {
    _LOG_ERROR("Action doesn't belong to this shared folder");
    return ActionItemPtr();
  }

  if (name.get(-3).toUri() != "action") {
    _LOG_ERROR("not an action");
    return ActionItemPtr();
  }

  if (name.get(-4) != m_appName) {
    _LOG_ERROR("Action doesn't belong to this application");
    return ActionItemPtr();
  }

  Name deviceName = name.getSubName(0, name.size() - 4);

  _LOG_DEBUG("From [" << name << "] extracted deviceName: " << deviceName << ", sharedFolder: "
                      << sharedFolder
                      << ", seqno: "
                      << seqno);

  return AddRemoteAction(deviceName, seqno, actionData);
}
예제 #2
0
bool MySQLConnection::_Query(PreparedStatement* stmt, MYSQL_RES **pResult, uint64* pRowCount, uint32* pFieldCount)
{
    if (!m_Mysql)
        return false;

    uint32 index = stmt->m_index;
    {
        MySQLPreparedStatement* m_mStmt = GetPreparedStatement(index);
        ASSERT(m_mStmt);            // Can only be null if preparation failed, server side error or bad query
        m_mStmt->m_stmt = stmt;     // Cross reference them for debug output
        stmt->m_stmt = m_mStmt;     /// @todo Cleaner way

        stmt->BindParameters();

        MYSQL_STMT* msql_STMT = m_mStmt->GetSTMT();
        MYSQL_BIND* msql_BIND = m_mStmt->GetBind();

        boost::timer _s;

        if (mysql_stmt_bind_param(msql_STMT, msql_BIND))
        {
            uint32 lErrno = mysql_errno(m_Mysql);
            _LOG_ERROR(LOG_FILTER_SQL, "SQL(p): %s\n [ERROR]: [%u] %s", m_mStmt->getQueryString(m_queries[index].first).c_str(), lErrno, mysql_stmt_error(msql_STMT));

            if (_HandleMySQLErrno(lErrno))  // If it returns true, an error was handled successfully (i.e. reconnection)
                return _Query(stmt, pResult, pRowCount, pFieldCount);       // Try again

            m_mStmt->ClearParameters();
            return false;
        }

        if (mysql_stmt_execute(msql_STMT))
        {
            uint32 lErrno = mysql_errno(m_Mysql);
            _LOG_ERROR(LOG_FILTER_SQL, "SQL(p): %s\n [ERROR]: [%u] %s",
                m_mStmt->getQueryString(m_queries[index].first).c_str(), lErrno, mysql_stmt_error(msql_STMT));

            if (_HandleMySQLErrno(lErrno))  // If it returns true, an error was handled successfully (i.e. reconnection)
                return _Query(stmt, pResult, pRowCount, pFieldCount);      // Try again

            m_mStmt->ClearParameters();
            return false;
        }

        _LOG_DEBUG(LOG_FILTER_SQL, "[%u ms] SQL(p): %s",(uint32)_s.elapsed(), m_mStmt->getQueryString(m_queries[index].first).c_str());

        m_mStmt->ClearParameters();

        *pResult = mysql_stmt_result_metadata(msql_STMT);
        *pRowCount = mysql_stmt_num_rows(msql_STMT);
        *pFieldCount = mysql_stmt_field_count(msql_STMT);

        return true;

    }
}
예제 #3
0
bool MySQLConnection::_HandleMySQLErrno(uint32 errNo)
{
    switch (errNo)
    {
        case CR_SERVER_GONE_ERROR:
        case CR_SERVER_LOST:
        case CR_INVALID_CONN_HANDLE:
        case CR_SERVER_LOST_EXTENDED:
        {
            m_reconnecting = true;
            uint64 oldThreadId = mysql_thread_id(GetHandle());
            mysql_close(GetHandle());
            if (this->Open())                           // Don't remove 'this' pointer unless you want to skip loading all prepared statements....
            {
                _LOG_INFO(LOG_FILTER_SQL, "Connection to the MySQL server is active.");
                if (oldThreadId != mysql_thread_id(GetHandle()))
                    _LOG_INFO(LOG_FILTER_SQL, "Successfully reconnected to %s @%s:%s (%s).",
                        m_connectionInfo.database.c_str(), m_connectionInfo.host.c_str(), m_connectionInfo.port_or_socket.c_str(),
                            (m_connectionFlags & CONNECTION_ASYNC) ? "asynchronous" : "synchronous");

                m_reconnecting = false;
                return true;
            }

            uint32 lErrno = mysql_errno(GetHandle());   // It's possible this attempted reconnect throws 2006 at us. To prevent crazy recursive calls, sleep here.
            boost::thread::sleep(boost::get_system_time()+boost::posix_time::seconds(3));                           // Sleep 3 seconds
            return _HandleMySQLErrno(lErrno);           // Call self (recursive)
        }

        case ER_LOCK_DEADLOCK:
            return false;    // Implemented in TransactionTask::Execute and DatabaseWorkerPool<T>::DirectCommitTransaction
        // Query related errors - skip query
        case ER_WRONG_VALUE_COUNT:
        case ER_DUP_ENTRY:
            return false;

        // Outdated table or database structure - terminate core
        case ER_BAD_FIELD_ERROR:
        case ER_NO_SUCH_TABLE:
            _LOG_ERROR(LOG_FILTER_SQL, "Your database structure is not up to date. Please make sure you've executed all queries in the sql/updates folders.");
            boost::thread::sleep(boost::get_system_time()+boost::posix_time::seconds(10));            
            std::abort();
            return false;
        case ER_PARSE_ERROR:
            _LOG_ERROR(LOG_FILTER_SQL, "Error while parsing SQL. Core fix required.");
            boost::thread::sleep(boost::get_system_time()+boost::posix_time::seconds(10));            
            std::abort();
            return false;
        default:
            _LOG_ERROR(LOG_FILTER_SQL, "Unhandled MySQL errno %u. Unexpected behaviour possible.", errNo);
            return false;
    }
}
예제 #4
0
void
InterestValidationState::fail(const ValidationError& error)
{
  _LOG_TRACE(error);
  try {
    failureCallback_(interest_, error);
  } catch (const std::exception& ex) {
    _LOG_ERROR("InterestValidationState::fail: Error in failureCallback: " << ex.what());
  } catch (...) {
    _LOG_ERROR("InterestValidationState::fail: Error in failureCallback.");
  }
  setOutcome(false);
}
예제 #5
0
void
DataValidationState::bypassValidation()
{
  _LOG_TRACE("Signature verification bypassed for data `" << data_.getName()
             << "`");
  try {
    successCallback_(data_);
  } catch (const std::exception& ex) {
    _LOG_ERROR("DataValidationState::fail: Error in successCallback: " << ex.what());
  } catch (...) {
    _LOG_ERROR("DataValidationState::fail: Error in successCallback.");
  }
  setOutcome(true);
}
예제 #6
0
bool MySQLConnection::Execute(const char* sql)
{
    if (!m_Mysql)
        return false;

    {
		boost::timer _s;
        

        if (mysql_query(m_Mysql, sql))
        {
            uint32 lErrno = mysql_errno(m_Mysql);

            _LOG_INFO(LOG_FILTER_SQL, "SQL: %s", sql);
            _LOG_ERROR(LOG_FILTER_SQL, "[%u] %s", lErrno, mysql_error(m_Mysql));

            if (_HandleMySQLErrno(lErrno))  // If it returns true, an error was handled successfully (i.e. reconnection)
                return Execute(sql);       // Try again

            return false;
        }
        else
            _LOG_DEBUG(LOG_FILTER_SQL, "[%u ms] SQL: %s",(uint32) _s.elapsed(), sql);
    }

    return true;
}
예제 #7
0
void
InterestValidationState::bypassValidation()
{
  _LOG_TRACE("Signature verification bypassed for interest `" <<
             interest_.getName() << "`");
  for (size_t i = 0; i < successCallbacks_.size(); ++i) {
    try {
      successCallbacks_[i](interest_);
    } catch (const std::exception& ex) {
      _LOG_ERROR("InterestValidationState::fail: Error in successCallback: " << ex.what());
    } catch (...) {
      _LOG_ERROR("InterestValidationState::fail: Error in successCallback.");
    }
  }
  setOutcome(true);
}
예제 #8
0
void
DataValidationState::verifyOriginalPacket
  (const CertificateV2& trustedCertificate)
{
  if (VerificationHelpers::verifyDataSignature(data_, trustedCertificate)) {
    _LOG_TRACE("OK signature for data `" << data_.getName() << "`");
    try {
      successCallback_(data_);
    } catch (const std::exception& ex) {
      _LOG_ERROR("DataValidationState::fail: Error in successCallback: " << ex.what());
    } catch (...) {
      _LOG_ERROR("DataValidationState::fail: Error in successCallback.");
    }
    setOutcome(true);
  }
  else
    fail(ValidationError(ValidationError::INVALID_SIGNATURE,
      "Invalid signature of data `" + data_.getName().toUri() + "`"));
}
예제 #9
0
MySQLPreparedStatement* MySQLConnection::GetPreparedStatement(uint32 index)
{
    ASSERT(index < m_stmts.size());
    MySQLPreparedStatement* ret = m_stmts[index];
    if (!ret)
        _LOG_ERROR(LOG_FILTER_SQL, "Could not fetch prepared statement %u on database `%s`, connection type: %s.",
            index, m_connectionInfo.database.c_str(), (m_connectionFlags & CONNECTION_ASYNC) ? "asynchronous" : "synchronous");

    return ret;
}
예제 #10
0
void
InterestValidationState::verifyOriginalPacket
  (const CertificateV2& trustedCertificate)
{
  if (VerificationHelpers::verifyInterestSignature(interest_, trustedCertificate)) {
    _LOG_TRACE("OK signature for interest `" << interest_.getName() << "`");
    for (size_t i = 0; i < successCallbacks_.size(); ++i) {
      try {
        successCallbacks_[i](interest_);
      } catch (const std::exception& ex) {
        _LOG_ERROR("InterestValidationState::fail: Error in successCallback: " << ex.what());
      } catch (...) {
        _LOG_ERROR("InterestValidationState::fail: Error in successCallback.");
      }
    }
    setOutcome(true);
  }
  else
    fail(ValidationError(ValidationError::INVALID_SIGNATURE,
      "Invalid signature of interest `" + interest_.getName().toUri() + "`"));
}
예제 #11
0
void MySQLConnection::PrepareStatement(uint32 index, const char* sql, ConnectionFlags flags)
{
    m_queries.insert(PreparedStatementMap::value_type(index, std::make_pair(sql, flags)));

    // For reconnection case
    if (m_reconnecting)
        delete m_stmts[index];

    // Check if specified query should be prepared on this connection
    // i.e. don't prepare async statements on synchronous connections
    // to save memory that will not be used.
    if (!(m_connectionFlags & flags))
    {
        m_stmts[index] = NULL;
        return;
    }

    MYSQL_STMT* stmt = mysql_stmt_init(m_Mysql);
    if (!stmt)
    {
        _LOG_ERROR(LOG_FILTER_SQL, "In mysql_stmt_init() id: %u, sql: \"%s\"", index, sql);
        _LOG_ERROR(LOG_FILTER_SQL, "%s", mysql_error(m_Mysql));
        m_prepareError = true;
    }
    else
    {
        if (mysql_stmt_prepare(stmt, sql, static_cast<unsigned long>(strlen(sql))))
        {
            _LOG_ERROR(LOG_FILTER_SQL, "In mysql_stmt_prepare() id: %u, sql: \"%s\"", index, sql);
            _LOG_ERROR(LOG_FILTER_SQL, "%s", mysql_stmt_error(stmt));
            mysql_stmt_close(stmt);
            m_prepareError = true;
        }
        else
        {
            MySQLPreparedStatement* mStmt = new MySQLPreparedStatement(stmt);
            m_stmts[index] = mStmt;
        }
    }
}
예제 #12
0
uint64_t
NamePrefixTableEntry::removeRoutingTableEntry(shared_ptr<RoutingTablePoolEntry>
                                              rtpePtr)
{
  auto rtpeItr = std::find(m_rteList.begin(), m_rteList.end(), rtpePtr);

  if (rtpeItr != m_rteList.end()) {
    (*rtpeItr)->decrementUseCount();
    m_rteList.erase(rtpeItr);
  }
  else {
    _LOG_ERROR("Routing entry for: " << rtpePtr->getDestination()
               << " not found in NPT entry: " << getNamePrefix());
  }
  return (*rtpeItr)->getUseCount();
}
예제 #13
0
Data* Factory::create(const Config& args)
{
	if (args.size() < 2)
	{
		_LOG_ERROR("Create worker failed.[Reason: arguement less than 2]");
		return 0;
	}

	DataList::const_iterator iter = m_dataList.begin();
	for ( ; iter != m_dataList.end(); ++iter)
	{
		if ((iter->m_compatibleFunc)(args))
		{
			return (iter->m_createFunc)(args);
		}
	}
	
	return 0;
}
예제 #14
0
bool MySQLConnection::_Query(const char *sql, MYSQL_RES **pResult, MYSQL_FIELD **pFields, uint64* pRowCount, uint32* pFieldCount)
{
    if (!m_Mysql)
        return false;

    {
       boost::timer _s;

        if (mysql_query(m_Mysql, sql))
        {
            uint32 lErrno = mysql_errno(m_Mysql);
            _LOG_INFO(LOG_FILTER_SQL, "SQL: %s", sql);
            _LOG_ERROR(LOG_FILTER_SQL, "[%u] %s", lErrno, mysql_error(m_Mysql));

            if (_HandleMySQLErrno(lErrno))      // If it returns true, an error was handled successfully (i.e. reconnection)
                return _Query(sql, pResult, pFields, pRowCount, pFieldCount);    // We try again

            return false;
        }
        else
            _LOG_DEBUG(LOG_FILTER_SQL, "[%u ms] SQL: %s",(uint32)_s.elapsed(), sql);

        *pResult = mysql_store_result(m_Mysql);
        *pRowCount = mysql_affected_rows(m_Mysql);
        *pFieldCount = mysql_field_count(m_Mysql);
    }

    if (!*pResult )
        return false;

    if (!*pRowCount)
    {
        mysql_free_result(*pResult);
        return false;
    }

    *pFields = mysql_fetch_fields(*pResult);

    return true;
}
예제 #15
0
void
FsWatcher::DidFileChanged(QString filePath)
{
  if (!filePath.startsWith(m_dirPath)) {
    _LOG_ERROR(
      "Got notification about a file not from the monitored directory: " << filePath.toStdString());
    return;
  }
  QString absFilePath = filePath;

  fs::path absPathTriggeredFile(filePath.toStdString());
  filePath.remove(0, m_dirPath.size());

  fs::path triggeredFile(filePath.toStdString());
  if (fs::exists(fs::path(absPathTriggeredFile))) {
    _LOG_DEBUG("Triggered UPDATE of file:  " << triggeredFile.relative_path().generic_string());
    // m_onChange(triggeredFile.relative_path());

    m_watcher->removePath(absFilePath);
    m_watcher->addPath(absFilePath);

    rescheduleEvent("", triggeredFile.relative_path().string(), time::milliseconds(500),
                    bind(m_onChange, triggeredFile.relative_path()));
  }
  else {
    _LOG_DEBUG("Triggered DELETE of file: " << triggeredFile.relative_path().generic_string());
    // m_onDelete(triggeredFile.relative_path());

    m_watcher->removePath(absFilePath);

    deleteFile(triggeredFile.relative_path());

    rescheduleEvent("r", triggeredFile.relative_path().string(), time::milliseconds(500),
                    bind(m_onDelete, triggeredFile.relative_path()));
  }
}
예제 #16
0
bool MySQLConnection::Open()
{
    MYSQL *mysqlInit;
    mysqlInit = mysql_init(NULL);
    if (!mysqlInit)
    {
        _LOG_ERROR(LOG_FILTER_SQL, "Could not initialize Mysql connection to database `%s`", m_connectionInfo.database.c_str());
        return false;
    }

    int port;
    char const* unix_socket;
    //unsigned int timeout = 10;

    mysql_options(mysqlInit, MYSQL_SET_CHARSET_NAME, "utf8");
    //mysql_options(mysqlInit, MYSQL_OPT_READ_TIMEOUT, (char const*)&timeout);
    #ifdef _WIN32
    if (m_connectionInfo.host == ".")                                           // named pipe use option (Windows)
    {
        unsigned int opt = MYSQL_PROTOCOL_PIPE;
        mysql_options(mysqlInit, MYSQL_OPT_PROTOCOL, (char const*)&opt);
        port = 0;
        unix_socket = 0;
    }
    else                                                    // generic case
    {
        port = atoi(m_connectionInfo.port_or_socket.c_str());
        unix_socket = 0;
    }
    #else
    if (m_connectionInfo.host == ".")                                           // socket use option (Unix/Linux)
    {
        unsigned int opt = MYSQL_PROTOCOL_SOCKET;
        mysql_options(mysqlInit, MYSQL_OPT_PROTOCOL, (char const*)&opt);
        m_connectionInfo.host = "localhost";
        port = 0;
        unix_socket = m_connectionInfo.port_or_socket.c_str();
    }
    else                                                    // generic case
    {
        port = atoi(m_connectionInfo.port_or_socket.c_str());
        unix_socket = 0;
    }
    #endif

    m_Mysql = mysql_real_connect(mysqlInit, m_connectionInfo.host.c_str(), m_connectionInfo.user.c_str(),
        m_connectionInfo.password.c_str(), m_connectionInfo.database.c_str(), port, unix_socket, 0);

    if (m_Mysql)
    {
        if (!m_reconnecting)
        {
            _LOG_INFO(LOG_FILTER_SQL, "MySQL client library: %s", mysql_get_client_info());
            _LOG_INFO(LOG_FILTER_SQL, "MySQL server ver: %s ", mysql_get_server_info(m_Mysql));
            // MySQL version above 5.1 IS required in both client and server and there is no known issue with different versions above 5.1
            // if (mysql_get_server_version(m_Mysql) != mysql_get_client_version())
            //     _LOG_INFO(LOG_FILTER_SQL, "[WARNING] MySQL client/server version mismatch; may conflict with behaviour of prepared statements.");
        }

        _LOG_INFO(LOG_FILTER_SQL, "Connected to MySQL database at %s", m_connectionInfo.host.c_str());
        mysql_autocommit(m_Mysql, 1);

        // set connection properties to UTF8 to properly handle locales for different
        // server configs - core sends data in UTF8, so MySQL must expect UTF8 too
        mysql_set_character_set(m_Mysql, "utf8");
        return PrepareStatements();
    }
    else
    {
        _LOG_ERROR(LOG_FILTER_SQL, "Could not connect to MySQL database at %s: %s\n", m_connectionInfo.host.c_str(), mysql_error(mysqlInit));
        mysql_close(mysqlInit);
        return false;
    }
}
예제 #17
0
ActionItemPtr
ActionLog::AddRemoteAction(const Name& deviceName, sqlite3_int64 seqno, shared_ptr<Data> actionData)
{
  if (!actionData) {
    _LOG_ERROR("actionData is not valid");
    return ActionItemPtr();
  }
  ActionItemPtr action = deserializeMsg<ActionItem>(
    Buffer(actionData->getContent().value(), actionData->getContent().value_size()));

  if (!action) {
    _LOG_ERROR("action cannot be decoded");
    return ActionItemPtr();
  }

  _LOG_DEBUG("AddRemoteAction: [" << deviceName.toUri() << "] seqno: " << seqno);

  sqlite3_stmt* stmt;
  sqlite3_prepare_v2(m_db,
                     "INSERT INTO ActionLog "
                     "(device_name, seq_no, action, filename, version, action_timestamp, "
                     "file_hash, file_atime, file_mtime, file_ctime, file_chmod, file_seg_num, "
                     "parent_device_name, parent_seq_no, "
                     "action_name, action_content_object) "
                     "VALUES (?, ?, ?, ?, ?, datetime(?, 'unixepoch'),"
                     "        ?, datetime(?, 'unixepoch'), datetime(?, 'unixepoch'), datetime(?, 'unixepoch'), ?,?, "
                     "        ?, ?, "
                     "        ?, ?);",
                     -1, &stmt, 0);
  _LOG_DEBUG_COND(sqlite3_errcode(m_db) != SQLITE_OK, sqlite3_errmsg(m_db));

  sqlite3_bind_blob(stmt, 1, deviceName.wireEncode().wire(), deviceName.wireEncode().size(),
                    SQLITE_STATIC);
  sqlite3_bind_int64(stmt, 2, seqno);

  sqlite3_bind_int(stmt, 3, action->action());
  sqlite3_bind_text(stmt, 4, action->filename().c_str(), action->filename().size(), SQLITE_STATIC);
  sqlite3_bind_int64(stmt, 5, action->version());
  sqlite3_bind_int64(stmt, 6, action->timestamp());

  if (action->action() == ActionItem::UPDATE) {
    sqlite3_bind_blob(stmt, 7, action->file_hash().c_str(), action->file_hash().size(),
                      SQLITE_STATIC);

    // sqlite3_bind_int64(stmt, 8, atime); // NULL
    sqlite3_bind_int64(stmt, 9, action->mtime());
    // sqlite3_bind_int64(stmt, 10, ctime); // NULL

    sqlite3_bind_int(stmt, 11, action->mode());
    sqlite3_bind_int(stmt, 12, action->seg_num());
  }

  if (action->has_parent_device_name()) {
    sqlite3_bind_blob(stmt, 13, action->parent_device_name().c_str(),
                      action->parent_device_name().size(), SQLITE_STATIC);
    sqlite3_bind_int64(stmt, 14, action->parent_seq_no());
  }

  Name actionName = Name(deviceName);
  actionName.append("action").append(m_sharedFolderName).appendNumber(seqno);

  sqlite3_bind_blob(stmt, 15, actionName.wireEncode().wire(), actionName.wireEncode().size(),
                    SQLITE_STATIC);
  sqlite3_bind_blob(stmt, 16, actionData->wireEncode().wire(), actionData->wireEncode().size(),
                    SQLITE_STATIC);
  sqlite3_step(stmt);

  // if action needs to be applied to file state, the trigger will take care of it

  _LOG_DEBUG_COND(sqlite3_errcode(m_db) != SQLITE_DONE, sqlite3_errmsg(m_db));

  sqlite3_finalize(stmt);

  // I had a problem including directory_name assignment as part of the initial insert.
  sqlite3_prepare_v2(m_db,
                     "UPDATE ActionLog SET directory=directory_name(filename) WHERE device_name=? AND seq_no=?",
                     -1, &stmt, 0);
  _LOG_DEBUG_COND(sqlite3_errcode(m_db) != SQLITE_OK, sqlite3_errmsg(m_db));

  sqlite3_bind_blob(stmt, 1, deviceName.wireEncode().wire(), deviceName.wireEncode().size(),
                    SQLITE_STATIC);
  sqlite3_bind_int64(stmt, 2, seqno);
  sqlite3_step(stmt);
  _LOG_DEBUG_COND(sqlite3_errcode(m_db) != SQLITE_DONE, sqlite3_errmsg(m_db));

  sqlite3_finalize(stmt);

  return action;
}
예제 #18
0
void ClientController::onSocket_ReadEvent(coconut_socket_t fd) { 
	if(protocolFactory_) {
//#define PROTOCOL_READ_FROM_SOCKET
#ifdef PROTOCOL_READ_FROM_SOCKET
		do {
			if(!protocol_ || protocol_->isReadComplete()) {
				_LOG_TRACE("New Protocol make #1 in %p\n", this);
				protocol_ = protocolFactory_->makeProtocol();
			}

			if(protocol_->processRead(socket()) == true) {
				onReceivedProtocol(protocol_);
			} else {
				break;
			}
		} while(1);
#else
		char chunk[IOBUF_LEN];
		int nread = socket()->read(chunk, IOBUF_LEN);
		if(nread <= 0)
			return;

		//logger::hexdump( (unsigned char*)chunk, nread, stdout);

		if(!protocol_ || protocol_->isReadComplete()) {
			_LOG_TRACE("New Protocol make #1 in this = %p\n", this);
			protocol_ = protocolFactory_->makeProtocol();
		}

		_LOG_DEBUG("ClientController read socket fd = %d, readSize = %d in %p\n", socket()->socketFD(), nread, this); 
		protocol_->addToReadingBuffer(chunk, nread);
		int index = -1;
		while(true) {
			index++;
			if(protocol_->processReadFromReadingBuffer() == true) {
				// fire!
				eventGotProtocol()->fireObservers(shared_from_this(), protocol_);
				onReceivedProtocol(protocol_);

				_LOG_TRACE("ClientController Protocol receved completed. readSize = %d, remainBufferSize = %d in %p, index = %d\n", 
							nread, protocol_->remainingBufferSize(), this, index);

				if(protocol_->remainingBufferSize() > 0) {
#define ALWAS_MAKE_PROTOCOL
#ifdef ALWAS_MAKE_PROTOCOL
					// new protocol
					_LOG_TRACE("New Protocol make #2 in this = %p\n", this);
					boost::shared_ptr<protocol::BaseProtocol> protocolTemp = protocolFactory_->makeProtocol();
					protocolTemp->addToReadingBuffer(protocol_->remainingBufferPtr(), protocol_->remainingBufferSize());
					protocol_ = protocolTemp;
#else
					protocol_->resetReadingBufferToRemainingBuffer();
#endif
					continue;	// one more processing..
				}
			} 

			// --> parsing failed..

			if(protocol_->isInvalidPacketReceived()) {
				// this session close!
				_LOG_ERROR("Invalid Packet Recved.. this = %p, size = \n", this, protocol_->payloadBuffer()->totalSize());
				socket()->close();
			}
			break;
		}
#endif
	} else {
		char buffer[IOBUF_LEN];
		int res = socket()->read(buffer, IOBUF_LEN);
		if(res > 0)
			onReceivedData(buffer, res);
	}
}