Взаимодействие клиента и сервера

#ifndef TCPSERVER_H
#define TCPSERVER_H
 
#include <QTcpServer>
#include "NetworkInterface/clientsocket.h"
class TcpServer : public QTcpServer
{
    Q_OBJECT
public:
    explicit TcpServer(QObject *parent = 0);
 
signals:
    void clientOff(const QString &name);
    void userAuth(const QString &login, const QString &password);
    void userRegistration(const QVariantList &data);
    void userAuthStatus(const QString &name, const int status, const int idUser);
    void userRegistrationStatus(const QString &name, const int status);
public slots:
private:
    void incomingConnection(qintptr socketId);
};
#endif // TCPSERVER_H

#include "tcpserver.h"
 
TcpServer::TcpServer(QObject *parent) :
    QTcpServer(parent)
{
}
 
void TcpServer::incomingConnection(qintptr socketId)
{
    ClientSocket *socket = new ClientSocket;
    socket->setSocketDescriptor(socketId);
 
    connect(socket,SIGNAL(disconnects(QString)),
            this,SIGNAL(clientOff(QString)));
 
    connect(socket,SIGNAL(userAuth(QString,QString)),
            this,SIGNAL(userAuth(QString,QString)));
 
    connect(socket,SIGNAL(userRegistration(QVariantList)),
            this,SIGNAL(userRegistration(QVariantList)));
 
    connect(this,SIGNAL(userAuthStatus(QString,int,int)),
            socket,SLOT(slotUserAuthStatus(QString,int,int)));
 
    connect(this,SIGNAL(userRegistrationStatus(QString,int)),
            socket,SLOT(slotUserRegistrationStatus(QString,int)));
}

#ifndef CLIENTSOCKET_H
#define CLIENTSOCKET_H
 
#include <QTcpSocket>
#include <QDebug>
#include <QHostAddress>
#include <QNetworkInterface>
#include "service.h"
 
class ClientSocket : public QTcpSocket
{
    Q_OBJECT
public:
    explicit ClientSocket(QObject *parent = 0);
    ~ClientSocket();
 
signals:
    void disconnects(const QString &name);
    void userAuth(const QString &login, const QString &password);
    void userRegistration(const QVariantList &data);
 
public slots:
    void slotUserAuthStatus(const QString &name,
                            const int status, const int idUser);
    void slotUserRegistrationStatus(const QString &name,
                                    const int status);
private slots:
    void readClient();
private:
    quint16 nextBlockSize;
    QString sockeName;
    int     typeSocket;
};
 
#endif // CLIENTSOCKET_H

#include "clientsocket.h"
 
ClientSocket::ClientSocket(QObject *parent) :
    QTcpSocket(parent)
  , nextBlockSize(0)
{
    connect(this,SIGNAL(readyRead()), SLOT(readClient()));
    connect(this, SIGNAL(disconnected()), SLOT(deleteLater()));
    for (QHostAddress addr : QNetworkInterface::allAddresses()) {
        qDebug() << addr.toString();
    }
}
 
ClientSocket::~ClientSocket()
{
    QString str;
    switch (typeSocket) {
    case USER_SOCKET:{
        str =  "Пользователь\t" + sockeName + "\tотключился";
        break;
    }
    case DEVICE_SOCKET:{
        str = "Устройство\t" + sockeName + "\tотключилось";
        break;
    }
    default:
        break;
    }
    emit disconnects(str);
}
 
void ClientSocket::slotUserAuthStatus(const QString &name, const int status, const int idUser)
{
    if(name != sockeName){
        return;
    }
    QByteArray block;
    QDataStream out(&block, QIODevice::WriteOnly);
    out.setVersion(QDataStream::Qt_4_3);
    out << quint16(0)  << USER_AUTH
        << status << idUser;
    out.device()->seek(0);
    out << quint16(block.size() - sizeof(quint16));
    write(block);
}
 
void ClientSocket::slotUserRegistrationStatus(const QString &name, const int status)
{
    if(name != sockeName){
        return;
    }
    QByteArray block;
    QDataStream out(&block, QIODevice::WriteOnly);
    out.setVersion(QDataStream::Qt_4_3);
    out << quint16(0)  << USER_REGISTER
        << status;
    out.device()->seek(0);
    out << quint16(block.size() - sizeof(quint16));
    write(block);
}
 
 
 
 
void ClientSocket::readClient()
{
    QDataStream in(this);
    in.setVersion(QDataStream::Qt_4_3);
    if (nextBlockSize == 0) {
        if (bytesAvailable() < (int)sizeof(quint16)){
            return;
        }
        in >> nextBlockSize;
    }
    if (bytesAvailable() < nextBlockSize){
        return;
    }
    int type;
    in >> type;
    int requestType;
    in >> requestType;
    switch (type) {
        case USER:{
            typeSocket = USER_SOCKET;
            switch (requestType) {
            case USER_AUTH:{
                QString login;
                QString password;
                in >> login >> password;
                sockeName = login;
                emit userAuth(login,password);
//                nextBlockSize = 0;
                break;
            }
            case USER_REGISTER:{
                QVariantList data;
                in >> data;
                sockeName   = data.at(0).toString();
                emit userRegistration(data);
//                nextBlockSize = 0;
                break;
            }
            default:
                break;
            }
            break;
        }
        default:
            break;
    }
    nextBlockSize = 0;
}

