#include <qhttpnetworkconnectionchannel_p.h>

Inheritance diagram for QHttpNetworkConnectionChannel:

Public Types
enum	ChannelState { IdleState = 0, ConnectingState = 1, WritingState = 2, WaitingState = 4, ReadingState = 8, ClosingState = 16, BusyState = (ConnectingState\|WritingState\|WaitingState\|ReadingState\|ClosingState) }

enum	PipeliningSupport { PipeliningSupportUnknown, PipeliningProbablySupported, PipeliningNotSupported }

Public Functions
void	allDone ()

void	close ()

void	closeAndResendCurrentRequest ()

void	detectPipeliningSupport ()

bool	ensureConnection ()

bool	expand (bool dataComplete)

void	handleStatus ()

void	handleUnexpectedEOF ()

void	init ()

bool	isSocketBusy () const

bool	isSocketReading () const

bool	isSocketWaiting () const

bool	isSocketWriting () const

void	pipelineFlush ()

void	pipelineInto (HttpMessagePair &pair)

	QHttpNetworkConnectionChannel ()

void	requeueCurrentlyPipelinedRequests ()

bool	resetUploadData ()

bool	sendRequest ()

void	setConnection (QHttpNetworkConnection *c)

Public Functions inherited from QObject
bool	blockSignals (bool b)
	If block is true, signals emitted by this object are blocked (i.e., emitting a signal will not invoke anything connected to it). More...

const QObjectList &	children () const
	Returns a list of child objects. More...

bool	connect (const QObject sender, const char signal, const char *member, Qt::ConnectionType type=Qt::AutoConnection) const

bool	disconnect (const char signal=0, const QObject receiver=0, const char *member=0)

bool	disconnect (const QObject receiver, const char member=0)

void	dumpObjectInfo ()
	Dumps information about signal connections, etc. More...

void	dumpObjectTree ()
	Dumps a tree of children to the debug output. More...

QList< QByteArray >	dynamicPropertyNames () const
	Returns the names of all properties that were dynamically added to the object using setProperty(). More...

virtual bool	event (QEvent *)
	This virtual function receives events to an object and should return true if the event e was recognized and processed. More...

virtual bool	eventFilter (QObject , QEvent )
	Filters events if this object has been installed as an event filter for the watched object. More...

template<typename T >
T	findChild (const QString &aName=QString()) const
	Returns the child of this object that can be cast into type T and that is called name, or 0 if there is no such object. More...

template<typename T >
QList< T >	findChildren (const QString &aName=QString()) const
	Returns all children of this object with the given name that can be cast to type T, or an empty list if there are no such objects. More...

template<typename T >
QList< T >	findChildren (const QRegExp &re) const

bool	inherits (const char *classname) const
	Returns true if this object is an instance of a class that inherits className or a QObject subclass that inherits className; otherwise returns false. More...

void	installEventFilter (QObject *)
	Installs an event filter filterObj on this object. More...

bool	isWidgetType () const
	Returns true if the object is a widget; otherwise returns false. More...

void	killTimer (int id)
	Kills the timer with timer identifier, id. More...

virtual const QMetaObject *	metaObject () const
	Returns a pointer to the meta-object of this object. More...

void	moveToThread (QThread *thread)
	Changes the thread affinity for this object and its children. More...

QString	objectName () const

QObject *	parent () const
	Returns a pointer to the parent object. More...

QVariant	property (const char *name) const
	Returns the value of the object's name property. More...

Q_INVOKABLE	QObject (QObject *parent=0)
	Constructs an object with parent object parent. More...

void	removeEventFilter (QObject *)
	Removes an event filter object obj from this object. More...

void	setObjectName (const QString &name)

void	setParent (QObject *)
	Makes the object a child of parent. More...

bool	setProperty (const char *name, const QVariant &value)
	Sets the value of the object's name property to value. More...

void	setUserData (uint id, QObjectUserData *data)

bool	signalsBlocked () const
	Returns true if signals are blocked; otherwise returns false. More...

int	startTimer (int interval)
	Starts a timer and returns a timer identifier, or returns zero if it could not start a timer. More...

QThread *	thread () const
	Returns the thread in which the object lives. More...

QObjectUserData *	userData (uint id) const

virtual	~QObject ()
	Destroys the object, deleting all its child objects. More...

Protected Slots
void	_q_bytesWritten (qint64 bytes)

void	_q_connected ()

void	_q_disconnected ()

void	_q_encrypted ()

void	_q_encryptedBytesWritten (qint64 bytes)

void	_q_error (QAbstractSocket::SocketError)

void	_q_proxyAuthenticationRequired (const QNetworkProxy &proxy, QAuthenticator *auth)

void	_q_readyRead ()

void	_q_receiveReply ()

void	_q_sslErrors (const QList< QSslError > &errors)

void	_q_uploadDataReadyRead ()

Friends
class	QNetworkAccessHttpBackend

Additional Inherited Members
Public Slots inherited from QObject
void	deleteLater ()
	Schedules this object for deletion. More...

Signals inherited from QObject
void	destroyed (QObject *=0)
	This signal is emitted immediately before the object obj is destroyed, and can not be blocked. More...

Static Public Functions inherited from QObject
static bool	connect (const QObject sender, const char signal, const QObject receiver, const char member, Qt::ConnectionType=Qt::AutoConnection)
	Creates a connection of the given type from the signal in the sender object to the method in the receiver object. More...

static bool	connect (const QObject sender, const QMetaMethod &signal, const QObject receiver, const QMetaMethod &method, Qt::ConnectionType type=Qt::AutoConnection)

static bool	disconnect (const QObject sender, const char signal, const QObject receiver, const char member)
	Disconnects signal in object sender from method in object receiver. More...

static bool	disconnect (const QObject sender, const QMetaMethod &signal, const QObject receiver, const QMetaMethod &member)

static uint	registerUserData ()

static QString	tr (const char sourceText, const char comment=0, int n=-1)

static QString	trUtf8 (const char sourceText, const char comment=0, int n=-1)

Static Public Variables inherited from QObject
static const QMetaObject	staticMetaObject
	This variable stores the meta-object for the class. More...

Protected Functions inherited from QObject
virtual void	childEvent (QChildEvent *)
	This event handler can be reimplemented in a subclass to receive child events. More...

virtual void	connectNotify (const char *signal)
	This virtual function is called when something has been connected to signal in this object. More...

virtual void	customEvent (QEvent *)
	This event handler can be reimplemented in a subclass to receive custom events. More...

virtual void	disconnectNotify (const char *signal)
	This virtual function is called when something has been disconnected from signal in this object. More...

	QObject (QObjectPrivate &dd, QObject *parent=0)

int	receivers (const char *signal) const
	Returns the number of receivers connected to the signal. More...

QObject *	sender () const
	Returns a pointer to the object that sent the signal, if called in a slot activated by a signal; otherwise it returns 0. More...

int	senderSignalIndex () const

virtual void	timerEvent (QTimerEvent *)
	This event handler can be reimplemented in a subclass to receive timer events for the object. More...

Protected Variables inherited from QObject
QScopedPointer< QObjectData >	d_ptr

Static Protected Variables inherited from QObject
static const QMetaObject	staticQtMetaObject

Related Functions inherited from QObject
T	qFindChildqFindChildren (const QObject *obj, const QString &name)()

QList< T >	qFindChildrenqFindChildren (const QObject *obj, const QString &name)()

QList< T >	qFindChildrenqFindChildren (const QObject *obj, const QRegExp &regExp)()

T *	qobject_cast (QObject *object)

	QObjectList

void *	qt_find_obj_child (QObject parent, const char type, const QString &name)
	Returns a pointer to the object named name that inherits type and with a given parent. More...

Detailed Description

Definition at line 89 of file qhttpnetworkconnectionchannel_p.h.

Enumerations

◆ ChannelState

enum QHttpNetworkConnectionChannel::ChannelState

Enumerator
IdleState
ConnectingState
WritingState
WaitingState
ReadingState
ClosingState
BusyState

Definition at line 92 of file qhttpnetworkconnectionchannel_p.h.

                       {
         IdleState = 0,          // ready to send request
         ConnectingState = 1,    // connecting to host
         WritingState = 2,       // writing the data
         WaitingState = 4,       // waiting for reply
         ReadingState = 8,       // reading the reply
         ClosingState = 16,
         BusyState = (ConnectingState|WritingState|WaitingState|ReadingState|ClosingState)
     };

◆ PipeliningSupport

enum QHttpNetworkConnectionChannel::PipeliningSupport

Enumerator
PipeliningSupportUnknown
PipeliningProbablySupported
PipeliningNotSupported

Definition at line 127 of file qhttpnetworkconnectionchannel_p.h.

                            {
         PipeliningSupportUnknown, // default for a new connection
         PipeliningProbablySupported, // after having received a server response that indicates support
         PipeliningNotSupported // currently not used
     };

Constructors and Destructors

◆ QHttpNetworkConnectionChannel()

QHttpNetworkConnectionChannel::QHttpNetworkConnectionChannel ( )

Definition at line 65 of file qhttpnetworkconnectionchannel.cpp.

     : socket(0)
     , ssl(false)
     , state(IdleState)
     , reply(0)
     , written(0)
     , bytesTotal(0)
     , resendCurrent(false)
     , lastStatus(0)
     , pendingEncrypt(false)
     , reconnectAttempts(2)
     , authMethod(QAuthenticatorPrivate::None)
     , proxyAuthMethod(QAuthenticatorPrivate::None)
     , authenticationCredentialsSent(false)
     , proxyCredentialsSent(false)
 #ifndef QT_NO_OPENSSL
     , ignoreAllSslErrors(false)
 #endif
     , pipeliningSupported(PipeliningSupportUnknown)
     , connection(0)
 {
     // Inlining this function in the header leads to compiler error on
     // release-armv5, on at least timebox 9.2 and 10.1.
 }

Functions

◆ _q_bytesWritten

void QHttpNetworkConnectionChannel::_q_bytesWritten ( qint64 bytes )

protectedslot

Definition at line 980 of file qhttpnetworkconnectionchannel.cpp.

Referenced by init().

 {
     Q_UNUSED(bytes);
     // bytes have been written to the socket. write even more of them :)
     if (isSocketWriting())
         sendRequest();
     // otherwise we do nothing
 }

◆ _q_connected

void QHttpNetworkConnectionChannel::_q_connected ( )

protectedslot

Definition at line 1014 of file qhttpnetworkconnectionchannel.cpp.

Referenced by init().

 {
     // improve performance since we get the request sent by the kernel ASAP
     //socket->setSocketOption(QAbstractSocket::LowDelayOption, 1);
     // We have this commented out now. It did not have the effect we wanted. If we want to
     // do this properly, Qt has to combine multiple HTTP requests into one buffer
     // and send this to the kernel in one syscall and then the kernel immediately sends
     // it as one TCP packet because of TCP_NODELAY.
     // However, this code is currently not in Qt, so we rely on the kernel combining
     // the requests into one TCP packet.
 
     // not sure yet if it helps, but it makes sense
     socket->setSocketOption(QAbstractSocket::KeepAliveOption, 1);
 
     pipeliningSupported = QHttpNetworkConnectionChannel::PipeliningSupportUnknown;
 
     // ### FIXME: if the server closes the connection unexpectedly, we shouldn't send the same broken request again!
     //channels[i].reconnectAttempts = 2;
     if (!pendingEncrypt) {
         state = QHttpNetworkConnectionChannel::IdleState;
         if (!reply)
             connection->d_func()->dequeueRequest(socket);
         if (reply)
             sendRequest();
     }
 }

◆ _q_disconnected

void QHttpNetworkConnectionChannel::_q_disconnected ( )

protectedslot

Definition at line 989 of file qhttpnetworkconnectionchannel.cpp.

Referenced by init().

 {
     if (state == QHttpNetworkConnectionChannel::ClosingState) {
         state = QHttpNetworkConnectionChannel::IdleState;
         QMetaObject::invokeMethod(connection, "_q_startNextRequest", Qt::QueuedConnection);
         return;
     }
 
     // read the available data before closing
     if (isSocketWaiting() || isSocketReading()) {
         if (reply) {
             state = QHttpNetworkConnectionChannel::ReadingState;
             _q_receiveReply();
         }
     } else if (state == QHttpNetworkConnectionChannel::IdleState && resendCurrent) {
         // re-sending request because the socket was in ClosingState
         QMetaObject::invokeMethod(connection, "_q_startNextRequest", Qt::QueuedConnection);
     }
     state = QHttpNetworkConnectionChannel::IdleState;
 
     requeueCurrentlyPipelinedRequests();
     close();
 }

◆ _q_encrypted

void QHttpNetworkConnectionChannel::_q_encrypted ( )

protectedslot

Definition at line 1164 of file qhttpnetworkconnectionchannel.cpp.

Referenced by init().

 {
     if (!socket)
         return; // ### error
     state = QHttpNetworkConnectionChannel::IdleState;
     pendingEncrypt = false;
     if (!reply)
         connection->d_func()->dequeueRequest(socket);
     if (reply)
         sendRequest();
 }

◆ _q_encryptedBytesWritten

void QHttpNetworkConnectionChannel::_q_encryptedBytesWritten ( qint64 bytes )

protectedslot

Definition at line 1191 of file qhttpnetworkconnectionchannel.cpp.

Referenced by init().

 {
     Q_UNUSED(bytes);
     // bytes have been written to the socket. write even more of them :)
     if (isSocketWriting())
         sendRequest();
     // otherwise we do nothing
 }

◆ _q_error

void QHttpNetworkConnectionChannel::_q_error ( QAbstractSocket::SocketError socketError )

protectedslot

Definition at line 1042 of file qhttpnetworkconnectionchannel.cpp.

Referenced by _q_readyRead(), and init().

 {
     if (!socket)
         return;
     QNetworkReply::NetworkError errorCode = QNetworkReply::UnknownNetworkError;
 
     switch (socketError) {
     case QAbstractSocket::HostNotFoundError:
         errorCode = QNetworkReply::HostNotFoundError;
         break;
     case QAbstractSocket::ConnectionRefusedError:
         errorCode = QNetworkReply::ConnectionRefusedError;
         break;
     case QAbstractSocket::RemoteHostClosedError:
         // try to reconnect/resend before sending an error.
         // while "Reading" the _q_disconnected() will handle this.
         if (state != QHttpNetworkConnectionChannel::IdleState && state != QHttpNetworkConnectionChannel::ReadingState) {
             if (reconnectAttempts-- > 0) {
                 closeAndResendCurrentRequest();
                 return;
             } else {
                 errorCode = QNetworkReply::RemoteHostClosedError;
             }
         } else if (state == QHttpNetworkConnectionChannel::ReadingState) {
             if (!reply)
                 break;
 
             if (!reply->d_func()->expectContent()) {
                 // No content expected, this is a valid way to have the connection closed by the server
                 return;
             }
             if (reply->contentLength() == -1 && !reply->d_func()->isChunked()) {
                 // There was no content-length header and it's not chunked encoding,
                 // so this is a valid way to have the connection closed by the server
                 return;
             }
             // ok, we got a disconnect even though we did not expect it
             // Try to read everything from the socket before we emit the error.
             if (socket->bytesAvailable()) {
                 // Read everything from the socket into the reply buffer.
                 // we can ignore the readbuffersize as the data is already
                 // in memory and we will not recieve more data on the socket.
                 reply->setReadBufferSize(0);
                 _q_receiveReply();
 #ifndef QT_NO_OPENSSL
                 if (ssl) {
                     // QT_NO_OPENSSL. The QSslSocket can still have encrypted bytes in the plainsocket.
                     // So we need to check this if the socket is a QSslSocket. When the socket is flushed
                     // it will force a decrypt of the encrypted data in the plainsocket.
                     QSslSocket *sslSocket = static_cast<QSslSocket*>(socket);
                     qint64 beforeFlush = sslSocket->encryptedBytesAvailable();
                     while (sslSocket->encryptedBytesAvailable()) {
                         sslSocket->flush();
                         _q_receiveReply();
                         qint64 afterFlush = sslSocket->encryptedBytesAvailable();
                         if (afterFlush == beforeFlush)
                             break;
                         beforeFlush = afterFlush;
                     }
                 }
 #endif
             }
 
             errorCode = QNetworkReply::RemoteHostClosedError;
         } else {
             errorCode = QNetworkReply::RemoteHostClosedError;
         }
         break;
     case QAbstractSocket::SocketTimeoutError:
         // try to reconnect/resend before sending an error.
         if (state == QHttpNetworkConnectionChannel::WritingState && (reconnectAttempts-- > 0)) {
             closeAndResendCurrentRequest();
             return;
         }
         errorCode = QNetworkReply::TimeoutError;
         break;
     case QAbstractSocket::ProxyAuthenticationRequiredError:
         errorCode = QNetworkReply::ProxyAuthenticationRequiredError;
         break;
     case QAbstractSocket::SslHandshakeFailedError:
         errorCode = QNetworkReply::SslHandshakeFailedError;
         break;
     default:
         // all other errors are treated as NetworkError
         errorCode = QNetworkReply::UnknownNetworkError;
         break;
     }
     QPointer<QHttpNetworkConnection> that = connection;
     QString errorString = connection->d_func()->errorDetail(errorCode, socket, socket->errorString());
 
     // Need to dequeu the request so that we can emit the error.
     if (!reply)
         connection->d_func()->dequeueRequest(socket);
     if (reply) {
         reply->d_func()->errorString = errorString;
         emit reply->finishedWithError(errorCode, errorString);
         reply = 0;
     }
     // send the next request
     QMetaObject::invokeMethod(that, "_q_startNextRequest", Qt::QueuedConnection);
 
     if (that) //signal emission triggered event loop
         close();
 }

◆ _q_proxyAuthenticationRequired

void QHttpNetworkConnectionChannel::_q_proxyAuthenticationRequired	(	const QNetworkProxy &	proxy,
		QAuthenticator *	auth
	)

protectedslot

Definition at line 1148 of file qhttpnetworkconnectionchannel.cpp.

Referenced by init().

 {
     // Need to dequeue the request before we can emit the error.
     if (!reply)
         connection->d_func()->dequeueRequest(socket);
     if (reply)
         connection->d_func()->emitProxyAuthenticationRequired(this, proxy, auth);
 }

◆ _q_readyRead

void QHttpNetworkConnectionChannel::_q_readyRead ( )

protectedslot

Definition at line 955 of file qhttpnetworkconnectionchannel.cpp.

Referenced by init().

 {
     if (socket->state() == QAbstractSocket::ConnectedState && socket->bytesAvailable() == 0) {
         // We got a readyRead but no bytes are available..
         // This happens for the Unbuffered QTcpSocket
         // Also check if socket is in ConnectedState since
         // this function may also be invoked via the event loop.
         char c;
         qint64  ret = socket->peek(&c, 1);
         if (ret < 0) {
             _q_error(socket->error());
             // We still need to handle the reply so it emits its signals etc.
             if (reply)
                 _q_receiveReply();
             return;
         }
     }
 
     if (isSocketWaiting() || isSocketReading()) {
         state = QHttpNetworkConnectionChannel::ReadingState;
         if (reply)
             _q_receiveReply();
     }
 }

◆ _q_receiveReply

void QHttpNetworkConnectionChannel::_q_receiveReply ( )

protectedslot

Definition at line 334 of file qhttpnetworkconnectionchannel.cpp.

Referenced by _q_disconnected(), _q_error(), and _q_readyRead().

 {
     Q_ASSERT(socket);
 
     if (!reply) {
         if (socket->bytesAvailable() > 0)
             qWarning() << "QHttpNetworkConnectionChannel::_q_receiveReply() called without QHttpNetworkReply,"
                        << socket->bytesAvailable() << "bytes on socket.";
 
         close();
         return;
     }
 
     // only run when the QHttpNetworkConnection is not currently being destructed, e.g.
     // this function is called from _q_disconnected which is called because
     // of ~QHttpNetworkConnectionPrivate
     if (!qobject_cast<QHttpNetworkConnection*>(connection)) {
         return;
     }
 
     QAbstractSocket::SocketState socketState = socket->state();
 
     // connection might be closed to signal the end of data
     if (socketState == QAbstractSocket::UnconnectedState) {
         if (socket->bytesAvailable() <= 0) {
             if (reply->d_func()->state == QHttpNetworkReplyPrivate::ReadingDataState) {
                 // finish this reply. this case happens when the server did not send a content length
                 reply->d_func()->state = QHttpNetworkReplyPrivate::AllDoneState;
                 allDone();
                 return;
             } else {
                 handleUnexpectedEOF();
                 return;
             }
         } else {
             // socket not connected but still bytes for reading.. just continue in this function
         }
     }
 
     // read loop for the response
     qint64 bytes = 0;
     qint64 lastBytes = bytes;
     do {
         lastBytes = bytes;
 
         QHttpNetworkReplyPrivate::ReplyState state = reply->d_func()->state;
         switch (state) {
         case QHttpNetworkReplyPrivate::NothingDoneState: {
             state = reply->d_func()->state = QHttpNetworkReplyPrivate::ReadingStatusState;
             // fallthrough
         }
         case QHttpNetworkReplyPrivate::ReadingStatusState: {
             qint64 statusBytes = reply->d_func()->readStatus(socket);
             if (statusBytes == -1) {
                 // connection broke while reading status. also handled if later _q_disconnected is called
                 handleUnexpectedEOF();
                 return;
             }
             bytes += statusBytes;
             lastStatus = reply->d_func()->statusCode;
             break;
         }
         case QHttpNetworkReplyPrivate::ReadingHeaderState: {
             QHttpNetworkReplyPrivate *replyPrivate = reply->d_func();
             qint64 headerBytes = replyPrivate->readHeader(socket);
             if (headerBytes == -1) {
                 // connection broke while reading headers. also handled if later _q_disconnected is called
                 handleUnexpectedEOF();
                 return;
             }
             bytes += headerBytes;
             // If headers were parsed successfully now it is the ReadingDataState
             if (replyPrivate->state == QHttpNetworkReplyPrivate::ReadingDataState) {
                 if (replyPrivate->isGzipped() && replyPrivate->autoDecompress) {
                     // remove the Content-Length from header
                     replyPrivate->removeAutoDecompressHeader();
                 } else {
                     replyPrivate->autoDecompress = false;
                 }
                 if (replyPrivate->statusCode == 100) {
                     replyPrivate->clearHttpLayerInformation();
                     replyPrivate->state = QHttpNetworkReplyPrivate::ReadingStatusState;
                     break; // ignore
                 }
                 if (replyPrivate->shouldEmitSignals())
                     emit reply->headerChanged();
                 // After headerChanged had been emitted
                 // we can suddenly have a replyPrivate->userProvidedDownloadBuffer
                 // this is handled in the ReadingDataState however
 
                 if (!replyPrivate->expectContent()) {
                     replyPrivate->state = QHttpNetworkReplyPrivate::AllDoneState;
                     allDone();
                     break;
                 }
             }
             break;
         }
         case QHttpNetworkReplyPrivate::ReadingDataState: {
            QHttpNetworkReplyPrivate *replyPrivate = reply->d_func();
            if (socket->state() == QAbstractSocket::ConnectedState &&
                replyPrivate->downstreamLimited && !replyPrivate->responseData.isEmpty() && replyPrivate->shouldEmitSignals()) {
                // (only do the following when still connected, not when we have already been disconnected and there is still data)
                // We already have some HTTP body data. We don't read more from the socket until
                // this is fetched by QHttpNetworkAccessHttpBackend. If we would read more,
                // we could not limit our read buffer usage.
                // We only do this when shouldEmitSignals==true because our HTTP parsing
                // always needs to parse the 401/407 replies. Therefore they don't really obey
                // to the read buffer maximum size, but we don't care since they should be small.
                return;
            }
 
            if (replyPrivate->userProvidedDownloadBuffer) {
                // the user provided a direct buffer where we should put all our data in.
                // this only works when we can tell the user the content length and he/she can allocate
                // the buffer in that size.
                // note that this call will read only from the still buffered data
                qint64 haveRead = replyPrivate->readBodyVeryFast(socket, replyPrivate->userProvidedDownloadBuffer + replyPrivate->totalProgress);
                bytes += haveRead;
                replyPrivate->totalProgress += haveRead;
 
                // the user will get notified of it via progress signal
                if (haveRead > 0)
                    emit reply->dataReadProgress(replyPrivate->totalProgress, replyPrivate->bodyLength);
            } else if (!replyPrivate->isChunked() && !replyPrivate->autoDecompress
                  && replyPrivate->bodyLength > 0) {
                  // bulk files like images should fulfill these properties and
                  // we can therefore save on memory copying
                 qint64 haveRead = replyPrivate->readBodyFast(socket, &replyPrivate->responseData);
                 bytes += haveRead;
                 replyPrivate->totalProgress += haveRead;
                 if (replyPrivate->shouldEmitSignals()) {
                     emit reply->readyRead();
                     emit reply->dataReadProgress(replyPrivate->totalProgress, replyPrivate->bodyLength);
                 }
             }
             else
             {
                 // use the traditional slower reading (for compressed encoding, chunked encoding,
                 // no content-length etc)
                 QByteDataBuffer byteDatas;
                 qint64 haveRead = replyPrivate->readBody(socket, &byteDatas);
                 if (haveRead) {
                     bytes += haveRead;
                     if (replyPrivate->autoDecompress)
                         replyPrivate->appendCompressedReplyData(byteDatas);
                     else
                         replyPrivate->appendUncompressedReplyData(byteDatas);
 
                     if (!replyPrivate->autoDecompress) {
                         replyPrivate->totalProgress += bytes;
                         if (replyPrivate->shouldEmitSignals()) {
                             // important: At the point of this readyRead(), the byteDatas list must be empty,
                             // else implicit sharing will trigger memcpy when the user is reading data!
                             emit reply->readyRead();
                             emit reply->dataReadProgress(replyPrivate->totalProgress, replyPrivate->bodyLength);
                         }
                     }
 #ifndef QT_NO_COMPRESS
                     else if (!expand(false)) { // expand a chunk if possible
                         // If expand() failed we can just return, it had already called connection->emitReplyError()
                         return;
                     }
 #endif
                 }
             }
             // still in ReadingDataState? This function will be called again by the socket's readyRead
             if (replyPrivate->state == QHttpNetworkReplyPrivate::ReadingDataState)
                 break;
 
             // everything done, fall through
             }
       case QHttpNetworkReplyPrivate::AllDoneState:
             allDone();
             break;
         default:
             break;
         }
     } while (bytes != lastBytes && reply);
 }

