#include <qnetworkaccesshttpbackend_p.h>

Inheritance diagram for QNetworkAccessHttpBackend:

Signals
void	abortHttpRequest ()

void	haveUploadData (QByteArray dataArray, bool dataAtEnd, qint64 dataSize)

void	readBufferFreed (qint64 size)

void	readBufferSizeChanged (qint64 size)

void	startHttpRequest ()

void	startHttpRequestSynchronously ()

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...

Public Functions
bool	canResume () const

virtual void	closeDownstreamChannel ()

virtual void	copyFinished (QIODevice *)

virtual void	downstreamReadyWrite ()

virtual void	emitReadBufferFreed (qint64 size)

QNetworkCacheMetaData	fetchCacheMetaData (const QNetworkCacheMetaData &metaData) const

virtual void	fetchSslConfiguration (QSslConfiguration &configuration) const

virtual void	ignoreSslErrors ()

virtual void	ignoreSslErrors (const QList< QSslError > &errors)

bool	needsResetableUploadData ()

virtual void	open ()

	QNetworkAccessHttpBackend ()

virtual void	setDownstreamLimited (bool b)

virtual void	setReadBufferSize (qint64 size)

void	setResumeOffset (quint64 offset)

virtual void	setSslConfiguration (const QSslConfiguration &configuration)

virtual	~QNetworkAccessHttpBackend ()

Public Functions inherited from QNetworkAccessBackend
QVariant	attribute (QNetworkRequest::Attribute code) const

bool	hasRawHeader (const QByteArray &headerName) const

QVariant	header (QNetworkRequest::KnownHeaders header) const

bool	isCachingEnabled () const

bool	isSynchronous ()

QAbstractNetworkCache *	networkCache () const

QNetworkAccessManager::Operation	operation () const

virtual bool	processRequestSynchronously ()

QList< QNetworkProxy >	proxyList () const

	QNetworkAccessBackend ()

QByteArray	rawHeader (const QByteArray &headerName) const

QList< QByteArray >	rawHeaderList () const

QNetworkRequest	request () const

void	setAttribute (QNetworkRequest::Attribute code, const QVariant &value)

void	setCachingEnabled (bool enable)

void	setHeader (QNetworkRequest::KnownHeaders header, const QVariant &value)

void	setRawHeader (const QByteArray &headerName, const QByteArray &value)

void	setSynchronous (bool sync)

void	setUrl (const QUrl &url)

virtual bool	start ()
	Starts the backend. More...

QUrl	url () const

virtual	~QNetworkAccessBackend ()

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...

Private Slots
void	httpAuthenticationRequired (const QHttpNetworkRequest &request, QAuthenticator *auth)

void	httpError (QNetworkReply::NetworkError error, const QString &errorString)

void	replyDownloadData (QByteArray)

void	replyDownloadMetaData (QList< QPair< QByteArray, QByteArray > >, int, QString, bool, QSharedPointer< char >, qint64)

void	replyDownloadProgressSlot (qint64, qint64)

void	replyFinished ()

void	replySslConfigurationChanged (const QSslConfiguration &)

void	replySslErrors (const QList< QSslError > &, bool , QList< QSslError > )

void	resetUploadDataSlot (bool *r)

bool	sendCacheContents (const QNetworkCacheMetaData &metaData)

void	sentUploadDataSlot (qint64)

void	wantUploadDataSlot (qint64)

Private Functions
void	checkForRedirect (const int statusCode)

void	invalidateCache ()

bool	loadFromCacheIfAllowed (QHttpNetworkRequest &httpRequest)

void	postRequest ()

void	readFromHttp ()

Additional Inherited Members
Public Slots inherited from QNetworkAccessBackend
void	writeDownstreamData (QIODevice *data)

Public Slots inherited from QObject
void	deleteLater ()
	Schedules this object for deletion. 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 Slots inherited from QNetworkAccessBackend
void	authenticationRequired (QAuthenticator *auth)

void	emitReplyUploadProgress (qint64 bytesSent, qint64 bytesTotal)

void	error (QNetworkReply::NetworkError code, const QString &errorString)

void	finished ()

void	metaDataChanged ()

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

void	redirectionRequested (const QUrl &destination)

void	sslErrors (const QList< QSslError > &errors)

Protected Functions inherited from QNetworkAccessBackend
QNonContiguousByteDevice *	createUploadByteDevice ()

char *	getDownloadBuffer (qint64)

qint64	nextDownstreamBlockSize () const

void	writeDownstreamData (QByteDataBuffer &list)

void	writeDownstreamDataDownloadBuffer (qint64, qint64)

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 QNetworkAccessBackend
QNetworkAccessManagerPrivate *	manager

QNetworkReplyImplPrivate *	reply

QSharedPointer< QNonContiguousByteDevice >	uploadByteDevice

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 75 of file qnetworkaccesshttpbackend_p.h.

Constructors and Destructors

◆ QNetworkAccessHttpBackend()

QNetworkAccessHttpBackend::QNetworkAccessHttpBackend ( )

Definition at line 193 of file qnetworkaccesshttpbackend.cpp.

     : QNetworkAccessBackend()
     , statusCode(0)
     , pendingDownloadDataEmissions(new QAtomicInt())
     , pendingDownloadProgressEmissions(new QAtomicInt())
     , loadingFromCache(false)
     , usingZerocopyDownloadBuffer(false)
 #ifndef QT_NO_OPENSSL
     , pendingSslConfiguration(0), pendingIgnoreAllSslErrors(false)
 #endif
     , resumeOffset(0)
 {
 }

◆ ~QNetworkAccessHttpBackend()

QNetworkAccessHttpBackend::~QNetworkAccessHttpBackend ( )

virtual

Definition at line 207 of file qnetworkaccesshttpbackend.cpp.

 {
     // This will do nothing if the request was already finished or aborted
     emit abortHttpRequest();
 
 #ifndef QT_NO_OPENSSL
     delete pendingSslConfiguration;
 #endif
 }

Functions

◆ abortHttpRequest

void QNetworkAccessHttpBackend::abortHttpRequest ( )

signal

Referenced by needsResetableUploadData(), postRequest(), and ~QNetworkAccessHttpBackend().

◆ canResume()

bool QNetworkAccessHttpBackend::canResume ( ) const

virtual

Reimplemented from QNetworkAccessBackend.

Definition at line 1172 of file qnetworkaccesshttpbackend.cpp.

Referenced by needsResetableUploadData().

 {
     // Only GET operation supports resuming.
     if (operation() != QNetworkAccessManager::GetOperation)
         return false;
 
     // Can only resume if server/resource supports Range header.
     QByteArray acceptRangesheaderName("Accept-Ranges");
     if (!hasRawHeader(acceptRangesheaderName) || rawHeader(acceptRangesheaderName) == "none")
         return false;
 
     // We only support resuming for byte ranges.
     if (request().hasRawHeader("Range")) {
         QByteArray range = request().rawHeader("Range");
         if (!range.startsWith("bytes="))
             return false;
     }
 
     // If we're using a download buffer then we don't support resuming/migration
     // right now. Too much trouble.
     if (usingZerocopyDownloadBuffer)
         return false;
 
     return true;
 }

