blob: db6f508c4b77020018eba322e01b142894820d82 [file] [log] [blame]
/*
* Copyright (C) 2021 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 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 APPLE INC. OR 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 "ContentExtensionActions.h"
#if ENABLE(CONTENT_EXTENSIONS)
#include "ContentExtensionError.h"
#include "ResourceRequest.h"
#include <wtf/CrossThreadCopier.h>
#include <wtf/URL.h>
#include <wtf/URLParser.h>
#include <wtf/text/StringToIntegerConversion.h>
namespace WebCore::ContentExtensions {
static void append(Vector<uint8_t>& vector, size_t length)
{
RELEASE_ASSERT(length <= std::numeric_limits<uint32_t>::max());
uint32_t integer = length;
vector.append(Span<const uint8_t> { reinterpret_cast<const uint8_t*>(&integer), sizeof(integer) });
}
static void uncheckedAppend(Vector<uint8_t>& vector, size_t length)
{
RELEASE_ASSERT(length <= std::numeric_limits<uint32_t>::max());
uint32_t integer = length;
vector.uncheckedAppend(Span<const uint8_t> { reinterpret_cast<const uint8_t*>(&integer), sizeof(integer) });
}
static void append(Vector<uint8_t>& vector, const CString& string)
{
vector.append(Span<const uint8_t> { reinterpret_cast<const uint8_t*>(string.data()), string.length() });
}
static void uncheckedAppend(Vector<uint8_t>& vector, const CString& string)
{
vector.uncheckedAppend(Span<const uint8_t> { reinterpret_cast<const uint8_t*>(string.data()), string.length() });
}
static size_t deserializeLength(Span<const uint8_t> span, size_t offset)
{
RELEASE_ASSERT(span.size() >= offset + sizeof(uint32_t));
return *reinterpret_cast<const uint32_t*>(span.data() + offset);
}
static String deserializeUTF8String(Span<const uint8_t> span, size_t offset, size_t length)
{
RELEASE_ASSERT(span.size() >= offset + length);
return String::fromUTF8(span.data() + offset, length);
}
static void writeLengthToVectorAtOffset(Vector<uint8_t>& vector, size_t offset)
{
auto length = vector.size() - offset;
RELEASE_ASSERT(length <= std::numeric_limits<uint32_t>::max());
uint32_t integer = length;
RELEASE_ASSERT(vector.size() >= offset + sizeof(uint32_t));
RELEASE_ASSERT(!*reinterpret_cast<uint32_t*>(vector.data() + offset));
*reinterpret_cast<uint32_t*>(vector.data() + offset) = integer;
}
Expected<ModifyHeadersAction, std::error_code> ModifyHeadersAction::parse(const JSON::Object& modifyHeaders)
{
auto parseHeaders = [] (const JSON::Object& modifyHeaders, ASCIILiteral arrayName) -> Expected<Vector<ModifyHeaderInfo>, std::error_code> {
auto value = modifyHeaders.getValue(arrayName);
if (!value)
return { };
auto array = value->asArray();
if (!array)
return makeUnexpected(ContentExtensionError::JSONModifyHeadersNotArray);
Vector<ModifyHeaderInfo> vector;
vector.reserveInitialCapacity(array->length());
for (auto& value : *array) {
auto info = ModifyHeaderInfo::parse(value.get());
if (!info)
return makeUnexpected(info.error());
vector.uncheckedAppend(WTFMove(*info));
}
return vector;
};
auto requestHeaders = parseHeaders(modifyHeaders, "request-headers"_s);
if (!requestHeaders)
return makeUnexpected(requestHeaders.error());
auto responseHeaders = parseHeaders(modifyHeaders, "response-headers"_s);
if (!responseHeaders)
return makeUnexpected(responseHeaders.error());
return ModifyHeadersAction { WTFMove(*requestHeaders), WTFMove(*responseHeaders) };
}
ModifyHeadersAction ModifyHeadersAction::isolatedCopy() const
{
return {
crossThreadCopy(requestHeaders),
crossThreadCopy(responseHeaders)
};
}
bool ModifyHeadersAction::operator==(const ModifyHeadersAction& other) const
{
return other.hashTableType == this->hashTableType
&& other.requestHeaders == this->requestHeaders
&& other.responseHeaders == this->responseHeaders;
}
void ModifyHeadersAction::serialize(Vector<uint8_t>& vector) const
{
auto beginIndex = vector.size();
append(vector, 0);
auto requestHeadersLengthIndex = vector.size();
append(vector, 0);
for (auto& headerInfo : requestHeaders)
headerInfo.serialize(vector);
writeLengthToVectorAtOffset(vector, requestHeadersLengthIndex);
for (auto& headerInfo : responseHeaders)
headerInfo.serialize(vector);
writeLengthToVectorAtOffset(vector, beginIndex);
}
ModifyHeadersAction ModifyHeadersAction::deserialize(Span<const uint8_t> span)
{
auto serializedLength = deserializeLength(span, 0);
auto requestHeadersLength = deserializeLength(span, sizeof(uint32_t));
size_t progress = sizeof(uint32_t) * 2;
Vector<ModifyHeaderInfo> requestHeaders;
while (progress < requestHeadersLength + sizeof(uint32_t)) {
auto subspan = span.subspan(progress);
progress += ModifyHeaderInfo::serializedLength(subspan);
requestHeaders.append(ModifyHeaderInfo::deserialize(subspan));
}
RELEASE_ASSERT(progress == requestHeadersLength + sizeof(uint32_t));
Vector<ModifyHeaderInfo> responseHeaders;
while (progress < serializedLength) {
auto subspan = span.subspan(progress);
progress += ModifyHeaderInfo::serializedLength(subspan);
responseHeaders.append(ModifyHeaderInfo::deserialize(subspan));
}
RELEASE_ASSERT(progress == serializedLength);
return { WTFMove(requestHeaders), WTFMove(responseHeaders) };
}
size_t ModifyHeadersAction::serializedLength(Span<const uint8_t> span)
{
return deserializeLength(span, 0);
}
void ModifyHeadersAction::applyToRequest(ResourceRequest& request)
{
for (auto& info : requestHeaders)
info.applyToRequest(request);
}
void ModifyHeadersAction::ModifyHeaderInfo::applyToRequest(ResourceRequest& request)
{
std::visit(WTF::makeVisitor([&] (const AppendOperation& operation) {
auto existingValue = request.httpHeaderField(operation.header);
if (existingValue.isEmpty())
request.setHTTPHeaderField(operation.header, operation.value);
else
request.setHTTPHeaderField(operation.header, makeString(existingValue, "; ", operation.value));
}, [&] (const SetOperation& operation) {
request.setHTTPHeaderField(operation.header, operation.value);
}, [&] (const RemoveOperation& operation) {
request.removeHTTPHeaderField(operation.header);
}), operation);
}
auto ModifyHeadersAction::ModifyHeaderInfo::parse(const JSON::Value& infoValue) -> Expected<ModifyHeaderInfo, std::error_code>
{
auto object = infoValue.asObject();
if (!object)
return makeUnexpected(ContentExtensionError::JSONModifyHeadersInfoNotADictionary);
String operation = object->getString("operation");
if (!operation)
return makeUnexpected(ContentExtensionError::JSONModifyHeadersMissingOperation);
String header = object->getString("header");
if (!header)
return makeUnexpected(ContentExtensionError::JSONModifyHeadersMissingHeader);
String value = object->getString("value");
if (operation == "set") {
if (!value)
return makeUnexpected(ContentExtensionError::JSONModifyHeadersMissingValue);
return ModifyHeaderInfo { SetOperation { WTFMove(header), WTFMove(value) } };
}
if (operation == "append") {
if (!value)
return makeUnexpected(ContentExtensionError::JSONModifyHeadersMissingValue);
return ModifyHeaderInfo { AppendOperation { WTFMove(header), WTFMove(value) } };
}
if (operation == "remove")
return ModifyHeaderInfo { RemoveOperation { WTFMove(header) } };
return makeUnexpected(ContentExtensionError::JSONModifyHeadersInvalidOperation);
}
auto ModifyHeadersAction::ModifyHeaderInfo::isolatedCopy() const -> ModifyHeaderInfo
{
return {
crossThreadCopy(operation)
};
}
bool ModifyHeadersAction::ModifyHeaderInfo::operator==(const ModifyHeaderInfo& other) const
{
return other.operation == this->operation;
}
void ModifyHeadersAction::ModifyHeaderInfo::serialize(Vector<uint8_t>& vector) const
{
auto beginIndex = vector.size();
append(vector, 0);
vector.append(operation.index());
std::visit(WTF::makeVisitor([&] (const RemoveOperation& operation) {
append(vector, operation.header.utf8());
}, [&] (const auto& operation) {
auto valueUTF8 = operation.value.utf8();
append(vector, valueUTF8.length());
append(vector, operation.header.utf8());
append(vector, valueUTF8);
}), operation);
writeLengthToVectorAtOffset(vector, beginIndex);
}
auto ModifyHeadersAction::ModifyHeaderInfo::deserialize(Span<const uint8_t> span) -> ModifyHeaderInfo
{
constexpr auto headerSize = sizeof(uint32_t) + sizeof(uint8_t);
RELEASE_ASSERT(span.size() >= headerSize);
auto serializedLength = deserializeLength(span, 0);
return { [&] () -> OperationVariant {
switch (auto index = span[sizeof(uint32_t)]) {
case WTF::alternativeIndexV<RemoveOperation, OperationVariant>:
return RemoveOperation { deserializeUTF8String(span, headerSize, serializedLength - headerSize) };
case WTF::alternativeIndexV<AppendOperation, OperationVariant>:
case WTF::alternativeIndexV<SetOperation, OperationVariant>: {
auto valueLength = deserializeLength(span, headerSize);
auto headerLength = serializedLength - headerSize - valueLength - sizeof(uint32_t);
auto header = deserializeUTF8String(span, headerSize + sizeof(uint32_t), headerLength);
auto value = deserializeUTF8String(span, headerSize + sizeof(uint32_t) + headerLength, valueLength);
if (index == WTF::alternativeIndexV<AppendOperation, OperationVariant>)
return AppendOperation { WTFMove(header), WTFMove(value) };
return SetOperation { WTFMove(header), WTFMove(value) };
}
}
RELEASE_ASSERT_NOT_REACHED();
}() };
}
size_t ModifyHeadersAction::ModifyHeaderInfo::serializedLength(Span<const uint8_t> span)
{
return deserializeLength(span, 0);
}
Expected<RedirectAction, std::error_code> RedirectAction::parse(const JSON::Object& redirectObject)
{
auto redirect = redirectObject.getObject("redirect");
if (!redirect)
return makeUnexpected(ContentExtensionError::JSONRedirectMissing);
if (auto extensionPath = redirect->getString("extension-path"); !!extensionPath) {
if (!extensionPath.startsWith('/'))
return makeUnexpected(ContentExtensionError::JSONRedirectExtensionPathDoesNotStartWithSlash);
return RedirectAction { ExtensionPathAction { WTFMove(extensionPath) } };
}
if (auto regexSubstitution = redirect->getString("regex-substitution"); !!regexSubstitution)
return RedirectAction { RegexSubstitutionAction { WTFMove(regexSubstitution) } };
if (auto transform = redirect->getObject("transform")) {
auto parsedTransform = URLTransformAction::parse(*transform);
if (!parsedTransform)
return makeUnexpected(parsedTransform.error());
return RedirectAction { WTFMove(*parsedTransform) };
}
if (auto urlString = redirect->getString("url"); !!urlString) {
auto url = URL(URL(), urlString);
if (!url.isValid())
return makeUnexpected(ContentExtensionError::JSONRedirectURLInvalid);
if (url.protocolIsJavaScript())
return makeUnexpected(ContentExtensionError::JSONRedirectToJavaScriptURL);
return RedirectAction { URLAction { WTFMove(urlString) } };
}
return makeUnexpected(ContentExtensionError::JSONRedirectInvalidType);
}
RedirectAction RedirectAction::isolatedCopy() const
{
return {
crossThreadCopy(action)
};
}
bool RedirectAction::operator==(const RedirectAction& other) const
{
return other.hashTableType == this->hashTableType
&& other.action == this->action;
}
void RedirectAction::serialize(Vector<uint8_t>& vector) const
{
auto beginIndex = vector.size();
append(vector, 0);
vector.append(action.index());
std::visit(WTF::makeVisitor([&](const ExtensionPathAction& action) {
append(vector, action.extensionPath.utf8());
}, [&](const RegexSubstitutionAction& action) {
append(vector, action.regexSubstitution.utf8());
}, [&](const URLTransformAction& action) {
action.serialize(vector);
}, [&](const URLAction& action) {
append(vector, action.url.utf8());
}), action);
writeLengthToVectorAtOffset(vector, beginIndex);
}
RedirectAction RedirectAction::deserialize(Span<const uint8_t> span)
{
constexpr auto headerSize = sizeof(uint32_t) + sizeof(uint8_t);
auto stringLength = deserializeLength(span, 0) - headerSize;
RELEASE_ASSERT(span.size() >= headerSize);
return { [&] () -> ActionVariant {
switch (span[sizeof(uint32_t)]) {
case WTF::alternativeIndexV<ExtensionPathAction, ActionVariant>:
return ExtensionPathAction { deserializeUTF8String(span, headerSize, stringLength) };
case WTF::alternativeIndexV<RegexSubstitutionAction, ActionVariant>:
return RegexSubstitutionAction { deserializeUTF8String(span, headerSize, stringLength) };
case WTF::alternativeIndexV<URLTransformAction, ActionVariant>:
return URLTransformAction::deserialize(span.subspan(headerSize));
case WTF::alternativeIndexV<URLAction, ActionVariant>:
return URLAction { deserializeUTF8String(span, headerSize, stringLength) };
}
RELEASE_ASSERT_NOT_REACHED();
}() };
}
size_t RedirectAction::serializedLength(Span<const uint8_t> span)
{
return deserializeLength(span, 0);
}
void RedirectAction::applyToRequest(ResourceRequest& request, const URL& extensionBaseURL)
{
std::visit(WTF::makeVisitor([&](const ExtensionPathAction& action) {
auto url = extensionBaseURL;
url.setPath(action.extensionPath);
request.setURL(WTFMove(url));
}, [&] (const RegexSubstitutionAction&) {
// FIXME: Implement, ideally in a way that doesn't require making a new VM and global object for each redirect operation.
}, [&] (const URLTransformAction& action) {
auto url = request.url();
action.applyToURL(url);
request.setURL(WTFMove(url));
}, [&] (const URLAction& action) {
request.setURL(URL(URL(), action.url));
}), action);
}
auto RedirectAction::URLTransformAction::parse(const JSON::Object& transform) -> Expected<URLTransformAction, std::error_code>
{
URLTransformAction action;
if (auto fragment = transform.getString("fragment"); !!fragment) {
if (!fragment.isEmpty() && !fragment.startsWith('#'))
return makeUnexpected(ContentExtensionError::JSONRedirectInvalidFragment);
action.fragment = WTFMove(fragment);
}
action.host = transform.getString("host");
action.password = transform.getString("password");
action.path = transform.getString("path");
auto port = transform.getString("port");
if (!!port) {
if (port.isEmpty())
action.port = { std::optional<uint16_t> { } };
else {
auto parsedPort = parseInteger<uint16_t>(StringView(port));
if (!parsedPort)
return makeUnexpected(ContentExtensionError::JSONRedirectInvalidPort);
action.port = { parsedPort };
}
}
if (auto uncanonicalizedScheme = transform.getString("scheme"); !!uncanonicalizedScheme) {
auto scheme = WTF::URLParser::maybeCanonicalizeScheme(uncanonicalizedScheme);
if (!scheme)
return makeUnexpected(ContentExtensionError::JSONRedirectURLSchemeInvalid);
if (scheme == "javascript")
return makeUnexpected(ContentExtensionError::JSONRedirectToJavaScriptURL);
action.scheme = WTFMove(*scheme);
}
action.username = transform.getString("username");
if (auto queryTransform = transform.getObject("query-transform")) {
auto parsedQueryTransform = QueryTransform::parse(*queryTransform);
if (!parsedQueryTransform)
return makeUnexpected(parsedQueryTransform.error());
action.queryTransform = *parsedQueryTransform;
} else {
auto query = transform.getString("query");
if (!query.isEmpty() && !query.startsWith('?'))
return makeUnexpected(ContentExtensionError::JSONRedirectInvalidQuery);
action.queryTransform = WTFMove(query);
}
return action;
}
auto RedirectAction::URLTransformAction::isolatedCopy() const -> URLTransformAction
{
return {
crossThreadCopy(fragment),
crossThreadCopy(host),
crossThreadCopy(password),
crossThreadCopy(path),
crossThreadCopy(port),
crossThreadCopy(queryTransform),
crossThreadCopy(scheme),
crossThreadCopy(username)
};
}
bool RedirectAction::URLTransformAction::operator==(const URLTransformAction& other) const
{
return other.fragment == this->fragment
&& other.host == this->host
&& other.password == this->password
&& other.path == this->path
&& other.port == this->port
&& other.queryTransform == this->queryTransform
&& other.scheme == this->scheme
&& other.username == this->username;
}
void RedirectAction::URLTransformAction::serialize(Vector<uint8_t>& vector) const
{
uint8_t hasFragment = !!fragment;
uint8_t hasHost = !!host;
uint8_t hasPassword = !!password;
uint8_t hasPath = !!path;
uint8_t hasPort = !!port;
uint8_t hasScheme = !!scheme;
uint8_t hasUsername = !!username;
auto* queryString = std::get_if<String>(&queryTransform);
auto queryStringUTF8 = queryString ? queryString->utf8() : CString();
uint8_t hasQuery = !queryString || !!*queryString;
auto fragmentUTF8 = fragment.utf8();
auto hostUTF8 = host.utf8();
auto passwordUTF8 = password.utf8();
auto pathUTF8 = path.utf8();
auto schemeUTF8 = scheme.utf8();
auto usernameUTF8 = username.utf8();
vector.reserveCapacity(vector.size() + sizeof(uint32_t) + sizeof(uint8_t)
+ (hasFragment ? sizeof(uint32_t) + fragmentUTF8.length() : 0)
+ (hasHost ? sizeof(uint32_t) + hostUTF8.length() : 0)
+ (hasPassword ? sizeof(uint32_t) + passwordUTF8.length() : 0)
+ (hasPath ? sizeof(uint32_t) + pathUTF8.length() : 0)
+ (hasScheme ? sizeof(uint32_t) + schemeUTF8.length() : 0)
+ (hasUsername ? sizeof(uint32_t) + usernameUTF8.length() : 0)
+ (hasPort ? 1 + (*port ? sizeof(uint16_t) : 0) : 0)
+ (hasQuery ? 1 + (queryString ? sizeof(uint32_t) + queryStringUTF8.length() : 0) : 0));
auto beginIndex = vector.size();
uncheckedAppend(vector, 0);
vector.uncheckedAppend(
hasFragment << 7
| hasHost << 6
| hasPassword << 5
| hasPath << 4
| hasPort << 3
| hasScheme << 2
| hasUsername << 1
| hasQuery << 0
);
auto uncheckedAppendLengthAndString = [&] (const CString& string) {
uncheckedAppend(vector, string.length());
uncheckedAppend(vector, string);
};
if (hasFragment)
uncheckedAppendLengthAndString(fragmentUTF8);
if (hasHost)
uncheckedAppendLengthAndString(hostUTF8);
if (hasPassword)
uncheckedAppendLengthAndString(passwordUTF8);
if (hasPath)
uncheckedAppendLengthAndString(pathUTF8);
if (hasScheme)
uncheckedAppendLengthAndString(schemeUTF8);
if (hasUsername)
uncheckedAppendLengthAndString(usernameUTF8);
if (hasPort) {
vector.uncheckedAppend(!!*port);
if (*port) {
vector.uncheckedAppend(**port >> 0);
vector.uncheckedAppend(**port >> 8);
}
}
if (hasQuery) {
vector.uncheckedAppend(queryTransform.index());
std::visit(WTF::makeVisitor([&](const String&) {
uncheckedAppend(vector, queryStringUTF8.length());
uncheckedAppend(vector, queryStringUTF8);
}, [&](const QueryTransform& transform) {
transform.serialize(vector);
}), queryTransform);
}
writeLengthToVectorAtOffset(vector, beginIndex);
}
auto RedirectAction::URLTransformAction::deserialize(Span<const uint8_t> span) -> URLTransformAction
{
constexpr auto headerLength = sizeof(uint32_t) + sizeof(uint8_t);
RELEASE_ASSERT(span.size() >= headerLength);
uint8_t flags = span[sizeof(uint32_t)];
bool hasFragment = flags & (1 << 7);
bool hasHost = flags & (1 << 6);
bool hasPassword = flags & (1 << 5);
bool hasPath = flags & (1 << 4);
bool hasPort = flags & (1 << 3);
bool hasScheme = flags & (1 << 2);
bool hasUsername = flags & (1 << 1);
bool hasQuery = flags & (1 << 0);
size_t progress = headerLength;
auto deserializeString = [&] {
auto stringLength = deserializeLength(span, progress);
auto string = deserializeUTF8String(span, progress + sizeof(uint32_t), stringLength);
progress += sizeof(uint32_t) + stringLength;
return string;
};
auto fragment = hasFragment ? deserializeString() : String();
auto host = hasHost ? deserializeString() : String();
auto password = hasPassword ? deserializeString() : String();
auto path = hasPath ? deserializeString() : String();
auto scheme = hasScheme ? deserializeString() : String();
auto username = hasUsername ? deserializeString() : String();
std::optional<std::optional<uint16_t>> port;
if (hasPort) {
if (span[progress++]) {
RELEASE_ASSERT(span.size() > progress + 1);
uint16_t value = (span[progress] << 0) | (span[progress + 1] << 8);
port = { { value } };
progress += 2;
} else
port = { std::optional<uint16_t> { } };
}
QueryTransformVariant queryTransform;
if (hasQuery) {
RELEASE_ASSERT(span.size() > progress);
uint8_t variantIndex = span[progress++];
if (variantIndex == WTF::alternativeIndexV<String, QueryTransformVariant>) {
auto queryStringLength = deserializeLength(span, progress);
queryTransform = deserializeUTF8String(span, progress + sizeof(uint32_t), queryStringLength);
} else if (variantIndex == WTF::alternativeIndexV<QueryTransform, QueryTransformVariant>)
queryTransform = QueryTransform::deserialize(span.subspan(progress));
else
RELEASE_ASSERT_NOT_REACHED();
}
return {
WTFMove(fragment),
WTFMove(host),
WTFMove(password),
WTFMove(path),
WTFMove(port),
WTFMove(queryTransform),
WTFMove(scheme),
WTFMove(username)
};
}
size_t RedirectAction::URLTransformAction::serializedLength(Span<const uint8_t> span)
{
return deserializeLength(span, 0);
}
auto RedirectAction::URLTransformAction::QueryTransform::parse(const JSON::Object& queryTransform) -> Expected<QueryTransform, std::error_code>
{
QueryTransform parsedQueryTransform;
if (auto removeParametersValue = queryTransform.getValue("remove-parameters")) {
auto removeParametersArray = removeParametersValue->asArray();
if (!removeParametersArray)
return makeUnexpected(ContentExtensionError::JSONRemoveParametersNotStringArray);
Vector<String> removeParametersVector;
removeParametersVector.reserveInitialCapacity(removeParametersArray->length());
for (auto& parameter : *removeParametersArray) {
if (parameter.get().type() != JSON::Value::Type::String)
return makeUnexpected(ContentExtensionError::JSONRemoveParametersNotStringArray);
removeParametersVector.uncheckedAppend(parameter.get().asString());
}
parsedQueryTransform.removeParams = WTFMove(removeParametersVector);
}
if (auto addOrReplaceParametersValue = queryTransform.getValue("add-or-replace-parameters")) {
auto addOrReplaceParametersArray = addOrReplaceParametersValue->asArray();
if (!addOrReplaceParametersArray)
return makeUnexpected(ContentExtensionError::JSONAddOrReplaceParametersNotArray);
Vector<QueryKeyValue> keyValues;
keyValues.reserveInitialCapacity(addOrReplaceParametersArray->length());
for (auto& queryKeyValue : *addOrReplaceParametersArray) {
auto keyValue = QueryKeyValue::parse(queryKeyValue.get());
if (!keyValue)
return makeUnexpected(keyValue.error());
keyValues.uncheckedAppend(WTFMove(*keyValue));
}
parsedQueryTransform.addOrReplaceParams = WTFMove(keyValues);
}
return parsedQueryTransform;
}
void RedirectAction::URLTransformAction::applyToURL(URL& url) const
{
if (!!fragment) {
if (fragment.isEmpty())
url.removeFragmentIdentifier();
else
url.setFragmentIdentifier(StringView(fragment).substring(1));
}
if (!!host)
url.setHost(host);
if (!!password)
url.setPassword(password);
if (!!path)
url.setPath(path);
if (!!port)
url.setPort(*port);
std::visit(WTF::makeVisitor([&] (const String& query) {
if (!query.isNull())
url.setQuery(query.isEmpty() ? StringView() : StringView(query));
}, [&] (const URLTransformAction::QueryTransform& transform) {
transform.applyToURL(url);
}), queryTransform);
if (!!scheme)
url.setProtocol(scheme);
if (!!username)
url.setUser(username);
}
void RedirectAction::URLTransformAction::QueryTransform::applyToURL(URL& url) const
{
auto form = WTF::URLParser::parseURLEncodedForm(url.query());
HashSet<String> keysToRemove;
for (auto& key : removeParams)
keysToRemove.add(key);
form.removeAllMatching([&] (auto& keyValue) {
return keysToRemove.contains(keyValue.key);
});
Vector<WTF::KeyValuePair<String, String>> keysToAdd;
HashMap<String, String> keysToReplace;
for (auto& keyValue : addOrReplaceParams) {
if (keyValue.replaceOnly)
keysToReplace.add(keyValue.key, keyValue.value);
else
keysToAdd.append({ keyValue.key, keyValue.value });
}
for (auto& keyValue : form) {
auto iterator = keysToReplace.find(keyValue.key);
if (iterator != keysToReplace.end())
keyValue.value = iterator->value;
}
form.appendVector(WTFMove(keysToAdd));
StringBuilder transformedQuery;
for (auto& keyValue : form)
transformedQuery.append(transformedQuery.isEmpty() ? "" : "&", keyValue.key, !!keyValue.value ? "=" : "", keyValue.value);
url.setQuery(transformedQuery);
}
auto RedirectAction::URLTransformAction::QueryTransform::isolatedCopy() const -> QueryTransform
{
return {
crossThreadCopy(addOrReplaceParams),
crossThreadCopy(removeParams)
};
}
bool RedirectAction::URLTransformAction::QueryTransform::operator==(const QueryTransform& other) const
{
return other.addOrReplaceParams == this->addOrReplaceParams
&& other.removeParams == this->removeParams;
}
void RedirectAction::URLTransformAction::QueryTransform::serialize(Vector<uint8_t>& vector) const
{
auto beginIndex = vector.size();
append(vector, 0);
auto keyValueBeginIndex = vector.size();
append(vector, 0);
for (auto& queryKeyValue : addOrReplaceParams)
queryKeyValue.serialize(vector);
writeLengthToVectorAtOffset(vector, keyValueBeginIndex);
for (auto& string : removeParams) {
auto utf8 = string.utf8();
append(vector, utf8.length());
append(vector, utf8);
}
writeLengthToVectorAtOffset(vector, beginIndex);
}
auto RedirectAction::URLTransformAction::QueryTransform::deserialize(Span<const uint8_t> span) -> QueryTransform
{
auto serializedLength = deserializeLength(span, 0);
auto keyValuesSerializedLength = deserializeLength(span, sizeof(uint32_t));
Vector<QueryKeyValue> queryKeyValues;
auto queryKeyValuesProgress = sizeof(uint32_t);
while (queryKeyValuesProgress < keyValuesSerializedLength) {
auto subspan = span.subspan(sizeof(uint32_t) + queryKeyValuesProgress);
queryKeyValuesProgress += QueryKeyValue::serializedLength(subspan);
queryKeyValues.append(QueryKeyValue::deserialize(subspan));
}
RELEASE_ASSERT(queryKeyValuesProgress == keyValuesSerializedLength);
Vector<String> strings;
auto stringsProgress = sizeof(uint32_t) + queryKeyValuesProgress;
while (stringsProgress < serializedLength) {
auto stringLength = deserializeLength(span, stringsProgress);
strings.append(deserializeUTF8String(span, stringsProgress + sizeof(uint32_t), stringLength));
stringsProgress += sizeof(uint32_t) + stringLength;
}
return { WTFMove(queryKeyValues), WTFMove(strings) };
}
size_t RedirectAction::URLTransformAction::QueryTransform::serializedLength(Span<const uint8_t> span)
{
return deserializeLength(span, 0);
}
auto RedirectAction::URLTransformAction::QueryTransform::QueryKeyValue::parse(const JSON::Value& keyValueValue) -> Expected<QueryKeyValue, std::error_code>
{
auto keyValue = keyValueValue.asObject();
if (!keyValue)
return makeUnexpected(ContentExtensionError::JSONAddOrReplaceParametersKeyValueNotADictionary);
String key = keyValue->getString("key");
if (!key)
return makeUnexpected(ContentExtensionError::JSONAddOrReplaceParametersKeyValueMissingKeyString);
String value = keyValue->getString("value");
if (!value)
return makeUnexpected(ContentExtensionError::JSONAddOrReplaceParametersKeyValueMissingValueString);
bool replaceOnly { false };
if (auto boolean = keyValue->getBoolean("replace-only"))
replaceOnly = *boolean;
return { { WTFMove(key), replaceOnly, WTFMove(value) } };
}
auto RedirectAction::URLTransformAction::QueryTransform::QueryKeyValue::isolatedCopy() const -> QueryKeyValue
{
return {
crossThreadCopy(key),
crossThreadCopy(replaceOnly),
crossThreadCopy(value)
};
}
bool RedirectAction::URLTransformAction::QueryTransform::QueryKeyValue::operator==(const QueryKeyValue& other) const
{
return other.key == this->key
&& other.replaceOnly == this->replaceOnly
&& other.value == this->value;
}
void RedirectAction::URLTransformAction::QueryTransform::QueryKeyValue::serialize(Vector<uint8_t>& vector) const
{
constexpr auto headerLength = sizeof(uint32_t) + sizeof(uint32_t) + sizeof(bool);
// FIXME: All these allocations and copies aren't strictly necessary.
// We would need a way to query exactly what the UTF-8 encoded length would be to remove them, though.
auto keyUTF8 = key.utf8();
auto valueUTF8 = value.utf8();
auto serializedLength = headerLength + keyUTF8.length() + valueUTF8.length();
vector.reserveCapacity(vector.size() + serializedLength);
uncheckedAppend(vector, serializedLength);
uncheckedAppend(vector, keyUTF8.length());
vector.uncheckedAppend(replaceOnly);
uncheckedAppend(vector, keyUTF8);
uncheckedAppend(vector, valueUTF8);
}
auto RedirectAction::URLTransformAction::QueryTransform::QueryKeyValue::deserialize(Span<const uint8_t> span) -> QueryKeyValue
{
// FIXME: Using null terminated strings would reduce the binary size considerably.
// We would need to disallow null strings when parsing, though.
constexpr auto headerLength = sizeof(uint32_t) + sizeof(uint32_t) + sizeof(bool);
RELEASE_ASSERT(span.size() >= headerLength);
auto serializedLength = deserializeLength(span, 0);
auto keyUTF8Length = deserializeLength(span, sizeof(uint32_t));
bool replaceOnly = span[sizeof(uint32_t) + sizeof(uint32_t)];
auto key = deserializeUTF8String(span, headerLength, keyUTF8Length);
auto value = deserializeUTF8String(span, headerLength + keyUTF8Length, serializedLength - headerLength - keyUTF8Length);
return { WTFMove(key), replaceOnly, WTFMove(value) };
}
size_t RedirectAction::URLTransformAction::QueryTransform::QueryKeyValue::serializedLength(Span<const uint8_t> span)
{
return deserializeLength(span, 0);
}
} // namespace WebCore::ContentExtensions
#endif // ENABLE(CONTENT_EXTENSIONS)