Write to Threaded Server

[Suncell]

Hello, i got stuck while trying writing to a threaded server. Receiving works fine but the other way around...
Method readData() at tcpsocket.cpp is never called. What am I doing wrong?

Server:

MultiServer server;
     if (!server.listen(QHostAddress::Any, 15000)) {
         close();
         return;
     }

MultiServer server;
     if (!server.listen(QHostAddress::Any, 15000)) {
         close();
         return;
     }

To copy to clipboard, switch view to plain text mode 

multiserver.cpp

MultiServer::MultiServer(QObject *parent)
: QTcpServer(parent)
{
 
}
 
void MultiServer::incomingConnection(int socketDescriptor)
{
    QString msg = "Message from server";
    ConnectionThread *thread = new ConnectionThread(socketDescriptor, msg, this);
    connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater()));
    thread->start();
}

MultiServer::MultiServer(QObject *parent)
: QTcpServer(parent)
{

}

void MultiServer::incomingConnection(int socketDescriptor)
{
    QString msg = "Message from server";
    ConnectionThread *thread = new ConnectionThread(socketDescriptor, msg, this);
    connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater()));
    thread->start();
}

To copy to clipboard, switch view to plain text mode 

connectionthread.cpp

ConnectionThread::ConnectionThread(int socketDescriptor, const QString &msg, QObject *parent)
: QThread(parent)
, socketDescriptor(socketDescriptor)
, text(msg)
{
 
}
 
void ConnectionThread::run()
{
	my_sock = new CTcpSocket(socketDescriptor);
 
	my_sock->writeData(text);
}

ConnectionThread::ConnectionThread(int socketDescriptor, const QString &msg, QObject *parent)
: QThread(parent)
, socketDescriptor(socketDescriptor)
, text(msg)
{

}

void ConnectionThread::run()
{
	my_sock = new CTcpSocket(socketDescriptor);

	my_sock->writeData(text);
}

To copy to clipboard, switch view to plain text mode 

tcpsocket.cpp

CTcpSocket::CTcpSocket(int socketDescriptor, QObject *parent)
: QObject(parent)
, m_socketDescriptor(socketDescriptor)
{
	m_tcpSocket = new QTcpSocket();
 
	if (!m_tcpSocket->setSocketDescriptor(m_socketDescriptor)) {
		qDebug() << m_tcpSocket->error();
		return;
	}
 
	[COLOR="Red"]connect(m_tcpSocket, SIGNAL(readyRead()), SLOT(readData()));[/COLOR]
}
 
 
[COLOR="Red"]void CTcpSocket::readData()
{
	//ToDo Implement reading Data
	qDebug() << "try to read";
	//m_tcpSocket->waitForReadyRead(10000);
}[/COLOR]
 
 
void CTcpSocket::writeData(QString txt)
{
	qDebug() << "try to write";
 
    QByteArray block;
    QDataStream out(&block, QIODevice::WriteOnly);
    out.setVersion(QDataStream::Qt_4_0);
    out << (quint16)0;
    out << txt;
    out.device()->seek(0);
    out << (quint16)(block.size() - sizeof(quint16));
 
    m_tcpSocket->write(block);
 
    m_tcpSocket->waitForBytesWritten(10000);
 
    m_tcpSocket->disconnectFromHost();
    m_tcpSocket->waitForDisconnected();
}

CTcpSocket::CTcpSocket(int socketDescriptor, QObject *parent)
: QObject(parent)
, m_socketDescriptor(socketDescriptor)
{
	m_tcpSocket = new QTcpSocket();

	if (!m_tcpSocket->setSocketDescriptor(m_socketDescriptor)) {
		qDebug() << m_tcpSocket->error();
		return;
	}

	[COLOR="Red"]connect(m_tcpSocket, SIGNAL(readyRead()), SLOT(readData()));[/COLOR]
}


[COLOR="Red"]void CTcpSocket::readData()
{
	//ToDo Implement reading Data
	qDebug() << "try to read";
	//m_tcpSocket->waitForReadyRead(10000);
}[/COLOR]


void CTcpSocket::writeData(QString txt)
{
	qDebug() << "try to write";

    QByteArray block;
    QDataStream out(&block, QIODevice::WriteOnly);
    out.setVersion(QDataStream::Qt_4_0);
    out << (quint16)0;
    out << txt;
    out.device()->seek(0);
    out << (quint16)(block.size() - sizeof(quint16));

    m_tcpSocket->write(block);

    m_tcpSocket->waitForBytesWritten(10000);

    m_tcpSocket->disconnectFromHost();
    m_tcpSocket->waitForDisconnected();
}

To copy to clipboard, switch view to plain text mode 

[numbat]

Why do you call disconnectFromHost if you want a reply?

[Suncell]

ohh sure - but i fixed it already - this i shouldn't do of course. But it doesn't work anyway :-?

tcpsocket.cpp

CTcpSocket::CTcpSocket(int socketDescriptor, QObject *parent)
: QObject(parent)
, m_socketDescriptor(socketDescriptor)
{
	m_tcpSocket = new QTcpSocket();
 
	if (!m_tcpSocket->setSocketDescriptor(m_socketDescriptor)) {
		qDebug() << m_tcpSocket->error();
		return;
	}
 
	connect(m_tcpSocket, SIGNAL(readyRead()), SLOT(readData()));
}
 
 
void CTcpSocket::readData()
{
	//ToDo Implement reading Data
	qDebug() << "try to read";
	//m_tcpSocket->waitForReadyRead(10000);
}
 
 
void CTcpSocket::writeData(QString txt)
{
	qDebug() << "try to write";
 
    QByteArray block;
    QDataStream out(&block, QIODevice::WriteOnly);
    out.setVersion(QDataStream::Qt_4_0);
    out << (quint16)0;
    out << txt;
    out.device()->seek(0);
    out << (quint16)(block.size() - sizeof(quint16));
 
    m_tcpSocket->write(block);
 
    m_tcpSocket->waitForBytesWritten(10000);
}

