unotools/source/config/configpaths.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <sal/config.h>
  21
  22 #include <string_view>
  23
  24 #include <unotools/configpaths.hxx>
  25 #include <rtl/ustring.hxx>
  26 #include <rtl/ustrbuf.hxx>
  27 #include <osl/diagnose.h>
  28
  29 namespace utl
  30 {
  31
  32 static
  33 void lcl_resolveCharEntities(OUString & aLocalString)
  34 {
  35     sal_Int32 nEscapePos=aLocalString.indexOf('&');
  36     if (nEscapePos < 0) return;
  37
  38     OUStringBuffer aResult;
  39     sal_Int32 nStart = 0;
  40
  41     do
  42     {
  43         sal_Unicode ch = 0;
  44         if (aLocalString.match("&amp;",nEscapePos))
  45             ch = '&';
  46
  47         else if (aLocalString.match("&apos;",nEscapePos))
  48             ch = '\'';
  49
  50         else if (aLocalString.match("&quot;",nEscapePos))
  51             ch = '"';
  52
  53         OSL_ENSURE(ch,"Configuration path contains '&' that is not part of a valid character escape");
  54         if (ch)
  55         {
  56             aResult.append(std::u16string_view(aLocalString).substr(nStart,nEscapePos-nStart)).append(ch);
  57
  58             sal_Int32 nEscapeEnd=aLocalString.indexOf(';',nEscapePos);
  59             nStart = nEscapeEnd+1;
  60             nEscapePos=aLocalString.indexOf('&',nStart);
  61         }
  62         else
  63         {
  64             nEscapePos=aLocalString.indexOf('&',nEscapePos+1);
  65         }
  66     }
  67     while ( nEscapePos > 0);
  68
  69     aResult.append(std::u16string_view(aLocalString).substr(nStart));
  70
  71     aLocalString = aResult.makeStringAndClear();
  72 }
  73
  74 bool splitLastFromConfigurationPath(OUString const& _sInPath,
  75                                         OUString& _rsOutPath,
  76                                         OUString& _rsLocalName)
  77 {
  78     sal_Int32 nStart,nEnd;
  79
  80     sal_Int32 nPos = _sInPath.getLength()-1;
  81
  82     // strip trailing slash
  83     if (nPos > 0 && _sInPath[ nPos ] == '/')
  84     {
  85         OSL_FAIL("Invalid config path: trailing '/' is not allowed");
  86         --nPos;
  87     }
  88
  89     // check for predicate ['xxx'] or ["yyy"]
  90     if (nPos  > 0 && _sInPath[ nPos ] == ']')
  91     {
  92         sal_Unicode chQuote = _sInPath[--nPos];
  93
  94         if (chQuote == '\'' || chQuote == '\"')
  95         {
  96             nEnd = nPos;
  97             nPos = _sInPath.lastIndexOf(chQuote,nEnd);
  98             nStart = nPos + 1;
  99             --nPos; // nPos = rInPath.lastIndexOf('[',nPos);
 100         }
 101         else // allow [xxx]
 102         {
 103             nEnd = nPos + 1;
 104             nPos = _sInPath.lastIndexOf('[',nEnd);
 105             nStart = nPos + 1;
 106         }
 107
 108         OSL_ENSURE(nPos >= 0 && _sInPath[nPos] == '[', "Invalid config path: unmatched quotes or brackets");
 109         if (nPos >= 0 && _sInPath[nPos] == '[')
 110         {
 111             nPos =  _sInPath.lastIndexOf('/',nPos);
 112         }
 113         else // defined behavior for invalid paths
 114         {
 115             nStart = 0;
 116             nEnd = _sInPath.getLength();
 117             nPos = -1;
 118         }
 119
 120     }
 121     else
 122     {
 123         nEnd = nPos+1;
 124         nPos = _sInPath.lastIndexOf('/',nEnd);
 125         nStart = nPos + 1;
 126     }
 127     OSL_ASSERT( -1 <= nPos &&
 128                 nPos < nStart &&
 129                 nStart < nEnd &&
 130                 nEnd <= _sInPath.getLength() );
 131
 132     OSL_ASSERT(nPos == -1 || _sInPath[nPos] == '/');
 133     OSL_ENSURE(nPos != 0 , "Invalid config child path: immediate child of root");
 134
 135     _rsLocalName = _sInPath.copy(nStart, nEnd-nStart);
 136     _rsOutPath = (nPos > 0) ? _sInPath.copy(0,nPos) : OUString();
 137     lcl_resolveCharEntities(_rsLocalName);
 138
 139     return nPos >= 0;
 140 }
 141
 142 OUString extractFirstFromConfigurationPath(OUString const& _sInPath, OUString* _sOutPath)
 143 {
 144     sal_Int32 nSep      = _sInPath.indexOf('/');
 145     sal_Int32 nBracket  = _sInPath.indexOf('[');
 146
 147     sal_Int32 nStart    = nBracket + 1;
 148     sal_Int32 nEnd      = nSep;
 149
 150     if (0 <= nBracket) // found a bracket-quoted relative path
 151     {
 152         if (nSep < 0 || nBracket < nSep) // and the separator comes after it
 153         {
 154             sal_Unicode chQuote = _sInPath[nStart];
 155             if (chQuote == '\'' || chQuote == '\"')
 156             {
 157                 ++nStart;
 158                 nEnd      = _sInPath.indexOf(chQuote, nStart+1);
 159                 nBracket  = nEnd+1;
 160             }
 161             else
 162             {
 163                 nEnd = _sInPath.indexOf(']',nStart);
 164                 nBracket = nEnd;
 165             }
 166             OSL_ENSURE(nEnd > nStart && _sInPath[nBracket] == ']', "Invalid config path: improper mismatch of quote or bracket");
 167             OSL_ENSURE((nBracket+1 == _sInPath.getLength() && nSep == -1) || (_sInPath[nBracket+1] == '/' && nSep == nBracket+1), "Invalid config path: brackets not followed by slash");
 168         }
 169         else // ... but our initial element name is in simple form
 170             nStart = 0;
 171     }
 172
 173     OUString sResult = (nEnd >= 0) ? _sInPath.copy(nStart, nEnd-nStart) : _sInPath;
 174     lcl_resolveCharEntities(sResult);
 175
 176     if (_sOutPath != nullptr)
 177     {
 178         *_sOutPath = (nSep >= 0) ? _sInPath.copy(nSep + 1) : OUString();
 179     }
 180
 181     return sResult;
 182 }
 183
 184 // find the position after the prefix in the nested path
 185 static sal_Int32 lcl_findPrefixEnd(OUString const& _sNestedPath, OUString const& _sPrefixPath)
 186 {
 187     // TODO: currently handles only exact prefix matches
 188     sal_Int32 nPrefixLength = _sPrefixPath.getLength();
 189
 190     OSL_ENSURE(nPrefixLength == 0 || _sPrefixPath[nPrefixLength-1] != '/',
 191                 "Cannot handle slash-terminated prefix paths");
 192
 193     bool bIsPrefix;
 194     if (_sNestedPath.getLength() > nPrefixLength)
 195     {
 196         bIsPrefix = _sNestedPath[nPrefixLength] == '/' &&
 197                     _sNestedPath.startsWith(_sPrefixPath);
 198         ++nPrefixLength;
 199     }
 200     else if (_sNestedPath.getLength() == nPrefixLength)
 201     {
 202         bIsPrefix = _sNestedPath == _sPrefixPath;
 203     }
 204     else
 205     {
 206         bIsPrefix = false;
 207     }
 208
 209     return bIsPrefix ? nPrefixLength : 0;
 210 }
 211
 212 bool isPrefixOfConfigurationPath(OUString const& _sNestedPath,
 213                                      OUString const& _sPrefixPath)
 214 {
 215     return _sPrefixPath.isEmpty() || lcl_findPrefixEnd(_sNestedPath,_sPrefixPath) != 0;
 216 }
 217
 218 OUString dropPrefixFromConfigurationPath(OUString const& _sNestedPath,
 219                                          OUString const& _sPrefixPath)
 220 {
 221     if ( sal_Int32 nPrefixEnd = lcl_findPrefixEnd(_sNestedPath,_sPrefixPath) )
 222     {
 223         return _sNestedPath.copy(nPrefixEnd);
 224     }
 225     else
 226     {
 227         OSL_ENSURE(_sPrefixPath.isEmpty(),  "Path does not start with expected prefix");
 228
 229         return _sNestedPath;
 230     }
 231 }
 232
 233 static
 234 OUString lcl_wrapName(const OUString& _sContent, const OUString& _sType)
 235 {
 236     const sal_Unicode * const pBeginContent = _sContent.getStr();
 237     const sal_Unicode * const pEndContent   = pBeginContent + _sContent.getLength();
 238
 239     OSL_PRECOND(!_sType.isEmpty(), "Unexpected config type name: empty");
 240     OSL_PRECOND(pBeginContent <= pEndContent, "Invalid config name: empty");
 241
 242     if (pBeginContent == pEndContent)
 243         return _sType;
 244
 245     OUStringBuffer aNormalized(_sType.getLength() + _sContent.getLength() + 4); // reserve approximate size initially
 246
 247     // prefix: type, opening bracket and quote
 248     aNormalized.append( _sType ).append( "['" );
 249
 250     // content: copy over each char and handle escaping
 251     for(const sal_Unicode* pCur = pBeginContent; pCur != pEndContent; ++pCur)
 252     {
 253         // append (escape if needed)
 254         switch(*pCur)
 255         {
 256         case u'&' : aNormalized.append( "&amp;" ); break;
 257         case u'\'': aNormalized.append( "&apos;" ); break;
 258         case u'\"': aNormalized.append( "&quot;" ); break;
 259
 260         default: aNormalized.append( *pCur );
 261         }
 262     }
 263
 264     // suffix: closing quote and bracket
 265     aNormalized.append( "']" );
 266
 267     return aNormalized.makeStringAndClear();
 268 }
 269
 270 OUString wrapConfigurationElementName(OUString const& _sElementName)
 271 {
 272     return lcl_wrapName(_sElementName, "*" );
 273 }
 274
 275 OUString wrapConfigurationElementName(OUString const& _sElementName,
 276                                       OUString const& _sTypeName)
 277 {
 278     // todo: check that _sTypeName is valid
 279     return lcl_wrapName(_sElementName, _sTypeName);
 280 }
 281
 282 } // namespace utl
 283
 284 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */