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 <QNetworkCookie>
#include <QNetworkCookieJar>
#include <QNetworkProxy>
#include <QNetworkRequest>
#include <QMutex>
#include <QWaitCondition>
#include <QSemaphore>
#include <memory>
 
#include "qgis_core.h"
#include "qgis_sip.h"
#include "qgssettingsentryimpl.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 );
 
#ifndef SIP_RUN
    static QString setRequestPreprocessor( const std::function< void( QNetworkRequest *request )> &processor );
#else
    static QString setRequestPreprocessor( SIP_PYCALLABLE / AllowNone / );
    % MethodCode
    PyObject *s = 0;
    Py_BEGIN_ALLOW_THREADS
    Py_XINCREF( a0 );
    QString id = QgsNetworkAccessManager::setRequestPreprocessor( [a0]( QNetworkRequest *arg )->QString
    {
      QString res;
      SIP_BLOCK_THREADS
      PyObject *s = sipCallMethod( NULL, a0, "D", arg, sipType_QNetworkRequest, NULL );
      int state;
      int sipIsError = 0;
      QString *t1 = reinterpret_cast<QString *>( sipConvertToType( s, sipType_QString, 0, SIP_NOT_NONE, &state, &sipIsError ) );
      if ( sipIsError == 0 )
      {
        res = QString( *t1 );
      }
      sipReleaseType( t1, sipType_QString, state );
      SIP_UNBLOCK_THREADS
      return res;
    } );
 
    s = sipConvertFromNewType( new QString( id ), sipType_QString, 0 );
    Py_END_ALLOW_THREADS
    return s;
    % End
#endif
 
#ifndef SIP_RUN
    static bool removeRequestPreprocessor( const QString &id );
#else
    static void removeRequestPreprocessor( const QString &id );
    % MethodCode
    if ( !QgsNetworkAccessManager::removeRequestPreprocessor( *a0 ) )
    {
      PyErr_SetString( PyExc_KeyError, QStringLiteral( "No processor with id %1 exists." ).arg( *a0 ).toUtf8().constData() );
      sipIsErr = 1;
    }
    % End
#endif
 
#ifndef SIP_RUN
    static QString setReplyPreprocessor( const std::function<void ( const QNetworkRequest &, QNetworkReply * )> &processor );
#else
    static QString setReplyPreprocessor( SIP_PYCALLABLE / AllowNone / );
    % MethodCode
    PyObject *s = 0;
    Py_BEGIN_ALLOW_THREADS
    Py_XINCREF( a0 );
    QString id = QgsNetworkAccessManager::setReplyPreprocessor( [a0]( const QNetworkRequest &request, QNetworkReply *reply )
    {
      SIP_BLOCK_THREADS
      Py_XDECREF( sipCallMethod( NULL, a0, "ND", new QNetworkRequest( request ), sipType_QNetworkRequest, NULL, reply, sipType_QNetworkReply, NULL ) );
      SIP_UNBLOCK_THREADS
    } );
 
    s = sipConvertFromNewType( new QString( id ), sipType_QString, 0 );
    Py_END_ALLOW_THREADS
    return s;
    % End
#endif
 
#ifndef SIP_RUN
    static bool removeReplyPreprocessor( const QString &id );
#else
    static void removeReplyPreprocessor( const QString &id );
    % MethodCode
    if ( !QgsNetworkAccessManager::removeReplyPreprocessor( *a0 ) )
    {
      PyErr_SetString( PyExc_KeyError, QStringLiteral( "No processor with id %1 exists." ).arg( *a0 ).toUtf8().constData() );
      sipIsErr = 1;
    }
    % End
#endif
 
    void requestAuthOpenBrowser( const QUrl &url ) const;
 
    void requestAuthCloseBrowser() const;
 
    void abortAuthBrowser();
 
 
#ifndef SIP_RUN
    static const inline QgsSettingsEntryInteger settingsNetworkTimeout = QgsSettingsEntryInteger( QStringLiteral( "networkTimeout" ), QgsSettings::Prefix::QGIS_NETWORKANDPROXY, 60000, QObject::tr( "Network timeout" ) );
#endif
 
    void preprocessRequest( QNetworkRequest *req ) const;
 
  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();
 
    void cookiesChanged( const QList<QNetworkCookie> &cookies );
 
  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 );
 
    void syncCookies( const QList<QNetworkCookie> &cookies );
 
  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 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;
    // Used by worker threads to wait for authentication handler run in main thread
    QSemaphore mAuthRequestHandlerSemaphore;
};
 
#endif // QGSNETWORKACCESSMANAGER_H