◆ _q_sslErrors

void QHttpNetworkConnectionChannel::_q_sslErrors ( const QList< QSslError > & errors )

protectedslot

Definition at line 1176 of file qhttpnetworkconnectionchannel.cpp.

Referenced by init().

 {
     if (!socket)
         return;
     //QNetworkReply::NetworkError errorCode = QNetworkReply::ProtocolFailure;
     // Also pause the connection because socket notifiers may fire while an user
     // dialog is displaying
     connection->d_func()->pauseConnection();
     if (pendingEncrypt && !reply)
         connection->d_func()->dequeueRequest(socket);
     if (reply)
         emit reply->sslErrors(errors);
     connection->d_func()->resumeConnection();
 }

◆ _q_uploadDataReadyRead

void QHttpNetworkConnectionChannel::_q_uploadDataReadyRead ( )

protectedslot

Definition at line 1158 of file qhttpnetworkconnectionchannel.cpp.

Referenced by sendRequest().

 {
     sendRequest();
 }

◆ allDone()

void QHttpNetworkConnectionChannel::allDone ( )

Definition at line 687 of file qhttpnetworkconnectionchannel.cpp.

Referenced by _q_receiveReply().

 {
     Q_ASSERT(reply);
 #ifndef QT_NO_COMPRESS
     // expand the whole data.
     if (reply->d_func()->expectContent() && reply->d_func()->autoDecompress && !reply->d_func()->streamEnd) {
         bool expandResult = expand(true);
         // If expand() failed we can just return, it had already called connection->emitReplyError()
         if (!expandResult)
             return;
     }
 #endif
 
     if (!reply) {
         qWarning() << "QHttpNetworkConnectionChannel::allDone() called without reply. Please report at http://bugreports.qt-project.org/";
         return;
     }
 
     // while handling 401 & 407, we might reset the status code, so save this.
     bool emitFinished = reply->d_func()->shouldEmitSignals();
     bool connectionCloseEnabled = reply->d_func()->isConnectionCloseEnabled();
     detectPipeliningSupport();
 
     handleStatus();
     // handleStatus() might have removed the reply because it already called connection->emitReplyError()
 
     // queue the finished signal, this is required since we might send new requests from
     // slot connected to it. The socket will not fire readyRead signal, if we are already
     // in the slot connected to readyRead
     if (reply && emitFinished)
         QMetaObject::invokeMethod(reply, "finished", Qt::QueuedConnection);
 
 
     // reset the reconnection attempts after we receive a complete reply.
     // in case of failures, each channel will attempt two reconnects before emitting error.
     reconnectAttempts = 2;
 
     // now the channel can be seen as free/idle again, all signal emissions for the reply have been done
     if (state != QHttpNetworkConnectionChannel::ClosingState)
         state = QHttpNetworkConnectionChannel::IdleState;
 
     // if it does not need to be sent again we can set it to 0
     // the previous code did not do that and we had problems with accidental re-sending of a
     // finished request.
     // Note that this may trigger a segfault at some other point. But then we can fix the underlying
     // problem.
     if (!resendCurrent) {
         request = QHttpNetworkRequest();
         reply = 0;
     }
 
     // move next from pipeline to current request
     if (!alreadyPipelinedRequests.isEmpty()) {
         if (resendCurrent || connectionCloseEnabled || socket->state() != QAbstractSocket::ConnectedState) {
             // move the pipelined ones back to the main queue
             requeueCurrentlyPipelinedRequests();
             close();
         } else {
             // there were requests pipelined in and we can continue
             HttpMessagePair messagePair = alreadyPipelinedRequests.takeFirst();
 
             request = messagePair.first;
             reply = messagePair.second;
             state = QHttpNetworkConnectionChannel::ReadingState;
             resendCurrent = false;
 
             written = 0; // message body, excluding the header, irrelevant here
             bytesTotal = 0; // message body total, excluding the header, irrelevant here
 
             // pipeline even more
             connection->d_func()->fillPipeline(socket);
 
             // continue reading
             //_q_receiveReply();
             // this was wrong, allDone gets called from that function anyway.
         }
     } else if (alreadyPipelinedRequests.isEmpty() && socket->bytesAvailable() > 0) {
         // this is weird. we had nothing pipelined but still bytes available. better close it.
         close();
 
         QMetaObject::invokeMethod(connection, "_q_startNextRequest", Qt::QueuedConnection);
     } else if (alreadyPipelinedRequests.isEmpty()) {
         if (connectionCloseEnabled)
             if (socket->state() != QAbstractSocket::UnconnectedState)
                 close();
         if (qobject_cast<QHttpNetworkConnection*>(connection))
             QMetaObject::invokeMethod(connection, "_q_startNextRequest", Qt::QueuedConnection);
     }
 }

◆ close()

void QHttpNetworkConnectionChannel::close ( )

Definition at line 159 of file qhttpnetworkconnectionchannel.cpp.

Referenced by _q_disconnected(), _q_error(), _q_receiveReply(), allDone(), closeAndResendCurrentRequest(), QHttpNetworkConnectionPrivate::emitReplyError(), handleStatus(), and handleUnexpectedEOF().

 {
     if (socket->state() == QAbstractSocket::UnconnectedState)
         state = QHttpNetworkConnectionChannel::IdleState;
     else
         state = QHttpNetworkConnectionChannel::ClosingState;
 
     socket->close();
 }

◆ closeAndResendCurrentRequest()

void QHttpNetworkConnectionChannel::closeAndResendCurrentRequest ( )

Definition at line 924 of file qhttpnetworkconnectionchannel.cpp.

Referenced by _q_error(), handleStatus(), and handleUnexpectedEOF().

 {
     requeueCurrentlyPipelinedRequests();
     close();
     if (reply)
         resendCurrent = true;
     if (qobject_cast<QHttpNetworkConnection*>(connection))
         QMetaObject::invokeMethod(connection, "_q_startNextRequest", Qt::QueuedConnection);
 }

◆ detectPipeliningSupport()

void QHttpNetworkConnectionChannel::detectPipeliningSupport ( )

Definition at line 777 of file qhttpnetworkconnectionchannel.cpp.

Referenced by allDone().

 {
     Q_ASSERT(reply);
     // detect HTTP Pipelining support
     QByteArray serverHeaderField;
     if (
             // check for HTTP/1.1
             (reply->d_func()->majorVersion == 1 && reply->d_func()->minorVersion == 1)
             // check for not having connection close
             && (!reply->d_func()->isConnectionCloseEnabled())
             // check if it is still connected
             && (socket->state() == QAbstractSocket::ConnectedState)
             // check for broken servers in server reply header
             // this is adapted from http://mxr.mozilla.org/firefox/ident?i=SupportsPipelining
             && (serverHeaderField = reply->headerField("Server"), !serverHeaderField.contains("Microsoft-IIS/4."))
             && (!serverHeaderField.contains("Microsoft-IIS/5."))
             && (!serverHeaderField.contains("Netscape-Enterprise/3."))
             // this is adpoted from the knowledge of the Nokia 7.x browser team (DEF143319)
             && (!serverHeaderField.contains("WebLogic"))
             && (!serverHeaderField.startsWith("Rocket")) // a Python Web Server, see Web2py.com
             ) {
         pipeliningSupported = QHttpNetworkConnectionChannel::PipeliningProbablySupported;
     } else {
         pipeliningSupported = QHttpNetworkConnectionChannel::PipeliningSupportUnknown;
     }
 }

◆ ensureConnection()

bool QHttpNetworkConnectionChannel::ensureConnection ( )

Definition at line 535 of file qhttpnetworkconnectionchannel.cpp.

Referenced by QHttpNetworkConnectionPrivate::_q_startNextRequest(), and sendRequest().

 {
     QAbstractSocket::SocketState socketState = socket->state();
 
     // resend this request after we receive the disconnected signal
     if (socketState == QAbstractSocket::ClosingState) {
         if (reply)
             resendCurrent = true;
         return false;
     }
 
     // already trying to connect?
     if (socketState == QAbstractSocket::HostLookupState ||
         socketState == QAbstractSocket::ConnectingState) {
         return false;
     }
 
     // make sure that this socket is in a connected state, if not initiate
     // connection to the host.
     if (socketState != QAbstractSocket::ConnectedState) {
         // connect to the host if not already connected.
         state = QHttpNetworkConnectionChannel::ConnectingState;
         pendingEncrypt = ssl;
 
         // reset state
         pipeliningSupported = PipeliningSupportUnknown;
         authenticationCredentialsSent = false;
         proxyCredentialsSent = false;
         authenticator.detach();
         QAuthenticatorPrivate *priv = QAuthenticatorPrivate::getPrivate(authenticator);
         priv->hasFailed = false;
         proxyAuthenticator.detach();
         priv = QAuthenticatorPrivate::getPrivate(proxyAuthenticator);
         priv->hasFailed = false;
 
         // This workaround is needed since we use QAuthenticator for NTLM authentication. The "phase == Done"
         // is the usual criteria for emitting authentication signals. The "phase" is set to "Done" when the
         // last header for Authorization is generated by the QAuthenticator. Basic & Digest logic does not
         // check the "phase" for generating the Authorization header. NTLM authentication is a two stage
         // process & needs the "phase". To make sure the QAuthenticator uses the current username/password
         // the phase is reset to Start.
         priv = QAuthenticatorPrivate::getPrivate(authenticator);
         if (priv && priv->phase == QAuthenticatorPrivate::Done)
             priv->phase = QAuthenticatorPrivate::Start;
         priv = QAuthenticatorPrivate::getPrivate(proxyAuthenticator);
         if (priv && priv->phase == QAuthenticatorPrivate::Done)
             priv->phase = QAuthenticatorPrivate::Start;
 
         QString connectHost = connection->d_func()->hostName;
         qint16 connectPort = connection->d_func()->port;
 
 #ifndef QT_NO_NETWORKPROXY
         // HTTPS always use transparent proxy.
         if (connection->d_func()->networkProxy.type() != QNetworkProxy::NoProxy && !ssl) {
             connectHost = connection->d_func()->networkProxy.hostName();
             connectPort = connection->d_func()->networkProxy.port();
         }
         if (socket->proxy().type() == QNetworkProxy::HttpProxy) {
             // Make user-agent field available to HTTP proxy socket engine (QTBUG-17223)
             QByteArray value;
             // ensureConnection is called before any request has been assigned, but can also be called again if reconnecting
             if (request.url().isEmpty())
                 value = connection->d_func()->predictNextRequest().headerField("user-agent");
             else
                 value = request.headerField("user-agent");
             if (!value.isEmpty())
                 socket->setProperty("_q_user-agent", value);
         }
 #endif
         if (ssl) {
 #ifndef QT_NO_OPENSSL
             QSslSocket *sslSocket = qobject_cast<QSslSocket*>(socket);
             sslSocket->connectToHostEncrypted(connectHost, connectPort);
             if (ignoreAllSslErrors)
                 sslSocket->ignoreSslErrors();
             sslSocket->ignoreSslErrors(ignoreSslErrorsList);
 
             // limit the socket read buffer size. we will read everything into
             // the QHttpNetworkReply anyway, so let's grow only that and not
             // here and there.
             socket->setReadBufferSize(64*1024);
 #else
             connection->d_func()->emitReplyError(socket, reply, QNetworkReply::ProtocolUnknownError);
 #endif
         } else {
             // In case of no proxy we can use the Unbuffered QTcpSocket
 #ifndef QT_NO_NETWORKPROXY
             if (connection->d_func()->networkProxy.type() == QNetworkProxy::NoProxy
                     && connection->cacheProxy().type() == QNetworkProxy::NoProxy
                     && connection->transparentProxy().type() == QNetworkProxy::NoProxy) {
 #endif
                 socket->connectToHost(connectHost, connectPort, QIODevice::ReadWrite | QIODevice::Unbuffered);
                 // For an Unbuffered QTcpSocket, the read buffer size has a special meaning.
                 socket->setReadBufferSize(1*1024);
 #ifndef QT_NO_NETWORKPROXY
             } else {
                 socket->connectToHost(connectHost, connectPort);
 
                 // limit the socket read buffer size. we will read everything into
                 // the QHttpNetworkReply anyway, so let's grow only that and not
                 // here and there.
                 socket->setReadBufferSize(64*1024);
             }
 #endif
         }
         return false;
     }
     return true;
 }

◆ expand()

bool QHttpNetworkConnectionChannel::expand ( bool dataComplete )

Definition at line 647 of file qhttpnetworkconnectionchannel.cpp.

Referenced by _q_receiveReply(), and allDone().

 {
     Q_ASSERT(socket);
     Q_ASSERT(reply);
 
     qint64 total = reply->d_func()->compressedData.size();
     if (total >= CHUNK || dataComplete) {
          // uncompress the data
         QByteArray content, inflated;
         content = reply->d_func()->compressedData;
         reply->d_func()->compressedData.clear();
 
         int ret = Z_OK;
         if (content.size())
             ret = reply->d_func()->gunzipBodyPartially(content, inflated);
         if (ret >= Z_OK) {
             if (dataComplete && ret == Z_OK && !reply->d_func()->streamEnd) {
                 reply->d_func()->gunzipBodyPartiallyEnd();
                 reply->d_func()->streamEnd = true;
             }
             if (inflated.size()) {
                 reply->d_func()->totalProgress += inflated.size();
                 reply->d_func()->appendUncompressedReplyData(inflated);
                 if (reply->d_func()->shouldEmitSignals()) {
                     // important: At the point of this readyRead(), inflated must be cleared,
                     // else implicit sharing will trigger memcpy when the user is reading data!
                     emit reply->readyRead();
                     emit reply->dataReadProgress(reply->d_func()->totalProgress, 0);
                 }
             }
         } else {
             connection->d_func()->emitReplyError(socket, reply, QNetworkReply::ProtocolFailure);
             return false;
         }
     }
     return true;
 }

◆ handleStatus()

void QHttpNetworkConnectionChannel::handleStatus ( )

Definition at line 818 of file qhttpnetworkconnectionchannel.cpp.

Referenced by allDone().

 {
     Q_ASSERT(socket);
     Q_ASSERT(reply);
 
     int statusCode = reply->statusCode();
     bool resend = false;
 
     switch (statusCode) {
     case 401: // auth required
     case 407: // proxy auth required
         if (connection->d_func()->handleAuthenticateChallenge(socket, reply, (statusCode == 407), resend)) {
             if (resend) {
                 if (!resetUploadData())
                     break;
 
                 reply->d_func()->eraseData();
 
                 if (alreadyPipelinedRequests.isEmpty()) {
                     // this does a re-send without closing the connection
                     resendCurrent = true;
                     QMetaObject::invokeMethod(connection, "_q_startNextRequest", Qt::QueuedConnection);
                 } else {
                     // we had requests pipelined.. better close the connection in closeAndResendCurrentRequest
                     closeAndResendCurrentRequest();
                     QMetaObject::invokeMethod(connection, "_q_startNextRequest", Qt::QueuedConnection);
                 }
             } else {
                 //authentication cancelled, close the channel.
                 close();
             }
         } else {
             emit reply->headerChanged();
             emit reply->readyRead();
             QNetworkReply::NetworkError errorCode = (statusCode == 407)
                 ? QNetworkReply::ProxyAuthenticationRequiredError
                 : QNetworkReply::AuthenticationRequiredError;
             reply->d_func()->errorString = connection->d_func()->errorDetail(errorCode, socket);
             emit reply->finishedWithError(errorCode, reply->d_func()->errorString);
         }
         break;
     default:
         if (qobject_cast<QHttpNetworkConnection*>(connection))
             QMetaObject::invokeMethod(connection, "_q_startNextRequest", Qt::QueuedConnection);
     }
 }

