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