| /************************************************************** | |
| * | |
| * 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 | |
| * | |
| * Unless required by applicable law or agreed to in writing, | |
| * software distributed under the License is distributed on an | |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| * KIND, either express or implied. See the License for the | |
| * specific language governing permissions and limitations | |
| * under the License. | |
| * | |
| *************************************************************/ | |
| #include "precompiled_configmgr.hxx" | |
| #include "sal/config.h" | |
| #include <algorithm> | |
| #include "com/sun/star/uno/Reference.hxx" | |
| #include "com/sun/star/uno/RuntimeException.hpp" | |
| #include "com/sun/star/uno/XInterface.hpp" | |
| #include "osl/diagnose.h" | |
| #include "rtl/ref.hxx" | |
| #include "rtl/string.h" | |
| #include "rtl/textenc.h" | |
| #include "rtl/ustrbuf.hxx" | |
| #include "rtl/ustring.h" | |
| #include "rtl/ustring.hxx" | |
| #include "sal/types.h" | |
| #include "additions.hxx" | |
| #include "data.hxx" | |
| #include "groupnode.hxx" | |
| #include "node.hxx" | |
| #include "nodemap.hxx" | |
| #include "setnode.hxx" | |
| namespace configmgr { | |
| namespace { | |
| namespace css = com::sun::star; | |
| bool decode( | |
| rtl::OUString const & encoded, sal_Int32 begin, sal_Int32 end, | |
| rtl::OUString * decoded) | |
| { | |
| OSL_ASSERT( | |
| begin >= 0 && begin <= end && end <= encoded.getLength() && | |
| decoded != 0); | |
| rtl::OUStringBuffer buf; | |
| while (begin != end) { | |
| sal_Unicode c = encoded[begin++]; | |
| if (c == '&') { | |
| if (encoded.matchAsciiL(RTL_CONSTASCII_STRINGPARAM("amp;"), begin)) | |
| { | |
| buf.append(sal_Unicode('&')); | |
| begin += RTL_CONSTASCII_LENGTH("amp;"); | |
| } else if (encoded.matchAsciiL( | |
| RTL_CONSTASCII_STRINGPARAM("quot;"), begin)) | |
| { | |
| buf.append(sal_Unicode('"')); | |
| begin += RTL_CONSTASCII_LENGTH("quot;"); | |
| } else if (encoded.matchAsciiL( | |
| RTL_CONSTASCII_STRINGPARAM("apos;"), begin)) | |
| { | |
| buf.append(sal_Unicode('\'')); | |
| begin += RTL_CONSTASCII_LENGTH("apos;"); | |
| } else { | |
| return false; | |
| } | |
| OSL_ASSERT(begin <= end); | |
| } else { | |
| buf.append(c); | |
| } | |
| } | |
| *decoded = buf.makeStringAndClear(); | |
| return true; | |
| } | |
| } | |
| rtl::OUString Data::createSegment( | |
| rtl::OUString const & templateName, rtl::OUString const & name) | |
| { | |
| if (templateName.getLength() == 0) { | |
| return name; | |
| } | |
| rtl::OUStringBuffer buf(templateName); | |
| //TODO: verify template name contains no bad chars? | |
| buf.appendAscii(RTL_CONSTASCII_STRINGPARAM("['")); | |
| for (sal_Int32 i = 0; i < name.getLength(); ++i) { | |
| sal_Unicode c = name[i]; | |
| switch (c) { | |
| case '&': | |
| buf.appendAscii(RTL_CONSTASCII_STRINGPARAM("&")); | |
| break; | |
| case '"': | |
| buf.appendAscii(RTL_CONSTASCII_STRINGPARAM(""")); | |
| break; | |
| case '\'': | |
| buf.appendAscii(RTL_CONSTASCII_STRINGPARAM("'")); | |
| break; | |
| default: | |
| buf.append(c); | |
| break; | |
| } | |
| } | |
| buf.appendAscii(RTL_CONSTASCII_STRINGPARAM("']")); | |
| return buf.makeStringAndClear(); | |
| } | |
| sal_Int32 Data::parseSegment( | |
| rtl::OUString const & path, sal_Int32 index, rtl::OUString * name, | |
| bool * setElement, rtl::OUString * templateName) | |
| { | |
| OSL_ASSERT( | |
| index >= 0 && index <= path.getLength() && name != 0 && | |
| setElement != 0); | |
| sal_Int32 i = index; | |
| while (i < path.getLength() && path[i] != '/' && path[i] != '[') { | |
| ++i; | |
| } | |
| if (i == path.getLength() || path[i] == '/') { | |
| *name = path.copy(index, i - index); | |
| *setElement = false; | |
| return i; | |
| } | |
| if (templateName != 0) { | |
| if (i - index == 1 && path[index] == '*') { | |
| *templateName = rtl::OUString(); | |
| } else { | |
| *templateName = path.copy(index, i - index); | |
| } | |
| } | |
| if (++i == path.getLength()) { | |
| return -1; | |
| } | |
| sal_Unicode del = path[i++]; | |
| if (del != '\'' && del != '"') { | |
| return -1; | |
| } | |
| sal_Int32 j = path.indexOf(del, i); | |
| if (j == -1 || j + 1 == path.getLength() || path[j + 1] != ']' || | |
| !decode(path, i, j, name)) | |
| { | |
| return -1; | |
| } | |
| *setElement = true; | |
| return j + 2; | |
| } | |
| rtl::OUString Data::fullTemplateName( | |
| rtl::OUString const & component, rtl::OUString const & name) | |
| { | |
| if (component.indexOf(':') != -1 || name.indexOf(':') != -1) { | |
| throw css::uno::RuntimeException( | |
| (rtl::OUString( | |
| RTL_CONSTASCII_USTRINGPARAM( | |
| "bad component/name pair containing colon ")) + | |
| component + rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("/")) + | |
| name), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| } | |
| rtl::OUStringBuffer buf(component); | |
| buf.append(sal_Unicode(':')); | |
| buf.append(name); | |
| return buf.makeStringAndClear(); | |
| } | |
| bool Data::equalTemplateNames( | |
| rtl::OUString const & shortName, rtl::OUString const & longName) | |
| { | |
| if (shortName.indexOf(':') == -1) { | |
| sal_Int32 i = longName.indexOf(':') + 1; | |
| OSL_ASSERT(i > 0); | |
| return | |
| rtl_ustr_compare_WithLength( | |
| shortName.getStr(), shortName.getLength(), | |
| longName.getStr() + i, longName.getLength() - i) == | |
| 0; | |
| } else { | |
| return shortName == longName; | |
| } | |
| } | |
| rtl::Reference< Node > Data::findNode( | |
| int layer, NodeMap const & map, rtl::OUString const & name) | |
| { | |
| NodeMap::const_iterator i(map.find(name)); | |
| return i == map.end() || i->second->getLayer() > layer | |
| ? rtl::Reference< Node >() : i->second; | |
| } | |
| rtl::Reference< Node > Data::resolvePathRepresentation( | |
| rtl::OUString const & pathRepresentation, | |
| rtl::OUString * canonicRepresentation, Path * path, int * finalizedLayer) | |
| const | |
| { | |
| if (pathRepresentation.getLength() == 0 || pathRepresentation[0] != '/') { | |
| throw css::uno::RuntimeException( | |
| (rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("bad path ")) + | |
| pathRepresentation), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| } | |
| rtl::OUString seg; | |
| bool setElement; | |
| rtl::OUString templateName; | |
| sal_Int32 n = parseSegment(pathRepresentation, 1, &seg, &setElement, 0); | |
| if (n == -1 || setElement) | |
| { | |
| throw css::uno::RuntimeException( | |
| (rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("bad path ")) + | |
| pathRepresentation), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| } | |
| NodeMap::const_iterator i(components.find(seg)); | |
| rtl::OUStringBuffer canonic; | |
| if (path != 0) { | |
| path->clear(); | |
| } | |
| rtl::Reference< Node > parent; | |
| int finalized = NO_LAYER; | |
| for (rtl::Reference< Node > p(i == components.end() ? 0 : i->second);;) { | |
| if (!p.is()) { | |
| return p; | |
| } | |
| if (canonicRepresentation != 0) { | |
| canonic.append(sal_Unicode('/')); | |
| canonic.append(createSegment(templateName, seg)); | |
| } | |
| if (path != 0) { | |
| path->push_back(seg); | |
| } | |
| finalized = std::min(finalized, p->getFinalized()); | |
| if (n != pathRepresentation.getLength() && | |
| pathRepresentation[n++] != '/') | |
| { | |
| throw css::uno::RuntimeException( | |
| (rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("bad path ")) + | |
| pathRepresentation), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| } | |
| // for backwards compatibility, ignore a final slash | |
| if (n == pathRepresentation.getLength()) { | |
| if (canonicRepresentation != 0) { | |
| *canonicRepresentation = canonic.makeStringAndClear(); | |
| } | |
| if (finalizedLayer != 0) { | |
| *finalizedLayer = finalized; | |
| } | |
| return p; | |
| } | |
| parent = p; | |
| templateName = rtl::OUString(); | |
| n = parseSegment( | |
| pathRepresentation, n, &seg, &setElement, &templateName); | |
| if (n == -1) { | |
| throw css::uno::RuntimeException( | |
| (rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("bad path ")) + | |
| pathRepresentation), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| } | |
| // For backwards compatibility, allow set members to be accessed with | |
| // simple path segments, like group members: | |
| p = p->getMember(seg); | |
| if (setElement) { | |
| switch (parent->kind()) { | |
| case Node::KIND_LOCALIZED_PROPERTY: | |
| if (templateName.getLength() != 0) { | |
| throw css::uno::RuntimeException( | |
| (rtl::OUString( | |
| RTL_CONSTASCII_USTRINGPARAM("bad path ")) + | |
| pathRepresentation), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| } | |
| break; | |
| case Node::KIND_SET: | |
| if (templateName.getLength() != 0 && | |
| !dynamic_cast< SetNode * >(parent.get())->isValidTemplate( | |
| templateName)) | |
| { | |
| throw css::uno::RuntimeException( | |
| (rtl::OUString( | |
| RTL_CONSTASCII_USTRINGPARAM("bad path ")) + | |
| pathRepresentation), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| } | |
| break; | |
| default: | |
| throw css::uno::RuntimeException( | |
| (rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("bad path ")) + | |
| pathRepresentation), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| } | |
| if (templateName.getLength() != 0 && p != 0) { | |
| OSL_ASSERT(p->getTemplateName().getLength() != 0); | |
| if (!equalTemplateNames(templateName, p->getTemplateName())) { | |
| throw css::uno::RuntimeException( | |
| (rtl::OUString( | |
| RTL_CONSTASCII_USTRINGPARAM("bad path ")) + | |
| pathRepresentation), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| rtl::Reference< Node > Data::getTemplate( | |
| int layer, rtl::OUString const & fullName) const | |
| { | |
| return findNode(layer, templates, fullName); | |
| } | |
| Additions * Data::addExtensionXcuAdditions( | |
| rtl::OUString const & url, int layer) | |
| { | |
| rtl::Reference< ExtensionXcu > item(new ExtensionXcu); | |
| ExtensionXcuAdditions::iterator i( | |
| extensionXcuAdditions_.insert( | |
| ExtensionXcuAdditions::value_type( | |
| url, rtl::Reference< ExtensionXcu >())).first); | |
| if (i->second.is()) { | |
| throw css::uno::RuntimeException( | |
| (rtl::OUString( | |
| RTL_CONSTASCII_USTRINGPARAM( | |
| "already added extension xcu ")) + | |
| url), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| } | |
| i->second = item; | |
| item->layer = layer; | |
| return &item->additions; | |
| } | |
| rtl::Reference< Data::ExtensionXcu > Data::removeExtensionXcuAdditions( | |
| rtl::OUString const & url) | |
| { | |
| ExtensionXcuAdditions::iterator i(extensionXcuAdditions_.find(url)); | |
| if (i == extensionXcuAdditions_.end()) { | |
| // This can happen, as migration of pre OOo 3.3 UserInstallation | |
| // extensions in dp_registry::backend::configuration::BackendImpl:: | |
| // PackageImpl::processPackage_ can cause just-in-time creation of | |
| // extension xcu files that are never added via addExtensionXcuAdditions | |
| // (also, there might be url spelling differences between calls to | |
| // addExtensionXcuAdditions and removeExtensionXcuAdditions?): | |
| OSL_TRACE( | |
| "unknown configmgr::Data::removeExtensionXcuAdditions(%s)", | |
| rtl::OUStringToOString(url, RTL_TEXTENCODING_UTF8).getStr()); | |
| return rtl::Reference< ExtensionXcu >(); | |
| } | |
| rtl::Reference< ExtensionXcu > item(i->second); | |
| extensionXcuAdditions_.erase(i); | |
| return item; | |
| } | |
| } |