/*
* Copyright (C) 2006, 2007 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
#include "WebKitDLL.h"
#include <initguid.h>
#include "WebURLResponse.h"
#include "HTTPHeaderPropertyBag.h"
#include "MarshallingHelpers.h"
#include "WebLocalizableStrings.h"
#include <WebKitSystemInterface/WebKitSystemInterface.h>
#include <wtf/platform.h>
#pragma warning( push, 0 )
#include <WebCore/BString.h>
#include <WebCore/DeprecatedString.h>
#include <WebCore/KURL.h>
#include <WebCore/ResourceHandle.h>
#pragma warning( pop )
#include <shlobj.h>
#include <shlwapi.h>
#include <tchar.h>
using namespace WebCore;
static LPCTSTR CFHTTPMessageCopyLocalizedShortDescriptionForStatusCode(CFIndex statusCode)
{
LPCTSTR result = 0;
if (statusCode < 100 || statusCode >= 600)
result = LPCTSTR_UI_STRING("server error", "HTTP result code string");
else if (statusCode >= 100 && statusCode <= 199) {
switch (statusCode) {
case 100:
result = LPCTSTR_UI_STRING("continue", "HTTP result code string");
break;
case 101:
result = LPCTSTR_UI_STRING("switching protocols", "HTTP result code string");
break;
default:
result = LPCTSTR_UI_STRING("informational", "HTTP result code string");
break;
}
} else if (statusCode >= 200 && statusCode <= 299) {
switch (statusCode) {
case 200:
result = LPCTSTR_UI_STRING("no error", "HTTP result code string");
break;
case 201:
result = LPCTSTR_UI_STRING("created", "HTTP result code string");
break;
case 202:
result = LPCTSTR_UI_STRING("accepted", "HTTP result code string");
break;
case 203:
result = LPCTSTR_UI_STRING("non-authoritative information", "HTTP result code string");
break;
case 204:
result = LPCTSTR_UI_STRING("no content", "HTTP result code string");
break;
case 205:
result = LPCTSTR_UI_STRING("reset content", "HTTP result code string");
break;
case 206:
result = LPCTSTR_UI_STRING("partial content", "HTTP result code string");
break;
default:
result = LPCTSTR_UI_STRING("success", "HTTP result code string");
break;
}
} else if (statusCode >= 300 && statusCode <= 399) {
switch (statusCode) {
case 300:
result = LPCTSTR_UI_STRING("multiple choices", "HTTP result code string");
break;
case 301:
result = LPCTSTR_UI_STRING("moved permanently", "HTTP result code string");
break;
case 302:
result = LPCTSTR_UI_STRING("found", "HTTP result code string");
break;
case 303:
result = LPCTSTR_UI_STRING("see other", "HTTP result code string");
break;
case 304:
result = LPCTSTR_UI_STRING("not modified", "HTTP result code string");
break;
case 305:
result = LPCTSTR_UI_STRING("needs proxy", "HTTP result code string");
break;
case 307:
result = LPCTSTR_UI_STRING("temporarily redirected", "HTTP result code string");
break;
case 306: // 306 status code unused in HTTP
default:
result = LPCTSTR_UI_STRING("redirected", "HTTP result code string");
break;
}
} else if (statusCode >= 400 && statusCode <= 499) {
switch (statusCode) {
case 400:
result = LPCTSTR_UI_STRING("bad request", "HTTP result code string");
break;
case 401:
result = LPCTSTR_UI_STRING("unauthorized", "HTTP result code string");
break;
case 402:
result = LPCTSTR_UI_STRING("payment required", "HTTP result code string");
break;
case 403:
result = LPCTSTR_UI_STRING("forbidden", "HTTP result code string");
break;
case 404:
result = LPCTSTR_UI_STRING("not found", "HTTP result code string");
break;
case 405:
result = LPCTSTR_UI_STRING("method not allowed", "HTTP result code string");
break;
case 406:
result = LPCTSTR_UI_STRING("unacceptable", "HTTP result code string");
break;
case 407:
result = LPCTSTR_UI_STRING("proxy authentication required", "HTTP result code string");
break;
case 408:
result = LPCTSTR_UI_STRING("request timed out", "HTTP result code string");
break;
case 409:
result = LPCTSTR_UI_STRING("conflict", "HTTP result code string");
break;
case 410:
result = LPCTSTR_UI_STRING("no longer exists", "HTTP result code string");
break;
case 411:
result = LPCTSTR_UI_STRING("length required", "HTTP result code string");
break;
case 412:
result = LPCTSTR_UI_STRING("precondition failed", "HTTP result code string");
break;
case 413:
result = LPCTSTR_UI_STRING("request too large", "HTTP result code string");
break;
case 414:
result = LPCTSTR_UI_STRING("requested URL too long", "HTTP result code string");
break;
case 415:
result = LPCTSTR_UI_STRING("unsupported media type", "HTTP result code string");
break;
case 416:
result = LPCTSTR_UI_STRING("requested range not satisfiable", "HTTP result code string");
break;
case 417:
result = LPCTSTR_UI_STRING("expectation failed", "HTTP result code string");
break;
default:
result = LPCTSTR_UI_STRING("client error", "HTTP result code string");
break;
}
} else if (statusCode >= 500 && statusCode <= 599) {
switch (statusCode) {
case 500:
result = LPCTSTR_UI_STRING("internal server error", "HTTP result code string");
break;
case 501:
result = LPCTSTR_UI_STRING("unimplemented", "HTTP result code string");
break;
case 502:
result = LPCTSTR_UI_STRING("bad gateway", "HTTP result code string");
break;
case 503:
result = LPCTSTR_UI_STRING("service unavailable", "HTTP result code string");
break;
case 504:
result = LPCTSTR_UI_STRING("gateway timed out", "HTTP result code string");
break;
case 505:
result = LPCTSTR_UI_STRING("unsupported version", "HTTP result code string");
break;
default:
result = LPCTSTR_UI_STRING("server error", "HTTP result code string");
break;
}
}
return result;
}
// IWebURLResponse ----------------------------------------------------------------
WebURLResponse::WebURLResponse()
:m_refCount(0)
{
gClassCount++;
}
WebURLResponse::~WebURLResponse()
{
gClassCount--;
}
WebURLResponse* WebURLResponse::createInstance()
{
WebURLResponse* instance = new WebURLResponse();
// fake an http response - so it has the IWebHTTPURLResponse interface
instance->m_response = ResourceResponse(String("http://").deprecatedString(), String(), 0, String(), String());
instance->AddRef();
return instance;
}
WebURLResponse* WebURLResponse::createInstance(const ResourceResponse& response)
{
if (response.isNull())
return 0;
WebURLResponse* instance = new WebURLResponse();
instance->AddRef();
instance->m_response = response;
return instance;
}
// IUnknown -------------------------------------------------------------------
HRESULT STDMETHODCALLTYPE WebURLResponse::QueryInterface(REFIID riid, void** ppvObject)
{
*ppvObject = 0;
if (IsEqualGUID(riid, IID_IUnknown))
*ppvObject = static_cast<IWebURLResponse*>(this);
else if (IsEqualGUID(riid, IID_WebURLResponse))
*ppvObject = static_cast<WebURLResponse*>(this);
else if (IsEqualGUID(riid, IID_IWebURLResponse))
*ppvObject = static_cast<IWebURLResponse*>(this);
else if (IsEqualGUID(riid, IID_IWebURLResponsePrivate))
*ppvObject = static_cast<IWebURLResponsePrivate*>(this);
else if (m_response.isHTTP() && IsEqualGUID(riid, IID_IWebHTTPURLResponse))
*ppvObject = static_cast<IWebHTTPURLResponse*>(this);
else
return E_NOINTERFACE;
AddRef();
return S_OK;
}
ULONG STDMETHODCALLTYPE WebURLResponse::AddRef(void)
{
return ++m_refCount;
}
ULONG STDMETHODCALLTYPE WebURLResponse::Release(void)
{
ULONG newRef = --m_refCount;
if (!newRef)
delete(this);
return newRef;
}
// IWebURLResponse --------------------------------------------------------------------
HRESULT STDMETHODCALLTYPE WebURLResponse::expectedContentLength(
/* [retval][out] */ long long* result)
{
*result = m_response.expectedContentLength();
return S_OK;
}
HRESULT STDMETHODCALLTYPE WebURLResponse::initWithURL(
/* [in] */ BSTR url,
/* [in] */ BSTR mimeType,
/* [in] */ int expectedContentLength,
/* [in] */ BSTR textEncodingName)
{
m_response = ResourceResponse(String(url).deprecatedString(), String(mimeType), expectedContentLength, String(textEncodingName), String());
return S_OK;
}
HRESULT STDMETHODCALLTYPE WebURLResponse::MIMEType(
/* [retval][out] */ BSTR* result)
{
BString mimeType(m_response.mimeType());
*result = mimeType.release();
if (!m_response.mimeType().isNull() && !*result)
return E_OUTOFMEMORY;
return S_OK;
}
HRESULT STDMETHODCALLTYPE WebURLResponse::suggestedFilename(
/* [retval][out] */ BSTR* result)
{
if (!result) {
ASSERT_NOT_REACHED();
return E_POINTER;
}
*result = 0;
if (m_response.url().isEmpty())
return E_FAIL;
*result = BString(m_response.suggestedFilename()).release();
return S_OK;
}
HRESULT STDMETHODCALLTYPE WebURLResponse::textEncodingName(
/* [retval][out] */ BSTR* result)
{
if (!result)
return E_INVALIDARG;
BString textEncodingName(m_response.textEncodingName());
*result = textEncodingName.release();
if (!m_response.textEncodingName().isNull() && !*result)
return E_OUTOFMEMORY;
return S_OK;
}
HRESULT STDMETHODCALLTYPE WebURLResponse::URL(
/* [retval][out] */ BSTR* result)
{
if (!result)
return E_INVALIDARG;
BString url(m_response.url().url());
*result = url.release();
if (!m_response.url().isEmpty() && !*result)
return E_OUTOFMEMORY;
return S_OK;
}
// IWebHTTPURLResponse --------------------------------------------------------
HRESULT STDMETHODCALLTYPE WebURLResponse::allHeaderFields(
/* [retval][out] */ IPropertyBag** headerFields)
{
ASSERT(m_response.isHTTP());
*headerFields = HTTPHeaderPropertyBag::createInstance(this);
return S_OK;
}
HRESULT STDMETHODCALLTYPE WebURLResponse::localizedStringForStatusCode(
/* [in] */ int statusCode,
/* [retval][out] */ BSTR* statusString)
{
ASSERT(m_response.isHTTP());
if (statusString)
*statusString = 0;
LPCTSTR statusText = CFHTTPMessageCopyLocalizedShortDescriptionForStatusCode(statusCode);
if (!statusText)
return E_FAIL;
if (statusString)
*statusString = SysAllocString(statusText);
return S_OK;
}
HRESULT STDMETHODCALLTYPE WebURLResponse::statusCode(
/* [retval][out] */ int* statusCode)
{
ASSERT(m_response.isHTTP());
if (statusCode)
*statusCode = m_response.httpStatusCode();
return S_OK;
}
HRESULT STDMETHODCALLTYPE WebURLResponse::isAttachment(
/* [retval][out] */ BOOL *attachment)
{
*attachment = m_response.isAttachment();
return S_OK;
}
HRESULT STDMETHODCALLTYPE WebURLResponse::sslPeerCertificate(
/* [retval][out] */ OLE_HANDLE* result)
{
if (!result)
return E_POINTER;
*result = 0;
CFDictionaryRef dict = certificateDictionary();
if (!dict)
return E_FAIL;
void* data = wkGetSSLPeerCertificateData(dict);
if (!data)
return E_FAIL;
*result = (OLE_HANDLE)(ULONG64)data;
return *result ? S_OK : E_FAIL;
}
// WebURLResponse -------------------------------------------------------------
HRESULT WebURLResponse::suggestedFileExtension(BSTR *result)
{
if (!result)
return E_POINTER;
*result = 0;
if (m_response.mimeType().isEmpty())
return E_FAIL;
BString mimeType(m_response.mimeType());
HKEY key;
LONG err = RegOpenKeyEx(HKEY_CLASSES_ROOT, TEXT("MIME\\Database\\Content Type"), 0, KEY_QUERY_VALUE, &key);
if (!err) {
HKEY subKey;
err = RegOpenKeyEx(key, mimeType, 0, KEY_QUERY_VALUE, &subKey);
if (!err) {
DWORD keyType = REG_SZ;
TCHAR extension[MAX_PATH];
DWORD keySize = sizeof(extension)/sizeof(extension[0]);
err = RegQueryValueEx(subKey, TEXT("Extension"), 0, &keyType, (LPBYTE)extension, &keySize);
if (!err && keyType != REG_SZ)
err = ERROR_INVALID_DATA;
if (err) {
// fallback handlers
if (!_tcscmp(mimeType, TEXT("text/html"))) {
_tcscpy(extension, TEXT(".html"));
err = 0;
} else if (!_tcscmp(mimeType, TEXT("application/xhtml+xml"))) {
_tcscpy(extension, TEXT(".xhtml"));
err = 0;
} else if (!_tcscmp(mimeType, TEXT("image/svg+xml"))) {
_tcscpy(extension, TEXT(".svg"));
err = 0;
}
}
if (!err) {
*result = SysAllocString(extension);
if (!*result)
err = ERROR_OUTOFMEMORY;
}
RegCloseKey(subKey);
}
RegCloseKey(key);
}
return HRESULT_FROM_WIN32(err);
}
const ResourceResponse& WebURLResponse::resourceResponse() const
{
return m_response;
}
CFDictionaryRef WebURLResponse::certificateDictionary() const
{
if (m_SSLCertificateInfo)
return m_SSLCertificateInfo.get();
CFURLResponseRef cfResponse = m_response.cfURLResponse();
if (!cfResponse)
return 0;
m_SSLCertificateInfo = wkGetSSLCertificateInfo(cfResponse);
return m_SSLCertificateInfo.get();
}
|