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

#ifndef SST_REGCLI_H
#define SST_REGCLI_H

#include <QSet>

#include "reg.h"
#include "sock.h"
#include "timer.h"

class QHostInfo;


namespace SST {

class Host;
class RegReceiver;

class RegClient : public QObject
{
        friend class RegReceiver;
        Q_OBJECT

private:
        static const int maxRereg = 60*60*1000; // Max time before rereg - 1 hr


        Host *const h;          // Pointer to our per-host state

        enum State {
                Idle = 0,       // Unregistered and not doing anything
                Resolve,        // Resolving rendezvous server's host name
                Insert1,        // Sent Insert1 request, waiting response
                Insert2,        // Sent Insert2 request, waiting response
                Registered,     // Successfully registered
        } state;

        // DNS resolution info
        QString srvname;        // DNS hostname or IP address of server
        quint16 srvport;        // Port number of registration server
        int lookupid;           // QHostInfo lookupId for DNS resolution
        QList<QHostAddress> addrs;      // Server addresses from resolution
        RegInfo inf;            // Registration metadata

        // Registration process state
        QByteArray idi;         // Initiator's identity (i.e., mine)
        QByteArray ni;          // Initiator's nonce
        QByteArray nhi;         // Initiator's hashed nonce
        QByteArray chal;        // Responder's challenge from Insert1 reply
        QByteArray key;         // Our encoded public key to send to server
        QByteArray sig;         // Our signature to send in Insert2

        // Outstanding lookups and searches for which we're awaiting replies.
        QSet<QByteArray> lookups;       // IDs we're doing lookups on
        QSet<QByteArray> punches;       // Lookups with notify requests
        QSet<QString> searches;         // Strings we're searching for

        // Retry state
        Timer retrytimer;       // Retransmission timer
        bool persist;           // True if we should never give up

        Timer reregtimer;       // Counts lifetime of our reg entry

        // Error state
        QString err;


        // As the result of an error, disconnect and notify the client.
        void fail(const QString &error);

public:
        RegClient(Host *h, QObject *parent = NULL);
        ~RegClient();

        // Set the metadata to attach to our registration
        inline RegInfo info() { return inf; }
        inline void setInfo(const RegInfo &info) { inf = info; }

        // Attempt to register with the specified registration server.
        // We'll send a stateChanged() signal when it succeeds or fails.
        void registerAt(const QString &srvhost,
                        quint16 port = REGSERVER_DEFAULT_PORT);

        // Attempt to re-register with the same server previously indicated.
        void reregister();

        inline QString serverName() { return srvname; }
        inline quint16 serverPort() { return srvport; }

        inline QString errorString() { return err; }
        inline void setErrorString(const QString &err) { this->err = err; }

        inline bool idle() { return state == Idle; }
        inline bool registered() { return state == Registered; }
        inline bool registering() { return !idle() && !registered(); }

        // A persistent RegClient will never give up trying to register,
        // and will try to re-register if its connection is lost.
        inline void setPersistent(bool persist) { this->persist = persist; }
        inline bool isPersistent() { return persist; }

        // Request information about a specific ID from the server.
        // Will send a lookupDone() signal when the request completes.
        // If 'notify', ask regserver to notify the target as well.
        // Must be in the registered() state to initiate a lookup.
        void lookup(const QByteArray &id, bool notify = false);

        // Search for IDs of clients with metadata matching a search string.
        // Will send a searchDone() signal when the request completes.
        // Must be in the registered() state to initiate a search.
        void search(const QString &text);

        // Disconnect from our server or cancel the registration process,
        // and return immediately to the idle state.
        void disconnect();


signals:
        void stateChanged();
        void lookupDone(const QByteArray &id, const Endpoint &loc,
                        const RegInfo &info);
        void lookupNotify(const QByteArray &id, const Endpoint &loc,
                        const RegInfo &info);
        void searchDone(const QString &text, const QList<QByteArray> ids,
                        bool complete);

private:
        void goInsert1();
        void sendInsert1();
        void gotInsert1Reply(XdrStream &rs);

        void goInsert2();
        void sendInsert2();
        void gotInsert2Reply(XdrStream &rs);

        void sendLookup(const QByteArray &id, bool notify);
        void gotLookupReply(XdrStream &rs, bool isnotify);

        void sendSearch(const QString &text);
        void gotSearchReply(XdrStream &rs);

        void send(const QByteArray &msg);


private slots:
        void resolveDone(const QHostInfo &hi);  // DNS lookup done
        void timeout(bool fail);                // Retry timer timeout
        void reregTimeout();                    // Reregister timeout
};

// Private helper class for RegClient -
// attaches to our Socket and dispatches control messages to different clients
class RegReceiver : public SocketReceiver
{
        friend class RegClient;
        friend class RegHostState;

private:
        // Global hash table of active RegClient instances,
        // for dispatching incoming messages based on hashed nonce (nhi).
        QHash<QByteArray,RegClient*> nhihash;


        RegReceiver(Host *h);
        virtual void receive(QByteArray &msg, XdrStream &ds,
                                const SocketEndpoint &src);
};

// Per-host state for the registration client.
class RegHostState : public QObject
{
        friend class RegClient;
        Q_OBJECT

private:
        RegReceiver rcvr;

        // Global registry of every RegClient for this host, so we can
        // produce signals when RegClients are created or destroyed.
        QSet<RegClient*> cliset;

public:
        inline RegHostState(Host *h) : rcvr(h) { }

        inline QList<RegClient*> regClients()
                { return cliset.toList(); }

signals:
        void regClientCreate(RegClient *rc);
        void regClientDestroy(RegClient *rc);
};

} // namespace SST

#endif  // SST_REGCLI_H

---