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 = 1;
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
    //TODO maybe add checksum?
};

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.

    //all messages below here can only be sent from authenticated peers
    TIME, //time jumps + time scale updates
    LOCATION, //location changes
    SELECTION,

    ALIVE, //sent from a peer after no data was sent for about 5 seconds to indicate it is still alive
    MSGTYPE_MAX = ALIVE,
    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::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);

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

class SyncMessageHandler;

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

    void receiveMessage();

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

    void peerLog(const QString& msg);

    bool isValid;
    QAbstractSocket* sock; // The socket for communication with this peer
    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 isAuthenticated; // 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
};

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

    virtual bool handleMessage(QDataStream& stream, SyncRemotePeer& peer) = 0;
};

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


#endif