lockfile.h

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 2
 * 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/>.
 */
 
#pragma once
 
#include <wx/wx.h>
#include <wx/filefn.h>
#include <wx/log.h>
#include <wx/filename.h>
#include <json_common.h>
#include <kiplatform/environment.h>
#include <kiplatform/io.h>
#include <wildcards_and_files_ext.h>
 
#include <cstdint>
#include <random>
#include <string>

static const wxChar* traceLockFile = wxT( "KICAD_LOCKING" );

class LOCKFILE
{
public:
    LOCKFILE( const wxString &filename, bool aRemoveOnRelease = true ) :
            m_removeOnRelease( aRemoveOnRelease )
    {
        if( filename.IsEmpty() )
            return;
 
        wxLogTrace( traceLockFile, "Trying to lock %s", filename );
        m_lockFilename = LockPathFor( filename );
 
        if( !wxFileName( m_lockFilename ).IsDirWritable() )
        {
            wxLogTrace( traceLockFile, "File is not writable: %s", filename );
            m_status = true;
            m_removeOnRelease = false;
            return;
        }
 
        bool created = false;
        KIPLATFORM::IO::FILE_LOCK::STATE state = m_lock.Acquire( m_lockFilename, created );
 
        if( !m_lock.IsOpen() )
        {
            wxLogTrace( traceLockFile, "Could not open a lock file for %s", filename );
            return;
        }
 
        // Creating the file does not make the lock ours, since another process can take the lock
        // between our create and our own attempt.  Exclusive creation decides only where the
        // filesystem cannot lock at all.
        if( created && state != KIPLATFORM::IO::FILE_LOCK::STATE::BUSY )
        {
            claim();
            wxLogTrace( traceLockFile, "Locked %s", filename );
            return;
        }
 
        readOwner();
 
        // Whoever wrote this lock holds it until their process dies, so a lock we can take is
        // one nobody is using. 
        if( state == KIPLATFORM::IO::FILE_LOCK::STATE::HELD
            && ( IsLockedByMe() || KIPLATFORM::ENV::IsRemovablePath( m_lockFilename ) ) )
        {
            claim();
            wxLogTrace( traceLockFile, "Reclaimed the abandoned lock on %s", filename );
            return;
        }
 
        wxLogTrace( traceLockFile, "Existing Lock for %s", filename );
    }

    static LOCKFILE Inspect( const wxString& aFilename )
    {
        LOCKFILE probe;
        bool     heldByAnother = false;
 
        if( !aFilename.IsEmpty() )
        {
            probe.m_lockFilename = LockPathFor( aFilename );
 
            if( probe.m_lock.OpenForInspect( probe.m_lockFilename, heldByAnother ) )
                probe.readOwner();
        }
 
        probe.m_status = !heldByAnother;
 
        return probe;
    }

    static wxString LockPathFor( const wxString& aFilename )
    {
        wxFileName fn( aFilename );
        fn.SetName( FILEEXT::LockFilePrefix + fn.GetName() );
        fn.SetExt( fn.GetExt() + '.' + FILEEXT::LockFileExtension );
 
        return fn.GetFullPath();
    }
 
    LOCKFILE( LOCKFILE&& other ) noexcept :
            m_lockFilename( std::move( other.m_lockFilename ) ),
            m_username( std::move( other.m_username ) ),
            m_hostname( std::move( other.m_hostname ) ),
            m_token( std::move( other.m_token ) ),
            m_lock( std::move( other.m_lock ) ),
            m_owned( other.m_owned ),
            m_status( other.m_status ),
            m_removeOnRelease( other.m_removeOnRelease )
    {
        // Disable unlock in the moved-from object
        other.m_owned = false;
    }
 
    ~LOCKFILE()
    {
        UnlockFile();
    }

