Connection.cpp

#include "Headers.h"
#include "Connection.h"
#include "Debug.h"
#include "Console.h"

#pragma warning(disable : 4996)

__uint32    CConnection::idGlobal = 0;
__uint32    CConnection::flowGlobal = 0;

__time      CConnection::timerOpenTimeout = 0.5;
__time      CConnection::timerCloseTimeout = 0.5;
__time      CConnection::timerCancelTimeout = 2.0;
__time      CConnection::timerRequesterWaitTimeout = 2.0;
__time      CConnection::timerResponderWaitTimeout = 120.0;
__time      CConnection::timerDefaultWaitTimeout = 30.0;

char*       CConnection::strConnectionType[] = {"REQUESTER", "RESPONDER"};
char*       CConnection::strState[] = {"CLOSED", "OPENING", "OPENED", "CLOSING", "CANCELING", "WAITING"};

CConnection::CConnection(
    EConnectionType                                                     type,
    __uint32                                                            idEntry,
    __uint16                                                            port,
    CSimHandler*                                                        sim,
    IDelegate5<void, __uint16, __uint16, CAddress, __byte, CPacket*>*   delegateSend,
    IDelegate1<void, CConnection*>*                                     delegateDispose,
    CAddress                                                            remoteAddress,
    __uint16                                                            remotePort
    )
{
    // Type
    this->type = type;

    // Simulator
    this->sim = sim;

    // Flow
    this->flow = 0xFFFFFFFF;

    // State
    this->state = CLOSED;

    // Local
    this->id = CConnection::idGlobal++;
    this->idEntry = idEntry;
    this->port = port;

    // Remote
    this->remoteAddress = remoteAddress;
    this->remoteId = 0;
    this->remoteIdEntry = 0;
    this->remotePort = remotePort;

    // Delegates
    this->delegateSend = delegateSend;

    // Events
    this->eventOpen = new Event2<void, CConnection*, EOpenResult>();
    this->eventClose = new Event2<void, CConnection*, ECloseResult>();

    // Calls
    this->callDispose = new Call1<CConnection*>(this->sim, delegateDispose);

    // Timers
    this->timerControl = new CTimer<CConnection>(this->sim, this);

    // Tag
    this->tag = NULL;

    // Set functions
    switch(this->type)
    {
    case REQUESTER:
        this->functionOpen = &CConnection::OpenRequester;
        this->functionClose = &CConnection::CloseRequester;
        this->functionRecvMessageOpen = &CConnection::RecvMessageOpenRequester;
        this->functionRecvMessageOpenAck = &CConnection::RecvMessageOpenAckRequester;
        this->functionRecvMessageClose = &CConnection::RecvMessageCloseRequester;
        this->functionRecvMessageCloseAck = &CConnection::RecvMessageCloseAckRequester;
        this->functionRecvMessageCloseAckAck = &CConnection::RecvMessageCloseAckAckRequester;
        break;
    case RESPONDER:
        this->functionOpen = &CConnection::OpenResponder;
        this->functionClose = &CConnection::CloseResponder;
        this->functionRecvMessageOpen = &CConnection::RecvMessageOpenResponder;
        this->functionRecvMessageOpenAck = &CConnection::RecvMessageOpenAckResponder;
        this->functionRecvMessageClose = &CConnection::RecvMessageCloseResponder;
        this->functionRecvMessageCloseAck = &CConnection::RecvMessageCloseAckResponder;
        this->functionRecvMessageCloseAckAck = &CConnection::RecvMessageCloseAckAckResponder;
        break;
    }
}

CConnection::~CConnection()
{
    // Events
    delete this->eventOpen;
    delete this->eventClose;

    // Calls
    delete this->callDispose;

    // Timers
    delete this->timerControl;
}

void CConnection::Open()
{
    // Call open function for connection type
    (this->*this->functionOpen)();
}

void CConnection::OpenRequester()
{
    // Exception for any connection state other that CLOSED
    assert(CLOSED == this->state);

#ifdef LOG_FLOW
    CConsole::SetColor(CConsole::DARK_RED);
    printf("\n\tT = %8.3lf\tOpenRequester() : %s -> ", this->sim->Time(), this->ToString());
    CConsole::SetColor(CConsole::LIGHT_GRAY);
#endif

    // Initialize the flow number
    this->flow = CConnection::flowGlobal++;

    // Change the state
    this->state = OPENING;

    // Send an OPEN message to the sender
    CPacketConnectionMessage* packet = new CPacketConnectionMessage(
        this->flow,
        this->id,
        this->idEntry,
        this->sim->Time());

    (*this->delegateSend)(this->port, this->remotePort, this->remoteAddress, 128, packet);

    // Set the control timer to open handler
    this->timerControl->SetAfter(CConnection::timerOpenTimeout, &CConnection::TimerOpen);

#ifdef LOG_FLOW
    CConsole::SetColor(CConsole::DARK_RED);
    printf("%s", this->ToString());
    CConsole::SetColor(CConsole::LIGHT_GRAY);
#endif
}

void CConnection::OpenResponder()
{
#ifdef LOG_FLOW
    CConsole::SetColor(CConsole::DARK_BLUE);
    printf("\n\tT = %8.3lf\tOpenResponder() : %s -> ", this->sim->Time(), this->ToString());
    CConsole::SetColor(CConsole::LIGHT_GRAY);
#endif

    // Exception for any connection state
    assert(0);

#ifdef LOG_FLOW
    CConsole::SetColor(CConsole::DARK_BLUE);
    printf("%s", this->ToString());
    CConsole::SetColor(CConsole::LIGHT_GRAY);
#endif
}

void CConnection::Close()
{
    // Call close function for connection type
    (this->*this->functionClose)();
}

void CConnection::CloseRequester()
{
#ifdef LOG_FLOW
    CConsole::SetColor(CConsole::DARK_RED);
    printf("\n\tT = %8.3lf\tCloseRequester() : %s -> ", this->sim->Time(), this->ToString());
    CConsole::SetColor(CConsole::LIGHT_GRAY);
#endif

    // Close requester
    switch(this->state)
    {
    case OPENING:                       // Change to CANCELING / none / timer cancel
        {
            // Check the control timer is set
            assert(this->timerControl->IsSet());

            // Cancel the control timer
            this->timerControl->Cancel();

            // Change the state
            this->state = CANCELING;

            // Raise open event
            (*this->eventOpen)(this, OPEN_CANCELED);

            // Set the control timer to cancel handler
            this->timerControl->SetAfter(CConnection::timerCancelTimeout, &CConnection::TimerCancel);
        }
        break;
    case OPENED:                        // Change to CLOSING / CLOSE / timer close
        // If connection is opened, send a CLOSE message to remote party
        {
            // Check the control timer is not set
            assert(!this->timerControl->IsSet());

            // Send a CLOSE message to the sender
            CPacketConnectionMessage* packet = new CPacketConnectionMessage(
                this->flow,
                this->id,
                this->remoteId,
                this->idEntry,
                this->remoteIdEntry,
                CPacketConnectionMessage::CLOSE,
                this->sim->Time()
                );

            (*this->delegateSend)(this->port, this->remotePort, this->remoteAddress, 128, packet);

            // Change the state
            this->state = CLOSING;

            // Set the control timer to close handler
            this->timerControl->SetAfter(CConnection::timerCloseTimeout, &CConnection::TimerClose);
        }
        break;
    case CLOSING: break;                // Ignore
    case WAITING: break;                // Ignore
    default: assert(0);                 // Exception for all other states
    }

#ifdef LOG_FLOW
    CConsole::SetColor(CConsole::DARK_RED);
    printf("%s", this->ToString());
    CConsole::SetColor(CConsole::LIGHT_GRAY);
#endif
}

