qgscredentialdialog.cpp

Go to the documentation of this file.

/***************************************************************************
                          qgscredentialdialog.cpp  -  description
                             -------------------
    begin                : February 2010
    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.                                   *
 *                                                                         *
 ***************************************************************************/
 
#include "qgscredentialdialog.h"
 
#include "qgsapplication.h"
#include "qgsauthmanager.h"
#include "qgsdatasourceuri.h"
#include "qgsgui.h"
#include "qgslogger.h"
 
#include <QGlobalStatic>
#include <QMenu>
#include <QPushButton>
#include <QString>
#include <QThread>
#include <QTimer>
#include <QToolButton>
 
#include "moc_qgscredentialdialog.cpp"
 
using namespace Qt::StringLiterals;
 
QMutex QgsCredentialDialog::sIgnoredConnectionsCacheMutex;
typedef QSet<QString> IgnoredConnectionsSet;

Q_GLOBAL_STATIC( IgnoredConnectionsSet, sIgnoredConnectionsCache );
 
 
static QString invalidStyle_( const QString &selector = u"QLineEdit"_s )
{
  return u"%1{color: rgb(200, 0, 0);}"_s.arg( selector );
}
 
QgsCredentialDialog::QgsCredentialDialog( QWidget *parent, Qt::WindowFlags fl )
  : QDialog( parent, fl )
 
{
  setupUi( this );
  QgsGui::enableAutoGeometryRestore( this );
 
  connect( leMasterPass, &QgsPasswordLineEdit::textChanged, this, &QgsCredentialDialog::leMasterPass_textChanged );
  connect( leMasterPassVerify, &QgsPasswordLineEdit::textChanged, this, &QgsCredentialDialog::leMasterPassVerify_textChanged );
  connect( chkbxEraseAuthDb, &QCheckBox::toggled, this, &QgsCredentialDialog::chkbxEraseAuthDb_toggled );
  setInstance( this );
  connect( this, &QgsCredentialDialog::credentialsRequested, this, &QgsCredentialDialog::requestCredentials, Qt::BlockingQueuedConnection );
  connect( this, &QgsCredentialDialog::credentialsRequestedMasterPassword, this, &QgsCredentialDialog::requestCredentialsMasterPassword, Qt::BlockingQueuedConnection );
 
  // Setup ignore button
  mIgnoreButton->setToolTip( tr( "All requests for this connection will be automatically rejected" ) );
  QMenu *menu = new QMenu( mIgnoreButton );
  QAction *ignoreTemporarily = new QAction( tr( "Ignore for 10 Seconds" ), menu );
  ignoreTemporarily->setToolTip( tr( "All requests for this connection will be automatically rejected for 10 seconds" ) );
  QAction *ignoreForSession = new QAction( tr( "Ignore for Session" ), menu );
  ignoreForSession->setToolTip( tr( "All requests for this connection will be automatically rejected for the duration of the current session" ) );
  menu->addAction( ignoreTemporarily );
  menu->addAction( ignoreForSession );
  connect( ignoreTemporarily, &QAction::triggered, this, [this, ignoreTemporarily] {
    mIgnoreMode = IgnoreTemporarily;
    mIgnoreButton->setText( ignoreTemporarily->text() );
    mIgnoreButton->setToolTip( ignoreTemporarily->toolTip() );
  } );
  connect( ignoreForSession, &QAction::triggered, this, [this, ignoreForSession] {
    mIgnoreMode = IgnoreForSession;
    mIgnoreButton->setText( ignoreForSession->text() );
    mIgnoreButton->setToolTip( ignoreForSession->toolTip() );
  } );
  mIgnoreButton->setText( mIgnoreMode == IgnoreTemporarily ? ignoreTemporarily->text() : ignoreForSession->text() );
  mIgnoreButton->setToolTip( mIgnoreMode == IgnoreTemporarily ? ignoreTemporarily->toolTip() : ignoreForSession->toolTip() );
  mIgnoreButton->setMenu( menu );
  mIgnoreButton->setMaximumHeight( mOkButton->sizeHint().height() );
 
  // Connect ok and cancel buttons
  connect( mOkButton, &QPushButton::clicked, this, &QgsCredentialDialog::accept );
  connect( mCancelButton, &QPushButton::clicked, this, &QgsCredentialDialog::reject );
 
  // Keep a cache of ignored connections, and ignore them for 10 seconds.
  connect( mIgnoreButton, &QPushButton::clicked, this, [this]( bool ) {
    const QString realm { mRealm };
    {
      const QMutexLocker locker( &sIgnoredConnectionsCacheMutex );
      // Insert the realm in the cache of ignored connections
      sIgnoredConnectionsCache->insert( realm );
    }
    if ( mIgnoreMode == IgnoreTemporarily )
    {
      QTimer::singleShot( 10000, nullptr, [realm]() {
        QgsDebugMsgLevel( u"Removing ignored connection from cache: %1"_s.arg( realm ), 4 );
        const QMutexLocker locker( &sIgnoredConnectionsCacheMutex );
        sIgnoredConnectionsCache->remove( realm );
      } );
    }
    accept();
  } );
 
  leMasterPass->setPlaceholderText( tr( "Required" ) );
  chkbxPasswordHelperEnable->setText( tr( "Store/update the master password in your %1" )
                                        .arg( QgsAuthManager::passwordHelperDisplayName() ) );
  leUsername->setFocus();
}
 
