ConnectionLayer.cpp

#include "Headers.h"
#include "ConnectionLayer.h"

CConnectionLayer::CConnectionLayer(
    CSimHandler*                                                        sim,
    __uint16                                                            port,
    __uint32                                                            connectionsMax,
    IDelegate5<void, __uint16, __uint16, CAddress, __byte, CPacket*>*   delegateSend,
    IDelegate2<void, CConnectionReceiver*, CPacket*>*                   delegateRecv,
    IDelegate2<bool, CAddress, CPacket*>*                               delegateAccept,
    IDelegate1<void, CConnectionSender*>*                               delegateAccepted,
    __uint32                                                            senderSegmentSize
    )
{
    assert(delegateSend);
    assert(delegateRecv);
    assert(delegateAccept);
    assert(delegateAccepted);

    // Simulator
    this->sim = sim;

    // Parameters
    this->port = port;
    this->connectionsMax = connectionsMax;
    this->connectionsNum = 0;

    // Delegates
    this->delegateSend = delegateSend;
    this->delegateRecv = delegateRecv;
    this->delegateAccept = delegateAccept;
    this->delegateAccepted = delegateAccepted;

    // Delegates (local)
    this->delegateDispose = new Delegate1<CConnectionLayer, void, CConnection*>(this, &CConnectionLayer::Dispose);

    // Sender
    this->senderSegmentSize = senderSegmentSize;

    // Connections
    this->connections = new CConnectionEntry[this->connectionsMax];

    // Connection entries
    for(__uint32 index = 0; index < this->connectionsMax; index++)
        this->connections[index].Entry(index);

    // Connection free list
    this->connectionsFree = this->connections;
    for(__uint32 index = 1; index < this->connectionsMax; index++)
    {
        this->connections[index-1].Next(&this->connections[index]);
        this->connections[index].Prev(&this->connections[index-1]);
    }

    // Receivers allocated list
    this->connectionsAlloc = NULL;
}

CConnectionLayer::~CConnectionLayer()
{
    // Connections
    for(__uint32 index = 0; index < this->connectionsMax; index++)
        if(this->connections[index].State() == CConnectionEntry::ASSIGNED)
            delete this->connections[index].Connection();

    delete[] this->connections;

    // Delegates
    delete this->delegateDispose;
}

CConnectionLayer::EResult CConnectionLayer::Create(CAddress dstAddress, __uint16 dstPort, CConnectionReceiver** receiver)
{
    // Create a receiver connection

    // Check if there is a free connection entry
    if(this->IsAvailable())
    {
        // Allocate entry
        __uint32 entry = this->Alloc();

        // Create the connection
        CConnectionReceiver* connection = new CConnectionReceiver(
            entry,
            this->port,
            this->sim,
            this->delegateSend,
            this->delegateRecv,
            this->delegateDispose,
            dstAddress,
            dstPort
            );

        // Assign the connection to the entry
        this->Assign(connection);

        // Set receiver
        *receiver = connection;

        return SUCCESS;
    }
    else return FAIL_MAX_CONNECTIONS_REACHED;
}


__uint32 CConnectionLayer::Alloc()
{
    // Allocate connection entry
    assert(this->connectionsNum < this->connectionsMax);
    assert(this->connectionsFree != NULL);

    // Get connection entry from the beginning of the free list
    CConnectionEntry* connectionEntry = this->connectionsFree;

    // Check entry is free
    assert(connectionEntry->State() == CConnectionEntry::FREE);

    // Shift the beginning of the free list
    if(this->connectionsFree->Next()) this->connectionsFree->Next()->Prev(NULL);
    this->connectionsFree = this->connectionsFree->Next();

    // Add the entry to the beginning of the allocated list
    connectionEntry->Next(this->connectionsAlloc);
    connectionEntry->Prev(NULL);
    if(this->connectionsAlloc) this->connectionsAlloc->Prev(connectionEntry);
    this->connectionsAlloc = connectionEntry;

    // Mark the entry as allocated
    connectionEntry->Alloc();

    // Increment number of connections
    this->connectionsNum++;

    return connectionEntry->Entry();
}

void CConnectionLayer::Assign(CConnection* connection)
{
    assert(connection);
    assert(connection->IdEntry() < this->connectionsMax);

    // Get the connection entry
    CConnectionEntry* connectionEntry = &this->connections[connection->IdEntry()];

    // Check the connection entry is allocated
    assert(connectionEntry->State() == CConnectionEntry::ALLOC);

    // Assign the connection to the entry
    connectionEntry->Assign(connection);
}

