qgsnetworkaccessmanager.h

Go to the documentation of this file.

/***************************************************************************
                          qgsnetworkaccessmanager.h  -  description
                             -------------------
    begin                : 2010-05-08
    copyright            : (C) 2010 by Juergen E. Fischer
    email                : jef at norbit dot de
 ***************************************************************************/
 
/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
 
#ifndef QGSNETWORKACCESSMANAGER_H
#define QGSNETWORKACCESSMANAGER_H
 
#include <QList>
#include "qgsnetworkreply.h"
#include "qgis_sip.h"
#include <QStringList>
#include <QNetworkAccessManager>
#include <QNetworkProxy>
#include <QNetworkRequest>
#include <QMutex>
#include <QWaitCondition>
#include <memory>
 
#include "qgis_core.h"
#include "qgis_sip.h"
#include "qgssettingsentry.h"
 
class QgsFeedback;
 
#ifndef SIP_RUN
#include "qgsconfig.h"
constexpr int sFilePrefixLength = CMAKE_SOURCE_DIR[sizeof( CMAKE_SOURCE_DIR ) - 1] == '/' ? sizeof( CMAKE_SOURCE_DIR ) + 1 : sizeof( CMAKE_SOURCE_DIR );
 
#define QgsSetRequestInitiatorClass(request, _class) request.setAttribute( static_cast< QNetworkRequest::Attribute >( QgsNetworkRequestParameters::AttributeInitiatorClass ), _class ); request.setAttribute( static_cast< QNetworkRequest::Attribute >( QgsNetworkRequestParameters::AttributeInitiatorRequestId ), QString(QString( __FILE__ ).mid( sFilePrefixLength ) + ':' + QString::number( __LINE__ ) + " (" + __FUNCTION__ + ")") );
#define QgsSetRequestInitiatorId(request, str) request.setAttribute( static_cast< QNetworkRequest::Attribute >( QgsNetworkRequestParameters::AttributeInitiatorRequestId ), QString(QString( __FILE__ ).mid( sFilePrefixLength ) + ':' + QString::number( __LINE__ ) + " (" + __FUNCTION__ + "): " + str) );
#endif
 
class CORE_EXPORT QgsNetworkRequestParameters
{
  public:
 
    enum RequestAttributes
    {
      AttributeInitiatorClass = QNetworkRequest::User + 3000, 
      AttributeInitiatorRequestId, 
    };
 
    QgsNetworkRequestParameters() = default;
 
    QgsNetworkRequestParameters( QNetworkAccessManager::Operation operation,
                                 const QNetworkRequest &request,
                                 int requestId,
                                 const QByteArray &content = QByteArray() );
 
    QNetworkAccessManager::Operation operation() const { return mOperation; }
 
    QNetworkRequest request() const { return mRequest; }
 
    QString originatingThreadId() const { return mOriginatingThreadId; }
 
    int requestId() const { return mRequestId; }
 
    QByteArray content() const { return mContent; }
 
    QString initiatorClassName() const { return mInitiatorClass; }
 
    QVariant initiatorRequestId() const { return mInitiatorRequestId; }
 
  private:
 
    QNetworkAccessManager::Operation mOperation;
    QNetworkRequest mRequest;
    QString mOriginatingThreadId;
    int mRequestId = 0;
    QByteArray mContent;
    QString mInitiatorClass;
    QVariant mInitiatorRequestId;
};
 
class QgsNetworkAccessManager;
 
#ifndef SIP_RUN
 
class CORE_EXPORT QgsSslErrorHandler
{
 
  public:
 
    virtual ~QgsSslErrorHandler() = default;
 
    virtual void handleSslErrors( QNetworkReply *reply, const QList<QSslError> &errors );
 
};
 
class CORE_EXPORT QgsNetworkAuthenticationHandler
{
 
  public:
 
    virtual ~QgsNetworkAuthenticationHandler() = default;
 
    virtual void handleAuthRequest( QNetworkReply *reply, QAuthenticator *auth );
 
    virtual void handleAuthRequestOpenBrowser( const QUrl &url );
 
    virtual void handleAuthRequestCloseBrowser();
 
};
#endif
 
 
class CORE_EXPORT QgsNetworkAccessManager : public QNetworkAccessManager
{
    Q_OBJECT
 
  public:
 
    static QgsNetworkAccessManager *instance( Qt::ConnectionType connectionType = Qt::BlockingQueuedConnection );
 
    QgsNetworkAccessManager( QObject *parent = nullptr );
 
#ifndef SIP_RUN
 
    void setSslErrorHandler( std::unique_ptr< QgsSslErrorHandler > handler );
 
    void setAuthHandler( std::unique_ptr< QgsNetworkAuthenticationHandler > handler );
#endif
 
    void insertProxyFactory( QNetworkProxyFactory *factory SIP_TRANSFER );
 
    void removeProxyFactory( QNetworkProxyFactory *factory SIP_TRANSFERBACK );
 
    const QList<QNetworkProxyFactory *> proxyFactories() const;
 
    const QNetworkProxy &fallbackProxy() const;
 
    QStringList excludeList() const;
 
    QStringList noProxyList() const;
 
    void setFallbackProxyAndExcludes( const QNetworkProxy &proxy, const QStringList &excludes, const QStringList &noProxyURLs );
 
    static QString cacheLoadControlName( QNetworkRequest::CacheLoadControl control );
 
