dev 2

ClientProtocol/ClientProtocol.pro

@@ -43,18 +43,22 @@ include($$PWD/../Qt-Secret/src/Qt-Secret.pri)
 
 
 SOURCES += \
+        abstractdata.cpp \
+        abstractnode.cpp \
         baseclient.cpp \
+        basenodeinfo.cpp \
         baseserver.cpp \
-        clientprotocol.cpp \
-        connectioninfo.cpp
+        clientprotocol.cpp
 
 
 HEADERS += \
+        abstractdata.h \
+        abstractnode.h \
         baseclient.h \
+        basenodeinfo.h \
         baseserver.h \
         clientprotocol.h \
         clientprotocol_global.h \
-        config.h \
-        connectioninfo.h
+        config.h
 
 include($$PWD/ClientProtocolIncludes.pri)

ClientProtocol/abstractdata.cpp

@@ -0,0 +1,78 @@
+#include "abstractdata.h"
+#include <QDataStream>
+#include <typeinfo>
+#include "clientprotocol.h"
+
+namespace ClientProtocol {
+
+
+
+static QMap<size_t, unsigned char> commandTable = {};
+
+
+unsigned char ClientProtocol::AbstractData::cmd() const {
+    return _cmd;
+}
+
+AbstractData::AbstractData() {
+    size_t hash = typeid(*this).hash_code();
+    if (!commandTable.contains(hash)) {
+        commandTable[hash] = static_cast<unsigned char>(commandTable.size());
+    }
+    _cmd = commandTable[hash];
+}
+
+AbstractData::AbstractData(const ClientProtocol::BasePackage &package):
+    AbstractData() {
+
+    fromBytes(package.data);
+}
+
+bool AbstractData::fromBytes(const QByteArray &data) {
+
+    if (data.isEmpty())
+        return false;
+
+    QDataStream stream(data);
+    fromStream(stream);
+    return true;
+}
+
+QByteArray AbstractData::toBytes() const {
+    QByteArray res;
+    QDataStream stream(&res, QIODevice::WriteOnly);
+    toStream(stream);
+    return res;
+}
+
+bool AbstractData::toPackage(BasePackage &package,
+                                             unsigned char trigeredCommand) const {
+
+    if (!isValid()) {
+        return false;
+    }
+
+    package.data = toBytes();
+
+    package.hdr.command = _cmd;
+    package.hdr.triggerCommnad = trigeredCommand;
+    package.hdr.size = static_cast<unsigned short>(package.data.size());
+
+    return package.isValid();
+}
+
+QDataStream &AbstractData::fromStream(QDataStream &stream) {
+    stream >> _cmd;
+    return stream;
+}
+
+QDataStream &AbstractData::toStream(QDataStream &stream) const {
+    stream << _cmd;
+    return stream;
+}
+
+bool AbstractData::isValid() const {
+    return _cmd;
+}
+
+}

ClientProtocol/abstractdata.h

@@ -0,0 +1,87 @@
+#ifndef ABSTRACTDATA_H
+#define ABSTRACTDATA_H
+#include "clientprotocol.h"
+
+namespace ClientProtocol {
+
+/**
+ * @brief The AbstractData class
+ * all data packages inherited this class.
+ */
+class CLIENTPROTOCOLSHARED_EXPORT AbstractData
+{
+private:
+    /**
+     * @brief _cmd - unique id of class using in Header of package for identification.
+     */
+    unsigned char _cmd = 0;
+
+protected:
+    /**
+     * @brief AbstractData
+     */
+    explicit AbstractData();
+
+    /**
+     * @brief AbstractData
+     * @param package
+     */
+    explicit AbstractData(const BasePackage& package);
+
+    /**
+     * @brief fromBytes - private initialisation of object from byte array
+     * @return true if all good
+     */
+    bool fromBytes(const QByteArray&);
+
+public:
+
+    /**
+     * @brief cmd
+     * @return command of package
+     */
+    unsigned char cmd() const;
+
+    /**
+     * @brief toBytes
+     * @return byte array for package
+     */
+    QByteArray toBytes() const;
+
+
+    /**
+     * @brief toPackage
+     * @param package - return value
+     * @param trigeredCommand - old cmd
+     * @return retorn package object created from this object.
+     */
+    bool toPackage(BasePackage &package, unsigned char trigeredCommand = 0) const;
+
+    /**
+     * @brief fromStream
+     * @param stream
+     * @return stream
+     */
+    virtual QDataStream& fromStream(QDataStream& stream);
+
+    /**
+     * @brief toStream
+     * @param stream
+     * @return stream
+     */
+    virtual QDataStream& toStream(QDataStream& stream) const;
+
+    /**
+     * @brief isValid
+     * @return true if class isValid
+     */
+    virtual bool isValid() const;
+
+    virtual ~AbstractData();
+
+
+};
+}
+
+
+#endif // ABSTRACTDATA_H