◆ checkForRedirect()

void QNetworkAccessHttpBackend::checkForRedirect ( const int statusCode )

private

Definition at line 756 of file qnetworkaccesshttpbackend.cpp.

Referenced by replyDownloadMetaData(), and sendCacheContents().

 {
     switch (statusCode) {
     case 301:                   // Moved Permanently
     case 302:                   // Found
     case 303:                   // See Other
     case 307:                   // Temporary Redirect
         // What do we do about the caching of the HTML note?
         // The response to a 303 MUST NOT be cached, while the response to
         // all of the others is cacheable if the headers indicate it to be
         QByteArray header = rawHeader("location");
         QUrl url = QUrl::fromEncoded(header);
         if (!url.isValid())
             url = QUrl(QLatin1String(header));
         redirectionRequested(url);
     }
 }

◆ closeDownstreamChannel()

void QNetworkAccessHttpBackend::closeDownstreamChannel ( )

virtual

Implements QNetworkAccessBackend.

Definition at line 695 of file qnetworkaccesshttpbackend.cpp.

 {
     // FIXME Maybe we can get rid of this whole architecture part
 }

◆ copyFinished()

void QNetworkAccessHttpBackend::copyFinished ( QIODevice * dev )

virtual

Reimplemented from QNetworkAccessBackend.

Definition at line 994 of file qnetworkaccesshttpbackend.cpp.

 {
     delete dev;
     finished();
 }

◆ downstreamReadyWrite()

void QNetworkAccessHttpBackend::downstreamReadyWrite ( )

virtual

Reimplemented from QNetworkAccessBackend.

Definition at line 700 of file qnetworkaccesshttpbackend.cpp.

 {
     // FIXME Maybe we can get rid of this whole architecture part
 }

◆ emitReadBufferFreed()

void QNetworkAccessHttpBackend::emitReadBufferFreed ( qint64 size )

virtual

Reimplemented from QNetworkAccessBackend.

Definition at line 717 of file qnetworkaccesshttpbackend.cpp.

 {
     emit readBufferFreed(size);
 }

◆ fetchCacheMetaData()

QNetworkCacheMetaData QNetworkAccessHttpBackend::fetchCacheMetaData ( const QNetworkCacheMetaData & metaData ) const

virtual

Reimplemented from QNetworkAccessBackend.

Definition at line 1029 of file qnetworkaccesshttpbackend.cpp.

Referenced by replyDownloadMetaData().

 {
     QNetworkCacheMetaData metaData = oldMetaData;
 
     QNetworkHeadersPrivate cacheHeaders;
     cacheHeaders.setAllRawHeaders(metaData.rawHeaders());
     QNetworkHeadersPrivate::RawHeadersList::ConstIterator it;
 
     QList<QByteArray> newHeaders = rawHeaderList();
     foreach (QByteArray header, newHeaders) {
         QByteArray originalHeader = header;
         header = header.toLower();
         bool hop_by_hop =
             (header == "connection"
              || header == "keep-alive"
              || header == "proxy-authenticate"
              || header == "proxy-authorization"
              || header == "te"
              || header == "trailers"
              || header == "transfer-encoding"
              || header ==  "upgrade");
         if (hop_by_hop)
             continue;
 
         // we are currently not using the date header to determine the expiration time of a page,
         // but only the "Expires", "max-age" and "s-maxage" headers, see
         // QNetworkAccessHttpBackend::validateCache() and below ("metaData.setExpirationDate()").
         if (header == "date")
             continue;
 
         // Don't store Warning 1xx headers
         if (header == "warning") {
             QByteArray v = rawHeader(header);
             if (v.length() == 3
                 && v[0] == '1'
                 && v[1] >= '0' && v[1] <= '9'
                 && v[2] >= '0' && v[2] <= '9')
                 continue;
         }
 
         it = cacheHeaders.findRawHeader(header);
         if (it != cacheHeaders.rawHeaders.constEnd()) {
             // Match the behavior of Firefox and assume Cache-Control: "no-transform"
             if (header == "content-encoding"
                 || header == "content-range"
                 || header == "content-type")
                 continue;
 
             // For MS servers that send "Content-Length: 0" on 304 responses
             // ignore this too
             if (header == "content-length")
                 continue;
         }
 
 #if defined(QNETWORKACCESSHTTPBACKEND_DEBUG)
         QByteArray n = rawHeader(header);
         QByteArray o;
         if (it != cacheHeaders.rawHeaders.constEnd())
             o = (*it).second;
         if (n != o && header != "date") {
             qDebug() << "replacing" << header;
             qDebug() << "new" << n;
             qDebug() << "old" << o;
         }
 #endif
         cacheHeaders.setRawHeader(originalHeader, rawHeader(header));
     }
     metaData.setRawHeaders(cacheHeaders.rawHeaders);
 
     bool checkExpired = true;
 
     QHash<QByteArray, QByteArray> cacheControl;
     it = cacheHeaders.findRawHeader("Cache-Control");
     if (it != cacheHeaders.rawHeaders.constEnd()) {
         cacheControl = parseHttpOptionHeader(it->second);
         QByteArray maxAge = cacheControl.value("max-age");
         if (!maxAge.isEmpty()) {
             checkExpired = false;
             QDateTime dt = QDateTime::currentDateTime();
             dt = dt.addSecs(maxAge.toInt());
             metaData.setExpirationDate(dt);
         }
     }
     if (checkExpired) {
         it = cacheHeaders.findRawHeader("expires");
         if (it != cacheHeaders.rawHeaders.constEnd()) {
             QDateTime expiredDateTime = QNetworkHeadersPrivate::fromHttpDate(it->second);
             metaData.setExpirationDate(expiredDateTime);
         }
     }
 
     it = cacheHeaders.findRawHeader("last-modified");
     if (it != cacheHeaders.rawHeaders.constEnd())
         metaData.setLastModified(QNetworkHeadersPrivate::fromHttpDate(it->second));
 
     bool canDiskCache;
     // only cache GET replies by default, all other replies (POST, PUT, DELETE)
     //  are not cacheable by default (according to RFC 2616 section 9)
     if (httpRequest.operation() == QHttpNetworkRequest::Get) {
 
         canDiskCache = true;
         // 14.32
         // HTTP/1.1 caches SHOULD treat "Pragma: no-cache" as if the client
         // had sent "Cache-Control: no-cache".
         it = cacheHeaders.findRawHeader("pragma");
         if (it != cacheHeaders.rawHeaders.constEnd()
             && it->second == "no-cache")
             canDiskCache = false;
 
         // HTTP/1.1. Check the Cache-Control header
         if (cacheControl.contains("no-cache"))
             canDiskCache = false;
         else if (cacheControl.contains("no-store"))
             canDiskCache = false;
 
     // responses to POST might be cacheable
     } else if (httpRequest.operation() == QHttpNetworkRequest::Post) {
 
         canDiskCache = false;
         // some pages contain "expires:" and "cache-control: no-cache" field,
         // so we only might cache POST requests if we get "cache-control: max-age ..."
         if (cacheControl.contains("max-age"))
             canDiskCache = true;
 
     // responses to PUT and DELETE are not cacheable
     } else {
         canDiskCache = false;
     }
 
     metaData.setSaveToDisk(canDiskCache);
     QNetworkCacheMetaData::AttributesMap attributes;
     if (statusCode != 304) {
         // update the status code
         attributes.insert(QNetworkRequest::HttpStatusCodeAttribute, statusCode);
         attributes.insert(QNetworkRequest::HttpReasonPhraseAttribute, reasonPhrase);
     } else {
         // this is a redirection, keep the attributes intact
         attributes = oldMetaData.attributes();
     }
     metaData.setAttributes(attributes);
     return metaData;
 }