CTcpSocket::CTcpSocket(int socketDescriptor, QObject *parent)
: QObject(parent)
, m_socketDescriptor(socketDescriptor)
{
	m_tcpSocket = new QTcpSocket();

	if (!m_tcpSocket->setSocketDescriptor(m_socketDescriptor)) {
		qDebug() << m_tcpSocket->error();
		return;
	}

	connect(m_tcpSocket, SIGNAL(readyRead()), SLOT(readData()));
}


void CTcpSocket::readData()
{
	//ToDo Implement reading Data
	qDebug() << "try to read";
	//m_tcpSocket->waitForReadyRead(10000);
}


void CTcpSocket::writeData(QString txt)
{
	qDebug() << "try to write";

    QByteArray block;
    QDataStream out(&block, QIODevice::WriteOnly);
    out.setVersion(QDataStream::Qt_4_0);
    out << (quint16)0;
    out << txt;
    out.device()->seek(0);
    out << (quint16)(block.size() - sizeof(quint16));

    m_tcpSocket->write(block);

    m_tcpSocket->waitForBytesWritten(10000);
}

To copy to clipboard, switch view to plain text mode 

[tbscope]

One reason you're not being able to read is because there's nothing to read.
Are you sure you are receiving data? Are you sure that what you send is correct?

[Suncell]

There is something to read for sure - I've a working not threaded server. There the message arrives.

Client is like this:

InstructionGen::InstructionGen(..)
{
...
socket = new QTcpSocket(this);
...
socket->connectToHost(server->text(), port->value());
...
}
 
void InstructionGen::sendInstruction()
{
	socket->write(prefix->text().toLatin1() + message->text().toLatin1() + "\n");
	log_stat->append((prefix->text().toLatin1() + message->text().toLatin1() + "\n").simplified());
	message->clear();
}

InstructionGen::InstructionGen(..)
{
...
socket = new QTcpSocket(this);
...
socket->connectToHost(server->text(), port->value());
...
}

void InstructionGen::sendInstruction()
{
	socket->write(prefix->text().toLatin1() + message->text().toLatin1() + "\n");
	log_stat->append((prefix->text().toLatin1() + message->text().toLatin1() + "\n").simplified());
	message->clear();
}

To copy to clipboard, switch view to plain text mode 

[tbscope]

Where do you call void InstructionGen::sendInstruction() in your server?

Edit: and you don't need to use threads and the socket's blocking functions.

[Suncell]

InstructionGen is the client, which should send data to the server.

Thx for the hint with the blocking functions... but should work anyway - am I right?

[tbscope]

You have lost me completely.
Can you post the complete code please?

[Suncell]

Okay: server is complete.

Now the Client: its actual the ChatSample Client in a slightly different form.

Client:

main.cpp

#include <QApplication>
#include "instructiongen.h"
 
int main(int argc, char *argv[])
{
	QApplication a(argc, argv);
	InstructionGen generator;
	generator.show();
	return a.exec();
}

#include <QApplication>
#include "instructiongen.h"

int main(int argc, char *argv[])
{
	QApplication a(argc, argv);
	InstructionGen generator;
	generator.show();
	return a.exec();
}

To copy to clipboard, switch view to plain text mode 

instructiongen.cpp

#include "instructiongen.h"
#include <QVBoxLayout>
#include <QHBoxLayout>
#include <QGridLayout>
#include <QPushButton>
#include <QTextEdit>
#include <QLabel>
#include <QLineEdit>
#include <QTcpSocket>
#include <QBuffer>
#include <QSpinBox>
#include <QErrorMessage>
 
static const quint16 DEFAULT_PORT = 15001;
 
InstructionGen::InstructionGen(QWidget* parent, Qt::WFlags flags)
: QWidget(parent, flags)
{
	QVBoxLayout* main	= new QVBoxLayout(this);
	QGridLayout* top	= new QGridLayout;
	QHBoxLayout* bottom	= new QHBoxLayout;
 
	QLabel* label	= new QLabel("Server:", this);
	server			= new QLineEdit(this);
	port			= new QSpinBox(this);
	conn			= new QPushButton("Connect", this);
	port->setRange(1, 32767);
	port->setValue(DEFAULT_PORT);
	server->setText("localhost");
	top->addWidget(label, 0, 0);
	top->addWidget(server, 0, 1);
	top->addWidget(port, 0, 2);
 
	label	= new QLabel("Prefix:", this);
	prefix	= new QLineEdit(this);
	prefix->setText("sim.");
	top->addWidget(label, 1, 0);
	top->addWidget(prefix, 1, 1);
	top->addWidget(conn, 1, 2);
 
	log_stat	= new QTextEdit(this);
	log_stat->setReadOnly(true);
 
	label	= new QLabel("Instruction:", this);
	message	= new QLineEdit(this);
	send	= new QPushButton("Send", this);
	send->setDefault(true);
	bottom->addWidget(label);
	bottom->addWidget(message);
	bottom->addWidget(send);
 
	main->addLayout(top);
	main->addWidget(log_stat);
	main->addLayout(bottom);
	setLayout(main);
 
	buffer = new QBuffer(this);
	socket = new QTcpSocket(this);
	buffer->open(QIODevice::ReadWrite);
 
	connect(message, SIGNAL(returnPressed()), SLOT(sendInstruction()));
	connect(send, SIGNAL(clicked()), SLOT(sendInstruction()));
	connect(conn, SIGNAL(clicked()), SLOT(toggleConnection()));
 
	connect(socket, SIGNAL(connected()), SLOT(setConnected()));
	connect(socket, SIGNAL(disconnected()), SLOT(setDisconnected()));
	connect(socket, SIGNAL(readyRead()), SLOT(receiveMessage()));
 
	setDisconnected();
}
 
