qgsauthconfig.h

Go to the documentation of this file.

/***************************************************************************
    qgsauthconfig.h
    ---------------------
    begin                : October 5, 2014
    copyright            : (C) 2014 by Boundless Spatial, Inc. USA
    author               : Larry Shaffer
    email                : lshaffer at boundlessgeo dot com
 ***************************************************************************
 *                                                                         *
 *   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 QGSAUTHCONFIG_H
#define QGSAUTHCONFIG_H
 
#include "qgis_core.h"
#include "qgis_sip.h"
 
#include <QDomDocument>
#include <QDomElement>
#include <QHash>
#include <QString>
 
#ifndef QT_NO_SSL
#include <QSslCertificate>
#include <QSslKey>
#include <QSslError>
#include <QSslSocket>
#endif
 
#include "qgis.h"
 

class CORE_EXPORT QgsAuthMethodConfig
{
  public:

    QgsAuthMethodConfig( const QString &method = QString(), int version = 0 );
 
    // TODO c++20 - replace with = default
 
    bool operator==( const QgsAuthMethodConfig &other ) const;
    bool operator!=( const QgsAuthMethodConfig &other ) const;

    const QString id() const { return mId; }
    void setId( const QString &id ) { mId = id; }

    const QString name() const { return mName; }
    void setName( const QString &name ) { mName = name; }

    const QString uri() const { return mUri; }
    void setUri( const QString &uri ) { mUri = uri; }

    QString method() const { return mMethod; }
    void setMethod( const QString &method ) { mMethod = method; }

    int version() const { return mVersion; }
    void setVersion( int version ) { mVersion = version; }

    bool isValid( bool validateid = false ) const;

    const QString configString() const;

    void loadConfigString( const QString &configstr );

    QgsStringMap configMap() const { return mConfigMap; }

    void setConfigMap( const QgsStringMap &map ) { mConfigMap = map; }

    void setConfig( const QString &key, const QString &value );

    void setConfigList( const QString &key, const QStringList &value );

    int removeConfig( const QString &key );

    QString config( const QString &key, const QString &defaultvalue = QString() ) const;

    QStringList configList( const QString &key ) const;

    bool hasConfig( const QString &key ) const;

    void clearConfigMap() { mConfigMap.clear(); }

    static bool uriToResource( const QString &accessurl, QString *resource, bool withpath = false );

    bool writeXml( QDomElement &parentElement, QDomDocument &document );

    bool readXml( const QDomElement &element );
 
  private:
    QString mId;
    QString mName;
    QString mUri;
    QString mMethod;
    int mVersion;
 
    QgsStringMap mConfigMap;
 
    static const QString CONFIG_SEP;
    static const QString CONFIG_KEY_SEP;
    static const QString CONFIG_LIST_SEP;
 
    static const int CONFIG_VERSION;
};
 
typedef QHash<QString, QgsAuthMethodConfig> QgsAuthMethodConfigsMap;
 
 
#ifndef QT_NO_SSL

class CORE_EXPORT QgsPkiBundle
{
  public:

    QgsPkiBundle( const QSslCertificate &clientCert = QSslCertificate(),
                  const QSslKey &clientKey = QSslKey(),
                  const QList<QSslCertificate> &caChain = QList<QSslCertificate>() );

    static const QgsPkiBundle fromPemPaths( const QString &certPath,
                                            const QString &keyPath,
                                            const QString &keyPass = QString(),
                                            const QList<QSslCertificate> &caChain = QList<QSslCertificate>() );

    static const QgsPkiBundle fromPkcs12Paths( const QString &bundlepath,
        const QString &bundlepass = QString() );

    bool isNull() const;

    bool isValid() const;

    const QString certId() const;

    const QSslCertificate clientCert() const { return mCert; }
    void setClientCert( const QSslCertificate &cert );

    const QSslKey clientKey() const { return mCertKey; }
    void setClientKey( const QSslKey &certkey );

    const QList<QSslCertificate> caChain() const { return mCaChain; }
    void setCaChain( const QList<QSslCertificate> &cachain ) { mCaChain = cachain; }
 
  private:
    QSslCertificate mCert;
    QSslKey mCertKey;
    QList<QSslCertificate> mCaChain;
};
 

class CORE_EXPORT QgsPkiConfigBundle
{
  public:

    QgsPkiConfigBundle( const QgsAuthMethodConfig &config,
                        const QSslCertificate &cert,
                        const QSslKey &certkey,
                        const QList<QSslCertificate> &cachain = QList<QSslCertificate>( ) );

    bool isValid();

    const QgsAuthMethodConfig config() const { return mConfig; }

    void setConfig( const QgsAuthMethodConfig &config ) { mConfig = config; }

    const QSslCertificate clientCert() const { return mCert; }

    void setClientCert( const QSslCertificate &cert ) { mCert = cert; }

    const QSslKey clientCertKey() const { return mCertKey; }

    void setClientCertKey( const QSslKey &certkey ) { mCertKey = certkey; }

    QList<QSslCertificate> caChain() const { return mCaChain; }

    void setCaChain( const QList<QSslCertificate> &caChain ) { mCaChain = caChain; }
 
  private:
    QgsAuthMethodConfig mConfig;
    QSslCertificate mCert;
    QSslKey mCertKey;
    QList<QSslCertificate> mCaChain;
};
 
#ifdef SIP_RUN // should not be required, but mingw workflow needs it..
SIP_INSERT_QLIST_ENUM_CONVERSION_CODE( QSslError::SslError, "<QSslError>" );
#endif

class CORE_EXPORT QgsAuthConfigSslServer
{
  public:
    QgsAuthConfigSslServer();

    const QSslCertificate sslCertificate() const { return mSslCert; }
    void setSslCertificate( const QSslCertificate &cert ) { mSslCert = cert; }

    const QString sslHostPort() const  { return mSslHostPort; }
    void setSslHostPort( const QString &hostport ) { mSslHostPort = hostport; }

    QSsl::SslProtocol sslProtocol() const { return mSslProtocol; }
    void setSslProtocol( QSsl::SslProtocol protocol ) { mSslProtocol = protocol; }

    const QList<QSslError> sslIgnoredErrors() const;
    const QList<QSslError::SslError> sslIgnoredErrorEnums() const { return mSslIgnoredErrors; }
    void setSslIgnoredErrorEnums( const QList<QSslError::SslError> &errors ) { mSslIgnoredErrors = errors; }

    QSslSocket::PeerVerifyMode sslPeerVerifyMode() const { return mSslPeerVerifyMode; }
    void setSslPeerVerifyMode( QSslSocket::PeerVerifyMode mode ) { mSslPeerVerifyMode = mode; }

    int sslPeerVerifyDepth() const { return mSslPeerVerifyDepth; }

    void setSslPeerVerifyDepth( int depth ) { mSslPeerVerifyDepth = depth; }

    int version() const { return mVersion; }
    void setVersion( int version ) { mVersion = version; }

    int qtVersion() const { return mQtVersion; }
    void setQtVersion( int version ) { mQtVersion = version; }

    const QString configString() const;
    void loadConfigString( const QString &config = QString() );

    bool isNull() const;
 
  private:
 
    QString mSslHostPort;
    QSslCertificate mSslCert;
 
    static QSsl::SslProtocol decodeSslProtocol( const QString &protocol );
    static QString encodeSslProtocol( QSsl::SslProtocol protocol );
 
    QSsl::SslProtocol mSslProtocol;
    int mQtVersion;
    QList<QSslError::SslError> mSslIgnoredErrors;
    QSslSocket::PeerVerifyMode mSslPeerVerifyMode = QSslSocket::VerifyPeer;
    int mSslPeerVerifyDepth = 0;
    int mVersion = 1;
 
    static const QString CONF_SEP;
};
#endif
 
#endif // QGSAUTHCONFIG_H