◆ fetchSslConfiguration()

void QNetworkAccessHttpBackend::fetchSslConfiguration ( QSslConfiguration & configuration ) const

virtual

Reimplemented from QNetworkAccessBackend.

Definition at line 1013 of file qnetworkaccesshttpbackend.cpp.

 {
     if (pendingSslConfiguration)
         config = *pendingSslConfiguration;
     else
         config = request().sslConfiguration();
 }

◆ haveUploadData

void QNetworkAccessHttpBackend::haveUploadData	(	QByteArray	dataArray,
		bool	dataAtEnd,
		qint64	dataSize
	)

signal

Referenced by needsResetableUploadData(), postRequest(), and wantUploadDataSlot().

◆ httpAuthenticationRequired

void QNetworkAccessHttpBackend::httpAuthenticationRequired	(	const QHttpNetworkRequest &	request,
		QAuthenticator *	auth
	)

privateslot

Definition at line 875 of file qnetworkaccesshttpbackend.cpp.

Referenced by needsResetableUploadData(), and postRequest().

 {
     authenticationRequired(auth);
 }

◆ httpError

void QNetworkAccessHttpBackend::httpError	(	QNetworkReply::NetworkError	error,
		const QString &	errorString
	)

privateslot

Definition at line 881 of file qnetworkaccesshttpbackend.cpp.

Referenced by needsResetableUploadData(), and postRequest().

 {
 #if defined(QNETWORKACCESSHTTPBACKEND_DEBUG)
     qDebug() << "http error!" << errorCode << errorString;
 #endif
 
     error(errorCode, errorString);
 }

◆ ignoreSslErrors() [1/2]

void QNetworkAccessHttpBackend::ignoreSslErrors ( )

virtual

Reimplemented from QNetworkAccessBackend.

Definition at line 1001 of file qnetworkaccesshttpbackend.cpp.

 {
     pendingIgnoreAllSslErrors = true;
 }

◆ ignoreSslErrors() [2/2]

void QNetworkAccessHttpBackend::ignoreSslErrors ( const QList< QSslError > & errors )

virtual

Reimplemented from QNetworkAccessBackend.

Definition at line 1006 of file qnetworkaccesshttpbackend.cpp.

 {
     // the pending list is set if QNetworkReply::ignoreSslErrors(const QList<QSslError> &errors)
     // is called before QNetworkAccessManager::get() (or post(), etc.)
     pendingIgnoreSslErrorsList = errors;
 }

◆ invalidateCache()

void QNetworkAccessHttpBackend::invalidateCache ( )

private

Definition at line 683 of file qnetworkaccesshttpbackend.cpp.

Referenced by postRequest().

 {
     QAbstractNetworkCache *nc = networkCache();
     if (nc)
         nc->remove(url());
 }

◆ loadFromCacheIfAllowed()

bool QNetworkAccessHttpBackend::loadFromCacheIfAllowed ( QHttpNetworkRequest & httpRequest )

private

Definition at line 223 of file qnetworkaccesshttpbackend.cpp.

Referenced by postRequest().

 {
     QNetworkRequest::CacheLoadControl CacheLoadControlAttribute =
         (QNetworkRequest::CacheLoadControl)request().attribute(QNetworkRequest::CacheLoadControlAttribute, QNetworkRequest::PreferNetwork).toInt();
     if (CacheLoadControlAttribute == QNetworkRequest::AlwaysNetwork) {
         // If the request does not already specify preferred cache-control
         // force reload from the network and tell any caching proxy servers to reload too
         if (!request().rawHeaderList().contains("Cache-Control")) {
             httpRequest.setHeaderField("Cache-Control", "no-cache");
             httpRequest.setHeaderField("Pragma", "no-cache");
         }
         return false;
     }
 
     // The disk cache API does not currently support partial content retrieval.
     // That is why we don't use the disk cache for any such requests.
     if (request().hasRawHeader("Range"))
         return false;
 
     QAbstractNetworkCache *nc = networkCache();
     if (!nc)
         return false;                 // no local cache
 
     QNetworkCacheMetaData metaData = nc->metaData(url());
     if (!metaData.isValid())
         return false;                 // not in cache
 
     if (!metaData.saveToDisk())
         return false;
 
     QNetworkHeadersPrivate cacheHeaders;
     QNetworkHeadersPrivate::RawHeadersList::ConstIterator it;
     cacheHeaders.setAllRawHeaders(metaData.rawHeaders());
 
     it = cacheHeaders.findRawHeader("etag");
     if (it != cacheHeaders.rawHeaders.constEnd())
         httpRequest.setHeaderField("If-None-Match", it->second);
 
     QDateTime lastModified = metaData.lastModified();
     if (lastModified.isValid())
         httpRequest.setHeaderField("If-Modified-Since", QNetworkHeadersPrivate::toHttpDate(lastModified));
 
     it = cacheHeaders.findRawHeader("Cache-Control");
     if (it != cacheHeaders.rawHeaders.constEnd()) {
         QHash<QByteArray, QByteArray> cacheControl = parseHttpOptionHeader(it->second);
         if (cacheControl.contains("must-revalidate"))
             return false;
     }
 
     QDateTime currentDateTime = QDateTime::currentDateTime();
     QDateTime expirationDate = metaData.expirationDate();
 
 #if 0
     /*
      * age_value
      *      is the value of Age: header received by the cache with
      *              this response.
      * date_value
      *      is the value of the origin server's Date: header
      * request_time
      *      is the (local) time when the cache made the request
      *              that resulted in this cached response
      * response_time
      *      is the (local) time when the cache received the
      *              response
      * now
      *      is the current (local) time
      */
     int age_value = 0;
     it = cacheHeaders.findRawHeader("age");
     if (it != cacheHeaders.rawHeaders.constEnd())
         age_value = it->second.toInt();
 
     QDateTime dateHeader;
     int date_value = 0;
     it = cacheHeaders.findRawHeader("date");
     if (it != cacheHeaders.rawHeaders.constEnd()) {
         dateHeader = QNetworkHeadersPrivate::fromHttpDate(it->second);
         date_value = dateHeader.toTime_t();
     }
 
     int now = currentDateTime.toUTC().toTime_t();
     int request_time = now;
     int response_time = now;
 
     // Algorithm from RFC 2616 section 13.2.3
     int apparent_age = qMax(0, response_time - date_value);
     int corrected_received_age = qMax(apparent_age, age_value);
     int response_delay = response_time - request_time;
     int corrected_initial_age = corrected_received_age + response_delay;
     int resident_time = now - response_time;
     int current_age   = corrected_initial_age + resident_time;
 
     // RFC 2616 13.2.4 Expiration Calculations
     if (!expirationDate.isValid()) {
         if (lastModified.isValid()) {
             int diff = currentDateTime.secsTo(lastModified);
             expirationDate = lastModified;
             expirationDate.addSecs(diff / 10);
             if (httpRequest.headerField("Warning").isEmpty()) {
                 QDateTime dt;
                 dt.setTime_t(current_age);
                 if (dt.daysTo(currentDateTime) > 1)
                     httpRequest.setHeaderField("Warning", "113");
             }
         }
     }
 
     // the cache-saving code below sets the expirationDate with date+max_age
     // if "max-age" is present, or to Expires otherwise
     int freshness_lifetime = dateHeader.secsTo(expirationDate);
     bool response_is_fresh = (freshness_lifetime > current_age);
 #else
     bool response_is_fresh = currentDateTime.secsTo(expirationDate) >= 0;
 #endif
 
     if (!response_is_fresh)
         return false;
 
 #if defined(QNETWORKACCESSHTTPBACKEND_DEBUG)
     qDebug() << "response_is_fresh" << CacheLoadControlAttribute;
 #endif
     return sendCacheContents(metaData);
 }