InstructionGen::~InstructionGen()
{
	buffer->close();
}
 
void InstructionGen::setConnected()
{
	port->setEnabled(false);
	server->setEnabled(false);
	prefix->setEnabled(true);
	message->setEnabled(true);
	log_stat->setEnabled(true);
	log_stat->clear();
	send->setEnabled(true);
	conn->setText("Disconnect");
}
 
void InstructionGen::setDisconnected()
{
	port->setEnabled(true);
	server->setEnabled(true);
	prefix->setEnabled(false);
	message->setEnabled(false);
	log_stat->setEnabled(false);
	send->setEnabled(false);
	conn->setText("Connect");
}
 
void InstructionGen::toggleConnection()
{
	if (socket->state() == QAbstractSocket::UnconnectedState)
	{
		socket->connectToHost(server->text(), port->value());
	}
	else
	{
		socket->disconnectFromHost();
	}
}
 
void InstructionGen::sendInstruction()
{
	socket->write(prefix->text().toLatin1() + message->text().toLatin1() + "\n");
	log_stat->append((prefix->text().toLatin1() + message->text().toLatin1() + "\n").simplified());
	message->clear();
}
 
void InstructionGen::receiveMessage()
{
	// missing some checks for returns values for the sake of simplicity
	qint64 bytes = buffer->write(socket->readAll());
	// go back as many bytes as we just wrote so that it can be read
	buffer->seek(buffer->pos() - bytes);
	// read only full lines, line by line
	while (buffer->canReadLine())
	{
		QString line = buffer->readLine();
		log_stat->append("received: "+line.simplified());
	}
}

#include "instructiongen.h"
#include <QVBoxLayout>
#include <QHBoxLayout>
#include <QGridLayout>
#include <QPushButton>
#include <QTextEdit>
#include <QLabel>
#include <QLineEdit>
#include <QTcpSocket>
#include <QBuffer>
#include <QSpinBox>
#include <QErrorMessage>

static const quint16 DEFAULT_PORT = 15001;

InstructionGen::InstructionGen(QWidget* parent, Qt::WFlags flags)
: QWidget(parent, flags)
{
	QVBoxLayout* main	= new QVBoxLayout(this);
	QGridLayout* top	= new QGridLayout;
	QHBoxLayout* bottom	= new QHBoxLayout;

	QLabel* label	= new QLabel("Server:", this);
	server			= new QLineEdit(this);
	port			= new QSpinBox(this);
	conn			= new QPushButton("Connect", this);
	port->setRange(1, 32767);
	port->setValue(DEFAULT_PORT);
	server->setText("localhost");
	top->addWidget(label, 0, 0);
	top->addWidget(server, 0, 1);
	top->addWidget(port, 0, 2);

	label	= new QLabel("Prefix:", this);
	prefix	= new QLineEdit(this);
	prefix->setText("sim.");
	top->addWidget(label, 1, 0);
	top->addWidget(prefix, 1, 1);
	top->addWidget(conn, 1, 2);

	log_stat	= new QTextEdit(this);
	log_stat->setReadOnly(true);

	label	= new QLabel("Instruction:", this);
	message	= new QLineEdit(this);
	send	= new QPushButton("Send", this);
	send->setDefault(true);
	bottom->addWidget(label);
	bottom->addWidget(message);
	bottom->addWidget(send);

	main->addLayout(top);
	main->addWidget(log_stat);
	main->addLayout(bottom);
	setLayout(main);

	buffer = new QBuffer(this);
	socket = new QTcpSocket(this);
	buffer->open(QIODevice::ReadWrite);

	connect(message, SIGNAL(returnPressed()), SLOT(sendInstruction()));
	connect(send, SIGNAL(clicked()), SLOT(sendInstruction()));
	connect(conn, SIGNAL(clicked()), SLOT(toggleConnection()));

	connect(socket, SIGNAL(connected()), SLOT(setConnected()));
	connect(socket, SIGNAL(disconnected()), SLOT(setDisconnected()));
	connect(socket, SIGNAL(readyRead()), SLOT(receiveMessage()));

	setDisconnected();
}

InstructionGen::~InstructionGen()
{
	buffer->close();
}

void InstructionGen::setConnected()
{
	port->setEnabled(false);
	server->setEnabled(false);
	prefix->setEnabled(true);
	message->setEnabled(true);
	log_stat->setEnabled(true);
	log_stat->clear();
	send->setEnabled(true);
	conn->setText("Disconnect");
}

void InstructionGen::setDisconnected()
{
	port->setEnabled(true);
	server->setEnabled(true);
	prefix->setEnabled(false);
	message->setEnabled(false);
	log_stat->setEnabled(false);
	send->setEnabled(false);
	conn->setText("Connect");
}

void InstructionGen::toggleConnection()
{
	if (socket->state() == QAbstractSocket::UnconnectedState)
	{
		socket->connectToHost(server->text(), port->value());
	}
	else
	{
		socket->disconnectFromHost();
	}
}

void InstructionGen::sendInstruction()
{
	socket->write(prefix->text().toLatin1() + message->text().toLatin1() + "\n");
	log_stat->append((prefix->text().toLatin1() + message->text().toLatin1() + "\n").simplified());
	message->clear();
}

void InstructionGen::receiveMessage()
{
	// missing some checks for returns values for the sake of simplicity
	qint64 bytes = buffer->write(socket->readAll());
	// go back as many bytes as we just wrote so that it can be read
	buffer->seek(buffer->pos() - bytes);
	// read only full lines, line by line
	while (buffer->canReadLine())
	{
		QString line = buffer->readLine();
		log_stat->append("received: "+line.simplified());
	}
}

To copy to clipboard, switch view to plain text mode 

[tbscope]

Here's your problem

connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater()));

connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater()));

To copy to clipboard, switch view to plain text mode 

Do you understand why?

If you want to keep it simple, I've just added an example to the wiki on how to do all this without using threads.
A lot of people seem to think they need threads for some reason.
http://www.qtcentre.org/wiki/index.p...ithout_threads

[Suncell]

Outsch yeah - thx.

And I need to loop in the run method - right?

Why isn't a thread necessary. The program will receive tons of data out of a medical device. It should be prevent in any case blocking biosignal analysis.
Or doesn't it matter?

[tbscope]

You might want to have an event loop in your thread.

It should be prevent in any case blocking biosignal analysis

And yet you use blocking functions :-)

It doesn't really matter. In general, do not use threads for your connections. Do use them if you need to perform long tasks in parallel (send or receive a lot of data is not one of those tasks as it is received in packets).
And if you don't use threads, don't use the blocking functions at all. Don't use them in threads either. The blocking functions are there for a few special cases where the client or server doesn't allow you to communicate asynchronously.

[Suncell]

^^ yeah I should remove them.

But now - I'm still stuck. The readData() function is never called. Maybe deriving the Class CTcpSocket from QObject() is wrong?

Now, server code looks like that:

Server:

MultiServer server;
if (!server.listen(QHostAddress::Any, 15000)) {
   close();
   return;
 }

MultiServer server;
if (!server.listen(QHostAddress::Any, 15000)) {
   close();
   return;
 }

To copy to clipboard, switch view to plain text mode 

MultiServer.cpp

MultiServer::MultiServer(QObject *parent)
: QTcpServer(parent)
{
 
}
 
void MultiServer::incomingConnection(int socketDescriptor)
{
    QString msg = "Message from server";
    ConnectionThread *thread = new ConnectionThread(socketDescriptor, msg, this);
    thread->start();
}

MultiServer::MultiServer(QObject *parent)
: QTcpServer(parent)
{

}

void MultiServer::incomingConnection(int socketDescriptor)
{
    QString msg = "Message from server";
    ConnectionThread *thread = new ConnectionThread(socketDescriptor, msg, this);
    thread->start();
}

To copy to clipboard, switch view to plain text mode 

ConnectionThread.cpp

ConnectionThread::ConnectionThread(int socketDescriptor, const QString &msg, QObject *parent)
: QThread(parent)
, socketDescriptor(socketDescriptor)
, text(msg)
{
 
}
 
void ConnectionThread::run()
{
	my_sock = new CTcpSocket(socketDescriptor);
 
	my_sock->writeData(text);
 
	while(1)
	{
 
	}
}

ConnectionThread::ConnectionThread(int socketDescriptor, const QString &msg, QObject *parent)
: QThread(parent)
, socketDescriptor(socketDescriptor)
, text(msg)
{

}

void ConnectionThread::run()
{
	my_sock = new CTcpSocket(socketDescriptor);

	my_sock->writeData(text);

	while(1)
	{

	}
}

To copy to clipboard, switch view to plain text mode 

tcpsocket.cpp

CTcpSocket::CTcpSocket(int socketDescriptor, QObject *parent)
: QObject(parent)
, m_socketDescriptor(socketDescriptor)
{
	m_tcpSocket = new QTcpSocket();
 
	if (!m_tcpSocket->setSocketDescriptor(m_socketDescriptor)) {
		qDebug() << m_tcpSocket->error();
		return;
	}
 
	connect(m_tcpSocket, SIGNAL(readyRead()), SLOT(readData()));
}
 
 
void CTcpSocket::readData()
{
	//ToDo Implement reading Data
	qDebug() << "try to read";
}
 
 
void CTcpSocket::writeData(QString txt)
{
	qDebug() << "try to write";
 
    QByteArray block;
    QDataStream out(&block, QIODevice::WriteOnly);
    out.setVersion(QDataStream::Qt_4_0);
    out << (quint16)0;
    out << txt;
    out.device()->seek(0);
    out << (quint16)(block.size() - sizeof(quint16));
 
    m_tcpSocket->write(block);
}

CTcpSocket::CTcpSocket(int socketDescriptor, QObject *parent)
: QObject(parent)
, m_socketDescriptor(socketDescriptor)
{
	m_tcpSocket = new QTcpSocket();

	if (!m_tcpSocket->setSocketDescriptor(m_socketDescriptor)) {
		qDebug() << m_tcpSocket->error();
		return;
	}

	connect(m_tcpSocket, SIGNAL(readyRead()), SLOT(readData()));
}


void CTcpSocket::readData()
{
	//ToDo Implement reading Data
	qDebug() << "try to read";
}


void CTcpSocket::writeData(QString txt)
{
	qDebug() << "try to write";

    QByteArray block;
    QDataStream out(&block, QIODevice::WriteOnly);
    out.setVersion(QDataStream::Qt_4_0);
    out << (quint16)0;
    out << txt;
    out.device()->seek(0);
    out << (quint16)(block.size() - sizeof(quint16));

    m_tcpSocket->write(block);
}

To copy to clipboard, switch view to plain text mode 

[numbat]

Instead of "while (1)" which just loops forever and doesn't allow anything else to happen in that thread, yoiu need to run "exec()". This starts the event loop for a thread and will allow your events to run. Note, it is your responsibility to call "exit()" when you want event processing (and the thread) to finish.

[Suncell]

okay instead of while I use now exec(). Am I doing it right with the exit()?

The connect works fine and also the reading of the incoming data.
But writing to the socket by emitting a signal does not work - Cannot create children for a parent that is in a different thread - is the error. I tried moving several objects to several threads by using moveToThread(currentThread()). What should I move to which place?

multiserver.cpp

MultiServer::MultiServer(QObject *parent)
: QTcpServer(parent)
{
 
}
 
