FCL/sf/mw/qt: comparison src/network/access/qhttpnetworkreply.cpp

equal deleted inserted replaced

-:41300fa6a67c
+:f7bc934e204c
 /****************************************************************************
 **
-** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtNetwork module of the Qt Toolkit.
 **
 }
 QByteArray QHttpNetworkReply::readAny()
 {
 Q_D(QHttpNetworkReply);
+// we'll take the last buffer, so schedule another read from http
+if (d->downstreamLimited && d->responseData.bufferCount() == 1)
+d->connection->d_func()->readMoreLater(this);
 return d->responseData.read();
+}
+void QHttpNetworkReply::setDownstreamLimited(bool dsl)
+{
+Q_D(QHttpNetworkReply);
+d->downstreamLimited = dsl;
+d->connection->d_func()->readMoreLater(this);
 }
 bool QHttpNetworkReply::isFinished() const
 {
 return d_func()->state == QHttpNetworkReplyPrivate::AllDoneState;
 chunkedTransferEncoding(false),
 connectionCloseEnabled(true),
 forceConnectionCloseEnabled(false),
 currentChunkSize(0), currentChunkRead(0), connection(0), initInflate(false),
 autoDecompress(false), responseData(), requestIsPrepared(false)
-,pipeliningUsed(false)
+,pipeliningUsed(false), downstreamLimited(false)
 {
 }
 QHttpNetworkReplyPrivate::~QHttpNetworkReplyPrivate()
 {
 }
-void QHttpNetworkReplyPrivate::clear()
+void QHttpNetworkReplyPrivate::clearHttpLayerInformation()
 {
 state = NothingDoneState;
 statusCode = 100;
 bodyLength = 0;
 contentRead = 0;
 totalProgress = 0;
 currentChunkSize = 0;
 currentChunkRead = 0;
 connectionCloseEnabled = true;
-connection = 0;
 #ifndef QT_NO_COMPRESS
 if (initInflate)
 inflateEnd(&inflateStrm);
 #endif
 initInflate = false;
 streamEnd = false;
+fields.clear();
+}
+// TODO: Isn't everything HTTP layer related? We don't need to set connection and connectionChannel to 0 at all
+void QHttpNetworkReplyPrivate::clear()
+{
+connection = 0;
+connectionChannel = 0;
 autoDecompress = false;
-fields.clear();
+clearHttpLayerInformation();
 }
 // QHttpNetworkReplyPrivate
 qint64 QHttpNetworkReplyPrivate::bytesAvailable() const
 {
 }
 #endif
 qint64 QHttpNetworkReplyPrivate::readStatus(QAbstractSocket *socket)
 {
+if (fragment.isEmpty()) {
+// reserve bytes for the status line. This is better than always append() which reallocs the byte array
+fragment.reserve(32);
+}
 qint64 bytes = 0;
 char c;
+qint64 haveRead = 0;
-while (socket->bytesAvailable()) {
+do {
+haveRead = socket->read(&c, 1);
+if (haveRead == -1)
+return -1; // unexpected EOF
+else if (haveRead == 0)
+break; // read more later
+bytes++;
 // allow both CRLF & LF (only) line endings
-if (socket->peek(&c, 1) == 1 && c == '\n') {
+if (c == '\n') {
-bytes += socket->read(&c, 1); // read the "n"
 // remove the CR at the end
 if (fragment.endsWith('\r')) {
 fragment.truncate(fragment.length()-1);
 }
 bool ok = parseStatus(fragment);
 if (!ok) {
 return -1;
 }
 break;
 } else {
-c = 0;
-int haveRead = socket->read(&c, 1);
-if (haveRead == -1)
-return -1;
-bytes += haveRead;
 fragment.append(c);
 }
 // is this a valid reply?
 if (fragment.length() >= 5 && !fragment.startsWith("HTTP/"))
 {
 fragment.clear();
 return -1;
 }
+} while (haveRead == 1);
-}
 return bytes;
 }
 bool QHttpNetworkReplyPrivate::parseStatus(const QByteArray &status)
 return ok && uint(majorVersion) <= 9 && uint(minorVersion) <= 9;
 }
 qint64 QHttpNetworkReplyPrivate::readHeader(QAbstractSocket *socket)
 {
+if (fragment.isEmpty()) {
+// according to http://dev.opera.com/articles/view/mama-http-headers/ the average size of the header
+// block is 381 bytes.
+// reserve bytes. This is better than always append() which reallocs the byte array.
+fragment.reserve(512);
+}
 qint64 bytes = 0;
 char c = 0;
 bool allHeaders = false;
-while (!allHeaders && socket->bytesAvailable()) {
+qint64 haveRead = 0;
-if (socket->peek(&c, 1) == 1 && c == '\n') {
+do {
-// check for possible header endings. As per HTTP rfc,
+haveRead = socket->read(&c, 1);
-// the header endings will be marked by CRLFCRLF. But
+if (haveRead == 0) {
-// we will allow CRLFLF, LFLF & CRLFCRLF
+// read more later
-if (fragment.endsWith("\n\r") || fragment.endsWith('\n'))
+break;
-allHeaders = true;
+} else if (haveRead == -1) {
-}
+// connection broke down
-bytes += socket->read(&c, 1);
+return -1;
-fragment.append(c);
+} else {
-}
+fragment.append(c);
+bytes++;
+if (c == '\n') {
+// check for possible header endings. As per HTTP rfc,
+// the header endings will be marked by CRLFCRLF. But
+// we will allow CRLFCRLF, CRLFLF, LFLF
+if (fragment.endsWith("\r\n\r\n")
+|| fragment.endsWith("\r\n\n")
+|| fragment.endsWith("\n\n"))
+allHeaders = true;
+// there is another case: We have no headers. Then the fragment equals just the line ending
+if ((fragment.length() == 2 && fragment.endsWith("\r\n"))
+|| (fragment.length() == 1 && fragment.endsWith("\n")))
+allHeaders = true;
+}
+}
+} while (!allHeaders && haveRead > 0);
 // we received all headers now parse them
 if (allHeaders) {
 parseHeader(fragment);
 state = ReadingDataState;
 fragment.clear(); // next fragment
 #ifndef QT_NO_OPENSSL
 QSslConfiguration QHttpNetworkReply::sslConfiguration() const
 {
 Q_D(const QHttpNetworkReply);
-if (d->connection)
-return d->connection->d_func()->sslConfiguration(*this);
+if (!d->connectionChannel)
 return QSslConfiguration();
+QSslSocket *sslSocket = qobject_cast<QSslSocket*>(d->connectionChannel->socket);
+if (!sslSocket)
+return QSslConfiguration();
+return sslSocket->sslConfiguration();
 }
 void QHttpNetworkReply::setSslConfiguration(const QSslConfiguration &config)
 {
 Q_D(QHttpNetworkReply);

changeset 7	f7bc934e204c
parent 3	41300fa6a67c