    void UnlockFile()
    {
        wxLogTrace( traceLockFile, "Unlocking %s", m_lockFilename );
 
        // Remove the file before dropping the lock, so that the window in which another
        // process could adopt a lock we are abandoning never opens
        if( m_owned && stillOwnLock() )
        {
            if( m_removeOnRelease )
                wxRemoveFile( m_lockFilename );
 
            m_owned = false;
            m_status = false;
        }
 
        m_lock.Release();
    }

    bool OverrideLock( bool aRemoveOnRelease = true )
    {
        wxLogTrace( traceLockFile, "Overriding lock on %s", m_lockFilename );
 
        if( !m_owned && m_lock.IsOpen() )
            claim();
 
        m_removeOnRelease = aRemoveOnRelease;
 
        return m_status;
    }
 
    bool IsLockedByMe()
    {
        // Empty owner means the lock file could not be parsed (e.g. partial cloud sync).
        // We cannot prove another user owns it, so treat it as reclaimable.
        if( m_username.IsEmpty() && m_hostname.IsEmpty() )
            return true;
 
        return m_username == wxGetUserId() && m_hostname == wxGetHostName();
    }

    wxString GetUsername() { return m_username; }

    wxString GetHostname() { return m_hostname; }
 
    bool Locked() const { return m_owned; }
 
    bool Valid() const { return m_status; }
 
private:
    // Only Inspect() builds a lock that holds nothing
    LOCKFILE() = default;
 
    wxString m_lockFilename;
    wxString m_username;
    wxString m_hostname;
    wxString m_token;
    KIPLATFORM::IO::FILE_LOCK m_lock;
    bool m_owned = false;
    bool m_status = false;
    bool m_removeOnRelease = false;

    static wxString newToken()
    {
        std::random_device rd;
 
        uint64_t high = ( static_cast<uint64_t>( rd() ) << 32 ) | rd();
        uint64_t low = ( static_cast<uint64_t>( rd() ) << 32 ) | rd();
 
        return wxString::Format( wxS( "%016llx%016llx" ),
                                 static_cast<unsigned long long>( high ),
                                 static_cast<unsigned long long>( low ) );
    }
 
    void claim()
    {
        m_username = wxGetUserId();
        m_hostname = wxGetHostName();
        m_token = newToken();
 
        nlohmann::json j;
        j["username"] = std::string( m_username.mb_str() );
        j["hostname"] = std::string( m_hostname.mb_str() );
        j["token"] = std::string( m_token.mb_str() );
 
        if( m_lock.Rewrite( j.dump() ) )
        {
            m_owned = true;
            m_status = true;
        }
        else
        {
            wxLogTrace( traceLockFile, "Could not write the lock record for %s", m_lockFilename );
        }
    }

    bool readRecord( nlohmann::json& aRecord ) const
    {
        std::string contents;
 
        if( !m_lock.ReadAll( contents ) )
            return false;
 
        aRecord = nlohmann::json::parse( contents, nullptr, false /* exceptions allowed */ );
 
        if( aRecord.is_discarded() )
        {
            wxLogTrace( traceLockFile, "Unreadable lock contents for %s", m_lockFilename );
            return false;
        }
 
        return true;
    }
 
    void readOwner()
    {
        m_username = wxEmptyString;
        m_hostname = wxEmptyString;
        m_token = wxEmptyString;
 
        try
        {
            nlohmann::json record;
 
            if( readRecord( record ) )
            {
                m_username = wxString( record.value( "username", std::string() ) );
                m_hostname = wxString( record.value( "hostname", std::string() ) );
                m_token = wxString( record.value( "token", std::string() ) );
            }
        }
        catch(...)
        {
            // best efforts
        }
    }

    bool stillOwnLock()
    {
        if( m_token.IsEmpty() )
            return false;
 
        try
        {
            nlohmann::json record;
 
            if( !readRecord( record ) )
                return false;
 
            if( m_token == wxString( record.value( "token", std::string() ) ) )
                return true;
        }
        catch(...)
        {
            return false;
        }
 
        wxLogTrace( traceLockFile, "Lock on %s is no longer ours", m_lockFilename );
 
        return false;
    }
};