#include <qhttpnetworkreply_p.h>

Inheritance diagram for QHttpNetworkReplyPrivate:

Public Types
enum	ReplyState { NothingDoneState, ReadingStatusState, ReadingHeaderState, ReadingDataState, AllDoneState }

Public Types inherited from QObjectPrivate
typedef void(*	StaticMetaCallFunction) (QObject , QMetaObject::Call, int, void *)

Public Functions
void	appendCompressedReplyData (QByteDataBuffer &data)

void	appendUncompressedReplyData (QByteArray &qba)

void	appendUncompressedReplyData (QByteDataBuffer &data)

QAuthenticatorPrivate::Method	authenticationMethod (bool isProxy) const

qint64	bytesAvailable () const

void	clear ()

void	clearHttpLayerInformation ()

void	eraseData ()

bool	expectContent ()

bool	findChallenge (bool forProxy, QByteArray &challenge) const

qint64	getChunkSize (QAbstractSocket in, qint64 chunkSize)

int	gunzipBodyPartially (QByteArray &compressed, QByteArray &inflated)

void	gunzipBodyPartiallyEnd ()

bool	gzipCheckHeader (QByteArray &content, int &pos)

bool	isChunked ()

bool	isConnectionCloseEnabled ()

bool	isGzipped ()

void	parseHeader (const QByteArray &header)

bool	parseStatus (const QByteArray &status)

	QHttpNetworkReplyPrivate (const QUrl &newUrl=QUrl())

qint64	readBody (QAbstractSocket socket, QByteDataBuffer out)

qint64	readBodyFast (QAbstractSocket socket, QByteDataBuffer rb)

qint64	readBodyVeryFast (QAbstractSocket socket, char b)

qint64	readHeader (QAbstractSocket *socket)

qint64	readReplyBodyChunked (QAbstractSocket in, QByteDataBuffer out)

qint64	readReplyBodyRaw (QAbstractSocket in, QByteDataBuffer out, qint64 size)

qint64	readStatus (QAbstractSocket *socket)

void	removeAutoDecompressHeader ()

bool	shouldEmitSignals ()

	~QHttpNetworkReplyPrivate ()

Public Functions inherited from QObjectPrivate
void	_q_reregisterTimers (void *pointer)

void	addConnection (int signal, Connection *c)

void	cleanConnectionLists ()

void	connectNotify (const char *signal)

void	deleteChildren ()

void	disconnectNotify (const char *signal)

bool	isSender (const QObject receiver, const char signal) const

bool	isSignalConnected (uint signalIdx) const
	Returns true if the signal with index signal_index from object sender is connected. More...

void	moveToThread_helper ()

	QObjectPrivate (int version=QObjectPrivateVersion)

QObjectList	receiverList (const char *signal) const

QObjectList	senderList () const

void	setParent_helper (QObject *)

void	setThreadData_helper (QThreadData currentData, QThreadData targetData)

int	signalIndex (const char *signalName) const
	Returns the signal index used in the internal connectionLists vector. More...

virtual	~QObjectPrivate ()

Public Functions inherited from QObjectData
virtual	~QObjectData ()=0

Public Functions inherited from QHttpNetworkHeaderPrivate
qint64	contentLength () const

QByteArray	headerField (const QByteArray &name, const QByteArray &defaultValue=QByteArray()) const

QList< QByteArray >	headerFieldValues (const QByteArray &name) const

bool	operator== (const QHttpNetworkHeaderPrivate &other) const

	QHttpNetworkHeaderPrivate (const QUrl &newUrl=QUrl())

	QHttpNetworkHeaderPrivate (const QHttpNetworkHeaderPrivate &other)

void	setContentLength (qint64 length)

void	setHeaderField (const QByteArray &name, const QByteArray &data)

Public Functions inherited from QSharedData
	QSharedData ()
	Constructs a QSharedData object with a reference count of 0. More...

	QSharedData (const QSharedData &)
	Constructs a QSharedData object with reference count 0. More...

Public Variables
bool	autoDecompress

qint64	bodyLength

bool	chunkedTransferEncoding

QByteArray	compressedData

QPointer< QHttpNetworkConnection >	connection

QPointer< QHttpNetworkConnectionChannel >	connectionChannel

bool	connectionCloseEnabled

qint64	contentRead

qint64	currentChunkRead

qint64	currentChunkSize

bool	downstreamLimited

QString	errorString

bool	forceConnectionCloseEnabled

QByteArray	fragment

z_stream	inflateStrm

bool	initInflate

bool	lastChunkRead

int	majorVersion

int	minorVersion

bool	pipeliningUsed

qint64	readBufferMaxSize

QString	reasonPhrase

QHttpNetworkRequest	request

bool	requestIsPrepared

QByteDataBuffer	responseData

bool	ssl

enum QHttpNetworkReplyPrivate::ReplyState	state

int	statusCode

bool	streamEnd

qint64	totalProgress

char *	userProvidedDownloadBuffer

Public Variables inherited from QObjectPrivate
union {
QObject * currentChildBeingDeleted

QAbstractDeclarativeData * declarativeData

};

quint32	connectedSignals [2]

QObjectConnectionListVector *	connectionLists

Sender *	currentSender

QList< QPointer< QObject > >	eventFilters

ExtraData *	extraData

QString	objectName

Connection *	senders

QAtomicPointer< QtSharedPointer::ExternalRefCountData >	sharedRefcount

QThreadData *	threadData

void *	unused