◆ needsResetableUploadData()

bool QNetworkAccessHttpBackend::needsResetableUploadData ( )

inlinevirtual

Reimplemented from QNetworkAccessBackend.

Definition at line 101 of file qnetworkaccesshttpbackend_p.h.

101 { return true; }

◆ open()

void QNetworkAccessHttpBackend::open ( )

virtual

Implements QNetworkAccessBackend.

Definition at line 690 of file qnetworkaccesshttpbackend.cpp.

 {
     postRequest();
 }

◆ postRequest()

void QNetworkAccessHttpBackend::postRequest ( )

private

Definition at line 361 of file qnetworkaccesshttpbackend.cpp.

Referenced by open().

 {
     QThread *thread = 0;
     if (isSynchronous()) {
         // A synchronous HTTP request uses its own thread
         thread = new QThread();
         QObject::connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater()));
         thread->start();
     } else if (!manager->httpThread) {
         // We use the manager-global thread.
         // At some point we could switch to having multiple threads if it makes sense.
         manager->httpThread = new QThread();
         QObject::connect(manager->httpThread, SIGNAL(finished()), manager->httpThread, SLOT(deleteLater()));
         manager->httpThread->start();
 #ifndef QT_NO_NETWORKPROXY
         qRegisterMetaType<QNetworkProxy>("QNetworkProxy");
 #endif
 #ifndef QT_NO_OPENSSL
         qRegisterMetaType<QList<QSslError> >("QList<QSslError>");
         qRegisterMetaType<QSslConfiguration>("QSslConfiguration");
 #endif
         qRegisterMetaType<QList<QPair<QByteArray,QByteArray> > >("QList<QPair<QByteArray,QByteArray> >");
         qRegisterMetaType<QHttpNetworkRequest>("QHttpNetworkRequest");
         qRegisterMetaType<QNetworkReply::NetworkError>("QNetworkReply::NetworkError");
         qRegisterMetaType<QSharedPointer<char> >("QSharedPointer<char>");
 
         thread = manager->httpThread;
     } else {
         // Asynchronous request, thread already exists
         thread = manager->httpThread;
     }
 
     QUrl url = request().url();
     httpRequest.setUrl(url);
 
     bool ssl = url.scheme().toLower() == QLatin1String("https");
     setAttribute(QNetworkRequest::ConnectionEncryptedAttribute, ssl);
     httpRequest.setSsl(ssl);
 
 
 #ifndef QT_NO_NETWORKPROXY
     QNetworkProxy transparentProxy, cacheProxy;
 
     foreach (const QNetworkProxy &p, proxyList()) {
         // use the first proxy that works
         // for non-encrypted connections, any transparent or HTTP proxy
         // for encrypted, only transparent proxies
         if (!ssl
             && (p.capabilities() & QNetworkProxy::CachingCapability)
             && (p.type() == QNetworkProxy::HttpProxy ||
                 p.type() == QNetworkProxy::HttpCachingProxy)) {
             cacheProxy = p;
             transparentProxy = QNetworkProxy::NoProxy;
             break;
         }
         if (p.isTransparentProxy()) {
             transparentProxy = p;
             cacheProxy = QNetworkProxy::NoProxy;
             break;
         }
     }
 
     // check if at least one of the proxies
     if (transparentProxy.type() == QNetworkProxy::DefaultProxy &&
         cacheProxy.type() == QNetworkProxy::DefaultProxy) {
         // unsuitable proxies
         QMetaObject::invokeMethod(this, "error", isSynchronous() ? Qt::DirectConnection : Qt::QueuedConnection,
                                   Q_ARG(QNetworkReply::NetworkError, QNetworkReply::ProxyNotFoundError),
                                   Q_ARG(QString, tr("No suitable proxy found")));
         QMetaObject::invokeMethod(this, "finished", isSynchronous() ? Qt::DirectConnection : Qt::QueuedConnection);
         return;
     }
 #endif
 
 
     bool loadedFromCache = false;
     httpRequest.setPriority(convert(request().priority()));
 
     switch (operation()) {
     case QNetworkAccessManager::GetOperation:
         httpRequest.setOperation(QHttpNetworkRequest::Get);
         loadedFromCache = loadFromCacheIfAllowed(httpRequest);
         break;
 
     case QNetworkAccessManager::HeadOperation:
         httpRequest.setOperation(QHttpNetworkRequest::Head);
         loadedFromCache = loadFromCacheIfAllowed(httpRequest);
         break;
 
     case QNetworkAccessManager::PostOperation:
         invalidateCache();
         httpRequest.setOperation(QHttpNetworkRequest::Post);
         createUploadByteDevice();
         break;
 
     case QNetworkAccessManager::PutOperation:
         invalidateCache();
         httpRequest.setOperation(QHttpNetworkRequest::Put);
         createUploadByteDevice();
         break;
 
     case QNetworkAccessManager::DeleteOperation:
         invalidateCache();
         httpRequest.setOperation(QHttpNetworkRequest::Delete);
         break;
 
     case QNetworkAccessManager::CustomOperation:
         invalidateCache(); // for safety reasons, we don't know what the operation does
         httpRequest.setOperation(QHttpNetworkRequest::Custom);
         createUploadByteDevice();
         httpRequest.setCustomVerb(request().attribute(
                 QNetworkRequest::CustomVerbAttribute).toByteArray());
         break;
 
     default:
         break;                  // can't happen
     }
 
     if (loadedFromCache) {
         // commented this out since it will be called later anyway
         // by copyFinished()
         //QNetworkAccessBackend::finished();
         return;    // no need to send the request! :)
     }
 
     QList<QByteArray> headers = request().rawHeaderList();
     if (resumeOffset != 0) {
         if (headers.contains("Range")) {
             // Need to adjust resume offset for user specified range
 
             headers.removeOne("Range");
 
             // We've already verified that requestRange starts with "bytes=", see canResume.
             QByteArray requestRange = request().rawHeader("Range").mid(6);
 
             int index = requestRange.indexOf('-');
 
             quint64 requestStartOffset = requestRange.left(index).toULongLong();
             quint64 requestEndOffset = requestRange.mid(index + 1).toULongLong();
 
             requestRange = "bytes=" + QByteArray::number(resumeOffset + requestStartOffset) +
                            '-' + QByteArray::number(requestEndOffset);
 
             httpRequest.setHeaderField("Range", requestRange);
         } else {
             httpRequest.setHeaderField("Range", "bytes=" + QByteArray::number(resumeOffset) + '-');
         }
     }
 
     foreach (const QByteArray &header, headers)
         httpRequest.setHeaderField(header, request().rawHeader(header));
 
     if (request().attribute(QNetworkRequest::HttpPipeliningAllowedAttribute).toBool() == true)
         httpRequest.setPipeliningAllowed(true);
 
     if (static_cast<QNetworkRequest::LoadControl>
         (request().attribute(QNetworkRequest::AuthenticationReuseAttribute,
                              QNetworkRequest::Automatic).toInt()) == QNetworkRequest::Manual)
         httpRequest.setWithCredentials(false);
 
 
     // Create the HTTP thread delegate
     QHttpThreadDelegate *delegate = new QHttpThreadDelegate;
 #ifndef QT_NO_BEARERMANAGEMENT
     QVariant v(property("_q_networksession"));
     if (v.isValid())
         delegate->networkSession = qvariant_cast<QSharedPointer<QNetworkSession> >(v);
 #endif
 
     // For the synchronous HTTP, this is the normal way the delegate gets deleted
     // For the asynchronous HTTP this is a safety measure, the delegate deletes itself when HTTP is finished
     connect(thread, SIGNAL(finished()), delegate, SLOT(deleteLater()));
 
     // Set the properties it needs
     delegate->httpRequest = httpRequest;
 #ifndef QT_NO_NETWORKPROXY
     delegate->cacheProxy = cacheProxy;
     delegate->transparentProxy = transparentProxy;
 #endif
     delegate->ssl = ssl;
 #ifndef QT_NO_OPENSSL
     if (ssl)
         delegate->incomingSslConfiguration = request().sslConfiguration();
 #endif
 
     // Do we use synchronous HTTP?
     delegate->synchronous = isSynchronous();
 
     // The authentication manager is used to avoid the BlockingQueuedConnection communication
     // from HTTP thread to user thread in some cases.
     delegate->authenticationManager = manager->authenticationManager;
 
     if (!isSynchronous()) {
         // Tell our zerocopy policy to the delegate
         delegate->downloadBufferMaximumSize =
                 request().attribute(QNetworkRequest::MaximumDownloadBufferSizeAttribute).toLongLong();
 
         // These atomic integers are used for signal compression
         delegate->pendingDownloadData = pendingDownloadDataEmissions;
         delegate->pendingDownloadProgress = pendingDownloadProgressEmissions;
 
         // Connect the signals of the delegate to us
         connect(delegate, SIGNAL(downloadData(QByteArray)),
                 this, SLOT(replyDownloadData(QByteArray)),
                 Qt::QueuedConnection);
         connect(delegate, SIGNAL(downloadFinished()),
                 this, SLOT(replyFinished()),
                 Qt::QueuedConnection);
         connect(delegate, SIGNAL(downloadMetaData(QList<QPair<QByteArray,QByteArray> >,int,QString,bool,QSharedPointer<char>,qint64)),
                 this, SLOT(replyDownloadMetaData(QList<QPair<QByteArray,QByteArray> >,int,QString,bool,QSharedPointer<char>,qint64)),
                 Qt::QueuedConnection);
         connect(delegate, SIGNAL(downloadProgress(qint64,qint64)),
                 this, SLOT(replyDownloadProgressSlot(qint64,qint64)),
                 Qt::QueuedConnection);
         connect(delegate, SIGNAL(error(QNetworkReply::NetworkError,QString)),
                 this, SLOT(httpError(QNetworkReply::NetworkError, const QString)),
                 Qt::QueuedConnection);
 #ifndef QT_NO_OPENSSL
         connect(delegate, SIGNAL(sslConfigurationChanged(QSslConfiguration)),
                 this, SLOT(replySslConfigurationChanged(QSslConfiguration)),
                 Qt::QueuedConnection);
 #endif
         // Those need to report back, therefire BlockingQueuedConnection
         connect(delegate, SIGNAL(authenticationRequired(QHttpNetworkRequest,QAuthenticator*)),
                 this, SLOT(httpAuthenticationRequired(QHttpNetworkRequest,QAuthenticator*)),
                 Qt::BlockingQueuedConnection);
 #ifndef QT_NO_NETWORKPROXY
         connect (delegate, SIGNAL(proxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)),
                  this, SLOT(proxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)),
                  Qt::BlockingQueuedConnection);
 #endif
 #ifndef QT_NO_OPENSSL
         connect(delegate, SIGNAL(sslErrors(QList<QSslError>,bool*,QList<QSslError>*)),
                 this, SLOT(replySslErrors(const QList<QSslError> &, bool *, QList<QSslError> *)),
                 Qt::BlockingQueuedConnection);
 #endif
         // This signal we will use to start the request.
         connect(this, SIGNAL(startHttpRequest()), delegate, SLOT(startRequest()));
         connect(this, SIGNAL(abortHttpRequest()), delegate, SLOT(abortRequest()));
 
         // To throttle the connection.
         QObject::connect(this, SIGNAL(readBufferSizeChanged(qint64)), delegate, SLOT(readBufferSizeChanged(qint64)));
         QObject::connect(this, SIGNAL(readBufferFreed(qint64)), delegate, SLOT(readBufferFreed(qint64)));
 
         if (uploadByteDevice) {
             QNonContiguousByteDeviceThreadForwardImpl *forwardUploadDevice =
                     new QNonContiguousByteDeviceThreadForwardImpl(uploadByteDevice->atEnd(), uploadByteDevice->size());
             if (uploadByteDevice->isResetDisabled())
                 forwardUploadDevice->disableReset();
             forwardUploadDevice->setParent(delegate); // needed to make sure it is moved on moveToThread()
             delegate->httpRequest.setUploadByteDevice(forwardUploadDevice);
 
             // From main thread to user thread:
             QObject::connect(this, SIGNAL(haveUploadData(QByteArray, bool, qint64)),
                              forwardUploadDevice, SLOT(haveDataSlot(QByteArray, bool, qint64)), Qt::QueuedConnection);
             QObject::connect(uploadByteDevice.data(), SIGNAL(readyRead()),
                              forwardUploadDevice, SIGNAL(readyRead()),
                              Qt::QueuedConnection);
 
             // From http thread to user thread:
             QObject::connect(forwardUploadDevice, SIGNAL(wantData(qint64)),
                              this, SLOT(wantUploadDataSlot(qint64)));
             QObject::connect(forwardUploadDevice, SIGNAL(processedData(qint64)),
                              this, SLOT(sentUploadDataSlot(qint64)));
             connect(forwardUploadDevice, SIGNAL(resetData(bool*)),
                     this, SLOT(resetUploadDataSlot(bool*)),
                     Qt::BlockingQueuedConnection); // this is the only one with BlockingQueued!
         }
     } else if (isSynchronous()) {
         connect(this, SIGNAL(startHttpRequestSynchronously()), delegate, SLOT(startRequestSynchronously()), Qt::BlockingQueuedConnection);
 
         if (uploadByteDevice) {
             // For the synchronous HTTP use case the use thread (this one here) is blocked
             // so we cannot use the asynchronous upload architecture.
             // We therefore won't use the QNonContiguousByteDeviceThreadForwardImpl but directly
             // use the uploadByteDevice provided to us by the QNetworkReplyImpl.
             // The code that is in QNetworkReplyImplPrivate::setup() makes sure it is safe to use from a thread
             // since it only wraps a QRingBuffer
             delegate->httpRequest.setUploadByteDevice(uploadByteDevice.data());
         }
     }
 
 
     // Move the delegate to the http thread
     delegate->moveToThread(thread);
     // This call automatically moves the uploadDevice too for the asynchronous case.
 
     // Send an signal to the delegate so it starts working in the other thread
     if (isSynchronous()) {
         emit startHttpRequestSynchronously(); // This one is BlockingQueuedConnection, so it will return when all work is done
 
         if (delegate->incomingErrorCode != QNetworkReply::NoError) {
             replyDownloadMetaData
                     (delegate->incomingHeaders,
                      delegate->incomingStatusCode,
                      delegate->incomingReasonPhrase,
                      delegate->isPipeliningUsed,
                      QSharedPointer<char>(),
                      delegate->incomingContentLength);
             replyDownloadData(delegate->synchronousDownloadData);
             httpError(delegate->incomingErrorCode, delegate->incomingErrorDetail);
         } else {
             replyDownloadMetaData
                     (delegate->incomingHeaders,
                      delegate->incomingStatusCode,
                      delegate->incomingReasonPhrase,
                      delegate->isPipeliningUsed,
                      QSharedPointer<char>(),
                      delegate->incomingContentLength);
             replyDownloadData(delegate->synchronousDownloadData);
         }
 
         // End the thread. It will delete itself from the finished() signal
         thread->quit();
         thread->wait(5000);
 
         finished();
     } else {
         emit startHttpRequest(); // Signal to the HTTP thread and go back to user.
     }
 }

◆ readBufferFreed

void QNetworkAccessHttpBackend::readBufferFreed ( qint64 size )

signal

Referenced by emitReadBufferFreed(), needsResetableUploadData(), and postRequest().

◆ readBufferSizeChanged

void QNetworkAccessHttpBackend::readBufferSizeChanged ( qint64 size )

signal

Referenced by needsResetableUploadData(), postRequest(), and setReadBufferSize().

◆ readFromHttp()

void QNetworkAccessHttpBackend::readFromHttp ( )

private

◆ replyDownloadData

void QNetworkAccessHttpBackend::replyDownloadData ( QByteArray d )

privateslot

Definition at line 722 of file qnetworkaccesshttpbackend.cpp.

Referenced by needsResetableUploadData(), and postRequest().

 {
     int pendingSignals = (int)pendingDownloadDataEmissions->fetchAndAddAcquire(-1) - 1;
 
     if (pendingSignals > 0) {
         // Some more signal emissions to this slot are pending.
         // Instead of writing the downstream data, we wait
         // and do it in the next call we get
         // (signal comppression)
         pendingDownloadData.append(d);
         return;
     }
 
     pendingDownloadData.append(d);
     d.clear();
     // We need to usa a copy for calling writeDownstreamData as we could
     // possibly recurse into this this function when we call
     // appendDownstreamDataSignalEmissions because the user might call
     // processEvents() or spin an event loop when this occur.
     QByteDataBuffer pendingDownloadDataCopy = pendingDownloadData;
     pendingDownloadData.clear();
     writeDownstreamData(pendingDownloadDataCopy);
 }