void MultiServer::incomingConnection(int socketDescriptor)
{
    ConnectionThread *thread = new ConnectionThread(socketDescriptor, this);
    connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater()));
    thread->start();
}

MultiServer::MultiServer(QObject *parent)
: QTcpServer(parent)
{

}

void MultiServer::incomingConnection(int socketDescriptor)
{
    ConnectionThread *thread = new ConnectionThread(socketDescriptor, this);
    connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater()));
    thread->start();
}

To copy to clipboard, switch view to plain text mode 

ConnectionThread.h

#ifndef CONNECTIONTHREAD_H
 #define CONNECTIONTHREAD_H
 
 #include <QThread>
 #include <QTcpSocket>
 
 #include <QMutex>
 #include <QWaitCondition>
 
#include "tcpsocket.h"
 
 class ConnectionThread : public QThread
 {
     Q_OBJECT
 
 public:
     ConnectionThread(int socketDescriptor, QObject *parent);
     ~ConnectionThread();
 
     void run();
 
     void stop();
 
 signals:
     void error(QTcpSocket::SocketError socketError, const QString &message);
     void dataAvailable(QString &msg);
 
 private slots:
	 void readData();
	 void writeData(QString &msg);
 
 private:
     int socketDescriptor;
     QString text;
 
     QMutex mutex;
     QWaitCondition cond;
 
     QBuffer* buffer;
 
     QTcpSocket* m_tcpSocket;
 };
 #endif

#ifndef CONNECTIONTHREAD_H
 #define CONNECTIONTHREAD_H

 #include <QThread>
 #include <QTcpSocket>

 #include <QMutex>
 #include <QWaitCondition>

#include "tcpsocket.h"

 class ConnectionThread : public QThread
 {
     Q_OBJECT

 public:
     ConnectionThread(int socketDescriptor, QObject *parent);
     ~ConnectionThread();

     void run();

     void stop();

 signals:
     void error(QTcpSocket::SocketError socketError, const QString &message);
     void dataAvailable(QString &msg);

 private slots:
	 void readData();
	 void writeData(QString &msg);

 private:
     int socketDescriptor;
     QString text;

     QMutex mutex;
     QWaitCondition cond;

     QBuffer* buffer;

     QTcpSocket* m_tcpSocket;
 };
 #endif

To copy to clipboard, switch view to plain text mode 

ConnectionThread.cpp

#include "ConnectionThread.h"
 
 #include <QtNetwork>
 
ConnectionThread::ConnectionThread(int socketDescriptor, QObject *parent)
: QThread(parent)
, socketDescriptor(socketDescriptor)
{
	qDebug() << currentThreadId ();//Thread Y
}
 
ConnectionThread::~ConnectionThread ()
{
	stop();
}
 
void ConnectionThread::stop()
{
	exit();
}
 
void ConnectionThread::run()
{
	qDebug() << currentThreadId();//Thread X - Different thread ID than all others
 
 
	m_tcpSocket = new QTcpSocket();
 
	buffer = new QBuffer();
	buffer->open(QIODevice::ReadWrite);
 
 
    if (!m_tcpSocket->setSocketDescriptor(socketDescriptor)) {
        emit error(m_tcpSocket->error(), m_tcpSocket->errorString());
        return;
    }
 
	connect(m_tcpSocket, SIGNAL(readyRead()), SLOT(readData()));
	connect(this, SIGNAL(dataAvailable(QString &)), SLOT(writeData(QString &)));
 
       exec();
}
 
 void ConnectionThread::readData()
 {
	 qDebug() << "data arrived";
	 qDebug() << currentThreadId (); // Thread Y
 
	qint64 bytes = buffer->write(m_tcpSocket->readAll());
	buffer->seek(buffer->pos() - bytes);
	while (buffer->canReadLine())
	{
		QString line = buffer->readLine();
		//log_stat->append("received: "+line.simplified());
		qDebug() << line;
	}
 
	QString msg = "reply code";
 
	emit dataAvailable(msg);//here is the Error -Cannot create children for a parent that is in a different thread - emitted
 }
 
 
void ConnectionThread::writeData(QString &msg)
{
	qDebug() << msg;
	qDebug() << currentThreadId ();  //Thread Y
	qint64 blockSize = msg.size();
	m_tcpSocket->write(msg.toAscii().data(),blockSize);
}

#include "ConnectionThread.h"

 #include <QtNetwork>

ConnectionThread::ConnectionThread(int socketDescriptor, QObject *parent)
: QThread(parent)
, socketDescriptor(socketDescriptor)
{
	qDebug() << currentThreadId ();//Thread Y
}

ConnectionThread::~ConnectionThread ()
{
	stop();
}

void ConnectionThread::stop()
{
	exit();
}

void ConnectionThread::run()
{
	qDebug() << currentThreadId();//Thread X - Different thread ID than all others


	m_tcpSocket = new QTcpSocket();

	buffer = new QBuffer();
	buffer->open(QIODevice::ReadWrite);


    if (!m_tcpSocket->setSocketDescriptor(socketDescriptor)) {
        emit error(m_tcpSocket->error(), m_tcpSocket->errorString());
        return;
    }

	connect(m_tcpSocket, SIGNAL(readyRead()), SLOT(readData()));
	connect(this, SIGNAL(dataAvailable(QString &)), SLOT(writeData(QString &)));

       exec();
}

 void ConnectionThread::readData()
 {
	 qDebug() << "data arrived";
	 qDebug() << currentThreadId (); // Thread Y

	qint64 bytes = buffer->write(m_tcpSocket->readAll());
	buffer->seek(buffer->pos() - bytes);
	while (buffer->canReadLine())
	{
		QString line = buffer->readLine();
		//log_stat->append("received: "+line.simplified());
		qDebug() << line;
	}

	QString msg = "reply code";

	emit dataAvailable(msg);//here is the Error -Cannot create children for a parent that is in a different thread - emitted
 }


void ConnectionThread::writeData(QString &msg)
{
	qDebug() << msg;
	qDebug() << currentThreadId ();  //Thread Y
	qint64 blockSize = msg.size();
	m_tcpSocket->write(msg.toAscii().data(),blockSize);
}

To copy to clipboard, switch view to plain text mode 

AND just for Information:
Working version without signal and slots - but with a strict order of reading and writing

ConnectionThread.cpp version 2

#include "ConnectionThread.h"
 
#include <QtNetwork>
 
ConnectionThread::ConnectionThread(int socketDescriptor, QObject *parent)
: QThread(parent)
, socketDescriptor(socketDescriptor)
{
}
 
 
void ConnectionThread::run()
{
	while(1)// ToDo no quit
	{
//		int st;
//		switch(tcpSocket.state())
//		{
//			case QTcpSocket::UnconnectedState:
//				st= 0;
//				break;
//			case QTcpSocket::HostLookupState:
//				st= 1;
//				break;
//			case QTcpSocket::ConnectingState:
//				st= 2;
//				break;
//			case QTcpSocket::ConnectedState:
//				st= 3;
//				break;
//			case QTcpSocket::BoundState:
//				st= 4;
//				break;
//			case QTcpSocket::ListeningState:
//				st= 5;
//				break;
//			case QTcpSocket::ClosingState:
//				st= 6;
//				break;
//		}
//		qDebug() << st;
 
 
		while (tcpSocket.bytesAvailable() < (int)sizeof(quint16)) {
			if (!tcpSocket.waitForReadyRead(Timeout)) {
				qDebug() << "Nothing arrived!";
				if(tcpSocket.state()!=QTcpSocket::ConnectedState)
				{
					qDebug() << "Connection broken!";
					emit error(tcpSocket.error(), tcpSocket.errorString());
					return;
				}
				continue;
			}
		}
 
		char *buffer = (char*) malloc (1024);
		quint64 n = tcpSocket.read(buffer,1024);
 
 
 
        mutex.lock();
		QString txt = QString(buffer).mid(0,n);
 
		qDebug() << txt;
 
        //cond.wait(&mutex); //wait condition to wake up thread -> obsolete waiting above for data arriving - maybe connect with incoming data
 
        mutex.unlock();
 
 
		QString msg = "Hello, world - here is rtproc! Give me some data to process! \n";//Todo just for debug purpose
		qint64 blockSize = msg.size();//Todo just for debug purpose
 
		tcpSocket.write(msg.toAscii().data(),blockSize);//Todo just for debug purpose
		tcpSocket.flush();//Todo just for debug purpose
	}
 
 
//    tcpSocket.disconnectFromHost();
//    tcpSocket.waitForDisconnected();
}

#include "ConnectionThread.h"

#include <QtNetwork>

ConnectionThread::ConnectionThread(int socketDescriptor, QObject *parent)
: QThread(parent)
, socketDescriptor(socketDescriptor)
{
}


void ConnectionThread::run()
{
	while(1)// ToDo no quit
	{
//		int st;
//		switch(tcpSocket.state())
//		{
//			case QTcpSocket::UnconnectedState:
//				st= 0;
//				break;
//			case QTcpSocket::HostLookupState:
//				st= 1;
//				break;
//			case QTcpSocket::ConnectingState:
//				st= 2;
//				break;
//			case QTcpSocket::ConnectedState:
//				st= 3;
//				break;
//			case QTcpSocket::BoundState:
//				st= 4;
//				break;
//			case QTcpSocket::ListeningState:
//				st= 5;
//				break;
//			case QTcpSocket::ClosingState:
//				st= 6;
//				break;
//		}
//		qDebug() << st;


		while (tcpSocket.bytesAvailable() < (int)sizeof(quint16)) {
			if (!tcpSocket.waitForReadyRead(Timeout)) {
				qDebug() << "Nothing arrived!";
				if(tcpSocket.state()!=QTcpSocket::ConnectedState)
				{
					qDebug() << "Connection broken!";
					emit error(tcpSocket.error(), tcpSocket.errorString());
					return;
				}
				continue;
			}
		}

		char *buffer = (char*) malloc (1024);
		quint64 n = tcpSocket.read(buffer,1024);



        mutex.lock();
		QString txt = QString(buffer).mid(0,n);

		qDebug() << txt;

        //cond.wait(&mutex); //wait condition to wake up thread -> obsolete waiting above for data arriving - maybe connect with incoming data

        mutex.unlock();


		QString msg = "Hello, world - here is rtproc! Give me some data to process! \n";//Todo just for debug purpose
		qint64 blockSize = msg.size();//Todo just for debug purpose

		tcpSocket.write(msg.toAscii().data(),blockSize);//Todo just for debug purpose
		tcpSocket.flush();//Todo just for debug purpose
	}


//    tcpSocket.disconnectFromHost();
//    tcpSocket.waitForDisconnected();
}

To copy to clipboard, switch view to plain text mode 

[Suncell]

Found a very useful thread in the forum: http://www.qtcentre.org/threads/1197...ded-TCP-server

But writing to the client is now a problem....

Code looks now like that:

multiserver.cpp

#include "multiserver.h"
 
MultiServer::MultiServer(QObject *parent)
: QTcpServer(parent)
{
}
 
void MultiServer::incomingConnection(int socketDescriptor)
{
    server = new ServerThread(socketDescriptor, this);
    connect(server, SIGNAL(finished()), server, SLOT(deleteLater()));
    server->start();
}

#include "multiserver.h"

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

void MultiServer::incomingConnection(int socketDescriptor)
{
    server = new ServerThread(socketDescriptor, this);
    connect(server, SIGNAL(finished()), server, SLOT(deleteLater()));
    server->start();
}

