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