ClientProtocol/abstractnode.cpp

@@ -0,0 +1,8 @@
+#include "abstractnode.h"
+namespace ClientProtocol {
+
+AbstractNode::AbstractNode()
+{
+
+}
+}

ClientProtocol/abstractnode.h

@@ -0,0 +1,20 @@
+#ifndef ABSTRACTNODE_H
+#define ABSTRACTNODE_H
+
+#include "basenodeinfo.h"
+#include "clientprotocol.h"
+
+#include <QAbstractSocket>
+
+namespace ClientProtocol {
+
+class AbstractNode
+{
+private:
+    QAbstractSocket *_destination = nullptr;
+    QHash<unsigned int, BaseNodeInfo*> _connections;
+public:
+    AbstractNode();
+};
+}
+#endif // ABSTRACTNODE_H

ClientProtocol/baseclient.cpp

@@ -58,7 +58,7 @@ void BaseClient::updateStatuses(Command extCmd, Command cmd, Type type, const QB
     }
 }
 
-bool BaseClient::receiveData(const QByteArray &obj, Header hdr) {
+bool BaseClient::receiveData(const QByteArray &obj, BaseHeader hdr) {
 
     auto command = static_cast<Command>(hdr.command);
     auto requesCommand = static_cast<Command>(hdr.requestCommand);
@@ -128,8 +128,8 @@ void BaseClient::incommingData() {
 
     } else {
         memcpy(&_downloadPackage.hdr,
-               array.data(), sizeof(Header));
-        _downloadPackage.data.append(array.mid(sizeof(Header)));
+               array.data(), sizeof(BaseHeader));
+        _downloadPackage.data.append(array.mid(sizeof(BaseHeader)));
     }
 
     if (_downloadPackage.isValid()) {
@@ -159,7 +159,7 @@ BaseClient::BaseClient(const QString &addrress, unsigned short port, QObject *pt
             this, &BaseClient::handleDisconnected);
 }
 
-bool BaseClient::sendPackage(Package &pkg) {
+bool BaseClient::sendPackage(BasePackage &pkg) {
     if (!pkg.isValid()) {
         return false;
     }
@@ -190,7 +190,7 @@ unsigned char BaseClient::nextIndex() {
 
 bool BaseClient::ping() {
 
-    Package pcg;
+    BasePackage pcg;
 
     if (!pcg.create(Command::Ping, Type::Request)) {
         return false;
@@ -224,7 +224,7 @@ bool BaseClient::login(const QString &gmail, const QByteArray &pass, bool newUse
         return false;
     }
 
-    Package pcg;
+    BasePackage pcg;
 
     Login login;
 
@@ -278,7 +278,7 @@ bool BaseClient::updateData() {
         return false;
     }
 
-    Package pcg;
+    BasePackage pcg;
 
     UpdatePlayerData rec;
     rec.setToken(_token);
@@ -304,7 +304,7 @@ bool BaseClient::savaData(const QList<int>& gameData) {
         return false;
     }
 
-    Package pcg;
+    BasePackage pcg;
 
     GameData rec;
     rec.setToken(_token);
@@ -336,7 +336,7 @@ bool BaseClient::getItem(int id) {
         return false;
     }
 
-    Package pcg;
+    BasePackage pcg;
 
     GetItem rec;
     rec.setToken(_token);
@@ -366,7 +366,7 @@ bool BaseClient::getPlayer(int id){
         return false;
     }
 
-    Package pcg;
+    BasePackage pcg;
 
     UpdatePlayerData rec;
     rec.setToken(_token);
@@ -400,7 +400,7 @@ bool BaseClient::setSubscribe(Command cmd, bool subscribe, int id) {
         return false;
     }
 
-    Package pcg;
+    BasePackage pcg;
 
     WebSocket rec;
     rec.setId(0);

ClientProtocol/baseclient.h

@@ -19,7 +19,7 @@ class CLIENTPROTOCOLSHARED_EXPORT BaseClient: public QObject
     Q_OBJECT
 private:
     QTcpSocket *_destination;
-    Package _downloadPackage;
+    BasePackage _downloadPackage;
     QByteArray _token;
     int currentIndex = 0;
     QHash<unsigned char, QVariantMap> _requestsMap;
@@ -27,10 +27,10 @@ private:
     QString _address = LOCAL_SNAKE_SERVER;
     unsigned short _port = DEFAULT_SNAKE_PORT;
 
-    bool receiveData(const QByteArray &obj, Header hdr);
+    bool receiveData(const QByteArray &obj, BaseHeader hdr);
     void setLoginStatus(bool newStatus);
     void setOnlineStatus(bool newStatus);
-    bool sendPackage(Package &pkg);
+    bool sendPackage(BasePackage &pkg);
     inline unsigned char nextIndex();
 
 

ClientProtocol/basenodeinfo.cpp

@@ -0,0 +1,88 @@
+#include "basenodeinfo.h"
+#include <QTcpSocket>
+#include <QHostAddress>
+
+namespace ClientProtocol {
+
+
+int BaseNodeInfo::getKarma() const {
+    return karma;
+}
+
+void BaseNodeInfo::setKarma(int value) {
+    karma = value;
+
+    if (isBaned()) {
+        disconnect();
+    }
+}
+
+QAbstractSocket *BaseNodeInfo::getSct() const {
+    return _sct;
+}
+
+void BaseNodeInfo::setSct(QAbstractSocket *value) {
+    _sct = value;
+}
+
+QByteArray BaseNodeInfo::getToken() const {
+    return token;
+}
+
+void BaseNodeInfo::setToken(const QByteArray &value) {
+    token = value;
+}
+
+Relations BaseNodeInfo::getRel() const {
+    return _rel;
+}
+
+void BaseNodeInfo::setRel(const Relations &rel) {
+    _rel = rel;
+}
+
+void BaseNodeInfo::disconnect() {
+    if (_sct) {
+        _sct->close();
+        token = "";
+        _sct->deleteLater();
+        _sct = nullptr;
+    }
+}
+
+unsigned int BaseNodeInfo::id() const {
+    if (_sct)
+        return (qHash(_sct->peerAddress()));
+
+    return 0;
+}
+
+void BaseNodeInfo::ban() {
+    karma = BANED_KARMA;
+    disconnect();
+}
+
+bool BaseNodeInfo::isBaned() const {
+    return karma < 1;
+}
+
+void BaseNodeInfo::unBan() {
+    karma = RESTORE_KARMA;
+}
+
+bool BaseNodeInfo::isValid() const {
+    return _sct;
+}
+
+BaseNodeInfo::BaseNodeInfo(QAbstractSocket *tcp, int kar) {
+    _sct = tcp;
+    karma = kar;
+    token = "";
+}
+
+BaseNodeInfo::~BaseNodeInfo() {
+    if (_sct) {
+        _sct->deleteLater();
+    }
+}
+}

ClientProtocol/basenodeinfo.h

@@ -0,0 +1,127 @@
+#ifndef CONNECTIONINFO_H
+#define CONNECTIONINFO_H
+
+#include "clientprotocol_global.h"
+
+#include <QByteArray>
+
+class QAbstractSocket;
+namespace ClientProtocol {
+
+#define NOT_VALID_CARMA 0xFF
+#define DEFAULT_KARMA   100
+#define RESTORE_KARMA   20
+#define BANED_KARMA     0
+
+enum class Relations {
+    Undefined,
+    Client,
+    Node,
+    Server
+};
+
+class CLIENTPROTOCOLSHARED_EXPORT BaseNodeInfo {
+
+private:
+    QAbstractSocket *_sct = nullptr;
+    Relations _rel = Relations::Undefined;
+protected:
+
+    int karma = DEFAULT_KARMA;
+    QByteArray token;
+
+public:
+    /**
+     * @brief disconnect disconnect from host
+     */
+    void disconnect();
+
+    /**
+     * @brief id
+     * @return unique id of socket
+     */
+    unsigned int id() const;
+
+    /**
+     * @brief ban this node
+     */
+    void ban();
+
+    /**
+     * @brief isBaned
+     * @return true if node baned
+     */
+    bool isBaned() const;
+
+    /**
+     * @brief unBan
+     */
+    void unBan();
+
+    /**
+     * @brief isValid
+     * @return true if node is valid
+     */
+    virtual bool isValid() const;
+
+    /**
+     * @brief BaseNodeInfo
+     * @param tcp socket
+     * @param kar karma of node
+     */
+    explicit BaseNodeInfo(QAbstractSocket * tcp = nullptr,
+                   int kar = NOT_VALID_CARMA);
+    virtual ~BaseNodeInfo();
+
+    /**
+     * @brief getKarma
+     * @return node karma
+     */
+    int getKarma() const;
+
+    /**
+     * @brief setKarma
+     * @param value new node karma
+     */
+    void setKarma(int value);
+
+    /**
+     * @brief getSct
+     * @return socket
+     */
+    QAbstractSocket *getSct() const;
+
+    /**
+     * @brief setSct
+     * @param value - new socket
+     */
+    void setSct(QAbstractSocket *value);
+
+    /**
+     * @brief getToken
+     * @return tocken of node ()
+     */
+    QByteArray getToken() const;
+
+    /**
+     * @brief setToken
+     * @param valuenew tocken
+     */
+    void setToken(const QByteArray &value);
+
+    /**
+     * @brief getRel
+     * @return Relation of node
+     */
+    Relations getRel() const;
+
+    /**
+     * @brief setRel
+     * @param rel
+     */
+    void setRel(const Relations &rel);
+};
+}
+
+size_t qHash(const ClientProtocol::BaseNodeInfo& info);
+#endif // CONNECTIONINFO_H

ClientProtocol/baseserver.cpp

@@ -5,7 +5,7 @@
 
 namespace ClientProtocol {
 
-bool BaseServer::parsePackage(const Package &pkg, QAbstractSocket* sender) {
+bool BaseServer::parsePackage(const BasePackage &pkg, QAbstractSocket* sender) {
     if (!pkg.isValid()) {
         QuasarAppUtils::Params::verboseLog("incomming package is not valid!");
         changeKarma(sender->peerAddress().toIPv4Address(), CRITICAL_ERROOR);
@@ -25,7 +25,7 @@ bool BaseServer::parsePackage(const Package &pkg, QAbstractSocket* sender) {
             return false;
         }
 
-        Package pcg;
+        BasePackage pcg;
 
         if (!(pcg.create(Command::Ping, Type::Responke, &pkg.hdr))) {
             return false;
@@ -47,7 +47,7 @@ bool BaseServer::parsePackage(const Package &pkg, QAbstractSocket* sender) {
     return true;
 }
 
-bool BaseServer::sendPackage(const Package &pkg, QAbstractSocket * target) {
+bool BaseServer::sendPackage(const BasePackage &pkg, QAbstractSocket * target) {
     if (!pkg.isValid()) {
         return false;
     }
@@ -70,7 +70,7 @@ bool BaseServer::sendPackage(const Package &pkg, QAbstractSocket * target) {
 
 void BaseServer::ban(quint32 target) {
     if (!_connections[target]) {
-        _connections[target] = new Connectioninfo();
+        _connections[target] = new AbstractNode();
     }
 
     _connections[target]->ban();
@@ -88,7 +88,7 @@ bool BaseServer::registerSocket(QAbstractSocket *socket) {
     auto address = socket->peerAddress().toIPv4Address();
 
 
-    _connections[address] = new Connectioninfo(socket, DEFAULT_KARMA);
+    _connections[address] = new AbstractNode(socket, DEFAULT_KARMA);
 
     connect(socket, &QTcpSocket::readyRead, this, &BaseServer::avelableBytes);
     connect(socket, &QTcpSocket::disconnected, this, &BaseServer::handleDisconected);
@@ -157,9 +157,9 @@ void BaseServer::avelableBytes() {
         _downloadPackage.reset();
 
         memcpy(&_downloadPackage.hdr,
-               array.data(), sizeof(Header));
+               array.data(), sizeof(BaseHeader));
 
-        _downloadPackage.data.append(array.mid(sizeof(Header)));
+        _downloadPackage.data.append(array.mid(sizeof(BaseHeader)));
     }
 
     if (_downloadPackage.isValid()) {
@@ -241,7 +241,7 @@ void BaseServer::stop(bool reset) {
     }
 }
 
-void BaseServer::badRequest(quint32 address, const Header &req) {
+void BaseServer::badRequest(quint32 address, const BaseHeader &req) {
     auto client = _connections.value(address);
 
     if (!client) {
@@ -261,7 +261,7 @@ void BaseServer::badRequest(quint32 address, const Header &req) {
         return;
     }
 
-    Package pcg;
+    BasePackage pcg;
     if (!(pcg.create(Command::BadRequest, Type::Responke, &req))) {
         QuasarAppUtils::Params::verboseLog("Bad request detected, bud responce command not sendet!"
                                            " because package not created",
@@ -281,9 +281,9 @@ void BaseServer::badRequest(quint32 address, const Header &req) {
                                        QuasarAppUtils::Info);
 }
 
-bool BaseServer::sendResponse(const BaseNetworkObject *resp, quint32 address, const Header *req) {
+bool BaseServer::sendResponse(const BaseNetworkObject *resp, quint32 address, const BaseHeader *req) {
 
-    Package pcg;
+    BasePackage pcg;
 
     if (!pcg.create(resp, Type::Responke, req)) {
         QuasarAppUtils::Params::verboseLog("Response not sent because package not created",
@@ -293,12 +293,12 @@ bool BaseServer::sendResponse(const BaseNetworkObject *resp, quint32 address, co
     return sendResponse(&pcg, address, req);
 }
 
-bool BaseServer::sendResponse(Package *pcg, quint32 address, const Header *req) {
+bool BaseServer::sendResponse(BasePackage *pcg, quint32 address, const BaseHeader *req) {
     pcg->signPackage(req);
     return sendResponse(*pcg, address);
 }
 
-bool BaseServer::sendResponse(const Package &pcg, quint32 address)
+bool BaseServer::sendResponse(const BasePackage &pcg, quint32 address)
 {
     auto client = _connections.value(address);
 

ClientProtocol/baseserver.h

@@ -4,7 +4,7 @@
 #include "clientprotocol.h"
 
 #include <QTcpServer>
-#include "connectioninfo.h"
+#include "basenodeinfo.h"
 
 namespace ClientProtocol {
 
@@ -17,11 +17,11 @@ class CLIENTPROTOCOLSHARED_EXPORT BaseServer : public QTcpServer
 {
     Q_OBJECT
 private:
-    Package _downloadPackage;
-    QHash<quint32, Connectioninfo*> _connections;
+    BasePackage _downloadPackage;
+    QHash<quint32, AbstractNode*> _connections;
 
-    bool parsePackage(const Package &pkg, QAbstractSocket * sender);
-    bool sendPackage(const Package &pkg, QAbstractSocket *target);
+    bool parsePackage(const BasePackage &pkg, QAbstractSocket * sender);
+    bool sendPackage(const BasePackage &pkg, QAbstractSocket *target);
     bool registerSocket(QAbstractSocket *socket);
     bool changeKarma(quint32 addresss, int diff);
     inline bool isBaned(const QTcpSocket *) const;
@@ -41,12 +41,12 @@ public:
     bool run(const QString& ip, unsigned short port);
     void stop(bool reset = false);
 
-    void badRequest(quint32 address, const Header &req);
+    void badRequest(quint32 address, const BaseHeader &req);
 
     bool sendResponse(const BaseNetworkObject* resp,  quint32 address,
-                      const Header *req = nullptr);
-    bool sendResponse(Package *pcg, quint32 address, const Header *req = nullptr);
-    bool sendResponse(const Package &pcg, quint32 address);
+                      const BaseHeader *req = nullptr);
+    bool sendResponse(BasePackage *pcg, quint32 address, const BaseHeader *req = nullptr);
+    bool sendResponse(const BasePackage &pcg, quint32 address);
 
     void ban(quint32 target);
     void unBan(quint32 target);
@@ -69,7 +69,7 @@ public:
     bool setToken(quint32 address, const QByteArray &token);
 
 signals:
-    void incomingReques(Header hdr, const QByteArray &data, const quint32 &sender);
+    void incomingReques(BaseHeader hdr, const QByteArray &data, const quint32 &sender);
 };
 
 }

ClientProtocol/clientprotocol.cpp

@@ -2,16 +2,14 @@
 
 #include <QDataStream>
 #include <QVariantMap>
-#include <map.h>
 
 namespace ClientProtocol {
 
-
-Header::Header() {
+BaseHeader::BaseHeader() {
     reset();
 }
 
-bool Header::isValid() const {
+bool BaseHeader::isValid() const {
 
     if (sizeof (*this) != 4) {
         return false;
@@ -20,17 +18,17 @@ bool Header::isValid() const {
     return true;
 }
 
-void Header::reset() {
+void BaseHeader::reset() {
     size = 0;
     command = 0;
     triggerCommnad = 0;
 }
 
-Package::Package() {
+BasePackage::BasePackage() {
     reset();
 }
 
-bool Package::isValid() const {
+bool BasePackage::isValid() const {
     if (!hdr.isValid()) {
         return false;
     }
@@ -42,16 +40,16 @@ bool Package::isValid() const {
     return hdr.size == static_cast<unsigned int> (data.size());
 }
 
-QByteArray Package::toBytes() const {
+QByteArray BasePackage::toBytes() const {
     QByteArray res;
-    res.append(reinterpret_cast<char*>(const_cast<Header*>(&hdr)),
+    res.append(reinterpret_cast<char*>(const_cast<BaseHeader*>(&hdr)),
                sizeof (hdr));
 
     res.append(data);
     return res;
 }
 
-void Package::reset() {
+void BasePackage::reset() {
     hdr.reset();
     data.clear();
 }

ClientProtocol/clientprotocol.h

@@ -9,63 +9,61 @@
 
 namespace ClientProtocol {
 
-
-bool CLIENTPROTOCOLSHARED_EXPORT initClientProtockol();
-
 /**
  * @brief The Header struct 4 byte
  */
 #pragma pack(push, 1)
-struct CLIENTPROTOCOLSHARED_EXPORT Header {
+struct CLIENTPROTOCOLSHARED_EXPORT BaseHeader {
     /**
      * @brief size - size of package data (not header)
      */
-    unsigned short size: 12;
+    unsigned short size;
 
     /**
      * @brief command of pacage
      */
-    quint8 command: 5;
+    quint8 command;
 
     /**
      * @brief command of pacage see Command (rquest from client)
      * the server should write to which command it responds
      */
-    quint8 triggerCommnad: 5;
+    quint8 triggerCommnad;
 
     /**
      * @brief Header default constructor
      */
-    Header();
+    BaseHeader();
+    virtual ~BaseHeader() = default;
 
     /**
      * @brief isValid
      * @return true if header is valid
      */
-    bool isValid() const;
+    virtual bool isValid() const;
 
 
     /**
      * @brief reset - reset all data and set for header invalid status
      */
-    void reset();
+    virtual void reset();
 };
 #pragma pack(pop)
 
 /**
  * @brief The Package struct
  */
-struct CLIENTPROTOCOLSHARED_EXPORT Package {
+struct CLIENTPROTOCOLSHARED_EXPORT BasePackage {
     /**
      * @brief hdr - header of package
      */
-    Header hdr;
+    BaseHeader hdr;
     /**
      * @brief data - source data of package
      */
     QByteArray data;
 
-    Package();
+    BasePackage();
 
     /**
      * @brief isValid
@@ -77,14 +75,14 @@ struct CLIENTPROTOCOLSHARED_EXPORT Package {
      * @brief toBytes
      * @return bytes array of packag
      */
-    QByteArray toBytes() const;
+    virtual QByteArray toBytes() const;
 
     /**
      * @brief reset - reset all data and set for package invalid status
      */
-    void reset();
+    virtual void reset();
 
-    virtual ~Package() = default;
+    virtual ~BasePackage() = default;
 
 };
 

ClientProtocol/connectioninfo.cpp

@@ -1,72 +0,0 @@
-#include "connectioninfo.h"
-#include <QTcpSocket>
-
-namespace ClientProtocol {
-
-
-int Connectioninfo::getKarma() const {
-    return karma;
-}
-
-void Connectioninfo::setKarma(int value) {
-    karma = value;
-
-    if (isBaned()) {
-        disconnect();
-    }
-}
-
-QAbstractSocket *Connectioninfo::getSct() const {
-    return sct;
-}
-
-void Connectioninfo::setSct(QAbstractSocket *value) {
-    sct = value;
-}
-
-QByteArray Connectioninfo::getToken() const {
-    return token;
-}
-
-void Connectioninfo::setToken(const QByteArray &value) {
-    token = value;
-}
-
-void Connectioninfo::disconnect() {
-    if (sct) {
-        sct->close();
-        token = "";
-        sct->deleteLater();
-        sct = nullptr;
-    }
-}
-
-void Connectioninfo::ban() {
-    karma = BANED_KARMA;
-    disconnect();
-}
-
-bool Connectioninfo::isBaned() const {
-    return karma < 1;
-}
-
-void Connectioninfo::unBan() {
-    karma = RESTORE_KARMA;
-}
-
-bool Connectioninfo::isValid() const {
-    return sct;
-}
-
-Connectioninfo::Connectioninfo(QAbstractSocket *tcp, int kar) {
-    sct = tcp;
-    karma = kar;
-    token = "";
-}
-
-Connectioninfo::~Connectioninfo() {
-    if (sct) {
-        sct->deleteLater();
-    }
-}
-}

ClientProtocol/connectioninfo.h

@@ -1,43 +0,0 @@
-#ifndef CONNECTIONINFO_H
-#define CONNECTIONINFO_H
-
-#include "clientprotocol_global.h"
-
-#include <QByteArray>
-
-class QAbstractSocket;
-namespace ClientProtocol {
-
-#define NOT_VALID_CARMA 0xFF
-#define DEFAULT_KARMA   100
-#define RESTORE_KARMA   20
-#define BANED_KARMA     0
-
-class CLIENTPROTOCOLSHARED_EXPORT Connectioninfo {
-
-    QAbstractSocket *sct = nullptr;
-    int karma = DEFAULT_KARMA;
-    QByteArray token;
-
-public:
-    void disconnect();
-
-    void ban();
-    bool isBaned() const;
-    void unBan();
-
-    bool isValid() const;
-
-    Connectioninfo(QAbstractSocket * tcp = nullptr,
-                   int kar = NOT_VALID_CARMA);
-    ~Connectioninfo();
-
-    int getKarma() const;
-    void setKarma(int value);
-    QAbstractSocket *getSct() const;
-    void setSct(QAbstractSocket *value);
-    QByteArray getToken() const;
-    void setToken(const QByteArray &value);
-};
-}
-#endif // CONNECTIONINFO_H

Server/item.cpp

@@ -26,7 +26,7 @@ Item::Item() {
 
 }
 
-Item::Item(const ClientProtocol::Package &other) {
+Item::Item(const ClientProtocol::BasePackage &other) {
     hdr = other.hdr;
     data = other.data;
     ClientProtocol::BaseNetworkObject base;
@@ -68,5 +68,5 @@ const QByteArray &Item::dataArray() const {
 
 bool Item::isValid() const {
     return ClientProtocol::FactoryNetObjects::isRegisteredType(hdr.type)
-            && Package::isValid();
+            && BasePackage::isValid();
 }

Server/item.h

@@ -3,7 +3,7 @@
 #include <clientprotocol.h>
 #include "server_global.h"
 
-class SERVERSHARED_EXPORT Item : public ClientProtocol::Package
+class SERVERSHARED_EXPORT Item : public ClientProtocol::BasePackage
 {
 private:
 
@@ -11,7 +11,7 @@ private:
 
 public:
     Item();
-    Item(const ClientProtocol::Package& other);
+    Item(const ClientProtocol::BasePackage& other);
     Item(const ClientProtocol::BaseNetworkObject* obj);
     Item(ClientProtocol::Command cmd, const QByteArray& data);
 
@@ -23,7 +23,7 @@ public:
     bool setId(int value);
     template<class T>
     bool parse(T& res) {
-        return ClientProtocol::Package::parse(res);
+        return ClientProtocol::BasePackage::parse(res);
     }
 };
 

Server/mainserver.cpp

@@ -85,7 +85,7 @@ bool MainServer::restartSrver(const QString &ip, unsigned short port) {
     return true;
 }
 
-void MainServer::handleRequest(ClientProtocol::Header hdr,
+void MainServer::handleRequest(ClientProtocol::BaseHeader hdr,
                                const QByteArray& data,
                                const quint32 &addres) {
 

Server/mainserver.h

@@ -41,7 +41,7 @@ private:
     bool restartSrver(const QString& ip, unsigned short port);
 
 private slots:
-    void handleRequest(ClientProtocol::Header hdr, const QByteArray &data,
+    void handleRequest(ClientProtocol::BaseHeader hdr, const QByteArray &data,
                        const quint32& addres);
     void handleTerminalRequest(QVariantMap obj);