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 <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 );
 
    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 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
% MappedType QList<QSslError::SslError>
{
  % TypeHeaderCode
#include <QList>
  % End
 
  % ConvertFromTypeCode
  // Create the list.
  PyObject *l;
 
  if ( ( l = PyList_New( sipCpp->size() ) ) == NULL )
    return NULL;
 
  // Set the list elements.
  QList<QSslError::SslError>::iterator it = sipCpp->begin();
  for ( int i = 0; it != sipCpp->end(); ++it, ++i )
  {
    PyObject *tobj;
 
    if ( ( tobj = sipConvertFromEnum( *it, sipType_QSslError_SslError ) ) == NULL )
    {
      Py_DECREF( l );
      return NULL;
    }
    PyList_SET_ITEM( l, i, tobj );
  }
 
  return l;
  % End
 
  % ConvertToTypeCode
  // Check the type if that is all that is required.
  if ( sipIsErr == NULL )
    return PyList_Check( sipPy );
 
  QList<QSslError::SslError> *qlist = new QList<QSslError::SslError>;
 
  for ( int i = 0; i < PyList_GET_SIZE( sipPy ); ++i )
  {
    *qlist << ( QSslError::SslError )SIPLong_AsLong( PyList_GET_ITEM( sipPy, i ) );
  }
 
  *sipCppPtr = qlist;
  return sipGetState( sipTransferObj );
  % End
};
#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;
 
    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