I think that you can use the QHttp class to make more than one request at the same time, each having it’s own request id and that’s probably why trolltech designed the interface this way.

As for the “bad” responses i remember that i was curious about this at the time and that i discovered that the QHttp class can make other internal, protocol specific, requests witch are handled the same way as normal requests. I think that braking with a debugger when the “bad” response arrives will give you a clearer answer.

best wishes for you and thank you very much
pellex

Thanks a lot!!!!!

Those changes are the two methods syncSetHost and syncSetUser, and the connect() calls are moved to the constructors (to avoid re-connecting the signals in each call to this class).

So the code is as follows:

/***************************************************************************
* Copyright (C) 2005 by Iulian M *
* eti@erata.net *
***************************************************************************/
#ifndef ETKSYNCHTTP_H
#define ETKSYNCHTTP_H

#include
#include
#include

/**
* Provide a synchronous api over QHttp
* Uses a QEventLoop to block until the request is completed
* @author Iulian M
*/
class SyncHTTP: public QHttp
{
Q_OBJECT
public:
/// constructors
SyncHTTP(QObject* parent=0)
: QHttp(parent), requestID(-1), status(false)
{
///connect the requestFinished signal to our finished slot
connect(this,SIGNAL(requestFinished(int,bool)),SLOT(finished(int,bool)));
}

SyncHTTP(const QString& hostName, quint16 port=80, QObject* parent=0)
: QHttp(hostName,port,parent), requestID(-1), status(false)
{
///connect the requestFinished signal to our finished slot
connect(this,SIGNAL(requestFinished(int,bool)),SLOT(finished(int,bool)));
}

virtual ~SyncHTTP() {}

/// send GET request and wait until finished
bool syncGet(const QString& path, QIODevice* to=0)
{
/// start the request and store the requestID
requestID = get(path, to);
/// block until the request is finished
loop.exec();
/// return the request status
return status;
}

/// send POST request and wait until finished
bool syncPost(const QString& path, QIODevice* data, QIODevice* to=0)
{
/// start the request and store the requestID
requestID = post(path, data, to);
/// block until the request is finished
loop.exec();
/// return the request status
return status;
}

bool syncPost(const QString& path, const QByteArray& data, QIODevice* to=0)
{
/// create io device from QByteArray
QBuffer buffer;
buffer.setData(data);
return syncPost(path, &buffer, to);
}

bool syncSetHost(const QString& hostName, quint16 port=80)
{
/// start the request and store the requestID
requestID = setHost(hostName, port);
/// block until the request is finished
loop.exec();
/// return the request status
return status;
}

bool syncSetUser(const QString& userName, const QString& password=QString())
{
/// start the request and store the requestID
requestID = setUser(userName, password);
/// block until the request is finished
loop.exec();
/// return the request status
return status;
}

protected slots:
virtual void finished(int idx, bool err)
{
/// check to see if it’s the request we made
if (idx != requestID)
return;
/// set status of the request
status = !err;
/// end the loop
loop.exit();
}

private:
/// id of current request
int requestID;
/// error status of current request
bool status;
/// event loop used to block until request finished
QEventLoop loop;
};

#endif

goodbye!