void CConnection::CloseResponder()
{
#ifdef LOG_FLOW
    CConsole::SetColor(CConsole::DARK_BLUE);
    printf("\n\tT = %8.3lf\tCloseResponder() : %s -> ", this->sim->Time(), this->ToString());
    CConsole::SetColor(CConsole::LIGHT_GRAY);
#endif

    // Close responder
    switch(this->state)
    {
    case OPENING:                       // Change to CLOSING / none / timer cancel
        // If connection is opened, send a CLOSE message to remote party
        {
            // Check the control timer is set
            assert(this->timerControl->IsSet());

            // Cancel the control timer
            this->timerControl->Cancel();

            // Send a CLOSE message to the sender
            CPacketConnectionMessage* packet = new CPacketConnectionMessage(
                this->flow,
                this->id,
                this->remoteId,
                this->idEntry,
                this->remoteIdEntry,
                CPacketConnectionMessage::CLOSE,
                this->sim->Time()
                );

            (*this->delegateSend)(this->port, this->remotePort, this->remoteAddress, 128, packet);

            // Set the control timer to close handler
            this->timerControl->SetAfter(CConnection::timerCloseTimeout, &CConnection::TimerClose);

            // Change the state
            this->state = CLOSING;

            // Raise open event
            (*this->eventOpen)(this, OPEN_CANCELED);
        }
        break;
    case OPENED:                        // Change to CLOSING / CLOSE / timer close
        // If connection is opened, send a CLOSE message to remote party
        {
            // Check the control timer is not set
            assert(!this->timerControl->IsSet());

            // Send a CLOSE message to the sender
            CPacketConnectionMessage* packet = new CPacketConnectionMessage(
                this->flow,
                this->id,
                this->remoteId,
                this->idEntry,
                this->remoteIdEntry,
                CPacketConnectionMessage::CLOSE,
                this->sim->Time()
                );

            (*this->delegateSend)(this->port, this->remotePort, this->remoteAddress, 128, packet);

            // Change the state
            this->state = CLOSING;

            // Set the control timer to close handler
            this->timerControl->SetAfter(CConnection::timerCloseTimeout, &CConnection::TimerClose);
        }
        break;
    case CLOSING: break;                // Ignore in CLOSING state
    case WAITING: break;                // Ignore in WAITING state
    default: assert(0);                 // Exception for other states
    }

#ifdef LOG_FLOW
    CConsole::SetColor(CConsole::DARK_BLUE);
    printf("%s", this->ToString());
    CConsole::SetColor(CConsole::LIGHT_GRAY);
#endif
}

bool CConnection::SendData(CPacketConnectionData* packet)
{
    assert("To do" != 0);

    return false;
}

void CConnection::Recv(CAddress src, CPacketConnection* packet)
{
    // Check the packet source and destination
    assert(src == this->remoteAddress);

    switch(packet->TypeConnection())
    {
    case CPacketConnection::MESSAGE: this->RecvMessage(type_cast<CPacketConnectionMessage*>(packet)); break;
    case CPacketConnection::FEEDBACK: this->RecvFeedback(type_cast<CPacketConnectionFeedback*>(packet)); break;
    case CPacketConnection::DATA: this->RecvData(type_cast<CPacketConnectionData*>(packet)); break;
    }

    // General processing
    this->Recv(packet);
}

void CConnection::RecvMessage(CPacketConnectionMessage* packet)
{
    switch(packet->TypeMessage())
    {
    case CPacketConnectionMessage::OPEN: (this->*this->functionRecvMessageOpen)(packet); break;
    case CPacketConnectionMessage::OPEN_ACK: (this->*this->functionRecvMessageOpenAck)(packet); break;
    case CPacketConnectionMessage::CLOSE: (this->*this->functionRecvMessageClose)(packet); break;
    case CPacketConnectionMessage::CLOSE_ACK: (this->*this->functionRecvMessageCloseAck)(packet); break;
    case CPacketConnectionMessage::CLOSE_ACK_ACK: (this->*this->functionRecvMessageCloseAckAck)(packet); break;
    default: assert(0); // Not supported
    }
}

void CConnection::RecvMessageOpenRequester(CPacketConnectionMessage* packet)
{
    // Received an OPEN message

    // Exception for any connection state
    assert(0);
}

