PDA

View Full Version : QTCPSocket created from QTCPServer stops receiveing after first packet is sent until



tlann
24th October 2012, 01:34
A QTCPSocket created from a QTCPServer after receiving a connection stops receiving after the first packet is sent from the QTCPServer Socket. If another packet is sent from the Server created socket the rest of the packets are received that were sent. I can tell that the tcp connection is still connected because the client is still in the connected state.

The code is heavily based on the async Fortune Server.

This is pretty confusing and I'm not sure how else to trouble shoot this. I've been working on this for about 3 days. Any suggestions would be greatly appreciated.



class TCPThread : public QThread
{
Q_OBJECT

public:
TCPThread(int socketDescriptor, QObject *parent);

void run();

void write(QString& toWrite);
signals:
void error(QTcpSocket::SocketError socketError);
void clientDisconnected();
void receiveMessage(QString* message);

public slots:
void readMessage();
void disconnectedFromClient();
void writeMessage(QString& message);

private:
int socketDescriptor_;
QTcpSocket* socket_;

};




class TCPServerA : public QTcpServer
{
Q_OBJECT

public:
TCPServerA(QObject *parent);
~TCPServerA();

void quit();

void write(QString& message);

public slots:
void socketError(QTcpSocket::SocketError socketError);
void disconnectedClient();
void receiveMessage(QString* message);


signals:
void error(QTcpSocket::SocketError socketError);
void disconnectedFromClient();
void writeMessage(QString& message);
void receivedMessage(QString* message);

private:
void incomingConnection(int socketDescriptor);

TCPThread* thread_;


};


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


void TCPThread::readMessage()
{
qint16 size(-1);
QDataStream in( socket_ );
QString* msg=new QString;
in.setVersion(QDataStream::Qt_4_7);

//Get all of the data from the queue
while (1)
{
if( size < 0 )
{
if( socket_->bytesAvailable() < sizeof( size ) )
return;
in >> size;
}
if( socket_->bytesAvailable() < size )
return;
in >> *msg;

emit receiveMessage(msg);

size = -1;
}

}

void TCPThread::run()
{

socket_= new QTcpSocket(this);

connect(socket_, SIGNAL(readyRead()),
this, SLOT(readMessage()));

connect(socket_, SIGNAL(disconnected()),
this, SLOT(disconnectedFromClient()));

if (!socket_->setSocketDescriptor(socketDescriptor_)) {
emit error(socket_->error());
return;
}

exec();


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

void TCPThread::disconnectedFromClient()
{
emit (clientDisconnected());

}

void TCPThread::writeMessage(QString& message)
{
write(message);
}


void TCPThread::write(QString& toWrite)
{
QByteArray block;

QDataStream out(&block, QIODevice::WriteOnly);
out.setVersion(QDataStream::Qt_4_7);
out<<(qint16)toWrite.size();
out<<toWrite;

socket_->write(block);
while(socket_->bytesToWrite() > 0)
{
socket_->waitForBytesWritten();
}
socket_->flush();
}


TCPServerA::TCPServerA(QObject *parent)
: QTcpServer(parent), thread_(NULL)
{

}

TCPServerA::~TCPServerA()
{

}


void TCPServerA::quit()
{
if (thread_ !=NULL)
{
thread_->quit();
thread_->wait();
delete thread_;
thread_=NULL;
}

close();
}

void TCPServerA::incomingConnection(int socketDescriptor)
{

thread_ = new TCPThread(socketDescriptor,this);
connect(thread_,SIGNAL(error(QTcpSocket::SocketErr or socketError)),this, SLOT(socketError(QTcpSocket::SocketError)));
connect(thread_, SIGNAL(finished()), thread_, SLOT(deleteLater()));
connect(this, SIGNAL(writeMessage(QString&)), thread_, SLOT(writeMessage(QString&)));

connect(thread_, SIGNAL(receiveMessage(QString*)), this, SLOT(receiveMessage(QString*)));
thread_->start();
}

void TCPServerA::write(QString& message)
{
if (thread_ == NULL )
return;
//thread_->write(message);
emit writeMessage(message);

}

void TCPServerA::socketError(QTcpSocket::SocketError socketError)
{
emit (error(socketError));
}


void TCPServerA::disconnectedClient()
{
emit (disconnectedFromClient());
}

void TCPServerA::receiveMessage(QString* message)
{
emit (receivedMessage(message));
}