void CConnectionLayer::Free(__uint32 entry)
{
    // Free receiver entry
    assert(this->connectionsNum > 0);
    assert(entry < this->connectionsMax);

    // Get the connection entry
    CConnectionEntry* connectionEntry = &this->connections[entry];

    // Check the entry state (either allocated or assigned)
    assert(connectionEntry->State() != CConnectionEntry::FREE);

    // Remove the entry from the allocated list
    if(connectionEntry->Prev()) connectionEntry->Prev()->Next(connectionEntry->Next());
    if(connectionEntry->Next()) connectionEntry->Next()->Prev(connectionEntry->Prev());
    if(this->connectionsAlloc == connectionEntry) this->connectionsAlloc = this->connectionsAlloc->Next();

    // Add the entry to the beginning of the free list
    connectionEntry->Next(this->connectionsFree);
    connectionEntry->Prev(NULL);
    if(this->connectionsFree) this->connectionsFree->Prev(connectionEntry);
    this->connectionsFree = connectionEntry;

    // Increment number of connections
    this->connectionsNum--;

    // Change the state to free
    connectionEntry->Free();
}

bool CConnectionLayer::IsAvailable()
{
    return this->connectionsNum < this->connectionsMax;
}

CConnectionLayer::EResult CConnectionLayer::Recv(CAddress srcAddress, __uint16 srcPort, __uint16 dstPort, CPacketConnection* packet)
{
    // Received connection packet

    // Check transport layer port
    if(dstPort != this->port) return FAIL_INCORRECT_PORT;

    // If the packet destination is not set
    if(packet->Dst() == PACKET_INVALID_CONNECTION)
    {
        // Check if the packet is a connection message
        if(packet->TypeConnection() == CPacketConnection::MESSAGE)
        {
            // Check if the packet is an OPEN message
            CPacketConnectionMessage* message = type_cast<CPacketConnectionMessage*>(packet);

            if(message->TypeMessage() == CPacketConnectionMessage::OPEN)
            {
                // Send the OPEN request information to the client
                if((*this->delegateAccept)(srcAddress, packet->Payload()))
                {
                    // If the upper layer accepts the connection, check if there is a free connection entry
                    assert(this->IsAvailable());
                    if(this->IsAvailable())
                    {
                        // Allocate a new connection entry
                        __uint32 entry = this->Alloc();

                        // Create a new sender connection
                        CConnectionSender* connection = new CConnectionSender(
                            entry,
                            this->port,
                            this->sim,
                            this->delegateSend,
                            this->delegateDispose,
                            srcAddress,
                            srcPort,
                            message->Src(),
                            message->SrcEntry(),
                            this->senderSegmentSize
                            );

                        // Assign the connection to the entry
                        this->Assign(connection);

                        // Send the packet to the connection
                        type_cast<CConnection*>(connection)->Recv(srcAddress, packet);

                        // Send the connection to the upper layer
                        (*this->delegateAccepted)(connection);

                        return SUCCESS;
                    }
                    else return FAIL_MAX_CONNECTIONS_REACHED;
                }
                else return FAIL_NOT_ACCEPTED;
            }
            else return FAIL_INVALID_DESTINATION_MESSAGE;
        }
        else return FAIL_INVALID_DESTINATION_PACKET;
    }
    else
    {
        // Check the packet
        assert(packet->DstEntry() < this->connectionsMax);

        // Get the connection entry
        CConnectionEntry* connectionEntry = &this->connections[packet->DstEntry()];
        
        // If there is an assigned connection entry for the destination of this packet
        if(connectionEntry->State() == CConnectionEntry::ASSIGNED)
        {
            // If the endpoint is the destination of this packet
            if(connectionEntry->Connection()->Id() == packet->Dst())
            {
                // Pass the packet to the connection
                connectionEntry->Connection()->Recv(srcAddress, packet);

                return SUCCESS;
            }
        }
        return FAIL_CONNECTION_NOT_EXIST;
    }
}

CConnection* CConnectionLayer::Get(__uint32 id, __uint32 idEntry)
{
    // Get the connection entry
    CConnectionEntry* connectionEntry = &this->connections[idEntry];

    if(connectionEntry->State() != CConnectionEntry::ASSIGNED) return NULL;
    if(connectionEntry->Connection()->Id() != id) return NULL;

    return connectionEntry->Connection();
}


void CConnectionLayer::Dispose(CConnection* connection)
{
    assert(connection);

    // Free the connection entry
    this->Free(connection->IdEntry());

    // Delete the connection
    delete connection;
}