Home | History | Annotate | Download | only in win 
      1 /*
      2  * Copyright (C) 2007 Apple Inc.  All rights reserved.
      3  *
      4  * Redistribution and use in source and binary forms, with or without
      5  * modification, are permitted provided that the following conditions
      6  * are met:
      7  * 1. Redistributions of source code must retain the above copyright
      8  *    notice, this list of conditions and the following disclaimer.
      9  * 2. Redistributions in binary form must reproduce the above copyright
     10  *    notice, this list of conditions and the following disclaimer in the
     11  *    documentation and/or other materials provided with the distribution.
     12  *
     13  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
     14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
     17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
     18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
     19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
     20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
     21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     24  */
     25 
     26 #include "config.h"
     27 #include "WebKit.h"
     28 #include "WebKitDLL.h"
     29 #include "WebURLProtectionSpace.h"
     30 
     31 #pragma warning(push, 0)
     32 #include <WebCore/BString.h>
     33 #pragma warning(pop)
     34 
     35 using namespace WebCore;
     36 
     37 // WebURLProtectionSpace ----------------------------------------------------------------
     38 
     39 WebURLProtectionSpace::WebURLProtectionSpace(const ProtectionSpace& protectionSpace)
     40     : m_refCount(0)
     41     , m_protectionSpace(protectionSpace)
     42 {
     43     gClassCount++;
     44     gClassNameCount.add("WebURLProtectionSpace");
     45 }
     46 
     47 WebURLProtectionSpace::~WebURLProtectionSpace()
     48 {
     49     gClassCount--;
     50     gClassNameCount.remove("WebURLProtectionSpace");
     51 }
     52 
     53 WebURLProtectionSpace* WebURLProtectionSpace::createInstance()
     54 {
     55     WebURLProtectionSpace* instance = new WebURLProtectionSpace(ProtectionSpace());
     56     instance->AddRef();
     57     return instance;
     58 }
     59 
     60 WebURLProtectionSpace* WebURLProtectionSpace::createInstance(const ProtectionSpace& protectionSpace)
     61 {
     62     WebURLProtectionSpace* instance = new WebURLProtectionSpace(protectionSpace);
     63     instance->AddRef();
     64     return instance;
     65 }
     66 
     67 // IUnknown -------------------------------------------------------------------
     68 
     69 HRESULT STDMETHODCALLTYPE WebURLProtectionSpace::QueryInterface(REFIID riid, void** ppvObject)
     70 {
     71     *ppvObject = 0;
     72     if (IsEqualGUID(riid, IID_IUnknown))
     73         *ppvObject = static_cast<IUnknown*>(this);
     74     else if (IsEqualGUID(riid, CLSID_WebURLProtectionSpace))
     75         *ppvObject = static_cast<WebURLProtectionSpace*>(this);
     76     else if (IsEqualGUID(riid, IID_IWebURLProtectionSpace))
     77         *ppvObject = static_cast<IWebURLProtectionSpace*>(this);
     78     else
     79         return E_NOINTERFACE;
     80 
     81     AddRef();
     82     return S_OK;
     83 }
     84 
     85 ULONG STDMETHODCALLTYPE WebURLProtectionSpace::AddRef(void)
     86 {
     87     return ++m_refCount;
     88 }
     89 
     90 ULONG STDMETHODCALLTYPE WebURLProtectionSpace::Release(void)
     91 {
     92     ULONG newRef = --m_refCount;
     93     if (!newRef)
     94         delete(this);
     95 
     96     return newRef;
     97 }
     98 
     99 // IWebURLProtectionSpace -------------------------------------------------------------------
    100 
    101 HRESULT STDMETHODCALLTYPE WebURLProtectionSpace::authenticationMethod(
    102     /* [out, retval] */ BSTR* result)
    103 {
    104     switch (m_protectionSpace.authenticationScheme()) {
    105     case ProtectionSpaceAuthenticationSchemeDefault:
    106         *result = SysAllocString(WebURLAuthenticationMethodDefault);
    107         break;
    108     case ProtectionSpaceAuthenticationSchemeHTTPBasic:
    109         *result = SysAllocString(WebURLAuthenticationMethodHTTPBasic);
    110         break;
    111     case ProtectionSpaceAuthenticationSchemeHTTPDigest:
    112         *result = SysAllocString(WebURLAuthenticationMethodHTTPDigest);
    113         break;
    114     case ProtectionSpaceAuthenticationSchemeHTMLForm:
    115         *result = SysAllocString(WebURLAuthenticationMethodHTMLForm);
    116         break;
    117     default:
    118         ASSERT_NOT_REACHED();
    119         return E_FAIL;
    120     }
    121     return S_OK;
    122 }
    123 
    124 HRESULT STDMETHODCALLTYPE WebURLProtectionSpace::host(
    125     /* [out, retval] */ BSTR* result)
    126 {
    127     BString str = m_protectionSpace.host();
    128     *result = str.release();
    129     return S_OK;
    130 }
    131 
    132 static ProtectionSpaceAuthenticationScheme coreScheme(BSTR authenticationMethod)
    133 {
    134     ProtectionSpaceAuthenticationScheme scheme = ProtectionSpaceAuthenticationSchemeDefault;
    135     if (BString(authenticationMethod) == BString(WebURLAuthenticationMethodDefault))
    136         scheme = ProtectionSpaceAuthenticationSchemeDefault;
    137     else if (BString(authenticationMethod) == BString(WebURLAuthenticationMethodHTTPBasic))
    138         scheme = ProtectionSpaceAuthenticationSchemeHTTPBasic;
    139     else if (BString(authenticationMethod) == BString(WebURLAuthenticationMethodHTTPDigest))
    140         scheme = ProtectionSpaceAuthenticationSchemeHTTPDigest;
    141     else if (BString(authenticationMethod) == BString(WebURLAuthenticationMethodHTMLForm))
    142         scheme = ProtectionSpaceAuthenticationSchemeHTMLForm;
    143     else
    144         ASSERT_NOT_REACHED();
    145     return scheme;
    146 }
    147 
    148 HRESULT STDMETHODCALLTYPE WebURLProtectionSpace::initWithHost(
    149     /* [in] */ BSTR host,
    150     /* [in] */ int port,
    151     /* [in] */ BSTR protocol,
    152     /* [in] */ BSTR realm,
    153     /* [in] */ BSTR authenticationMethod)
    154 {
    155     static BString& webURLProtectionSpaceHTTPBString = *new BString(WebURLProtectionSpaceHTTP);
    156     static BString& webURLProtectionSpaceHTTPSBString = *new BString(WebURLProtectionSpaceHTTPS);
    157     static BString& webURLProtectionSpaceFTPBString = *new BString(WebURLProtectionSpaceFTP);
    158     static BString& webURLProtectionSpaceFTPSBString = *new BString(WebURLProtectionSpaceFTPS);
    159 
    160     ProtectionSpaceServerType serverType = ProtectionSpaceServerHTTP;
    161     if (BString(protocol) == webURLProtectionSpaceHTTPBString)
    162         serverType = ProtectionSpaceServerHTTP;
    163     else if (BString(protocol) == webURLProtectionSpaceHTTPSBString)
    164         serverType = ProtectionSpaceServerHTTPS;
    165     else if (BString(protocol) == webURLProtectionSpaceFTPBString)
    166         serverType = ProtectionSpaceServerFTP;
    167     else if (BString(protocol) == webURLProtectionSpaceFTPSBString)
    168         serverType = ProtectionSpaceServerFTPS;
    169     else
    170         ASSERT_NOT_REACHED();
    171 
    172     m_protectionSpace = ProtectionSpace(String(host, SysStringLen(host)), port, serverType,
    173         String(realm, SysStringLen(realm)), coreScheme(authenticationMethod));
    174 
    175     return S_OK;
    176 }
    177 
    178 HRESULT STDMETHODCALLTYPE WebURLProtectionSpace::initWithProxyHost(
    179     /* [in] */ BSTR host,
    180     /* [in] */ int port,
    181     /* [in] */ BSTR proxyType,
    182     /* [in] */ BSTR realm,
    183     /* [in] */ BSTR authenticationMethod)
    184 {
    185     static BString& webURLProtectionSpaceHTTPProxyBString = *new BString(WebURLProtectionSpaceHTTPProxy);
    186     static BString& webURLProtectionSpaceHTTPSProxyBString = *new BString(WebURLProtectionSpaceHTTPSProxy);
    187     static BString& webURLProtectionSpaceFTPProxyBString = *new BString(WebURLProtectionSpaceFTPProxy);
    188     static BString& webURLProtectionSpaceSOCKSProxyBString = *new BString(WebURLProtectionSpaceSOCKSProxy);
    189 
    190     ProtectionSpaceServerType serverType = ProtectionSpaceProxyHTTP;
    191     if (BString(proxyType) == webURLProtectionSpaceHTTPProxyBString)
    192         serverType = ProtectionSpaceProxyHTTP;
    193     else if (BString(proxyType) == webURLProtectionSpaceHTTPSProxyBString)
    194         serverType = ProtectionSpaceProxyHTTPS;
    195     else if (BString(proxyType) == webURLProtectionSpaceFTPProxyBString)
    196         serverType = ProtectionSpaceProxyFTP;
    197     else if (BString(proxyType) == webURLProtectionSpaceSOCKSProxyBString)
    198         serverType = ProtectionSpaceProxySOCKS;
    199     else
    200         ASSERT_NOT_REACHED();
    201 
    202     m_protectionSpace = ProtectionSpace(String(host, SysStringLen(host)), port, serverType,
    203         String(realm, SysStringLen(realm)), coreScheme(authenticationMethod));
    204 
    205     return S_OK;
    206 }
    207 
    208 HRESULT STDMETHODCALLTYPE WebURLProtectionSpace::isProxy(
    209     /* [out, retval] */ BOOL* result)
    210 {
    211     *result = m_protectionSpace.isProxy();
    212     return S_OK;
    213 }
    214 
    215 HRESULT STDMETHODCALLTYPE WebURLProtectionSpace::port(
    216     /* [out, retval] */ int* result)
    217 {
    218     *result = m_protectionSpace.port();
    219     return S_OK;
    220 }
    221 
    222 HRESULT STDMETHODCALLTYPE WebURLProtectionSpace::protocol(
    223     /* [out, retval] */ BSTR* result)
    224 {
    225     switch (m_protectionSpace.serverType()) {
    226     case ProtectionSpaceServerHTTP:
    227         *result = SysAllocString(WebURLProtectionSpaceHTTP);
    228         break;
    229     case ProtectionSpaceServerHTTPS:
    230         *result = SysAllocString(WebURLProtectionSpaceHTTPS);
    231         break;
    232     case ProtectionSpaceServerFTP:
    233         *result = SysAllocString(WebURLProtectionSpaceFTP);
    234         break;
    235     case ProtectionSpaceServerFTPS:
    236         *result = SysAllocString(WebURLProtectionSpaceFTPS);
    237         break;
    238     default:
    239         ASSERT_NOT_REACHED();
    240         return E_FAIL;
    241     }
    242     return S_OK;
    243 }
    244 
    245 HRESULT STDMETHODCALLTYPE WebURLProtectionSpace::proxyType(
    246     /* [out, retval] */ BSTR* result)
    247 {
    248     switch (m_protectionSpace.serverType()) {
    249     case ProtectionSpaceProxyHTTP:
    250         *result = SysAllocString(WebURLProtectionSpaceHTTPProxy);
    251         break;
    252     case ProtectionSpaceProxyHTTPS:
    253         *result = SysAllocString(WebURLProtectionSpaceHTTPSProxy);
    254         break;
    255     case ProtectionSpaceProxyFTP:
    256         *result = SysAllocString(WebURLProtectionSpaceFTPProxy);
    257         break;
    258     case ProtectionSpaceProxySOCKS:
    259         *result = SysAllocString(WebURLProtectionSpaceSOCKSProxy);
    260         break;
    261     default:
    262         ASSERT_NOT_REACHED();
    263         return E_FAIL;
    264     }
    265     return S_OK;
    266 }
    267 
    268 HRESULT STDMETHODCALLTYPE WebURLProtectionSpace::realm(
    269     /* [out, retval] */ BSTR* result)
    270 {
    271     BString bstring = m_protectionSpace.realm();
    272     *result = bstring.release();
    273     return S_OK;
    274 }
    275 
    276 HRESULT STDMETHODCALLTYPE WebURLProtectionSpace::receivesCredentialSecurely(
    277     /* [out, retval] */ BOOL* result)
    278 {
    279     *result = m_protectionSpace.receivesCredentialSecurely();
    280     return S_OK;
    281 }
    282 
    283 // WebURLProtectionSpace -------------------------------------------------------------------
    284 const ProtectionSpace& WebURLProtectionSpace::protectionSpace() const
    285 {
    286     return m_protectionSpace;
    287 }
    288