void CConnection::RecvMessageOpenAckRequester(CPacketConnectionMessage* packet)
{
    // Received an OPEN-ACK message

#ifdef LOG_FLOW
    CConsole::SetColor(CConsole::DARK_RED);
    printf("\n\tT = %8.3lf\tRecvRequester(OPEN_ACK) : %s -> ", this->sim->Time(), this->ToString());
    CConsole::SetColor(CConsole::LIGHT_GRAY);
#endif

    // Check the packet source and destination
    assert(packet->Dst() == this->id);
    assert(packet->DstEntry() == this->idEntry);
    assert(packet->Flow() == this->flow);

    // Check the state
    switch(this->state)
    {
    case CConnection::OPENING:      // Change to OPENED / OPEN_ACK / none
        {
            // Check the control timer is set
            assert(this->timerControl->IsSet());

            // Cancel the control timer
            this->timerControl->Cancel();

            // Set the sender information
            this->remoteId = packet->Src();
            this->remoteIdEntry = packet->SrcEntry();

            // Send a OPEN-ACK message
            CPacketConnectionMessage* reply = new CPacketConnectionMessage(
                this->flow,
                this->id,
                this->remoteId,
                this->idEntry,
                this->remoteIdEntry,
                CPacketConnectionMessage::OPEN_ACK,
                this->sim->Time(),
                packet->TimeTx()
                );

            (*this->delegateSend)(this->port, this->remotePort, this->remoteAddress, 128, reply);

            // Change the state
            this->state = OPENED;

            // Raise open event
            (*this->eventOpen)(this, OPEN_SUCCESS);
        }
        break;
    case CConnection::CANCELING:    // Change to CLOSING / CLOSE / timer close
        {
            // Check the control timer is set
            assert(this->timerControl->IsSet());

            // Cancel the control timer
            this->timerControl->Cancel();

            // Set the sender information
            this->remoteId = packet->Src();
            this->remoteIdEntry = packet->SrcEntry();

            // Send a CLOSE message
            CPacketConnectionMessage* reply = new CPacketConnectionMessage(
                this->flow,
                this->id,
                this->remoteId,
                this->idEntry,
                this->remoteIdEntry,
                CPacketConnectionMessage::CLOSE,
                this->sim->Time(),
                packet->TimeTx()
                );

            (*this->delegateSend)(this->port, this->remotePort, this->remoteAddress, 128, reply);

            // Change the state
            this->state = CLOSING;

            // Set the control timer to close handler
            this->timerControl->SetAfter(CConnection::timerCloseTimeout, &CConnection::TimerClose);
        }
        break;
    default: assert(0);             // Exception for other states
    }

#ifdef LOG_FLOW
    CConsole::SetColor(CConsole::DARK_RED);
    printf("%s", this->ToString());
    CConsole::SetColor(CConsole::LIGHT_GRAY);
#endif
}

void CConnection::RecvMessageCloseRequester(CPacketConnectionMessage* packet)
{
    // Received a CLOSE message

#ifdef LOG_FLOW
    CConsole::SetColor(CConsole::DARK_RED);
    printf("\n\tT = %8.3lf\tRecvRequester(CLOSE) : %s -> ", this->sim->Time(), this->ToString());
    CConsole::SetColor(CConsole::LIGHT_GRAY);
#endif

    // Check the packet source and destination
    assert(packet->Dst() == this->id);
    assert(packet->DstEntry() == this->idEntry);
    assert(packet->Flow() == this->flow);

    // Check the state
    switch(this->state)
    {
    case OPENING:                   // Change to CLOSING / CLOSE_ACK / timer close
        {
            // Check the control timer is set
            assert(this->timerControl->IsSet());

            // Cancel the control timer
            this->timerControl->Cancel();

            // Send a CLOSE-ACK message
            CPacketConnectionMessage* reply = new CPacketConnectionMessage(
                this->flow,
                this->id,
                this->remoteId,
                this->idEntry,
                this->remoteIdEntry,
                CPacketConnectionMessage::CLOSE_ACK,
                this->sim->Time(),
                packet->TimeTx()
                );

            (*this->delegateSend)(this->port, this->remotePort, this->remoteAddress, 128, reply);

            // Change the state
            this->state = CLOSING;

            // Raise the event
            (*this->eventOpen)(this, OPEN_FAIL_REMOTE);

            // Set the control timer to close handler
            this->timerControl->SetAfter(CConnection::timerCloseTimeout, &CConnection::TimerClose);
        }
        break;
    case OPENED:                    // Change to CLOSING / CLOSE_ACK / timer close
        {
            // Check the control timer is not set
            assert(!this->timerControl->IsSet());

            // Send a CLOSE-ACK message
            CPacketConnectionMessage* reply = new CPacketConnectionMessage(
                this->flow,
                this->id,
                this->remoteId,
                this->idEntry,
                this->remoteIdEntry,
                CPacketConnectionMessage::CLOSE_ACK,
                this->sim->Time(),
                packet->TimeTx()
                );

            (*this->delegateSend)(this->port, this->remotePort, this->remoteAddress, 128, reply);

            // Change the state
            this->state = CLOSING;

            // Set the control timer to close handler
            this->timerControl->SetAfter(CConnection::timerCloseTimeout, &CConnection::TimerClose);
        }
        break;
    case CANCELING:                 // Change to CLOSING / CLOSE_ACK / timer close
        {
            // Check the control timer is set
            assert(this->timerControl->IsSet());

            // Cancel the control timer
            this->timerControl->Cancel();

            // Send a CLOSE-ACK message
            CPacketConnectionMessage* reply = new CPacketConnectionMessage(
                this->flow,
                this->id,
                this->remoteId,
                this->idEntry,
                this->remoteIdEntry,
                CPacketConnectionMessage::CLOSE_ACK,
                this->sim->Time(),
                packet->TimeTx()
                );

            (*this->delegateSend)(this->port, this->remotePort, this->remoteAddress, 128, reply);

            // Change the state
            this->state = CLOSING;

            // Set the control timer to close handler
            this->timerControl->SetAfter(CConnection::timerCloseTimeout, &CConnection::TimerClose);
        }
        break;
    case CLOSING:                   // Change to CLOSING / CLOSE_ACK / none
        {
            // Check the control timer is set
            assert(this->timerControl->IsSet());

            // Send a CLOSE-ACK message
            CPacketConnectionMessage* reply = new CPacketConnectionMessage(
                this->flow,
                this->id,
                this->remoteId,
                this->idEntry,
                this->remoteIdEntry,
                CPacketConnectionMessage::CLOSE_ACK,
                this->sim->Time(),
                packet->TimeTx()
                );

            (*this->delegateSend)(this->port, this->remotePort, this->remoteAddress, 128, reply);

            // Leave the current state and timer
        }
        break;
    default: assert(0);             // Exception for other states 
    }

#ifdef LOG_FLOW
    CConsole::SetColor(CConsole::DARK_RED);
    printf("%s", this->ToString());
    CConsole::SetColor(CConsole::LIGHT_GRAY);
#endif
}

