blob: d96c7bb8696b600d7d15fb543c25d88b113ce530 [file] [log] [blame]
/*
* Copyright (C) 2016 Canon Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted, provided that the following conditions
* are required to be 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.
* 3. Neither the name of Canon Inc. nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY CANON INC. AND ITS CONTRIBUTORS "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 CANON INC. AND ITS 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 "FetchResponse.h"
#include "FetchRequest.h"
#include "HTTPParsers.h"
#include "JSBlob.h"
#include "MIMETypeRegistry.h"
#include "ReadableStreamSink.h"
#include "ResourceError.h"
#include "ScriptExecutionContext.h"
namespace WebCore {
// https://fetch.spec.whatwg.org/#null-body-status
static inline bool isNullBodyStatus(int status)
{
return status == 101 || status == 204 || status == 205 || status == 304;
}
Ref<FetchResponse> FetchResponse::create(ScriptExecutionContext& context, std::optional<FetchBody>&& body, FetchHeaders::Guard guard, ResourceResponse&& response)
{
bool isSynthetic = response.type() == ResourceResponse::Type::Default || response.type() == ResourceResponse::Type::Error;
bool isOpaque = response.tainting() == ResourceResponse::Tainting::Opaque;
auto headers = isOpaque ? FetchHeaders::create(guard) : FetchHeaders::create(guard, HTTPHeaderMap { response.httpHeaderFields() });
auto fetchResponse = adoptRef(*new FetchResponse(context, WTFMove(body), WTFMove(headers), WTFMove(response)));
if (!isSynthetic)
fetchResponse->m_filteredResponse = ResourceResponseBase::filter(fetchResponse->m_internalResponse);
if (isOpaque)
fetchResponse->setBodyAsOpaque();
return fetchResponse;
}
ExceptionOr<Ref<FetchResponse>> FetchResponse::create(ScriptExecutionContext& context, std::optional<FetchBody::Init>&& body, Init&& init)
{
// 1. If init’s status member is not in the range 200 to 599, inclusive, then throw a RangeError.
if (init.status < 200 || init.status > 599)
return Exception { RangeError, ASCIILiteral("Status must be between 200 and 599") };
// 2. If init’s statusText member does not match the reason-phrase token production, then throw a TypeError.
if (!isValidReasonPhrase(init.statusText))
return Exception { TypeError, ASCIILiteral("Status text must be a valid reason-phrase.") };
// 3. Let r be a new Response object associated with a new response.
// NOTE: Creation of the Response object is delayed until all potential exceptional cases are handled.
// 4. Set r’s headers to a new Headers object, whose header list is r’s response’s header list, and guard is "response".
auto headers = FetchHeaders::create(FetchHeaders::Guard::Response);
// 5. Set r’s response’s status to init’s status member.
auto status = init.status;
// 6. Set r’s response’s status message to init’s statusText member.
auto statusText = init.statusText;
// 7. If init’s headers member is present, then fill r’s headers with init’s headers member.
if (init.headers) {
auto result = headers->fill(*init.headers);
if (result.hasException())
return result.releaseException();
}
std::optional<FetchBody> extractedBody;
// 8. If body is non-null, run these substeps:
if (body) {
// 8.1 If init’s status member is a null body status, then throw a TypeError.
// (NOTE: 101 is included in null body status due to its use elsewhere. It does not affect this step.)
if (isNullBodyStatus(init.status))
return Exception { TypeError, ASCIILiteral("Response cannot have a body with the given status.") };
// 8.2 Let Content-Type be null.
String contentType;
// 8.3 Set r’s response’s body and Content-Type to the result of extracting body.
extractedBody = FetchBody::extract(context, WTFMove(*body), contentType);
// 8.4 If Content-Type is non-null and r’s response’s header list does not contain `Content-Type`, then append
// `Content-Type`/Content-Type to r’s response’s header list.
if (!contentType.isNull() && !headers->fastHas(HTTPHeaderName::ContentType))
headers->fastSet(HTTPHeaderName::ContentType, contentType);
}
// 9. Set r’s MIME type to the result of extracting a MIME type from r’s response’s header list.
auto contentType = headers->fastGet(HTTPHeaderName::ContentType);
// 10. Set r’s response’s HTTPS state to current settings object’s HTTPS state.
// FIXME: Implement.
// 11. Resolve r’s trailer promise with a new Headers object whose guard is "immutable".
// FIXME: Implement.
// 12. Return r.
auto r = adoptRef(*new FetchResponse(context, WTFMove(extractedBody), WTFMove(headers), { }));
r->m_contentType = contentType;
auto mimeType = extractMIMETypeFromMediaType(contentType);
r->m_internalResponse.setMimeType(mimeType.isEmpty() ? defaultMIMEType() : mimeType);
r->m_internalResponse.setTextEncodingName(extractCharsetFromMediaType(contentType));
r->m_internalResponse.setHTTPStatusCode(status);
r->m_internalResponse.setHTTPStatusText(statusText);
return WTFMove(r);
}
Ref<FetchResponse> FetchResponse::error(ScriptExecutionContext& context)
{
auto response = adoptRef(*new FetchResponse(context, { }, FetchHeaders::create(FetchHeaders::Guard::Immutable), { }));
response->m_internalResponse.setType(Type::Error);
return response;
}
ExceptionOr<Ref<FetchResponse>> FetchResponse::redirect(ScriptExecutionContext& context, const String& url, int status)
{
// FIXME: Tighten the URL parsing algorithm according https://url.spec.whatwg.org/#concept-url-parser.
URL requestURL = context.completeURL(url);
if (!requestURL.isValid() || !requestURL.user().isEmpty() || !requestURL.pass().isEmpty())
return Exception { TypeError };
if (!ResourceResponse::isRedirectionStatusCode(status))
return Exception { RangeError };
auto redirectResponse = adoptRef(*new FetchResponse(context, { }, FetchHeaders::create(FetchHeaders::Guard::Immutable), { }));
redirectResponse->m_internalResponse.setHTTPStatusCode(status);
redirectResponse->m_internalResponse.setHTTPHeaderField(HTTPHeaderName::Location, requestURL.string());
redirectResponse->m_headers->fastSet(HTTPHeaderName::Location, requestURL.string());
return WTFMove(redirectResponse);
}
FetchResponse::FetchResponse(ScriptExecutionContext& context, std::optional<FetchBody>&& body, Ref<FetchHeaders>&& headers, ResourceResponse&& response)
: FetchBodyOwner(context, WTFMove(body), WTFMove(headers))
, m_internalResponse(WTFMove(response))
{
}
ExceptionOr<Ref<FetchResponse>> FetchResponse::clone(ScriptExecutionContext& context)
{
if (isDisturbedOrLocked())
return Exception { TypeError };
ASSERT(scriptExecutionContext());
// If loading, let's create a stream so that data is teed on both clones.
if (isLoading() && !m_readableStreamSource)
createReadableStream(*context.execState());
// Synthetic responses do not store headers in m_internalResponse.
if (m_internalResponse.type() == ResourceResponse::Type::Default)
m_internalResponse.setHTTPHeaderFields(HTTPHeaderMap { headers().internalHeaders() });
auto clone = FetchResponse::create(context, std::nullopt, headers().guard(), ResourceResponse { m_internalResponse });
clone->m_loadingError = m_loadingError;
clone->cloneBody(*this);
clone->m_opaqueLoadIdentifier = m_opaqueLoadIdentifier;
clone->m_bodySizeWithPadding = m_bodySizeWithPadding;
return WTFMove(clone);
}
void FetchResponse::fetch(ScriptExecutionContext& context, FetchRequest& request, NotificationCallback&& responseCallback)
{
if (request.hasReadableStreamBody()) {
if (responseCallback)
responseCallback(Exception { NotSupportedError, "ReadableStream uploading is not supported" });
return;
}
auto response = adoptRef(*new FetchResponse(context, FetchBody { }, FetchHeaders::create(FetchHeaders::Guard::Immutable), { }));
response->body().consumer().setAsLoading();
response->m_bodyLoader.emplace(response.get(), WTFMove(responseCallback));
if (!response->m_bodyLoader->start(context, request))
response->m_bodyLoader = std::nullopt;
}
const String& FetchResponse::url() const
{
if (m_responseURL.isNull()) {
URL url = m_internalResponse.url();
url.removeFragmentIdentifier();
m_responseURL = url.string();
}
return m_responseURL;
}
const ResourceResponse& FetchResponse::filteredResponse() const
{
if (m_filteredResponse)
return m_filteredResponse.value();
return m_internalResponse;
}
void FetchResponse::BodyLoader::didSucceed()
{
ASSERT(m_response.hasPendingActivity());
m_response.m_body->loadingSucceeded();
#if ENABLE(STREAMS_API)
if (m_response.m_readableStreamSource && !m_response.body().consumer().hasData())
m_response.closeStream();
#endif
if (auto consumeDataCallback = WTFMove(m_consumeDataCallback))
consumeDataCallback(nullptr);
if (m_loader->isStarted()) {
Ref<FetchResponse> protector(m_response);
m_response.m_bodyLoader = std::nullopt;
}
}
void FetchResponse::BodyLoader::didFail(const ResourceError& error)
{
ASSERT(m_response.hasPendingActivity());
m_response.m_loadingError = error;
if (auto responseCallback = WTFMove(m_responseCallback))
responseCallback(Exception { TypeError, error.localizedDescription() });
if (auto consumeDataCallback = WTFMove(m_consumeDataCallback))
consumeDataCallback(Exception { TypeError, error.localizedDescription() });
#if ENABLE(STREAMS_API)
if (m_response.m_readableStreamSource) {
if (!m_response.m_readableStreamSource->isCancelling())
m_response.m_readableStreamSource->error(ASCIILiteral("Loading failed"));
m_response.m_readableStreamSource = nullptr;
}
#endif
// Check whether didFail is called as part of FetchLoader::start.
if (m_loader->isStarted()) {
Ref<FetchResponse> protector(m_response);
m_response.m_bodyLoader = std::nullopt;
}
}
FetchResponse::BodyLoader::BodyLoader(FetchResponse& response, NotificationCallback&& responseCallback)
: m_response(response)
, m_responseCallback(WTFMove(responseCallback))
{
m_response.setPendingActivity(&m_response);
}
FetchResponse::BodyLoader::~BodyLoader()
{
m_response.unsetPendingActivity(&m_response);
}
static uint64_t nextOpaqueLoadIdentifier { 0 };
void FetchResponse::BodyLoader::didReceiveResponse(const ResourceResponse& resourceResponse)
{
m_response.m_filteredResponse = ResourceResponseBase::filter(resourceResponse);
m_response.m_internalResponse = resourceResponse;
m_response.m_internalResponse.setType(m_response.m_filteredResponse->type());
if (resourceResponse.tainting() == ResourceResponse::Tainting::Opaque) {
m_response.m_opaqueLoadIdentifier = ++nextOpaqueLoadIdentifier;
m_response.setBodyAsOpaque();
}
m_response.m_headers->filterAndFill(m_response.m_filteredResponse->httpHeaderFields(), FetchHeaders::Guard::Response);
m_response.updateContentType();
if (auto responseCallback = WTFMove(m_responseCallback))
responseCallback(m_response);
}
void FetchResponse::BodyLoader::didReceiveData(const char* data, size_t size)
{
#if ENABLE(STREAMS_API)
ASSERT(m_response.m_readableStreamSource || m_consumeDataCallback);
#else
ASSERT(m_consumeDataCallback);
#endif
if (m_consumeDataCallback) {
ReadableStreamChunk chunk { reinterpret_cast<const uint8_t*>(data), size };
m_consumeDataCallback(&chunk);
return;
}
#if ENABLE(STREAMS_API)
auto& source = *m_response.m_readableStreamSource;
if (!source.isPulling()) {
m_response.body().consumer().append(data, size);
return;
}
if (m_response.body().consumer().hasData() && !source.enqueue(m_response.body().consumer().takeAsArrayBuffer())) {
stop();
return;
}
if (!source.enqueue(ArrayBuffer::tryCreate(data, size))) {
stop();
return;
}
source.resolvePullPromise();
#else
UNUSED_PARAM(data);
UNUSED_PARAM(size);
#endif
}
bool FetchResponse::BodyLoader::start(ScriptExecutionContext& context, const FetchRequest& request)
{
m_loader = std::make_unique<FetchLoader>(*this, &m_response.m_body->consumer());
m_loader->start(context, request);
return m_loader->isStarted();
}
void FetchResponse::BodyLoader::stop()
{
m_responseCallback = { };
if (m_loader)
m_loader->stop();
}
void FetchResponse::BodyLoader::consumeDataByChunk(ConsumeDataByChunkCallback&& consumeDataCallback)
{
ASSERT(!m_consumeDataCallback);
m_consumeDataCallback = WTFMove(consumeDataCallback);
auto data = m_loader->startStreaming();
if (!data)
return;
ReadableStreamChunk chunk { reinterpret_cast<const uint8_t*>(data->data()), data->size() };
m_consumeDataCallback(&chunk);
}
FetchResponse::ResponseData FetchResponse::consumeBody()
{
ASSERT(!isBodyReceivedByChunk());
if (isBodyNull())
return nullptr;
ASSERT(!m_isDisturbed);
m_isDisturbed = true;
return body().take();
}
void FetchResponse::consumeBodyReceivedByChunk(ConsumeDataByChunkCallback&& callback)
{
ASSERT(isBodyReceivedByChunk());
ASSERT(!isDisturbed());
m_isDisturbed = true;
if (hasReadableStreamBody()) {
m_body->consumer().extract(*m_body->readableStream(), WTFMove(callback));
return;
}
ASSERT(isLoading());
m_bodyLoader->consumeDataByChunk(WTFMove(callback));
}
void FetchResponse::setBodyData(ResponseData&& data, uint64_t bodySizeWithPadding)
{
m_bodySizeWithPadding = bodySizeWithPadding;
WTF::switchOn(data,
[this](Ref<FormData>& formData) {
if (isBodyNull())
setBody({ });
body().setAsFormData(WTFMove(formData));
},
[this](Ref<SharedBuffer>& buffer) {
if (isBodyNull())
setBody({ });
body().consumer().setData(WTFMove(buffer));
},
[](std::nullptr_t&) {
}
);
}
#if ENABLE(STREAMS_API)
void FetchResponse::consumeChunk(Ref<JSC::Uint8Array>&& chunk)
{
body().consumer().append(chunk->data(), chunk->byteLength());
}
void FetchResponse::consumeBodyAsStream()
{
ASSERT(m_readableStreamSource);
if (!isLoading()) {
FetchBodyOwner::consumeBodyAsStream();
return;
}
ASSERT(m_bodyLoader);
auto data = m_bodyLoader->startStreaming();
if (data) {
if (!m_readableStreamSource->enqueue(data->tryCreateArrayBuffer())) {
stop();
return;
}
m_readableStreamSource->resolvePullPromise();
}
}
void FetchResponse::closeStream()
{
ASSERT(m_readableStreamSource);
m_readableStreamSource->close();
m_readableStreamSource = nullptr;
}
void FetchResponse::feedStream()
{
ASSERT(m_readableStreamSource);
bool shouldCloseStream = !m_bodyLoader;
if (body().consumer().hasData()) {
if (!m_readableStreamSource->enqueue(body().consumer().takeAsArrayBuffer())) {
stop();
return;
}
if (!shouldCloseStream) {
m_readableStreamSource->resolvePullPromise();
return;
}
} else if (!shouldCloseStream)
return;
closeStream();
}
RefPtr<SharedBuffer> FetchResponse::BodyLoader::startStreaming()
{
ASSERT(m_loader);
return m_loader->startStreaming();
}
void FetchResponse::cancel()
{
m_isDisturbed = true;
stop();
}
#endif
void FetchResponse::stop()
{
RefPtr<FetchResponse> protectedThis(this);
FetchBodyOwner::stop();
if (m_bodyLoader) {
m_bodyLoader->stop();
m_bodyLoader = std::nullopt;
}
}
const char* FetchResponse::activeDOMObjectName() const
{
return "Response";
}
bool FetchResponse::canSuspendForDocumentSuspension() const
{
// FIXME: We can probably do the same strategy as XHR.
return !isActive();
}
ResourceResponse FetchResponse::resourceResponse() const
{
auto response = m_internalResponse;
if (headers().guard() != FetchHeaders::Guard::Immutable) {
// FIXME: Add a setHTTPHeaderFields on ResourceResponseBase.
for (auto& header : headers().internalHeaders())
response.setHTTPHeaderField(header.key, header.value);
}
return response;
}
} // namespace WebCore