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