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 <memory>
 
#include "qgis.h"
#include "qgis_core.h"
#include "qgis_sip.h"
#include "qgsnetworkreply.h"
 
#include <QList>
#include <QMutex>
#include <QNetworkAccessManager>
#include <QNetworkCookie>
#include <QNetworkCookieJar>
#include <QNetworkProxy>
#include <QNetworkRequest>
#include <QSemaphore>
#include <QString>
#include <QStringList>
#include <QWaitCondition>
 
using namespace Qt::StringLiterals;
 
class QgsFeedback;
class QgsSettingsEntryInteger;

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 = QNetworkAccessManager::Operation::UnknownOperation;
    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, Qgis::NetworkRequestFlags flags = Qgis::NetworkRequestFlags() );

    static QgsNetworkReplyContent blockingPost( QNetworkRequest &request, const QByteArray &data, const QString &authCfg = QString(), bool forceRefresh = false, QgsFeedback *feedback = nullptr, Qgis::NetworkRequestFlags flags = Qgis::NetworkRequestFlags() );

#ifndef SIP_RUN
    static QString setRequestPreprocessor( const std::function< void( QNetworkRequest *request )> &processor );
#else
    static QString setRequestPreprocessor( SIP_PYCALLABLE / AllowNone / );
    % MethodCode
    PyObject *s = 0;
    QString id;
    Py_XINCREF( a0 );
    Py_BEGIN_ALLOW_THREADS
    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;
    } );
    Py_END_ALLOW_THREADS
 
    s = sipConvertFromNewType( new QString( id ), sipType_QString, 0 );
    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, u"No processor with id %1 exists."_s.arg( *a0 ).toUtf8().constData() );
      sipIsErr = 1;
    }
    % End
#endif

#ifndef SIP_RUN
    static QString setAdvancedRequestPreprocessor( const std::function< void( QNetworkRequest *, int &op, QByteArray *data )> &processor );
#else
    static QString setAdvancedRequestPreprocessor( SIP_PYCALLABLE / AllowNone / );
    % MethodCode
    PyObject *s = 0;
    QString id;
    Py_XINCREF( a0 );
    Py_BEGIN_ALLOW_THREADS
    id = QgsNetworkAccessManager::setAdvancedRequestPreprocessor( [a0]( QNetworkRequest *reqArg, int &op, QByteArray *data )
    {
      SIP_BLOCK_THREADS
 
      PyObject *requestObj = sipConvertFromType( reqArg, sipType_QNetworkRequest, NULL );
      PyObject *postDataObj = sipConvertFromType( new QByteArray( *data ), sipType_QByteArray, Py_None );
 
      PyObject *result = sipCallMethod( NULL, a0, "RiR", requestObj, op, postDataObj );
 
      Py_XDECREF( requestObj );
      Py_XDECREF( postDataObj );
 
      if ( result && PyTuple_Check( result ) && PyTuple_Size( result ) == 2 )
      {
        // Extract modified operation
        PyObject *opObj = PyTuple_GetItem( result, 0 );
        if ( opObj && PyLong_Check( opObj ) )
        {
          op = static_cast<int>( PyLong_AsLong( opObj ) );
        }
        PyObject *dataObj = PyTuple_GetItem( result, 1 );
        if ( dataObj && dataObj != Py_None )
        {
          int dataState;
          int sipIsErr = 0;
          QByteArray *modifiedData = reinterpret_cast<QByteArray *>( sipConvertToType( dataObj, sipType_QByteArray, 0, SIP_NOT_NONE, &dataState, &sipIsErr ) );
          if ( sipIsErr == 0 )
          {
            data->clear();
            data->append( *modifiedData );
            sipReleaseType( modifiedData, sipType_QByteArray, dataState );
          }
        }
      }
 
      Py_XDECREF( result );
      SIP_UNBLOCK_THREADS
    } );
    Py_END_ALLOW_THREADS
 
    s = sipConvertFromNewType( new QString( id ), sipType_QString, 0 );
    return s;
    % End
#endif

#ifndef SIP_RUN
    static bool removeAdvancedRequestPreprocessor( const QString &id );
#else
    static void removeAdvancedRequestPreprocessor( const QString &id );
    % MethodCode
    if ( !QgsNetworkAccessManager::removeAdvancedRequestPreprocessor( *a0 ) )
    {
      PyErr_SetString( PyExc_KeyError, u"No processor with id %1 exists."_s.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;
    QString id;
    Py_XINCREF( a0 );
    Py_BEGIN_ALLOW_THREADS
    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
    } );
 
    Py_END_ALLOW_THREADS
    s = sipConvertFromNewType( new QString( id ), sipType_QString, 0 );
    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, u"No processor with id %1 exists."_s.arg( *a0 ).toUtf8().constData() );
      sipIsErr = 1;
    }
    % End
#endif

    void requestAuthOpenBrowser( const QUrl &url ) const;

    void requestAuthCloseBrowser() const;

    void abortAuthBrowser();
 
 
#ifndef SIP_RUN
    static const QgsSettingsEntryInteger *settingsNetworkTimeout;
#endif

    void preprocessRequest( QNetworkRequest *req ) const;
 
  signals:

    Q_DECL_DEPRECATED void requestAboutToBeCreated( QNetworkAccessManager::Operation operation, const QNetworkRequest &request, QIODevice *device ) SIP_DEPRECATED;

    void requestAboutToBeCreated( QgsNetworkRequestParameters request );

    void requestCreated( const 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 *reply ) SIP_DEPRECATED;

    void requestTimedOut( QNetworkReply *reply );
 
#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 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;
    // Used by worker threads to wait for ssl error handler run in main thread
    QSemaphore mSslErrorHandlerSemaphore;
 
    // 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;
 
    friend class TestQgsNetworkAccessManager;
};
 
#endif // QGSNETWORKACCESSMANAGER_H