void CConnection::RecvMessageCloseAckRequester(CPacketConnectionMessage* packet)
{
    // Received a CLOSE-ACK message

#ifdef LOG_FLOW
    CConsole::SetColor(CConsole::DARK_RED);
    printf("\n\tT = %8.3lf\tRecvRequester(CLOSE_ACK) : %s -> ", this->sim->Time(), this->ToString());
    CConsole::SetColor(CConsole::LIGHT_GRAY);
#endif

    // Check the packet source and destination
    assert(packet->Dst() == this->id);
    assert(packet->DstEntry() == this->idEntry);
    assert(packet->Flow() == this->flow);

    // Check the state
    switch(this->state)
    {
    case CLOSING:                   // Change to WAITING / CLOSE_ACK_ACK / timer wait
        {
            // Check the control timer is set
            assert(this->timerControl->IsSet());

            // Cancel the control timer
            this->timerControl->Cancel();

            // Send a CLOSE-ACK-ACK message
            CPacketConnectionMessage* reply = new CPacketConnectionMessage(
                this->flow,
                this->id,
                this->remoteId,
                this->idEntry,
                this->remoteIdEntry,
                CPacketConnectionMessage::CLOSE_ACK_ACK,
                this->sim->Time(),
                packet->TimeTx()
                );

            (*this->delegateSend)(this->port, this->remotePort, this->remoteAddress, 128, reply);

            // Change the state
            this->state = WAITING;

            // Raise the event
            (*this->eventClose)(this, CLOSE_CONFIRMED);

            // Set the control timer to the waiting handler
            this->timerControl->SetAfter(CConnection::timerRequesterWaitTimeout, &CConnection::TimerWait);
        }
        break;
    default: assert(0);             // Exception for other sattes
    }

#ifdef LOG_FLOW
    CConsole::SetColor(CConsole::DARK_RED);
    printf("%s", this->ToString());
    CConsole::SetColor(CConsole::LIGHT_GRAY);
#endif
}

void CConnection::RecvMessageCloseAckAckRequester(CPacketConnectionMessage* packet)
{
    // Received a CLOSE-ACK-ACK

#ifdef LOG_FLOW
    CConsole::SetColor(CConsole::DARK_RED);
    printf("\n\tT = %8.3lf\tRecvRequester(CLOSE_ACK_ACK) : %s -> ", this->sim->Time(), this->ToString());
    CConsole::SetColor(CConsole::LIGHT_GRAY);
#endif

    // Check the packet source and destination
    assert(packet->Dst() == this->id);
    assert(packet->DstEntry() == this->idEntry);
    assert(packet->Flow() == this->flow);

    // Check the state
    switch(this->state)
    {
    case CLOSING:                   // Change to WAITING / none / timer wait
        {
            // Check the control timer is set
            assert(this->timerControl->IsSet());

            // Cancel the control timer
            this->timerControl->Cancel();

            // Change the state
            this->state = WAITING;

            // Raise the event
            (*this->eventClose)(this, CLOSE_CONFIRMED);

            // Set the control timer to the waiting handler
            this->timerControl->SetAfter(CConnection::timerResponderWaitTimeout, &CConnection::TimerWait);
        }
        break;
    case CLOSED:
    case WAITING:
        break;                      // Ignore in CLOSED or WAITING state
    default: assert(0);             // Exception for other states
    }

#ifdef LOG_FLOW
    CConsole::SetColor(CConsole::DARK_RED);
    printf("%s", this->ToString());
    CConsole::SetColor(CConsole::LIGHT_GRAY);
#endif
}

void CConnection::RecvMessageOpenResponder(CPacketConnectionMessage* packet)
{
    // Received an OPEN message

#ifdef LOG_FLOW
    CConsole::SetColor(CConsole::DARK_BLUE);
    printf("\n\tT = %8.3lf\tRecvResponder(OPEN) : %s -> ", this->sim->Time(), this->ToString());
    CConsole::SetColor(CConsole::LIGHT_GRAY);
#endif

    // Check the packet source and destination : must be set to an invalid connection
    assert(packet->Dst() == PACKET_INVALID_CONNECTION);
    assert(packet->DstEntry() == PACKET_INVALID_CONNECTION_ENTRY);

    // Check the state
    switch(this->state)
    {
    case CLOSED:                    // Change to OPENING / OPEN_ACK / timer open
        {
            // Check the control timer is not set
            assert(!this->timerControl->IsSet());

            // Set the flow number
            this->flow = packet->Flow();

            // Send an OPEN-ACK message
            CPacketConnectionMessage* reply = new CPacketConnectionMessage(
                this->flow,
                this->id,
                this->remoteId,
                this->idEntry,
                this->remoteIdEntry,
                CPacketConnectionMessage::OPEN_ACK,
                this->sim->Time(),
                packet->TimeTx()
                );

            (*this->delegateSend)(this->port, this->remotePort, this->remoteAddress, 128, reply);

            // Change the state
            this->state = OPENING;

            // Set the control timer to open handler
            this->timerControl->SetAfter(CConnection::timerOpenTimeout, &CConnection::TimerOpen);
        }
        break;
    default: assert(0);             // Exception for other state
    }

#ifdef LOG_FLOW
    CConsole::SetColor(CConsole::DARK_BLUE);
    printf("%s", this->ToString());
    CConsole::SetColor(CConsole::LIGHT_GRAY);
#endif
}

void CConnection::RecvMessageOpenAckResponder(CPacketConnectionMessage* packet)
{
    // Received an OPEN-ACK message

#ifdef LOG_FLOW
    CConsole::SetColor(CConsole::DARK_BLUE);
    printf("\n\tT = %8.3lf\tRecvResponder(OPEN_ACK) : %s -> ", this->sim->Time(), this->ToString());
    CConsole::SetColor(CConsole::LIGHT_GRAY);
#endif

    // Check the packet source and destination
    assert(packet->Dst() == this->id);
    assert(packet->DstEntry() == this->idEntry);
    assert(packet->Flow() == this->flow);

    // Check the state
    switch(this->state)
    {
    case OPENING:                   // Change to OPENED / none / none
        {
            // Check the control timer is set
            assert(this->timerControl->IsSet());

            // Cancel the control timer
            this->timerControl->Cancel();

            // Change the state
            this->state = OPENED;

            // Raise the event
            (*this->eventOpen)(this, OPEN_SUCCESS);
        }
        break;
    case CLOSING: break;            // Ignore in CLOSING state
    default: assert(0);             // Exception for other state
    }

#ifdef LOG_FLOW
    CConsole::SetColor(CConsole::DARK_BLUE);
    printf("%s", this->ToString());
    CConsole::SetColor(CConsole::LIGHT_GRAY);
#endif
}