Public Variables inherited from QObjectData
uint	blockSig: 1

QObjectList	children

uint	hasGuards: 1

uint	inEventHandler: 1

uint	inThreadChangeEvent: 1

uint	isWidget: 1

QMetaObject *	metaObject

uint	ownObjectName: 1

QObject *	parent

uint	pendTimer: 1

int	postedEvents

QObject *	q_ptr

uint	receiveChildEvents: 1

uint	sendChildEvents: 1

uint	unused: 22

uint	wasDeleted: 1

Public Variables inherited from QHttpNetworkHeaderPrivate
QList< QPair< QByteArray, QByteArray > >	fields

QUrl	url

Public Variables inherited from QSharedData
QAtomicInt	ref

Additional Inherited Members
Static Public Functions inherited from QObjectPrivate
static void	clearGuards (QObject *)

static QObjectPrivate *	get (QObject *o)

static void	resetCurrentSender (QObject receiver, Sender currentSender, Sender *previousSender)

static Sender *	setCurrentSender (QObject receiver, Sender sender)

static void	signalSignature (const QMetaMethod &signal, QVarLengthArray< char > *result)

Detailed Description

Definition at line 177 of file qhttpnetworkreply_p.h.

Enumerations

◆ ReplyState

enum QHttpNetworkReplyPrivate::ReplyState

Enumerator
NothingDoneState
ReadingStatusState
ReadingHeaderState
ReadingDataState
AllDoneState

Definition at line 217 of file qhttpnetworkreply_p.h.

                     {
         NothingDoneState,
         ReadingStatusState,
         ReadingHeaderState,
         ReadingDataState,
         AllDoneState
     } state;

Constructors and Destructors

◆ QHttpNetworkReplyPrivate()

QHttpNetworkReplyPrivate::QHttpNetworkReplyPrivate ( const QUrl & newUrl = QUrl() )

Definition at line 264 of file qhttpnetworkreply.cpp.

     : QHttpNetworkHeaderPrivate(newUrl)
     , state(NothingDoneState)
     , ssl(false)
     , statusCode(100),
       majorVersion(0), minorVersion(0), bodyLength(0), contentRead(0), totalProgress(0),
       chunkedTransferEncoding(false),
       connectionCloseEnabled(true),
       forceConnectionCloseEnabled(false),
       lastChunkRead(false),
       currentChunkSize(0), currentChunkRead(0), readBufferMaxSize(0), connection(0), initInflate(false),
       autoDecompress(false), responseData(), requestIsPrepared(false)
       ,pipeliningUsed(false), downstreamLimited(false)
       ,userProvidedDownloadBuffer(0)
 {
 }

◆ ~QHttpNetworkReplyPrivate()

QHttpNetworkReplyPrivate::~QHttpNetworkReplyPrivate ( )

Definition at line 281 of file qhttpnetworkreply.cpp.

282 {

283 }

Functions

◆ appendCompressedReplyData()

void QHttpNetworkReplyPrivate::appendCompressedReplyData ( QByteDataBuffer & data )

Definition at line 914 of file qhttpnetworkreply.cpp.

Referenced by QHttpNetworkConnectionChannel::_q_receiveReply().

 {
     // Work in progress: Later we will directly use a list of QByteArray or a QRingBuffer
     // instead of one QByteArray.
     for(int i = 0; i < data.bufferCount(); i++) {
         QByteArray &byteData = data[i];
         compressedData.append(byteData.constData(), byteData.size());
     }
     data.clear();
 }

◆ appendUncompressedReplyData() [1/2]

void QHttpNetworkReplyPrivate::appendUncompressedReplyData ( QByteArray & qba )

Definition at line 896 of file qhttpnetworkreply.cpp.

Referenced by QHttpNetworkConnectionChannel::_q_receiveReply().

 {
     responseData.append(qba);
 
     // clear the original! helps with implicit sharing and
     // avoiding memcpy when the user is reading the data
     qba.clear();
 }

◆ appendUncompressedReplyData() [2/2]

void QHttpNetworkReplyPrivate::appendUncompressedReplyData ( QByteDataBuffer & data )

Definition at line 905 of file qhttpnetworkreply.cpp.

 {
     responseData.append(data);
 
     // clear the original! helps with implicit sharing and
     // avoiding memcpy when the user is reading the data
     data.clear();
 }

◆ authenticationMethod()

QAuthenticatorPrivate::Method QHttpNetworkReplyPrivate::authenticationMethod ( bool isProxy ) const

Definition at line 359 of file qhttpnetworkreply.cpp.

 {
     // The logic is same as the one used in void QAuthenticatorPrivate::parseHttpResponse()
     QAuthenticatorPrivate::Method method = QAuthenticatorPrivate::None;
     QByteArray header = isProxy ? "proxy-authenticate" : "www-authenticate";
     QList<QByteArray> challenges = headerFieldValues(header);
     for (int i = 0; i<challenges.size(); i++) {
         QByteArray line = challenges.at(i).trimmed().toLower();
         if (method < QAuthenticatorPrivate::Basic
             && line.startsWith("basic")) {
             method = QAuthenticatorPrivate::Basic;
         } else if (method < QAuthenticatorPrivate::Ntlm
             && line.startsWith("ntlm")) {
             method = QAuthenticatorPrivate::Ntlm;
         } else if (method < QAuthenticatorPrivate::DigestMd5
             && line.startsWith("digest")) {
             method = QAuthenticatorPrivate::DigestMd5;
         }
     }
     return method;
 }