To copy to clipboard, switch view to plain text mode 

serverthread.cpp

#include "serverthread.h"
 
ServerThread::ServerThread(int socketDescriptor, QObject *parent)
: QThread(parent)
, m_socketDescriptor(socketDescriptor)
{
	qDebug() << currentThreadId ();
}
 
ServerThread::~ServerThread ()
{
	stop();
}
 
void ServerThread::stop()
{
	exit();
}
 
void ServerThread::run()
{
	serverSocket = new ServerTcpSocket();
 
	if (!serverSocket->setSocketDescriptor(m_socketDescriptor)) {
		emit error(serverSocket->error(), serverSocket->errorString());
		qDebug() << "setSocketDescriptor error : " << serverSocket->error() << endl;
		return;
	}
 
	exec();
}

#include "serverthread.h"

ServerThread::ServerThread(int socketDescriptor, QObject *parent)
: QThread(parent)
, m_socketDescriptor(socketDescriptor)
{
	qDebug() << currentThreadId ();
}

ServerThread::~ServerThread ()
{
	stop();
}

void ServerThread::stop()
{
	exit();
}

void ServerThread::run()
{
	serverSocket = new ServerTcpSocket();

	if (!serverSocket->setSocketDescriptor(m_socketDescriptor)) {
		emit error(serverSocket->error(), serverSocket->errorString());
		qDebug() << "setSocketDescriptor error : " << serverSocket->error() << endl;
		return;
	}

	exec();
}

To copy to clipboard, switch view to plain text mode 

servertcpsocket.cpp

#include "servertcpsocket.h"
 
ServerTcpSocket::ServerTcpSocket(QObject *parent)
: QTcpSocket(parent)
{
	buffer = new QBuffer();
	buffer->open(QIODevice::ReadWrite);
 
	connect(this, SIGNAL(readyRead()), this, SLOT(readData()));
 
	connect(this, SIGNAL(disconnected()), this, SLOT(deleteLater()));
}
 
 
void ServerTcpSocket::readData()
{
	qint64 bytes = buffer->write(this->readAll());
	buffer->seek(buffer->pos() - bytes);
	while (buffer->canReadLine())
	{
		QString line = buffer->readLine();
		qDebug() << line;
	}
 
	emit dataAvailable();
}

#include "servertcpsocket.h"

ServerTcpSocket::ServerTcpSocket(QObject *parent)
: QTcpSocket(parent)
{
	buffer = new QBuffer();
	buffer->open(QIODevice::ReadWrite);

	connect(this, SIGNAL(readyRead()), this, SLOT(readData()));

	connect(this, SIGNAL(disconnected()), this, SLOT(deleteLater()));
}


void ServerTcpSocket::readData()
{
	qint64 bytes = buffer->write(this->readAll());
	buffer->seek(buffer->pos() - bytes);
	while (buffer->canReadLine())
	{
		QString line = buffer->readLine();
		qDebug() << line;
	}

	emit dataAvailable();
}

To copy to clipboard, switch view to plain text mode 

Any clue how to solve the writing to the client

[Suncell]

Actually writing to the client does work, but with annoying messages.
When I try to write a reply immediately after receiving a message. (For debug purpose it is solved with a connect.)
Then I got always "QObject: Cannot create children for a parent that is in a different thread." But reply message is send anyway. So i could not care about, but its a kind of distrubing. This error appears with and without moving to thread. Is there a way to fix this problem?

serverthread.cpp

#include "serverthread.h"
 
ServerThread::ServerThread(int socketDescriptor, QObject *parent)
: QThread(parent)
, m_socketDescriptor(socketDescriptor)
{
	qDebug() << currentThreadId ();
}
 
ServerThread::~ServerThread ()
{
	stop();
}
 
void ServerThread::stop()
{
	exit();
}
 
void ServerThread::run()
{
	serverSocket = new ServerTcpSocket();
 
	if (!serverSocket->setSocketDescriptor(m_socketDescriptor)) {
		emit error(serverSocket->error(), serverSocket->errorString());
		qDebug() << "setSocketDescriptor error : " << serverSocket->error() << endl;
		return;
	}
 
	connect(serverSocket, SIGNAL(dataAvailable()), this, SLOT(writeData()));
 
	exec();
}
 
void ServerThread::writeData()
{
	serverSocket->moveToThread(currentThread());
//QObject::moveToThread: Current thread (0x1b102fc0) is not the object's thread (0x1b01b6a0).
//Cannot move to target thread (0x1b01b6a0)
 
        m_mutex.lock();
 
	QString msg = "Message from Server\n";
	qint64 blockSize = msg.size();
 
	serverSocket->write(msg.toAscii().data(),blockSize);
// QObject: Cannot create children for a parent that is in a different thread.
//(Parent is QNativeSocketEngine(0x103df1b0), parent's thread is ServerThread(0x103c2910), current thread is QThread(0x101966a0)
	m_mutex.unlock();
}

#include "serverthread.h"

ServerThread::ServerThread(int socketDescriptor, QObject *parent)
: QThread(parent)
, m_socketDescriptor(socketDescriptor)
{
	qDebug() << currentThreadId ();
}

ServerThread::~ServerThread ()
{
	stop();
}

void ServerThread::stop()
{
	exit();
}

void ServerThread::run()
{
	serverSocket = new ServerTcpSocket();

	if (!serverSocket->setSocketDescriptor(m_socketDescriptor)) {
		emit error(serverSocket->error(), serverSocket->errorString());
		qDebug() << "setSocketDescriptor error : " << serverSocket->error() << endl;
		return;
	}

	connect(serverSocket, SIGNAL(dataAvailable()), this, SLOT(writeData()));

	exec();
}