◆ handleUnexpectedEOF()

void QHttpNetworkConnectionChannel::handleUnexpectedEOF ( )

Definition at line 516 of file qhttpnetworkconnectionchannel.cpp.

Referenced by _q_receiveReply().

 {
     Q_ASSERT(reply);
     if (reconnectAttempts <= 0) {
         // too many errors reading/receiving/parsing the status, close the socket and emit error
         requeueCurrentlyPipelinedRequests();
         close();
         reply->d_func()->errorString = connection->d_func()->errorDetail(QNetworkReply::RemoteHostClosedError, socket);
         emit reply->finishedWithError(QNetworkReply::RemoteHostClosedError, reply->d_func()->errorString);
         QMetaObject::invokeMethod(connection, "_q_startNextRequest", Qt::QueuedConnection);
     } else {
         reconnectAttempts--;
         reply->d_func()->clear();
         reply->d_func()->connection = connection;
         reply->d_func()->connectionChannel = this;
         closeAndResendCurrentRequest();
     }
 }

◆ init()

void QHttpNetworkConnectionChannel::init ( )

Definition at line 90 of file qhttpnetworkconnectionchannel.cpp.

Referenced by QHttpNetworkConnectionPrivate::init().

 {
 #ifndef QT_NO_OPENSSL
     if (connection->d_func()->encrypt)
         socket = new QSslSocket;
     else
         socket = new QTcpSocket;
 #else
     socket = new QTcpSocket;
 #endif
 #ifndef QT_NO_BEARERMANAGEMENT
     //push session down to socket
     if (networkSession)
         socket->setProperty("_q_networksession", QVariant::fromValue(networkSession));
 #endif
 #ifndef QT_NO_NETWORKPROXY
     // Set by QNAM anyway, but let's be safe here
     socket->setProxy(QNetworkProxy::NoProxy);
 #endif
 
     QObject::connect(socket, SIGNAL(bytesWritten(qint64)),
                      this, SLOT(_q_bytesWritten(qint64)),
                      Qt::DirectConnection);
     QObject::connect(socket, SIGNAL(connected()),
                      this, SLOT(_q_connected()),
                      Qt::DirectConnection);
     QObject::connect(socket, SIGNAL(readyRead()),
                      this, SLOT(_q_readyRead()),
                      Qt::DirectConnection);
 
     // The disconnected() and error() signals may already come
     // while calling connectToHost().
     // In case of a cached hostname or an IP this
     // will then emit a signal to the user of QNetworkReply
     // but cannot be caught because the user did not have a chance yet
     // to connect to QNetworkReply's signals.
     qRegisterMetaType<QAbstractSocket::SocketError>("QAbstractSocket::SocketError");
     QObject::connect(socket, SIGNAL(disconnected()),
                      this, SLOT(_q_disconnected()),
                      Qt::QueuedConnection);
     QObject::connect(socket, SIGNAL(error(QAbstractSocket::SocketError)),
                      this, SLOT(_q_error(QAbstractSocket::SocketError)),
                      Qt::QueuedConnection);
 
 
 #ifndef QT_NO_NETWORKPROXY
     QObject::connect(socket, SIGNAL(proxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)),
                      this, SLOT(_q_proxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)),
                      Qt::DirectConnection);
 #endif
 
 #ifndef QT_NO_OPENSSL
     QSslSocket *sslSocket = qobject_cast<QSslSocket*>(socket);
     if (sslSocket) {
         // won't be a sslSocket if encrypt is false
         QObject::connect(sslSocket, SIGNAL(encrypted()),
                          this, SLOT(_q_encrypted()),
                          Qt::DirectConnection);
         QObject::connect(sslSocket, SIGNAL(sslErrors(QList<QSslError>)),
                          this, SLOT(_q_sslErrors(QList<QSslError>)),
                          Qt::DirectConnection);
         QObject::connect(sslSocket, SIGNAL(encryptedBytesWritten(qint64)),
                          this, SLOT(_q_encryptedBytesWritten(qint64)),
                          Qt::DirectConnection);
     }
 #endif
 }

◆ isSocketBusy()

bool QHttpNetworkConnectionChannel::isSocketBusy ( ) const

Definition at line 934 of file qhttpnetworkconnectionchannel.cpp.

 {
     return (state & QHttpNetworkConnectionChannel::BusyState);
 }

◆ isSocketReading()

bool QHttpNetworkConnectionChannel::isSocketReading ( ) const

Definition at line 949 of file qhttpnetworkconnectionchannel.cpp.

Referenced by _q_disconnected(), and _q_readyRead().

 {
     return (state & QHttpNetworkConnectionChannel::ReadingState);
 }

◆ isSocketWaiting()

bool QHttpNetworkConnectionChannel::isSocketWaiting ( ) const

Definition at line 944 of file qhttpnetworkconnectionchannel.cpp.

Referenced by _q_disconnected(), and _q_readyRead().

 {
     return (state & QHttpNetworkConnectionChannel::WaitingState);
 }

◆ isSocketWriting()

bool QHttpNetworkConnectionChannel::isSocketWriting ( ) const

Definition at line 939 of file qhttpnetworkconnectionchannel.cpp.

Referenced by _q_bytesWritten(), and _q_encryptedBytesWritten().

 {
     return (state & QHttpNetworkConnectionChannel::WritingState);
 }

◆ pipelineFlush()

void QHttpNetworkConnectionChannel::pipelineFlush ( )

Definition at line 909 of file qhttpnetworkconnectionchannel.cpp.

Referenced by QHttpNetworkConnectionPrivate::fillPipeline().

 {
     if (pipeline.isEmpty())
         return;
 
     // The goal of this is so that we have everything in one TCP packet.
     // For the Unbuffered QTcpSocket this is manually needed, the buffered
     // QTcpSocket does it automatically.
     // Also, sometimes the OS does it for us (Nagle's algorithm) but that
     // happens only sometimes.
     socket->write(pipeline);
     pipeline.clear();
 }

◆ pipelineInto()

void QHttpNetworkConnectionChannel::pipelineInto ( HttpMessagePair & pair )

Definition at line 885 of file qhttpnetworkconnectionchannel.cpp.

Referenced by QHttpNetworkConnectionPrivate::fillPipeline().

 {
     // this is only called for simple GET
 
     QHttpNetworkRequest &request = pair.first;
     QHttpNetworkReply *reply = pair.second;
     reply->d_func()->clear();
     reply->d_func()->connection = connection;
     reply->d_func()->connectionChannel = this;
     reply->d_func()->autoDecompress = request.d->autoDecompress;
     reply->d_func()->pipeliningUsed = true;
 
 #ifndef QT_NO_NETWORKPROXY
     pipeline.append(QHttpNetworkRequestPrivate::header(request,
                                                            (connection->d_func()->networkProxy.type() != QNetworkProxy::NoProxy)));
 #else
     pipeline.append(QHttpNetworkRequestPrivate::header(request, false));
 #endif
 
     alreadyPipelinedRequests.append(pair);
 
     // pipelineFlush() needs to be called at some point afterwards
 }

◆ requeueCurrentlyPipelinedRequests()

void QHttpNetworkConnectionChannel::requeueCurrentlyPipelinedRequests ( )

Definition at line 805 of file qhttpnetworkconnectionchannel.cpp.

Referenced by _q_disconnected(), allDone(), closeAndResendCurrentRequest(), QHttpNetworkConnectionPrivate::emitReplyError(), handleUnexpectedEOF(), and QHttpNetworkConnectionPrivate::removeReply().

 {
     for (int i = 0; i < alreadyPipelinedRequests.length(); i++)
         connection->d_func()->requeueRequest(alreadyPipelinedRequests.at(i));
     alreadyPipelinedRequests.clear();
 
     // only run when the QHttpNetworkConnection is not currently being destructed, e.g.
     // this function is called from _q_disconnected which is called because
     // of ~QHttpNetworkConnectionPrivate
     if (qobject_cast<QHttpNetworkConnection*>(connection))
         QMetaObject::invokeMethod(connection, "_q_startNextRequest", Qt::QueuedConnection);
 }

◆ resetUploadData()

bool QHttpNetworkConnectionChannel::resetUploadData ( )

Definition at line 865 of file qhttpnetworkconnectionchannel.cpp.

Referenced by handleStatus().

 {
     if (!reply) {
         //this happens if server closes connection while QHttpNetworkConnectionPrivate::_q_startNextRequest is pending
         return false;
     }
     QNonContiguousByteDevice* uploadByteDevice = request.uploadByteDevice();
     if (!uploadByteDevice)
         return true;
 
     if (uploadByteDevice->reset()) {
         written = 0;
         return true;
     } else {
         connection->d_func()->emitReplyError(socket, reply, QNetworkReply::ContentReSendError);
         return false;
     }
 }

