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 "WebKitDLL.h"
     28 #include "WebURLAuthenticationChallenge.h"
     29 
     30 #include "COMPtr.h"
     31 #include "WebError.h"
     32 #include "WebKit.h"
     33 #include "WebURLAuthenticationChallengeSender.h"
     34 #include "WebURLCredential.h"
     35 #include "WebURLProtectionSpace.h"
     36 #include "WebURLResponse.h"
     37 #include "WebKit.h"
     38 
     39 #pragma warning(push, 0)
     40 #include <WebCore/BString.h>
     41 #include <WebCore/ResourceHandle.h>
     42 #pragma warning(pop)
     43 
     44 using namespace WebCore;
     45 
     46 // WebURLAuthenticationChallenge ----------------------------------------------------------------
     47 
     48 WebURLAuthenticationChallenge::WebURLAuthenticationChallenge(const AuthenticationChallenge& authenticationChallenge,
     49                                                              IWebURLAuthenticationChallengeSender* sender)
     50     : m_refCount(0)
     51     , m_authenticationChallenge(authenticationChallenge)
     52     , m_sender(sender)
     53 {
     54     gClassCount++;
     55     gClassNameCount.add("WebURLAuthenticationChallenge");
     56 }
     57 
     58 WebURLAuthenticationChallenge::~WebURLAuthenticationChallenge()
     59 {
     60     gClassCount--;
     61     gClassNameCount.remove("WebURLAuthenticationChallenge");
     62 }
     63 
     64 WebURLAuthenticationChallenge* WebURLAuthenticationChallenge::createInstance(const AuthenticationChallenge& authenticationChallenge)
     65 {
     66     WebURLAuthenticationChallenge* instance = new WebURLAuthenticationChallenge(authenticationChallenge, 0);
     67     instance->AddRef();
     68     return instance;
     69 }
     70 
     71 WebURLAuthenticationChallenge* WebURLAuthenticationChallenge::createInstance(const AuthenticationChallenge& authenticationChallenge,
     72                                                                              IWebURLAuthenticationChallengeSender* sender)
     73 {
     74     WebURLAuthenticationChallenge* instance = new WebURLAuthenticationChallenge(authenticationChallenge, sender);
     75     instance->AddRef();
     76     return instance;
     77 }
     78 
     79 // IUnknown -------------------------------------------------------------------
     80 
     81 HRESULT STDMETHODCALLTYPE WebURLAuthenticationChallenge::QueryInterface(REFIID riid, void** ppvObject)
     82 {
     83     *ppvObject = 0;
     84     if (IsEqualGUID(riid, IID_IUnknown))
     85         *ppvObject = static_cast<IUnknown*>(this);
     86     else if (IsEqualGUID(riid, __uuidof(this)))
     87         *ppvObject = static_cast<WebURLAuthenticationChallenge*>(this);
     88     else if (IsEqualGUID(riid, IID_IWebURLAuthenticationChallenge))
     89         *ppvObject = static_cast<IWebURLAuthenticationChallenge*>(this);
     90     else
     91         return E_NOINTERFACE;
     92 
     93     AddRef();
     94     return S_OK;
     95 }
     96 
     97 ULONG STDMETHODCALLTYPE WebURLAuthenticationChallenge::AddRef(void)
     98 {
     99     return ++m_refCount;
    100 }
    101 
    102 ULONG STDMETHODCALLTYPE WebURLAuthenticationChallenge::Release(void)
    103 {
    104     ULONG newRef = --m_refCount;
    105     if (!newRef)
    106         delete(this);
    107 
    108     return newRef;
    109 }
    110 
    111 // IWebURLAuthenticationChallenge -------------------------------------------------------------------
    112 
    113 HRESULT STDMETHODCALLTYPE WebURLAuthenticationChallenge::initWithProtectionSpace(
    114     /* [in] */ IWebURLProtectionSpace* space,
    115     /* [in] */ IWebURLCredential* proposedCredential,
    116     /* [in] */ int previousFailureCount,
    117     /* [in] */ IWebURLResponse* failureResponse,
    118     /* [in] */ IWebError* error,
    119     /* [in] */ IWebURLAuthenticationChallengeSender* sender)
    120 {
    121     LOG_ERROR("Calling the ala carte init for WebURLAuthenticationChallenge - is this really what you want to do?");
    122 
    123     if (!space || !proposedCredential || !failureResponse || !sender)
    124         return E_POINTER;
    125 
    126     HRESULT hr = S_OK;
    127     COMPtr<WebURLProtectionSpace> webSpace;
    128     hr = space->QueryInterface(&webSpace);
    129     if (FAILED(hr))
    130         return hr;
    131 
    132     COMPtr<WebURLCredential> webCredential(Query, proposedCredential);
    133     if (!webCredential)
    134         return E_NOINTERFACE;
    135 
    136     COMPtr<WebURLResponse> webResponse;
    137     hr = failureResponse->QueryInterface(&webResponse);
    138     if (FAILED(hr))
    139         return hr;
    140 
    141     COMPtr<WebError> webError;
    142     hr = error->QueryInterface(CLSID_WebError, (void**)&webError);
    143     if (FAILED(hr))
    144         return hr;
    145 
    146     COMPtr<WebURLAuthenticationChallengeSender> webSender(Query, sender);
    147     if (!webSender)
    148         return E_NOINTERFACE;
    149 
    150     // FIXME: After we change AuthenticationChallenge to use "ResourceHandle" as the abstract "Sender" or "Source of this Auth Challenge", then we'll
    151     // construct the AuthenticationChallenge with that as obtained from the webSender
    152 #if USE(CFNETWORK)
    153     m_authenticationChallenge = AuthenticationChallenge(webSpace->protectionSpace(), webCredential->credential(),
    154                                     previousFailureCount, webResponse->resourceResponse(), webError->resourceError());
    155 #endif
    156     return S_OK;
    157 }
    158 
    159 HRESULT STDMETHODCALLTYPE WebURLAuthenticationChallenge::initWithAuthenticationChallenge(
    160     /* [in] */ IWebURLAuthenticationChallenge* challenge,
    161     /* [in] */ IWebURLAuthenticationChallengeSender* sender)
    162 {
    163     if (!challenge || !sender)
    164         return E_POINTER;
    165 
    166     COMPtr<WebURLAuthenticationChallenge> webChallenge(Query, challenge);
    167     if (!webChallenge)
    168         return E_NOINTERFACE;
    169 
    170     COMPtr<WebURLAuthenticationChallengeSender> webSender(Query, sender);
    171     if (!webSender)
    172         return E_NOINTERFACE;
    173 
    174 #if USE(CFNETWORK)
    175     m_authenticationChallenge = AuthenticationChallenge(webChallenge->authenticationChallenge().cfURLAuthChallengeRef(), webSender->authenticationClient());
    176 
    177     return S_OK;
    178 #else
    179 
    180     return E_FAIL;
    181 #endif
    182 }
    183 
    184 HRESULT STDMETHODCALLTYPE WebURLAuthenticationChallenge::error(
    185     /* [out, retval] */ IWebError** result)
    186 {
    187     *result = WebError::createInstance(m_authenticationChallenge.error());
    188     return S_OK;
    189 }
    190 
    191 HRESULT STDMETHODCALLTYPE WebURLAuthenticationChallenge::failureResponse(
    192     /* [out, retval] */ IWebURLResponse** result)
    193 {
    194     *result = WebURLResponse::createInstance(m_authenticationChallenge.failureResponse());
    195     return S_OK;
    196 }
    197 
    198 HRESULT STDMETHODCALLTYPE WebURLAuthenticationChallenge::previousFailureCount(
    199     /* [out, retval] */ UINT* result)
    200 {
    201     *result = m_authenticationChallenge.previousFailureCount();
    202     return S_OK;
    203 }
    204 
    205 HRESULT STDMETHODCALLTYPE WebURLAuthenticationChallenge::proposedCredential(
    206     /* [out, retval] */ IWebURLCredential** result)
    207 {
    208     *result = WebURLCredential::createInstance(m_authenticationChallenge.proposedCredential());
    209     return S_OK;
    210 }
    211 
    212 HRESULT STDMETHODCALLTYPE WebURLAuthenticationChallenge::protectionSpace(
    213     /* [out, retval] */ IWebURLProtectionSpace** result)
    214 {
    215     *result = WebURLProtectionSpace::createInstance(m_authenticationChallenge.protectionSpace());
    216     return S_OK;
    217 }
    218 
    219 HRESULT STDMETHODCALLTYPE WebURLAuthenticationChallenge::sender(
    220     /* [out, retval] */ IWebURLAuthenticationChallengeSender** sender)
    221 {
    222     if (!m_sender) {
    223         AuthenticationClient* client = m_authenticationChallenge.authenticationClient();
    224         m_sender.adoptRef(WebURLAuthenticationChallengeSender::createInstance(client));
    225     }
    226 
    227     return m_sender.copyRefTo(sender);
    228 }
    229 
    230 // WebURLAuthenticationChallenge -------------------------------------------------------------------
    231 const AuthenticationChallenge& WebURLAuthenticationChallenge::authenticationChallenge() const
    232 {
    233     return m_authenticationChallenge;
    234 }
    235