UdpSwitch.cpp

Go to the documentation of this file.

/*

Copyright (C) 2005-2007 by Peter Dimov.

This file is part of Calitko (http://www.calitko.org).

Calitko is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

Calitko is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Calitko; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

*/

#include "Qt.h"
#include "Imports.h"
#include "UdpSwitch.h"
#include "UdpConnection.h"

namespace Protocols {
namespace Transports {

enum Constants
{
    MaximalReadBufferLength     = 4096
};

class UdpSwitchPrivate
{
    REFERENCE_OBJECT (UdpSwitchPrivate)

public:
    typedef QMap <NodeAddress, UdpConnection *> ReadMap;
    typedef QMap <UdpConnection *, NodeAddress> WriteMap;

    QUdpSocket  *socket;
    bool        isStarted;
    bool        isAcceptingIncomingConnections;
    ReadMap     readMap;
    WriteMap    writeMap;

    UdpSwitchPrivate()
     :  socket (new QUdpSocket), isStarted (false),
        isAcceptingIncomingConnections (false), readMap(), writeMap()
    {}

    ~UdpSwitchPrivate()
    {
        delete socket;
    }
};

} // namespace Transports;
} // namespace Protocols;

using namespace Protocols::Transports;

UdpSwitch::UdpSwitch()
 :  p (new UdpSwitchPrivate())
{
    QObject::connect (p->socket, SIGNAL (readyRead()), this, SLOT (readyRead()));
}

UdpSwitch::~UdpSwitch()
{
    delete p;
}


bool UdpSwitch::start (const NodeAddress &switchAddress,
                       bool acceptIncomingConnections)
{
    p->isAcceptingIncomingConnections = acceptIncomingConnections;
    p->isStarted = p->socket->bind (switchAddress.hostAddress(),
                                    switchAddress.hostPort());
    // \todo Emit signals started() and startFailed() ?
    return p->isStarted;
}

void UdpSwitch::stop()
{
    Q_ASSERT (p->isStarted);

    p->socket->close();
    p->isStarted = false;
    // \todo Wait for disconnected() to emit stopped() ?
    // \todo Close all associated UdpConnections!
}

bool UdpSwitch::openChannel (UdpConnection *udpConnection,
                             const NodeAddress &nodeAddress)
{
    Q_ASSERT (p->isStarted);
    // \todo Enable to open a channel for which we already have datagrams
    // pending (accepted connection)
    if (p->readMap.contains (nodeAddress) || p->writeMap.contains (udpConnection))
        return false;

    p->readMap.insert (nodeAddress, udpConnection);
    p->writeMap.insert (udpConnection, nodeAddress);
    return true;
}

void UdpSwitch::closeChannel (UdpConnection *udpConnection)
{
    Q_ASSERT (p->isStarted);
    Q_ASSERT (p->writeMap.contains (udpConnection));

    NodeAddress nodeAddress = p->writeMap.take (udpConnection);
    p->readMap.take (nodeAddress);
}

bool UdpSwitch::writeDatagram (UdpConnection *udpConnection,
                               const char * data, qint64 maxSize)
{
    Q_ASSERT (p->isStarted);
    Q_ASSERT (p->writeMap.contains (udpConnection));

    NodeAddress nodeAddress = p->writeMap.value (udpConnection);
    qint64 bytesWritten = p->socket->writeDatagram (data, maxSize,
                                                    nodeAddress.hostAddress(),
                                                    nodeAddress.hostPort());
    // \todo Can bytesWritten be 0? If yes, then UdpConnection must be changed.
    Q_ASSERT (bytesWritten == -1 || bytesWritten == maxSize);
    return bytesWritten == maxSize;
}

void UdpSwitch::readyRead()
{
    Q_ASSERT (p->isStarted);

    if (!p->socket->hasPendingDatagrams())
        return;

    char            buffer [MaximalReadBufferLength];
    QHostAddress    hostAddress;
    quint16         hostPort;

    // socket->pendingDatagramSize() would return the size of the datagram
    // With the current approach we read the pending datagram and ignore
    // all data bigger than MaximalReadBufferLength.
    // \todo Is it better to just use a buffer of the correct size?
    qint64 bytesRead = p->socket->readDatagram (buffer, MaximalReadBufferLength,
                                                &hostAddress, &hostPort);

    NodeAddress nodeAddress (hostAddress, hostPort);
    UdpSwitchPrivate::ReadMap::iterator it  = p->readMap.find (nodeAddress);
    if (it != p->readMap.end()) {
        (*it)->datagramRead (QByteArray (buffer, bytesRead));
    } else if (p->isAcceptingIncomingConnections) {
        UdpConnection *incomingConnection = new UdpConnection (this);
        incomingConnection->connectToNode (nodeAddress);
        // The connect must always work:
        Q_ASSERT (incomingConnection->state() == Connection::ConnectedState);
        incomingConnection->datagramRead (QByteArray (buffer, bytesRead));
        emit connectionAccepted (incomingConnection);
    }
}

Copyright © 2006 Peter Dimov.
Powered by Doxygen.