◆ bytesAvailable()

qint64 QHttpNetworkReplyPrivate::bytesAvailable ( ) const

Definition at line 315 of file qhttpnetworkreply.cpp.

Referenced by getChunkSize().

 {
     return (state != ReadingDataState ? 0 : fragment.size());
 }

◆ clear()

void QHttpNetworkReplyPrivate::clear ( )

Definition at line 306 of file qhttpnetworkreply.cpp.

Referenced by QHttpNetworkConnectionChannel::sendRequest().

 {
     connection = 0;
     connectionChannel = 0;
     autoDecompress = false;
     clearHttpLayerInformation();
 }

◆ clearHttpLayerInformation()

void QHttpNetworkReplyPrivate::clearHttpLayerInformation ( )

Definition at line 285 of file qhttpnetworkreply.cpp.

Referenced by QHttpNetworkConnectionChannel::_q_receiveReply(), and clear().

 {
     state = NothingDoneState;
     statusCode = 100;
     bodyLength = 0;
     contentRead = 0;
     totalProgress = 0;
     currentChunkSize = 0;
     currentChunkRead = 0;
     lastChunkRead = false;
     connectionCloseEnabled = true;
 #ifndef QT_NO_COMPRESS
     if (initInflate)
         inflateEnd(&inflateStrm);
 #endif
     initInflate = false;
     streamEnd = false;
     fields.clear();
 }

◆ eraseData()

void QHttpNetworkReplyPrivate::eraseData ( )

Definition at line 952 of file qhttpnetworkreply.cpp.

 {
     compressedData.clear();
     responseData.clear();
 }

◆ expectContent()

bool QHttpNetworkReplyPrivate::expectContent ( )

Definition at line 933 of file qhttpnetworkreply.cpp.

Referenced by QHttpNetworkConnectionChannel::_q_receiveReply().

 {
     // check whether we can expect content after the headers (rfc 2616, sec4.4)
     if ((statusCode >= 100 && statusCode < 200)
         || statusCode == 204 || statusCode == 304)
         return false;
     if (request.operation() == QHttpNetworkRequest::Head)
         return false; // no body expected for HEAD request
     qint64 expectedContentLength = contentLength();
     if (expectedContentLength == 0)
         return false;
     if (expectedContentLength == -1 && bodyLength == 0) {
         // The content-length header was stripped, but its value was 0.
         // This would be the case for an explicitly zero-length compressed response.
         return false;
     }
     return true;
 }

◆ findChallenge()

bool QHttpNetworkReplyPrivate::findChallenge	(	bool	forProxy,
		QByteArray &	challenge
	)		const

Definition at line 343 of file qhttpnetworkreply.cpp.

 {
     challenge.clear();
     // find out the type of authentication protocol requested.
     QByteArray header = forProxy ? "proxy-authenticate" : "www-authenticate";
     // pick the best protocol (has to match parsing in QAuthenticatorPrivate)
     QList<QByteArray> challenges = headerFieldValues(header);
     for (int i = 0; i<challenges.size(); i++) {
         QByteArray line = challenges.at(i);
         // todo use qstrincmp
         if (!line.toLower().startsWith("negotiate"))
             challenge = line;
     }
     return !challenge.isEmpty();
 }

◆ getChunkSize()

qint64 QHttpNetworkReplyPrivate::getChunkSize	(	QAbstractSocket *	in,
		qint64 *	chunkSize
	)

Definition at line 856 of file qhttpnetworkreply.cpp.

Referenced by readReplyBodyChunked().

 {
     qint64 bytes = 0;
     char crlf[2];
     *chunkSize = -1;
 
     int bytesAvailable = socket->bytesAvailable();
     // FIXME rewrite to permanent loop without bytesAvailable
     while (bytesAvailable > bytes) {
         qint64 sniffedBytes = socket->peek(crlf, 2);
         int fragmentSize = fragment.size();
 
         // check the next two bytes for a "\r\n", skip blank lines
         if ((fragmentSize && sniffedBytes == 2 && crlf[0] == '\r' && crlf[1] == '\n')
            ||(fragmentSize > 1 && fragment.endsWith('\r')  && crlf[0] == '\n'))
         {
             bytes += socket->read(crlf, 1);     // read the \r or \n
             if (crlf[0] == '\r')
                 bytes += socket->read(crlf, 1); // read the \n
             bool ok = false;
             // ignore the chunk-extension
             fragment = fragment.mid(0, fragment.indexOf(';')).trimmed();
             *chunkSize = fragment.toLong(&ok, 16);
             fragment.clear();
             break; // size done
         } else {
             // read the fragment to the buffer
             char c = 0;
             qint64 haveRead = socket->read(&c, 1);
             if (haveRead < 0) {
                 return -1; // FIXME
             }
             bytes += haveRead;
             fragment.append(c);
         }
     }
 
     return bytes;
 }

◆ gunzipBodyPartially()

int QHttpNetworkReplyPrivate::gunzipBodyPartially	(	QByteArray &	compressed,
		QByteArray &	inflated
	)

Definition at line 439 of file qhttpnetworkreply.cpp.

 {
     int ret = Z_DATA_ERROR;
     unsigned have;
     unsigned char out[CHUNK];
     int pos = -1;
 
     if (!initInflate) {
         // check the header
         if (!gzipCheckHeader(compressed, pos))
             return ret;
         // allocate inflate state
         inflateStrm.zalloc = Z_NULL;
         inflateStrm.zfree = Z_NULL;
         inflateStrm.opaque = Z_NULL;
         inflateStrm.avail_in = 0;
         inflateStrm.next_in = Z_NULL;
         ret = inflateInit2(&inflateStrm, -MAX_WBITS);
         if (ret != Z_OK)
             return ret;
         initInflate = true;
         streamEnd = false;
     }
 
     //remove the header.
     compressed.remove(0, pos+1);
     // expand until deflate stream ends
     inflateStrm.next_in = (unsigned char *)compressed.data();
     inflateStrm.avail_in = compressed.size();
     do {
         inflateStrm.avail_out = sizeof(out);
         inflateStrm.next_out = out;
         ret = inflate(&inflateStrm, Z_NO_FLUSH);
         switch (ret) {
         case Z_NEED_DICT:
             ret = Z_DATA_ERROR;
             // and fall through
         case Z_DATA_ERROR:
         case Z_MEM_ERROR:
             inflateEnd(&inflateStrm);
             initInflate = false;
             return ret;
         }
         have = sizeof(out) - inflateStrm.avail_out;
         inflated.append(QByteArray((const char *)out, have));
      } while (inflateStrm.avail_out == 0 && inflateStrm.avail_in > 0);
     // clean up and return
     if (ret <= Z_ERRNO || ret == Z_STREAM_END) {
         gunzipBodyPartiallyEnd();
     }
     streamEnd = (ret == Z_STREAM_END);
     return ret;
 }

◆ gunzipBodyPartiallyEnd()

void QHttpNetworkReplyPrivate::gunzipBodyPartiallyEnd ( )

Definition at line 493 of file qhttpnetworkreply.cpp.

Referenced by gunzipBodyPartially().

 {
     if (initInflate) {
         inflateEnd(&inflateStrm);
         initInflate = false;
     }
 }

◆ gzipCheckHeader()

bool QHttpNetworkReplyPrivate::gzipCheckHeader	(	QByteArray &	content,
		int &	pos
	)

Definition at line 382 of file qhttpnetworkreply.cpp.

Referenced by gunzipBodyPartially().

 {
     int method = 0; // method byte
     int flags = 0;  // flags byte
     bool ret = false;
 
     // Assure two bytes in the buffer so we can peek ahead -- handle case
     // where first byte of header is at the end of the buffer after the last
     // gzip segment
     pos = -1;
     QByteArray &body = content;
     int maxPos = body.size()-1;
     if (maxPos < 1) {
         return ret;
     }
 
     // Peek ahead to check the gzip magic header
     if (body[0] != char(gz_magic[0]) ||
         body[1] != char(gz_magic[1])) {
         return ret;
     }
     pos += 2;
     // Check the rest of the gzip header
     if (++pos <= maxPos)
         method = body[pos];
     if (pos++ <= maxPos)
         flags = body[pos];
     if (method != Z_DEFLATED || (flags & RESERVED) != 0) {
         return ret;
     }
 
     // Discard time, xflags and OS code:
     pos += 6;
     if (pos > maxPos)
         return ret;
     if ((flags & EXTRA_FIELD) && ((pos+2) <= maxPos)) { // skip the extra field
         unsigned len =  (unsigned)body[++pos];
         len += ((unsigned)body[++pos])<<8;
         pos += len;
         if (pos > maxPos)
             return ret;
     }
     if ((flags & ORIG_NAME) != 0) { // skip the original file name
         while(++pos <= maxPos && body[pos]) {}
     }
     if ((flags & COMMENT) != 0) {   // skip the .gz file comment
         while(++pos <= maxPos && body[pos]) {}
     }
     if ((flags & HEAD_CRC) != 0) {  // skip the header crc
         pos += 2;
         if (pos > maxPos)
             return ret;
     }
     ret = (pos < maxPos); // return failed, if no more bytes left
     return ret;
 }

◆ isChunked()

bool QHttpNetworkReplyPrivate::isChunked ( )

Definition at line 686 of file qhttpnetworkreply.cpp.

Referenced by QHttpNetworkConnectionChannel::_q_receiveReply(), and readBody().

 {
     return chunkedTransferEncoding;
 }

◆ isConnectionCloseEnabled()

bool QHttpNetworkReplyPrivate::isConnectionCloseEnabled ( )

Definition at line 691 of file qhttpnetworkreply.cpp.

 {
     return connectionCloseEnabled || forceConnectionCloseEnabled;
 }

◆ isGzipped()

bool QHttpNetworkReplyPrivate::isGzipped ( )

Definition at line 320 of file qhttpnetworkreply.cpp.

Referenced by QHttpNetworkConnectionChannel::_q_receiveReply().

 {
     QByteArray encoding = headerField("content-encoding");
     return qstricmp(encoding.constData(), "gzip") == 0;
 }

◆ parseHeader()

void QHttpNetworkReplyPrivate::parseHeader ( const QByteArray & header )

Definition at line 652 of file qhttpnetworkreply.cpp.

Referenced by readHeader().

 {
     // see rfc2616, sec 4 for information about HTTP/1.1 headers.
     // allows relaxed parsing here, accepts both CRLF & LF line endings
     const QByteArrayMatcher lf("\n");
     const QByteArrayMatcher colon(":");
     int i = 0;
     while (i < header.count()) {
         int j = colon.indexIn(header, i); // field-name
         if (j == -1)
             break;
         const QByteArray field = header.mid(i, j - i).trimmed();
         j++;
         // any number of LWS is allowed before and after the value
         QByteArray value;
         do {
             i = lf.indexIn(header, j);
             if (i == -1)
                 break;
             if (!value.isEmpty())
                 value += ' ';
             // check if we have CRLF or only LF
             bool hasCR = (i && header[i-1] == '\r');
             int length = i -(hasCR ? 1: 0) - j;
             value += header.mid(j, length).trimmed();
             j = ++i;
         } while (i < header.count() && (header.at(i) == ' ' || header.at(i) == '\t'));
         if (i == -1)
             break; // something is wrong
 
         fields.append(qMakePair(field, value));
     }
 }

◆ parseStatus()

bool QHttpNetworkReplyPrivate::parseStatus ( const QByteArray & status )

Definition at line 553 of file qhttpnetworkreply.cpp.

Referenced by readStatus().

 {
     // from RFC 2616:
     //        Status-Line = HTTP-Version SP Status-Code SP Reason-Phrase CRLF
     //        HTTP-Version   = "HTTP" "/" 1*DIGIT "." 1*DIGIT
     // that makes: 'HTTP/n.n xxx Message'
     // byte count:  0123456789012
 
     static const int minLength = 11;
     static const int dotPos = 6;
     static const int spacePos = 8;
     static const char httpMagic[] = "HTTP/";
 
     if (status.length() < minLength
         || !status.startsWith(httpMagic)
         || status.at(dotPos) != '.'
         || status.at(spacePos) != ' ') {
         // I don't know how to parse this status line
         return false;
     }
 
     // optimize for the valid case: defer checking until the end
     majorVersion = status.at(dotPos - 1) - '0';
     minorVersion = status.at(dotPos + 1) - '0';
 
     int i = spacePos;
     int j = status.indexOf(' ', i + 1); // j == -1 || at(j) == ' ' so j+1 == 0 && j+1 <= length()
     const QByteArray code = status.mid(i + 1, j - i - 1);
 
     bool ok;
     statusCode = code.toInt(&ok);
     reasonPhrase = QString::fromLatin1(status.constData() + j + 1);
 
     return ok && uint(majorVersion) <= 9 && uint(minorVersion) <= 9;
 }

◆ readBody()

qint64 QHttpNetworkReplyPrivate::readBody	(	QAbstractSocket *	socket,
		QByteDataBuffer *	out
	)

Definition at line 743 of file qhttpnetworkreply.cpp.

Referenced by QHttpNetworkConnectionChannel::_q_receiveReply().

 {
     qint64 bytes = 0;
     if (isChunked()) {
         // chunked transfer encoding (rfc 2616, sec 3.6)
         bytes += readReplyBodyChunked(socket, out);
     } else if (bodyLength > 0) {
         // we have a Content-Length
         bytes += readReplyBodyRaw(socket, out, bodyLength - contentRead);
         if (contentRead + bytes == bodyLength)
             state = AllDoneState;
     } else {
         // no content length. just read what's possible
         bytes += readReplyBodyRaw(socket, out, socket->bytesAvailable());
     }
     contentRead += bytes;
     return bytes;
 }

◆ readBodyFast()

qint64 QHttpNetworkReplyPrivate::readBodyFast	(	QAbstractSocket *	socket,
		QByteDataBuffer *	rb
	)

Definition at line 717 of file qhttpnetworkreply.cpp.

Referenced by QHttpNetworkConnectionChannel::_q_receiveReply().

 {
 
     qint64 toBeRead = qMin(socket->bytesAvailable(), bodyLength - contentRead);
     if (readBufferMaxSize)
         toBeRead = qMin(toBeRead, readBufferMaxSize);
     QByteArray bd;
     bd.resize(toBeRead);
     qint64 haveRead = socket->read(bd.data(), toBeRead);
     if (haveRead == -1) {
         bd.clear();
         return 0; // ### error checking here;
     }
     bd.resize(haveRead);
 
     rb->append(bd);
 
     if (contentRead + haveRead == bodyLength) {
         state = AllDoneState;
     }
 
     contentRead += haveRead;
     return haveRead;
 }

◆ readBodyVeryFast()

qint64 QHttpNetworkReplyPrivate::readBodyVeryFast	(	QAbstractSocket *	socket,
		char *	b
	)

Definition at line 698 of file qhttpnetworkreply.cpp.

Referenced by QHttpNetworkConnectionChannel::_q_receiveReply().

 {
     // This first read is to flush the buffer inside the socket
     qint64 haveRead = 0;
     haveRead = socket->read(b, bodyLength - contentRead);
     if (haveRead == -1) {
         return 0; // ### error checking here;
     }
     contentRead += haveRead;
 
     if (contentRead == bodyLength) {
         state = AllDoneState;
     }
 
     return haveRead;
 }

◆ readHeader()

qint64 QHttpNetworkReplyPrivate::readHeader ( QAbstractSocket * socket )

Definition at line 589 of file qhttpnetworkreply.cpp.

Referenced by QHttpNetworkConnectionChannel::_q_receiveReply().

 {
     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;
     qint64 haveRead = 0;
     do {
         haveRead = socket->read(&c, 1);
         if (haveRead == 0) {
             // read more later
             break;
         } else if (haveRead == -1) {
             // connection broke down
             return -1;
         } 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
         bodyLength = contentLength(); // cache the length
 
         // cache isChunked() since it is called often
         chunkedTransferEncoding = headerField("transfer-encoding").toLower().contains("chunked");
 
         // cache isConnectionCloseEnabled since it is called often
         QByteArray connectionHeaderField = headerField("connection");
         // check for explicit indication of close or the implicit connection close of HTTP/1.0
         connectionCloseEnabled = (connectionHeaderField.toLower().contains("close") ||
             headerField("proxy-connection").toLower().contains("close")) ||
             (majorVersion == 1 && minorVersion == 0 &&
             (connectionHeaderField.isEmpty() && !headerField("proxy-connection").toLower().contains("keep-alive")));
     }
     return bytes;
 }

