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 <QHash>
#include <QString>

#ifndef QT_NO_OPENSSL
#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 );

    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 );

  private:
    QString mId;
    QString mName;
    QString mUri;
    QString mMethod;
    int mVersion;

    QgsStringMap mConfigMap;

    static const QString mConfigSep;
    static const QString mConfigKeySep;
    static const QString mConfigListSep;

    static const int mConfigVersion;
};

typedef QHash<QString, QgsAuthMethodConfig> QgsAuthMethodConfigsMap;


#ifndef QT_NO_OPENSSL

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::null,
                                            const QList<QSslCertificate> &caChain = QList<QSslCertificate>() );

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

    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 );

    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; }

  private:
    QgsAuthMethodConfig mConfig;
    QSslCertificate mCert;
    QSslKey mCertKey;
};


class CORE_EXPORT QgsAuthConfigSslServer
{
  public:
    QgsAuthConfigSslServer();

    ~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;

    QSsl::SslProtocol mSslProtocol;
    int mQtVersion;
    QList<QSslError::SslError> mSslIgnoredErrors;
    QSslSocket::PeerVerifyMode mSslPeerVerifyMode;
    int mSslPeerVerifyDepth;
    int mVersion;

    static const QString mConfSep;
};
#endif

#endif // QGSAUTHCONFIG_H