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