ucbhelper/source/client/proxydecider.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 #include <utility>
  24 #include <vector>
  25 #include <deque>
  26
  27 #include <osl/diagnose.h>
  28 #include <osl/mutex.hxx>
  29 #include <rtl/ref.hxx>
  30 #include <osl/socket.hxx>
  31 #include <rtl/ustrbuf.hxx>
  32 #include <com/sun/star/container/XNameAccess.hpp>
  33 #include <com/sun/star/configuration/theDefaultProvider.hpp>
  34 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  35 #include <com/sun/star/util/XChangesListener.hpp>
  36 #include <com/sun/star/util/XChangesNotifier.hpp>
  37 #include <cppuhelper/implbase.hxx>
  38 #include <ucbhelper/proxydecider.hxx>
  39 #include <o3tl/string_view.hxx>
  40
  41 #ifdef _WIN32
  42 #include <o3tl/char16_t2wchar_t.hxx>
  43 #define WIN32_LEAN_AND_MEAN
  44 #include <Windows.h>
  45 #include <Winhttp.h>
  46 #include <process.h>
  47 #endif
  48
  49 using namespace com::sun::star;
  50 using namespace ucbhelper;
  51
  52 constexpr OUString CONFIG_ROOT_KEY = u"org.openoffice.Inet/Settings"_ustr;
  53 constexpr OUString PROXY_TYPE_KEY = u"ooInetProxyType"_ustr;
  54 constexpr OUString NO_PROXY_LIST_KEY = u"ooInetNoProxy"_ustr;
  55 constexpr OUString HTTP_PROXY_NAME_KEY = u"ooInetHTTPProxyName"_ustr;
  56 constexpr OUString HTTP_PROXY_PORT_KEY = u"ooInetHTTPProxyPort"_ustr;
  57 constexpr OUString HTTPS_PROXY_NAME_KEY = u"ooInetHTTPSProxyName"_ustr;
  58 constexpr OUString HTTPS_PROXY_PORT_KEY = u"ooInetHTTPSProxyPort"_ustr;
  59
  60
  61 namespace ucbhelper
  62 {
  63
  64
  65 namespace proxydecider_impl
  66 {
  67
  68 namespace {
  69
  70 // A simple case ignoring wildcard matcher.
  71 class WildCard
  72 {
  73 private:
  74     OString m_aWildString;
  75
  76 public:
  77     explicit WildCard( std::u16string_view rWildCard )
  78     : m_aWildString(
  79         OUStringToOString(
  80             rWildCard, RTL_TEXTENCODING_UTF8 ).toAsciiLowerCase() ) {}
  81
  82     bool Matches( std::u16string_view rStr ) const;
  83 };
  84
  85 }
  86
  87 namespace {
  88
  89 class HostnameCache
  90 {
  91     typedef std::pair< OUString, OUString > HostListEntry;
  92
  93     std::deque< HostListEntry >    m_aHostList;
  94
  95 public:
  96     bool get( std::u16string_view rKey, OUString & rValue ) const
  97     {
  98         for (auto const& host : m_aHostList)
  99         {
 100             if ( host.first == rKey )
 101             {
 102                 rValue = host.second;
 103                 return true;
 104             }
 105         }
 106         return false;
 107     }
 108
 109     void put( const OUString & rKey, const OUString & rValue )
 110     {
 111         static constexpr sal_uInt32 nCapacity = 256;
 112
 113         if ( m_aHostList.size() == nCapacity )
 114             m_aHostList.resize( nCapacity / 2 );
 115
 116         m_aHostList.push_front( HostListEntry( rKey, rValue ) );
 117     }
 118 };
 119
 120 }
 121
 122 class InternetProxyDecider_Impl :
 123     public cppu::WeakImplHelper< util::XChangesListener >
 124 {
 125     // see officecfg/registry/schema/org/openoffice/Inet.xcs for the definition of these values
 126     enum class ProxyType { NoProxy, Automatic, Manual };
 127     mutable osl::Mutex                       m_aMutex;
 128     InternetProxyServer                      m_aHttpProxy;
 129     InternetProxyServer                      m_aHttpsProxy;
 130     const InternetProxyServer                m_aEmptyProxy;
 131     ProxyType                                m_nProxyType;
 132     uno::Reference< util::XChangesNotifier > m_xNotifier;
 133     typedef std::pair< WildCard, WildCard > NoProxyListEntry;
 134     std::vector< NoProxyListEntry >          m_aNoProxyList;
 135     mutable HostnameCache                    m_aHostnames;
 136
 137 private:
 138     bool shouldUseProxy( std::u16string_view rHost,
 139                          sal_Int32 nPort,
 140                          bool bUseFullyQualified ) const;
 141 public:
 142     explicit InternetProxyDecider_Impl(
 143         const uno::Reference< uno::XComponentContext >& rxContext );
 144
 145     void dispose();
 146
 147     InternetProxyServer getProxy(const OUString& rProtocol,
 148                                           const OUString & rHost,
 149                                           sal_Int32 nPort ) const;
 150
 151     // XChangesListener
 152     virtual void SAL_CALL changesOccurred( const util::ChangesEvent& Event ) override;
 153
 154     // XEventListener ( base of XChangesLisetenr )
 155     virtual void SAL_CALL disposing( const lang::EventObject& Source ) override;
 156
 157 private:
 158     void setNoProxyList( std::u16string_view rNoProxyList );
 159 };
 160
 161
 162 // WildCard Implementation.
 163
 164
 165 bool WildCard::Matches( std::u16string_view rString ) const
 166 {
 167     OString aString
 168         = OUStringToOString( rString, RTL_TEXTENCODING_UTF8 ).toAsciiLowerCase();
 169     const char * pStr  = aString.getStr();
 170     const char * pWild = m_aWildString.getStr();
 171
 172     int pos  = 0;
 173     int flag = 0;
 174
 175     while ( *pWild || flag )
 176     {
 177         switch ( *pWild )
 178         {
 179             case '?':
 180                 if ( *pStr == '\0' )
 181                     return false;
 182                 break;
 183
 184             default:
 185                 if ( ( *pWild == '\\' ) && ( ( *( pWild + 1 ) == '?' )
 186                                              || ( *( pWild + 1 ) == '*') ) )
 187                     pWild++;
 188                 if ( *pWild != *pStr )
 189                     if ( !pos )
 190                         return false;
 191                     else
 192                         pWild += pos;
 193                 else
 194                     break;
 195
 196                 [[fallthrough]];
 197
 198             case '*':
 199                 while ( *pWild == '*' )
 200                     pWild++;
 201                 if ( *pWild == '\0' )
 202                     return true;
 203                 flag = 1;
 204                 pos  = 0;
 205                 if ( *pStr == '\0' )
 206                     return ( *pWild == '\0' );
 207                 while ( *pStr && *pStr != *pWild )
 208                 {
 209                     if ( *pWild == '?' ) {
 210                         pWild++;
 211                         while ( *pWild == '*' )
 212                             pWild++;
 213                     }
 214                     pStr++;
 215                     if ( *pStr == '\0' )
 216                         return ( *pWild == '\0' );
 217                 }
 218                 break;
 219         }
 220         if ( *pWild != '\0' )
 221             pWild++;
 222         if ( *pStr != '\0' )
 223             pStr++;
 224         else
 225             flag = 0;
 226         if ( flag )
 227             pos--;
 228     }
 229     return ( *pStr == '\0' ) && ( *pWild == '\0' );
 230 }
 231
 232
 233 static bool getConfigStringValue(
 234     const uno::Reference< container::XNameAccess > & xNameAccess,
 235     const OUString& key,
 236     OUString & value )
 237 {
 238     try
 239     {
 240         if ( !( xNameAccess->getByName( key ) >>= value ) )
 241         {
 242             OSL_FAIL( "InternetProxyDecider - "
 243                         "Error getting config item value!" );
 244             return false;
 245         }
 246     }
 247     catch ( lang::WrappedTargetException const & )
 248     {
 249         return false;
 250     }
 251     catch ( container::NoSuchElementException const & )
 252     {
 253         return false;
 254     }
 255     return true;
 256 }
 257
 258
 259 static bool getConfigInt32Value(
 260     const uno::Reference< container::XNameAccess > & xNameAccess,
 261     const OUString& key,
 262     sal_Int32 & value )
 263 {
 264     try
 265     {
 266         uno::Any aValue = xNameAccess->getByName( key );
 267         if ( aValue.hasValue() && !( aValue >>= value ) )
 268         {
 269             OSL_FAIL( "InternetProxyDecider - "
 270                         "Error getting config item value!" );
 271             return false;
 272         }
 273     }
 274     catch ( lang::WrappedTargetException const & )
 275     {
 276         return false;
 277     }
 278     catch ( container::NoSuchElementException const & )
 279     {
 280         return false;
 281     }
 282     return true;
 283 }
 284
 285
 286 // InternetProxyDecider_Impl Implementation.
 287
 288
 289 InternetProxyDecider_Impl::InternetProxyDecider_Impl(
 290     const uno::Reference< uno::XComponentContext >& rxContext )
 291     : m_nProxyType( ProxyType::NoProxy ),
 292       m_aHostnames()
 293 {
 294     try
 295     {
 296
 297         // Read proxy configuration from config db.
 298
 299
 300         uno::Reference< lang::XMultiServiceFactory > xConfigProv =
 301                 configuration::theDefaultProvider::get( rxContext );
 302
 303         uno::Sequence< uno::Any > aArguments{ uno::Any(CONFIG_ROOT_KEY) };
 304         uno::Reference< uno::XInterface > xInterface(
 305                     xConfigProv->createInstanceWithArguments(
 306                         u"com.sun.star.configuration.ConfigurationAccess"_ustr,
 307                         aArguments ) );
 308
 309         OSL_ENSURE( xInterface.is(),
 310                     "InternetProxyDecider - No config access!" );
 311
 312         if ( xInterface.is() )
 313         {
 314             uno::Reference< container::XNameAccess > xNameAccess(
 315                                             xInterface, uno::UNO_QUERY );
 316             OSL_ENSURE( xNameAccess.is(),
 317                         "InternetProxyDecider - No name access!" );
 318
 319             if ( xNameAccess.is() )
 320             {
 321                 // *** Proxy type ***
 322                 sal_Int32 tmp = 0;
 323                 getConfigInt32Value(
 324                     xNameAccess, PROXY_TYPE_KEY, tmp );
 325                 m_nProxyType = static_cast<ProxyType>(tmp);
 326
 327                 // *** No proxy list ***
 328                 OUString aNoProxyList;
 329                 getConfigStringValue(
 330                     xNameAccess, NO_PROXY_LIST_KEY, aNoProxyList );
 331                 setNoProxyList( aNoProxyList );
 332
 333                 // *** HTTP ***
 334                 getConfigStringValue(
 335                     xNameAccess, HTTP_PROXY_NAME_KEY, m_aHttpProxy.aName );
 336
 337                 m_aHttpProxy.nPort = -1;
 338                 getConfigInt32Value(
 339                     xNameAccess, HTTP_PROXY_PORT_KEY, m_aHttpProxy.nPort );
 340                 if ( m_aHttpProxy.nPort == -1 )
 341                     m_aHttpProxy.nPort = 80; // standard HTTP port.
 342
 343                 // *** HTTPS ***
 344                 getConfigStringValue(
 345                     xNameAccess, HTTPS_PROXY_NAME_KEY, m_aHttpsProxy.aName );
 346
 347                 m_aHttpsProxy.nPort = -1;
 348                 getConfigInt32Value(
 349                     xNameAccess, HTTPS_PROXY_PORT_KEY, m_aHttpsProxy.nPort );
 350                 if ( m_aHttpsProxy.nPort == -1 )
 351                     m_aHttpsProxy.nPort = 443; // standard HTTPS port.
 352             }
 353
 354             // Register as listener for config changes.
 355
 356             m_xNotifier.set( xInterface, uno::UNO_QUERY );
 357
 358             OSL_ENSURE( m_xNotifier.is(),
 359                         "InternetProxyDecider - No notifier!" );
 360
 361             if ( m_xNotifier.is() )
 362                 m_xNotifier->addChangesListener( this );
 363         }
 364     }
 365     catch ( uno::Exception const & )
 366     {
 367         // createInstance, createInstanceWithArguments
 368         OSL_FAIL( "InternetProxyDecider - Exception!" );
 369     }
 370 }
 371
 372 void InternetProxyDecider_Impl::dispose()
 373 {
 374     uno::Reference< util::XChangesNotifier > xNotifier;
 375
 376     if ( m_xNotifier.is() )
 377     {
 378         osl::Guard< osl::Mutex > aGuard( m_aMutex );
 379
 380         if ( m_xNotifier.is() )
 381         {
 382             xNotifier = m_xNotifier;
 383             m_xNotifier.clear();
 384         }
 385     }
 386
 387     // Do this unguarded!
 388     if ( xNotifier.is() )
 389         xNotifier->removeChangesListener( this );
 390 }
 391
 392
 393 bool InternetProxyDecider_Impl::shouldUseProxy( std::u16string_view rHost,
 394                                                 sal_Int32 nPort,
 395                                                 bool bUseFullyQualified ) const
 396 {
 397     OUStringBuffer aBuffer;
 398
 399     if ( ( rHost.find( ':' ) != std::u16string_view::npos ) &&
 400          ( rHost[ 0 ] != '[' ) )
 401     {
 402         // host is given as numeric IPv6 address
 403         aBuffer.append( OUString::Concat("[") + rHost + "]" );
 404     }
 405     else
 406     {
 407         // host is given either as numeric IPv4 address or non-numeric hostname
 408         aBuffer.append( rHost );
 409     }
 410
 411     aBuffer.append( ":" + OUString::number( nPort ) );
 412
 413     for (auto const& noProxy : m_aNoProxyList)
 414     {
 415         if ( bUseFullyQualified )
 416         {
 417             if ( noProxy.second.Matches( aBuffer ) )
 418                 return false;
 419         }
 420         else
 421         {
 422             if ( noProxy.first.Matches( aBuffer ) )
 423                 return false;
 424         }
 425     }
 426
 427     return true;
 428 }
 429
 430 namespace
 431 {
 432 #ifdef _WIN32
 433 struct GetPACProxyData
 434 {
 435     const OUString& m_rProtocol;
 436     const OUString& m_rHost;
 437     sal_Int32 m_nPort;
 438     bool m_bAutoDetect = false;
 439     OUString m_sAutoConfigUrl;
 440     InternetProxyServer m_ProxyServer;
 441
 442     GetPACProxyData(const OUString& rProtocol, const OUString& rHost, sal_Int32 nPort)
 443         : m_rProtocol(rProtocol)
 444         , m_rHost(rHost)
 445         , m_nPort(nPort)
 446     {
 447     }
 448 };
 449
 450 // Tries to get proxy configuration using WinHttpGetProxyForUrl, which supports Web Proxy Auto-Discovery
 451 // (WPAD) protocol and manually configured address to get Proxy Auto-Configuration (PAC) file.
 452 // The WinINet/WinHTTP functions cannot correctly run in a STA COM thread, so use a dedicated thread
 453 unsigned __stdcall GetPACProxyThread(void* lpParameter)
 454 {
 455     assert(lpParameter);
 456     GetPACProxyData* pData = static_cast<GetPACProxyData*>(lpParameter);
 457
 458     OUString url(pData->m_rProtocol + "://" + pData->m_rHost + ":"
 459                  + OUString::number(pData->m_nPort));
 460
 461     HINTERNET hInternet = WinHttpOpen(L"Mozilla 5.0", WINHTTP_ACCESS_TYPE_NO_PROXY,
 462                                       WINHTTP_NO_PROXY_NAME, WINHTTP_NO_PROXY_BYPASS, 0);
 463     DWORD nError = GetLastError();
 464     if (!hInternet)
 465         return nError;
 466
 467     WINHTTP_AUTOPROXY_OPTIONS AutoProxyOptions{};
 468     if (pData->m_bAutoDetect)
 469     {
 470         AutoProxyOptions.dwFlags = WINHTTP_AUTOPROXY_AUTO_DETECT;
 471         AutoProxyOptions.dwAutoDetectFlags
 472             = WINHTTP_AUTO_DETECT_TYPE_DHCP | WINHTTP_AUTO_DETECT_TYPE_DNS_A;
 473     }
 474     if (!pData->m_sAutoConfigUrl.isEmpty())
 475     {
 476         AutoProxyOptions.dwFlags |= WINHTTP_AUTOPROXY_CONFIG_URL;
 477         AutoProxyOptions.lpszAutoConfigUrl = o3tl::toW(pData->m_sAutoConfigUrl.getStr());
 478     }
 479     // First, try without autologon. According to
 480     // https://github.com/Microsoft/Windows-classic-samples/blob/master/Samples/Win7Samples/web/winhttp/WinhttpProxySample/GetProxy.cpp
 481     // autologon prevents caching, and so causes repetitive network traffic.
 482     AutoProxyOptions.fAutoLogonIfChallenged = FALSE;
 483     WINHTTP_PROXY_INFO ProxyInfo{};
 484     bool bResult
 485         = WinHttpGetProxyForUrl(hInternet, o3tl::toW(url.getStr()), &AutoProxyOptions, &ProxyInfo);
 486     nError = GetLastError();
 487     if (!bResult && nError == ERROR_WINHTTP_LOGIN_FAILURE)
 488     {
 489         AutoProxyOptions.fAutoLogonIfChallenged = TRUE;
 490         bResult = WinHttpGetProxyForUrl(hInternet, o3tl::toW(url.getStr()),
 491                                         &AutoProxyOptions, &ProxyInfo);
 492         nError = GetLastError();
 493     }
 494     WinHttpCloseHandle(hInternet);
 495     if (bResult)
 496     {
 497         if (ProxyInfo.lpszProxyBypass)
 498             GlobalFree(ProxyInfo.lpszProxyBypass);
 499         if (ProxyInfo.lpszProxy)
 500         {
 501             OUString sProxyResult(o3tl::toU(ProxyInfo.lpszProxy));
 502             GlobalFree(ProxyInfo.lpszProxy);
 503             // Get the first of possibly multiple results
 504             sProxyResult = sProxyResult.getToken(0, ';');
 505             sal_Int32 nPortSepPos = sProxyResult.indexOf(':');
 506             if (nPortSepPos != -1)
 507             {
 508                 pData->m_ProxyServer.nPort = o3tl::toInt32(sProxyResult.subView(nPortSepPos + 1));
 509                 sProxyResult = sProxyResult.copy(0, nPortSepPos);
 510             }
 511             else
 512             {
 513                 pData->m_ProxyServer.nPort = 0;
 514             }
 515             pData->m_ProxyServer.aName = sProxyResult;
 516         }
 517     }
 518
 519     return nError;
 520 }
 521
 522 InternetProxyServer GetPACProxy(const OUString& rProtocol, const OUString& rHost, sal_Int32 nPort)
 523 {
 524     GetPACProxyData aData(rProtocol, rHost, nPort);
 525
 526     // WinHTTP only supports http(s), so don't try for other protocols
 527     if (!(rProtocol.equalsIgnoreAsciiCase("http") || rProtocol.equalsIgnoreAsciiCase("https")))
 528         return aData.m_ProxyServer;
 529
 530     // Only try to get configuration from PAC (with all the overhead, including new thread)
 531     // if configured to do so
 532     {
 533         WINHTTP_CURRENT_USER_IE_PROXY_CONFIG aProxyConfig{};
 534         bool bResult = WinHttpGetIEProxyConfigForCurrentUser(&aProxyConfig);
 535         if (aProxyConfig.lpszProxy)
 536             GlobalFree(aProxyConfig.lpszProxy);
 537         if (aProxyConfig.lpszProxyBypass)
 538             GlobalFree(aProxyConfig.lpszProxyBypass);
 539         // Don't try WPAD if AutoDetection or AutoConfig script URL are not configured
 540         if (!bResult || !(aProxyConfig.fAutoDetect || aProxyConfig.lpszAutoConfigUrl))
 541             return aData.m_ProxyServer;
 542         aData.m_bAutoDetect = aProxyConfig.fAutoDetect;
 543         if (aProxyConfig.lpszAutoConfigUrl)
 544         {
 545             aData.m_sAutoConfigUrl = o3tl::toU(aProxyConfig.lpszAutoConfigUrl);
 546             GlobalFree(aProxyConfig.lpszAutoConfigUrl);
 547         }
 548     }
 549
 550     HANDLE hThread = reinterpret_cast<HANDLE>(
 551         _beginthreadex(nullptr, 0, GetPACProxyThread, &aData, 0, nullptr));
 552     if (hThread)
 553     {
 554         WaitForSingleObject(hThread, INFINITE);
 555         CloseHandle(hThread);
 556     }
 557     return aData.m_ProxyServer;
 558 }
 559
 560 #else // .. _WIN32
 561
 562 // Read the settings from the OS which are stored in env vars
 563 //
 564 InternetProxyServer GetUnixSystemProxy(const OUString & rProtocol)
 565 {
 566     // TODO this could be improved to read the "no_proxy" env variable
 567     InternetProxyServer aProxy;
 568     OUString protocolLower = rProtocol.toAsciiLowerCase() + "_proxy";
 569     OString protocolLowerStr = OUStringToOString( protocolLower, RTL_TEXTENCODING_ASCII_US );
 570     const char* pEnvProxy = getenv(protocolLowerStr.getStr());
 571     if (!pEnvProxy)
 572         return aProxy;
 573     // expecting something like "https://example.ct:80"
 574     OUString tmp = OUString::createFromAscii(pEnvProxy);
 575     if (tmp.getLength() < (rProtocol.getLength() + 3))
 576         return aProxy;
 577     sal_Int32 x = tmp.indexOf("://");
 578     sal_Int32 at = tmp.indexOf('@', x == -1 ? 0 : x + 3);
 579     x = tmp.indexOf(':', at == -1 ? x == -1 ? 0 : x + 3 : at + 1);
 580     if (x == -1)
 581         return aProxy;
 582     int nPort = o3tl::toInt32(tmp.subView(x + 1));
 583     if (nPort == 0)
 584         return aProxy;
 585     aProxy.aName = tmp.copy(0, x);
 586     aProxy.nPort = nPort;
 587     return aProxy;
 588 }
 589
 590 #endif // else .. _WIN32
 591 }
 592
 593 InternetProxyServer InternetProxyDecider_Impl::getProxy(
 594                                             const OUString & rProtocol,
 595                                             const OUString & rHost,
 596                                             sal_Int32 nPort ) const
 597 {
 598     osl::Guard< osl::Mutex > aGuard( m_aMutex );
 599
 600     if ( m_nProxyType == ProxyType::NoProxy )
 601     {
 602         // Never use proxy.
 603         return m_aEmptyProxy;
 604     }
 605
 606     // If get from system
 607     if (m_nProxyType == ProxyType::Automatic && !rHost.isEmpty())
 608     {
 609 #ifdef _WIN32
 610         InternetProxyServer aProxy(GetPACProxy(rProtocol, rHost, nPort));
 611 #else
 612         InternetProxyServer aProxy(GetUnixSystemProxy(rProtocol));
 613 #endif // _WIN32
 614         if (!aProxy.aName.isEmpty())
 615             return aProxy;
 616     }
 617
 618     if ( !rHost.isEmpty() && !m_aNoProxyList.empty() )
 619     {
 620
 621         // First, try direct hostname match - #110515#
 622
 623
 624         if ( !shouldUseProxy( rHost, nPort, false ) )
 625             return m_aEmptyProxy;
 626
 627
 628         // Second, try match against full qualified hostname - #104401#
 629
 630
 631         OUString aHost;
 632
 633         if ( ( rHost.getLength() > 1 ) &&
 634              ( rHost[ 0 ] == '[' ))
 635         {
 636             // host is given as numeric IPv6 address. name resolution
 637             // functions need hostname without square brackets.
 638             aHost = rHost.copy( 1, rHost.getLength() - 2 );
 639         }
 640         else
 641         {
 642             aHost = rHost;
 643         }
 644
 645         OUString aFullyQualifiedHost;
 646         if ( !m_aHostnames.get( aHost, aFullyQualifiedHost ) )
 647         {
 648             // This might be quite expensive (DNS lookup).
 649             const osl::SocketAddr aAddr( aHost, nPort );
 650             aFullyQualifiedHost = aAddr.getHostname().toAsciiLowerCase();
 651             m_aHostnames.put( aHost, aFullyQualifiedHost );
 652         }
 653
 654         // Error resolving name? -> fallback.
 655         if ( aFullyQualifiedHost.isEmpty() )
 656             aFullyQualifiedHost = aHost;
 657
 658         if ( aFullyQualifiedHost != aHost )
 659         {
 660             if ( !shouldUseProxy( aFullyQualifiedHost, nPort, false ) )
 661                 return m_aEmptyProxy;
 662         }
 663
 664
 665         // Third, try match of fully qualified entries in no-proxy list
 666         // against full qualified hostname
 667
 668         // Example:
 669         // list: staroffice-doc -> full: xyz.germany.sun.com
 670         // in:   staroffice-doc.germany.sun.com -> full: xyz.germany.sun.com
 671
 672
 673         if ( !shouldUseProxy( aFullyQualifiedHost, nPort, true ) )
 674             return m_aEmptyProxy;
 675     }
 676
 677     if (rProtocol.toAsciiLowerCase() == "https")
 678     {
 679         if ( !m_aHttpsProxy.aName.isEmpty() )
 680             return m_aHttpsProxy;
 681     }
 682     else if ( !m_aHttpProxy.aName.isEmpty() )
 683     {
 684         // All other protocols use the HTTP proxy.
 685         return m_aHttpProxy;
 686     }
 687     return m_aEmptyProxy;
 688 }
 689
 690 // virtual
 691 void SAL_CALL InternetProxyDecider_Impl::changesOccurred(
 692                                         const util::ChangesEvent& Event )
 693 {
 694     osl::Guard< osl::Mutex > aGuard( m_aMutex );
 695
 696     for ( const util::ElementChange& rElem : Event.Changes )
 697     {
 698         OUString aKey;
 699         if ( ( rElem.Accessor >>= aKey ) && !aKey.isEmpty() )
 700         {
 701             if ( aKey == PROXY_TYPE_KEY )
 702             {
 703                 sal_Int32 tmp;
 704                 if ( !( rElem.Element >>= tmp ) )
 705                 {
 706                     OSL_FAIL( "InternetProxyDecider - changesOccurred - "
 707                                 "Error getting config item value!" );
 708                 }
 709                 else
 710                     m_nProxyType = static_cast<ProxyType>(tmp);
 711             }
 712             else if ( aKey == NO_PROXY_LIST_KEY )
 713             {
 714                 OUString aNoProxyList;
 715                 if ( !( rElem.Element >>= aNoProxyList ) )
 716                 {
 717                     OSL_FAIL( "InternetProxyDecider - changesOccurred - "
 718                                 "Error getting config item value!" );
 719                 }
 720
 721                 setNoProxyList( aNoProxyList );
 722             }
 723             else if ( aKey == HTTP_PROXY_NAME_KEY )
 724             {
 725                 if ( !( rElem.Element >>= m_aHttpProxy.aName ) )
 726                 {
 727                     OSL_FAIL( "InternetProxyDecider - changesOccurred - "
 728                                 "Error getting config item value!" );
 729                 }
 730             }
 731             else if ( aKey == HTTP_PROXY_PORT_KEY )
 732             {
 733                 if ( !( rElem.Element >>= m_aHttpProxy.nPort ) )
 734                 {
 735                     OSL_FAIL( "InternetProxyDecider - changesOccurred - "
 736                                 "Error getting config item value!" );
 737                 }
 738
 739                 if ( m_aHttpProxy.nPort == -1 )
 740                     m_aHttpProxy.nPort = 80; // standard HTTP port.
 741             }
 742             else if ( aKey == HTTPS_PROXY_NAME_KEY )
 743             {
 744                 if ( !( rElem.Element >>= m_aHttpsProxy.aName ) )
 745                 {
 746                     OSL_FAIL( "InternetProxyDecider - changesOccurred - "
 747                                 "Error getting config item value!" );
 748                 }
 749             }
 750             else if ( aKey == HTTPS_PROXY_PORT_KEY )
 751             {
 752                 if ( !( rElem.Element >>= m_aHttpsProxy.nPort ) )
 753                 {
 754                     OSL_FAIL( "InternetProxyDecider - changesOccurred - "
 755                                 "Error getting config item value!" );
 756                 }
 757
 758                 if ( m_aHttpsProxy.nPort == -1 )
 759                     m_aHttpsProxy.nPort = 443; // standard HTTPS port.
 760             }
 761         }
 762     }
 763 }
 764
 765
 766 // virtual
 767 void SAL_CALL InternetProxyDecider_Impl::disposing(const lang::EventObject&)
 768 {
 769     if ( m_xNotifier.is() )
 770     {
 771         osl::Guard< osl::Mutex > aGuard( m_aMutex );
 772
 773         if ( m_xNotifier.is() )
 774             m_xNotifier.clear();
 775     }
 776 }
 777
 778
 779 void InternetProxyDecider_Impl::setNoProxyList(
 780                                         std::u16string_view rNoProxyList )
 781 {
 782     osl::Guard< osl::Mutex > aGuard( m_aMutex );
 783
 784     m_aNoProxyList.clear();
 785
 786     if ( rNoProxyList.empty() )
 787         return;
 788
 789     // List of connection endpoints hostname[:port],
 790     // separated by semicolon. Wildcards allowed.
 791
 792     size_t nPos = 0;
 793     size_t nEnd = rNoProxyList.find( ';' );
 794     size_t nLen = rNoProxyList.size();
 795
 796     do
 797     {
 798         if ( nEnd == std::u16string_view::npos )
 799             nEnd = nLen;
 800
 801         OUString aToken( rNoProxyList.substr( nPos, nEnd - nPos ) );
 802
 803         if ( !aToken.isEmpty() )
 804         {
 805             OUString aServer;
 806             OUString aPort;
 807
 808             // numerical IPv6 address?
 809             bool bIPv6Address = false;
 810             sal_Int32 nClosedBracketPos = aToken.indexOf( ']' );
 811             if ( nClosedBracketPos == -1 )
 812                 nClosedBracketPos = 0;
 813             else
 814                 bIPv6Address = true;
 815
 816             sal_Int32 nColonPos = aToken.indexOf( ':', nClosedBracketPos );
 817             if ( nColonPos == -1 )
 818             {
 819                 // No port given, server pattern equals current token
 820                 aPort = "*";
 821                 if ( aToken.indexOf( '*' ) == -1 )
 822                 {
 823                     // pattern describes exactly one server
 824                     aServer = aToken;
 825                 }
 826
 827                 aToken += ":*";
 828             }
 829             else
 830             {
 831                 // Port given, extract server pattern
 832                 sal_Int32 nAsteriskPos = aToken.indexOf( '*' );
 833                 aPort = aToken.copy( nColonPos + 1 );
 834                 if ( nAsteriskPos < nColonPos )
 835                 {
 836                     // pattern describes exactly one server
 837                     aServer = aToken.copy( 0, nColonPos );
 838                 }
 839             }
 840
 841             OUStringBuffer aFullyQualifiedHost;
 842             if ( !aServer.isEmpty() )
 843             {
 844                 // Remember fully qualified server name if current list
 845                 // entry specifies exactly one non-fully qualified server
 846                 // name.
 847
 848                 // remove square brackets from host name in case it's
 849                 // a numerical IPv6 address.
 850                 if ( bIPv6Address )
 851                     aServer = aServer.copy( 1, aServer.getLength() - 2 );
 852
 853                 // This might be quite expensive (DNS lookup).
 854                 const osl::SocketAddr aAddr( aServer, 0 );
 855                 OUString aTmp = aAddr.getHostname().toAsciiLowerCase();
 856                 if ( aTmp != aServer.toAsciiLowerCase() )
 857                 {
 858                     if ( bIPv6Address )
 859                         aFullyQualifiedHost.append( "[" + aTmp + "]" );
 860                     else
 861                         aFullyQualifiedHost.append( aTmp );
 862                     aFullyQualifiedHost.append( ":" + aPort );
 863                 }
 864             }
 865
 866             m_aNoProxyList.emplace_back( WildCard( aToken ),
 867                                   WildCard( aFullyQualifiedHost ) );
 868         }
 869
 870         if ( nEnd != nLen )
 871         {
 872             nPos = nEnd + 1;
 873             nEnd = rNoProxyList.find( ';', nPos );
 874         }
 875     }
 876     while ( nEnd != nLen );
 877 }
 878
 879 } // namespace proxydecider_impl
 880
 881
 882 // InternetProxyDecider Implementation.
 883
 884
 885 InternetProxyDecider::InternetProxyDecider(
 886     const uno::Reference< uno::XComponentContext>& rxContext )
 887 : m_xImpl( new proxydecider_impl::InternetProxyDecider_Impl( rxContext ) )
 888 {
 889 }
 890
 891
 892 InternetProxyDecider::~InternetProxyDecider()
 893 {
 894     // Break circular reference between config listener and notifier.
 895     m_xImpl->dispose();
 896 }
 897
 898
 899 OUString InternetProxyDecider::getProxy(
 900                                             const OUString & rProtocol,
 901                                             const OUString & rHost,
 902                                             sal_Int32 nPort ) const
 903 {
 904     InternetProxyServer ret(m_xImpl->getProxy(rProtocol, rHost, nPort));
 905
 906     if (ret.aName.isEmpty() || ret.nPort == -1)
 907     {
 908         return ret.aName;
 909     }
 910
 911     return ret.aName + ":" + OUString::number(ret.nPort);
 912 }
 913
 914 } // namespace ucbhelper
 915
 916 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */