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