◆ readReplyBodyChunked()

qint64 QHttpNetworkReplyPrivate::readReplyBodyChunked	(	QAbstractSocket *	in,
		QByteDataBuffer *	out
	)

Definition at line 794 of file qhttpnetworkreply.cpp.

Referenced by readBody().

 {
     qint64 bytes = 0;
     while (socket->bytesAvailable()) {
 
         if (readBufferMaxSize && (bytes > readBufferMaxSize))
             break;
 
         if (!lastChunkRead && currentChunkRead >= currentChunkSize) {
             // For the first chunk and when we're done with a chunk
             currentChunkSize = 0;
             currentChunkRead = 0;
             if (bytes) {
                 // After a chunk
                 char crlf[2];
                 // read the "\r\n" after the chunk
                 qint64 haveRead = socket->read(crlf, 2);
                 // FIXME: This code is slightly broken and not optimal. What if the 2 bytes are not available yet?!
                 // For nice reasons (the toLong in getChunkSize accepting \n at the beginning
                 // it right now still works, but we should definitely fix this.
 
                 if (haveRead != 2)
                     return bytes; // FIXME
                 bytes += haveRead;
             }
             // Note that chunk size gets stored in currentChunkSize, what is returned is the bytes read
             bytes += getChunkSize(socket, &currentChunkSize);
             if (currentChunkSize == -1)
                 break;
         }
         // if the chunk size is 0, end of the stream
         if (currentChunkSize == 0 || lastChunkRead) {
             lastChunkRead = true;
             // try to read the "\r\n" after the chunk
             char crlf[2];
             qint64 haveRead = socket->read(crlf, 2);
             if (haveRead > 0)
                 bytes += haveRead;
 
             if ((haveRead == 2 && crlf[0] == '\r' && crlf[1] == '\n') || (haveRead == 1 && crlf[0] == '\n'))
                 state = AllDoneState;
             else if (haveRead == 1 && crlf[0] == '\r')
                 break; // Still waiting for the last \n
             else if (haveRead > 0) {
                 // If we read something else then CRLF, we need to close the channel.
                 forceConnectionCloseEnabled = true;
                 state = AllDoneState;
             }
             break;
         }
 
         // otherwise, try to begin reading this chunk / to read what is missing for this chunk
         qint64 haveRead = readReplyBodyRaw (socket, out, currentChunkSize - currentChunkRead);
         currentChunkRead += haveRead;
         bytes += haveRead;
 
         // ### error checking here
 
     }
     return bytes;
 }

◆ readReplyBodyRaw()

qint64 QHttpNetworkReplyPrivate::readReplyBodyRaw	(	QAbstractSocket *	in,
		QByteDataBuffer *	out,
		qint64	size
	)

Definition at line 762 of file qhttpnetworkreply.cpp.

Referenced by readBody(), and readReplyBodyChunked().

 {
     // FIXME get rid of this function and just use readBodyFast and give it socket->bytesAvailable()
     qint64 bytes = 0;
     Q_ASSERT(socket);
     Q_ASSERT(out);
 
     int toBeRead = qMin<qint64>(128*1024, qMin<qint64>(size, socket->bytesAvailable()));
     if (readBufferMaxSize)
         toBeRead = qMin<qint64>(toBeRead, readBufferMaxSize);
 
     while (toBeRead > 0) {
         QByteArray byteData;
         byteData.resize(toBeRead);
         qint64 haveRead = socket->read(byteData.data(), byteData.size());
         if (haveRead <= 0) {
             // ### error checking here
             byteData.clear();
             return bytes;
         }
 
         byteData.resize(haveRead);
         out->append(byteData);
         bytes += haveRead;
         size -= haveRead;
 
         toBeRead = qMin<qint64>(128*1024, qMin<qint64>(size, socket->bytesAvailable()));
     }
     return bytes;
 
 }

◆ readStatus()

qint64 QHttpNetworkReplyPrivate::readStatus ( QAbstractSocket * socket )

Definition at line 503 of file qhttpnetworkreply.cpp.

 {
     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;
 
     do {
         haveRead = socket->read(&c, 1);
         if (haveRead == -1)
             return -1; // unexpected EOF
         else if (haveRead == 0)
             break; // read more later
         else if (haveRead == 1 && fragment.size() == 0 && (c == 11 || c == '\n' || c == '\r' || c == ' ' || c == 31))
             continue; // Ignore all whitespace that was trailing froma previous request on that socket
 
         bytes++;
 
         // allow both CRLF & LF (only) line endings
         if (c == '\n') {
             // remove the CR at the end
             if (fragment.endsWith('\r')) {
                 fragment.truncate(fragment.length()-1);
             }
             bool ok = parseStatus(fragment);
             state = ReadingHeaderState;
             fragment.clear();
             if (!ok) {
                 return -1;
             }
             break;
         } else {
             fragment.append(c);
         }
 
         // is this a valid reply?
         if (fragment.length() >= 5 && !fragment.startsWith("HTTP/"))
         {
             fragment.clear();
             return -1;
         }
     } while (haveRead == 1);
 
     return bytes;
 }