    static QNetworkRequest::CacheLoadControl cacheLoadControlFromName( const QString &name );
 
    void setupDefaultProxyAndCache( Qt::ConnectionType connectionType = Qt::BlockingQueuedConnection );
 
#ifndef SIP_RUN
 
    bool cacheDisabled() const { return mCacheDisabled; }
 
    void setCacheDisabled( bool disabled ) { mCacheDisabled = disabled; }
#endif
 
    bool useSystemProxy() const { return mUseSystemProxy; }
 
    static int timeout();
 
    static void setTimeout( int time );
 
    static QgsNetworkReplyContent blockingGet( QNetworkRequest &request, const QString &authCfg = QString(), bool forceRefresh = false, QgsFeedback *feedback = nullptr );
 
    static QgsNetworkReplyContent blockingPost( QNetworkRequest &request, const QByteArray &data, const QString &authCfg = QString(), bool forceRefresh = false, QgsFeedback *feedback = nullptr );
 
    void requestAuthOpenBrowser( const QUrl &url ) const;
 
    void requestAuthCloseBrowser() const;
 
    void abortAuthBrowser();
 
 
#ifndef SIP_RUN
    static const inline QgsSettingsEntryInteger settingsNetworkTimeout = QgsSettingsEntryInteger( QStringLiteral( "/qgis/networkAndProxy/networkTimeout" ), QgsSettings::NoSection, 60000, QObject::tr( "Network timeout" ) );
#endif
 
 
  signals:
 
    Q_DECL_DEPRECATED void requestAboutToBeCreated( QNetworkAccessManager::Operation, const QNetworkRequest &, QIODevice * ) SIP_DEPRECATED;
 
    void requestAboutToBeCreated( QgsNetworkRequestParameters request );
 
    void finished( QgsNetworkReplyContent reply );
 
    void requestTimedOut( QgsNetworkRequestParameters request );
 
    void downloadProgress( int requestId, qint64 bytesReceived, qint64 bytesTotal );
 
    void requestRequiresAuth( int requestId, const QString &realm );
 
    void requestAuthDetailsAdded( int requestId, const QString &realm, const QString &user, const QString &password );
 
#ifndef QT_NO_SSL
 
    void requestEncounteredSslErrors( int requestId, const QList<QSslError> &errors );
 
#ifndef SIP_RUN
    // these signals are for internal use only - it's not safe to connect by external code
    void sslErrorsOccurred( QNetworkReply *, const QList<QSslError> &errors );
    void sslErrorsHandled( QNetworkReply *reply );
#endif
 
#endif
 
    Q_DECL_DEPRECATED void requestCreated( QNetworkReply * ) SIP_DEPRECATED;
 
    void requestTimedOut( QNetworkReply * );
 
#ifndef SIP_RUN
    // these signals are for internal use only - it's not safe to connect by external code
    void authRequestOccurred( QNetworkReply *, QAuthenticator *auth );
    void authRequestHandled( QNetworkReply *reply );
#endif
 
    void authBrowserAborted();
 
  private slots:
    void abortRequest();
 
    void onReplyFinished( QNetworkReply *reply );
 
    void onReplyDownloadProgress( qint64 bytesReceived, qint64 bytesTotal );
#ifndef QT_NO_SSL
    void onReplySslErrors( const QList<QSslError> &errors );
 
    void handleSslErrors( QNetworkReply *reply, const QList<QSslError> &errors );
#endif
 
    void onAuthRequired( QNetworkReply *reply, QAuthenticator *auth );
    void handleAuthRequest( QNetworkReply *reply, QAuthenticator *auth );
 
  protected:
    QNetworkReply *createRequest( QNetworkAccessManager::Operation op, const QNetworkRequest &req, QIODevice *outgoingData = nullptr ) override;
 
  private:
#ifndef QT_NO_SSL
    void unlockAfterSslErrorHandled();
    void afterSslErrorHandled( QNetworkReply *reply );
#endif
 
    void unlockAfterAuthRequestHandled();
    void afterAuthRequestHandled( QNetworkReply *reply );
 
    void pauseTimeout( QNetworkReply *reply );
    void restartTimeout( QNetworkReply *reply );
    static int getRequestId( QNetworkReply *reply );
 
    QList<QNetworkProxyFactory *> mProxyFactories;
    QNetworkProxy mFallbackProxy;
    QStringList mExcludedURLs;
    QStringList mNoProxyURLs;
    bool mUseSystemProxy = false;
    bool mInitialized = false;
    bool mCacheDisabled = false;
    static QgsNetworkAccessManager *sMainNAM;
    // ssl error handler, will be set for main thread ONLY
    std::unique_ptr< QgsSslErrorHandler > mSslErrorHandler;
    // only in use by worker threads, unused in main thread
    QMutex mSslErrorHandlerMutex;
    // only in use by worker threads, unused in main thread
    QWaitCondition mSslErrorWaitCondition;
 
    // auth request handler, will be set for main thread ONLY
    std::unique_ptr< QgsNetworkAuthenticationHandler > mAuthHandler;
    // only in use by worker threads, unused in main thread
    QMutex mAuthRequestHandlerMutex;
    // only in use by worker threads, unused in main thread
    QWaitCondition mAuthRequestWaitCondition;
 
};
 
#endif // QGSNETWORKACCESSMANAGER_H