QNetworkReplyHandler.cpp [plain text]
#include "config.h"
#include "QNetworkReplyHandler.h"
#include "HTTPParsers.h"
#include "MIMETypeRegistry.h"
#include "ResourceHandle.h"
#include "ResourceHandleClient.h"
#include "ResourceHandleInternal.h"
#include "ResourceResponse.h"
#include "ResourceRequest.h"
#include <QDateTime>
#include <QFile>
#include <QFileInfo>
#include <QNetworkReply>
#include <QNetworkCookie>
#include <wtf/text/CString.h>
#include <QDebug>
#include <QCoreApplication>
const QNetworkRequest::Attribute gSynchronousNetworkRequestAttribute = static_cast<QNetworkRequest::Attribute>(QNetworkRequest::HttpPipeliningWasUsedAttribute + 7);
static const int gMaxRedirections = 10;
namespace WebCore {
FormDataIODevice::FormDataIODevice(FormData* data)
: m_formElements(data ? data->elements() : Vector<FormDataElement>())
, m_currentFile(0)
, m_currentDelta(0)
, m_fileSize(0)
, m_dataSize(0)
{
setOpenMode(FormDataIODevice::ReadOnly);
if (!m_formElements.isEmpty() && m_formElements[0].m_type == FormDataElement::encodedFile)
openFileForCurrentElement();
computeSize();
}
FormDataIODevice::~FormDataIODevice()
{
delete m_currentFile;
}
qint64 FormDataIODevice::computeSize()
{
for (int i = 0; i < m_formElements.size(); ++i) {
const FormDataElement& element = m_formElements[i];
if (element.m_type == FormDataElement::data)
m_dataSize += element.m_data.size();
else {
QFileInfo fi(element.m_filename);
m_fileSize += fi.size();
}
}
return m_dataSize + m_fileSize;
}
void FormDataIODevice::moveToNextElement()
{
if (m_currentFile)
m_currentFile->close();
m_currentDelta = 0;
m_formElements.remove(0);
if (m_formElements.isEmpty() || m_formElements[0].m_type == FormDataElement::data)
return;
openFileForCurrentElement();
}
void FormDataIODevice::openFileForCurrentElement()
{
if (!m_currentFile)
m_currentFile = new QFile;
m_currentFile->setFileName(m_formElements[0].m_filename);
m_currentFile->open(QFile::ReadOnly);
}
qint64 FormDataIODevice::readData(char* destination, qint64 size)
{
if (m_formElements.isEmpty())
return -1;
qint64 copied = 0;
while (copied < size && !m_formElements.isEmpty()) {
const FormDataElement& element = m_formElements[0];
const qint64 available = size-copied;
if (element.m_type == FormDataElement::data) {
const qint64 toCopy = qMin<qint64>(available, element.m_data.size() - m_currentDelta);
memcpy(destination+copied, element.m_data.data()+m_currentDelta, toCopy);
m_currentDelta += toCopy;
copied += toCopy;
if (m_currentDelta == element.m_data.size())
moveToNextElement();
} else {
const QByteArray data = m_currentFile->read(available);
memcpy(destination+copied, data.constData(), data.size());
copied += data.size();
if (m_currentFile->atEnd() || !m_currentFile->isOpen())
moveToNextElement();
}
}
return copied;
}
qint64 FormDataIODevice::writeData(const char*, qint64)
{
return -1;
}
bool FormDataIODevice::isSequential() const
{
return true;
}
QNetworkReplyHandlerCallQueue::QNetworkReplyHandlerCallQueue(QNetworkReplyHandler* handler, bool deferSignals)
: m_replyHandler(handler)
, m_locks(0)
, m_deferSignals(deferSignals)
, m_flushing(false)
{
Q_ASSERT(handler);
}
void QNetworkReplyHandlerCallQueue::push(EnqueuedCall method)
{
m_enqueuedCalls.append(method);
flush();
}
void QNetworkReplyHandlerCallQueue::lock()
{
++m_locks;
}
void QNetworkReplyHandlerCallQueue::unlock()
{
if (!m_locks)
return;
--m_locks;
flush();
}
void QNetworkReplyHandlerCallQueue::setDeferSignals(bool defer, bool sync)
{
m_deferSignals = defer;
if (sync)
flush();
else
QMetaObject::invokeMethod(this, "flush", Qt::QueuedConnection);
}
void QNetworkReplyHandlerCallQueue::flush()
{
if (m_flushing)
return;
m_flushing = true;
while (!m_deferSignals && !m_locks && !m_enqueuedCalls.isEmpty())
(m_replyHandler->*(m_enqueuedCalls.takeFirst()))();
m_flushing = false;
}
class QueueLocker {
public:
QueueLocker(QNetworkReplyHandlerCallQueue* queue) : m_queue(queue) { m_queue->lock(); }
~QueueLocker() { m_queue->unlock(); }
private:
QNetworkReplyHandlerCallQueue* m_queue;
};
QNetworkReplyWrapper::QNetworkReplyWrapper(QNetworkReplyHandlerCallQueue* queue, QNetworkReply* reply, bool sniffMIMETypes, QObject* parent)
: QObject(parent)
, m_reply(reply)
, m_queue(queue)
, m_responseContainsData(false)
, m_sniffMIMETypes(sniffMIMETypes)
{
Q_ASSERT(m_reply);
connect(m_reply, SIGNAL(finished()), this, SLOT(setFinished()));
connect(m_reply, SIGNAL(finished()), this, SLOT(receiveMetaData()));
connect(m_reply, SIGNAL(readyRead()), this, SLOT(receiveMetaData()));
}
QNetworkReplyWrapper::~QNetworkReplyWrapper()
{
if (m_reply)
m_reply->deleteLater();
m_queue->clear();
}
QNetworkReply* QNetworkReplyWrapper::release()
{
if (!m_reply)
return 0;
resetConnections();
QNetworkReply* reply = m_reply;
m_reply = 0;
m_sniffer = nullptr;
reply->setParent(0);
return reply;
}
void QNetworkReplyWrapper::synchronousLoad()
{
setFinished();
receiveMetaData();
}
void QNetworkReplyWrapper::resetConnections()
{
if (m_reply) {
m_reply->disconnect(this, SLOT(receiveMetaData()));
m_reply->disconnect(this, SLOT(didReceiveFinished()));
m_reply->disconnect(this, SLOT(didReceiveReadyRead()));
}
QCoreApplication::removePostedEvents(this, QEvent::MetaCall);
}
void QNetworkReplyWrapper::receiveMetaData()
{
resetConnections();
WTF::String contentType = m_reply->header(QNetworkRequest::ContentTypeHeader).toString();
m_encoding = extractCharsetFromMediaType(contentType);
m_advertisedMIMEType = extractMIMETypeFromMediaType(contentType);
m_redirectionTargetUrl = m_reply->attribute(QNetworkRequest::RedirectionTargetAttribute).toUrl();
if (m_redirectionTargetUrl.isValid()) {
QueueLocker lock(m_queue);
m_queue->push(&QNetworkReplyHandler::sendResponseIfNeeded);
m_queue->push(&QNetworkReplyHandler::finish);
return;
}
if (!m_sniffMIMETypes) {
emitMetaDataChanged();
return;
}
bool isSupportedImageType = MIMETypeRegistry::isSupportedImageMIMEType(m_advertisedMIMEType);
Q_ASSERT(!m_sniffer);
m_sniffer = adoptPtr(new QtMIMETypeSniffer(m_reply, m_advertisedMIMEType, isSupportedImageType));
if (m_sniffer->isFinished()) {
receiveSniffedMIMEType();
return;
}
connect(m_sniffer.get(), SIGNAL(finished()), this, SLOT(receiveSniffedMIMEType()));
}
void QNetworkReplyWrapper::receiveSniffedMIMEType()
{
Q_ASSERT(m_sniffer);
m_sniffedMIMEType = m_sniffer->mimeType();
m_sniffer = nullptr;
emitMetaDataChanged();
}
void QNetworkReplyWrapper::setFinished()
{
Q_ASSERT(!isFinished());
m_reply->setProperty("_q_isFinished", true);
}
void QNetworkReplyWrapper::emitMetaDataChanged()
{
QueueLocker lock(m_queue);
m_queue->push(&QNetworkReplyHandler::sendResponseIfNeeded);
if (m_reply->bytesAvailable()) {
m_responseContainsData = true;
m_queue->push(&QNetworkReplyHandler::forwardData);
}
if (isFinished()) {
m_queue->push(&QNetworkReplyHandler::finish);
return;
}
connect(m_reply, SIGNAL(readyRead()), this, SLOT(didReceiveReadyRead()));
connect(m_reply, SIGNAL(finished()), this, SLOT(didReceiveFinished()));
}
void QNetworkReplyWrapper::didReceiveReadyRead()
{
if (m_reply->bytesAvailable())
m_responseContainsData = true;
m_queue->push(&QNetworkReplyHandler::forwardData);
}
void QNetworkReplyWrapper::didReceiveFinished()
{
resetConnections();
m_queue->push(&QNetworkReplyHandler::finish);
}
String QNetworkReplyHandler::httpMethod() const
{
switch (m_method) {
case QNetworkAccessManager::GetOperation:
return "GET";
case QNetworkAccessManager::HeadOperation:
return "HEAD";
case QNetworkAccessManager::PostOperation:
return "POST";
case QNetworkAccessManager::PutOperation:
return "PUT";
case QNetworkAccessManager::DeleteOperation:
return "DELETE";
case QNetworkAccessManager::CustomOperation:
return m_resourceHandle->firstRequest().httpMethod();
default:
ASSERT_NOT_REACHED();
return "GET";
}
}
QNetworkReplyHandler::QNetworkReplyHandler(ResourceHandle* handle, LoadType loadType, bool deferred)
: QObject(0)
, m_resourceHandle(handle)
, m_loadType(loadType)
, m_redirectionTries(gMaxRedirections)
, m_queue(this, deferred)
{
const ResourceRequest &r = m_resourceHandle->firstRequest();
if (r.httpMethod() == "GET")
m_method = QNetworkAccessManager::GetOperation;
else if (r.httpMethod() == "HEAD")
m_method = QNetworkAccessManager::HeadOperation;
else if (r.httpMethod() == "POST")
m_method = QNetworkAccessManager::PostOperation;
else if (r.httpMethod() == "PUT")
m_method = QNetworkAccessManager::PutOperation;
else if (r.httpMethod() == "DELETE")
m_method = QNetworkAccessManager::DeleteOperation;
else
m_method = QNetworkAccessManager::CustomOperation;
m_request = r.toNetworkRequest(m_resourceHandle->getInternal()->m_context.get());
m_queue.push(&QNetworkReplyHandler::start);
}
void QNetworkReplyHandler::abort()
{
m_resourceHandle = 0;
if (QNetworkReply* reply = release()) {
reply->abort();
reply->deleteLater();
}
deleteLater();
}
QNetworkReply* QNetworkReplyHandler::release()
{
if (!m_replyWrapper)
return 0;
QNetworkReply* reply = m_replyWrapper->release();
m_replyWrapper = nullptr;
return reply;
}
static bool shouldIgnoreHttpError(QNetworkReply* reply, bool receivedData)
{
int httpStatusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
if (httpStatusCode == 401 || httpStatusCode == 407)
return true;
if (receivedData && (httpStatusCode >= 400 && httpStatusCode < 600))
return true;
return false;
}
void QNetworkReplyHandler::finish()
{
ASSERT(m_replyWrapper && m_replyWrapper->reply() && !wasAborted());
ResourceHandleClient* client = m_resourceHandle->client();
if (!client) {
m_replyWrapper = nullptr;
return;
}
if (m_replyWrapper->wasRedirected()) {
m_replyWrapper = nullptr;
m_queue.push(&QNetworkReplyHandler::start);
return;
}
if (!m_replyWrapper->reply()->error() || shouldIgnoreHttpError(m_replyWrapper->reply(), m_replyWrapper->responseContainsData()))
client->didFinishLoading(m_resourceHandle, 0);
else
client->didFail(m_resourceHandle, errorForReply(m_replyWrapper->reply()));
m_replyWrapper = nullptr;
}
void QNetworkReplyHandler::sendResponseIfNeeded()
{
ASSERT(m_replyWrapper && m_replyWrapper->reply() && !wasAborted());
if (m_replyWrapper->reply()->error() && m_replyWrapper->reply()->attribute(QNetworkRequest::HttpStatusCodeAttribute).isNull())
return;
ResourceHandleClient* client = m_resourceHandle->client();
if (!client)
return;
WTF::String mimeType = m_replyWrapper->mimeType();
if (mimeType.isEmpty()) {
mimeType = MIMETypeRegistry::getMIMETypeForPath(m_replyWrapper->reply()->url().path());
}
KURL url(m_replyWrapper->reply()->url());
ResourceResponse response(url, mimeType.lower(),
m_replyWrapper->reply()->header(QNetworkRequest::ContentLengthHeader).toLongLong(),
m_replyWrapper->encoding(), String());
if (url.isLocalFile()) {
client->didReceiveResponse(m_resourceHandle, response);
return;
}
int statusCode = m_replyWrapper->reply()->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
if (url.protocolIsInHTTPFamily()) {
String suggestedFilename = filenameFromHTTPContentDisposition(QString::fromLatin1(m_replyWrapper->reply()->rawHeader("Content-Disposition")));
if (!suggestedFilename.isEmpty())
response.setSuggestedFilename(suggestedFilename);
else
response.setSuggestedFilename(url.lastPathComponent());
response.setHTTPStatusCode(statusCode);
response.setHTTPStatusText(m_replyWrapper->reply()->attribute(QNetworkRequest::HttpReasonPhraseAttribute).toByteArray().constData());
foreach (const QNetworkReply::RawHeaderPair& pair, m_replyWrapper->reply()->rawHeaderPairs())
response.setHTTPHeaderField(QString::fromLatin1(pair.first), QString::fromLatin1(pair.second));
}
QUrl redirection = m_replyWrapper->reply()->attribute(QNetworkRequest::RedirectionTargetAttribute).toUrl();
if (redirection.isValid()) {
redirect(response, redirection);
return;
}
client->didReceiveResponse(m_resourceHandle, response);
}
void QNetworkReplyHandler::redirect(ResourceResponse& response, const QUrl& redirection)
{
QUrl newUrl = m_replyWrapper->reply()->url().resolved(redirection);
ResourceHandleClient* client = m_resourceHandle->client();
ASSERT(client);
int statusCode = m_replyWrapper->reply()->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
m_redirectionTries--;
if (!m_redirectionTries) {
ResourceError error("HTTP", 400 ,
newUrl.toString(),
QCoreApplication::translate("QWebPage", "Redirection limit reached"));
client->didFail(m_resourceHandle, error);
m_replyWrapper = nullptr;
return;
}
if ((statusCode >= 301 && statusCode <= 303) && m_resourceHandle->firstRequest().httpMethod() == "POST")
m_method = QNetworkAccessManager::GetOperation;
ResourceRequest newRequest = m_resourceHandle->firstRequest();
newRequest.setHTTPMethod(httpMethod());
newRequest.setURL(newUrl);
if (!newRequest.url().protocolIs("https") && protocolIs(newRequest.httpReferrer(), "https"))
newRequest.clearHTTPReferrer();
client->willSendRequest(m_resourceHandle, newRequest, response);
if (wasAborted()) return;
m_request = newRequest.toNetworkRequest(m_resourceHandle->getInternal()->m_context.get());
}
void QNetworkReplyHandler::forwardData()
{
ASSERT(m_replyWrapper && m_replyWrapper->reply() && !wasAborted() && !m_replyWrapper->wasRedirected());
QByteArray data = m_replyWrapper->reply()->read(m_replyWrapper->reply()->bytesAvailable());
ResourceHandleClient* client = m_resourceHandle->client();
if (!client)
return;
if (!data.isEmpty())
client->didReceiveData(m_resourceHandle, data.constData(), data.length(), -1);
}
void QNetworkReplyHandler::uploadProgress(qint64 bytesSent, qint64 bytesTotal)
{
if (wasAborted())
return;
ResourceHandleClient* client = m_resourceHandle->client();
if (!client)
return;
client->didSendData(m_resourceHandle, bytesSent, bytesTotal);
}
void QNetworkReplyHandler::clearContentHeaders()
{
m_request.setHeader(QNetworkRequest::ContentTypeHeader, QVariant());
m_request.setHeader(QNetworkRequest::ContentLengthHeader, QVariant());
}
FormDataIODevice* QNetworkReplyHandler::getIODevice(const ResourceRequest& request)
{
FormDataIODevice* device = new FormDataIODevice(request.httpBody());
m_request.setHeader(QNetworkRequest::ContentLengthHeader, device->getFormDataSize());
m_request.setAttribute(QNetworkRequest::DoNotBufferUploadDataAttribute, QVariant(true));
return device;
}
QNetworkReply* QNetworkReplyHandler::sendNetworkRequest(QNetworkAccessManager* manager, const ResourceRequest& request)
{
if (m_loadType == SynchronousLoad)
m_request.setAttribute(gSynchronousNetworkRequestAttribute, true);
if (!manager)
return 0;
const QUrl url = m_request.url();
if (m_method == QNetworkAccessManager::PostOperation
&& (!url.toLocalFile().isEmpty() || url.scheme() == QLatin1String("data")))
m_method = QNetworkAccessManager::GetOperation;
switch (m_method) {
case QNetworkAccessManager::GetOperation:
clearContentHeaders();
return manager->get(m_request);
case QNetworkAccessManager::PostOperation: {
FormDataIODevice* postDevice = getIODevice(request);
QNetworkReply* result = manager->post(m_request, postDevice);
postDevice->setParent(result);
return result;
}
case QNetworkAccessManager::HeadOperation:
clearContentHeaders();
return manager->head(m_request);
case QNetworkAccessManager::PutOperation: {
FormDataIODevice* putDevice = getIODevice(request);
QNetworkReply* result = manager->put(m_request, putDevice);
putDevice->setParent(result);
return result;
}
case QNetworkAccessManager::DeleteOperation: {
clearContentHeaders();
return manager->deleteResource(m_request);
}
case QNetworkAccessManager::CustomOperation: {
FormDataIODevice* customDevice = getIODevice(request);
QNetworkReply* result = manager->sendCustomRequest(m_request, m_resourceHandle->firstRequest().httpMethod().latin1().data(), customDevice);
customDevice->setParent(result);
return result;
}
case QNetworkAccessManager::UnknownOperation:
ASSERT_NOT_REACHED();
return 0;
}
return 0;
}
void QNetworkReplyHandler::start()
{
ResourceHandleInternal* d = m_resourceHandle->getInternal();
if (!d || !d->m_context)
return;
QNetworkReply* reply = sendNetworkRequest(d->m_context->networkAccessManager(), d->m_firstRequest);
if (!reply)
return;
m_replyWrapper = adoptPtr(new QNetworkReplyWrapper(&m_queue, reply, m_resourceHandle->shouldContentSniff() && d->m_context->mimeSniffingEnabled(), this));
if (m_loadType == SynchronousLoad) {
m_replyWrapper->synchronousLoad();
return;
}
if (m_resourceHandle->firstRequest().reportUploadProgress())
connect(m_replyWrapper->reply(), SIGNAL(uploadProgress(qint64, qint64)), this, SLOT(uploadProgress(qint64, qint64)));
}
ResourceError QNetworkReplyHandler::errorForReply(QNetworkReply* reply)
{
QUrl url = reply->url();
int httpStatusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
if (httpStatusCode)
return ResourceError("HTTP", httpStatusCode, url.toString(), reply->attribute(QNetworkRequest::HttpReasonPhraseAttribute).toString());
return ResourceError("QtNetwork", reply->error(), url.toString(), reply->errorString());
}
}
#include "moc_QNetworkReplyHandler.cpp"