void ServerThread::writeData()
{
	serverSocket->moveToThread(currentThread());
//QObject::moveToThread: Current thread (0x1b102fc0) is not the object's thread (0x1b01b6a0).
//Cannot move to target thread (0x1b01b6a0)

        m_mutex.lock();

	QString msg = "Message from Server\n";
	qint64 blockSize = msg.size();

	serverSocket->write(msg.toAscii().data(),blockSize);
// QObject: Cannot create children for a parent that is in a different thread.
//(Parent is QNativeSocketEngine(0x103df1b0), parent's thread is ServerThread(0x103c2910), current thread is QThread(0x101966a0)
	m_mutex.unlock();
}

To copy to clipboard, switch view to plain text mode 

[Suncell]

Solved it finally!
Now writing and reading are running in one different thread

I'm thankful for every improvement.

Now the Source code:
multiserver.cpp

#include "multiserver.h"
 
MultiServer::MultiServer(QObject *parent)
: QTcpServer(parent)
{
}
 
MultiServer::~MultiServer()
{
	delete server;
}
 
void MultiServer::incomingConnection(int socketDescriptor)
{
	qDebug() << "MultiServer thread " << QThread::currentThreadId ();
 
    server = new ServerThread(socketDescriptor);
    connect(server, SIGNAL(finished()), server, SLOT(deleteLater()));
    server->start();
}

#include "multiserver.h"

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

MultiServer::~MultiServer()
{
	delete server;
}

void MultiServer::incomingConnection(int socketDescriptor)
{
	qDebug() << "MultiServer thread " << QThread::currentThreadId ();

    server = new ServerThread(socketDescriptor);
    connect(server, SIGNAL(finished()), server, SLOT(deleteLater()));
    server->start();
}

To copy to clipboard, switch view to plain text mode 

serverthread.cpp

#include "serverthread.h"
 
ServerThread::ServerThread(int socketDescriptor)
: QThread()
, m_socketDescriptor(socketDescriptor)
{
	QObject::moveToThread(this); //destroy the obsolete thread
	qDebug() << "ServerThread " << QThread::currentThreadId ();
}
 
ServerThread::~ServerThread ()
{
	stop();
	delete serverSocket;
}
 
void ServerThread::stop()
{
	this->quit();
    this->wait();
}
 
void ServerThread::run()
{
	serverSocket = new ServerTcpSocket();
 
	if (!serverSocket->setSocketDescriptor(m_socketDescriptor)) {
		emit error(serverSocket->error(), serverSocket->errorString());
		qDebug() << "setSocketDescriptor error : " << serverSocket->error() << endl;
		return;
	}
 
	connect(serverSocket, SIGNAL(dataAvailable()), this, SLOT(writeData()));
 
	this->exec();
}
 
void ServerThread::writeData()
{
 
	qDebug() << "writing thread" << currentThreadId ();
 
	QString msg = "Message from Server\n";//Todo just for debug purpose
	qint64 blockSize = msg.size();//Todo just for debug purpose
 
	serverSocket->write(msg.toAscii().data(),blockSize);
}

#include "serverthread.h"

ServerThread::ServerThread(int socketDescriptor)
: QThread()
, m_socketDescriptor(socketDescriptor)
{
	QObject::moveToThread(this); //destroy the obsolete thread
	qDebug() << "ServerThread " << QThread::currentThreadId ();
}

ServerThread::~ServerThread ()
{
	stop();
	delete serverSocket;
}

void ServerThread::stop()
{
	this->quit();
    this->wait();
}

void ServerThread::run()
{
	serverSocket = new ServerTcpSocket();

	if (!serverSocket->setSocketDescriptor(m_socketDescriptor)) {
		emit error(serverSocket->error(), serverSocket->errorString());
		qDebug() << "setSocketDescriptor error : " << serverSocket->error() << endl;
		return;
	}

	connect(serverSocket, SIGNAL(dataAvailable()), this, SLOT(writeData()));

	this->exec();
}

void ServerThread::writeData()
{

	qDebug() << "writing thread" << currentThreadId ();

	QString msg = "Message from Server\n";//Todo just for debug purpose
	qint64 blockSize = msg.size();//Todo just for debug purpose

	serverSocket->write(msg.toAscii().data(),blockSize);
}

To copy to clipboard, switch view to plain text mode 

servertcpsocket.cpp

#include "servertcpsocket.h"
 
ServerTcpSocket::ServerTcpSocket(QObject *parent)
: QTcpSocket(parent)
{
	buffer = new QBuffer();
	buffer->open(QIODevice::ReadWrite);
 
	connect(this, SIGNAL(readyRead()), this, SLOT(readData()));
 
	connect(this, SIGNAL(disconnected()), this, SLOT(deleteLater()));
}
 
 
void ServerTcpSocket::readData()
{
	qDebug() << "reading thread" << QThread::currentThreadId ();
	qint64 bytes = buffer->write(this->readAll());
	buffer->seek(buffer->pos() - bytes);
	while (buffer->canReadLine())
	{
		QString line = buffer->readLine();
		qDebug() << line;
	}
 
	emit dataAvailable();
}

#include "servertcpsocket.h"

ServerTcpSocket::ServerTcpSocket(QObject *parent)
: QTcpSocket(parent)
{
	buffer = new QBuffer();
	buffer->open(QIODevice::ReadWrite);

	connect(this, SIGNAL(readyRead()), this, SLOT(readData()));

	connect(this, SIGNAL(disconnected()), this, SLOT(deleteLater()));
}


void ServerTcpSocket::readData()
{
	qDebug() << "reading thread" << QThread::currentThreadId ();
	qint64 bytes = buffer->write(this->readAll());
	buffer->seek(buffer->pos() - bytes);
	while (buffer->canReadLine())
	{
		QString line = buffer->readLine();
		qDebug() << line;
	}

	emit dataAvailable();
}

To copy to clipboard, switch view to plain text mode