sandbox.cpp

Go to the documentation of this file.

 
#include "sandbox_p.h"
 
#include <stdlib.h>
 
#include <QtCore/QDir>
#include <QtCore/QDirIterator>
#include <QtCore/QFileInfo>
#include <QtCore/QProcessEnvironment>
#include <QtCore/QSet>
 
#include "libssu/ssucoreconfig_p.h"
#include "constants.h"
 
Sandbox *Sandbox::s_activeInstance = 0;
 
Sandbox::Sandbox()
    : m_defaultConstructed(true), m_usage(UseDirectly), m_scopes(ThisProcess),
      m_sandboxPath(QProcessEnvironment::systemEnvironment().value("SSU_SANDBOX_DIR")),
      m_prepared(false)
{
    if (!activate()) {
        qFatal("%s: Failed to activate", Q_FUNC_INFO);
    }
}
 
Sandbox::Sandbox(const QString &sandboxPath, Usage usage, Scopes scopes)
    : m_defaultConstructed(false), m_usage(usage), m_scopes(scopes),
      m_sandboxPath(sandboxPath), m_prepared(false)
{
    Q_ASSERT(!sandboxPath.isEmpty());
}
 
Sandbox::~Sandbox()
{
    if (isActive()) {
        deactivate();
    }
 
    if (!m_tempDir.isEmpty() && QFileInfo(m_tempDir).exists()) {
        if (!QDir(m_tempDir).removeRecursively()) {
            qWarning("%s: Failed to remove temporary directory", Q_FUNC_INFO);
        }
    }
}
 
bool Sandbox::isActive() const
{
    return s_activeInstance == this;
}
 
bool Sandbox::activate()
{
    Q_ASSERT_X(s_activeInstance == 0, Q_FUNC_INFO, "Only one instance can be active!");
 
    if (!prepare()) {
        return false;
    }
 
    if (m_scopes & ChildProcesses) {
        setenv("SSU_SANDBOX_DIR", qPrintable(m_workingSandboxDir.path()), 1);
    }
 
    s_activeInstance = this;
    return true;
}
 
void Sandbox::deactivate()
{
    Q_ASSERT(isActive());
 
    if (m_scopes & ChildProcesses) {
        unsetenv("SSU_SANDBOX_DIR");
    }
 
    s_activeInstance = 0;
}
 
QDir Sandbox::effectiveRootDir()
{
    return s_activeInstance != 0 && s_activeInstance->m_scopes & ThisProcess
           ? s_activeInstance->m_workingSandboxDir
           : QDir::root();
}
 
QString Sandbox::map(const QString &fileName)
{
    return effectiveRootDir().filePath(
               QDir::root().relativeFilePath(
                   QFileInfo(fileName).absoluteFilePath()));
}
 
QString Sandbox::map(const QString &pathName, const QString &fileName)
{
    return effectiveRootDir().filePath(
               QDir::root().relativeFilePath(
                   QFileInfo(pathName + fileName).absoluteFilePath()));
}
 
bool Sandbox::addWorldFiles(const QString &directory, QDir::Filters filters,
                            const QStringList &filterNames, bool recurse)
{
    Q_ASSERT(!isActive());
    Q_ASSERT(!directory.isEmpty());
 
    if (!prepare()) {
        return false;
    }
 
    const QString sandboxedDirectory = m_workingSandboxDir.filePath(
                                           QDir::root().relativeFilePath(
                                               QFileInfo(directory).absoluteFilePath()));
 
    if (!QFileInfo(directory).exists()) {
        // Accept missing world directory - allow to create directories inside sandbox
        qDebug("%s: Directory does not exist - an empty one will be created instead of copied: '%s'",
               Q_FUNC_INFO, qPrintable(directory));
    } else if (!QFileInfo(directory).isDir()) {
        qWarning("%s: Is not a directory: '%s'", Q_FUNC_INFO, qPrintable(directory));
        return false;
    }
 
    if (!QFileInfo(sandboxedDirectory).exists()) {
        if (!QDir().mkpath(sandboxedDirectory)) {
            qWarning("%s: Failed to create sandbox directory '%s'", Q_FUNC_INFO,
                     qPrintable(sandboxedDirectory));
            return false;
        }
    } else if (!QFileInfo(sandboxedDirectory).isDir()) {
        qWarning("%s: Failed to create sandbox directory '%s': Is not a directory", Q_FUNC_INFO,
                 qPrintable(sandboxedDirectory));
        return false;
    }
 
    if (filters == QDir::NoFilter) {
        filters = QDir::AllEntries;
    }
 
    filters |= QDir::NoDotAndDotDot;
 
    foreach (const QFileInfo &worldEntryInfo, QDir(directory).entryInfoList(filterNames, filters)) {
 
        const QFileInfo sandboxEntryInfo(QDir(sandboxedDirectory).filePath(worldEntryInfo.fileName()));
 
        if (worldEntryInfo.isDir()) {
            if (!sandboxEntryInfo.exists()) {
                if (!QDir(sandboxedDirectory).mkdir(worldEntryInfo.fileName())) {
                    qWarning("%s: Failed to create overlay directory '%s/%s'", Q_FUNC_INFO,
                             qPrintable(sandboxedDirectory), qPrintable(worldEntryInfo.fileName()));
                    return false;
                }
            } else if (!sandboxEntryInfo.isDir()) {
                qWarning("%s: Failed to create sandboxed copy '%s': Is not a directory", Q_FUNC_INFO,
                         qPrintable(sandboxEntryInfo.filePath()));
                return false;
            }
 
            if (recurse) {
                if (!addWorldFiles(worldEntryInfo.absoluteFilePath(), filters, filterNames, true)) {
                    return false;
                }
            }
        } else {
            if (!sandboxEntryInfo.exists()) {
                if (!QFile(worldEntryInfo.filePath()).copy(sandboxEntryInfo.filePath())) {
                    qWarning("%s: Failed to copy file into sandbox '%s'", Q_FUNC_INFO,
                             qPrintable(worldEntryInfo.filePath()));
                    return false;
                }
            } else if (sandboxEntryInfo.isDir()) {
                qWarning("%s: Failed to create sandboxed copy '%s': Is a directory", Q_FUNC_INFO,
                         qPrintable(sandboxEntryInfo.filePath()));
                return false;
            }
        }
    }
 
    return true;
}
 
