summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/network/access/qnetworkaccessdebugpipebackend.cpp283
-rw-r--r--src/network/access/qnetworkaccessdebugpipebackend_p.h23
-rw-r--r--src/network/access/qnetworkaccessfilebackend.cpp85
-rw-r--r--src/network/access/qnetworkaccessfilebackend_p.h9
-rw-r--r--src/network/access/qnetworkaccessftpbackend.cpp64
-rw-r--r--src/network/access/qnetworkaccessftpbackend_p.h5
-rw-r--r--src/network/access/qnetworkaccesshttpbackend.cpp89
-rw-r--r--src/network/access/qnetworkaccesshttpbackend_p.h11
8 files changed, 198 insertions, 371 deletions
diff --git a/src/network/access/qnetworkaccessdebugpipebackend.cpp b/src/network/access/qnetworkaccessdebugpipebackend.cpp
index 2e5f1b1..d4bda9a 100644
--- a/src/network/access/qnetworkaccessdebugpipebackend.cpp
+++ b/src/network/access/qnetworkaccessdebugpipebackend.cpp
@@ -41,6 +41,8 @@
#include "qnetworkaccessdebugpipebackend_p.h"
#include "QtCore/qdatastream.h"
+#include <QCoreApplication>
+#include "private/qnoncontiguousbytedevice_p.h"
QT_BEGIN_NAMESPACE
@@ -51,12 +53,6 @@ enum {
WriteBufferSize = ReadBufferSize
};
-struct QNetworkAccessDebugPipeBackend::DataPacket
-{
- QList<QPair<QByteArray, QByteArray> > headers;
- QByteArray data;
-};
-
QNetworkAccessBackend *
QNetworkAccessDebugPipeBackendFactory::create(QNetworkAccessManager::Operation op,
const QNetworkRequest &request) const
@@ -79,12 +75,14 @@ QNetworkAccessDebugPipeBackendFactory::create(QNetworkAccessManager::Operation o
}
QNetworkAccessDebugPipeBackend::QNetworkAccessDebugPipeBackend()
- : incomingPacketSize(0), bareProtocol(false)
+ : bareProtocol(false), hasUploadFinished(false), hasDownloadFinished(false),
+ hasEverythingFinished(false), bytesDownloaded(0), bytesUploaded(0)
{
}
QNetworkAccessDebugPipeBackend::~QNetworkAccessDebugPipeBackend()
{
+ // this is signals disconnect, not network!
socket.disconnect(this); // we're not interested in the signals at this point
}
@@ -92,160 +90,150 @@ void QNetworkAccessDebugPipeBackend::open()
{
socket.connectToHost(url().host(), url().port(12345));
socket.setReadBufferSize(ReadBufferSize);
+
+ // socket ready read -> we can push from socket to downstream
connect(&socket, SIGNAL(readyRead()), SLOT(socketReadyRead()));
- connect(&socket, SIGNAL(bytesWritten(qint64)), SLOT(socketBytesWritten(qint64)));
connect(&socket, SIGNAL(error(QAbstractSocket::SocketError)), SLOT(socketError()));
connect(&socket, SIGNAL(disconnected()), SLOT(socketDisconnected()));
+ connect(&socket, SIGNAL(connected()), SLOT(socketConnected()));
+ // socket bytes written -> we can push more from upstream to socket
+ connect(&socket, SIGNAL(bytesWritten(qint64)), SLOT(socketBytesWritten(qint64)));
bareProtocol = url().queryItemValue(QLatin1String("bare")) == QLatin1String("1");
- if (!bareProtocol) {
- // "Handshake":
- // send outgoing metadata and the URL being requested
- DataPacket packet;
- //packet.metaData = request().metaData();
- packet.data = url().toEncoded();
- send(packet);
+ if (operation() == QNetworkAccessManager::PutOperation) {
+ uploadByteDevice = createUploadByteDevice();
+ QObject::connect(uploadByteDevice, SIGNAL(readyRead()), this, SLOT(uploadReadyReadSlot()));
+ QMetaObject::invokeMethod(this, "uploadReadyReadSlot", Qt::QueuedConnection);
}
}
-void QNetworkAccessDebugPipeBackend::closeDownstreamChannel()
+void QNetworkAccessDebugPipeBackend::socketReadyRead()
{
- if (operation() == QNetworkAccessManager::GetOperation)
- socket.disconnectFromHost();
+ pushFromSocketToDownstream();
}
-void QNetworkAccessDebugPipeBackend::closeUpstreamChannel()
+void QNetworkAccessDebugPipeBackend::downstreamReadyWrite()
{
- if (operation() == QNetworkAccessManager::PutOperation)
- socket.disconnectFromHost();
- else if (operation() == QNetworkAccessManager::PostOperation) {
- send(DataPacket());
- }
+ pushFromSocketToDownstream();
}
-bool QNetworkAccessDebugPipeBackend::waitForDownstreamReadyRead(int ms)
+void QNetworkAccessDebugPipeBackend::socketBytesWritten(qint64)
{
- readyReadEmitted = false;
- if (socket.bytesAvailable()) {
- socketReadyRead();
- if (readyReadEmitted)
- return true;
- }
- socket.waitForReadyRead(ms);
- return readyReadEmitted;
+ pushFromUpstreamToSocket();
}
-bool QNetworkAccessDebugPipeBackend::waitForUpstreamBytesWritten(int ms)
+void QNetworkAccessDebugPipeBackend::uploadReadyReadSlot()
{
- bytesWrittenEmitted = false;
- upstreamReadyRead();
- if (bytesWrittenEmitted)
- return true;
-
- socket.waitForBytesWritten(ms);
- return bytesWrittenEmitted;
+ pushFromUpstreamToSocket();
}
-void QNetworkAccessDebugPipeBackend::upstreamReadyRead()
+void QNetworkAccessDebugPipeBackend::pushFromSocketToDownstream()
{
- int maxWrite = WriteBufferSize - socket.bytesToWrite();
- if (maxWrite <= 0)
- return; // can't write yet, wait for the socket to write
-
- if (bareProtocol) {
- QByteArray data = readUpstream();
- if (data.isEmpty())
- return;
+ QByteArray buffer;
- socket.write(data);
- upstreamBytesConsumed(data.size());
- bytesWrittenEmitted = true;
+ if (socket.state() == QAbstractSocket::ConnectingState) {
return;
}
- DataPacket packet;
- packet.data = readUpstream();
- if (packet.data.isEmpty())
- return; // we'll be called again when there's data
- if (packet.data.size() > maxWrite)
- packet.data.truncate(maxWrite);
-
- if (!send(packet)) {
- QString msg = QObject::tr("Write error writing to %1: %2")
- .arg(url().toString(), socket.errorString());
- error(QNetworkReply::ProtocolFailure, msg);
+ forever {
+ if (hasDownloadFinished)
+ return;
- finished();
- return;
+ buffer.resize(ReadBufferSize);
+ qint64 haveRead = socket.read(buffer.data(), ReadBufferSize);
+
+ if (haveRead == -1) {
+ hasDownloadFinished = true;
+ // this ensures a good last downloadProgress is emitted
+ setHeader(QNetworkRequest::ContentLengthHeader, QVariant());
+ possiblyFinish();
+ break;
+ } else if (haveRead == 0) {
+ break;
+ } else {
+ // have read something
+ buffer.resize(haveRead);
+ bytesDownloaded += haveRead;
+ writeDownstreamData(buffer);
+ }
}
- upstreamBytesConsumed(packet.data.size());
- bytesWrittenEmitted = true;
}
-void QNetworkAccessDebugPipeBackend::downstreamReadyWrite()
+void QNetworkAccessDebugPipeBackend::pushFromUpstreamToSocket()
{
- socketReadyRead();
-}
+ // FIXME
+ if (operation() == QNetworkAccessManager::PutOperation) {
+ if (hasUploadFinished)
+ return;
-void QNetworkAccessDebugPipeBackend::socketReadyRead()
-{
- if (bareProtocol) {
- qint64 bytesToRead = socket.bytesAvailable();
- if (bytesToRead) {
- QByteArray buffer;
- buffer.resize(bytesToRead);
- qint64 bytesRead = socket.read(buffer.data(), bytesToRead);
- if (bytesRead < bytesToRead)
- buffer.truncate(bytesRead);
- writeDownstreamData(buffer);
- readyReadEmitted = true;
+ forever {
+ if (socket.bytesToWrite() >= WriteBufferSize)
+ return;
+
+ qint64 haveRead;
+ const char *readPointer = uploadByteDevice->readPointer(WriteBufferSize, haveRead);
+ if (haveRead == -1) {
+ // EOF
+ hasUploadFinished = true;
+ emitReplyUploadProgress(bytesUploaded, bytesUploaded);
+ possiblyFinish();
+ break;
+ } else if (haveRead == 0 || readPointer == 0) {
+ // nothing to read right now, we will be called again later
+ break;
+ } else {
+ qint64 haveWritten;
+ haveWritten = socket.write(readPointer, haveRead);
+
+ if (haveWritten < 0) {
+ // write error!
+ QString msg = QCoreApplication::translate("QNetworkAccessDebugPipeBackend", "Write error writing to %1: %2")
+ .arg(url().toString(), socket.errorString());
+ error(QNetworkReply::ProtocolFailure, msg);
+ finished();
+ return;
+ } else {
+ uploadByteDevice->advanceReadPointer(haveWritten);
+ bytesUploaded += haveWritten;
+ emitReplyUploadProgress(bytesUploaded, -1);
+ }
+
+ //QCoreApplication::processEvents();
+
+ }
}
- return;
}
+}
- while (canReceive() &&
- (socket.state() == QAbstractSocket::UnconnectedState || nextDownstreamBlockSize())) {
- DataPacket packet;
- if (receive(packet)) {
- if (!packet.headers.isEmpty()) {
- QList<QPair<QByteArray, QByteArray> >::ConstIterator
- it = packet.headers.constBegin(),
- end = packet.headers.constEnd();
- for ( ; it != end; ++it)
- setRawHeader(it->first, it->second);
- metaDataChanged();
- }
+void QNetworkAccessDebugPipeBackend::possiblyFinish()
+{
+ if (hasEverythingFinished)
+ return;
+ hasEverythingFinished = true;
- if (!packet.data.isEmpty()) {
- writeDownstreamData(packet.data);
- readyReadEmitted = true;
- }
+ if ((operation() == QNetworkAccessManager::GetOperation) && hasDownloadFinished) {
+ socket.close();
+ finished();
+ } else if ((operation() == QNetworkAccessManager::PutOperation) && hasUploadFinished) {
+ socket.close();
+ finished();
+ }
- if (packet.headers.isEmpty() && packet.data.isEmpty()) {
- // it's an eof
- socket.close();
- readyReadEmitted = true;
- }
- } else {
- // got an error
- QString msg = QObject::tr("Read error reading from %1: %2")
- .arg(url().toString(), socket.errorString());
- error(QNetworkReply::ProtocolFailure, msg);
- finished();
- return;
- }
- }
}
-void QNetworkAccessDebugPipeBackend::socketBytesWritten(qint64)
+void QNetworkAccessDebugPipeBackend::closeDownstreamChannel()
{
- upstreamReadyRead();
+ qWarning() << "QNetworkAccessDebugPipeBackend::closeDownstreamChannel()" << operation();
+ //if (operation() == QNetworkAccessManager::GetOperation)
+ // socket.disconnectFromHost();
}
+
void QNetworkAccessDebugPipeBackend::socketError()
{
+ qWarning() << "QNetworkAccessDebugPipeBackend::socketError()" << socket.error();
QNetworkReply::NetworkError code;
switch (socket.error()) {
case QAbstractSocket::RemoteHostClosedError:
@@ -269,76 +257,27 @@ void QNetworkAccessDebugPipeBackend::socketError()
void QNetworkAccessDebugPipeBackend::socketDisconnected()
{
- socketReadyRead();
- if (incomingPacketSize == 0 && socket.bytesToWrite() == 0) {
+ pushFromSocketToDownstream();
+
+ if (socket.bytesToWrite() == 0) {
// normal close
- finished();
} else {
// abnormal close
QString msg = QObject::tr("Remote host closed the connection prematurely on %1")
.arg(url().toString());
error(QNetworkReply::RemoteHostClosedError, msg);
-
finished();
}
}
-bool QNetworkAccessDebugPipeBackend::send(const DataPacket &packet)
-{
- QByteArray ba;
- {
- QDataStream stream(&ba, QIODevice::WriteOnly);
- stream.setVersion(QDataStream::Qt_4_4);
-
- stream << packet.headers << packet.data;
- }
-
- qint32 outgoingPacketSize = ba.size();
- qint64 written = socket.write((const char*)&outgoingPacketSize, sizeof outgoingPacketSize);
- written += socket.write(ba);
- return quint64(written) == (outgoingPacketSize + sizeof outgoingPacketSize);
-}
-
-bool QNetworkAccessDebugPipeBackend::receive(DataPacket &packet)
+void QNetworkAccessDebugPipeBackend::socketConnected()
{
- if (!canReceive())
- return false;
-
- // canReceive() does the setting up for us
- Q_ASSERT(socket.bytesAvailable() >= incomingPacketSize);
- QByteArray incomingPacket = socket.read(incomingPacketSize);
- QDataStream stream(&incomingPacket, QIODevice::ReadOnly);
- stream.setVersion(QDataStream::Qt_4_4);
- stream >> packet.headers >> packet.data;
-
- // reset for next packet:
- incomingPacketSize = 0;
- socket.setReadBufferSize(ReadBufferSize);
- return true;
}
-bool QNetworkAccessDebugPipeBackend::canReceive()
+bool QNetworkAccessDebugPipeBackend::waitForDownstreamReadyRead(int ms)
{
- if (incomingPacketSize == 0) {
- // read the packet size
- if (quint64(socket.bytesAvailable()) >= sizeof incomingPacketSize)
- socket.read((char*)&incomingPacketSize, sizeof incomingPacketSize);
- else
- return false;
- }
-
- if (incomingPacketSize == 0) {
- QString msg = QObject::tr("Protocol error: packet of size 0 received");
- error(QNetworkReply::ProtocolFailure, msg);
- finished();
-
- socket.blockSignals(true);
- socket.abort();
- socket.blockSignals(false);
- return false;
- }
-
- return socket.bytesAvailable() >= incomingPacketSize;
+ qCritical("QNetworkAccess: Debug pipe backend does not support waitForReadyRead()");
+ return false;
}
#endif
diff --git a/src/network/access/qnetworkaccessdebugpipebackend_p.h b/src/network/access/qnetworkaccessdebugpipebackend_p.h
index 73a35cf..a13edc4 100644
--- a/src/network/access/qnetworkaccessdebugpipebackend_p.h
+++ b/src/network/access/qnetworkaccessdebugpipebackend_p.h
@@ -66,35 +66,38 @@ class QNetworkAccessDebugPipeBackend: public QNetworkAccessBackend
{
Q_OBJECT
public:
- struct DataPacket;
QNetworkAccessDebugPipeBackend();
virtual ~QNetworkAccessDebugPipeBackend();
virtual void open();
virtual void closeDownstreamChannel();
- virtual void closeUpstreamChannel();
virtual bool waitForDownstreamReadyRead(int msecs);
- virtual bool waitForUpstreamBytesWritten(int msecs);
- virtual void upstreamReadyRead();
virtual void downstreamReadyWrite();
+protected:
+ void pushFromSocketToDownstream();
+ void pushFromUpstreamToSocket();
+ void possiblyFinish();
+ QNonContiguousByteDevice *uploadByteDevice;
+
private slots:
+ void uploadReadyReadSlot();
void socketReadyRead();
void socketBytesWritten(qint64 bytes);
void socketError();
void socketDisconnected();
+ void socketConnected();
private:
QTcpSocket socket;
- qint32 incomingPacketSize;
- bool readyReadEmitted;
- bool bytesWrittenEmitted;
bool bareProtocol;
+ bool hasUploadFinished;
+ bool hasDownloadFinished;
+ bool hasEverythingFinished;
- bool send(const DataPacket &packet);
- bool canReceive();
- bool receive(DataPacket &packet);
+ qint64 bytesDownloaded;
+ qint64 bytesUploaded;
};
class QNetworkAccessDebugPipeBackendFactory: public QNetworkAccessBackendFactory
diff --git a/src/network/access/qnetworkaccessfilebackend.cpp b/src/network/access/qnetworkaccessfilebackend.cpp
index 8a5a665..6374fde 100644
--- a/src/network/access/qnetworkaccessfilebackend.cpp
+++ b/src/network/access/qnetworkaccessfilebackend.cpp
@@ -43,6 +43,7 @@
#include "qfileinfo.h"
#include "qurlinfo.h"
#include "qdir.h"
+#include "private/qnoncontiguousbytedevice_p.h"
#include <QtCore/QCoreApplication>
@@ -77,7 +78,7 @@ QNetworkAccessFileBackendFactory::create(QNetworkAccessManager::Operation op,
}
QNetworkAccessFileBackend::QNetworkAccessFileBackend()
- : totalBytes(0)
+ : uploadByteDevice(0), totalBytes(0), hasUploadFinished(false)
{
}
@@ -126,6 +127,9 @@ void QNetworkAccessFileBackend::open()
break;
case QNetworkAccessManager::PutOperation:
mode = QIODevice::WriteOnly | QIODevice::Truncate;
+ uploadByteDevice = createUploadByteDevice();
+ QObject::connect(uploadByteDevice, SIGNAL(readyRead()), this, SLOT(uploadReadyReadSlot()));
+ QMetaObject::invokeMethod(this, "uploadReadyReadSlot", Qt::QueuedConnection);
break;
default:
Q_ASSERT_X(false, "QNetworkAccessFileBackend::open",
@@ -152,19 +156,50 @@ void QNetworkAccessFileBackend::open()
}
}
-void QNetworkAccessFileBackend::closeDownstreamChannel()
+void QNetworkAccessFileBackend::uploadReadyReadSlot()
{
- if (operation() == QNetworkAccessManager::GetOperation) {
- file.close();
- //downstreamChannelClosed();
+ if (hasUploadFinished)
+ return;
+
+ forever {
+ qint64 haveRead;
+ const char *readPointer = uploadByteDevice->readPointer(-1, haveRead);
+ if (haveRead == -1) {
+ // EOF
+ hasUploadFinished = true;
+ file.flush();
+ file.close();
+ finished();
+ break;
+ } else if (haveRead == 0 || readPointer == 0) {
+ // nothing to read right now, we will be called again later
+ break;
+ } else {
+ qint64 haveWritten;
+ haveWritten = file.write(readPointer, haveRead);
+
+ if (haveWritten < 0) {
+ // write error!
+ QString msg = QCoreApplication::translate("QNetworkAccessFileBackend", "Write error writing to %1: %2")
+ .arg(url().toString(), file.errorString());
+ error(QNetworkReply::ProtocolFailure, msg);
+
+ finished();
+ return;
+ } else {
+ uploadByteDevice->advanceReadPointer(haveWritten);
+ }
+
+
+ file.flush();
+ }
}
}
-void QNetworkAccessFileBackend::closeUpstreamChannel()
+void QNetworkAccessFileBackend::closeDownstreamChannel()
{
- if (operation() == QNetworkAccessManager::PutOperation) {
+ if (operation() == QNetworkAccessManager::GetOperation) {
file.close();
- finished();
}
}
@@ -174,40 +209,6 @@ bool QNetworkAccessFileBackend::waitForDownstreamReadyRead(int)
return readMoreFromFile();
}
-bool QNetworkAccessFileBackend::waitForUpstreamBytesWritten(int)
-{
- Q_ASSERT_X(false, "QNetworkAccessFileBackend::waitForUpstreamBytesWritten",
- "This function should never have been called, since there is never anything "
- "left to be written!");
- return false;
-}
-
-void QNetworkAccessFileBackend::upstreamReadyRead()
-{
- Q_ASSERT_X(operation() == QNetworkAccessManager::PutOperation, "QNetworkAccessFileBackend",
- "We're being told to upload data but operation isn't PUT!");
-
- // there's more data to be written to the file
- while (upstreamBytesAvailable()) {
- // write everything and let QFile handle it
- int written = file.write(readUpstream());
-
- if (written < 0) {
- // write error!
- QString msg = QCoreApplication::translate("QNetworkAccessFileBackend", "Write error writing to %1: %2")
- .arg(url().toString(), file.errorString());
- error(QNetworkReply::ProtocolFailure, msg);
-
- finished();
- return;
- }
-
- // successful write
- file.flush();
- upstreamBytesConsumed(written);
- }
-}
-
void QNetworkAccessFileBackend::downstreamReadyWrite()
{
Q_ASSERT_X(operation() == QNetworkAccessManager::GetOperation, "QNetworkAccessFileBackend",
diff --git a/src/network/access/qnetworkaccessfilebackend_p.h b/src/network/access/qnetworkaccessfilebackend_p.h
index ce7d351..4615c5f 100644
--- a/src/network/access/qnetworkaccessfilebackend_p.h
+++ b/src/network/access/qnetworkaccessfilebackend_p.h
@@ -62,22 +62,25 @@ QT_BEGIN_NAMESPACE
class QNetworkAccessFileBackend: public QNetworkAccessBackend
{
+ Q_OBJECT
public:
QNetworkAccessFileBackend();
virtual ~QNetworkAccessFileBackend();
virtual void open();
virtual void closeDownstreamChannel();
- virtual void closeUpstreamChannel();
virtual bool waitForDownstreamReadyRead(int msecs);
- virtual bool waitForUpstreamBytesWritten(int msecs);
- virtual void upstreamReadyRead();
virtual void downstreamReadyWrite();
+public slots:
+ void uploadReadyReadSlot();
+protected:
+ QNonContiguousByteDevice *uploadByteDevice;
private:
QFile file;
qint64 totalBytes;
+ bool hasUploadFinished;
bool loadFileInfo();
bool readMoreFromFile();
diff --git a/src/network/access/qnetworkaccessftpbackend.cpp b/src/network/access/qnetworkaccessftpbackend.cpp
index ea39dec..ad55b85 100644
--- a/src/network/access/qnetworkaccessftpbackend.cpp
+++ b/src/network/access/qnetworkaccessftpbackend.cpp
@@ -42,6 +42,7 @@
#include "qnetworkaccessftpbackend_p.h"
#include "qnetworkaccessmanager_p.h"
#include "QtNetwork/qauthenticator.h"
+#include "private/qnoncontiguousbytedevice_p.h"
#ifndef QT_NO_FTP
@@ -81,41 +82,6 @@ QNetworkAccessFtpBackendFactory::create(QNetworkAccessManager::Operation op,
return 0;
}
-class QNetworkAccessFtpIODevice: public QIODevice
-{
- //Q_OBJECT
-public:
- QNetworkAccessFtpBackend *backend;
- bool eof;
-
- inline QNetworkAccessFtpIODevice(QNetworkAccessFtpBackend *parent)
- : QIODevice(parent), backend(parent), eof(false)
- { open(ReadOnly); }
-
- bool isSequential() const { return true; }
- bool atEnd() const { return backend->upstreamBytesAvailable() == 0; }
-
- qint64 bytesAvailable() const { return backend->upstreamBytesAvailable(); }
- qint64 bytesToWrite() const { return backend->downstreamBytesToConsume(); }
-protected:
- qint64 readData(char *data, qint64 maxlen)
- {
- const QByteArray toSend = backend->readUpstream();
- maxlen = qMin<qint64>(maxlen, toSend.size());
- if (!maxlen)
- return eof ? -1 : 0;
-
- backend->upstreamBytesConsumed(maxlen);
- memcpy(data, toSend.constData(), maxlen);
- return maxlen;
- }
-
- qint64 writeData(const char *, qint64)
- { return -1; }
-
- friend class QNetworkAccessFtpBackend;
-};
-
class QNetworkAccessFtpFtp: public QFtp, public QNetworkAccessCache::CacheableObject
{
// Q_OBJECT
@@ -198,7 +164,11 @@ void QNetworkAccessFtpBackend::open()
ftpConnectionReady(ftp);
}
- uploadDevice = new QNetworkAccessFtpIODevice(this);
+ // Put operation
+ if (operation() == QNetworkAccessManager::PutOperation) {
+ uploadDevice = QNonContiguousByteDeviceFactory::wrap(createUploadByteDevice());
+ uploadDevice->setParent(this);
+ }
}
void QNetworkAccessFtpBackend::closeDownstreamChannel()
@@ -212,16 +182,6 @@ void QNetworkAccessFtpBackend::closeDownstreamChannel()
#endif
}
-void QNetworkAccessFtpBackend::closeUpstreamChannel()
-{
- if (operation() == QNetworkAccessManager::PutOperation) {
- Q_ASSERT(uploadDevice);
- uploadDevice->eof = true;
- if (!upstreamBytesAvailable())
- emit uploadDevice->readyRead();
- }
-}
-
bool QNetworkAccessFtpBackend::waitForDownstreamReadyRead(int ms)
{
if (!ftp)
@@ -239,18 +199,6 @@ bool QNetworkAccessFtpBackend::waitForDownstreamReadyRead(int ms)
return false;
}
-bool QNetworkAccessFtpBackend::waitForUpstreamBytesWritten(int ms)
-{
- Q_UNUSED(ms);
- qCritical("QNetworkAccess: FTP backend does not support waitForBytesWritten()");
- return false;
-}
-
-void QNetworkAccessFtpBackend::upstreamReadyRead()
-{
- // uh... how does QFtp operate?
-}
-
void QNetworkAccessFtpBackend::downstreamReadyWrite()
{
if (state == Transferring && ftp && ftp->bytesAvailable())
diff --git a/src/network/access/qnetworkaccessftpbackend_p.h b/src/network/access/qnetworkaccessftpbackend_p.h
index 9ec2dd8..1bb7ff2 100644
--- a/src/network/access/qnetworkaccessftpbackend_p.h
+++ b/src/network/access/qnetworkaccessftpbackend_p.h
@@ -87,11 +87,8 @@ public:
virtual void open();
virtual void closeDownstreamChannel();
- virtual void closeUpstreamChannel();
virtual bool waitForDownstreamReadyRead(int msecs);
- virtual bool waitForUpstreamBytesWritten(int msecs);
- virtual void upstreamReadyRead();
virtual void downstreamReadyWrite();
void disconnectFromFtp();
@@ -105,7 +102,7 @@ public slots:
private:
friend class QNetworkAccessFtpIODevice;
QPointer<QNetworkAccessFtpFtp> ftp;
- QNetworkAccessFtpIODevice *uploadDevice;
+ QIODevice *uploadDevice;
qint64 totalBytes;
int helpId, sizeId, mdtmId;
bool supportsSize, supportsMdtm;
diff --git a/src/network/access/qnetworkaccesshttpbackend.cpp b/src/network/access/qnetworkaccesshttpbackend.cpp
index a52b5a0..7d0438e 100644
--- a/src/network/access/qnetworkaccesshttpbackend.cpp
+++ b/src/network/access/qnetworkaccesshttpbackend.cpp
@@ -286,37 +286,6 @@ public:
}
};
-class QNetworkAccessHttpBackendIODevice: public QIODevice
-{
- // Q_OBJECT
-public:
- bool eof;
- QNetworkAccessHttpBackendIODevice(QNetworkAccessHttpBackend *parent)
- : QIODevice(parent), eof(false)
- {
- setOpenMode(ReadOnly);
- }
- bool isSequential() const { return true; }
- qint64 bytesAvailable() const
- { return static_cast<QNetworkAccessHttpBackend *>(parent())->upstreamBytesAvailable(); }
-
-protected:
- virtual qint64 readData(char *buffer, qint64 maxlen)
- {
- qint64 ret = static_cast<QNetworkAccessHttpBackend *>(parent())->deviceReadData(buffer, maxlen);
- if (!ret && eof)
- return -1;
- return ret;
- }
-
- virtual qint64 writeData(const char *, qint64)
- {
- return -1; // cannot write
- }
-
- friend class QNetworkAccessHttpBackend;
-};
-
QNetworkAccessHttpBackend::QNetworkAccessHttpBackend()
: QNetworkAccessBackend(), httpReply(0), http(0), uploadDevice(0)
#ifndef QT_NO_OPENSSL
@@ -507,20 +476,19 @@ void QNetworkAccessHttpBackend::postRequest()
case QNetworkAccessManager::PostOperation:
invalidateCache();
httpRequest.setOperation(QHttpNetworkRequest::Post);
- uploadDevice = new QNetworkAccessHttpBackendIODevice(this);
+ httpRequest.setUploadByteDevice(createUploadByteDevice());
break;
case QNetworkAccessManager::PutOperation:
invalidateCache();
httpRequest.setOperation(QHttpNetworkRequest::Put);
- uploadDevice = new QNetworkAccessHttpBackendIODevice(this);
+ httpRequest.setUploadByteDevice(createUploadByteDevice());
break;
default:
break; // can't happen
}
- httpRequest.setData(uploadDevice);
httpRequest.setUrl(url());
QList<QByteArray> headers = request().rawHeaderList();
@@ -528,7 +496,9 @@ void QNetworkAccessHttpBackend::postRequest()
httpRequest.setHeaderField(header, request().rawHeader(header));
if (loadedFromCache) {
- QNetworkAccessBackend::finished();
+ // commented this out since it will be called later anyway
+ // by copyFinished()
+ //QNetworkAccessBackend::finished();
return; // no need to send the request! :)
}
@@ -624,14 +594,6 @@ void QNetworkAccessHttpBackend::closeDownstreamChannel()
// this indicates that the user closed the stream while the reply isn't finished yet
}
-void QNetworkAccessHttpBackend::closeUpstreamChannel()
-{
- // this indicates that the user finished uploading the data for POST
- Q_ASSERT(uploadDevice);
- uploadDevice->eof = true;
- emit uploadDevice->readChannelFinished();
-}
-
bool QNetworkAccessHttpBackend::waitForDownstreamReadyRead(int msecs)
{
Q_ASSERT(http);
@@ -651,38 +613,6 @@ bool QNetworkAccessHttpBackend::waitForDownstreamReadyRead(int msecs)
return false;
}
-bool QNetworkAccessHttpBackend::waitForUpstreamBytesWritten(int msecs)
-{
-
- // ### FIXME: not implemented in QHttpNetworkAccess
- Q_UNUSED(msecs);
- qCritical("QNetworkAccess: HTTP backend does not support waitForBytesWritten()");
- return false;
-}
-
-void QNetworkAccessHttpBackend::upstreamReadyRead()
-{
- // There is more data available from the user to be uploaded
- // QHttpNetworkAccess implements the upload rate control:
- // we simply tell QHttpNetworkAccess that there is more data available
- // it'll pull from us when it can (through uploadDevice)
-
- Q_ASSERT(uploadDevice);
- emit uploadDevice->readyRead();
-}
-
-qint64 QNetworkAccessHttpBackend::deviceReadData(char *buffer, qint64 maxlen)
-{
- QByteArray toBeUploaded = readUpstream();
- if (toBeUploaded.isEmpty())
- return 0; // nothing to be uploaded
-
- maxlen = qMin<qint64>(maxlen, toBeUploaded.length());
-
- memcpy(buffer, toBeUploaded.constData(), maxlen);
- upstreamBytesConsumed(maxlen);
- return maxlen;
-}
void QNetworkAccessHttpBackend::downstreamReadyWrite()
{
@@ -904,7 +834,14 @@ bool QNetworkAccessHttpBackend::sendCacheContents(const QNetworkCacheMetaData &m
checkForRedirect(status);
- writeDownstreamData(contents);
+ emit metaDataChanged();
+
+ // invoke this asynchronously, else Arora/QtDemoBrowser don't like cached downloads
+ // see task 250221 / 251801
+ qRegisterMetaType<QIODevice*>("QIODevice*");
+ QMetaObject::invokeMethod(this, "writeDownstreamData", Qt::QueuedConnection, Q_ARG(QIODevice*, contents));
+
+
#if defined(QNETWORKACCESSHTTPBACKEND_DEBUG)
qDebug() << "Successfully sent cache:" << url() << contents->size() << "bytes";
#endif
diff --git a/src/network/access/qnetworkaccesshttpbackend_p.h b/src/network/access/qnetworkaccesshttpbackend_p.h
index 02915e7..225f944 100644
--- a/src/network/access/qnetworkaccesshttpbackend_p.h
+++ b/src/network/access/qnetworkaccesshttpbackend_p.h
@@ -79,11 +79,8 @@ public:
virtual void open();
virtual void closeDownstreamChannel();
- virtual void closeUpstreamChannel();
virtual bool waitForDownstreamReadyRead(int msecs);
- virtual bool waitForUpstreamBytesWritten(int msecs);
- virtual void upstreamReadyRead();
virtual void downstreamReadyWrite();
virtual void copyFinished(QIODevice *);
#ifndef QT_NO_OPENSSL
@@ -96,6 +93,9 @@ public:
qint64 deviceReadData(char *buffer, qint64 maxlen);
+ // we return true since HTTP needs to send PUT/POST data again after having authenticated
+ bool needsResetableUploadData() {return true;};
+
private slots:
void replyReadyRead();
void replyFinished();
@@ -108,7 +108,8 @@ private:
QHttpNetworkReply *httpReply;
QPointer<QNetworkAccessHttpBackendCache> http;
QByteArray cacheKey;
- QNetworkAccessHttpBackendIODevice *uploadDevice;
+ QNetworkAccessBackendUploadIODevice *uploadDevice;
+
#ifndef QT_NO_OPENSSL
QSslConfiguration *pendingSslConfiguration;
bool pendingIgnoreSslErrors;
@@ -122,8 +123,6 @@ private:
void postRequest();
void readFromHttp();
void checkForRedirect(const int statusCode);
-
- friend class QNetworkAccessHttpBackendIODevice;
};
class QNetworkAccessHttpBackendFactory : public QNetworkAccessBackendFactory
generated by cgit v0.12 at 2024-11-29 07:00:14 (GMT)