code.vuplus.com Git - vuplus_webkit/blob - Source/WebKit/win/WebURLProtectionSpace.cpp

   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 #include <WebCore/BString.h>
  32
  33 using namespace WebCore;
  34
  35 // WebURLProtectionSpace ----------------------------------------------------------------
  36
  37 WebURLProtectionSpace::WebURLProtectionSpace(const ProtectionSpace& protectionSpace)
  38     : m_refCount(0)
  39     , m_protectionSpace(protectionSpace)
  40 {
  41     gClassCount++;
  42     gClassNameCount.add("WebURLProtectionSpace");
  43 }
  44
  45 WebURLProtectionSpace::~WebURLProtectionSpace()
  46 {
  47     gClassCount--;
  48     gClassNameCount.remove("WebURLProtectionSpace");
  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     static BString& webURLProtectionSpaceHTTPBString = *new BString(WebURLProtectionSpaceHTTP);
 154     static BString& webURLProtectionSpaceHTTPSBString = *new BString(WebURLProtectionSpaceHTTPS);
 155     static BString& webURLProtectionSpaceFTPBString = *new BString(WebURLProtectionSpaceFTP);
 156     static BString& webURLProtectionSpaceFTPSBString = *new BString(WebURLProtectionSpaceFTPS);
 157
 158     ProtectionSpaceServerType serverType = ProtectionSpaceServerHTTP;
 159     if (BString(protocol) == webURLProtectionSpaceHTTPBString)
 160         serverType = ProtectionSpaceServerHTTP;
 161     else if (BString(protocol) == webURLProtectionSpaceHTTPSBString)
 162         serverType = ProtectionSpaceServerHTTPS;
 163     else if (BString(protocol) == webURLProtectionSpaceFTPBString)
 164         serverType = ProtectionSpaceServerFTP;
 165     else if (BString(protocol) == webURLProtectionSpaceFTPSBString)
 166         serverType = ProtectionSpaceServerFTPS;
 167
 168     m_protectionSpace = ProtectionSpace(String(host, SysStringLen(host)), port, serverType,
 169         String(realm, SysStringLen(realm)), coreScheme(authenticationMethod));
 170
 171     return S_OK;
 172 }
 173
 174 HRESULT STDMETHODCALLTYPE WebURLProtectionSpace::initWithProxyHost(
 175     /* [in] */ BSTR host,
 176     /* [in] */ int port,
 177     /* [in] */ BSTR proxyType,
 178     /* [in] */ BSTR realm,
 179     /* [in] */ BSTR authenticationMethod)
 180 {
 181     static BString& webURLProtectionSpaceHTTPProxyBString = *new BString(WebURLProtectionSpaceHTTPProxy);
 182     static BString& webURLProtectionSpaceHTTPSProxyBString = *new BString(WebURLProtectionSpaceHTTPSProxy);
 183     static BString& webURLProtectionSpaceFTPProxyBString = *new BString(WebURLProtectionSpaceFTPProxy);
 184     static BString& webURLProtectionSpaceSOCKSProxyBString = *new BString(WebURLProtectionSpaceSOCKSProxy);
 185
 186     ProtectionSpaceServerType serverType = ProtectionSpaceProxyHTTP;
 187     if (BString(proxyType) == webURLProtectionSpaceHTTPProxyBString)
 188         serverType = ProtectionSpaceProxyHTTP;
 189     else if (BString(proxyType) == webURLProtectionSpaceHTTPSProxyBString)
 190         serverType = ProtectionSpaceProxyHTTPS;
 191     else if (BString(proxyType) == webURLProtectionSpaceFTPProxyBString)
 192         serverType = ProtectionSpaceProxyFTP;
 193     else if (BString(proxyType) == webURLProtectionSpaceSOCKSProxyBString)
 194         serverType = ProtectionSpaceProxySOCKS;
 195     else
 196         ASSERT_NOT_REACHED();
 197
 198     m_protectionSpace = ProtectionSpace(String(host, SysStringLen(host)), port, serverType,
 199         String(realm, SysStringLen(realm)), coreScheme(authenticationMethod));
 200
 201     return S_OK;
 202 }
 203
 204 HRESULT STDMETHODCALLTYPE WebURLProtectionSpace::isProxy(
 205     /* [out, retval] */ BOOL* result)
 206 {
 207     *result = m_protectionSpace.isProxy();
 208     return S_OK;
 209 }
 210
 211 HRESULT STDMETHODCALLTYPE WebURLProtectionSpace::port(
 212     /* [out, retval] */ int* result)
 213 {
 214     *result = m_protectionSpace.port();
 215     return S_OK;
 216 }
 217
 218 HRESULT STDMETHODCALLTYPE WebURLProtectionSpace::protocol(
 219     /* [out, retval] */ BSTR* result)
 220 {
 221     switch (m_protectionSpace.serverType()) {
 222     case ProtectionSpaceServerHTTP:
 223         *result = SysAllocString(WebURLProtectionSpaceHTTP);
 224         break;
 225     case ProtectionSpaceServerHTTPS:
 226         *result = SysAllocString(WebURLProtectionSpaceHTTPS);
 227         break;
 228     case ProtectionSpaceServerFTP:
 229         *result = SysAllocString(WebURLProtectionSpaceFTP);
 230         break;
 231     case ProtectionSpaceServerFTPS:
 232         *result = SysAllocString(WebURLProtectionSpaceFTPS);
 233         break;
 234     default:
 235         ASSERT_NOT_REACHED();
 236         return E_FAIL;
 237     }
 238     return S_OK;
 239 }
 240
 241 HRESULT STDMETHODCALLTYPE WebURLProtectionSpace::proxyType(
 242     /* [out, retval] */ BSTR* result)
 243 {
 244     switch (m_protectionSpace.serverType()) {
 245     case ProtectionSpaceProxyHTTP:
 246         *result = SysAllocString(WebURLProtectionSpaceHTTPProxy);
 247         break;
 248     case ProtectionSpaceProxyHTTPS:
 249         *result = SysAllocString(WebURLProtectionSpaceHTTPSProxy);
 250         break;
 251     case ProtectionSpaceProxyFTP:
 252         *result = SysAllocString(WebURLProtectionSpaceFTPProxy);
 253         break;
 254     case ProtectionSpaceProxySOCKS:
 255         *result = SysAllocString(WebURLProtectionSpaceSOCKSProxy);
 256         break;
 257     default:
 258         ASSERT_NOT_REACHED();
 259         return E_FAIL;
 260     }
 261     return S_OK;
 262 }
 263
 264 HRESULT STDMETHODCALLTYPE WebURLProtectionSpace::realm(
 265     /* [out, retval] */ BSTR* result)
 266 {
 267     BString bstring = m_protectionSpace.realm();
 268     *result = bstring.release();
 269     return S_OK;
 270 }
 271
 272 HRESULT STDMETHODCALLTYPE WebURLProtectionSpace::receivesCredentialSecurely(
 273     /* [out, retval] */ BOOL* result)
 274 {
 275     *result = m_protectionSpace.receivesCredentialSecurely();
 276     return S_OK;
 277 }
 278
 279 // WebURLProtectionSpace -------------------------------------------------------------------
 280 const ProtectionSpace& WebURLProtectionSpace::protectionSpace() const
 281 {
 282     return m_protectionSpace;
 283 }