◆ removeAutoDecompressHeader()

void QHttpNetworkReplyPrivate::removeAutoDecompressHeader ( )

Definition at line 326 of file qhttpnetworkreply.cpp.

Referenced by QHttpNetworkConnectionChannel::_q_receiveReply().

 {
     // The header "Content-Encoding  = gzip" is retained.
     // Content-Length is removed since the actual one send by the server is for compressed data
     QByteArray name("content-length");
     QList<QPair<QByteArray, QByteArray> >::Iterator it = fields.begin(),
                                                    end = fields.end();
     while (it != end) {
         if (qstricmp(name.constData(), it->first.constData()) == 0) {
             fields.erase(it);
             break;
         }
         ++it;
     }
 
 }

◆ shouldEmitSignals()

bool QHttpNetworkReplyPrivate::shouldEmitSignals ( )

Definition at line 926 of file qhttpnetworkreply.cpp.

Referenced by QHttpNetworkConnectionChannel::_q_receiveReply().

 {
     // for 401 & 407 don't emit the data signals. Content along with these
     // responses are send only if the authentication fails.
     return (statusCode != 401 && statusCode != 407);
 }

Properties

◆ autoDecompress

bool QHttpNetworkReplyPrivate::autoDecompress

Definition at line 250 of file qhttpnetworkreply_p.h.

Referenced by QHttpNetworkConnectionChannel::_q_receiveReply(), clear(), and QHttpNetworkConnectionChannel::sendRequest().

◆ bodyLength

qint64 QHttpNetworkReplyPrivate::bodyLength

Definition at line 232 of file qhttpnetworkreply_p.h.

Referenced by QHttpNetworkConnectionChannel::_q_receiveReply(), clearHttpLayerInformation(), expectContent(), readBody(), readBodyFast(), readBodyVeryFast(), and readHeader().

◆ chunkedTransferEncoding

bool QHttpNetworkReplyPrivate::chunkedTransferEncoding

Definition at line 236 of file qhttpnetworkreply_p.h.

Referenced by isChunked(), and readHeader().

◆ compressedData

QByteArray QHttpNetworkReplyPrivate::compressedData

Definition at line 253 of file qhttpnetworkreply_p.h.

Referenced by appendCompressedReplyData(), and eraseData().

◆ connection

QPointer<QHttpNetworkConnection> QHttpNetworkReplyPrivate::connection

Definition at line 243 of file qhttpnetworkreply_p.h.

Referenced by clear(), and QHttpNetworkConnectionChannel::sendRequest().

◆ connectionChannel

QPointer<QHttpNetworkConnectionChannel> QHttpNetworkReplyPrivate::connectionChannel

Definition at line 244 of file qhttpnetworkreply_p.h.

Referenced by clear(), and QHttpNetworkConnectionChannel::sendRequest().

◆ connectionCloseEnabled

bool QHttpNetworkReplyPrivate::connectionCloseEnabled

Definition at line 237 of file qhttpnetworkreply_p.h.

Referenced by clearHttpLayerInformation(), isConnectionCloseEnabled(), and readHeader().

◆ contentRead

qint64 QHttpNetworkReplyPrivate::contentRead

Definition at line 233 of file qhttpnetworkreply_p.h.

Referenced by clearHttpLayerInformation(), readBody(), readBodyFast(), and readBodyVeryFast().

◆ currentChunkRead

qint64 QHttpNetworkReplyPrivate::currentChunkRead

Definition at line 241 of file qhttpnetworkreply_p.h.

Referenced by clearHttpLayerInformation(), and readReplyBodyChunked().

◆ currentChunkSize

qint64 QHttpNetworkReplyPrivate::currentChunkSize

Definition at line 240 of file qhttpnetworkreply_p.h.

Referenced by clearHttpLayerInformation(), and readReplyBodyChunked().

◆ downstreamLimited

bool QHttpNetworkReplyPrivate::downstreamLimited

Definition at line 257 of file qhttpnetworkreply_p.h.

Referenced by QHttpNetworkConnectionChannel::_q_receiveReply().

◆ errorString

QString QHttpNetworkReplyPrivate::errorString

Definition at line 230 of file qhttpnetworkreply_p.h.

◆ forceConnectionCloseEnabled

bool QHttpNetworkReplyPrivate::forceConnectionCloseEnabled

Definition at line 238 of file qhttpnetworkreply_p.h.

Referenced by isConnectionCloseEnabled(), and readReplyBodyChunked().

◆ fragment

QByteArray QHttpNetworkReplyPrivate::fragment

Definition at line 235 of file qhttpnetworkreply_p.h.

Referenced by bytesAvailable(), getChunkSize(), readHeader(), and readStatus().

◆ inflateStrm

z_stream QHttpNetworkReplyPrivate::inflateStrm

Definition at line 248 of file qhttpnetworkreply_p.h.

Referenced by clearHttpLayerInformation(), gunzipBodyPartially(), and gunzipBodyPartiallyEnd().

◆ initInflate

bool QHttpNetworkReplyPrivate::initInflate

Definition at line 245 of file qhttpnetworkreply_p.h.

Referenced by clearHttpLayerInformation(), gunzipBodyPartially(), and gunzipBodyPartiallyEnd().

◆ lastChunkRead

bool QHttpNetworkReplyPrivate::lastChunkRead

Definition at line 239 of file qhttpnetworkreply_p.h.