void CConnection::RecvMessageCloseResponder(CPacketConnectionMessage* packet)
{
    // Received a CLOSE message

#ifdef LOG_FLOW
    CConsole::SetColor(CConsole::DARK_BLUE);
    printf("\n\tT = %8.3lf\tRecvResponder(CLOSE) : %s -> ", this->sim->Time(), this->ToString());
    CConsole::SetColor(CConsole::LIGHT_GRAY);
#endif

    // Check the packet source and destination
    assert(packet->Dst() == this->id);
    assert(packet->DstEntry() == this->idEntry);
    assert(packet->Flow() == this->flow);

    // Check the state
    switch(this->state)
    {
    case OPENING:                   // Change to CLOSING / CLOSE_ACK / timer close
        {
            // Check the control timer is set
            assert(this->timerControl->IsSet());

            // Cancel the control timer
            this->timerControl->Cancel();

            // Send a CLOSE-ACK message
            CPacketConnectionMessage* reply = new CPacketConnectionMessage(
                this->flow,
                this->id,
                this->remoteId,
                this->idEntry,
                this->remoteIdEntry,
                CPacketConnectionMessage::CLOSE_ACK,
                this->sim->Time(),
                packet->TimeTx()
                );

            (*this->delegateSend)(this->port, this->remotePort, this->remoteAddress, 128, reply);

            // Change the state
            this->state = CLOSING;

            // Raise the event
            (*this->eventOpen)(this, OPEN_FAIL_REMOTE);

            // Set the control timer to close handler
            this->timerControl->SetAfter(CConnection::timerCloseTimeout, &CConnection::TimerClose);
        }
        break;
    case OPENED:                    // Change to CLOSING / CLOSE_ACK / timer close
        {
            // Check the control timer is not set
            assert(!this->timerControl->IsSet());

            // Send a CLOSE-ACK message
            CPacketConnectionMessage* reply = new CPacketConnectionMessage(
                this->flow,
                this->id,
                this->remoteId,
                this->idEntry,
                this->remoteIdEntry,
                CPacketConnectionMessage::CLOSE_ACK,
                this->sim->Time(),
                packet->TimeTx()
                );
            (*this->delegateSend)(this->port, this->remotePort, this->remoteAddress, 128, reply);

            // Change the state
            this->state = CLOSING;

            // Set the control timer to close handler
            this->timerControl->SetAfter(CConnection::timerCloseTimeout, &CConnection::TimerClose);
        }
        break;
    case CLOSING:                   // Change to CLOSING / CLOSE_ACK / none
        {
            // Check the control timer is set
            assert(this->timerControl->IsSet());

            // Send a CLOSE-ACK message
            CPacketConnectionMessage* reply = new CPacketConnectionMessage(
                this->flow,
                this->id,
                this->remoteId,
                this->idEntry,
                this->remoteIdEntry,
                CPacketConnectionMessage::CLOSE_ACK,
                this->sim->Time(),
                packet->TimeTx()
                );
            (*this->delegateSend)(this->port, this->remotePort, this->remoteAddress, 128, reply);

            // Leave the current state and timer
        }
        break;
    default: assert(0);             // Exception for other states 
    }

#ifdef LOG_FLOW
    CConsole::SetColor(CConsole::DARK_BLUE);
    printf("%s", this->ToString());
    CConsole::SetColor(CConsole::LIGHT_GRAY);
#endif
}

void CConnection::RecvMessageCloseAckResponder(CPacketConnectionMessage* packet)
{
    // Received a CLOSE-ACK message

#ifdef LOG_FLOW
    CConsole::SetColor(CConsole::DARK_BLUE);
    printf("\n\tT = %8.3lf\tRecvResponder(CLOSE_ACK) : %s -> ", this->sim->Time(), this->ToString());
    CConsole::SetColor(CConsole::LIGHT_GRAY);
#endif

    // Check the packet source and destination
    assert(packet->Dst() == this->id);
    assert(packet->DstEntry() == this->idEntry);
    assert(packet->Flow() == this->flow);

    // Check the state
    switch(this->state)
    {
    case CLOSING:                   // Change to WAITING / CLOSE_ACK_ACK / timer wait
        {
            // Check the control timer is set
            assert(this->timerControl->IsSet());

            // Cancel the control timer
            this->timerControl->Cancel();

            // Send a CLOSE-ACK-ACK message
            CPacketConnectionMessage* reply = new CPacketConnectionMessage(
                this->flow,
                this->id,
                this->remoteId,
                this->idEntry,
                this->remoteIdEntry,
                CPacketConnectionMessage::CLOSE_ACK_ACK,
                this->sim->Time(),
                packet->TimeTx()
                );
            (*this->delegateSend)(this->port, this->remotePort, this->remoteAddress, 128, reply);

            // Change the state
            this->state = WAITING;

            // Raise the event
            (*this->eventClose)(this, CLOSE_CONFIRMED);

            // Set the control timer to the waiting handler
            this->timerControl->SetAfter(CConnection::timerResponderWaitTimeout, &CConnection::TimerWait);
        }
        break;
    default: assert(0);             // Exception for other sattes
    }

#ifdef LOG_FLOW
    CConsole::SetColor(CConsole::DARK_BLUE);
    printf("%s", this->ToString());
    CConsole::SetColor(CConsole::LIGHT_GRAY);
#endif
}

