void Connection::closeConnectionTask()
{
//dispatcher thread
#ifdef __DEBUG_NET_DETAIL__
std::cout << "Connection::closeConnectionTask" << std::endl;
#endif
m_connectionLock.lock();
if(m_connectionState != CONNECTION_STATE_REQUEST_CLOSE){
std::cout << "Error: [Connection::closeConnectionTask] m_connectionState = " << m_connectionState << std::endl;
m_connectionLock.unlock();
return;
}
if(m_protocol){
m_protocol->setConnection(Connection_ptr());
m_protocol->releaseProtocol();
m_protocol = NULL;
}
m_connectionState = CONNECTION_STATE_CLOSING;
if(m_pendingWrite == 0 || m_writeError){
closeSocket();
releaseConnection();
m_connectionState = CONNECTION_STATE_CLOSED;
}
else{
//will be closed by onWriteOperation/handleWriteTimeout/handleReadTimeout instead
}
m_connectionLock.unlock();
}
void Connection::closeConnection() {
LOGt("Connection::closeConnection()");
boost::recursive_mutex::scoped_lock lock(m_connectionLock);
if(m_connectionState != CONNECTION_STATE_REQUEST_CLOSE)
{
LOGe("[Connection::closeConnection] m_connectionState = " << m_connectionState);
return;
}
if(m_protocol)
{
m_protocol->setConnection(Connection_ptr());
m_protocol->releaseProtocol();
m_protocol = nullptr;
}
m_connectionState = CONNECTION_STATE_CLOSING;
if(!m_pendingWrite || m_writeError)
{
closeSocket();
releaseConnection();
m_connectionState = CONNECTION_STATE_CLOSED;
}
}
void Connection::closeConnection()
{
//dispatcher thread
#ifdef __DEBUG_NET_DETAIL__
std::clog << "Connection::closeConnection" << std::endl;
#endif
m_connectionLock.lock();
if(m_connectionState != CONNECTION_STATE_REQUEST_CLOSE)
{
std::clog << "[Error - Connection::closeConnection] m_connectionState = " << m_connectionState << std::endl;
m_connectionLock.unlock();
return;
}
if(m_protocol)
{
m_protocol->setConnection(Connection_ptr());
m_protocol->releaseProtocol();
m_protocol = NULL;
}
m_connectionState = CONNECTION_STATE_CLOSING;
if(!m_pendingWrite || m_writeError)
{
closeSocket();
releaseConnection();
m_connectionState = CONNECTION_STATE_CLOSED;
}
m_connectionLock.unlock();
}
void Connection::closeConnectionTask()
{
//dispatcher thread
std::lock_guard<std::recursive_mutex> lockClass(m_connectionLock);
if (m_connectionState != CONNECTION_STATE_REQUEST_CLOSE) {
std::cout << "Error: [Connection::closeConnectionTask] m_connectionState = " << m_connectionState << std::endl;
return;
}
if (m_protocol) {
m_protocol->setConnection(Connection_ptr());
m_protocol->releaseProtocol();
m_protocol = nullptr;
}
m_connectionState = CONNECTION_STATE_CLOSING;
if (m_pendingWrite == 0 || m_writeError) {
closeSocket();
releaseConnection();
m_connectionState = CONNECTION_STATE_CLOSED;
} else {
//will be closed by onWriteOperation/handleWriteTimeout/handleReadTimeout instead
}
}
Connection_ptr ConnectionManager::createConnection(boost::asio::ip::tcp::socket* socket,
boost::asio::io_service& io_service, ServicePort_ptr servicer)
{
boost::recursive_mutex::scoped_lock lockClass(m_connectionManagerLock);
Connection_ptr connection = Connection_ptr(new Connection(socket, io_service, servicer));
m_connections.push_back(connection);
return connection;
}
Connection_ptr ConnectionManager::createConnection(boost::asio::ip::tcp::socket* socket,
boost::asio::io_service& io_service, ServicePort_ptr servicer)
{
std::lock_guard<std::recursive_mutex> lockClass(m_connectionManagerLock);
Connection_ptr connection = Connection_ptr(new Connection(socket, io_service, servicer));
m_connections.insert(connection);
return connection;
}
Protocol* ServicePort::make_protocol(bool checksummed, NetworkMessage& msg) const
{
uint8_t protocolID = msg.GetByte();
for(std::vector<Service_ptr>::const_iterator service_iter = m_services.begin(); service_iter != m_services.end(); ++service_iter)
{
Service_ptr service = *service_iter;
if(protocolID != service->get_protocol_identifier())
continue;
if(checksummed)
{
if(service->is_checksummed())
return service->make_protocol(Connection_ptr());
}
else if(!service->is_checksummed())
return service->make_protocol(Connection_ptr());
}
return NULL;
}
Protocol* ServicePort::make_protocol(NetworkMessage& msg) const
{
uint8_t protocolID = msg.GetByte();
for (Service_ptr service : m_services) {
if (protocolID == service->get_protocol_identifier()) {
return service->make_protocol(Connection_ptr());
}
}
return nullptr;
}
Protocol* ServicePort::makeProtocol(bool checksum, NetworkMessage& msg) const
{
uint8_t protocolId = msg.GetByte();
for(ServiceVec::const_iterator it = m_services.begin(); it != m_services.end(); ++it)
{
if((*it)->getProtocolId() == protocolId && ((checksum && (*it)->hasChecksum()) || !(*it)->hasChecksum()))
return (*it)->makeProtocol(Connection_ptr());
}
return NULL;
}
Protocol* ServicePort::makeProtocol(NetworkMessage& msg) const
{
uint8_t protocolId = msg.get<char>();
for(ServiceVec::const_iterator it = m_services.begin(); it != m_services.end(); ++it)
{
if((*it)->getProtocolId() == protocolId)
return (*it)->makeProtocol(Connection_ptr());
}
return NULL;
}
Protocol* ServicePort::make_protocol(bool checksummed, NetworkMessage& msg) const
{
uint8_t protocolID = msg.GetByte();
for (Service_ptr service : m_services) {
if (protocolID != service->get_protocol_identifier()) {
continue;
}
if ((checksummed && service->is_checksummed()) || !service->is_checksummed()) {
return service->make_protocol(Connection_ptr());
}
}
return nullptr;
}
Protocol* ServicePort::make_protocol(bool checksummed, NetworkMessage& msg) const
{
uint8_t protocolId = msg.GetByte();
for(std::vector<Service_ptr>::const_iterator it = m_services.begin(); it != m_services.end(); ++it)
{
Service_ptr service = *it;
if(service->get_protocol_identifier() == protocolId && ((checksummed &&
service->is_checksummed()) || !service->is_checksummed())){
// Correct service! Create protocol and get on with it
return service->make_protocol(Connection_ptr());
}
// We can ignore the other cases, they will most likely end up in return NULL anyways.
}
return NULL;
}
