SyncProtocol.hpp

/*
 * Stellarium Remote Sync plugin
 * Copyright (C) 2015 Florian Schaukowitsch
 *
 * This program 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.
 *
 * This program 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 this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA  02110-1335, USA.
 */

#ifndef SYNCPROTOCOL_HPP_
#define SYNCPROTOCOL_HPP_

#include <QByteArray>
#include <QDataStream>
#include <QAbstractSocket>
#include <QUuid>

namespace SyncProtocol
{

//Important: All data should use the sized typedefs provided by Qt (i.e. qint32 instead of 4 byte int on x86)

const quint8 SYNC_PROTOCOL_VERSION = 2;
const QDataStream::Version SYNC_DATASTREAM_VERSION = QDataStream::Qt_5_0;
const QByteArray SYNC_MAGIC_VALUE = "StellariumSyncPluginProtocol";

typedef quint16 tPayloadSize;

struct SyncHeader
{
    quint8 msgType; //The SyncMessageType of the data
    SyncProtocol::tPayloadSize dataSize; //The size of the data part
};

QDataStream& operator<<(QDataStream& out, const SyncHeader& header);
QDataStream& operator>>(QDataStream& in, SyncHeader& header);

const qint64 SYNC_HEADER_SIZE = sizeof(quint8) + sizeof(tPayloadSize); //3 byte
const qint64 SYNC_MAX_PAYLOAD_SIZE = (2<<15) - 1; // 65535
const qint64 SYNC_MAX_MESSAGE_SIZE = SYNC_HEADER_SIZE + SYNC_MAX_PAYLOAD_SIZE;

enum SyncMessageType
{
    ERROR, //sent to the other party on protocol/auth error with a message, connection will be dropped afterwards
    SERVER_CHALLENGE, //sent as a challenge to the client on establishment of connection
    CLIENT_CHALLENGE_RESPONSE, //sent as a reply to the challenge
    SERVER_CHALLENGERESPONSEVALID, //sent from the server to the client after valid client hello was received.
    ALIVE, //sent from a peer after no data was sent for about 5 seconds to indicate it is still alive

    //all messages below here can only be sent from authenticated peers
    TIME, //time jumps + time scale updates
    LOCATION, //location changes
    SELECTION, //current selection changed
    STELPROPERTY, //stelproperty updates
    VIEW, //view change
    FOV, //fov change

    MSGTYPE_MAX = FOV,
    MSGTYPE_SIZE = MSGTYPE_MAX+1
};

inline QDebug& operator<<(QDebug& deb, SyncMessageType msg)
{
    switch (msg) {
        case SyncProtocol::ERROR:
            deb<<"ERROR";
            break;
        case SyncProtocol::SERVER_CHALLENGE:
            deb<<"SERVER_CHALLENGE";
            break;
        case SyncProtocol::CLIENT_CHALLENGE_RESPONSE:
            deb<<"CLIENT_CHALLENGE_RESPONSE";
            break;
        case SyncProtocol::SERVER_CHALLENGERESPONSEVALID:
            deb<<"SERVER_CHALLENGERESPONSEVALID";
            break;
        case SyncProtocol::TIME:
            deb<<"TIME";
            break;
        case SyncProtocol::LOCATION:
            deb<<"LOCATION";
            break;
        case SyncProtocol::SELECTION:
            deb<<"SELECTION";
            break;
        case SyncProtocol::STELPROPERTY:
            deb<<"STELPROPERTY";
            break;
        case SyncProtocol::VIEW:
            deb<<"VIEW";
            break;
        case SyncProtocol::FOV:
            deb<<"FOV";
            break;
        case SyncProtocol::ALIVE:
            deb<<"ALIVE";
            break;
        default:
            deb<<"UNKNOWN("<<int(msg)<<')';
            break;
    }
    return deb;
}

class SyncMessage
{
public:
    virtual ~SyncMessage() {}

    virtual SyncProtocol::SyncMessageType getMessageType() const = 0;

    qint64 createFullMessage(QByteArray& target) const;

    virtual void serialize(QDataStream& stream) const;
    virtual bool deserialize(QDataStream& stream, SyncProtocol::tPayloadSize dataSize);

    virtual QDebug debugOutput(QDebug dbg) const
    {
        return dbg;
    }

    friend QDebug operator<<(QDebug dbg, const SyncMessage& msg)
    {
        dbg = dbg<<msg.getMessageType()<<'[';
        dbg = msg.debugOutput(dbg);
        return dbg<<']';
    }

protected:
    static void writeString(QDataStream& stream, const QString& str);
    static QString readString(QDataStream& stream);
};

}

class SyncMessageHandler;

class SyncRemotePeer : public QObject
{
    Q_OBJECT
public:
    SyncRemotePeer(QAbstractSocket* socket, bool isServer, const QVector<SyncMessageHandler*>& handlerList);
    ~SyncRemotePeer();



    void writeMessage(const SyncProtocol::SyncMessage& msg);
    void writeData(const QByteArray& data, int size=-1);
    void writeError(const QString& err);

    void peerLog(const QString& msg) const;
    QDebug peerLog() const;

    bool isAuthenticated() const { return authenticated; }
    QUuid getID() const { return id; }

    void checkTimeout();
    void disconnectPeer();

    QString getError() const { return errorString; }
signals:
    void disconnected(bool cleanDisconnect);
private slots:
    void sockDisconnected();
    void sockError(QAbstractSocket::SocketError err);
    void sockStateChanged(QAbstractSocket::SocketState state);

    void receiveMessage();
private:
    QAbstractSocket* sock; // The socket for communication with this peer
    QDataStream stream;
    QString errorString;
    bool expectDisconnect;
    bool isPeerAServer; // True if this identifies a server
    QUuid id; // An ID value, currently not used for anything else than auth. The server always has a NULL UUID.
    bool authenticated; // True if the peer ran through the HELLO process and can receive/send all message types
    bool authResponseSent; //only for client use, tracks if the client has sent a resonse to the server challenge
    bool waitingForBody; //True if waiting for full message body (after header was received)
    SyncProtocol::SyncHeader msgHeader; //the last message header read/currently being processed
    qint64 lastReceiveTime; // The time the last data of this peer was received
    qint64 lastSendTime; //The time the last data was written to this peer
    QVector<SyncMessageHandler*> handlerList;
    QByteArray msgWriteBuffer; //Byte array used to construct messages before writing them

    friend class ServerAuthHandler;
    friend class ClientAuthHandler;
};

class SyncMessageHandler
{
public:
    virtual ~SyncMessageHandler() {}

    virtual bool handleMessage(QDataStream& stream, SyncProtocol::tPayloadSize dataSize,  SyncRemotePeer& peer) = 0;
};

class DummyMessageHandler : public SyncMessageHandler
{
public:
    virtual bool handleMessage(QDataStream &stream, SyncProtocol::tPayloadSize dataSize, SyncRemotePeer &peer)
    {
        stream.skipRawData(dataSize);
        return !stream.status();
    }
};

Q_DECLARE_INTERFACE(SyncMessageHandler,"Stellarium/RemoteSync/SyncMessageHandler/1.0")


#endif