void CConnection::RecvMessageCloseAckAckResponder(CPacketConnectionMessage* packet)
{
    // Received a CLOSE-ACK-ACK message

#ifdef LOG_FLOW
    CConsole::SetColor(CConsole::DARK_BLUE);
    printf("\n\tT = %8.3lf\tRecvResponder(CLOSE_ACK_ACK) : %s -> ", this->sim->Time(), this->ToString());
    CConsole::SetColor(CConsole::LIGHT_GRAY);
#endif

    // Check the packet source and destination
    assert(packet->Dst() == this->id);
    assert(packet->DstEntry() == this->idEntry);
    assert(packet->Flow() == this->flow);

    // Check the state
    switch(this->state)
    {
    case CLOSING:                   // Change to WAITING / none / timer wait
        {
            // Check the control timer is set
            assert(this->timerControl->IsSet());

            // Cancel the control timer
            this->timerControl->Cancel();

            // Change the state
            this->state = WAITING;

            // Raise the event
            (*this->eventClose)(this, CLOSE_CONFIRMED);

            // Set the control timer to the waiting handler
            this->timerControl->SetAfter(CConnection::timerRequesterWaitTimeout, &CConnection::TimerWait);
        }
        break;
    case CLOSED:
    case WAITING:
        break;                      // Ignore in CLOSED and WAITING state
    default: assert(0);             // Exception for other states
    }

#ifdef LOG_FLOW
    CConsole::SetColor(CConsole::DARK_BLUE);
    printf("%s", this->ToString());
    CConsole::SetColor(CConsole::LIGHT_GRAY);
#endif
}

void CConnection::TimerOpen(CTimerInfo* info)
{
    // Check the state
    switch(this->state)
    {
    case OPENING:                   // Change to CLOSED / none / none
        {
            // Change the state
            this->state = CLOSED;

            // Raise the event
            (*this->eventOpen)(this, OPEN_FAIL_TIMEOUT);

            // Call the dispose function to relase the resources for this connection
            (*this->callDispose)(this);
        }
        break;
    default: assert(0);             // Exception for other states
    }
}

void CConnection::TimerClose(CTimerInfo* info)
{
    // Check the state
    switch(this->state)
    {
    case CLOSING:                   // Change to WAITING / none / timer wait
        {
            // Change the state
            this->state = WAITING;

            // Raise the event
            (*this->eventClose)(this, CLOSE_TIMEOUT);

            // Set the control timer to the waiting handler
            this->timerControl->SetAfter(CConnection::timerDefaultWaitTimeout, &CConnection::TimerWait);
        }
        break;
    default: assert(0);             // Exception for other states
    }
}

void CConnection::TimerCancel(CTimerInfo* info)
{
    // Check the state
    switch(this->state)
    {
    case CANCELING:                 // Change to CLOSED / none / none
        {
            // Change the state
            this->state = CLOSED;

            // Raise the event
            (*this->eventClose)(this, CLOSE_TIMEOUT);

            // Call the dispose function to relase the resources for this connection
            (*this->callDispose)(this);
        }
        break;
    default: assert(0);             // Exception for other states
    }
}

void CConnection::TimerWait(CTimerInfo* info)
{
    // Check the state
    switch(this->state)
    {
    case WAITING:                   // Change to CLOSED / none / none
        {
            // Change the state
            this->state = CLOSED;

            // Raise the event
            (*this->eventClose)(this, CLOSE_COMPLETE);

            // Call the dispose function to release the resources for this connection
            (*this->callDispose)(this);
        }
        break;
    default: assert(0);             // Exception for other states
    }
}

char* CConnection::ToString() const
{
    sprintf((char*)this->str, "[ l=*:%u:%u:%u r=%u:%u:%u:%u t=%s s=%s ]",
        this->port, this->id, this->idEntry, this->remoteAddress, this->remotePort, this->remoteId, this->remoteIdEntry,
        CConnection::strConnectionType[this->type], CConnection::strState[this->state]
        );

    return (char*)this->str;
}