[QT4] Ein kleiner TcpServer ...

[nul]

... der allerdings nicht richtig funktioniert!
Meine Klasse stuetzt sich stark auf die Beispiele aus dem Bereich network, die Trolltech mit QT4 ausliefert.
Allerdings kann ich keine Daten vom Socket lesen, oder es werden keine Daten geschrieben :confused:
Auf jedenfall macht die Klasse nicht das was sie soll. Ich kann zwar verbindungen annehmen, kann aber dann vom Socket keine Nachrichten lesen, oder wie schon gesagt, das senden funktioniert nicht, was auch immmer ...
Vielleicht hat einer von euch kurz Zeit die ff. Klasse zu durchforsten und mir nen Ratschlag geben, was ich falsch mache ...

TcpServer::TcpServer()
{
tcpServer = new QTcpServer( this );

QHostAddress* hostaddr = new QHostAddress( "127.0.0.1" );

if ( !tcpServer->listen( *hostaddr, TCP_SERVER_PORT ) )
{
QString who = "TcpServer";
QString why = tcpServer->errorString();

// error message!
std::cout << "Can't create TcpServerSocket!" << std::endl;

tcpServer->close();
return;
}

connect( tcpServer, SIGNAL( newConnection() ), this, SLOT( newClientConnection() ) );
};

TcpServer::~TcpServer()
{
tcpServer->close();
};

void
TcpServer::newClientConnection()
{
QTcpSocket* clientSocket = tcpServer->nextPendingConnection();
connect( clientSocket, SIGNAL( readyRead() ), this, SLOT( readClientMessage( clientSocket ) ) );
std::cout << "new connection" << std::endl;
};

void
TcpServer::readClientMessage( QTcpSocket* clientSocket )
{
std::cout << "read data" << std::endl;
/* QDataStream in( clientSocket );
in.setVersion( QDataStream::Qt_4_1 );

QString clientMessage;
in >> clientMessage;

std::cout << clientMessage.toStdString() << std::endl;

clientSocket->disconnect();
delete clientSocket; */
};

void
TcpServer::sendMessage( const QHostAddress* host, const QString& message )
{
QTcpSocket* sendSocket;

QByteArray block;
QDataStream out( &block, QIODevice::WriteOnly );
out.setVersion( QDataStream::Qt_4_1 );
out << message;

sendSocket = new QTcpSocket;
sendSocket->connectToHost ( *host, TCP_SERVER_PORT );
connect( sendSocket, SIGNAL( disconnected() ), sendSocket, SLOT( deleteLater() ) );

sendSocket->write( block );
sendSocket->disconnectFromHost();

delete sendSocket;
};
Bin fuer jeden Hinweis dankbar!!!

mfg

[anda_skoa]

Sofern sich bei Qt4 das nicht geändert hat, ist dieser Connect nicht möglich


connect( clientSocket, SIGNAL( readyRead() ), this, SLOT( readClientMessage( clientSocket ) ) );


Das Signal hat weniger Parameter als der Slot und clientSocket ist kein Typ sondern der Name einer Variable

Ciao,
_

[nul]

Also ich hatte so ca. die selben Probleme und das so geloest:
TcpServer.h

#include <QTcpServer>
#include <QHostAddress>
#include <iostream>
#include "Read.h"
#include "main.h"

#ifndef TCPSERVER_H
#define TCPSERVER_H TCPSERVER_H

class TcpServer : public QTcpServer
{
Q_OBJECT

public:
TcpServer(QObject* parent = 0, QHostAddress& host = QHostAddress::Broadcast );

protected:
void incomingConnection( int socketDescriptor );

private:
QTcpSocket* socket;
QHostAddress hAddress;
};


#include "TcpServer.h"

TcpServer::TcpServer(QObject* parent, QHostAddress& host ) :
QTcpServer(parent), hAddress( host )
{
if ( !listen( hAddress, TCP_SERVER_PORT ) )
{
std::cout << "server couldn't be started" << std::endl;
return;
}
};

void
TcpServer::incomingConnection( int socketDescriptor )
{
Read* read = new Read( socketDescriptor, this );
connect( read, SIGNAL( started() ), read, SLOT( started() ) );
connect( read, SIGNAL( finished() ), read, SLOT( deleteLater() ) );
read->start();
};

Write.h

#ifndef WRITE_H
#define WRITE_H WRITE_H

#include <QThread>
#include <QHostAddress>
#include <QTcpSocket>
#include <iostream>
#include "main.h"

class Write : public QThread
{
Q_OBJECT

public:
Write( QObject* parent = 0 );
virtual ~Write();
void run();
void setHostAddress( QHostAddress& hostAddress );
void setMessage( QString& message );

private slots:
void started();
void finished( int exitCode );

private:
QHostAddress hAddress;
QString cMessage;

QTcpSocket* socket;
};

#endif


#include "Write.h"

Write::Write( QObject* parent ) :
QThread( parent )
{
connect( this, SIGNAL( started() ), this, SLOT( started() ) );
connect( this, SIGNAL( finished() ), this, SLOT( deleteLater() ) );
};

Write::~Write()
{
delete socket;
};

void
Write::run()
{
socket = new QTcpSocket;
socket->connectToHost( hAddress, TCP_SERVER_PORT );
exec();
};

void
Write::setHostAddress( QHostAddress& hostAddress )
{
hAddress = hostAddress;
};

void
Write::setMessage( QString& message )
{
cMessage = message;
};

void
Write::started()
{
QByteArray byteArray;
byteArray.append( cMessage );

socket->write( byteArray );
socket->flush();

finished( 0 );
};

void
Write::finished( int exitCode )
{
socket->disconnectFromHost();
socket->close();

quit();
};

Read.h

#ifndef READ_H
#define READ_H READ_H

#include <QThread>
#include <QTcpSocket>
#include <QProcess>
#include <QHostAddress>
#include <iostream>

class Read : public QThread
{
Q_OBJECT

public:
Read( int fd, QObject* parent = 0 );
virtual ~Read();
void run();

private slots:
void read();
void started();
void finished( int exitCode );

signals:
void error( QTcpSocket::SocketError socketError );

private:
QProcess *process;
QTcpSocket *socket;
int socketDescriptor;
};

#endif


#include "Read.h"
#include "Controller.h"

Read::Read( int fd, QObject* parent ) :
QThread( parent ), socketDescriptor( fd )
{
};

Read::~Read()
{
delete socket;
};

void
Read::run()
{
exec();
};

void
Read::read()
{
QByteArray arr = socket->readAll();
QString mess( arr.data() );

Controller* controller = Controller::getInstance();

QHostAddress h = socket->peerAddress();
controller->getClientMessage( h, mess );

finished( 0 );
};

void
Read::started()
{
socket = new QTcpSocket;

connect( socket, SIGNAL( readyRead() ), this, SLOT( read() ) );

if ( !socket->setSocketDescriptor( socketDescriptor ) )
{
std::cout << "Start thread error socket descriptor" << std::endl;
return;
}
};

void
Read::finished( int exitCode )
{
socket->disconnectFromHost();
socket->close();

quit();
};

Ich hoffe ich hab jetzt nicht zu viel geloescht, aber so muesste es im Prinzip funktionieren!