QServer

//qserverthread.cpp - поток, в котором обрабатывается соединение.
//
#include "qserverthread.h"
#include <QTime>
#include <QHostAddress>

#define PRINT(x) emit QServerThread::print((QString)x);

QServerThread::QServerThread(int socketDescriptor, QObject *parent)
    : QThread(parent), socketDescriptor(socketDescriptor)
{
    this->moveToThread(this);
}

void QServerThread::run(){
    QTcpSocket pClientSocket;
    if (!pClientSocket.setSocketDescriptor(socketDescriptor)) {
        emit error(pClientSocket.error());
        return;
    }

    connect(&pClientSocket, SIGNAL(readyRead()), this, SLOT(slotReadFromClient()));
    connect(&pClientSocket, SIGNAL(disconnected()), this, SLOT(slotDisconnect()));
    connect(&pClientSocket, SIGNAL(destroyed()), this, SLOT(quit()));

    PRINT("New connection from "+
          pClientSocket.peerAddress().toString() + ":" + NUMTOSTR(pClientSocket.peerPort()))
    //sendToClient(&pClientSocket,"HELLO WORLD");

    //QThread::run();
    exec();
}

void QServerThread::sendToClient(QTcpSocket *pClientSocket, const QString &nstr){
    QByteArray dataBlock;
    QDataStream out(&dataBlock, QIODevice::WriteOnly);
    out.setVersion(QDataStream::Qt_4_5);
    out << qint16(0) << nstr;
    out.device()->seek(0);
    out << qint16(dataBlock.size() - sizeof(qint16));

    pClientSocket->write(dataBlock);
    PRINT("Sending data to "+
          pClientSocket->peerAddress().toString() + ":" + NUMTOSTR(pClientSocket->peerPort()))
}

void QServerThread::slotReadFromClient(){
    QTcpSocket *pClientSocket = (QTcpSocket*)sender();
    QDataStream in(pClientSocket);
    in.setVersion(QDataStream::Qt_4_5);

    for(;;){
        if(!m_nNextBlockSize){
            if (pClientSocket->bytesAvailable() < (int)sizeof(qint16)){
                break;
            }
            in >> m_nNextBlockSize;
        }

        if (pClientSocket->bytesAvailable() < m_nNextBlockSize){
            break;
        }

        QString data;
        //QTime time;
        in /*>> time*/ >> data;

        PRINT("Client ("+pClientSocket->peerAddress().toString()+":"+NUMTOSTR(pClientSocket->peerPort())+") has send " + NUMTOSTR(m_nNextBlockSize)+"b > " + data)
        m_nNextBlockSize = 0;

        sendToClient(pClientSocket, "Server Response > Received \"" + data + "\"");
    }
}

void QServerThread::slotDisconnect(){
    QTcpSocket *pClientSocket = (QTcpSocket*)sender();
    PRINT("Client ("+pClientSocket->peerAddress().toString()+":"+
          NUMTOSTR(pClientSocket->peerPort())+") is disconnected")
    //pClientSocket->deleteLater();
}

// qserverthread.h - класс обработчика соединения, потока
//
#ifndef QSERVERTHREAD_H
#define QSERVERTHREAD_H
#define NUMTOSTR(x) QString::number(x)

#include <QThread>
#include <QTcpSocket>

class QServerThread : public QThread
{
    Q_OBJECT

public:
    explicit QServerThread(int socketDescriptor, QObject *parent = 0);
    void run();

private:
    int socketDescriptor;
    qint16 m_nNextBlockSize;
    void sendToClient(QTcpSocket *pClientSocket, const QString &nstr);

private slots:
    void slotReadFromClient();
    void slotDisconnect();

signals:
    void error(QTcpSocket::SocketError socketError);
    void print(const QString &info);
};

#endif // QSERVERTHREAD_H

//qserverbase.cpp - сервер
//
#include "qserverbase.h"
#include "qserverthread.h"

QServerBase::QServerBase(QObject *parent) :
    QTcpServer(parent)
{
}

void QServerBase::incomingConnection(int socketDescriptor){
    QServerThread *thread = new QServerThread(socketDescriptor);
    connect(thread, SIGNAL(print(QString)), this, SIGNAL(log(QString)));
    connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater()));
    thread->start();
}

//qserverbase.h класс сервера
//
#ifndef QSERVERBASE_H
#define QSERVERBASE_H

#include <QTcpServer>

class QServerBase : public QTcpServer
{
    Q_OBJECT
public:
    explicit QServerBase(QObject *parent = 0);

protected:
    void incomingConnection(int socketDescriptor);

signals:
    void log(const QString &info);

};

#endif // QSERVERBASE_H

//qserver.cpp
//
#include "qserver.h"

#include <QtNetwork>
#include <QtGui>

#define PRINT(x) QServer::m_ptxtedit->append(QTime::currentTime().toString()+" "+(QString)x + "\n---------");
#ifndef NUMTOSTR()
    #define NUMTOSTR(x) QString::number(x)
#endif

QServer::QServer(int nPort, QWidget *parent)
    : QWidget(parent), m_nNextBlockSize(0), m_nPort(nPort)
{
    m_ptxtedit = new QTextEdit;
    m_ptxtedit->setReadOnly(true);
    QVBoxLayout *pvboxlayout = new QVBoxLayout;
    pvboxlayout->addWidget(new QLabel(tr("<h1>Multi-Threaded Server<h1>")));
    pvboxlayout->addWidget(m_ptxtedit);
    setLayout(pvboxlayout);
    resize(400,300);
    setWindowTitle(tr("Threaded TCP Server"));

    QNetworkConfigurationManager manager;
    if (manager.capabilities() & QNetworkConfigurationManager::NetworkSessionRequired){
        QNetworkConfiguration config;
        config = manager.defaultConfiguration();
        m_pnetworkSession = new QNetworkSession(config, this);
        PRINT("Session opening");
        connect(m_pnetworkSession, SIGNAL(opened()), this, SLOT(sessionOpened()));
        m_pnetworkSession->open();
    }
    else{
        sessionOpened();
    }
}

QServer::~QServer(){
    delete m_pServerBase;
}

void QServer::sessionOpened(){
    m_pServerBase = new QServerBase(this);
    if (!m_pServerBase->listen(QHostAddress::Any, m_nPort)){
        PRINT("Error starting server > "+m_pServerBase->errorString());
        m_pServerBase->close();
        return;
    }
    else
        PRINT("Server started on "+m_pServerBase->serverAddress().toString()+":"+NUMTOSTR(m_pServerBase->serverPort()));
    //connect(m_ptcpServer, SIGNAL(newConnection()), this, SLOT(newConnection()));
    connect(m_pServerBase, SIGNAL(log(QString)), this, SLOT(slotShowLog(QString)));
}

void QServer::slotShowLog(const QString &log){
    PRINT(log)
}

//qserver.h
//
#ifndef QSERVER_H
#define QSERVER_H

#include <QtGui/QWidget>
#include "qserverbase.h"

QT_BEGIN_NAMESPACE
//class QTcpServer;
class QNetworkSession;
class QTextEdit;
class QTcpSocket;
QT_END_NAMESPACE

class QServer : public QWidget
{
    Q_OBJECT

public:
    QServer(int nPort, QWidget *parent = 0);
    ~QServer();

private:
    QNetworkSession *m_pnetworkSession;
    //QTcpServer      *m_ptcpServer;
    QServerBase     *m_pServerBase;
    QTextEdit       *m_ptxtedit;
    qint16          m_nNextBlockSize;
    int             m_nPort;

    //void sendToClient(QTcpSocket *pSocket, const QString& nStr);

private slots:
    void sessionOpened();
    //virtual void newConnection();
    //virtual void newDisconnection();
    //void readFromClient();
    void slotShowLog(const QString &log);
};

#endif // QSERVER_H