LCOV - code coverage report
Current view: top level - libreoffice/svl/source/misc - urihelper.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 10 294 3.4 %
Date: 2012-12-27 Functions: 2 15 13.3 %
Legend: Lines: hit not hit

          Line data    Source code
       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 <svl/urihelper.hxx>
      21             : #include "com/sun/star/ucb/Command.hpp"
      22             : #include "com/sun/star/ucb/IllegalIdentifierException.hpp"
      23             : #include "com/sun/star/ucb/UniversalContentBroker.hpp"
      24             : #include "com/sun/star/ucb/UnsupportedCommandException.hpp"
      25             : #include "com/sun/star/ucb/XCommandEnvironment.hpp"
      26             : #include "com/sun/star/ucb/XCommandProcessor.hpp"
      27             : #include "com/sun/star/ucb/XContent.hpp"
      28             : #include "com/sun/star/ucb/XUniversalContentBroker.hpp"
      29             : #include "com/sun/star/uno/Any.hxx"
      30             : #include "com/sun/star/uno/Exception.hpp"
      31             : #include "com/sun/star/uno/Reference.hxx"
      32             : #include "com/sun/star/uno/RuntimeException.hpp"
      33             : #include "com/sun/star/uno/XComponentContext.hpp"
      34             : #include "com/sun/star/uri/UriReferenceFactory.hpp"
      35             : #include "com/sun/star/uri/XUriReference.hpp"
      36             : #include "com/sun/star/uri/XUriReferenceFactory.hpp"
      37             : #include "comphelper/processfactory.hxx"
      38             : #include "osl/diagnose.h"
      39             : #include "rtl/ustrbuf.hxx"
      40             : #include "rtl/ustring.h"
      41             : #include "rtl/ustring.hxx"
      42             : #include "sal/types.h"
      43             : #include <tools/inetmime.hxx>
      44             : #include <unotools/charclass.hxx>
      45             : #include "rtl/instance.hxx"
      46             : 
      47             : using namespace com::sun::star;
      48             : 
      49             : //============================================================================
      50             : //
      51             : //  SmartRel2Abs
      52             : //
      53             : //============================================================================
      54             : 
      55           2 : OUString URIHelper::SmartRel2Abs(INetURLObject const & rTheBaseURIRef,
      56             :                                  OUString const & rTheRelURIRef,
      57             :                                  Link const & rMaybeFileHdl,
      58             :                                  bool bCheckFileExists,
      59             :                                  bool bIgnoreFragment,
      60             :                                  INetURLObject::EncodeMechanism eEncodeMechanism,
      61             :                                  INetURLObject::DecodeMechanism eDecodeMechanism,
      62             :                                  rtl_TextEncoding eCharset,
      63             :                                  bool bRelativeNonURIs,
      64             :                                  INetURLObject::FSysStyle eStyle)
      65             : {
      66             :     // Backwards compatibility:
      67           2 :     if (!rTheRelURIRef.isEmpty() && rTheRelURIRef[0] == '#')
      68           0 :         return rTheRelURIRef;
      69             : 
      70           2 :     INetURLObject aAbsURIRef;
      71           2 :     if (rTheBaseURIRef.HasError())
      72           0 :         aAbsURIRef. SetSmartURL(rTheRelURIRef, eEncodeMechanism, eCharset, eStyle);
      73             :     else
      74             :     {
      75             :         bool bWasAbsolute;
      76             :         aAbsURIRef = rTheBaseURIRef.smartRel2Abs(rTheRelURIRef,
      77             :                                                  bWasAbsolute,
      78             :                                                  bIgnoreFragment,
      79             :                                                  eEncodeMechanism,
      80             :                                                  eCharset,
      81             :                                                  bRelativeNonURIs,
      82           2 :                                                  eStyle);
      83           2 :         if (bCheckFileExists
      84           0 :             && !bWasAbsolute
      85           0 :             && (aAbsURIRef.GetProtocol() == INET_PROT_FILE))
      86             :         {
      87           0 :             INetURLObject aNonFileURIRef;
      88             :             aNonFileURIRef.SetSmartURL(rTheRelURIRef,
      89             :                                        eEncodeMechanism,
      90             :                                        eCharset,
      91           0 :                                        eStyle);
      92           0 :             if (!aNonFileURIRef.HasError()
      93           0 :                 && aNonFileURIRef.GetProtocol() != INET_PROT_FILE)
      94             :             {
      95           0 :                 bool bMaybeFile = false;
      96           0 :                 if (rMaybeFileHdl.IsSet())
      97             :                 {
      98           0 :                     OUString aFilePath(rTheRelURIRef);
      99           0 :                     bMaybeFile = rMaybeFileHdl.Call(&aFilePath) != 0;
     100             :                 }
     101           0 :                 if (!bMaybeFile)
     102           0 :                     aAbsURIRef = aNonFileURIRef;
     103           0 :             }
     104             :         }
     105             :     }
     106           2 :     return aAbsURIRef.GetMainURL(eDecodeMechanism, eCharset);
     107             : }
     108             : 
     109             : //============================================================================
     110             : //
     111             : //  SetMaybeFileHdl
     112             : //
     113             : //============================================================================
     114             : 
     115             : namespace { struct MaybeFileHdl : public rtl::Static< Link, MaybeFileHdl > {}; }
     116             : 
     117           9 : void URIHelper::SetMaybeFileHdl(Link const & rTheMaybeFileHdl)
     118             : {
     119           9 :     MaybeFileHdl::get() = rTheMaybeFileHdl;
     120           9 : }
     121             : 
     122             : //============================================================================
     123             : //
     124             : //  GetMaybeFileHdl
     125             : //
     126             : //============================================================================
     127             : 
     128           0 : Link URIHelper::GetMaybeFileHdl()
     129             : {
     130           0 :     return MaybeFileHdl::get();
     131             : }
     132             : 
     133             : namespace {
     134             : 
     135           0 : bool isAbsoluteHierarchicalUriReference(
     136             :     css::uno::Reference< css::uri::XUriReference > const & uriReference)
     137             : {
     138           0 :     return uriReference.is() && uriReference->isAbsolute()
     139           0 :         && uriReference->isHierarchical() && !uriReference->hasRelativePath();
     140             : }
     141             : 
     142             : // To improve performance, assume that if for any prefix URL of a given
     143             : // hierarchical URL either a UCB content cannot be created, or the UCB content
     144             : // does not support the getCasePreservingURL command, then this will hold for
     145             : // any other prefix URL of the given URL, too:
     146             : enum Result { Success, GeneralFailure, SpecificFailure };
     147             : 
     148           0 : Result normalizePrefix( css::uno::Reference< css::ucb::XUniversalContentBroker > const & broker,
     149             :                         OUString const & uri, OUString * normalized)
     150             : {
     151             :     OSL_ASSERT(broker.is() && normalized != 0);
     152           0 :     css::uno::Reference< css::ucb::XContent > content;
     153             :     try {
     154           0 :         content = broker->queryContent(broker->createContentIdentifier(uri));
     155           0 :     } catch (css::ucb::IllegalIdentifierException &) {}
     156           0 :     if (!content.is()) {
     157           0 :         return GeneralFailure;
     158             :     }
     159             :     try {
     160             :         #if OSL_DEBUG_LEVEL > 0
     161             :         bool ok =
     162             :         #endif
     163             :             (css::uno::Reference< css::ucb::XCommandProcessor >(
     164           0 :                    content, css::uno::UNO_QUERY_THROW)->execute(
     165             :                        css::ucb::Command("getCasePreservingURL",
     166             :                            -1, css::uno::Any()),
     167             :                        0,
     168           0 :                        css::uno::Reference< css::ucb::XCommandEnvironment >())
     169           0 :                >>= *normalized);
     170             :         OSL_ASSERT(ok);
     171           0 :     } catch (css::uno::RuntimeException &) {
     172           0 :         throw;
     173           0 :     } catch (css::ucb::UnsupportedCommandException &) {
     174           0 :         return GeneralFailure;
     175           0 :     } catch (css::uno::Exception &) {
     176           0 :         return SpecificFailure;
     177             :     }
     178           0 :     return Success;
     179             : }
     180             : 
     181           0 : OUString normalize(
     182             :     css::uno::Reference< css::ucb::XUniversalContentBroker > const & broker,
     183             :     css::uno::Reference< css::uri::XUriReferenceFactory > const & uriFactory,
     184             :     OUString const & uriReference)
     185             : {
     186             :     // normalizePrefix can potentially fail (a typically example being a file
     187             :     // URL that denotes a non-existing resource); in such a case, try to
     188             :     // normalize as long a prefix of the given URL as possible (i.e., normalize
     189             :     // all the existing directories within the path):
     190           0 :     OUString normalized;
     191           0 :     sal_Int32 n = uriReference.indexOf('#');
     192           0 :     normalized = n == -1 ? uriReference : uriReference.copy(0, n);
     193           0 :     switch (normalizePrefix(broker, normalized, &normalized)) {
     194             :     case Success:
     195           0 :         return n == -1 ? normalized : normalized + uriReference.copy(n);
     196             :     case GeneralFailure:
     197           0 :         return uriReference;
     198             :     case SpecificFailure:
     199             :     default:
     200           0 :         break;
     201             :     }
     202             :     css::uno::Reference< css::uri::XUriReference > ref(
     203           0 :         uriFactory->parse(uriReference));
     204           0 :     if (!isAbsoluteHierarchicalUriReference(ref)) {
     205           0 :         return uriReference;
     206             :     }
     207           0 :     sal_Int32 count = ref->getPathSegmentCount();
     208           0 :     if (count < 2) {
     209           0 :         return uriReference;
     210             :     }
     211           0 :     OUStringBuffer head(ref->getScheme());
     212           0 :     head.append(static_cast< sal_Unicode >(':'));
     213           0 :     if (ref->hasAuthority()) {
     214           0 :         head.appendAscii(RTL_CONSTASCII_STRINGPARAM("//"));
     215           0 :         head.append(ref->getAuthority());
     216             :     }
     217           0 :     for (sal_Int32 i = count - 1; i > 0; --i) {
     218           0 :         OUStringBuffer buf(head);
     219           0 :         for (sal_Int32 j = 0; j < i; ++j) {
     220           0 :             buf.append(static_cast< sal_Unicode >('/'));
     221           0 :             buf.append(ref->getPathSegment(j));
     222             :         }
     223           0 :         normalized = buf.makeStringAndClear();
     224           0 :         if (normalizePrefix(broker, normalized, &normalized) != SpecificFailure)
     225             :         {
     226           0 :             buf.append(normalized);
     227             :             css::uno::Reference< css::uri::XUriReference > preRef(
     228           0 :                 uriFactory->parse(normalized));
     229           0 :             if (!isAbsoluteHierarchicalUriReference(preRef)) {
     230             :                 // This could only happen if something is inconsistent:
     231             :                 break;
     232             :             }
     233           0 :             sal_Int32 preCount = preRef->getPathSegmentCount();
     234             :             // normalizePrefix may have added or removed a final slash:
     235           0 :             if (preCount != i) {
     236           0 :                 if (preCount == i - 1) {
     237           0 :                     buf.append(static_cast< sal_Unicode >('/'));
     238           0 :                 } else if (preCount - 1 == i && buf.getLength() > 0
     239           0 :                            && buf[buf.getLength() - 1] == '/')
     240             :                 {
     241           0 :                     buf.setLength(buf.getLength() - 1);
     242             :                 } else {
     243             :                     // This could only happen if something is inconsistent:
     244             :                     break;
     245             :                 }
     246             :             }
     247           0 :             for (sal_Int32 j = i; j < count; ++j) {
     248           0 :                 buf.append(static_cast< sal_Unicode >('/'));
     249           0 :                 buf.append(ref->getPathSegment(j));
     250             :             }
     251           0 :             if (ref->hasQuery()) {
     252           0 :                 buf.append(static_cast< sal_Unicode >('?'));
     253           0 :                 buf.append(ref->getQuery());
     254             :             }
     255           0 :             if (ref->hasFragment()) {
     256           0 :                 buf.append(static_cast< sal_Unicode >('#'));
     257           0 :                 buf.append(ref->getFragment());
     258             :             }
     259           0 :             return buf.makeStringAndClear();
     260             :         }
     261           0 :     }
     262           0 :     return uriReference;
     263             : }
     264             : 
     265             : }
     266             : 
     267             : css::uno::Reference< css::uri::XUriReference >
     268           0 : URIHelper::normalizedMakeRelative(
     269             :     css::uno::Reference< css::uno::XComponentContext > const & context,
     270             :     OUString const & baseUriReference, OUString const & uriReference)
     271             : {
     272             :     OSL_ASSERT(context.is());
     273             :     css::uno::Reference< css::ucb::XUniversalContentBroker > broker(
     274           0 :         css::ucb::UniversalContentBroker::create(context));
     275             :     css::uno::Reference< css::uri::XUriReferenceFactory > uriFactory(
     276           0 :         css::uri::UriReferenceFactory::create(context));
     277           0 :     return uriFactory->makeRelative(
     278           0 :         uriFactory->parse(normalize(broker, uriFactory, baseUriReference)),
     279           0 :         uriFactory->parse(normalize(broker, uriFactory, uriReference)), true,
     280           0 :         true, false);
     281             : }
     282             : 
     283           0 : OUString URIHelper::simpleNormalizedMakeRelative(
     284             :     OUString const & baseUriReference, OUString const & uriReference)
     285             : {
     286             :     com::sun::star::uno::Reference< com::sun::star::uri::XUriReference > rel(
     287             :         URIHelper::normalizedMakeRelative(
     288             :             comphelper::getProcessComponentContext(), baseUriReference,
     289           0 :             uriReference));
     290           0 :     return rel.is() ? rel->getUriReference() : uriReference;
     291             : }
     292             : 
     293             : //============================================================================
     294             : //
     295             : //  FindFirstURLInText
     296             : //
     297             : //============================================================================
     298             : 
     299             : namespace {
     300             : 
     301           0 : inline sal_Int32 nextChar(OUString const & rStr, sal_Int32 nPos)
     302             : {
     303           0 :     return INetMIME::isHighSurrogate(rStr[nPos])
     304           0 :            && rStr.getLength() - nPos >= 2
     305           0 :            && INetMIME::isLowSurrogate(rStr[nPos + 1]) ?
     306           0 :         nPos + 2 : nPos + 1;
     307             : }
     308             : 
     309           0 : bool isBoundary1(CharClass const & rCharClass, OUString const & rStr,
     310             :                  sal_Int32 nPos, sal_Int32 nEnd)
     311             : {
     312           0 :     if (nPos == nEnd)
     313           0 :         return true;
     314           0 :     if (rCharClass.isLetterNumeric(rStr, nPos))
     315           0 :         return false;
     316           0 :     switch (rStr[nPos])
     317             :     {
     318             :     case '$':
     319             :     case '%':
     320             :     case '&':
     321             :     case '-':
     322             :     case '/':
     323             :     case '@':
     324             :     case '\\':
     325           0 :         return false;
     326             :     default:
     327           0 :         return true;
     328             :     }
     329             : }
     330             : 
     331           0 : bool isBoundary2(CharClass const & rCharClass, OUString const & rStr,
     332             :                  sal_Int32 nPos, sal_Int32 nEnd)
     333             : {
     334           0 :     if (nPos == nEnd)
     335           0 :         return true;
     336           0 :     if (rCharClass.isLetterNumeric(rStr, nPos))
     337           0 :         return false;
     338           0 :     switch (rStr[nPos])
     339             :     {
     340             :     case '!':
     341             :     case '#':
     342             :     case '$':
     343             :     case '%':
     344             :     case '&':
     345             :     case '\'':
     346             :     case '*':
     347             :     case '+':
     348             :     case '-':
     349             :     case '/':
     350             :     case '=':
     351             :     case '?':
     352             :     case '@':
     353             :     case '^':
     354             :     case '_':
     355             :     case '`':
     356             :     case '{':
     357             :     case '|':
     358             :     case '}':
     359             :     case '~':
     360           0 :         return false;
     361             :     default:
     362           0 :         return true;
     363             :     }
     364             : }
     365             : 
     366           0 : bool checkWChar(CharClass const & rCharClass, OUString const & rStr,
     367             :                 sal_Int32 * pPos, sal_Int32 * pEnd, bool bBackslash = false,
     368             :                 bool bPipe = false)
     369             : {
     370           0 :     sal_Unicode c = rStr[*pPos];
     371           0 :     if (INetMIME::isUSASCII(c))
     372             :     {
     373             :         static sal_uInt8 const aMap[128]
     374             :             = { 0, 0, 0, 0, 0, 0, 0, 0,
     375             :                 0, 0, 0, 0, 0, 0, 0, 0,
     376             :                 0, 0, 0, 0, 0, 0, 0, 0,
     377             :                 0, 0, 0, 0, 0, 0, 0, 0,
     378             :                 0, 1, 0, 0, 4, 4, 4, 1,   //  !"#$%&'
     379             :                 1, 1, 1, 1, 1, 4, 1, 4,   // ()*+,-./
     380             :                 4, 4, 4, 4, 4, 4, 4, 4,   // 01234567
     381             :                 4, 4, 1, 1, 0, 1, 0, 1,   // 89:;<=>?
     382             :                 4, 4, 4, 4, 4, 4, 4, 4,   // @ABCDEFG
     383             :                 4, 4, 4, 4, 4, 4, 4, 4,   // HIJKLMNO
     384             :                 4, 4, 4, 4, 4, 4, 4, 4,   // PQRSTUVW
     385             :                 4, 4, 4, 1, 2, 1, 0, 1,   // XYZ[\]^_
     386             :                 0, 4, 4, 4, 4, 4, 4, 4,   // `abcdefg
     387             :                 4, 4, 4, 4, 4, 4, 4, 4,   // hijklmno
     388             :                 4, 4, 4, 4, 4, 4, 4, 4,   // pqrstuvw
     389             :                 4, 4, 4, 0, 3, 0, 1, 0 }; // xyz{|}~
     390           0 :         switch (aMap[c])
     391             :         {
     392             :             default: // not uric
     393           0 :                 return false;
     394             : 
     395             :             case 1: // uric
     396           0 :                 ++(*pPos);
     397           0 :                 return true;
     398             : 
     399             :             case 2: // "\"
     400           0 :                 if (bBackslash)
     401             :                 {
     402           0 :                     *pEnd = ++(*pPos);
     403           0 :                     return true;
     404             :                 }
     405             :                 else
     406           0 :                     return false;
     407             : 
     408             :             case 3: // "|"
     409           0 :                 if (bPipe)
     410             :                 {
     411           0 :                     *pEnd = ++(*pPos);
     412           0 :                     return true;
     413             :                 }
     414             :                 else
     415           0 :                     return false;
     416             : 
     417             :             case 4: // alpha, digit, "$", "%", "&", "-", "/", "@" (see
     418             :                     // isBoundary1)
     419           0 :                 *pEnd = ++(*pPos);
     420           0 :                 return true;
     421             :         }
     422             :     }
     423           0 :     else if (rCharClass.isLetterNumeric(rStr, *pPos))
     424             :     {
     425           0 :         *pEnd = *pPos = nextChar(rStr, *pPos);
     426           0 :         return true;
     427             :     }
     428             :     else
     429           0 :         return false;
     430             : }
     431             : 
     432           0 : sal_uInt32 scanDomain(OUString const & rStr, sal_Int32 * pPos,
     433             :                       sal_Int32 nEnd)
     434             : {
     435           0 :     sal_Unicode const * pBuffer = rStr.getStr();
     436           0 :     sal_Unicode const * p = pBuffer + *pPos;
     437           0 :     sal_uInt32 nLabels = INetURLObject::scanDomain(p, pBuffer + nEnd, false);
     438           0 :     *pPos = sal::static_int_cast< sal_Int32 >(p - pBuffer);
     439           0 :     return nLabels;
     440             : }
     441             : 
     442             : }
     443             : 
     444           0 : OUString URIHelper::FindFirstURLInText(OUString const & rText,
     445             :                                        sal_Int32 & rBegin,
     446             :                                        sal_Int32 & rEnd,
     447             :                                        CharClass const & rCharClass,
     448             :                                        INetURLObject::EncodeMechanism eMechanism,
     449             :                                        rtl_TextEncoding eCharset,
     450             :                                        INetURLObject::FSysStyle eStyle)
     451             : {
     452           0 :     if (!(rBegin <= rEnd && rEnd <= rText.getLength()))
     453           0 :         return OUString();
     454             : 
     455             :     // Search for the first substring of [rBegin..rEnd[ that matches any of the
     456             :     // following productions (for which the appropriate style bit is set in
     457             :     // eStyle, if applicable).
     458             :     //
     459             :     // 1st Production (known scheme):
     460             :     //    \B1 <one of the known schemes, except file> ":" 1*wchar ["#" 1*wchar]
     461             :     //        \B1
     462             :     //
     463             :     // 2nd Production (file):
     464             :     //    \B1 "FILE:" 1*(wchar / "\" / "|") ["#" 1*wchar] \B1
     465             :     //
     466             :     // 3rd Production (ftp):
     467             :     //    \B1 "FTP" 2*("." label) ["/" *wchar] ["#" 1*wchar] \B1
     468             :     //
     469             :     // 4th Production (http):
     470             :     //    \B1 "WWW" 2*("." label) ["/" *wchar] ["#" 1*wchar] \B1
     471             :     //
     472             :     // 5th Production (mailto):
     473             :     //    \B2 local-part "@" domain \B1
     474             :     //
     475             :     // 6th Production (UNC file):
     476             :     //    \B1 "\\" domain "\" *(wchar / "\") \B1
     477             :     //
     478             :     // 7th Production (DOS file):
     479             :     //    \B1 ALPHA ":\" *(wchar / "\") \B1
     480             :     //
     481             :     // 8th Production (Unix-like DOS file):
     482             :     //    \B1 ALPHA ":/" *(wchar / "\") \B1
     483             :     //
     484             :     // The productions use the following auxiliary rules.
     485             :     //
     486             :     //    local-part = atom *("." atom)
     487             :     //    atom = 1*(alphanum / "!" / "#" / "$" / "%" / "&" / "'" / "*" / "+"
     488             :     //              / "-" / "/" / "=" / "?" / "^" / "_" / "`" / "{" / "|" / "}"
     489             :     //              / "~")
     490             :     //    domain = label *("." label)
     491             :     //    label = alphanum [*(alphanum / "-") alphanum]
     492             :     //    alphanum = ALPHA / DIGIT
     493             :     //    wchar = <any uric character (ignoring the escaped rule), or "%", or
     494             :     //             a letter or digit (according to rCharClass)>
     495             :     //
     496             :     // "\B1" (boundary 1) stands for the beginning or end of the block of text,
     497             :     // or a character that is neither (a) a letter or digit (according to
     498             :     // rCharClass), nor (b) any of "$", "%", "&", "-", "/", "@", or "\".
     499             :     // (FIXME:  What was the rationale for this set of punctuation characters?)
     500             :     //
     501             :     // "\B2" (boundary 2) stands for the beginning or end of the block of text,
     502             :     // or a character that is neither (a) a letter or digit (according to
     503             :     // rCharClass), nor (b) any of "!", "#", "$", "%", "&", "'", "*", "+", "-",
     504             :     // "/", "=", "?", "@", "^", "_", "`", "{", "|", "}", or "~" (i.e., an RFC
     505             :     // 822 <atom> character, or "@" from \B1's set above).
     506             :     //
     507             :     // Productions 1--4, and 6--8 try to find a maximum-length match, but they
     508             :     // stop at the first <wchar> character that is a "\B1" character which is
     509             :     // only followed by "\B1" characters (taking "\" and "|" characters into
     510             :     // account appropriately).  Production 5 simply tries to find a maximum-
     511             :     // length match.
     512             :     //
     513             :     // Productions 1--4 use the given eMechanism and eCharset.  Productions 5--9
     514             :     // use ENCODE_ALL.
     515             :     //
     516             :     // Productions 6--9 are only applicable if the FSYS_DOS bit is set in
     517             :     // eStyle.
     518             : 
     519           0 :     bool bBoundary1 = true;
     520           0 :     bool bBoundary2 = true;
     521           0 :     for (sal_Int32 nPos = rBegin; nPos != rEnd; nPos = nextChar(rText, nPos))
     522             :     {
     523           0 :         sal_Unicode c = rText[nPos];
     524           0 :         if (bBoundary1)
     525             :         {
     526           0 :             if (INetMIME::isAlpha(c))
     527             :             {
     528           0 :                 sal_Int32 i = nPos;
     529           0 :                 INetProtocol eScheme = INetURLObject::CompareProtocolScheme(rText.copy(i, rEnd - i));
     530           0 :                 if (eScheme == INET_PROT_FILE) // 2nd
     531             :                 {
     532           0 :                     while (rText[i++] != ':') ;
     533           0 :                     sal_Int32 nPrefixEnd = i;
     534           0 :                     sal_Int32 nUriEnd = i;
     535           0 :                     while (i != rEnd
     536             :                            && checkWChar(rCharClass, rText, &i, &nUriEnd, true,
     537           0 :                                          true)) ;
     538           0 :                     if (i != nPrefixEnd && rText[i] == (sal_Unicode)'#')
     539             :                     {
     540           0 :                         ++i;
     541           0 :                         while (i != rEnd
     542           0 :                                && checkWChar(rCharClass, rText, &i, &nUriEnd)) ;
     543             :                     }
     544           0 :                     if (nUriEnd != nPrefixEnd
     545           0 :                         && isBoundary1(rCharClass, rText, nUriEnd, rEnd))
     546             :                     {
     547             :                         INetURLObject aUri(rText.copy(nPos, nUriEnd - nPos),
     548             :                                            INET_PROT_FILE, eMechanism, eCharset,
     549           0 :                                            eStyle);
     550           0 :                         if (!aUri.HasError())
     551             :                         {
     552           0 :                             rBegin = nPos;
     553           0 :                             rEnd = nUriEnd;
     554             :                             return
     555           0 :                                 aUri.GetMainURL(INetURLObject::DECODE_TO_IURI);
     556           0 :                         }
     557             :                     }
     558             :                 }
     559           0 :                 else if (eScheme != INET_PROT_NOT_VALID) // 1st
     560             :                 {
     561           0 :                     while (rText[i++] != ':') ;
     562           0 :                     sal_Int32 nPrefixEnd = i;
     563           0 :                     sal_Int32 nUriEnd = i;
     564           0 :                     while (i != rEnd
     565           0 :                            && checkWChar(rCharClass, rText, &i, &nUriEnd)) ;
     566           0 :                     if (i != nPrefixEnd && rText[i] == '#')
     567             :                     {
     568           0 :                         ++i;
     569           0 :                         while (i != rEnd
     570           0 :                                && checkWChar(rCharClass, rText, &i, &nUriEnd)) ;
     571             :                     }
     572           0 :                     if (nUriEnd != nPrefixEnd
     573           0 :                         && (isBoundary1(rCharClass, rText, nUriEnd, rEnd)
     574           0 :                             || rText[nUriEnd] == '\\'))
     575             :                     {
     576             :                         INetURLObject aUri(rText.copy(nPos, nUriEnd - nPos),
     577             :                                            INET_PROT_HTTP, eMechanism,
     578           0 :                                            eCharset);
     579           0 :                         if (!aUri.HasError())
     580             :                         {
     581           0 :                             rBegin = nPos;
     582           0 :                             rEnd = nUriEnd;
     583             :                             return
     584           0 :                                 aUri.GetMainURL(INetURLObject::DECODE_TO_IURI);
     585           0 :                         }
     586             :                     }
     587             :                 }
     588             : 
     589             :                 // 3rd, 4th:
     590           0 :                 i = nPos;
     591           0 :                 sal_uInt32 nLabels = scanDomain(rText, &i, rEnd);
     592           0 :                 if (nLabels >= 3
     593           0 :                     && rText[nPos + 3] == '.'
     594           0 :                     && (((rText[nPos] == 'w'
     595           0 :                           || rText[nPos] == 'W')
     596           0 :                          && (rText[nPos + 1] == 'w'
     597           0 :                              || rText[nPos + 1] == 'W')
     598           0 :                          && (rText[nPos + 2] == 'w'
     599           0 :                              || rText[nPos + 2] == 'W'))
     600           0 :                         || ((rText[nPos] == 'f'
     601           0 :                              || rText[nPos] == 'F')
     602           0 :                             && (rText[nPos + 1] == 't'
     603           0 :                                 || rText[nPos + 1] == 'T')
     604           0 :                             && (rText[nPos + 2] == 'p'
     605           0 :                                 || rText[nPos + 2] == 'P'))))
     606             :                     // (note that rText.GetChar(nPos + 3) is guaranteed to be
     607             :                     // valid)
     608             :                 {
     609           0 :                     sal_Int32 nUriEnd = i;
     610           0 :                     if (i != rEnd && rText[i] == '/')
     611             :                     {
     612           0 :                         nUriEnd = ++i;
     613           0 :                         while (i != rEnd
     614           0 :                                && checkWChar(rCharClass, rText, &i, &nUriEnd)) ;
     615             :                     }
     616           0 :                     if (i != rEnd && rText[i] == '#')
     617             :                     {
     618           0 :                         ++i;
     619           0 :                         while (i != rEnd
     620           0 :                                && checkWChar(rCharClass, rText, &i, &nUriEnd)) ;
     621             :                     }
     622           0 :                     if (isBoundary1(rCharClass, rText, nUriEnd, rEnd)
     623           0 :                         || rText[nUriEnd] == '\\')
     624             :                     {
     625             :                         INetURLObject aUri(rText.copy(nPos, nUriEnd - nPos),
     626             :                                            INET_PROT_HTTP, eMechanism,
     627           0 :                                            eCharset);
     628           0 :                         if (!aUri.HasError())
     629             :                         {
     630           0 :                             rBegin = nPos;
     631           0 :                             rEnd = nUriEnd;
     632             :                             return
     633           0 :                                 aUri.GetMainURL(INetURLObject::DECODE_TO_IURI);
     634           0 :                         }
     635             :                     }
     636             :                 }
     637             : 
     638           0 :                 if ((eStyle & INetURLObject::FSYS_DOS) != 0 && rEnd - nPos >= 3
     639           0 :                     && rText[nPos + 1] == ':'
     640           0 :                     && (rText[nPos + 2] == '/'
     641           0 :                         || rText[nPos + 2] == '\\')) // 7th, 8th
     642             :                 {
     643           0 :                     i = nPos + 3;
     644           0 :                     sal_Int32 nUriEnd = i;
     645           0 :                     while (i != rEnd
     646           0 :                            && checkWChar(rCharClass, rText, &i, &nUriEnd)) ;
     647           0 :                     if (isBoundary1(rCharClass, rText, nUriEnd, rEnd))
     648             :                     {
     649             :                         INetURLObject aUri(rText.copy(nPos, nUriEnd - nPos),
     650             :                                            INET_PROT_FILE,
     651             :                                            INetURLObject::ENCODE_ALL,
     652             :                                            RTL_TEXTENCODING_UTF8,
     653           0 :                                            INetURLObject::FSYS_DOS);
     654           0 :                         if (!aUri.HasError())
     655             :                         {
     656           0 :                             rBegin = nPos;
     657           0 :                             rEnd = nUriEnd;
     658             :                             return
     659           0 :                                 aUri.GetMainURL(INetURLObject::DECODE_TO_IURI);
     660           0 :                         }
     661             :                     }
     662             :                 }
     663             :             }
     664           0 :             else if ((eStyle & INetURLObject::FSYS_DOS) != 0 && rEnd - nPos >= 2
     665           0 :                      && rText[nPos] == '\\'
     666           0 :                      && rText[nPos + 1] == '\\') // 6th
     667             :             {
     668           0 :                 sal_Int32 i = nPos + 2;
     669           0 :                 sal_uInt32 nLabels = scanDomain(rText, &i, rEnd);
     670           0 :                 if (nLabels >= 1 && i != rEnd && rText[i] == '\\')
     671             :                 {
     672           0 :                     sal_Int32 nUriEnd = ++i;
     673           0 :                     while (i != rEnd
     674             :                            && checkWChar(rCharClass, rText, &i, &nUriEnd,
     675           0 :                                          true)) ;
     676           0 :                     if (isBoundary1(rCharClass, rText, nUriEnd, rEnd))
     677             :                     {
     678             :                         INetURLObject aUri(rText.copy(nPos, nUriEnd - nPos),
     679             :                                            INET_PROT_FILE,
     680             :                                            INetURLObject::ENCODE_ALL,
     681             :                                            RTL_TEXTENCODING_UTF8,
     682           0 :                                            INetURLObject::FSYS_DOS);
     683           0 :                         if (!aUri.HasError())
     684             :                         {
     685           0 :                             rBegin = nPos;
     686           0 :                             rEnd = nUriEnd;
     687             :                             return
     688           0 :                                 aUri.GetMainURL(INetURLObject::DECODE_TO_IURI);
     689           0 :                         }
     690             :                     }
     691             :                 }
     692             :             }
     693             :         }
     694           0 :         if (bBoundary2 && INetMIME::isAtomChar(c)) // 5th
     695             :         {
     696           0 :             bool bDot = false;
     697           0 :             for (sal_Int32 i = nPos + 1; i != rEnd; ++i)
     698             :             {
     699           0 :                 sal_Unicode c2 = rText[i];
     700           0 :                 if (INetMIME::isAtomChar(c2))
     701           0 :                     bDot = false;
     702           0 :                 else if (bDot)
     703           0 :                     break;
     704           0 :                 else if (c2 == '.')
     705           0 :                     bDot = true;
     706             :                 else
     707             :                 {
     708           0 :                     if (c2 == '@')
     709             :                     {
     710           0 :                         ++i;
     711           0 :                         sal_uInt32 nLabels = scanDomain(rText, &i, rEnd);
     712           0 :                         if (nLabels >= 1
     713           0 :                             && isBoundary1(rCharClass, rText, i, rEnd))
     714             :                         {
     715             :                             INetURLObject aUri(rText.copy(nPos, i - nPos),
     716             :                                                INET_PROT_MAILTO,
     717           0 :                                                INetURLObject::ENCODE_ALL);
     718           0 :                             if (!aUri.HasError())
     719             :                             {
     720           0 :                                 rBegin = nPos;
     721           0 :                                 rEnd = i;
     722             :                                 return aUri.GetMainURL(
     723           0 :                                            INetURLObject::DECODE_TO_IURI);
     724           0 :                             }
     725             :                         }
     726             :                     }
     727           0 :                     break;
     728             :                 }
     729             :             }
     730             :         }
     731           0 :         bBoundary1 = isBoundary1(rCharClass, rText, nPos, rEnd);
     732           0 :         bBoundary2 = isBoundary2(rCharClass, rText, nPos, rEnd);
     733             :     }
     734           0 :     rBegin = rEnd;
     735           0 :     return OUString();
     736             : }
     737             : 
     738             : //============================================================================
     739             : //
     740             : //  removePassword
     741             : //
     742             : //============================================================================
     743             : 
     744           0 : OUString URIHelper::removePassword(OUString const & rURI,
     745             :                                    INetURLObject::EncodeMechanism eEncodeMechanism,
     746             :                                    INetURLObject::DecodeMechanism eDecodeMechanism,
     747             :                                    rtl_TextEncoding eCharset)
     748             : {
     749           0 :     INetURLObject aObj(rURI, eEncodeMechanism, eCharset);
     750           0 :     return aObj.HasError() ?
     751             :                rURI :
     752           0 :                aObj.GetURLNoPass(eDecodeMechanism, eCharset);
     753             : }
     754             : 
     755             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10