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