◆ sendRequest()

bool QHttpNetworkConnectionChannel::sendRequest ( )

Definition at line 170 of file qhttpnetworkconnectionchannel.cpp.

Referenced by _q_bytesWritten(), _q_connected(), _q_encrypted(), _q_encryptedBytesWritten(), QHttpNetworkConnectionPrivate::_q_startNextRequest(), and _q_uploadDataReadyRead().

 {
     if (!reply) {
         // heh, how should that happen!
         qWarning() << "QHttpNetworkConnectionChannel::sendRequest() called without QHttpNetworkReply";
         state = QHttpNetworkConnectionChannel::IdleState;
         return false;
     }
 
     switch (state) {
     case QHttpNetworkConnectionChannel::IdleState: { // write the header
         if (!ensureConnection()) {
             // wait for the connection (and encryption) to be done
             // sendRequest will be called again from either
             // _q_connected or _q_encrypted
             return false;
         }
         written = 0; // excluding the header
         bytesTotal = 0;
 
         QHttpNetworkReplyPrivate *replyPrivate = reply->d_func();
         replyPrivate->clear();
         replyPrivate->connection = connection;
         replyPrivate->connectionChannel = this;
         replyPrivate->autoDecompress = request.d->autoDecompress;
         replyPrivate->pipeliningUsed = false;
 
         // if the url contains authentication parameters, use the new ones
         // both channels will use the new authentication parameters
         if (!request.url().userInfo().isEmpty() && request.withCredentials()) {
             QUrl url = request.url();
             QAuthenticator &auth = authenticator;
             if (url.userName() != auth.user()
                 || (!url.password().isEmpty() && url.password() != auth.password())) {
                 auth.setUser(url.userName());
                 auth.setPassword(url.password());
                 connection->d_func()->copyCredentials(connection->d_func()->indexOf(socket), &auth, false);
             }
             // clear the userinfo,  since we use the same request for resending
             // userinfo in url can conflict with the one in the authenticator
             url.setUserInfo(QString());
             request.setUrl(url);
         }
         // Will only be false if QtWebKit is performing a cross-origin XMLHttpRequest
         // and withCredentials has not been set to true.
         if (request.withCredentials())
             connection->d_func()->createAuthorization(socket, request);
 #ifndef QT_NO_NETWORKPROXY
         QByteArray header = QHttpNetworkRequestPrivate::header(request,
             (connection->d_func()->networkProxy.type() != QNetworkProxy::NoProxy));
 #else
         QByteArray header = QHttpNetworkRequestPrivate::header(request, false);
 #endif
         socket->write(header);
         // flushing is dangerous (QSslSocket calls transmit which might read or error)
 //        socket->flush();
         QNonContiguousByteDevice* uploadByteDevice = request.uploadByteDevice();
         if (uploadByteDevice) {
             // connect the signals so this function gets called again
             QObject::connect(uploadByteDevice, SIGNAL(readyRead()),this, SLOT(_q_uploadDataReadyRead()));
 
             bytesTotal = request.contentLength();
 
             state = QHttpNetworkConnectionChannel::WritingState; // start writing data
             sendRequest(); //recurse
         } else {
             state = QHttpNetworkConnectionChannel::WaitingState; // now wait for response
             sendRequest(); //recurse
         }
 
         break;
     }
     case QHttpNetworkConnectionChannel::WritingState:
     {
         // write the data
         QNonContiguousByteDevice* uploadByteDevice = request.uploadByteDevice();
         if (!uploadByteDevice || bytesTotal == written) {
             if (uploadByteDevice)
                 emit reply->dataSendProgress(written, bytesTotal);
             state = QHttpNetworkConnectionChannel::WaitingState; // now wait for response
             sendRequest(); // recurse
             break;
         }
 
         // only feed the QTcpSocket buffer when there is less than 32 kB in it
         const qint64 socketBufferFill = 32*1024;
         const qint64 socketWriteMaxSize = 16*1024;
 
 
 #ifndef QT_NO_OPENSSL
         QSslSocket *sslSocket = qobject_cast<QSslSocket*>(socket);
         // if it is really an ssl socket, check more than just bytesToWrite()
         while ((socket->bytesToWrite() + (sslSocket ? sslSocket->encryptedBytesToWrite() : 0))
                 <= socketBufferFill && bytesTotal != written)
 #else
         while (socket->bytesToWrite() <= socketBufferFill
                && bytesTotal != written)
 #endif
         {
             // get pointer to upload data
             qint64 currentReadSize = 0;
             qint64 desiredReadSize = qMin(socketWriteMaxSize, bytesTotal - written);
             const char *readPointer = uploadByteDevice->readPointer(desiredReadSize, currentReadSize);
 
             if (currentReadSize == -1) {
                 // premature eof happened
                 connection->d_func()->emitReplyError(socket, reply, QNetworkReply::UnknownNetworkError);
                 return false;
                 break;
             } else if (readPointer == 0 || currentReadSize == 0) {
                 // nothing to read currently, break the loop
                 break;
             } else {
                 qint64 currentWriteSize = socket->write(readPointer, currentReadSize);
                 if (currentWriteSize == -1 || currentWriteSize != currentReadSize) {
                     // socket broke down
                     connection->d_func()->emitReplyError(socket, reply, QNetworkReply::UnknownNetworkError);
                     return false;
                 } else {
                     written += currentWriteSize;
                     uploadByteDevice->advanceReadPointer(currentWriteSize);
 
                     emit reply->dataSendProgress(written, bytesTotal);
 
                     if (written == bytesTotal) {
                         // make sure this function is called once again
                         state = QHttpNetworkConnectionChannel::WaitingState;
                         sendRequest();
                         break;
                     }
                 }
             }
         }
         break;
     }
 
     case QHttpNetworkConnectionChannel::WaitingState:
     {
         QNonContiguousByteDevice* uploadByteDevice = request.uploadByteDevice();
         if (uploadByteDevice) {
             QObject::disconnect(uploadByteDevice, SIGNAL(readyRead()), this, SLOT(_q_uploadDataReadyRead()));
         }
 
         // HTTP pipelining
         //connection->d_func()->fillPipeline(socket);
         //socket->flush();
 
         // ensure we try to receive a reply in all cases, even if _q_readyRead_ hat not been called
         // this is needed if the sends an reply before we have finished sending the request. In that
         // case receiveReply had been called before but ignored the server reply
         if (socket->bytesAvailable())
             QMetaObject::invokeMethod(this, "_q_receiveReply", Qt::QueuedConnection);
         break;
     }
     case QHttpNetworkConnectionChannel::ReadingState:
         // ignore _q_bytesWritten in these states
         // fall through
     default:
         break;
     }
     return true;
 }

◆ setConnection()

void QHttpNetworkConnectionChannel::setConnection ( QHttpNetworkConnection * c )

Definition at line 1202 of file qhttpnetworkconnectionchannel.cpp.

Referenced by QHttpNetworkConnectionPrivate::init().

 {
     // Inlining this function in the header leads to compiler error on
     // release-armv5, on at least timebox 9.2 and 10.1.
     connection = c;
 }

Friends and Related Functions

◆ QNetworkAccessHttpBackend

friend class QNetworkAccessHttpBackend

friend

Definition at line 166 of file qhttpnetworkconnectionchannel_p.h.

Properties

◆ alreadyPipelinedRequests

QList<HttpMessagePair> QHttpNetworkConnectionChannel::alreadyPipelinedRequests

Definition at line 133 of file qhttpnetworkconnectionchannel_p.h.

Referenced by allDone(), QHttpNetworkConnectionPrivate::fillPipeline(), handleStatus(), pipelineInto(), QHttpNetworkConnectionPrivate::removeReply(), and requeueCurrentlyPipelinedRequests().

◆ authenticationCredentialsSent

bool QHttpNetworkConnectionChannel::authenticationCredentialsSent

Definition at line 116 of file qhttpnetworkconnectionchannel_p.h.

Referenced by QHttpNetworkConnectionPrivate::createAuthorization(), ensureConnection(), and QHttpNetworkConnectionPrivate::handleAuthenticateChallenge().

◆ authenticator

QAuthenticator QHttpNetworkConnectionChannel::authenticator

Definition at line 114 of file qhttpnetworkconnectionchannel_p.h.

