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 <list>
  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/implbase1.hxx>
  35 #include "ucbhelper/proxydecider.hxx"
  36
  37 using namespace com::sun::star;
  38 using namespace ucbhelper;
  39
  40 #define CONFIG_ROOT_KEY      "org.openoffice.Inet/Settings"
  41 #define PROXY_TYPE_KEY       "ooInetProxyType"
  42 #define NO_PROXY_LIST_KEY    "ooInetNoProxy"
  43 #define HTTP_PROXY_NAME_KEY  "ooInetHTTPProxyName"
  44 #define HTTP_PROXY_PORT_KEY  "ooInetHTTPProxyPort"
  45 #define HTTPS_PROXY_NAME_KEY "ooInetHTTPSProxyName"
  46 #define HTTPS_PROXY_PORT_KEY "ooInetHTTPSProxyPort"
  47 #define FTP_PROXY_NAME_KEY   "ooInetFTPProxyName"
  48 #define FTP_PROXY_PORT_KEY   "ooInetFTPProxyPort"
  49
  50
  51 namespace ucbhelper
  52 {
  53
  54
  55 namespace proxydecider_impl
  56 {
  57
  58 // A simple case ignoring wildcard matcher.
  59 class WildCard
  60 {
  61 private:
  62     OString m_aWildString;
  63
  64 public:
  65     WildCard( const OUString& rWildCard )
  66     : m_aWildString(
  67         OUStringToOString(
  68             rWildCard, RTL_TEXTENCODING_UTF8 ).toAsciiLowerCase() ) {}
  69
  70     bool Matches( const OUString & rStr ) const;
  71 };
  72
  73
  74 typedef std::pair< WildCard, WildCard > NoProxyListEntry;
  75
  76
  77
  78 class HostnameCache
  79 {
  80     typedef std::pair< OUString, OUString > HostListEntry;
  81
  82     std::list< HostListEntry >     m_aHostList;
  83     sal_uInt32                     m_nCapacity;
  84
  85 public:
  86     explicit HostnameCache( sal_uInt32 nCapacity )
  87         : m_nCapacity( nCapacity ) {}
  88
  89     bool get( const OUString & rKey, OUString & rValue ) const
  90     {
  91         std::list< HostListEntry >::const_iterator it
  92             = m_aHostList.begin();
  93         const std::list< HostListEntry >::const_iterator end
  94             = m_aHostList.end();
  95
  96         while ( it != end )
  97         {
  98             if ( (*it).first == rKey )
  99             {
 100                 rValue = (*it).second;
 101                 return true;
 102             }
 103             ++it;
 104         }
 105         return false;
 106     }
 107
 108     void put( const OUString & rKey, const OUString & rValue )
 109     {
 110         if ( m_aHostList.size() == m_nCapacity )
 111             m_aHostList.resize( m_nCapacity / 2 );
 112
 113         m_aHostList.push_front( HostListEntry( rKey, rValue ) );
 114     }
 115 };
 116
 117
 118 class InternetProxyDecider_Impl :
 119     public cppu::WeakImplHelper1< util::XChangesListener >
 120 {
 121     mutable osl::Mutex                       m_aMutex;
 122     InternetProxyServer                      m_aHttpProxy;
 123     InternetProxyServer                      m_aHttpsProxy;
 124     InternetProxyServer                      m_aFtpProxy;
 125     const InternetProxyServer                m_aEmptyProxy;
 126     sal_Int32                                m_nProxyType;
 127     uno::Reference< util::XChangesNotifier > m_xNotifier;
 128     std::vector< NoProxyListEntry >          m_aNoProxyList;
 129     mutable HostnameCache                    m_aHostnames;
 130
 131 private:
 132     bool shouldUseProxy( const OUString & rHost,
 133                          sal_Int32 nPort,
 134                          bool bUseFullyQualified ) const;
 135 public:
 136     InternetProxyDecider_Impl(
 137         const uno::Reference< uno::XComponentContext >& rxContext );
 138     virtual ~InternetProxyDecider_Impl();
 139
 140     void dispose();
 141
 142     const InternetProxyServer & getProxy( const OUString & rProtocol,
 143                                           const OUString & rHost,
 144                                           sal_Int32 nPort ) const;
 145
 146     // XChangesListener
 147     virtual void SAL_CALL changesOccurred( const util::ChangesEvent& Event )
 148         throw( uno::RuntimeException, std::exception ) SAL_OVERRIDE;
 149
 150     // XEventListener ( base of XChangesLisetenr )
 151     virtual void SAL_CALL disposing( const lang::EventObject& Source )
 152         throw( uno::RuntimeException, std::exception ) SAL_OVERRIDE;
 153
 154 private:
 155     void setNoProxyList( const OUString & rNoProxyList );
 156 };
 157
 158
 159
 160
 161 // WildCard Implementation.
 162
 163
 164
 165
 166 bool WildCard::Matches( const OUString& rString ) const
 167 {
 168     OString aString
 169         = OUStringToOString(
 170                     rString, RTL_TEXTENCODING_UTF8 ).toAsciiLowerCase();
 171     const char * pStr  = aString.getStr();
 172     const char * pWild = m_aWildString.getStr();
 173
 174     int pos  = 0;
 175     int flag = 0;
 176
 177     while ( *pWild || flag )
 178     {
 179         switch ( *pWild )
 180         {
 181             case '?':
 182                 if ( *pStr == '\0' )
 183                     return false;
 184                 break;
 185
 186             default:
 187                 if ( ( *pWild == '\\' ) && ( ( *( pWild + 1 ) == '?' )
 188                                              || ( *( pWild + 1 ) == '*') ) )
 189                     pWild++;
 190                 if ( *pWild != *pStr )
 191                     if ( !pos )
 192                         return false;
 193                     else
 194                         pWild += pos;
 195                 else
 196                     break;
 197
 198                 // Note: fall-through are intended!
 199
 200             case '*':
 201                 while ( *pWild == '*' )
 202                     pWild++;
 203                 if ( *pWild == '\0' )
 204                     return true;
 205                 flag = 1;
 206                 pos  = 0;
 207                 if ( *pStr == '\0' )
 208                     return ( *pWild == '\0' );
 209                 while ( *pStr && *pStr != *pWild )
 210                 {
 211                     if ( *pWild == '?' ) {
 212                         pWild++;
 213                         while ( *pWild == '*' )
 214                             pWild++;
 215                     }
 216                     pStr++;
 217                     if ( *pStr == '\0' )
 218                         return ( *pWild == '\0' );
 219                 }
 220                 break;
 221         }
 222         if ( *pWild != '\0' )
 223             pWild++;
 224         if ( *pStr != '\0' )
 225             pStr++;
 226         else
 227             flag = 0;
 228         if ( flag )
 229             pos--;
 230     }
 231     return ( *pStr == '\0' ) && ( *pWild == '\0' );
 232 }
 233
 234
 235 bool getConfigStringValue(
 236     const uno::Reference< container::XNameAccess > & xNameAccess,
 237     const char * key,
 238     OUString & value )
 239 {
 240     try
 241     {
 242         if ( !( xNameAccess->getByName( OUString::createFromAscii( key ) )
 243                 >>= value ) )
 244         {
 245             OSL_FAIL( "InternetProxyDecider - "
 246                         "Error getting config item value!" );
 247             return false;
 248         }
 249     }
 250     catch ( lang::WrappedTargetException const & )
 251     {
 252         return false;
 253     }
 254     catch ( container::NoSuchElementException const & )
 255     {
 256         return false;
 257     }
 258     return true;
 259 }
 260
 261
 262 bool getConfigInt32Value(
 263     const uno::Reference< container::XNameAccess > & xNameAccess,
 264     const char * key,
 265     sal_Int32 & value )
 266 {
 267     try
 268     {
 269         uno::Any aValue = xNameAccess->getByName(
 270             OUString::createFromAscii( key ) );
 271         if ( aValue.hasValue() && !( aValue >>= value ) )
 272         {
 273             OSL_FAIL( "InternetProxyDecider - "
 274                         "Error getting config item value!" );
 275             return false;
 276         }
 277     }
 278     catch ( lang::WrappedTargetException const & )
 279     {
 280         return false;
 281     }
 282     catch ( container::NoSuchElementException const & )
 283     {
 284         return false;
 285     }
 286     return true;
 287 }
 288
 289
 290
 291
 292 // InternetProxyDecider_Impl Implementation.
 293
 294
 295
 296
 297 InternetProxyDecider_Impl::InternetProxyDecider_Impl(
 298     const uno::Reference< uno::XComponentContext >& rxContext )
 299     : m_nProxyType( 0 ),
 300       m_aHostnames( 256 ) // cache size
 301 {
 302     try
 303     {
 304
 305         // Read proxy configuration from config db.
 306
 307
 308         uno::Reference< lang::XMultiServiceFactory > xConfigProv =
 309                 configuration::theDefaultProvider::get( rxContext );
 310
 311         uno::Sequence< uno::Any > aArguments( 1 );
 312         aArguments[ 0 ] <<= OUString( CONFIG_ROOT_KEY );
 313
 314         uno::Reference< uno::XInterface > xInterface(
 315                     xConfigProv->createInstanceWithArguments(
 316                         OUString(
 317                             "com.sun.star.configuration.ConfigurationAccess" ),
 318                     aArguments ) );
 319
 320         OSL_ENSURE( xInterface.is(),
 321                     "InternetProxyDecider - No config access!" );
 322
 323         if ( xInterface.is() )
 324         {
 325             uno::Reference< container::XNameAccess > xNameAccess(
 326                                             xInterface, uno::UNO_QUERY );
 327             OSL_ENSURE( xNameAccess.is(),
 328                         "InternetProxyDecider - No name access!" );
 329
 330             if ( xNameAccess.is() )
 331             {
 332                 // *** Proxy type ***
 333                 getConfigInt32Value(
 334                     xNameAccess, PROXY_TYPE_KEY, m_nProxyType );
 335
 336                 // *** No proxy list ***
 337                 OUString aNoProxyList;
 338                 getConfigStringValue(
 339                     xNameAccess, NO_PROXY_LIST_KEY, aNoProxyList );
 340                 setNoProxyList( aNoProxyList );
 341
 342                 // *** HTTP ***
 343                 getConfigStringValue(
 344                     xNameAccess, HTTP_PROXY_NAME_KEY, m_aHttpProxy.aName );
 345
 346                 m_aHttpProxy.nPort = -1;
 347                 getConfigInt32Value(
 348                     xNameAccess, HTTP_PROXY_PORT_KEY, m_aHttpProxy.nPort );
 349                 if ( m_aHttpProxy.nPort == -1 )
 350                     m_aHttpProxy.nPort = 80; // standard HTTP port.
 351
 352                 // *** HTTPS ***
 353                 getConfigStringValue(
 354                     xNameAccess, HTTPS_PROXY_NAME_KEY, m_aHttpsProxy.aName );
 355
 356                 m_aHttpsProxy.nPort = -1;
 357                 getConfigInt32Value(
 358                     xNameAccess, HTTPS_PROXY_PORT_KEY, m_aHttpsProxy.nPort );
 359                 if ( m_aHttpsProxy.nPort == -1 )
 360                     m_aHttpsProxy.nPort = 443; // standard HTTPS port.
 361
 362                 // *** FTP ***
 363                 getConfigStringValue(
 364                     xNameAccess, FTP_PROXY_NAME_KEY, m_aFtpProxy.aName );
 365
 366                 m_aFtpProxy.nPort = -1;
 367                 getConfigInt32Value(
 368                     xNameAccess, FTP_PROXY_PORT_KEY, m_aFtpProxy.nPort );
 369             }
 370
 371             // Register as listener for config changes.
 372
 373             m_xNotifier = uno::Reference< util::XChangesNotifier >(
 374                                                 xInterface, uno::UNO_QUERY );
 375
 376             OSL_ENSURE( m_xNotifier.is(),
 377                         "InternetProxyDecider - No notifier!" );
 378
 379             if ( m_xNotifier.is() )
 380                 m_xNotifier->addChangesListener( this );
 381         }
 382     }
 383     catch ( uno::Exception const & )
 384     {
 385         // createInstance, createInstanceWithArguments
 386         OSL_FAIL( "InternetProxyDecider - Exception!" );
 387     }
 388 }
 389
 390
 391 // virtual
 392 InternetProxyDecider_Impl::~InternetProxyDecider_Impl()
 393 {
 394 }
 395
 396
 397 void InternetProxyDecider_Impl::dispose()
 398 {
 399     uno::Reference< util::XChangesNotifier > xNotifier;
 400
 401     if ( m_xNotifier.is() )
 402     {
 403         osl::Guard< osl::Mutex > aGuard( m_aMutex );
 404
 405         if ( m_xNotifier.is() )
 406         {
 407             xNotifier = m_xNotifier;
 408             m_xNotifier.clear();
 409         }
 410     }
 411
 412     // Do this unguarded!
 413     if ( xNotifier.is() )
 414         xNotifier->removeChangesListener( this );
 415 }
 416
 417
 418 bool InternetProxyDecider_Impl::shouldUseProxy( const OUString & rHost,
 419                                                 sal_Int32 nPort,
 420                                                 bool bUseFullyQualified ) const
 421 {
 422     OUStringBuffer aBuffer;
 423
 424     if ( ( rHost.indexOf( ':' ) != -1 ) &&
 425          ( rHost[ 0 ] != '[' ) )
 426     {
 427         // host is given as numeric IPv6 address
 428         aBuffer.appendAscii( "[" );
 429         aBuffer.append( rHost );
 430         aBuffer.appendAscii( "]" );
 431     }
 432     else
 433     {
 434         // host is given either as numeric IPv4 address or non-numeric hostname
 435         aBuffer.append( rHost );
 436     }
 437
 438     aBuffer.append( ':' );
 439     aBuffer.append( OUString::number( nPort ) );
 440     const OUString aHostAndPort( aBuffer.makeStringAndClear() );
 441
 442     std::vector< NoProxyListEntry >::const_iterator it
 443         = m_aNoProxyList.begin();
 444     const std::vector< NoProxyListEntry >::const_iterator end
 445         = m_aNoProxyList.end();
 446
 447     while ( it != end )
 448     {
 449         if ( bUseFullyQualified )
 450         {
 451             if ( (*it).second.Matches( aHostAndPort ) )
 452                 return false;
 453         }
 454         else
 455         {
 456             if ( (*it).first.Matches( aHostAndPort ) )
 457                 return false;
 458         }
 459         ++it;
 460     }
 461
 462     return true;
 463 }
 464
 465
 466 const InternetProxyServer & InternetProxyDecider_Impl::getProxy(
 467                                             const OUString & rProtocol,
 468                                             const OUString & rHost,
 469                                             sal_Int32 nPort ) const
 470 {
 471     osl::Guard< osl::Mutex > aGuard( m_aMutex );
 472
 473     if ( m_nProxyType == 0 )
 474     {
 475         // Never use proxy.
 476         return m_aEmptyProxy;
 477     }
 478
 479     if ( !rHost.isEmpty() && !m_aNoProxyList.empty() )
 480     {
 481
 482         // First, try direct hostname match - #110515#
 483
 484
 485         if ( !shouldUseProxy( rHost, nPort, false ) )
 486             return m_aEmptyProxy;
 487
 488
 489         // Second, try match against full qualified hostname - #104401#
 490
 491
 492         OUString aHost;
 493
 494         if ( ( rHost.getLength() > 1 ) &&
 495              ( rHost[ 0 ] == '[' ))
 496         {
 497             // host is given as numeric IPv6 address. name resolution
 498             // functions need hostname without square brackets.
 499             aHost = rHost.copy( 1, rHost.getLength() - 2 );
 500         }
 501         else
 502         {
 503             aHost = rHost;
 504         }
 505
 506         OUString aFullyQualifiedHost;
 507         if ( !m_aHostnames.get( aHost, aFullyQualifiedHost ) )
 508         {
 509             // This might be quite expensive (DNS lookup).
 510             const osl::SocketAddr aAddr( aHost, nPort );
 511             aFullyQualifiedHost = aAddr.getHostname().toAsciiLowerCase();
 512             m_aHostnames.put( aHost, aFullyQualifiedHost );
 513         }
 514
 515         // Error resolving name? -> fallback.
 516         if ( aFullyQualifiedHost.isEmpty() )
 517             aFullyQualifiedHost = aHost;
 518
 519         if ( aFullyQualifiedHost != aHost )
 520         {
 521             if ( !shouldUseProxy( aFullyQualifiedHost, nPort, false ) )
 522                 return m_aEmptyProxy;
 523         }
 524
 525
 526         // Third, try match of fully qualified entries in no-proxy list
 527         // against full qualified hostname
 528
 529         // Example:
 530         // list: staroffice-doc -> full: xyz.germany.sun.com
 531         // in:   staroffice-doc.germany.sun.com -> full: xyz.germany.sun.com
 532
 533
 534
 535         if ( !shouldUseProxy( aFullyQualifiedHost, nPort, true ) )
 536             return m_aEmptyProxy;
 537     }
 538
 539     if ( rProtocol.toAsciiLowerCase() == "ftp" )
 540     {
 541         if ( !m_aFtpProxy.aName.isEmpty() && m_aFtpProxy.nPort >= 0 )
 542             return m_aFtpProxy;
 543     }
 544     else if ( rProtocol.toAsciiLowerCase() == "https" )
 545     {
 546         if ( !m_aHttpsProxy.aName.isEmpty() )
 547             return m_aHttpsProxy;
 548     }
 549     else if ( !m_aHttpProxy.aName.isEmpty() )
 550     {
 551         // All other protocols use the HTTP proxy.
 552         return m_aHttpProxy;
 553     }
 554     return m_aEmptyProxy;
 555 }
 556
 557
 558 // virtual
 559 void SAL_CALL InternetProxyDecider_Impl::changesOccurred(
 560                                         const util::ChangesEvent& Event )
 561     throw( uno::RuntimeException, std::exception )
 562 {
 563     osl::Guard< osl::Mutex > aGuard( m_aMutex );
 564
 565     sal_Int32 nCount = Event.Changes.getLength();
 566     if ( nCount )
 567     {
 568         const util::ElementChange* pElementChanges
 569             = Event.Changes.getConstArray();
 570         for ( sal_Int32 n = 0; n < nCount; ++n )
 571         {
 572             const util::ElementChange& rElem = pElementChanges[ n ];
 573             OUString aKey;
 574             if ( ( rElem.Accessor >>= aKey ) && !aKey.isEmpty() )
 575             {
 576                 if ( aKey == PROXY_TYPE_KEY )
 577                 {
 578                     if ( !( rElem.Element >>= m_nProxyType ) )
 579                     {
 580                         OSL_FAIL( "InternetProxyDecider - changesOccurred - "
 581                                     "Error getting config item value!" );
 582                     }
 583                 }
 584                 else if ( aKey == NO_PROXY_LIST_KEY )
 585                 {
 586                     OUString aNoProxyList;
 587                     if ( !( rElem.Element >>= aNoProxyList ) )
 588                     {
 589                         OSL_FAIL( "InternetProxyDecider - changesOccurred - "
 590                                     "Error getting config item value!" );
 591                     }
 592
 593                     setNoProxyList( aNoProxyList );
 594                 }
 595                 else if ( aKey == HTTP_PROXY_NAME_KEY )
 596                 {
 597                     if ( !( rElem.Element >>= m_aHttpProxy.aName ) )
 598                     {
 599                         OSL_FAIL( "InternetProxyDecider - changesOccurred - "
 600                                     "Error getting config item value!" );
 601                     }
 602                 }
 603                 else if ( aKey == HTTP_PROXY_PORT_KEY )
 604                 {
 605                     if ( !( rElem.Element >>= m_aHttpProxy.nPort ) )
 606                     {
 607                         OSL_FAIL( "InternetProxyDecider - changesOccurred - "
 608                                     "Error getting config item value!" );
 609                     }
 610
 611                     if ( m_aHttpProxy.nPort == -1 )
 612                         m_aHttpProxy.nPort = 80; // standard HTTP port.
 613                 }
 614                 else if ( aKey == HTTPS_PROXY_NAME_KEY )
 615                 {
 616                     if ( !( rElem.Element >>= m_aHttpsProxy.aName ) )
 617                     {
 618                         OSL_FAIL( "InternetProxyDecider - changesOccurred - "
 619                                     "Error getting config item value!" );
 620                     }
 621                 }
 622                 else if ( aKey == HTTPS_PROXY_PORT_KEY )
 623                 {
 624                     if ( !( rElem.Element >>= m_aHttpsProxy.nPort ) )
 625                     {
 626                         OSL_FAIL( "InternetProxyDecider - changesOccurred - "
 627                                     "Error getting config item value!" );
 628                     }
 629
 630                     if ( m_aHttpsProxy.nPort == -1 )
 631                         m_aHttpsProxy.nPort = 443; // standard HTTPS port.
 632                 }
 633                 else if ( aKey == FTP_PROXY_NAME_KEY )
 634                 {
 635                     if ( !( rElem.Element >>= m_aFtpProxy.aName ) )
 636                     {
 637                         OSL_FAIL( "InternetProxyDecider - changesOccurred - "
 638                                     "Error getting config item value!" );
 639                     }
 640                 }
 641                 else if ( aKey == FTP_PROXY_PORT_KEY )
 642                 {
 643                     if ( !( rElem.Element >>= m_aFtpProxy.nPort ) )
 644                     {
 645                         OSL_FAIL( "InternetProxyDecider - changesOccurred - "
 646                                     "Error getting config item value!" );
 647                     }
 648                 }
 649             }
 650         }
 651     }
 652 }
 653
 654
 655 // virtual
 656 void SAL_CALL InternetProxyDecider_Impl::disposing(const lang::EventObject&)
 657     throw( uno::RuntimeException, std::exception )
 658 {
 659     if ( m_xNotifier.is() )
 660     {
 661         osl::Guard< osl::Mutex > aGuard( m_aMutex );
 662
 663         if ( m_xNotifier.is() )
 664             m_xNotifier.clear();
 665     }
 666 }
 667
 668
 669 void InternetProxyDecider_Impl::setNoProxyList(
 670                                         const OUString & rNoProxyList )
 671 {
 672     osl::Guard< osl::Mutex > aGuard( m_aMutex );
 673
 674     m_aNoProxyList.clear();
 675
 676     if ( !rNoProxyList.isEmpty() )
 677     {
 678         // List of connection endpoints hostname[:port],
 679         // separated by semicolon. Wilcards allowed.
 680
 681         sal_Int32 nPos = 0;
 682         sal_Int32 nEnd = rNoProxyList.indexOf( ';' );
 683         sal_Int32 nLen = rNoProxyList.getLength();
 684
 685         do
 686         {
 687             if ( nEnd == -1 )
 688                 nEnd = nLen;
 689
 690             OUString aToken = rNoProxyList.copy( nPos, nEnd - nPos );
 691
 692             if ( !aToken.isEmpty() )
 693             {
 694                 OUString aServer;
 695                 OUString aPort;
 696
 697                 // numerical IPv6 address?
 698                 bool bIPv6Address = false;
 699                 sal_Int32 nClosedBracketPos = aToken.indexOf( ']' );
 700                 if ( nClosedBracketPos == -1 )
 701                     nClosedBracketPos = 0;
 702                 else
 703                     bIPv6Address = true;
 704
 705                 sal_Int32 nColonPos = aToken.indexOf( ':', nClosedBracketPos );
 706                 if ( nColonPos == -1 )
 707                 {
 708                     // No port given, server pattern equals current token
 709                     aPort = "*";
 710                     if ( aToken.indexOf( '*' ) == -1 )
 711                     {
 712                         // pattern describes exactly one server
 713                         aServer = aToken;
 714                     }
 715
 716                     aToken += ":*";
 717                 }
 718                 else
 719                 {
 720                     // Port given, extract server pattern
 721                     sal_Int32 nAsteriskPos = aToken.indexOf( '*' );
 722                     aPort = aToken.copy( nColonPos + 1 );
 723                     if ( nAsteriskPos < nColonPos )
 724                     {
 725                         // pattern describes exactly one server
 726                         aServer = aToken.copy( 0, nColonPos );
 727                     }
 728                 }
 729
 730                 OUStringBuffer aFullyQualifiedHost;
 731                 if ( !aServer.isEmpty() )
 732                 {
 733                     // Remember fully qualified server name if current list
 734                     // entry specifies exactly one non-fully qualified server
 735                     // name.
 736
 737                     // remove square brackets from host name in case it's
 738                     // a numerical IPv6 address.
 739                     if ( bIPv6Address )
 740                         aServer = aServer.copy( 1, aServer.getLength() - 2 );
 741
 742                     // This might be quite expensive (DNS lookup).
 743                     const osl::SocketAddr aAddr( aServer, 0 );
 744                     OUString aTmp = aAddr.getHostname().toAsciiLowerCase();
 745                     if ( aTmp != aServer.toAsciiLowerCase() )
 746                     {
 747                         if ( bIPv6Address )
 748                         {
 749                             aFullyQualifiedHost.appendAscii( "[" );
 750                             aFullyQualifiedHost.append( aTmp );
 751                             aFullyQualifiedHost.appendAscii( "]" );
 752                         }
 753                         else
 754                         {
 755                             aFullyQualifiedHost.append( aTmp );
 756                         }
 757                         aFullyQualifiedHost.appendAscii( ":" );
 758                         aFullyQualifiedHost.append( aPort );
 759                     }
 760                 }
 761
 762                 m_aNoProxyList.push_back(
 763                     NoProxyListEntry( WildCard( aToken ),
 764                                       WildCard(
 765                                         aFullyQualifiedHost
 766                                             .makeStringAndClear() ) ) );
 767             }
 768
 769             if ( nEnd != nLen )
 770             {
 771                 nPos = nEnd + 1;
 772                 nEnd = rNoProxyList.indexOf( ';', nPos );
 773             }
 774         }
 775         while ( nEnd != nLen );
 776     }
 777 }
 778
 779 } // namespace proxydecider_impl
 780
 781
 782
 783
 784 // InternetProxyDecider Implementation.
 785
 786
 787
 788
 789 InternetProxyDecider::InternetProxyDecider(
 790     const uno::Reference< uno::XComponentContext>& rxContext )
 791 : m_pImpl( new proxydecider_impl::InternetProxyDecider_Impl( rxContext ) )
 792 {
 793     m_pImpl->acquire();
 794 }
 795
 796
 797 InternetProxyDecider::~InternetProxyDecider()
 798 {
 799     // Break circular reference between config listener and notifier.
 800     m_pImpl->dispose();
 801
 802     // Let him go...
 803     m_pImpl->release();
 804 }
 805
 806
 807 bool InternetProxyDecider::shouldUseProxy( const OUString & rProtocol,
 808                                            const OUString & rHost,
 809                                            sal_Int32 nPort ) const
 810 {
 811     const InternetProxyServer & rData = m_pImpl->getProxy( rProtocol,
 812                                                            rHost,
 813                                                            nPort );
 814     return !rData.aName.isEmpty();
 815 }
 816
 817
 818 const InternetProxyServer & InternetProxyDecider::getProxy(
 819                                             const OUString & rProtocol,
 820                                             const OUString & rHost,
 821                                             sal_Int32 nPort ) const
 822 {
 823     return m_pImpl->getProxy( rProtocol, rHost, nPort );
 824 }
 825
 826 } // namespace ucbhelper
 827
 828 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */