/Users/baford/proj/netsteria/sst/lib/sock.h

//
// Class implementing a UDP socket for Netsteria use.
// Multiplexes between flow-setup/key exchange traffic (which goes to key.cc)
// and per-flow data traffic (which goes to flow.cc).
// XX Rename Socket* to Net* or Link*?
// 
#ifndef SST_SOCK_H
#define SST_SOCK_H

#include <QHash>
#include <QPair>
#include <QPointer>
#include <QHostAddress>
#include <QUdpSocket>
#include <QPointer>

#include "util.h"

#define NETSTERIA_DEFAULT_PORT  8661

class QSettings;


namespace SST {

class XdrStream;
class Socket;
class SocketFlow;
class SocketReceiver;
class SocketHostState;


// An 8-bit channel number distinguishes different flows
// between the same pair of socket-layer endpoints.
// Channel number 0 is always invalid.
typedef quint8 Channel;


// SockEndpoint builds on the basic Endpoint class
// to keep an association with a particular Socket as well.
struct SocketEndpoint : public Endpoint
{
        QPointer<Socket> sock;

        inline SocketEndpoint() { }
        inline SocketEndpoint(const SocketEndpoint &other)
                : Endpoint(other), sock(other.sock) { }
        SocketEndpoint(const Endpoint &ep, Socket *sock);

        // Send a message to this endpoint on this socket
        bool send(const char *data, int size) const;
        inline bool send(const QByteArray &msg) const
                { return send(msg.constData(), msg.size()); }
};


class Socket : public QObject
{
        friend class SocketFlow;
        Q_OBJECT

private:
        SocketHostState *const h;

        QHash<QPair<Endpoint,Channel>, SocketFlow*> flows;

        bool act;


public:
        inline Socket(SocketHostState *host, QObject *parent = NULL)
                : QObject(parent), h(host), act(false) { }

        inline bool active() { return act; }

        void setActive(bool act);

        virtual bool bind(const QHostAddress &addr = QHostAddress::Any,
                quint16 port = 0,
                QUdpSocket::BindMode mode = QUdpSocket::DefaultForPlatform) = 0;

        virtual bool send(const Endpoint &ep, const char *data, int size) = 0;
        inline bool send(const Endpoint &ep, const QByteArray &msg)
                { return send(ep, msg.constData(), msg.size()); }

        virtual QList<Endpoint> localEndpoints() = 0;

        virtual quint16 localPort() = 0;

        inline SocketFlow *flow(const Endpoint &dst, Channel chan)
                { return flows.value(QPair<Endpoint,Channel>(dst, chan)); }

        virtual QString errorString() = 0;


protected:

        void receive(QByteArray &msg, const SocketEndpoint &src);
};


class UdpSocket : public Socket
{
        Q_OBJECT

        QUdpSocket usock;

public:
        UdpSocket(SocketHostState *host, QObject *parent = NULL);

        bool bind(const QHostAddress &addr = QHostAddress::Any,
                quint16 port = 0,
                QUdpSocket::BindMode mode = QUdpSocket::DefaultForPlatform);

        // Send a packet on this UDP socket.
        // Implements of Socket::send().
        bool send(const Endpoint &ep, const char *data, int size);

        // Return all known local endpoints referring to this socket.
        // Implements Socket::localEndpoints().
        QList<Endpoint> localEndpoints();

        quint16 localPort() { return usock.localPort(); }

        inline QString errorString() { return usock.errorString(); }


private slots:
        void udpReadyRead();
};


// Base class for flows that may be bound to a socket,
// for dispatching received packets based on endpoint and channel number.
// May be used as an abstract base by overriding the receive() method,
// or used as a concrete class by connecting to the received() signal.
class SocketFlow : public QObject
{
        friend class Socket;
        Q_OBJECT

private:
        Socket *sock;           // Socket we're currently bound to, if any
        Endpoint remoteep;      // UDP endpoint of remote end
        Channel localchan;      // Channel number of this flow at local node
        Channel remotechan;     // Channel number of this flow at remote node
        bool active;            // True if we're sending and accepting packets

public:
        SocketFlow(QObject *parent = NULL);
        virtual ~SocketFlow();

        // Set up for communication with specified remote endpoint,
        // allocating and binding a local channel number in the process.
        // Returns 0 if no channels are available for specified endpoint.
        Channel bind(Socket *sock, const Endpoint &remoteep);
        inline Channel bind(const SocketEndpoint &remoteep)
                { return bind(remoteep.sock, remoteep); }

        // Bind to a particular channel number.
        // Returns false if the channel is already in use.
        bool bind(Socket *sock, const Endpoint &remoteep, Channel chan);

        // Set the channel number to direct packets to the remote endpoint.
        // This MUST be done before a new flow can be activated.
        inline void setRemoteChannel(Channel chan) { remotechan = chan; }

        // Return the remote endpoint we're bound to, if any
        inline SocketEndpoint remoteEndpoint()
                { return SocketEndpoint(remoteep, sock); }

        // Return current local and remote channel numbers
        inline Channel localChannel() { return localchan; }
        inline Channel remoteChannel() { return remotechan; }

        // Start or stop the flow.
        virtual void start();
        virtual void stop();

        // Return infrormation about flow state.
        inline bool isActive() { return active; }
        inline bool isBound() { return sock != NULL; }

        // Stop flow and unbind from any currently bound remote endpoint.
        void unbind();

protected:

        inline bool udpSend(QByteArray &pkt) const
                { Q_ASSERT(active); return sock->send(remoteep, pkt); }

        virtual void receive(QByteArray &msg, const SocketEndpoint &src);

signals:
        void received(QByteArray &msg, const SocketEndpoint &src);
};


// SocketReceiver is an abstract base class for control protocols
// that need to multiplex onto Netsteria sockets:
// e.g., the key exchange protocol (key*) and registration protocol (reg*).
// A control protocol is identified by a 32-bit magic value,
// whose topmost byte must be zero to distinguish it from flows.
class SocketReceiver : public QObject
{
        friend class Socket;

        SocketHostState *const h;
        quint32 mag;

protected:
        void bind(quint32 magic);
        void unbind();

        inline bool isBound() { return mag != 0; }
        inline quint32 magic() { return mag; }

        // Socket calls this method to dispatch control messages.
        // The supplied XdrStream is positioned just after the
        // 4-byte magic value identifying the control protocol.
        virtual void receive(QByteArray &msg, XdrStream &ds,
                                const SocketEndpoint &src) = 0;

        inline SocketReceiver(SocketHostState *h, QObject *parent = NULL)
                : QObject(parent), h(h), mag(0) { }
        inline SocketReceiver(SocketHostState *h, quint32 magic,
                                QObject *parent = NULL)
                : QObject(parent), h(h), mag(0) { bind(magic); }
        virtual ~SocketReceiver();

};


class SocketHostState : public QObject
{
        friend class Socket;
        friend class SocketReceiver;

        Q_OBJECT

        QList<Socket*> actsocks;

        QPointer<Socket> mainsock;

        QHash<quint32, SocketReceiver*> receivers;


public:
        inline SocketHostState() : mainsock(NULL) { }
        virtual ~SocketHostState();

        inline QList<Socket*> activeSockets()
                { return actsocks; }

        QList<Endpoint> activeLocalEndpoints();

        inline SocketReceiver *lookupReceiver(quint32 magic)
                { return receivers.value(magic); }


        virtual Socket *newSocket(QObject *parent = NULL);

        Socket *initSocket(QSettings *settings = NULL,
                int defaultport = NETSTERIA_DEFAULT_PORT);
};

} // namespace SST


// Hash function for (Endpoint,Channel) tuples
inline uint qHash(const QPair<SST::Endpoint,SST::Channel> fl)
        { return qHash(fl.first) + qHash(fl.second); }


#endif  // SST_SOCK_H

---