bool QgsCredentialDialog::request( const QString &realm, QString &username, QString &password, const QString &message )
{
  bool ok;
  if ( qApp->thread() != QThread::currentThread() )
  {
    QgsDebugMsgLevel( u"emitting signal"_s, 2 );
    emit credentialsRequested( realm, &username, &password, message, &ok );
    QgsDebugMsgLevel( u"signal returned %1 (username=%2)"_s.arg( ok ? "true" : "false", username ), 2 );
  }
  else
  {
    requestCredentials( realm, &username, &password, message, &ok );
  }
  return ok;
}
 
void QgsCredentialDialog::requestCredentials( const QString &realm, QString *username, QString *password, const QString &message, bool *ok )
{
  Q_ASSERT( qApp->thread() == thread() && thread() == QThread::currentThread() );
  QgsDebugMsgLevel( u"Entering."_s, 4 );
  {
    const QMutexLocker locker( &sIgnoredConnectionsCacheMutex );
    if ( sIgnoredConnectionsCache->contains( realm ) )
    {
      QgsDebugMsgLevel( u"Skipping ignored connection: "_s + realm, 2 );
      *ok = false;
      return;
    }
  }
  stackedWidget->setCurrentIndex( 0 );
  mIgnoreButton->show();
  chkbxPasswordHelperEnable->setChecked( QgsApplication::authManager()->passwordHelperEnabled() );
  labelRealm->setText( QgsDataSourceUri::removePassword( realm, true ) );
  mRealm = realm;
  leUsername->setText( *username );
  lePassword->setText( *password );
  labelMessage->setText( message );
  labelMessage->setHidden( message.isEmpty() );
 
  if ( leUsername->text().isEmpty() )
    leUsername->setFocus();
  else
    lePassword->setFocus();
 
  QWidget *activeWindow = qApp->activeWindow();
 
  QApplication::setOverrideCursor( Qt::ArrowCursor );
 
  QgsDebugMsgLevel( u"exec()"_s, 4 );
  *ok = exec() == QDialog::Accepted;
  QgsDebugMsgLevel( u"exec(): %1"_s.arg( *ok ? "true" : "false" ), 4 );
 
  QApplication::restoreOverrideCursor();
 
  if ( activeWindow )
    activeWindow->raise();
 
  if ( *ok )
  {
    *username = leUsername->text();
    *password = lePassword->text();
  }
}
 
bool QgsCredentialDialog::requestMasterPassword( QString &password, bool stored )
{
  bool ok;
  if ( qApp->thread() != QThread::currentThread() )
  {
    QgsDebugMsgLevel( u"emitting signal"_s, 4 );
    emit credentialsRequestedMasterPassword( &password, stored, &ok );
  }
  else
  {
    requestCredentialsMasterPassword( &password, stored, &ok );
  }
  return ok;
}
 