bool Sandbox::addWorldFile(const QString &file)
{
    return addWorldFiles(QFileInfo(file).path(), QDir::NoFilter,
                         QStringList() << QFileInfo(file).fileName());
}
 
bool Sandbox::prepare()
{
    Q_ASSERT(m_defaultConstructed || !m_sandboxPath.isEmpty());
 
    if (m_prepared) {
        return true;
    }
 
    if (m_sandboxPath.isEmpty()) {
        return true;
    }
 
    if (!QFileInfo(m_sandboxPath).exists()) {
        qWarning("%s: Invalid sandboxPath: No such file or directory", qPrintable(m_sandboxPath));
        return false;
    }
 
    if (!QFileInfo(m_sandboxPath).isDir()) {
        qWarning("%s: Invalid sandboxPath: Not a directory", qPrintable(m_sandboxPath));
        return false;
    }
 
    if (m_usage == UseAsSkeleton) {
        if (m_tempDir = createTmpDir("ssu-sandbox.%1"), m_tempDir.isEmpty()) {
            qWarning("%s: Failed to create sandbox directory", Q_FUNC_INFO);
            return false;
        }
 
        const QString sandboxCopyPath = QDir(m_tempDir).filePath("configroot");
 
        if (!copyDir(m_sandboxPath, sandboxCopyPath)) {
            qWarning("%s: Failed to copy sandbox directory", Q_FUNC_INFO);
            return false;
        }
 
        m_workingSandboxDir = QDir(sandboxCopyPath);
    } else {
        m_workingSandboxDir = QDir(m_sandboxPath);
    }
 
    m_prepared = true;
    return true;
}
 
QString Sandbox::createTmpDir(const QString &nameTemplate)
{
    const int REASONABLE_REPEAT_COUNT = 10;
 
    for (int i = 0; i < REASONABLE_REPEAT_COUNT; ++i) {
        QString path;
        int suffix = 0;
        do {
            path = QDir::temp().filePath(nameTemplate.arg(++suffix));
        } while (QFileInfo(path).exists());
 
        if (QDir().mkpath(path)) {
            return path;
        }
    }
 
    qWarning("%s: Failed to create temporary directory", Q_FUNC_INFO);
    return QString();
}
 
bool Sandbox::copyDir(const QString &directory, const QString &newName)
{
    const QDir sourceRoot(directory);
    const QDir destinationRoot(newName);
 
    QDirIterator it(directory, QDir::AllEntries | QDir::NoDotAndDotDot, QDirIterator::Subdirectories);
    while (it.hasNext()) {
        it.next();
 
        const QFileInfo destination = QFileInfo(destinationRoot.filePath(
                                                    sourceRoot.relativeFilePath(it.filePath())));
 
        if (it.fileInfo().isDir()) {
            if (!QDir().mkpath(destination.absoluteFilePath())) {
                qWarning("%s: Failed to mkpath '%s'", Q_FUNC_INFO, qPrintable(destination.absolutePath()));
                return false;
            }
        } else if (it.fileInfo().isFile()) {
            if (!QDir().mkpath(destination.absolutePath())) {
                qWarning("%s: Failed to mkpath '%s'", Q_FUNC_INFO, qPrintable(destination.absolutePath()));
                return false;
            }
 
            if (!QFile::copy(it.fileInfo().absoluteFilePath(), destination.absoluteFilePath())) {
                qWarning("%s: Failed to copy file '%s'", Q_FUNC_INFO, qPrintable(it.filePath()));
                return false;
            }
        } else {
            qWarning("%s: Cannot copy other than regular files: '%s'", Q_FUNC_INFO,
                     qPrintable(it.filePath()));
            return false;
        }
    }
 
    return true;
}