Кроссплатформенное Клиент — Серверное приложение

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    O_server server(1234);

    return a.exec();
}

O_server::O_server(int nPort, QObject *parent) :
    QObject(parent), next_bloksize(0)
{
    m_tcpserver = new QTcpServer(this);
    if(!m_tcpserver->listen(QHostAddress::Any, nPort)){
       printf("No Listening\n");
       m_tcpserver->close();
       return;
   }
    connect(m_tcpserver, SIGNAL(newConnection()), this, SLOT(slotNewConection()));
    //printf("Server Started\n");
}
/*void*/ void O_server::slotNewConection()
{
   QTcpSocket *pClientSocket = m_tcpserver->nextPendingConnection();
   connect(pClientSocket, SIGNAL(disconnected()), pClientSocket, SLOT(deleteLater()));
   connect(pClientSocket, SIGNAL(readyRead()), this, SLOT(slotReadClient()));
   sendToClient(pClientSocket, "Server. —Conected—\n");

}

void O_server::slotReadClient()
{

    QTcpSocket* pClientSocket = (QTcpSocket*)sender();
    QDataStream in(pClientSocket);
    in.setVersion(QDataStream::Qt_4_5);
 for(;;)
 {
 if(!next_bloksize){
  if(pClientSocket->bytesAvailable()<sizeof(quint16)){
     break;
  }
        in >> next_bloksize;
 }
 if(pClientSocket->bytesAvailable()<next_bloksize){
   break;
 }
 QTime time;
 QString str;
 in >> time >> str;
 next_bloksize =0;
 sendToClient(pClientSocket, "Resived: \"" + str + "\"");
 }
}

void O_server::sendToClient(QTcpSocket* pSocket, const QString str)
{
  QByteArray arrBlock;
  QDataStream out(&arrBlock, QIODevice::WriteOnly);
  out.setVersion(QDataStream::Qt_4_5);
  out << quint16(0) << QTime::currentTime() << str;

  out.device()->seek(0);
  out << quint16(arrBlock.size() — sizeof(quint16));
  pSocket->write(arrBlock);
}

#define PCHQSTRING( ba, str, p ) \
QByteArray ba = str.toAscii(); \
p = ba.data();

#include <QObject>
#include <QTime>
#include <QtNetwork>

class QTcpServer;
class QTcpSocket;

class O_server : public QObject
{
    Q_OBJECT
private:
    QTcpServer * m_tcpserver;
    quint16 next_bloksize;
private:
    virtual void sendToClient(QTcpSocket *pSocket, QString str);
public:
    O_server(int nPort, QObject *parent = 0);

public slots:
    virtual void slotNewConection();   
    virtual void slotReadClient();

};

#endif // O_SERVER_H

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    O_client client("localhost", 1234);
    //client.resize(300,200);
    client.show();
    return a.exec();
}

O_client::O_client(const QString strHost, int nPort, QWidget *parent) :
    QWidget(parent), next_blockSize(0)
{
  m_tcpSocket =new QTcpSocket(this);
  m_tcpSocket->connectToHost(strHost,nPort);
  connect(m_tcpSocket, SIGNAL(connected()), SLOT(slotConnected()));
  connect(m_tcpSocket, SIGNAL(readyRead()), SLOT(slotReadyRead()));
  connect(m_tcpSocket, SIGNAL(error(QAbstractSocket::SocketError)), this,
          SLOT(slotError(QAbstractSocket::SocketError)));
 m_ptxinfo = new QTextEdit;
 m_ptxinput = new QLineEdit;
 m_ptxinfo->setReadOnly(true);

 QPushButton *pbtn = new QPushButton("send");
 connect(pbtn, SIGNAL(clicked()), SLOT(slotSendToServer()));
 connect(m_ptxinput, SIGNAL(returnPressed()), this, SLOT(slotSendToServer()));
 QVBoxLayout *pvb = new QVBoxLayout;
 pvb->addWidget(new QLabel("Client"));
 pvb->addWidget(m_ptxinfo);
 pvb->addWidget(m_ptxinput);
 pvb->addWidget(pbtn);
 setLayout(pvb);
}

void O_client::slotReadyRead() //сообщение от сервера
{
  QDataStream in(m_tcpSocket);
  in.setVersion(QDataStream::Qt_4_5);
  //for(;;)
  {
    if(!next_blockSize){
      if(m_tcpSocket->bytesAvailable() < sizeof(quint16))
      {
       return;//break;
      }
      in >>next_blockSize;
    }

    if(m_tcpSocket->bytesAvailable() < next_blockSize){
      return;//break;
    }
    QTime time;
    QString str;
    //char buf[256];
    in >> time >> str;
/* Выводим что получили */
    //char* cConType;
    //PCHQSTRING( v1, str, cConType);
    //printf("%s\n", cConType);
    m_ptxinfo->append(time.toString()+" " + str);
    next_blockSize = 0;
    //slotSendToServer();
  }

}

void O_client::slotError(QAbstractSocket::SocketError err) //обработка ошибок
{
  QString strErr =
      "Error: " + (
          err == QAbstractSocket::HostNotFoundError ?
          "Хост не найден.":
          err == QAbstractSocket::RemoteHostClosedError ?
          "Удаленный хост закрыт.":
          err == QAbstractSocket::ConnectionRefusedError ?
          "Соединение разорвано.":
          QString(m_tcpSocket->errorString())
          );
  //printf("Error");
  m_ptxinfo->append(strErr);
}

void O_client::slotSendToServer(){ //отправка сообщения серверу
  QByteArray arrBlock;
  QDataStream out(&arrBlock, QIODevice::WriteOnly);
  out.setVersion(QDataStream::Qt_4_5);
  out << quint16(0) << QTime::currentTime() << m_ptxinput->text();
  out.device()->seek(0);
  out << quint16(arrBlock.size()—sizeof(quint16));
  m_tcpSocket->write(arrBlock);
  m_ptxinput->setText("");
}

void O_client::slotConnected(){
  //printf("Recived the conected signal\n");
  m_ptxinfo->append("Recived the conected signal");
}

int O_client::send(){
  slotSendToServer();
  return 1;
}

#include <QObject>
#include <QTcpSocket>
#include <QTime>
#include <QWidget>
#include <QLineEdit>
#include <QTextEdit>
#include <QPushButton>
#include <QVBoxLayout>
#include <QLabel>

#define PCHQSTRING( ba, str, p ) \
QByteArray ba = str.toAscii(); \
p = ba.data();

class QLineEdit;
class QTextEdit;

class O_client : public QWidget
{
    Q_OBJECT
private:
  QTcpSocket* m_tcpSocket;
  quint16 next_blockSize;
  QLineEdit* m_ptxinput;
  QTextEdit* m_ptxinfo;
public:
    O_client(const QString strHost, int nPort, QWidget *parent = 0);
    int send();
signals:

private slots:
    void slotSendToServer();
    void slotReadyRead( );
    void slotError (QAbstractSocket::SocketError);

    void slotConnected();
};

#endif // MAINWINDOW_H