#ifndef TCPSOCKET_H
#define TCPSOCKET_H
 
#include <QTcpSocket>
#include <QDebug>
#include <QHostAddress>
#include <QNetworkInterface>
#include "service.h"
 
 
class TcpSocket : public QTcpSocket
{
    Q_OBJECT
public:
    explicit TcpSocket(QObject *parent = 0);
 
signals:
    void connectStatus(const int status);
    void socketMessage(const QString &message);
    void authStatus(const int status);
    void registrationStatus(const int status);
public slots:
    void slotAutorization(const QString &login, const QString &password);
    void slotRegistration(const QVariantList &data);
    void connectToServer(const QHostAddress &host, const int port);
private slots:
    void slotReadyRead();
    void slotSocketError(QAbstractSocket::SocketError socketError);
    void slotSocketMessage();
private:
    quint16 nextBlockSize;
 
};
 
#endif // TCPSOCKET_H

#include "tcpsocket.h"
 
TcpSocket::TcpSocket(QObject *parent) :
    QTcpSocket(parent)
  , nextBlockSize(0)
{
    connect(this,SIGNAL(readyRead()),SLOT(slotReadyRead()));
    connect(this,SIGNAL(error(QAbstractSocket::SocketError)),
            SLOT(slotSocketError(QAbstractSocket::SocketError)));
    connect(this,SIGNAL(connected()),SLOT(slotSocketMessage()));
}
 
void TcpSocket::slotAutorization(const QString &login, const QString &password)
{
    QByteArray block;
    QDataStream out(&block, QIODevice::WriteOnly);
    out.setVersion(QDataStream::Qt_4_3);
    out << quint16(0) << USER << USER_AUTH
        << login << password;
    out.device()->seek(0);
    out << quint16(block.size() - sizeof(quint16));
    write(block);
}
 
void TcpSocket::slotRegistration(const QVariantList &data)
{
    QByteArray block;
    QDataStream out(&block, QIODevice::WriteOnly);
    out.setVersion(QDataStream::Qt_4_3);
    out << quint16(0) << USER << USER_REGISTER
        << data;
    out.device()->seek(0);
    out << quint16(block.size() - sizeof(quint16));
    write(block);
 
}
 
void TcpSocket::connectToServer(const QHostAddress &host, const int port)
{
    if(this->state() != QTcpSocket::ConnectedState){
        connectToHost(host,port);
    }
}
 
 
void TcpSocket::slotReadyRead()
{
    QDataStream in(this);
    in.setVersion(QDataStream::Qt_4_3);
    if (nextBlockSize == 0) {
        if (bytesAvailable() < (int)sizeof(quint16)){
            return;
        }
        in >> nextBlockSize;
    }
    if (bytesAvailable() < nextBlockSize){
        return;
    }
    int requestType;
    in >> requestType;
    switch (requestType) {
    case USER_AUTH:
        int status;
        in >> status;
        emit authStatus(status);
        if(status == OK){
            //....
        }
        break;
    case USER_REGISTER:{
        int status;
        in >> status;
        emit registrationStatus(status);
        if(status == OK){
            //...
        }
        break;
    }
    default:
        break;
    }
    nextBlockSize = 0;
}
 
void TcpSocket::slotSocketError(QAbstractSocket::SocketError socketError)
{
    switch (socketError) {
    case QAbstractSocket::RemoteHostClosedError:{
        emit socketMessage(trUtf8( "Remote host close error"));
        emit connectStatus(NO);
        break;
    }
    case QAbstractSocket::HostNotFoundError:{
        emit socketMessage(trUtf8( "The host was not found. Please check the\n"
                                   "host name and port settings.\n"));
        emit connectStatus(NO);
        break;
    }
    case QAbstractSocket::ConnectionRefusedError:{
        emit socketMessage(trUtf8( "The connection was refused by the peer.\n"
                                   "Make sure the  server is running,\n"
                                   "and check that the host name and port\n"
                                   "settings are correct.\n"));
        emit connectStatus(NO);
        break;
    }
    default:
        emit socketMessage( trUtf8("The following error occurred: %1.\n").arg(
                                errorString()));
        emit connectStatus(NO);
    }
}
 
void TcpSocket::slotSocketMessage()
{
    emit socketMessage(trUtf8("Соединение с сервером\n"
                              "успешно установлено"));
    emit connectStatus(OK);
}