Adding upstream version 1:7.0.4.upstream/1%7.0.4upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 891 insertions, 0 deletions

diff --git a/configmgr/source/components.cxx b/configmgr/source/components.cxx
new file mode 100644
index 000000000..7f629bc8a
--- /dev/null
+++ b/configmgr/source/components.cxx
@@ -0,0 +1,891 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <sal/config.h>
+
+#include <cassert>
+#include <chrono>
+#include <vector>
+#include <set>
+
+#include <com/sun/star/beans/Optional.hpp>
+#include <com/sun/star/beans/UnknownPropertyException.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/container/NoSuchElementException.hpp>
+#include <com/sun/star/lang/WrappedTargetException.hpp>
+#include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>
+#include <com/sun/star/uno/Any.hxx>
+#include <com/sun/star/uno/Exception.hpp>
+#include <com/sun/star/uno/Reference.hxx>
+#include <com/sun/star/uno/RuntimeException.hpp>
+#include <com/sun/star/uno/XComponentContext.hpp>
+#include <com/sun/star/uno/XInterface.hpp>
+#include <cppuhelper/exc_hlp.hxx>
+#include <config_dconf.h>
+#include <config_folders.h>
+#include <osl/conditn.hxx>
+#include <osl/file.hxx>
+#include <osl/mutex.hxx>
+#include <rtl/bootstrap.hxx>
+#include <rtl/ref.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <rtl/ustring.hxx>
+#include <sal/log.hxx>
+#include <sal/types.h>
+#include <salhelper/thread.hxx>
+#include <tools/diagnose_ex.h>
+#include <comphelper/backupfilehelper.hxx>
+
+#include "additions.hxx"
+#include "components.hxx"
+#include "data.hxx"
+#include "lock.hxx"
+#include "modifications.hxx"
+#include "node.hxx"
+#include "nodemap.hxx"
+#include "parsemanager.hxx"
+#include "partial.hxx"
+#include "rootaccess.hxx"
+#include "writemodfile.hxx"
+#include "xcdparser.hxx"
+#include "xcuparser.hxx"
+#include "xcsparser.hxx"
+
+#if ENABLE_DCONF
+#include "dconf.hxx"
+#endif
+
+#if defined(_WIN32)
+#include "winreg.hxx"
+#endif
+
+namespace configmgr {
+
+namespace {
+
+struct UnresolvedVectorItem {
+    OUString name;
+    rtl::Reference< ParseManager > manager;
+
+    UnresolvedVectorItem(
+        OUString const & theName,
+        rtl::Reference< ParseManager > const & theManager):
+        name(theName), manager(theManager) {}
+};
+
+typedef std::vector< UnresolvedVectorItem > UnresolvedVector;
+
+void parseXcsFile(
+    OUString const & url, int layer, Data & data, Partial const * partial,
+    Modifications * modifications, Additions * additions)
+{
+    assert(partial == nullptr && modifications == nullptr && additions == nullptr);
+    (void) partial; (void) modifications; (void) additions;
+    bool ok = rtl::Reference< ParseManager >(
+        new ParseManager(url, new XcsParser(layer, data)))->parse(nullptr);
+    assert(ok);
+    (void) ok; // avoid warnings
+}
+
+void parseXcuFile(
+    OUString const & url, int layer, Data & data, Partial const * partial,
+    Modifications * modifications, Additions * additions)
+{
+    bool ok = rtl::Reference< ParseManager >(
+        new ParseManager(
+            url,
+            new XcuParser(layer, data, partial, modifications, additions)))->
+        parse(nullptr);
+    assert(ok);
+    (void) ok; // avoid warnings
+}
+
+OUString expand(OUString const & str) {
+    OUString s(str);
+    rtl::Bootstrap::expandMacros(s); //TODO: detect failure
+    return s;
+}
+
+bool canRemoveFromLayer(int layer, rtl::Reference< Node > const & node) {
+    assert(node.is());
+    if (node->getLayer() > layer && node->getLayer() < Data::NO_LAYER) {
+        return false;
+    }
+    switch (node->kind()) {
+    case Node::KIND_LOCALIZED_PROPERTY:
+    case Node::KIND_GROUP:
+        for (auto const& member : node->getMembers())
+        {
+            if (!canRemoveFromLayer(layer, member.second)) {
+                return false;
+            }
+        }
+        return true;
+    case Node::KIND_SET:
+        return node->getMembers().empty();
+    default: // Node::KIND_PROPERTY, Node::KIND_LOCALIZED_VALUE
+        return true;
+    }
+}
+
+}
+
+class Components::WriteThread: public salhelper::Thread {
+public:
+    WriteThread(
+        rtl::Reference< WriteThread > * reference, Components & components,
+        OUString const & url, Data const & data);
+
+    void flush() { delay_.set(); }
+
+private:
+    virtual ~WriteThread() override {}
+
+    virtual void execute() override;
+
+    rtl::Reference< WriteThread > * reference_;
+    Components & components_;
+    OUString url_;
+    Data const & data_;
+    osl::Condition delay_;
+    std::shared_ptr<osl::Mutex> lock_;
+};
+
+Components::WriteThread::WriteThread(
+    rtl::Reference< WriteThread > * reference, Components & components,
+    OUString const & url, Data const & data):
+    Thread("configmgrWriter"), reference_(reference), components_(components),
+    url_(url), data_(data),
+    lock_( lock() )
+{
+    assert(reference != nullptr);
+}
+
+void Components::WriteThread::execute() {
+    delay_.wait(std::chrono::seconds(1)); // must not throw; result_error is harmless and ignored
+    osl::MutexGuard g(*lock_); // must not throw
+    try {
+        try {
+            writeModFile(components_, url_, data_);
+        } catch (css::uno::RuntimeException &) {
+            // Ignore write errors, instead of aborting:
+            TOOLS_WARN_EXCEPTION("configmgr", "error writing modifications");
+        }
+    } catch (...) {
+        reference_->clear();
+        throw;
+    }
+    reference_->clear();
+}
+
+Components & Components::getSingleton(
+    css::uno::Reference< css::uno::XComponentContext > const & context)
+{
+    assert(context.is());
+    static Components singleton(context);
+    return singleton;
+}
+
+bool Components::allLocales(OUString const & locale) {
+    return locale == "*";
+}
+
+rtl::Reference< Node > Components::resolvePathRepresentation(
+    OUString const & pathRepresentation,
+    OUString * canonicRepresentation, std::vector<OUString> * path, int * finalizedLayer)
+    const
+{
+    return data_.resolvePathRepresentation(
+        pathRepresentation, canonicRepresentation, path, finalizedLayer);
+}
+
+rtl::Reference< Node > Components::getTemplate(OUString const & fullName) const
+{
+    return data_.getTemplate(Data::NO_LAYER, fullName);
+}
+
+void Components::addRootAccess(rtl::Reference< RootAccess > const & access) {
+    roots_.insert(access.get());
+}
+
+void Components::removeRootAccess(RootAccess * access) {
+    roots_.erase(access);
+}
+
+void Components::initGlobalBroadcaster(
+    Modifications const & modifications,
+    rtl::Reference< RootAccess > const & exclude, Broadcaster * broadcaster)
+{
+    //TODO: Iterate only over roots w/ listeners:
+    for (auto const& elemRoot : roots_)
+    {
+        rtl::Reference< RootAccess > root;
+        if (elemRoot->acquireCounting() > 1) {
+            root.set(elemRoot); // must not throw
+        }
+        elemRoot->releaseNondeleting();
+        if (root.is()) {
+            if (root != exclude) {
+                std::vector<OUString> path(root->getAbsolutePath());
+                Modifications::Node const * mods = &modifications.getRoot();
+                for (auto const& pathElem : path)
+                {
+                    Modifications::Node::Children::const_iterator k(
+                        mods->children.find(pathElem));
+                    if (k == mods->children.end()) {
+                        mods = nullptr;
+                        break;
+                    }
+                    mods = &k->second;
+                }
+                //TODO: If the complete tree of which root is a part is deleted,
+                // or replaced, mods will be null, but some of the listeners
+                // from within root should probably fire nonetheless:
+                if (mods != nullptr) {
+                    root->initBroadcaster(*mods, broadcaster);
+                }
+            }
+        }
+    }
+}
+
+void Components::addModification(std::vector<OUString> const & path) {
+    data_.modifications.add(path);
+}
+
+void Components::writeModifications() {
+
+    if (!data_.modifications.empty()) {
+        switch (modificationTarget_) {
+        case ModificationTarget::None:
+            break;
+        case ModificationTarget::File:
+            if (!writeThread_.is()) {
+                writeThread_ = new WriteThread(
+                    &writeThread_, *this, modificationFileUrl_, data_);
+                writeThread_->launch();
+            }
+            break;
+        case ModificationTarget::Dconf:
+#if ENABLE_DCONF
+            dconf::writeModifications(*this, data_);
+#endif
+            break;
+        }
+    }
+}
+
+void Components::flushModifications() {
+    rtl::Reference< WriteThread > thread;
+    {
+        osl::MutexGuard g(*lock_);
+        thread = writeThread_;
+    }
+    if (thread.is()) {
+        thread->flush();
+        thread->join();
+    }
+}
+
+void Components::insertExtensionXcsFile(
+    bool shared, OUString const & fileUri)
+{
+    int layer = getExtensionLayer(shared);
+    try {
+        parseXcsFile(fileUri, layer, data_, nullptr, nullptr, nullptr);
+    } catch (css::container::NoSuchElementException & e) {
+        throw css::uno::RuntimeException(
+            "insertExtensionXcsFile does not exist: " + e.Message);
+    }
+}
+
+void Components::insertExtensionXcuFile(
+    bool shared, OUString const & fileUri, Modifications * modifications)
+{
+    assert(modifications != nullptr);
+    int layer = getExtensionLayer(shared) + 1;
+    Additions * adds = data_.addExtensionXcuAdditions(fileUri, layer);
+    try {
+        parseXcuFile(fileUri, layer, data_, nullptr, modifications, adds);
+    } catch (css::container::NoSuchElementException & e) {
+        data_.removeExtensionXcuAdditions(fileUri);
+        throw css::uno::RuntimeException(
+            "insertExtensionXcuFile does not exist: " + e.Message);
+    }
+}
+
+void Components::removeExtensionXcuFile(
+    OUString const & fileUri, Modifications * modifications)
+{
+    //TODO: Ideally, exactly the data coming from the specified xcu file would
+    // be removed.  However, not enough information is recorded in the in-memory
+    // data structures to do so.  So, as a workaround, all those set elements
+    // that were freshly added by the xcu and have afterwards been left
+    // unchanged or have only had their properties changed in the user layer are
+    // removed (and nothing else).  The heuristic to determine
+    // whether a node has been left unchanged is to check the layer ID (as
+    // usual) and additionally to check that the node does not recursively
+    // contain any non-empty sets (multiple extension xcu files are merged into
+    // one layer, so checking layer ID alone is not enough).  Since
+    // item->additions records all additions of set members in textual order,
+    // the latter check works well when iterating through item->additions in
+    // reverse order.
+    assert(modifications != nullptr);
+    rtl::Reference< Data::ExtensionXcu > item(
+        data_.removeExtensionXcuAdditions(fileUri));
+    if (item.is()) {
+        for (Additions::reverse_iterator i(item->additions.rbegin());
+             i != item->additions.rend(); ++i)
+        {
+            rtl::Reference< Node > parent;
+            NodeMap const * map = &data_.getComponents();
+            rtl::Reference< Node > node;
+            for (auto const& j : *i)
+            {
+                parent = node;
+                node = map->findNode(Data::NO_LAYER, j);
+                if (!node.is()) {
+                    break;
+                }
+                map = &node->getMembers();
+            }
+            if (node.is()) {
+                assert(parent.is());
+                if (parent->kind() == Node::KIND_SET) {
+                    assert(
+                        node->kind() == Node::KIND_GROUP ||
+                        node->kind() == Node::KIND_SET);
+                    if (canRemoveFromLayer(item->layer, node)) {
+                        parent->getMembers().erase(i->back());
+                        data_.modifications.remove(*i);
+                        modifications->add(*i);
+                    }
+                }
+            }
+        }
+        writeModifications();
+    }
+}
+
+void Components::insertModificationXcuFile(
+    OUString const & fileUri,
+    std::set< OUString > const & includedPaths,
+    std::set< OUString > const & excludedPaths,
+    Modifications * modifications)
+{
+    assert(modifications != nullptr);
+    Partial part(includedPaths, excludedPaths);
+    try {
+        parseFileLeniently(
+            &parseXcuFile, fileUri, Data::NO_LAYER, &part, modifications, nullptr);
+    } catch (const css::container::NoSuchElementException &) {
+        TOOLS_WARN_EXCEPTION(
+            "configmgr",
+            "error inserting non-existing \"" << fileUri << "\"");
+    }
+}
+
+css::beans::Optional< css::uno::Any > Components::getExternalValue(
+    OUString const & descriptor)
+{
+    sal_Int32 i = descriptor.indexOf(' ');
+    if (i <= 0) {
+        throw css::uno::RuntimeException(
+            "bad external value descriptor " + descriptor);
+    }
+    //TODO: Do not make calls with mutex locked:
+    OUString name(descriptor.copy(0, i));
+    ExternalServices::iterator j(externalServices_.find(name));
+    if (j == externalServices_.end()) {
+        css::uno::Reference< css::uno::XInterface > service;
+        try {
+            service = context_->getServiceManager()->createInstanceWithContext(
+                name, context_);
+        } catch (const css::uno::RuntimeException &) {
+            // Assuming these exceptions are real errors:
+            throw;
+        } catch (const css::uno::Exception &)  {
+            // Assuming these exceptions indicate that the service is not
+            // installed:
+            TOOLS_WARN_EXCEPTION(
+                "configmgr",
+                "createInstance(" << name << ") failed");
+        }
+        css::uno::Reference< css::beans::XPropertySet > propset;
+        if (service.is()) {
+            propset.set( service, css::uno::UNO_QUERY_THROW);
+        }
+        j = externalServices_.emplace(name, propset).first;
+    }
+    css::beans::Optional< css::uno::Any > value;
+    if (j->second.is()) {
+        try {
+            if (!(j->second->getPropertyValue(descriptor.copy(i + 1)) >>=
+                  value))
+            {
+                throw css::uno::RuntimeException(
+                    "cannot obtain external value through " + descriptor);
+            }
+        } catch (css::beans::UnknownPropertyException & e) {
+            throw css::uno::RuntimeException(
+                "unknown external value descriptor ID: " + e.Message);
+        } catch (css::lang::WrappedTargetException & e) {
+            css::uno::Any anyEx = cppu::getCaughtException();
+            throw css::lang::WrappedTargetRuntimeException(
+                "cannot obtain external value: " + e.Message,
+                nullptr, anyEx );
+        }
+    }
+    return value;
+}
+
+Components::Components(
+    css::uno::Reference< css::uno::XComponentContext > const & context):
+    context_(context), sharedExtensionLayer_(-1), userExtensionLayer_(-1),
+    modificationTarget_(ModificationTarget::None)
+{
+    assert(context.is());
+    lock_ = lock();
+    OUString conf(expand("${CONFIGURATION_LAYERS}"));
+    int layer = 0;
+    for (sal_Int32 i = 0;;) {
+        while (i != conf.getLength() && conf[i] == ' ') {
+            ++i;
+        }
+        if (i == conf.getLength()) {
+            break;
+        }
+        if (modificationTarget_ != ModificationTarget::None) {
+            throw css::uno::RuntimeException(
+                "CONFIGURATION_LAYERS: modification target layer followed by"
+                " further layers");
+        }
+        sal_Int32 c = i;
+        for (;; ++c) {
+            if (c == conf.getLength() || conf[c] == ' ') {
+                throw css::uno::RuntimeException(
+                    "CONFIGURATION_LAYERS: missing ':' in \"" + conf + "\"");
+            }
+            if (conf[c] == ':') {
+                break;
+            }
+        }
+        sal_Int32 n = conf.indexOf(' ', c + 1);
+        if (n == -1) {
+            n = conf.getLength();
+        }
+        OUString type(conf.copy(i, c - i));
+        OUString url(conf.copy(c + 1, n - c - 1));
+        if (type == "xcsxcu") {
+            sal_uInt32 nStartTime = osl_getGlobalTimer();
+            parseXcsXcuLayer(layer, url);
+            SAL_INFO("configmgr", "parseXcsXcuLayer() took " << (osl_getGlobalTimer() - nStartTime) << " ms");
+            layer += 2; //TODO: overflow
+        } else if (type == "bundledext") {
+            parseXcsXcuIniLayer(layer, url, false);
+            layer += 2; //TODO: overflow
+        } else if (type == "sharedext") {
+            if (sharedExtensionLayer_ != -1) {
+                throw css::uno::RuntimeException(
+                    "CONFIGURATION_LAYERS: multiple \"sharedext\" layers");
+            }
+            sharedExtensionLayer_ = layer;
+            parseXcsXcuIniLayer(layer, url, true);
+            layer += 2; //TODO: overflow
+        } else if (type == "userext") {
+            if (userExtensionLayer_ != -1) {
+                throw css::uno::RuntimeException(
+                    "CONFIGURATION_LAYERS: multiple \"userext\" layers");
+            }
+            userExtensionLayer_ = layer;
+            parseXcsXcuIniLayer(layer, url, true);
+            layer += 2; //TODO: overflow
+        } else if (type == "res") {
+            sal_uInt32 nStartTime = osl_getGlobalTimer();
+            parseResLayer(layer, url);
+            SAL_INFO("configmgr", "parseResLayer() took " << (osl_getGlobalTimer() - nStartTime) << " ms");
+            ++layer; //TODO: overflow
+#if ENABLE_DCONF
+        } else if (type == "dconf") {
+            if (url == "!") {
+                modificationTarget_ = ModificationTarget::Dconf;
+                dconf::readLayer(data_, Data::NO_LAYER);
+            } else if (url == "*") {
+                dconf::readLayer(data_, layer);
+            } else {
+                throw css::uno::RuntimeException(
+                    "CONFIGURATION_LAYERS: unknown \"dconf\" kind \"" + url
+                    + "\"");
+            }
+            ++layer; //TODO: overflow
+#endif
+#if defined(_WIN32)
+        } else if (type == "winreg") {
+            WinRegType eType;
+            if (url == "LOCAL_MACHINE" || url.isEmpty()/*backwards comp.*/) {
+                eType = WinRegType::LOCAL_MACHINE;
+            } else if (url == "CURRENT_USER") {
+                eType = WinRegType::CURRENT_USER;
+            } else {
+                throw css::uno::RuntimeException(
+                    "CONFIGURATION_LAYERS: unknown \"winreg\" kind \"" + url
+                    + "\"");
+            }
+            OUString aTempFileURL;
+            if (dumpWindowsRegistry(&aTempFileURL, eType)) {
+                parseFileLeniently(&parseXcuFile, aTempFileURL, layer, nullptr, nullptr, nullptr);
+                if (!getenv("SAL_CONFIG_WINREG_RETAIN_TMP"))
+                    osl::File::remove(aTempFileURL);
+            }
+            ++layer; //TODO: overflow
+#endif
+        } else if (type == "user") {
+            bool write;
+            if (url.startsWith("!", &url)) {
+                write = true;
+            } else if (url.startsWith("*", &url)) {
+                write = false;
+            } else {
+                write = true; // for backwards compatibility
+            }
+            if (url.isEmpty()) {
+                throw css::uno::RuntimeException(
+                    "CONFIGURATION_LAYERS: empty \"user\" URL");
+            }
+            bool ignore = false;
+#if ENABLE_DCONF
+            if (write) {
+                OUString token(
+                    expand("${SYSUSERCONFIG}/libreoffice/dconfwrite"));
+                osl::DirectoryItem it;
+                osl::FileBase::RC e = osl::DirectoryItem::get(token, it);
+                ignore = e == osl::FileBase::E_None;
+                SAL_INFO(
+                    "configmgr",
+                    "dconf write (<" << token << "> " << +e << "): "
+                        << int(ignore));
+                if (ignore) {
+                    modificationTarget_ = ModificationTarget::Dconf;
+                }
+            }
+#endif
+            if (!ignore) {
+                if (write) {
+                    modificationTarget_ = ModificationTarget::File;
+                    modificationFileUrl_ = url;
+                }
+                parseModificationLayer(write ? Data::NO_LAYER : layer, url);
+            }
+            ++layer; //TODO: overflow
+        } else {
+            throw css::uno::RuntimeException(
+                "CONFIGURATION_LAYERS: unknown layer type \"" + type + "\"");
+        }
+        i = n;
+    }
+}
+
+Components::~Components()
+{
+    // get flag if _exit was already called which is a sign to not secure user config.
+    // this is used for win only currently where calling _exit() unfortunately still
+    // calls destructors (what is not wanted). May be needed for other systems, too
+    // (unknown yet) but can do no harm
+    const bool bExitWasCalled(comphelper::BackupFileHelper::getExitWasCalled());
+
+#ifndef _WIN32
+    // we can add a SAL_WARN here for other systems where the destructor gets called after
+    // an _exit() call. Still safe - the getExitWasCalled() is used, but a hint that _exit
+    // behaves different on a system
+    SAL_WARN_IF(bExitWasCalled, "configmgr", "Components::~Components() called after _exit() call");
+#endif
+
+    if (bExitWasCalled)
+    {
+        // do not write, re-join threads
+        osl::MutexGuard g(*lock_);
+
+        if (writeThread_.is())
+        {
+            writeThread_->join();
+        }
+    }
+    else
+    {
+        // write changes
+        flushModifications();
+    }
+
+    for (auto const& rootElem : roots_)
+    {
+        rootElem->setAlive(false);
+    }
+}
+
+void Components::parseFileLeniently(
+    FileParser * parseFile, OUString const & url, int layer,
+    Partial const * partial, Modifications * modifications,
+    Additions * additions)
+{
+    assert(parseFile != nullptr);
+    try {
+        (*parseFile)(url, layer, data_, partial, modifications, additions);
+    } catch (const css::container::NoSuchElementException &) {
+        throw;
+    } catch (const css::uno::Exception &) { //TODO: more specific exception catching
+        // Ignore invalid XML files, instead of completely preventing OOo from
+        // starting:
+        TOOLS_WARN_EXCEPTION(
+            "configmgr",
+            "error reading \"" << url << "\"");
+    }
+}
+
+void Components::parseFiles(
+    int layer, OUString const & extension, FileParser * parseFile,
+    OUString const & url, bool recursive)
+{
+    osl::Directory dir(url);
+    switch (dir.open()) {
+    case osl::FileBase::E_None:
+        break;
+    case osl::FileBase::E_NOENT:
+        if (!recursive) {
+            return;
+        }
+        [[fallthrough]];
+    default:
+        throw css::uno::RuntimeException(
+            "cannot open directory " + url);
+    }
+    for (;;) {
+        osl::DirectoryItem i;
+        osl::FileBase::RC rc = dir.getNextItem(i, SAL_MAX_UINT32);
+        if (rc == osl::FileBase::E_NOENT) {
+            break;
+        }
+        if (rc != osl::FileBase::E_None) {
+            throw css::uno::RuntimeException(
+                "cannot iterate directory " + url);
+        }
+        osl::FileStatus stat(
+            osl_FileStatus_Mask_Type | osl_FileStatus_Mask_FileName |
+            osl_FileStatus_Mask_FileURL);
+        if (i.getFileStatus(stat) != osl::FileBase::E_None) {
+            throw css::uno::RuntimeException(
+                "cannot stat in directory " + url);
+        }
+        if (stat.getFileType() == osl::FileStatus::Directory) { //TODO: symlinks
+            parseFiles(layer, extension, parseFile, stat.getFileURL(), true);
+        } else {
+            OUString file(stat.getFileName());
+            if (file.endsWith(extension)) {
+                try {
+                    parseFileLeniently(
+                        parseFile, stat.getFileURL(), layer, nullptr, nullptr, nullptr);
+                } catch (css::container::NoSuchElementException & e) {
+                    if (stat.getFileType() == osl::FileStatus::Link) {
+                        SAL_WARN("configmgr", "dangling link <" << stat.getFileURL() << ">");
+                        continue;
+                    }
+                    throw css::uno::RuntimeException(
+                        "stat'ed file does not exist: " + e.Message);
+                }
+            }
+        }
+    }
+}
+
+void Components::parseFileList(
+    int layer, FileParser * parseFile, OUString const & urls,
+    bool recordAdditions)
+{
+    for (sal_Int32 i = 0;;) {
+        OUString url(urls.getToken(0, ' ', i));
+        if (!url.isEmpty()) {
+            Additions * adds = nullptr;
+            if (recordAdditions) {
+                adds = data_.addExtensionXcuAdditions(url, layer);
+            }
+            try {
+                parseFileLeniently(parseFile, url, layer, nullptr, nullptr, adds);
+            } catch (const css::container::NoSuchElementException &) {
+                TOOLS_WARN_EXCEPTION("configmgr", "file does not exist");
+                if (adds != nullptr) {
+                    data_.removeExtensionXcuAdditions(url);
+                }
+            }
+        }
+        if (i == -1) {
+            break;
+        }
+    }
+}
+
+void Components::parseXcdFiles(int layer, OUString const & url) {
+    osl::Directory dir(url);
+    switch (dir.open()) {
+    case osl::FileBase::E_None:
+        break;
+    case osl::FileBase::E_NOENT:
+        return;
+    default:
+        throw css::uno::RuntimeException(
+            "cannot open directory " + url);
+    }
+    UnresolvedVector unres;
+    std::set< OUString > existingDeps;
+    std::set< OUString > processedDeps;
+    for (;;) {
+        osl::DirectoryItem i;
+        osl::FileBase::RC rc = dir.getNextItem(i, SAL_MAX_UINT32);
+        if (rc == osl::FileBase::E_NOENT) {
+            break;
+        }
+        if (rc != osl::FileBase::E_None) {
+            throw css::uno::RuntimeException(
+                "cannot iterate directory " + url);
+        }
+        osl::FileStatus stat(
+            osl_FileStatus_Mask_Type | osl_FileStatus_Mask_FileName |
+            osl_FileStatus_Mask_FileURL);
+        if (i.getFileStatus(stat) != osl::FileBase::E_None) {
+            throw css::uno::RuntimeException(
+                "cannot stat in directory " + url);
+        }
+        if (stat.getFileType() != osl::FileStatus::Directory) { //TODO: symlinks
+            OUString file(stat.getFileName());
+            OUString name;
+            if (file.endsWith(".xcd", &name)) {
+                existingDeps.insert(name);
+                rtl::Reference< ParseManager > manager;
+                try {
+                    manager = new ParseManager(
+                        stat.getFileURL(),
+                        new XcdParser(layer, processedDeps, data_));
+                } catch (css::container::NoSuchElementException & e) {
+                    if (stat.getFileType() == osl::FileStatus::Link) {
+                        SAL_WARN("configmgr", "dangling link <" << stat.getFileURL() << ">");
+                        continue;
+                    }
+                    throw css::uno::RuntimeException(
+                        "stat'ed file does not exist: " + e.Message);
+                }
+                if (manager->parse(nullptr)) {
+                    processedDeps.insert(name);
+                } else {
+                    unres.emplace_back(name, manager);
+                }
+            }
+        }
+    }
+    while (!unres.empty()) {
+        bool resolved = false;
+        for (UnresolvedVector::iterator i(unres.begin()); i != unres.end();) {
+            if (i->manager->parse(&existingDeps)) {
+                processedDeps.insert(i->name);
+                i = unres.erase(i);
+                resolved = true;
+            } else {
+                ++i;
+            }
+        }
+        if (!resolved) {
+            throw css::uno::RuntimeException(
+                "xcd: unresolved dependencies in " + url);
+        }
+    }
+}
+
+void Components::parseXcsXcuLayer(int layer, OUString const & url) {
+    parseXcdFiles(layer, url);
+    parseFiles(layer, ".xcs", &parseXcsFile, url + "/schema", false);
+    parseFiles(layer + 1, ".xcu", &parseXcuFile, url + "/data", false);
+}
+
+void Components::parseXcsXcuIniLayer(
+    int layer, OUString const & url, bool recordAdditions)
+{
+    // Check if ini file exists (otherwise .override would still read global
+    // SCHEMA/DATA variables, which could interfere with unrelated environment
+    // variables):
+    if (rtl::Bootstrap(url).getHandle() != nullptr) {
+        OUStringBuffer prefix("${.override:");
+        for (sal_Int32 i = 0; i != url.getLength(); ++i) {
+            sal_Unicode c = url[i];
+            switch (c) {
+            case '$':
+            case ':':
+            case '\\':
+                prefix.append('\\');
+                [[fallthrough]];
+            default:
+                prefix.append(c);
+            }
+        }
+        prefix.append(':');
+        OUString urls(prefix.toString() + "SCHEMA}");
+        rtl::Bootstrap::expandMacros(urls);
+        if (!urls.isEmpty()) {
+            parseFileList(layer, &parseXcsFile, urls, false);
+        }
+        urls = prefix.makeStringAndClear() + "DATA}";
+        rtl::Bootstrap::expandMacros(urls);
+        if (!urls.isEmpty()) {
+            parseFileList(layer + 1, &parseXcuFile, urls, recordAdditions);
+        }
+    }
+}
+
+void Components::parseResLayer(int layer, OUString const & url) {
+    OUString resUrl(url + "/res");
+    parseXcdFiles(layer, resUrl);
+    parseFiles(layer, ".xcu", &parseXcuFile, resUrl, false);
+}
+
+void Components::parseModificationLayer(int layer, OUString const & url) {
+    try {
+        parseFileLeniently(&parseXcuFile, url, layer, nullptr, nullptr, nullptr);
+    } catch (css::container::NoSuchElementException &) {
+        SAL_INFO(
+            "configmgr", "user registrymodifications.xcu does not (yet) exist");
+        // Migrate old user layer data (can be removed once migration is no
+        // longer relevant, probably OOo 4; also see hack for xsi namespace in
+        // xmlreader::XmlReader::registerNamespaceIri):
+        parseFiles(
+            layer, ".xcu", &parseXcuFile,
+            expand(
+                "${$BRAND_BASE_DIR/" LIBO_ETC_FOLDER "/" SAL_CONFIGFILE("bootstrap")
+                ":UserInstallation}/user/registry/data"),
+            false);
+    }
+}
+
+int Components::getExtensionLayer(bool shared) const {
+    int layer = shared ? sharedExtensionLayer_ : userExtensionLayer_;
+    if (layer == -1) {
+        throw css::uno::RuntimeException(
+            "insert extension xcs/xcu file into undefined layer");
+    }
+    return layer;
+}
+
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */