webengine/osswebengine/WebKit/win/WebURLProtectionSpace.cpp
changeset 0 dd21522fd290
equal deleted inserted replaced
-1:000000000000 0:dd21522fd290
       
     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 }
       
    45 
       
    46 WebURLProtectionSpace::~WebURLProtectionSpace()
       
    47 {
       
    48     gClassCount--;
       
    49 }
       
    50 
       
    51 WebURLProtectionSpace* WebURLProtectionSpace::createInstance()
       
    52 {
       
    53     WebURLProtectionSpace* instance = new WebURLProtectionSpace(ProtectionSpace());
       
    54     instance->AddRef();
       
    55     return instance;
       
    56 }
       
    57 
       
    58 WebURLProtectionSpace* WebURLProtectionSpace::createInstance(const ProtectionSpace& protectionSpace)
       
    59 {
       
    60     WebURLProtectionSpace* instance = new WebURLProtectionSpace(protectionSpace);
       
    61     instance->AddRef();
       
    62     return instance;
       
    63 }
       
    64 
       
    65 // IUnknown -------------------------------------------------------------------
       
    66 
       
    67 HRESULT STDMETHODCALLTYPE WebURLProtectionSpace::QueryInterface(REFIID riid, void** ppvObject)
       
    68 {
       
    69     *ppvObject = 0;
       
    70     if (IsEqualGUID(riid, IID_IUnknown))
       
    71         *ppvObject = static_cast<IUnknown*>(this);
       
    72     else if (IsEqualGUID(riid, CLSID_WebURLProtectionSpace))
       
    73         *ppvObject = static_cast<WebURLProtectionSpace*>(this);
       
    74     else if (IsEqualGUID(riid, IID_IWebURLProtectionSpace))
       
    75         *ppvObject = static_cast<IWebURLProtectionSpace*>(this);
       
    76     else
       
    77         return E_NOINTERFACE;
       
    78 
       
    79     AddRef();
       
    80     return S_OK;
       
    81 }
       
    82 
       
    83 ULONG STDMETHODCALLTYPE WebURLProtectionSpace::AddRef(void)
       
    84 {
       
    85     return ++m_refCount;
       
    86 }
       
    87 
       
    88 ULONG STDMETHODCALLTYPE WebURLProtectionSpace::Release(void)
       
    89 {
       
    90     ULONG newRef = --m_refCount;
       
    91     if (!newRef)
       
    92         delete(this);
       
    93 
       
    94     return newRef;
       
    95 }
       
    96 
       
    97 // IWebURLProtectionSpace -------------------------------------------------------------------
       
    98 
       
    99 HRESULT STDMETHODCALLTYPE WebURLProtectionSpace::authenticationMethod(
       
   100     /* [out, retval] */ BSTR* result)
       
   101 {
       
   102     switch (m_protectionSpace.authenticationScheme()) {
       
   103     case ProtectionSpaceAuthenticationSchemeDefault:
       
   104         *result = SysAllocString(WebURLAuthenticationMethodDefault);
       
   105         break;
       
   106     case ProtectionSpaceAuthenticationSchemeHTTPBasic:
       
   107         *result = SysAllocString(WebURLAuthenticationMethodHTTPBasic);
       
   108         break;
       
   109     case ProtectionSpaceAuthenticationSchemeHTTPDigest:
       
   110         *result = SysAllocString(WebURLAuthenticationMethodHTTPDigest);
       
   111         break;
       
   112     case ProtectionSpaceAuthenticationSchemeHTMLForm:
       
   113         *result = SysAllocString(WebURLAuthenticationMethodHTMLForm);
       
   114         break;
       
   115     default:
       
   116         ASSERT_NOT_REACHED();
       
   117         return E_FAIL;
       
   118     }
       
   119     return S_OK;
       
   120 }
       
   121 
       
   122 HRESULT STDMETHODCALLTYPE WebURLProtectionSpace::host(
       
   123     /* [out, retval] */ BSTR* result)
       
   124 {
       
   125     BString str = m_protectionSpace.host();
       
   126     *result = str.release();
       
   127     return S_OK;
       
   128 }
       
   129 
       
   130 static ProtectionSpaceAuthenticationScheme coreScheme(BSTR authenticationMethod)
       
   131 {
       
   132     ProtectionSpaceAuthenticationScheme scheme = ProtectionSpaceAuthenticationSchemeDefault;
       
   133     if (BString(authenticationMethod) == BString(WebURLAuthenticationMethodDefault))
       
   134         scheme = ProtectionSpaceAuthenticationSchemeDefault;
       
   135     else if (BString(authenticationMethod) == BString(WebURLAuthenticationMethodHTTPBasic))
       
   136         scheme = ProtectionSpaceAuthenticationSchemeHTTPBasic;
       
   137     else if (BString(authenticationMethod) == BString(WebURLAuthenticationMethodHTTPDigest))
       
   138         scheme = ProtectionSpaceAuthenticationSchemeHTTPDigest;
       
   139     else if (BString(authenticationMethod) == BString(WebURLAuthenticationMethodHTMLForm))
       
   140         scheme = ProtectionSpaceAuthenticationSchemeHTMLForm;
       
   141     else
       
   142         ASSERT_NOT_REACHED();
       
   143     return scheme;
       
   144 }
       
   145 
       
   146 HRESULT STDMETHODCALLTYPE WebURLProtectionSpace::initWithHost(
       
   147     /* [in] */ BSTR host, 
       
   148     /* [in] */ int port, 
       
   149     /* [in] */ BSTR protocol, 
       
   150     /* [in] */ BSTR realm, 
       
   151     /* [in] */ BSTR authenticationMethod)
       
   152 {
       
   153     ProtectionSpaceServerType serverType = ProtectionSpaceServerHTTP;
       
   154     if (BString(protocol) == WebURLProtectionSpaceHTTP)
       
   155         serverType = ProtectionSpaceServerHTTP;
       
   156     else if (BString(protocol) == WebURLProtectionSpaceHTTPS)
       
   157         serverType = ProtectionSpaceServerHTTPS;
       
   158     else if (BString(protocol) == WebURLProtectionSpaceFTP)
       
   159         serverType = ProtectionSpaceServerFTP;
       
   160     else if (BString(protocol) == WebURLProtectionSpaceFTPS)
       
   161         serverType = ProtectionSpaceServerFTPS;
       
   162     else
       
   163         ASSERT_NOT_REACHED();
       
   164 
       
   165     m_protectionSpace = ProtectionSpace(String(host, SysStringLen(host)), port, serverType, 
       
   166         String(realm, SysStringLen(realm)), coreScheme(authenticationMethod));
       
   167 
       
   168     return S_OK;
       
   169 }
       
   170 
       
   171 HRESULT STDMETHODCALLTYPE WebURLProtectionSpace::initWithProxyHost(
       
   172     /* [in] */ BSTR host, 
       
   173     /* [in] */ int port, 
       
   174     /* [in] */ BSTR proxyType, 
       
   175     /* [in] */ BSTR realm, 
       
   176     /* [in] */ BSTR authenticationMethod)
       
   177 {
       
   178     ProtectionSpaceServerType serverType = ProtectionSpaceProxyHTTP;
       
   179     if (BString(proxyType) == WebURLProtectionSpaceHTTPProxy)
       
   180         serverType = ProtectionSpaceProxyHTTP;
       
   181     else if (BString(proxyType) == WebURLProtectionSpaceHTTPSProxy)
       
   182         serverType = ProtectionSpaceProxyHTTPS;
       
   183     else if (BString(proxyType) == WebURLProtectionSpaceFTPProxy)
       
   184         serverType = ProtectionSpaceProxyFTP;
       
   185     else if (BString(proxyType) == WebURLProtectionSpaceSOCKSProxy)
       
   186         serverType = ProtectionSpaceProxySOCKS;
       
   187     else
       
   188         ASSERT_NOT_REACHED();
       
   189 
       
   190     m_protectionSpace = ProtectionSpace(String(host, SysStringLen(host)), port, serverType, 
       
   191         String(realm, SysStringLen(realm)), coreScheme(authenticationMethod));
       
   192 
       
   193     return S_OK;
       
   194 }
       
   195 
       
   196 HRESULT STDMETHODCALLTYPE WebURLProtectionSpace::isProxy(
       
   197     /* [out, retval] */ BOOL* result)
       
   198 {
       
   199     *result = m_protectionSpace.isProxy();
       
   200     return S_OK;
       
   201 }
       
   202 
       
   203 HRESULT STDMETHODCALLTYPE WebURLProtectionSpace::port(
       
   204     /* [out, retval] */ int* result)
       
   205 {
       
   206     *result = m_protectionSpace.port();
       
   207     return S_OK;
       
   208 }
       
   209 
       
   210 HRESULT STDMETHODCALLTYPE WebURLProtectionSpace::protocol(
       
   211     /* [out, retval] */ BSTR* result)
       
   212 {
       
   213     switch (m_protectionSpace.serverType()) {
       
   214     case ProtectionSpaceServerHTTP:
       
   215         *result = SysAllocString(WebURLProtectionSpaceHTTP);
       
   216         break;
       
   217     case ProtectionSpaceServerHTTPS:
       
   218         *result = SysAllocString(WebURLProtectionSpaceHTTPS);
       
   219         break;
       
   220     case ProtectionSpaceServerFTP:
       
   221         *result = SysAllocString(WebURLProtectionSpaceFTP);
       
   222         break;
       
   223     case ProtectionSpaceServerFTPS:
       
   224         *result = SysAllocString(WebURLProtectionSpaceFTPS);
       
   225         break;
       
   226     default:
       
   227         ASSERT_NOT_REACHED();
       
   228         return E_FAIL;
       
   229     }
       
   230     return S_OK;
       
   231 }
       
   232 
       
   233 HRESULT STDMETHODCALLTYPE WebURLProtectionSpace::proxyType(
       
   234     /* [out, retval] */ BSTR* result)
       
   235 {
       
   236     switch (m_protectionSpace.serverType()) {
       
   237     case ProtectionSpaceProxyHTTP:
       
   238         *result = SysAllocString(WebURLProtectionSpaceHTTPProxy);
       
   239         break;
       
   240     case ProtectionSpaceProxyHTTPS:
       
   241         *result = SysAllocString(WebURLProtectionSpaceHTTPSProxy);
       
   242         break;
       
   243     case ProtectionSpaceProxyFTP:
       
   244         *result = SysAllocString(WebURLProtectionSpaceFTPProxy);
       
   245         break;
       
   246     case ProtectionSpaceProxySOCKS:
       
   247         *result = SysAllocString(WebURLProtectionSpaceSOCKSProxy);
       
   248         break;
       
   249     default:
       
   250         ASSERT_NOT_REACHED();
       
   251         return E_FAIL;
       
   252     }
       
   253     return S_OK;
       
   254 }
       
   255 
       
   256 HRESULT STDMETHODCALLTYPE WebURLProtectionSpace::realm(
       
   257     /* [out, retval] */ BSTR* result)
       
   258 {
       
   259     BString bstring = m_protectionSpace.realm();
       
   260     *result = bstring.release();
       
   261     return S_OK;
       
   262 }
       
   263 
       
   264 HRESULT STDMETHODCALLTYPE WebURLProtectionSpace::receivesCredentialSecurely(
       
   265     /* [out, retval] */ BOOL* result)
       
   266 {
       
   267     *result = m_protectionSpace.receivesCredentialSecurely();
       
   268     return S_OK;
       
   269 }
       
   270 
       
   271 // WebURLProtectionSpace -------------------------------------------------------------------
       
   272 const ProtectionSpace& WebURLProtectionSpace::protectionSpace() const
       
   273 {
       
   274     return m_protectionSpace;
       
   275 }