откоментируйте пожалуйста

QT       += core gui network
TARGET    = tcp-cs
TEMPLATE  = app
 
SOURCES  += main.cpp\
            mainwindow.cpp
 
HEADERS  += mainwindow.h
 
FORMS    += mainwindow.ui

#include "mainwindow.h"
 
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    MainWindow w;
    w.show();
 
    return a.exec();
}

#ifndef MAINWINDOW_H
#define MAINWINDOW_H
 
#include <QtGui/QApplication>
#include <QMainWindow>
#include <QtNetwork>
#include <QTcpSocket>
#include <QHostAddress>
#include <QObject>
#include <QByteArray>
#include <QBitArray>
#include <QDebug>
#include <QFile>
#include <QCoreApplication>
#include <QTextStream>
 
namespace Ui {
    class MainWindow;
}
 
class QTcpServer;
 
class MainWindow : public QMainWindow
{
    Q_OBJECT
public:
    explicit MainWindow(QWidget *parent = 0);
    QString currentTime();
    ~MainWindow();
private slots:
    void on_starting_clicked();
    void on_stoping_clicked();
    void newuser();
    void newstate();
    void reconnect();
    void establish();
    void slotReadClient();
private:
    bool server_status;
    QBitArray packets_with_errors;
    int packets_sent_number;
    int packets_not_sent;
    int packets_total;
 
 
    int idusersocs;
 
    Ui::MainWindow *ui;
    QTcpServer *tcpServer;
    QTcpSocket *clientSocket;
 
    QMap<int,QTcpSocket *> SClients;
};
#endif // MAINWINDOW_H

#include "mainwindow.h"
#include "ui_mainwindow.h"
 
MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);
}
 
MainWindow::~MainWindow()
{
    delete ui;
    // Server status by default
    server_status = false;
    // We should know which packet failed
    packets_with_errors[12];
    packets_with_errors.fill(false);
}
 
void MainWindow::establish()
{
    // Creating tcpServer object for further use
    tcpServer = new QTcpServer(this);
 
    // If tcpServer sends newConnection signal, we shoul goto newuser slot
    connect(tcpServer, SIGNAL(newConnection()), this, SLOT(newuser()));
 
    // Connection troubleshooting. Set listen to localhost: "free port", at first if.
    // tcpServer->listen returns false on error
    if (!tcpServer->listen(QHostAddress::LocalHost, 33333) && server_status == false) {
        qDebug() <<  "[FAIL] Unable to start the server: " << tcpServer->errorString();
        ui->textinfo->append("FAIL] Unable to start the server: "+tcpServer->errorString());
    } else {
        // Connection established, so set server status to true
        server_status = true;
 
        // Check LISTEN state
        bool isListenState = tcpServer->isListening();
        QString protocolVersion;
 
        // Get current host (localhost actualy) adress
        QString serverAdress = tcpServer->serverAddress().toString();
 
        // LISTEN state always should be TRUE in this secion
        if (isListenState) {
            qDebug() << "[INFO] LISTEN STATE";
            ui->textinfo->append("[INFO] LISTEN STATE");
        }
 
        // Verify what IP protocol version is in use by TCP connection
        if (tcpServer->serverAddress().operator ==(QHostAddress::LocalHostIPv6))  
             protocolVersion = "[INFO][USED] IPv6";
        else if (tcpServer->serverAddress().operator ==(QHostAddress::LocalHost)) 
             protocolVersion = "[INFO][USED] IPv4";
        else protocolVersion = "[INFO][USED] Unknown protocol version";
 
        // Connection status to qDebug
        qDebug() << protocolVersion;
        qDebug() << "[INFO] Socket listening on <localhost>,<port>: " << serverAdress << ", \"" << tcpServer->serverPort() << '\"';
        qDebug() << "[INFO] Maximum pending accepted connections <number>: " << tcpServer->maxPendingConnections();
        qDebug() << "[INFO] Waiting for connection";
 
        // Connection status to GUI
        ui->textinfo->append(protocolVersion);
        ui->textinfo->append("[INFO] Socket listening on <localhost>:<port>: "+QObject::tr("%1:%2").arg(serverAdress).arg(tcpServer->serverPort()));
        ui->textinfo->append("[INFO] Maximum pending accepted connections <number>: "+QObject::tr("%1").arg(tcpServer->maxPendingConnections()));
        ui->textinfo->append("<font color='green'>[INFO] Waiting for connection</font>");
 
        // Creating socket for our connection. ReadWrite mode is set.
        clientSocket = new QTcpSocket(this);
        clientSocket->QIODevice::open(QIODevice::ReadWrite);
 
        // Can't check socket by signal in this case. qDebug output only.
        qDebug() << "[INFO] " << clientSocket->QAbstractSocket::state();
 
    }
}
 
void MainWindow::on_starting_clicked()
{
    //Variables 
    packets_sent_number = 0;
    packets_not_sent = 0;
    packets_total = 12;
 
    //Create conncection
    establish();
}
 
void MainWindow::on_stoping_clicked()
{
    if(server_status == true){
        foreach(int i,SClients.keys()){
            QTextStream os(SClients[i]);
            os.setAutoDetectUnicode(true);
            os << QDateTime::currentDateTime().toString() << "\n";
            SClients[i]->close();
            SClients.remove(i);
        }
        server_status = false;
        tcpServer->close();
        ui->textinfo->append("[INFO] Server have been stopped");
        qDebug() << "[INFO] Server have been stopped";
    }
 
    // Write to file
    QFile file("info.txt");
    file.open(QIODevice::WriteOnly | QIODevice::Text);
    QTextStream out(&file);
    out << "Packets should arrive <count>:    " << packets_total << endl;
    out << "Analyzed packets <count>:         " << packets_sent_number << endl;
    out << "Not transmitted packets <count>:  " << packets_not_sent<< endl;
    // Type to file which packet contains error
    for (int i = 0; i < packets_total; i++) if (packets_with_errors[i] == true) out << "Error occured at packet <number>: " << i << endl;
}
 
 
void MainWindow::reconnect ()
{
    if(server_status == true){
        // Clearing our <QMap> SClients
        foreach(int i,SClients.keys()){
            QTextStream os(SClients[i]);
            os.setAutoDetectUnicode(true);
            os << QDateTime::currentDateTime().toString() << "\n";
            SClients[i]->close();
            SClients.remove(i);
        }
 
        // Terminating TCP server
        tcpServer->close();
        server_status = false;
 
        // Number of packages sent. Connection close message to qDebug
        qDebug() << "[INFO] Packets sent: " << packets_sent_number;
        qDebug() << "[INFO] Connection closed";
        qDebug() << "[INFO] Sending another packet(s)";
        qDebug() << "\n";
 
        // Same to GUI
        ui->textinfo->append(QObject::tr("<font color='green'>[INFO] Packets sent: %1 </font>").arg(packets_sent_number));
        ui->textinfo->append("<font color='red'>[INFO] Connection closed</font>");
        ui->textinfo->append("<font color='green'[INFO] Sending another packet(s)</font>");
        ui->textinfo->append("\n");
 
        // Ready for reconnecting now
        establish();
    }
}
 
void MainWindow::newuser()
{
    if(server_status == true){
        // Connection ESTABLISHED state in this section
        qDebug() << "[INFO] Connection ESTABLISHED";
        ui->textinfo->append("[INFO] Connection ESTABLISHED");
 
        // Returns the next pending connection as a connected QTcpSocket object.
        clientSocket=tcpServer->nextPendingConnection();
 
        // Get descriptor. Removing from map when closing socket
        idusersocs=clientSocket->socketDescriptor();
        SClients[idusersocs]=clientSocket;
 
        // Trying to catch state signal
        connect(clientSocket, SIGNAL(stateChanged(QAbstractSocket::SocketState)), this, SLOT(newstate()));
 
        // Socket parametres
        qDebug() << "[INFO] Socket <descriptor>,<physical adress>: " << idusersocs << "," << SClients[idusersocs];
 
        // Trying to catch readyRead socket signal, then connect it with slotReadClient()
        connect(SClients[idusersocs],SIGNAL(readyRead()),this, SLOT(slotReadClient()));
    }
}
 
QString MainWindow::currentTime()
{
    return QTime::currentTime().toString("hh:mm:ss");
}
 
void MainWindow::newstate()
{
    QString theTime = currentTime();
    // TO DEBUG PRINT ONLY
    qDebug() << "[INFO][" << theTime << "] " << clientSocket->state();
}
 
void MainWindow::slotReadClient()
{
    // Get socket object sender.
    // Returns pointer to object, which send the signal
    clientSocket = (QTcpSocket*) sender();
 
    // Send data to client
    QTextStream out(clientSocket);
    QDataStream out_bin(clientSocket);
    switch (packets_sent_number) {
        case 0:
            out << 80;
            break;
        case 1:
            out << 808;
            break;
        case 2:
            out << 1129;
            break;
        case 3:
            out << 1130;
            break;
        case 4:
            out << 60;
            break;
        case 5:
            out_bin << (quint8) 3;
            break;
        case 6:
            out_bin << (quint8) 18;
            break;
        case 7:
            out << 1500;
            break;
        case 8:
            out_bin << (quint16) 65087;
            break;
        case 9:
            out_bin << (quint8) 24;
            break;
        case 10:
            out_bin << (quint16) 70719;
            break;
        case 11:
            out_bin << (quint64) 4226812920;
            break;
                default:
                    out << "Nothing to send more!";
                    break;
    }
    // 12 packets should be sent. Client should request each of them
    packets_sent_number++;
 
    // Checking if packet have been sent through connection.
    // Number of packet should be written to array
    if(clientSocket->ConnectionRefusedError)
    {
        packets_not_sent++;
        packets_with_errors[packets_sent_number] = true;
    }
 
    // Closing client socket
    clientSocket->close();
 
    // Removing Sclients[idusersocs]
    SClients.remove(idusersocs);
 
    // Recreate connection
    reconnect();
}