◆ replyDownloadMetaData

void QNetworkAccessHttpBackend::replyDownloadMetaData	(	QList< QPair< QByteArray, QByteArray > >	hm,
		int	sc,
		QString	rp,
		bool	pu,
		QSharedPointer< char >	db,
		qint64	contentLength
	)

privateslot

Definition at line 775 of file qnetworkaccesshttpbackend.cpp.

Referenced by checkForRedirect(), needsResetableUploadData(), and postRequest().

 {
     statusCode = sc;
     reasonPhrase = rp;
 
     // Download buffer
     if (!db.isNull()) {
         reply->setDownloadBuffer(db, contentLength);
         usingZerocopyDownloadBuffer = true;
     } else {
         usingZerocopyDownloadBuffer = false;
     }
 
     setAttribute(QNetworkRequest::HttpPipeliningWasUsedAttribute, pu);
 
     // reconstruct the HTTP header
     QList<QPair<QByteArray, QByteArray> > headerMap = hm;
     QList<QPair<QByteArray, QByteArray> >::ConstIterator it = headerMap.constBegin(),
                                                         end = headerMap.constEnd();
     QByteArray header;
 
     for (; it != end; ++it) {
         QByteArray value = rawHeader(it->first);
         if (!value.isEmpty()) {
             if (qstricmp(it->first.constData(), "set-cookie") == 0)
                 value += '\n';
             else
                 value += ", ";
         }
         value += it->second;
         setRawHeader(it->first, value);
     }
 
     setAttribute(QNetworkRequest::HttpStatusCodeAttribute, statusCode);
     setAttribute(QNetworkRequest::HttpReasonPhraseAttribute, reasonPhrase);
 
     // is it a redirection?
     checkForRedirect(statusCode);
 
     if (statusCode >= 500 && statusCode < 600) {
         QAbstractNetworkCache *nc = networkCache();
         if (nc) {
             QNetworkCacheMetaData metaData = nc->metaData(url());
             QNetworkHeadersPrivate cacheHeaders;
             cacheHeaders.setAllRawHeaders(metaData.rawHeaders());
             QNetworkHeadersPrivate::RawHeadersList::ConstIterator it;
             it = cacheHeaders.findRawHeader("Cache-Control");
             bool mustReValidate = false;
             if (it != cacheHeaders.rawHeaders.constEnd()) {
                 QHash<QByteArray, QByteArray> cacheControl = parseHttpOptionHeader(it->second);
                 if (cacheControl.contains("must-revalidate"))
                     mustReValidate = true;
             }
             if (!mustReValidate && sendCacheContents(metaData))
                 return;
         }
     }
 
     if (statusCode == 304) {
 #if defined(QNETWORKACCESSHTTPBACKEND_DEBUG)
         qDebug() << "Received a 304 from" << url();
 #endif
         QAbstractNetworkCache *nc = networkCache();
         if (nc) {
             QNetworkCacheMetaData oldMetaData = nc->metaData(url());
             QNetworkCacheMetaData metaData = fetchCacheMetaData(oldMetaData);
             if (oldMetaData != metaData)
                 nc->updateMetaData(metaData);
             if (sendCacheContents(metaData))
                 return;
         }
     }
 
 
     if (statusCode != 304 && statusCode != 303) {
         if (!isCachingEnabled())
             setCachingEnabled(true);
     }
 
     metaDataChanged();
 }

◆ replyDownloadProgressSlot

void QNetworkAccessHttpBackend::replyDownloadProgressSlot	(	qint64	received,
		qint64	total
	)

privateslot

Definition at line 860 of file qnetworkaccesshttpbackend.cpp.

Referenced by needsResetableUploadData(), and postRequest().

 {
     // we can be sure here that there is a download buffer
 
     int pendingSignals = (int)pendingDownloadProgressEmissions->fetchAndAddAcquire(-1) - 1;
     if (pendingSignals > 0) {
         // Let's ignore this signal and look at the next one coming in
         // (signal comppression)
         return;
     }
 
     // Now do the actual notification of new bytes
     writeDownstreamDataDownloadBuffer(received, total);
 }

◆ replyFinished

void QNetworkAccessHttpBackend::replyFinished ( )

privateslot

Definition at line 746 of file qnetworkaccesshttpbackend.cpp.

Referenced by needsResetableUploadData(), and postRequest().

 {
     // We are already loading from cache, we still however
     // got this signal because it was posted already
     if (loadingFromCache)
         return;
 
     finished();
 }

◆ replySslConfigurationChanged

void QNetworkAccessHttpBackend::replySslConfigurationChanged ( const QSslConfiguration & c )

privateslot

Definition at line 904 of file qnetworkaccesshttpbackend.cpp.

Referenced by needsResetableUploadData(), and postRequest().

 {
     // Receiving the used SSL configuration from the HTTP thread
     if (pendingSslConfiguration)
         *pendingSslConfiguration = c;
     else if (!c.isNull())
         pendingSslConfiguration = new QSslConfiguration(c);
 }

◆ replySslErrors

void QNetworkAccessHttpBackend::replySslErrors	(	const QList< QSslError > &	list,
		bool *	ignoreAll,
		QList< QSslError > *	toBeIgnored
	)

privateslot

Definition at line 892 of file qnetworkaccesshttpbackend.cpp.

Referenced by needsResetableUploadData(), and postRequest().

 {
     // Go to generic backend
     sslErrors(list);
     // Check if the callback set any ignore and return this here to http thread
     if (pendingIgnoreAllSslErrors)
         *ignoreAll = true;
     if (!pendingIgnoreSslErrorsList.isEmpty())
         *toBeIgnored = pendingIgnoreSslErrorsList;
 }

◆ resetUploadDataSlot

void QNetworkAccessHttpBackend::resetUploadDataSlot ( bool * r )

privateslot

Definition at line 915 of file qnetworkaccesshttpbackend.cpp.

Referenced by needsResetableUploadData(), and postRequest().

 {
     *r = uploadByteDevice->reset();
 }

◆ sendCacheContents

bool QNetworkAccessHttpBackend::sendCacheContents ( const QNetworkCacheMetaData & metaData )

privateslot

Definition at line 942 of file qnetworkaccesshttpbackend.cpp.

Referenced by loadFromCacheIfAllowed(), needsResetableUploadData(), and replyDownloadMetaData().

 {
     setCachingEnabled(false);
     if (!metaData.isValid())
         return false;
 
     QAbstractNetworkCache *nc = networkCache();
     Q_ASSERT(nc);
     QIODevice *contents = nc->data(url());
     if (!contents) {
 #if defined(QNETWORKACCESSHTTPBACKEND_DEBUG)
         qDebug() << "Can not send cache, the contents are 0" << url();
 #endif
         return false;
     }
     contents->setParent(this);
 
     QNetworkCacheMetaData::AttributesMap attributes = metaData.attributes();
     int status = attributes.value(QNetworkRequest::HttpStatusCodeAttribute).toInt();
     if (status < 100)
         status = 200;           // fake it
 
     setAttribute(QNetworkRequest::HttpStatusCodeAttribute, status);
     setAttribute(QNetworkRequest::HttpReasonPhraseAttribute, attributes.value(QNetworkRequest::HttpReasonPhraseAttribute));
     setAttribute(QNetworkRequest::SourceIsFromCacheAttribute, true);
 
     QNetworkCacheMetaData::RawHeaderList rawHeaders = metaData.rawHeaders();
     QNetworkCacheMetaData::RawHeaderList::ConstIterator it = rawHeaders.constBegin(),
                                                        end = rawHeaders.constEnd();
     for ( ; it != end; ++it)
         setRawHeader(it->first, it->second);
 
     checkForRedirect(status);
 
     // This needs to be emitted in the event loop because it can be reached at
     // the direct code path of qnam.get(...) before the user has a chance
     // to connect any signals.
     QMetaObject::invokeMethod(this, "metaDataChanged", isSynchronous() ? Qt::DirectConnection : Qt::QueuedConnection);
     qRegisterMetaType<QIODevice*>("QIODevice*");
     QMetaObject::invokeMethod(this, "writeDownstreamData", isSynchronous() ? Qt::DirectConnection : Qt::QueuedConnection, Q_ARG(QIODevice*, contents));
 
 
 #if defined(QNETWORKACCESSHTTPBACKEND_DEBUG)
     qDebug() << "Successfully sent cache:" << url() << contents->size() << "bytes";
 #endif
 
     // Set the following flag so we can ignore some signals from HTTP thread
     // that would still come
     loadingFromCache = true;
     return true;
 }

◆ sentUploadDataSlot

void QNetworkAccessHttpBackend::sentUploadDataSlot ( qint64 amount )

privateslot

Definition at line 921 of file qnetworkaccesshttpbackend.cpp.

Referenced by needsResetableUploadData(), and postRequest().

 {
     uploadByteDevice->advanceReadPointer(amount);
 }

◆ setDownstreamLimited()

void QNetworkAccessHttpBackend::setDownstreamLimited ( bool b )

virtual

Reimplemented from QNetworkAccessBackend.

Definition at line 705 of file qnetworkaccesshttpbackend.cpp.

 {
     Q_UNUSED(b);
     // We know that readBuffer maximum size limiting is broken since quite a while.
     // The task to fix this is QTBUG-15065
 }

◆ setReadBufferSize()

void QNetworkAccessHttpBackend::setReadBufferSize ( qint64 size )

virtual

Reimplemented from QNetworkAccessBackend.

Definition at line 712 of file qnetworkaccesshttpbackend.cpp.

 {
     emit readBufferSizeChanged(size);
 }

◆ setResumeOffset()

void QNetworkAccessHttpBackend::setResumeOffset ( quint64 offset )

virtual

Reimplemented from QNetworkAccessBackend.

Definition at line 1198 of file qnetworkaccesshttpbackend.cpp.

Referenced by needsResetableUploadData().

 {
     resumeOffset = offset;
 }

◆ setSslConfiguration()

void QNetworkAccessHttpBackend::setSslConfiguration ( const QSslConfiguration & configuration )