void QgsCredentialDialog::requestCredentialsMasterPassword( QString *password, bool stored, bool *ok )
{
  QgsDebugMsgLevel( u"Entering."_s, 4 );
  stackedWidget->setCurrentIndex( 1 );
 
  mIgnoreButton->hide();
  leMasterPass->setFocus();
 
  const QString titletxt( stored ? tr( "Enter CURRENT master authentication password" ) : tr( "Set NEW master authentication password" ) );
  lblPasswordTitle->setText( titletxt );
 
  chkbxPasswordHelperEnable->setChecked( QgsApplication::authManager()->passwordHelperEnabled() );
 
  leMasterPassVerify->setVisible( !stored );
  lblDontForget->setVisible( !stored );
 
  QApplication::setOverrideCursor( Qt::ArrowCursor );
 
  grpbxPassAttempts->setVisible( false );
  int passfailed = 0;
  while ( true )
  {
    mOkButton->setEnabled( false );
    // TODO: have the number of attempted passwords configurable in auth settings?
    if ( passfailed >= 3 )
    {
      lblSavedForSession->setVisible( false );
      grpbxPassAttempts->setTitle( tr( "Password attempts: %1" ).arg( passfailed ) );
      grpbxPassAttempts->setVisible( true );
    }
 
    // resize vertically to fit contents
    QSize s = sizeHint();
    s.setWidth( width() );
    resize( s );
 
    QgsDebugMsgLevel( u"exec()"_s, 4 );
    *ok = exec() == QDialog::Accepted;
    QgsDebugMsgLevel( u"exec(): %1"_s.arg( *ok ? "true" : "false" ), 4 );
 
    if ( *ok )
    {
      bool passok = !leMasterPass->text().isEmpty();
      if ( passok && stored && !chkbxEraseAuthDb->isChecked() )
      {
        passok = QgsApplication::authManager()->verifyMasterPassword( leMasterPass->text() );
      }
 
      if ( passok && !stored )
      {
        passok = ( leMasterPass->text() == leMasterPassVerify->text() );
      }
 
      if ( passok || chkbxEraseAuthDb->isChecked() )
      {
        if ( stored && chkbxEraseAuthDb->isChecked() )
        {
          QgsApplication::authManager()->setScheduledAuthDatabaseErase( true );
        }
        else
        {
          *password = leMasterPass->text();
          // Let's store user's preferences to use the password helper
          if ( chkbxPasswordHelperEnable->isChecked() != QgsApplication::authManager()->passwordHelperEnabled() )
          {
            QgsApplication::authManager()->setPasswordHelperEnabled( chkbxPasswordHelperEnable->isChecked() );
          }
        }
        break;
      }
      else
      {
        if ( stored )
          ++passfailed;
 
        leMasterPass->setStyleSheet( invalidStyle_() );
        if ( leMasterPassVerify->isVisible() )
        {
          leMasterPassVerify->setStyleSheet( invalidStyle_() );
        }
      }
    }
    else
    {
      break;
    }
 
    if ( passfailed >= 5 )
    {
      break;
    }
  }
 
  // don't leave master password in singleton's text field, or the ability to show it
  leMasterPass->clear();
  leMasterPassVerify->clear();
 
  chkbxEraseAuthDb->setChecked( false );
  lblSavedForSession->setVisible( true );
 
  // re-enable OK button or non-master-password requests will be blocked
  // needs to come after leMasterPass->clear() or textChanged auto-slot with disable it again
  mOkButton->setEnabled( true );
 
  QApplication::restoreOverrideCursor();
 
  if ( passfailed >= 5 )
  {
    close();
  }
}
 
void QgsCredentialDialog::leMasterPass_textChanged( const QString &pass )
{
  leMasterPass->setStyleSheet( QString() );
  bool passok = !pass.isEmpty(); // regardless of new or comparing existing, empty password disallowed
  if ( leMasterPassVerify->isVisible() )
  {
    leMasterPassVerify->setStyleSheet( QString() );
    passok = passok && ( leMasterPass->text() == leMasterPassVerify->text() );
  }
  mOkButton->setEnabled( passok );
 
  if ( leMasterPassVerify->isVisible() && !passok )
  {
    leMasterPass->setStyleSheet( invalidStyle_() );
    leMasterPassVerify->setStyleSheet( invalidStyle_() );
  }
}
 
void QgsCredentialDialog::leMasterPassVerify_textChanged( const QString &pass )
{
  if ( leMasterPassVerify->isVisible() )
  {
    leMasterPass->setStyleSheet( QString() );
    leMasterPassVerify->setStyleSheet( QString() );
 
    // empty password disallowed
    const bool passok = !pass.isEmpty() && ( leMasterPass->text() == leMasterPassVerify->text() );
    mOkButton->setEnabled( passok );
    if ( !passok )
    {
      leMasterPass->setStyleSheet( invalidStyle_() );
      leMasterPassVerify->setStyleSheet( invalidStyle_() );
    }
  }
}
 
void QgsCredentialDialog::chkbxEraseAuthDb_toggled( bool checked )
{
  if ( checked )
    mOkButton->setEnabled( true );
}