Referenced by QHttpNetworkConnectionPrivate::copyCredentials(), ensureConnection(), QHttpNetworkConnectionPrivate::fillPipeline(), QHttpNetworkConnectionPrivate::handleAuthenticateChallenge(), and sendRequest().

◆ authMethod

QAuthenticatorPrivate::Method QHttpNetworkConnectionChannel::authMethod

Definition at line 112 of file qhttpnetworkconnectionchannel_p.h.

Referenced by QHttpNetworkConnectionPrivate::handleAuthenticateChallenge().

◆ bytesTotal

qint64 QHttpNetworkConnectionChannel::bytesTotal

Definition at line 107 of file qhttpnetworkconnectionchannel_p.h.

Referenced by allDone(), and sendRequest().

◆ connection

QPointer<QHttpNetworkConnection> QHttpNetworkConnectionChannel::connection

◆ ignoreAllSslErrors

bool QHttpNetworkConnectionChannel::ignoreAllSslErrors

Definition at line 119 of file qhttpnetworkconnectionchannel_p.h.

Referenced by ensureConnection().

◆ ignoreSslErrorsList

QList<QSslError> QHttpNetworkConnectionChannel::ignoreSslErrorsList

Definition at line 120 of file qhttpnetworkconnectionchannel_p.h.

Referenced by ensureConnection().

◆ lastStatus

int QHttpNetworkConnectionChannel::lastStatus

Definition at line 109 of file qhttpnetworkconnectionchannel_p.h.

Referenced by _q_receiveReply().

◆ networkSession

QSharedPointer<QNetworkSession> QHttpNetworkConnectionChannel::networkSession

Definition at line 123 of file qhttpnetworkconnectionchannel_p.h.

Referenced by init(), and QHttpNetworkConnectionPrivate::init().

◆ pendingEncrypt

bool QHttpNetworkConnectionChannel::pendingEncrypt

Definition at line 110 of file qhttpnetworkconnectionchannel_p.h.

Referenced by _q_connected(), _q_encrypted(), _q_sslErrors(), and ensureConnection().

◆ pipeline

QByteArray QHttpNetworkConnectionChannel::pipeline

Definition at line 134 of file qhttpnetworkconnectionchannel_p.h.

Referenced by pipelineFlush(), and pipelineInto().

◆ pipeliningSupported

PipeliningSupport QHttpNetworkConnectionChannel::pipeliningSupported

Definition at line 132 of file qhttpnetworkconnectionchannel_p.h.

Referenced by _q_connected(), detectPipeliningSupport(), and ensureConnection().

◆ proxyAuthenticator

QAuthenticator QHttpNetworkConnectionChannel::proxyAuthenticator

Definition at line 115 of file qhttpnetworkconnectionchannel_p.h.

Referenced by QHttpNetworkConnectionPrivate::copyCredentials(), ensureConnection(), QHttpNetworkConnectionPrivate::fillPipeline(), and QHttpNetworkConnectionPrivate::handleAuthenticateChallenge().

◆ proxyAuthMethod

QAuthenticatorPrivate::Method QHttpNetworkConnectionChannel::proxyAuthMethod

Definition at line 113 of file qhttpnetworkconnectionchannel_p.h.

Referenced by QHttpNetworkConnectionPrivate::handleAuthenticateChallenge().

◆ proxyCredentialsSent

bool QHttpNetworkConnectionChannel::proxyCredentialsSent

Definition at line 117 of file qhttpnetworkconnectionchannel_p.h.

Referenced by QHttpNetworkConnectionPrivate::createAuthorization(), ensureConnection(), and QHttpNetworkConnectionPrivate::handleAuthenticateChallenge().

◆ reconnectAttempts

int QHttpNetworkConnectionChannel::reconnectAttempts

Definition at line 111 of file qhttpnetworkconnectionchannel_p.h.

Referenced by _q_error(), allDone(), and handleUnexpectedEOF().

◆ reply

◆ request

QHttpNetworkRequest QHttpNetworkConnectionChannel::request

Definition at line 104 of file qhttpnetworkconnectionchannel_p.h.

Referenced by allDone(), QHttpNetworkConnectionPrivate::dequeueRequest(), QHttpNetworkConnectionPrivate::emitReplyError(), ensureConnection(), pipelineInto(), QHttpNetworkConnectionPrivate::removeReply(), resetUploadData(), and sendRequest().

◆ resendCurrent

bool QHttpNetworkConnectionChannel::resendCurrent

Definition at line 108 of file qhttpnetworkconnectionchannel_p.h.

Referenced by _q_disconnected(), QHttpNetworkConnectionPrivate::_q_startNextRequest(), allDone(), closeAndResendCurrentRequest(), ensureConnection(), handleStatus(), and QHttpNetworkConnectionPrivate::removeReply().

◆ socket

QAbstractSocket* QHttpNetworkConnectionChannel::socket

◆ ssl

bool QHttpNetworkConnectionChannel::ssl

Definition at line 102 of file qhttpnetworkconnectionchannel_p.h.

Referenced by _q_error(), ensureConnection(), and QHttpNetworkConnectionPrivate::init().

◆ state

ChannelState QHttpNetworkConnectionChannel::state

Definition at line 103 of file qhttpnetworkconnectionchannel_p.h.

Referenced by _q_connected(), _q_disconnected(), _q_encrypted(), _q_error(), _q_readyRead(), _q_receiveReply(), QHttpNetworkConnectionPrivate::_q_startNextRequest(), allDone(), close(), ensureConnection(), isSocketBusy(), isSocketReading(), isSocketWaiting(), isSocketWriting(), and sendRequest().

◆ written

qint64 QHttpNetworkConnectionChannel::written

Definition at line 106 of file qhttpnetworkconnectionchannel_p.h.

Referenced by allDone(), resetUploadData(), and sendRequest().

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

/src/network/access/qhttpnetworkconnectionchannel_p.h
/src/network/access/qhttpnetworkconnectionchannel.cpp

Public Variables
QList< HttpMessagePair >	alreadyPipelinedRequests

bool	authenticationCredentialsSent

QAuthenticator	authenticator

QAuthenticatorPrivate::Method	authMethod

qint64	bytesTotal

QPointer< QHttpNetworkConnection >	connection

bool	ignoreAllSslErrors

QList< QSslError >	ignoreSslErrorsList

int	lastStatus

QSharedPointer< QNetworkSession >	networkSession

bool	pendingEncrypt

QByteArray	pipeline

PipeliningSupport	pipeliningSupported

QAuthenticator	proxyAuthenticator

QAuthenticatorPrivate::Method	proxyAuthMethod

bool	proxyCredentialsSent

int	reconnectAttempts

QHttpNetworkReply *	reply

QHttpNetworkRequest	request

bool	resendCurrent

QAbstractSocket *	socket

bool	ssl

ChannelState	state

qint64	written

Public Types

Public Functions

Public Variables

Protected Slots

Friends

Additional Inherited Members

Detailed Description

Enumerations

◆ ChannelState

◆ PipeliningSupport

Constructors and Destructors

◆ QHttpNetworkConnectionChannel()

Functions

◆ _q_bytesWritten

◆ _q_connected

◆ _q_disconnected

◆ _q_encrypted

◆ _q_encryptedBytesWritten

◆ _q_error

◆ _q_proxyAuthenticationRequired

◆ _q_readyRead

◆ _q_receiveReply

◆ _q_sslErrors

◆ _q_uploadDataReadyRead

◆ allDone()

◆ close()

◆ closeAndResendCurrentRequest()

◆ detectPipeliningSupport()

◆ ensureConnection()

◆ expand()

◆ handleStatus()

◆ handleUnexpectedEOF()

◆ init()

◆ isSocketBusy()

◆ isSocketReading()

◆ isSocketWaiting()

◆ isSocketWriting()

◆ pipelineFlush()

◆ pipelineInto()

◆ requeueCurrentlyPipelinedRequests()

◆ resetUploadData()

◆ sendRequest()

◆ setConnection()

Friends and Related Functions

◆ QNetworkAccessHttpBackend

Properties

◆ alreadyPipelinedRequests

◆ authenticationCredentialsSent

◆ authenticator

◆ authMethod

◆ bytesTotal

◆ connection

◆ ignoreAllSslErrors

◆ ignoreSslErrorsList

◆ lastStatus

◆ networkSession

◆ pendingEncrypt

◆ pipeline

◆ pipeliningSupported

◆ proxyAuthenticator

◆ proxyAuthMethod

◆ proxyCredentialsSent

◆ reconnectAttempts

◆ reply

◆ request

◆ resendCurrent

◆ socket

◆ ssl

◆ state

◆ written