752399ca6b
- an empty command isn't going to work (although it might successfully run chroot or env in the target system, that's not useful) - while here, move variable declarations closer to their use.
456 lines
13 KiB
C++
456 lines
13 KiB
C++
/* === This file is part of Calamares - <https://github.com/calamares> ===
|
|
*
|
|
* Copyright 2014, Teo Mrnjavac <teo@kde.org>
|
|
* Copyright 2017-2018, 2020, Adriaan de Groot <groot@kde.org>
|
|
*
|
|
* Calamares 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.
|
|
*
|
|
* Calamares 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 Calamares. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "CalamaresUtilsSystem.h"
|
|
|
|
#include "GlobalStorage.h"
|
|
#include "JobQueue.h"
|
|
#include "Settings.h"
|
|
#include "utils/Logger.h"
|
|
|
|
#include <QCoreApplication>
|
|
#include <QDir>
|
|
#include <QProcess>
|
|
#include <QRegularExpression>
|
|
|
|
#ifdef Q_OS_LINUX
|
|
#include <sys/sysinfo.h>
|
|
#endif
|
|
|
|
#ifdef Q_OS_FREEBSD
|
|
// clang-format off
|
|
// these includes need to stay in-order (that's a FreeBSD thing)
|
|
#include <sys/types.h>
|
|
#include <sys/sysctl.h>
|
|
// clang-format on
|
|
#endif
|
|
|
|
/** @brief When logging commands, don't log everything.
|
|
*
|
|
* The command-line arguments to some commands may contain the
|
|
* encrypted password set by the user. Don't log that password,
|
|
* since the log may get posted to bug reports, or stored in
|
|
* the target system.
|
|
*/
|
|
struct RedactedList
|
|
{
|
|
RedactedList( const QStringList& l )
|
|
: list( l )
|
|
{
|
|
}
|
|
|
|
const QStringList& list;
|
|
};
|
|
|
|
QDebug&
|
|
operator<<( QDebug& s, const RedactedList& l )
|
|
{
|
|
// Special case logging: don't log the (encrypted) password.
|
|
if ( l.list.contains( "usermod" ) )
|
|
{
|
|
for ( const auto& item : l.list )
|
|
if ( item.startsWith( "$6$" ) )
|
|
{
|
|
s << "<password>";
|
|
}
|
|
else
|
|
{
|
|
s << item;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
s << l.list;
|
|
}
|
|
|
|
return s;
|
|
}
|
|
|
|
namespace CalamaresUtils
|
|
{
|
|
|
|
System* System::s_instance = nullptr;
|
|
|
|
|
|
System::System( bool doChroot, QObject* parent )
|
|
: QObject( parent )
|
|
, m_doChroot( doChroot )
|
|
{
|
|
Q_ASSERT( !s_instance );
|
|
s_instance = this;
|
|
if ( !doChroot && Calamares::JobQueue::instance() && Calamares::JobQueue::instance()->globalStorage() )
|
|
{
|
|
Calamares::JobQueue::instance()->globalStorage()->insert( "rootMountPoint", "/" );
|
|
}
|
|
}
|
|
|
|
|
|
System::~System() {}
|
|
|
|
|
|
System*
|
|
System::instance()
|
|
{
|
|
if ( !s_instance )
|
|
{
|
|
cError() << "No Calamares system-object has been created.";
|
|
cError() << Logger::SubEntry << "using a bogus instance instead.";
|
|
return new System( true, nullptr );
|
|
}
|
|
return s_instance;
|
|
}
|
|
|
|
|
|
ProcessResult
|
|
System::runCommand( System::RunLocation location,
|
|
const QStringList& args,
|
|
const QString& workingPath,
|
|
const QString& stdInput,
|
|
std::chrono::seconds timeoutSec )
|
|
{
|
|
if ( args.isEmpty() )
|
|
{
|
|
cWarning() << "Cannot run an empty program list";
|
|
return ProcessResult::Code::FailedToStart;
|
|
}
|
|
|
|
Calamares::GlobalStorage* gs
|
|
= Calamares::JobQueue::instance() ? Calamares::JobQueue::instance()->globalStorage() : nullptr;
|
|
|
|
if ( ( location == System::RunLocation::RunInTarget ) && ( !gs || !gs->contains( "rootMountPoint" ) ) )
|
|
{
|
|
cWarning() << "No rootMountPoint in global storage";
|
|
return ProcessResult::Code::NoWorkingDirectory;
|
|
}
|
|
|
|
QString program;
|
|
QStringList arguments( args );
|
|
|
|
if ( location == System::RunLocation::RunInTarget )
|
|
{
|
|
QString destDir = gs->value( "rootMountPoint" ).toString();
|
|
if ( !QDir( destDir ).exists() )
|
|
{
|
|
cWarning() << "rootMountPoint points to a dir which does not exist";
|
|
return ProcessResult::Code::NoWorkingDirectory;
|
|
}
|
|
|
|
program = "chroot";
|
|
arguments.prepend( destDir );
|
|
}
|
|
else
|
|
{
|
|
program = "env";
|
|
}
|
|
|
|
QProcess process;
|
|
process.setProgram( program );
|
|
process.setArguments( arguments );
|
|
process.setProcessChannelMode( QProcess::MergedChannels );
|
|
|
|
if ( !workingPath.isEmpty() )
|
|
{
|
|
if ( QDir( workingPath ).exists() )
|
|
{
|
|
process.setWorkingDirectory( QDir( workingPath ).absolutePath() );
|
|
}
|
|
else
|
|
{
|
|
cWarning() << "Invalid working directory:" << workingPath;
|
|
return ProcessResult::Code::NoWorkingDirectory;
|
|
}
|
|
}
|
|
|
|
cDebug() << "Running" << program << RedactedList( arguments );
|
|
process.start();
|
|
if ( !process.waitForStarted() )
|
|
{
|
|
cWarning() << "Process failed to start" << process.error();
|
|
return ProcessResult::Code::FailedToStart;
|
|
}
|
|
|
|
if ( !stdInput.isEmpty() )
|
|
{
|
|
process.write( stdInput.toLocal8Bit() );
|
|
}
|
|
process.closeWriteChannel();
|
|
|
|
if ( !process.waitForFinished( timeoutSec > std::chrono::seconds::zero()
|
|
? ( static_cast< int >( std::chrono::milliseconds( timeoutSec ).count() ) )
|
|
: -1 ) )
|
|
{
|
|
cWarning().noquote().nospace() << "Timed out. Output so far:\n" << process.readAllStandardOutput();
|
|
return ProcessResult::Code::TimedOut;
|
|
}
|
|
|
|
QString output = QString::fromLocal8Bit( process.readAllStandardOutput() ).trimmed();
|
|
|
|
if ( process.exitStatus() == QProcess::CrashExit )
|
|
{
|
|
cWarning().noquote().nospace() << "Process crashed. Output so far:\n" << output;
|
|
return ProcessResult::Code::Crashed;
|
|
}
|
|
|
|
auto r = process.exitCode();
|
|
cDebug() << "Finished. Exit code:" << r;
|
|
bool showDebug = ( !Calamares::Settings::instance() ) || ( Calamares::Settings::instance()->debugMode() );
|
|
if ( ( r != 0 ) || showDebug )
|
|
{
|
|
cDebug() << "Target cmd:" << RedactedList( args );
|
|
cDebug().noquote().nospace() << "Target output:\n" << output;
|
|
}
|
|
return ProcessResult( r, output );
|
|
}
|
|
|
|
/// @brief Cheap check if a path is absolute.
|
|
static inline bool
|
|
isAbsolutePath( const QString& path )
|
|
{
|
|
return path.startsWith( '/' );
|
|
}
|
|
|
|
QString
|
|
System::targetPath( const QString& path ) const
|
|
{
|
|
if ( doChroot() )
|
|
{
|
|
Calamares::GlobalStorage* gs
|
|
= Calamares::JobQueue::instance() ? Calamares::JobQueue::instance()->globalStorage() : nullptr;
|
|
|
|
if ( !gs || !gs->contains( "rootMountPoint" ) )
|
|
{
|
|
cWarning() << "No rootMountPoint in global storage, cannot name target file" << path;
|
|
return QString();
|
|
}
|
|
|
|
QString root = gs->value( "rootMountPoint" ).toString();
|
|
return isAbsolutePath( path ) ? ( root + path ) : ( root + '/' + path );
|
|
}
|
|
else
|
|
{
|
|
return isAbsolutePath( path ) ? path : ( QStringLiteral( "/" ) + path );
|
|
}
|
|
}
|
|
|
|
CreationResult
|
|
System::createTargetFile( const QString& path, const QByteArray& contents, WriteMode mode ) const
|
|
{
|
|
QString completePath = targetPath( path );
|
|
if ( completePath.isEmpty() )
|
|
{
|
|
return CreationResult( CreationResult::Code::Invalid );
|
|
}
|
|
|
|
QFile f( completePath );
|
|
if ( ( mode == WriteMode::KeepExisting ) && f.exists() )
|
|
{
|
|
return CreationResult( CreationResult::Code::AlreadyExists );
|
|
}
|
|
|
|
QIODevice::OpenMode m =
|
|
#if QT_VERSION >= QT_VERSION_CHECK( 5, 11, 0 )
|
|
// New flag from Qt 5.11, implies WriteOnly
|
|
( mode == WriteMode::KeepExisting ? QIODevice::NewOnly : QIODevice::WriteOnly ) |
|
|
#endif
|
|
QIODevice::WriteOnly | QIODevice::Truncate;
|
|
|
|
if ( !f.open( m ) )
|
|
{
|
|
return CreationResult( CreationResult::Code::Failed );
|
|
}
|
|
|
|
if ( f.write( contents ) != contents.size() )
|
|
{
|
|
f.close();
|
|
f.remove();
|
|
return CreationResult( CreationResult::Code::Failed );
|
|
}
|
|
|
|
f.close();
|
|
return CreationResult( QFileInfo( f ).canonicalFilePath() );
|
|
}
|
|
|
|
void
|
|
System::removeTargetFile( const QString& path ) const
|
|
{
|
|
if ( !isAbsolutePath( path ) )
|
|
{
|
|
cWarning() << "Will not remove non-absolute path" << path;
|
|
return;
|
|
}
|
|
QString target = targetPath( path );
|
|
if ( !target.isEmpty() )
|
|
{
|
|
QFile::remove( target );
|
|
}
|
|
// If it was empty, a warning was already printed
|
|
}
|
|
|
|
bool
|
|
System::createTargetDirs( const QString& path ) const
|
|
{
|
|
if ( !isAbsolutePath( path ) )
|
|
{
|
|
cWarning() << "Will not create basedirs for non-absolute path" << path;
|
|
return false;
|
|
}
|
|
|
|
QString target = targetPath( path );
|
|
if ( target.isEmpty() )
|
|
{
|
|
// If it was empty, a warning was already printed
|
|
return false;
|
|
}
|
|
|
|
QString root = Calamares::JobQueue::instance()->globalStorage()->value( "rootMountPoint" ).toString();
|
|
if ( root.isEmpty() )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
QDir d( root );
|
|
if ( !d.exists() )
|
|
{
|
|
cWarning() << "Root mountpoint" << root << "does not exist.";
|
|
return false;
|
|
}
|
|
return d.mkpath( target ); // This re-does everything starting from the **host** /
|
|
}
|
|
|
|
bool
|
|
System::createTargetParentDirs( const QString& filePath ) const
|
|
{
|
|
return createTargetDirs( QFileInfo( filePath ).dir().path() );
|
|
}
|
|
|
|
|
|
QPair< quint64, float >
|
|
System::getTotalMemoryB() const
|
|
{
|
|
#ifdef Q_OS_LINUX
|
|
struct sysinfo i;
|
|
int r = sysinfo( &i );
|
|
|
|
if ( r )
|
|
{
|
|
return qMakePair( 0, 0.0 );
|
|
}
|
|
|
|
return qMakePair( quint64( i.mem_unit ) * quint64( i.totalram ), 1.1 );
|
|
#elif defined( Q_OS_FREEBSD )
|
|
unsigned long memsize;
|
|
size_t s = sizeof( memsize );
|
|
|
|
int r = sysctlbyname( "vm.kmem_size", &memsize, &s, NULL, 0 );
|
|
if ( r )
|
|
{
|
|
return qMakePair( 0, 0.0 );
|
|
}
|
|
|
|
return qMakePair( memsize, 1.01 );
|
|
#else
|
|
return qMakePair( 0, 0.0 ); // Unsupported
|
|
#endif
|
|
}
|
|
|
|
|
|
QString
|
|
System::getCpuDescription() const
|
|
{
|
|
QString model;
|
|
|
|
#ifdef Q_OS_LINUX
|
|
QFile file( "/proc/cpuinfo" );
|
|
if ( file.open( QIODevice::ReadOnly | QIODevice::Text ) )
|
|
while ( !file.atEnd() )
|
|
{
|
|
QByteArray line = file.readLine();
|
|
if ( line.startsWith( "model name" ) && ( line.indexOf( ':' ) > 0 ) )
|
|
{
|
|
model = QString::fromLatin1( line.right( line.length() - line.indexOf( ':' ) ) );
|
|
break;
|
|
}
|
|
}
|
|
#elif defined( Q_OS_FREEBSD )
|
|
// This would use sysctl "hw.model", which has a string value
|
|
#endif
|
|
return model.simplified();
|
|
}
|
|
|
|
quint64
|
|
System::getTotalDiskB() const
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
bool
|
|
System::doChroot() const
|
|
{
|
|
return m_doChroot;
|
|
}
|
|
|
|
Calamares::JobResult
|
|
ProcessResult::explainProcess( int ec, const QString& command, const QString& output, std::chrono::seconds timeout )
|
|
{
|
|
using Calamares::JobResult;
|
|
|
|
if ( ec == 0 )
|
|
{
|
|
return JobResult::ok();
|
|
}
|
|
|
|
QString outputMessage = output.isEmpty()
|
|
? QCoreApplication::translate( "ProcessResult", "\nThere was no output from the command." )
|
|
: ( QCoreApplication::translate( "ProcessResult", "\nOutput:\n" ) + output );
|
|
|
|
if ( ec == static_cast< int >( ProcessResult::Code::Crashed ) ) //Crash!
|
|
return JobResult::error(
|
|
QCoreApplication::translate( "ProcessResult", "External command crashed." ),
|
|
QCoreApplication::translate( "ProcessResult", "Command <i>%1</i> crashed." ).arg( command )
|
|
+ outputMessage );
|
|
|
|
if ( ec == static_cast< int >( ProcessResult::Code::FailedToStart ) )
|
|
return JobResult::error(
|
|
QCoreApplication::translate( "ProcessResult", "External command failed to start." ),
|
|
QCoreApplication::translate( "ProcessResult", "Command <i>%1</i> failed to start." ).arg( command ) );
|
|
|
|
if ( ec == static_cast< int >( ProcessResult::Code::NoWorkingDirectory ) )
|
|
return JobResult::error(
|
|
QCoreApplication::translate( "ProcessResult", "Internal error when starting command." ),
|
|
QCoreApplication::translate( "ProcessResult", "Bad parameters for process job call." ) );
|
|
|
|
if ( ec == static_cast< int >( ProcessResult::Code::TimedOut ) )
|
|
return JobResult::error(
|
|
QCoreApplication::translate( "ProcessResult", "External command failed to finish." ),
|
|
QCoreApplication::translate( "ProcessResult", "Command <i>%1</i> failed to finish in %2 seconds." )
|
|
.arg( command )
|
|
.arg( timeout.count() )
|
|
+ outputMessage );
|
|
|
|
//Any other exit code
|
|
return JobResult::error(
|
|
QCoreApplication::translate( "ProcessResult", "External command finished with errors." ),
|
|
QCoreApplication::translate( "ProcessResult", "Command <i>%1</i> finished with exit code %2." )
|
|
.arg( command )
|
|
.arg( ec )
|
|
+ outputMessage );
|
|
}
|
|
|
|
} // namespace CalamaresUtils
|