Referenced by clearHttpLayerInformation(), and readReplyBodyChunked().

◆ majorVersion

int QHttpNetworkReplyPrivate::majorVersion

Definition at line 228 of file qhttpnetworkreply_p.h.

Referenced by parseStatus(), and readHeader().

◆ minorVersion

int QHttpNetworkReplyPrivate::minorVersion

Definition at line 229 of file qhttpnetworkreply_p.h.

Referenced by parseStatus(), and readHeader().

◆ pipeliningUsed

bool QHttpNetworkReplyPrivate::pipeliningUsed

Definition at line 256 of file qhttpnetworkreply_p.h.

Referenced by QHttpNetworkConnectionChannel::sendRequest().

◆ readBufferMaxSize

qint64 QHttpNetworkReplyPrivate::readBufferMaxSize

Definition at line 242 of file qhttpnetworkreply_p.h.

Referenced by readBodyFast(), readReplyBodyChunked(), and readReplyBodyRaw().

◆ reasonPhrase

QString QHttpNetworkReplyPrivate::reasonPhrase

Definition at line 231 of file qhttpnetworkreply_p.h.

Referenced by parseStatus().

◆ request

QHttpNetworkRequest QHttpNetworkReplyPrivate::request

Definition at line 225 of file qhttpnetworkreply_p.h.

Referenced by expectContent().

◆ requestIsPrepared

bool QHttpNetworkReplyPrivate::requestIsPrepared

Definition at line 254 of file qhttpnetworkreply_p.h.

◆ responseData

QByteDataBuffer QHttpNetworkReplyPrivate::responseData

Definition at line 252 of file qhttpnetworkreply_p.h.

Referenced by QHttpNetworkConnectionChannel::_q_receiveReply(), appendUncompressedReplyData(), and eraseData().

◆ ssl

bool QHttpNetworkReplyPrivate::ssl

Definition at line 226 of file qhttpnetworkreply_p.h.

◆ state

enum QHttpNetworkReplyPrivate::ReplyState QHttpNetworkReplyPrivate::state

Referenced by QHttpNetworkConnectionChannel::_q_receiveReply(), bytesAvailable(), clearHttpLayerInformation(), readBody(), readBodyFast(), readBodyVeryFast(), readHeader(), readReplyBodyChunked(), and readStatus().

◆ statusCode

int QHttpNetworkReplyPrivate::statusCode

Definition at line 227 of file qhttpnetworkreply_p.h.

Referenced by QHttpNetworkConnectionChannel::_q_receiveReply(), clearHttpLayerInformation(), expectContent(), parseStatus(), and shouldEmitSignals().

◆ streamEnd

bool QHttpNetworkReplyPrivate::streamEnd

Definition at line 246 of file qhttpnetworkreply_p.h.

Referenced by clearHttpLayerInformation(), and gunzipBodyPartially().

◆ totalProgress

qint64 QHttpNetworkReplyPrivate::totalProgress

Definition at line 234 of file qhttpnetworkreply_p.h.

Referenced by QHttpNetworkConnectionChannel::_q_receiveReply(), and clearHttpLayerInformation().

◆ userProvidedDownloadBuffer

char* QHttpNetworkReplyPrivate::userProvidedDownloadBuffer

Definition at line 259 of file qhttpnetworkreply_p.h.

Referenced by QHttpNetworkConnectionChannel::_q_receiveReply().

The documentation for this class was generated from the following files:

/src/network/access/qhttpnetworkreply_p.h
/src/network/access/qhttpnetworkreply.cpp

Public Types

Public Functions

Public Variables

Additional Inherited Members

Detailed Description

Enumerations

◆ ReplyState

Constructors and Destructors

◆ QHttpNetworkReplyPrivate()

◆ ~QHttpNetworkReplyPrivate()

Functions

◆ appendCompressedReplyData()

◆ appendUncompressedReplyData() [1/2]

◆ appendUncompressedReplyData() [2/2]

◆ authenticationMethod()

◆ bytesAvailable()

◆ clear()

◆ clearHttpLayerInformation()

◆ eraseData()

◆ expectContent()

◆ findChallenge()

◆ getChunkSize()

◆ gunzipBodyPartially()

◆ gunzipBodyPartiallyEnd()

◆ gzipCheckHeader()

◆ isChunked()

◆ isConnectionCloseEnabled()

◆ isGzipped()

◆ parseHeader()

◆ parseStatus()

◆ readBody()

◆ readBodyFast()

◆ readBodyVeryFast()

◆ readHeader()

◆ readReplyBodyChunked()

◆ readReplyBodyRaw()

◆ readStatus()

◆ removeAutoDecompressHeader()

◆ shouldEmitSignals()

Properties

◆ autoDecompress

◆ bodyLength

◆ chunkedTransferEncoding

◆ compressedData

◆ connection

◆ connectionChannel

◆ connectionCloseEnabled

◆ contentRead

◆ currentChunkRead

◆ currentChunkSize

◆ downstreamLimited

◆ errorString

◆ forceConnectionCloseEnabled

◆ fragment

◆ inflateStrm

◆ initInflate

◆ lastChunkRead

◆ majorVersion

◆ minorVersion

◆ pipeliningUsed

◆ readBufferMaxSize

◆ reasonPhrase

◆ request

◆ requestIsPrepared

◆ responseData

◆ ssl

◆ state

◆ statusCode

◆ streamEnd

◆ totalProgress

◆ userProvidedDownloadBuffer