git_credentials_prompt.cpp

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
 *
 * 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 3
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 */
 
#include <dialogs/git/git_credentials_prompt.h>
#include <dialogs/git/dialog_git_credentials.h>
#include <dialogs/git/dialog_git_identity.h>
#include <dialogs/git/git_ui_utils.h>
#include <confirm.h>
#include <eda_base_frame.h>
#include <wx/utils.h>
#include <wx/weakref.h>
#include <mutex>
#include <git/git_backend.h>
#include <git/kicad_git_common.h>
#include <git/kicad_git_memory.h>
#include <pgm_base.h>
#include <project.h>
#include <project/project_local_settings.h>
#include <kiplatform/secrets.h>
 
 
bool KIGIT::PromptForCredentials( wxWindow* aParent, KIGIT_COMMON* aCommon, PROJECT* aProject )
{
    // The dialog seeds its picker from this, so a project that already knows its key does
    // not make the user find it again.
    DIALOG_GIT_CREDENTIALS dlg( aParent, aCommon->GetRemote(), aCommon->GetConnType(), aCommon->GetUsername(),
                                aCommon->GetSSHKey() );
 
    if( dlg.ShowModal() != wxID_OK )
        return false;
 
    // An ssh remote's user comes from its address, and the server refuses a different one.
    if( dlg.GetConnType() != KIGIT_COMMON::GIT_CONN_TYPE::GIT_CONN_SSH )
        aCommon->SetUsername( dlg.GetUsername() );
 
    aCommon->SetPassword( dlg.GetPassword() );
 
    if( dlg.GetConnType() == KIGIT_COMMON::GIT_CONN_TYPE::GIT_CONN_SSH && !dlg.GetSSHKey().IsEmpty() )
        aCommon->SetSSHKey( dlg.GetSSHKey() );
 
    if( dlg.SaveCredentials()
        && !KIPLATFORM::SECRETS::StoreSecret( aCommon->GetRemote(), aCommon->GetUsername(), dlg.GetPassword() ) )
    {
        DisplayInfoMessage( aParent, _( "The credentials could not be saved to the system keychain, so they "
                                        "are kept for this session only." ) );
    }
 
    // A correction only in the session would be reverted by the next attach.
    if( aProject )
    {
        if( dlg.GetConnType() != KIGIT_COMMON::GIT_CONN_TYPE::GIT_CONN_SSH )
            aProject->GetLocalSettings().m_GitRepoUsername = dlg.GetUsername();
 
        if( dlg.GetConnType() == KIGIT_COMMON::GIT_CONN_TYPE::GIT_CONN_SSH && !dlg.GetSSHKey().IsEmpty() )
            aProject->GetLocalSettings().m_GitSSHKey = dlg.GetSSHKey();
    }
 
    aCommon->ClearAuthFailure();
    aCommon->TestedTypes() = 0;
    aCommon->ResetNextKey();
    return true;
}
 
 
KIGIT::GIT_IDENTITY KIGIT::ReadGitIdentity( KIGIT_COMMON& aCommon )
{
    GIT_IDENTITY identity;
 
    if( !aCommon.GetRepo() )
        return identity;
 
    GIT_CONFIG_HANDLER handler( &aCommon );
    identity.config.hasName = GetGitBackend()->GetConfigString( &handler, "user.name", identity.config.authorName );
    identity.config.hasEmail = GetGitBackend()->GetConfigString( &handler, "user.email", identity.config.authorEmail );
 
    git_signature* signature = nullptr;
    identity.configured = git_signature_default( &signature, aCommon.GetRepo() ) == GIT_OK;
    GitSignaturePtr signaturePtr( signature );
    return identity;
}
 
 
GitUserConfig KIGIT::ResolveGitIdentity( const GIT_IDENTITY& aIdentity, const COMMON_SETTINGS::GIT& aPreferences,
                                         const wxString& aUserName )
{
    GitUserConfig config = aIdentity.config;
 
    if( !aPreferences.useDefaultAuthor )
    {
        if( config.authorName.IsEmpty() )
            config.authorName = aPreferences.authorName;
 
        if( config.authorEmail.IsEmpty() )
            config.authorEmail = aPreferences.authorEmail;
    }
 
    if( config.authorName.IsEmpty() )
        config.authorName = aUserName;
 
    return config;
}
 
 
namespace
{
 
bool identitySessionCurrent( EDA_BASE_FRAME* aFrame, const std::shared_ptr<KIGIT_COMMON>& aCommon )
{
    return aFrame && !aFrame->IsBeingDeleted() && aCommon && !aCommon->IsShuttingDown() && aCommon->GetRepo()
           && aFrame->Prj().GetGitCommon() == aCommon && Pgm().GetCommonSettings()->m_Git.enableGit
           && !aFrame->Prj().GetLocalSettings().m_GitIntegrationDisabled;
}
 
} // namespace
 
 
bool KIGIT::EditGitIdentity( wxWindow* aParent, EDA_BASE_FRAME* aFrame, const std::shared_ptr<KIGIT_COMMON>& aCommon,
                             const GIT_IDENTITY& aIdentity )
{
    if( !identitySessionCurrent( aFrame, aCommon ) )
        return false;
 
    wxWeakRef<EDA_BASE_FRAME> frame( aFrame );
    wxWeakRef<wxWindow>       parent( aParent );
    GitUserConfig config = ResolveGitIdentity( aIdentity, Pgm().GetCommonSettings()->m_Git, wxGetUserName() );
 
    {
        DIALOG_GIT_IDENTITY dlg( aParent, _( "Set Author" ), config.authorName, config.authorEmail );
 
        if( dlg.ShowModal() != wxID_OK )
            return false;
 
        config.authorName = dlg.GetName();
        config.authorEmail = dlg.GetEmail();
    }
 
    if( !parent || parent->IsBeingDeleted() || !identitySessionCurrent( frame.get(), aCommon ) )
        return false;
 
    bool saved = false;
 
    {
        std::unique_lock<std::mutex> lock = KIGIT::TryLockAction( *aCommon, aParent );
 
        if( !lock.owns_lock() )
            return false;
 
        if( !identitySessionCurrent( frame.get(), aCommon ) )
            return false;
 
        saved = aCommon->SetUserConfig( config.authorName, config.authorEmail );
    }
 
    if( !saved )
    {
        DisplayErrorMessage( aParent, _( "Could not save the name and email to the repository." ) );
        return false;
    }
 
    aCommon->NotifyRefreshListeners();
    return true;
}
 
 
bool KIGIT::EnsureGitIdentity( wxWindow* aParent, EDA_BASE_FRAME* aFrame, const std::shared_ptr<KIGIT_COMMON>& aCommon,
                               const GIT_IDENTITY& aIdentity )
{
    if( !identitySessionCurrent( aFrame, aCommon ) )
        return false;
 
    return aIdentity.configured || EditGitIdentity( aParent, aFrame, aCommon, aIdentity );
}