virtual

Reimplemented from QNetworkAccessBackend.

Definition at line 1021 of file qnetworkaccesshttpbackend.cpp.

 {
     // Setting a SSL configuration on a reply is not supported. The user needs to set
     // her/his QSslConfiguration on the QNetworkRequest.
     Q_UNUSED(newconfig);
 }

◆ startHttpRequest

void QNetworkAccessHttpBackend::startHttpRequest ( )

signal

Referenced by needsResetableUploadData(), and postRequest().

◆ startHttpRequestSynchronously

void QNetworkAccessHttpBackend::startHttpRequestSynchronously ( )

signal

Referenced by needsResetableUploadData(), and postRequest().

◆ wantUploadDataSlot

void QNetworkAccessHttpBackend::wantUploadDataSlot ( qint64 maxSize )

privateslot

Definition at line 927 of file qnetworkaccesshttpbackend.cpp.

Referenced by needsResetableUploadData(), and postRequest().

 {
     // call readPointer
     qint64 currentUploadDataLength = 0;
     char *data = const_cast<char*>(uploadByteDevice->readPointer(maxSize, currentUploadDataLength));
     // Let's make a copy of this data
     QByteArray dataArray(data, currentUploadDataLength);
 
     // Communicate back to HTTP thread
     emit haveUploadData(dataArray, uploadByteDevice->atEnd(), uploadByteDevice->size());
 }

Properties

◆ httpRequest

QHttpNetworkRequest QNetworkAccessHttpBackend::httpRequest

private

Definition at line 137 of file qnetworkaccesshttpbackend_p.h.

Referenced by fetchCacheMetaData(), and postRequest().

◆ loadingFromCache

bool QNetworkAccessHttpBackend::loadingFromCache

private

Definition at line 143 of file qnetworkaccesshttpbackend_p.h.

Referenced by replyFinished(), and sendCacheContents().

◆ pendingDownloadData

QByteDataBuffer QNetworkAccessHttpBackend::pendingDownloadData

private

Definition at line 144 of file qnetworkaccesshttpbackend_p.h.

Referenced by replyDownloadData().

◆ pendingDownloadDataEmissions

QSharedPointer<QAtomicInt> QNetworkAccessHttpBackend::pendingDownloadDataEmissions

private

Definition at line 141 of file qnetworkaccesshttpbackend_p.h.

Referenced by postRequest(), and replyDownloadData().

◆ pendingDownloadProgressEmissions

QSharedPointer<QAtomicInt> QNetworkAccessHttpBackend::pendingDownloadProgressEmissions

private

Definition at line 142 of file qnetworkaccesshttpbackend_p.h.

Referenced by postRequest(), and replyDownloadProgressSlot().

◆ pendingIgnoreAllSslErrors

bool QNetworkAccessHttpBackend::pendingIgnoreAllSslErrors

private

Definition at line 149 of file qnetworkaccesshttpbackend_p.h.

Referenced by ignoreSslErrors(), and replySslErrors().

◆ pendingIgnoreSslErrorsList

QList<QSslError> QNetworkAccessHttpBackend::pendingIgnoreSslErrorsList

private

Definition at line 150 of file qnetworkaccesshttpbackend_p.h.

Referenced by ignoreSslErrors(), and replySslErrors().

◆ pendingSslConfiguration

QSslConfiguration* QNetworkAccessHttpBackend::pendingSslConfiguration

private

Definition at line 148 of file qnetworkaccesshttpbackend_p.h.

Referenced by fetchSslConfiguration(), replySslConfigurationChanged(), and ~QNetworkAccessHttpBackend().

◆ reasonPhrase

QString QNetworkAccessHttpBackend::reasonPhrase

private

Definition at line 139 of file qnetworkaccesshttpbackend_p.h.

Referenced by fetchCacheMetaData(), and replyDownloadMetaData().

◆ resumeOffset

quint64 QNetworkAccessHttpBackend::resumeOffset

private

Definition at line 153 of file qnetworkaccesshttpbackend_p.h.

Referenced by postRequest(), and setResumeOffset().

◆ statusCode

int QNetworkAccessHttpBackend::statusCode

private

Definition at line 138 of file qnetworkaccesshttpbackend_p.h.

Referenced by fetchCacheMetaData(), and replyDownloadMetaData().

◆ usingZerocopyDownloadBuffer

bool QNetworkAccessHttpBackend::usingZerocopyDownloadBuffer

private

Definition at line 145 of file qnetworkaccesshttpbackend_p.h.

Referenced by canResume(), and replyDownloadMetaData().

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

/src/network/access/qnetworkaccesshttpbackend_p.h
/src/network/access/qnetworkaccesshttpbackend.cpp

Properties
QHttpNetworkRequest	httpRequest

bool	loadingFromCache

QByteDataBuffer	pendingDownloadData

QSharedPointer< QAtomicInt >	pendingDownloadDataEmissions

QSharedPointer< QAtomicInt >	pendingDownloadProgressEmissions

bool	pendingIgnoreAllSslErrors

QList< QSslError >	pendingIgnoreSslErrorsList

QSslConfiguration *	pendingSslConfiguration

QString	reasonPhrase

quint64	resumeOffset

int	statusCode

bool	usingZerocopyDownloadBuffer

Signals

Public Functions

Private Slots

Private Functions

Properties

Additional Inherited Members

Detailed Description

Constructors and Destructors

◆ QNetworkAccessHttpBackend()

◆ ~QNetworkAccessHttpBackend()

Functions

◆ abortHttpRequest

◆ canResume()

◆ checkForRedirect()

◆ closeDownstreamChannel()

◆ copyFinished()

◆ downstreamReadyWrite()

◆ emitReadBufferFreed()

◆ fetchCacheMetaData()

◆ fetchSslConfiguration()

◆ haveUploadData

◆ httpAuthenticationRequired

◆ httpError

◆ ignoreSslErrors() [1/2]

◆ ignoreSslErrors() [2/2]

◆ invalidateCache()

◆ loadFromCacheIfAllowed()

◆ needsResetableUploadData()

◆ open()

◆ postRequest()

◆ readBufferFreed

◆ readBufferSizeChanged

◆ readFromHttp()

◆ replyDownloadData

◆ replyDownloadMetaData

◆ replyDownloadProgressSlot

◆ replyFinished

◆ replySslConfigurationChanged

◆ replySslErrors

◆ resetUploadDataSlot

◆ sendCacheContents

◆ sentUploadDataSlot

◆ setDownstreamLimited()

◆ setReadBufferSize()

◆ setResumeOffset()

◆ setSslConfiguration()

◆ startHttpRequest

◆ startHttpRequestSynchronously

◆ wantUploadDataSlot

Properties

◆ httpRequest

◆ loadingFromCache

◆ pendingDownloadData

◆ pendingDownloadDataEmissions

◆ pendingDownloadProgressEmissions

◆ pendingIgnoreAllSslErrors

◆ pendingIgnoreSslErrorsList

◆ pendingSslConfiguration

◆ reasonPhrase

◆ resumeOffset

◆ statusCode

◆ usingZerocopyDownloadBuffer