/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

/* vim: set ts=8 sts=2 et sw=2 tw=80: */

/* This Source Code Form is subject to the terms of the Mozilla Public

* License, v. 2.0. If a copy of the MPL was not distributed with this

* file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "KeyPath.h"

#include "IDBObjectStore.h"

#include "IndexedDBCommon.h"

#include "Key.h"

#include "ReportInternalError.h"

#include "js/Array.h" // JS::NewArrayObject

#include "js/PropertyAndElement.h" // JS_DefineElement, JS_DefineUCProperty, JS_DeleteUCProperty

#include "js/PropertyDescriptor.h" // JS::PropertyDescriptor, JS_GetOwnUCPropertyDescriptor

#include "mozilla/ResultExtensions.h"

#include "mozilla/dom/BindingDeclarations.h"

#include "mozilla/dom/Blob.h"

#include "mozilla/dom/BlobBinding.h"

#include "mozilla/dom/File.h"

#include "mozilla/dom/IDBObjectStoreBinding.h"

#include "mozilla/dom/quota/ResultExtensions.h"

#include "nsCharSeparatedTokenizer.h"

#include "nsJSUtils.h"

#include "nsPrintfCString.h"

#include "xpcpublic.h"

namespace mozilla::dom::indexedDB {

namespace {

using KeyPathTokenizer =

nsCharSeparatedTokenizerTemplate<NS_TokenizerIgnoreNothing>;

bool IsValidKeyPathString(const nsAString& aKeyPath) {

NS_ASSERTION(!aKeyPath.IsVoid(), "What?");

for (const auto& token : KeyPathTokenizer(aKeyPath, '.').ToRange()) {

if (token.IsEmpty()) {

return false;

}

if (!JS_IsIdentifier(token.Data(), token.Length())) {

return false;

}

}

// If the very last character was a '.', the tokenizer won't give us an empty

// token, but the keyPath is still invalid.

return aKeyPath.IsEmpty() || aKeyPath.CharAt(aKeyPath.Length() - 1) != '.';

}

enum KeyExtractionOptions { DoNotCreateProperties, CreateProperties };

nsresult GetJSValFromKeyPathString(

JSContext* aCx, const JS::Value& aValue, const nsAString& aKeyPathString,

JS::Value* aKeyJSVal, KeyExtractionOptions aOptions,

KeyPath::ExtractOrCreateKeyCallback aCallback, void* aClosure) {

NS_ASSERTION(aCx, "Null pointer!");

NS_ASSERTION(IsValidKeyPathString(aKeyPathString), "This will explode!");

NS_ASSERTION(!(aCallback || aClosure) || aOptions == CreateProperties,

"This is not allowed!");

NS_ASSERTION(aOptions != CreateProperties || aCallback,

"If properties are created, there must be a callback!");

nsresult rv = NS_OK;

*aKeyJSVal = aValue;

KeyPathTokenizer tokenizer(aKeyPathString, '.');

nsString targetObjectPropName;

JS::Rooted<JSObject*> targetObject(aCx, nullptr);

JS::Rooted<JS::Value> currentVal(aCx, aValue);

JS::Rooted<JSObject*> obj(aCx);

while (tokenizer.hasMoreTokens()) {

const auto& token = tokenizer.nextToken();

NS_ASSERTION(!token.IsEmpty(), "Should be a valid keypath");

const char16_t* keyPathChars = token.BeginReading();

const size_t keyPathLen = token.Length();

if (!targetObject) {

// We're still walking the chain of existing objects

// http://w3c.github.io/IndexedDB/#evaluate-a-key-path-on-a-value

// step 4 substep 1: check for .length on a String value.

if (currentVal.isString() && !tokenizer.hasMoreTokens() &&

token.EqualsLiteral("length")) {

aKeyJSVal->setNumber(JS_GetStringLength(currentVal.toString()));

break;

}

if (!currentVal.isObject()) {

return NS_ERROR_DOM_INDEXEDDB_DATA_ERR;

}

obj = &currentVal.toObject();

// We call JS_GetOwnUCPropertyDescriptor on purpose (as opposed to

// JS_GetUCPropertyDescriptor) to avoid searching the prototype chain.

JS::Rooted<mozilla::Maybe<JS::PropertyDescriptor>> desc(aCx);

QM_TRY(OkIf(JS_GetOwnUCPropertyDescriptor(aCx, obj, keyPathChars,

keyPathLen, &desc)),

NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR,

IDB_REPORT_INTERNAL_ERR_LAMBDA);

JS::Rooted<JS::Value> intermediate(aCx);

bool hasProp = false;

if (desc.isSome() && desc->isDataDescriptor()) {

intermediate = desc->value();

hasProp = true;

} else {

// If we get here it means the object doesn't have the property or the

// property is available throuch a getter. We don't want to call any

// getters to avoid potential re-entrancy.

// The blob object is special since its properties are available

// only through getters but we still want to support them for key

// extraction. So they need to be handled manually.

Blob* blob;

if (NS_SUCCEEDED(UNWRAP_OBJECT(Blob, &obj, blob))) {

if (token.EqualsLiteral("size")) {

ErrorResult rv;

uint64_t size = blob->GetSize(rv);

MOZ_ALWAYS_TRUE(!rv.Failed());

intermediate = JS_NumberValue(size);

hasProp = true;

} else if (token.EqualsLiteral("type")) {

nsString type;

blob->GetType(type);

JSString* string =

JS_NewUCStringCopyN(aCx, type.get(), type.Length());

intermediate = JS::StringValue(string);

hasProp = true;

} else {

RefPtr<File> file = blob->ToFile();

if (file) {

if (token.EqualsLiteral("name")) {

nsString name;

file->GetName(name);

JSString* string =

JS_NewUCStringCopyN(aCx, name.get(), name.Length());

intermediate = JS::StringValue(string);

hasProp = true;

} else if (token.EqualsLiteral("lastModified")) {

ErrorResult rv;

int64_t lastModifiedDate = file->GetLastModified(rv);

MOZ_ALWAYS_TRUE(!rv.Failed());

intermediate = JS_NumberValue(lastModifiedDate);

hasProp = true;

}

// The spec also lists "lastModifiedDate", but we deprecated and

// removed support for it.

}

}

}

}

if (hasProp) {

// Treat explicitly undefined as an error.

if (intermediate.isUndefined()) {

return NS_ERROR_DOM_INDEXEDDB_DATA_ERR;

}

if (tokenizer.hasMoreTokens()) {

// ...and walk to it if there are more steps...

currentVal = intermediate;

} else {

// ...otherwise use it as key

*aKeyJSVal = intermediate;

}

} else {

// If the property doesn't exist, fall into below path of starting

// to define properties, if allowed.

if (aOptions == DoNotCreateProperties) {

return NS_ERROR_DOM_INDEXEDDB_DATA_ERR;

}

targetObject = obj;

targetObjectPropName = token;

}

}

if (targetObject) {

// We have started inserting new objects or are about to just insert

// the first one.

aKeyJSVal->setUndefined();

if (tokenizer.hasMoreTokens()) {

// If we're not at the end, we need to add a dummy object to the

// chain.

JS::Rooted<JSObject*> dummy(aCx, JS_NewPlainObject(aCx));

if (!dummy) {

IDB_REPORT_INTERNAL_ERR();

rv = NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;

break;

}

if (!JS_DefineUCProperty(aCx, obj, token.BeginReading(), token.Length(),

dummy, JSPROP_ENUMERATE)) {

IDB_REPORT_INTERNAL_ERR();

rv = NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;

break;

}

obj = dummy;

} else {

JS::Rooted<JSObject*> dummy(

aCx, JS_NewObject(aCx, IDBObjectStore::DummyPropClass()));

if (!dummy) {

IDB_REPORT_INTERNAL_ERR();

rv = NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;

break;

}

if (!JS_DefineUCProperty(aCx, obj, token.BeginReading(), token.Length(),

dummy, JSPROP_ENUMERATE)) {

IDB_REPORT_INTERNAL_ERR();

rv = NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;

break;

}

obj = dummy;

}

}

}

// We guard on rv being a success because we need to run the property

// deletion code below even if we should not be running the callback.

if (NS_SUCCEEDED(rv) && aCallback) {

rv = (*aCallback)(aCx, aClosure);

}

if (targetObject) {

// If this fails, we lose, and the web page sees a magical property

// appear on the object :-(

JS::ObjectOpResult succeeded;

if (!JS_DeleteUCProperty(aCx, targetObject, targetObjectPropName.get(),

targetObjectPropName.Length(), succeeded)) {

IDB_REPORT_INTERNAL_ERR();

return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;

}

QM_TRY(OkIf(succeeded.ok()), NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR,

IDB_REPORT_INTERNAL_ERR_LAMBDA);

}

// TODO: It would be nicer to do the cleanup using a RAII class or something.

// This last QM_TRY could be removed then.

QM_TRY(MOZ_TO_RESULT(rv));

return NS_OK;

}

} // namespace

// static

Result<KeyPath, nsresult> KeyPath::Parse(const nsAString& aString) {

KeyPath keyPath(0);

keyPath.SetType(KeyPathType::String);

if (!keyPath.AppendStringWithValidation(aString)) {

return Err(NS_ERROR_FAILURE);

}

return keyPath;

}

// static

Result<KeyPath, nsresult> KeyPath::Parse(const Sequence<nsString>& aStrings) {

KeyPath keyPath(0);

keyPath.SetType(KeyPathType::Array);

for (uint32_t i = 0; i < aStrings.Length(); ++i) {

if (!keyPath.AppendStringWithValidation(aStrings[i])) {

return Err(NS_ERROR_FAILURE);

}

}

return keyPath;

}

// static

Result<KeyPath, nsresult> KeyPath::Parse(

const Nullable<OwningStringOrStringSequence>& aValue) {

if (aValue.IsNull()) {

return KeyPath{0};

}

if (aValue.Value().IsString()) {

return Parse(aValue.Value().GetAsString());

}

MOZ_ASSERT(aValue.Value().IsStringSequence());

const Sequence<nsString>& seq = aValue.Value().GetAsStringSequence();

if (seq.Length() == 0) {

return Err(NS_ERROR_FAILURE);

}

return Parse(seq);

}

void KeyPath::SetType(KeyPathType aType) {

mType = aType;

mStrings.Clear();

}

bool KeyPath::AppendStringWithValidation(const nsAString& aString) {

if (!IsValidKeyPathString(aString)) {

return false;

}

if (IsString()) {

NS_ASSERTION(mStrings.Length() == 0, "Too many strings!");

mStrings.AppendElement(aString);

return true;

}

if (IsArray()) {

mStrings.AppendElement(aString);

return true;

}

MOZ_ASSERT_UNREACHABLE("What?!");

return false;

}

nsresult KeyPath::ExtractKey(JSContext* aCx, const JS::Value& aValue, Key& aKey,

const VoidOrObjectStoreKeyPathString&

aAutoIncrementedObjectStoreKeyPath) const {

uint32_t len = mStrings.Length();

JS::Rooted<JS::Value> value(aCx);

aKey.Unset();

for (uint32_t i = 0; i < len; ++i) {

nsresult rv =

GetJSValFromKeyPathString(aCx, aValue, mStrings[i], value.address(),

DoNotCreateProperties, nullptr, nullptr);

if (NS_FAILED(rv)) {

if (!aAutoIncrementedObjectStoreKeyPath.IsVoid() &&

mStrings[i].Equals(aAutoIncrementedObjectStoreKeyPath)) {

// We are extracting index keys of an object to be added if

// object store key path for a string key is provided.

// Because the autoIncrement primary key is part of

// this index key but is not defined in |aValue|, so we reserve

// the space here to update the key later in parent.

aKey.ReserveAutoIncrementKey(IsArray() && i == 0);

continue;

}

return rv;

}

auto result = aKey.AppendItem(aCx, IsArray() && i == 0, value);

if (result.isErr()) {

NS_ASSERTION(aKey.IsUnset(), "Encoding error should unset");

if (result.inspectErr().Is(SpecialValues::Exception)) {

result.unwrapErr().AsException().SuppressException();

}

return NS_ERROR_DOM_INDEXEDDB_DATA_ERR;

}

}

aKey.FinishArray();

return NS_OK;

}

nsresult KeyPath::ExtractKeyAsJSVal(JSContext* aCx, const JS::Value& aValue,

JS::Value* aOutVal) const {

NS_ASSERTION(IsValid(), "This doesn't make sense!");

if (IsString()) {

return GetJSValFromKeyPathString(aCx, aValue, mStrings[0], aOutVal,

DoNotCreateProperties, nullptr, nullptr);

}

const uint32_t len = mStrings.Length();

JS::Rooted<JSObject*> arrayObj(aCx, JS::NewArrayObject(aCx, len));

if (!arrayObj) {

return NS_ERROR_OUT_OF_MEMORY;

}

JS::Rooted<JS::Value> value(aCx);

for (uint32_t i = 0; i < len; ++i) {

nsresult rv =

GetJSValFromKeyPathString(aCx, aValue, mStrings[i], value.address(),

DoNotCreateProperties, nullptr, nullptr);

if (NS_FAILED(rv)) {

return rv;

}

if (!JS_DefineElement(aCx, arrayObj, i, value, JSPROP_ENUMERATE)) {

IDB_REPORT_INTERNAL_ERR();

return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;

}

}

aOutVal->setObject(*arrayObj);

return NS_OK;

}

nsresult KeyPath::ExtractOrCreateKey(JSContext* aCx, const JS::Value& aValue,

Key& aKey,

ExtractOrCreateKeyCallback aCallback,

void* aClosure) const {

NS_ASSERTION(IsString(), "This doesn't make sense!");

JS::Rooted<JS::Value> value(aCx);

aKey.Unset();

nsresult rv =

GetJSValFromKeyPathString(aCx, aValue, mStrings[0], value.address(),

CreateProperties, aCallback, aClosure);

if (NS_FAILED(rv)) {

return rv;

}

auto result = aKey.AppendItem(aCx, false, value);

if (result.isErr()) {

NS_ASSERTION(aKey.IsUnset(), "Should be unset");

if (result.inspectErr().Is(SpecialValues::Exception)) {

result.unwrapErr().AsException().SuppressException();

}

return value.isUndefined() ? NS_OK : NS_ERROR_DOM_INDEXEDDB_DATA_ERR;

}

aKey.FinishArray();

return NS_OK;

}

nsAutoString KeyPath::SerializeToString() const {

NS_ASSERTION(IsValid(), "Check to see if I'm valid first!");

if (IsString()) {

return nsAutoString{mStrings[0]};

}

if (IsArray()) {

nsAutoString res;

// We use a comma in the beginning to indicate that it's an array of

// key paths. This is to be able to tell a string-keypath from an

// array-keypath which contains only one item.

// It also makes serializing easier :-)

const uint32_t len = mStrings.Length();

for (uint32_t i = 0; i < len; ++i) {

res.Append(',');

res.Append(mStrings[i]);

}

return res;

}

MOZ_ASSERT_UNREACHABLE("What?");

return {};

}

// static

KeyPath KeyPath::DeserializeFromString(const nsAString& aString) {

KeyPath keyPath(0);

if (!aString.IsEmpty() && aString.First() == ',') {

keyPath.SetType(KeyPathType::Array);

// We use a comma in the beginning to indicate that it's an array of

// key paths. This is to be able to tell a string-keypath from an

// array-keypath which contains only one item.

nsCharSeparatedTokenizerTemplate<NS_TokenizerIgnoreNothing> tokenizer(

aString, ',');

tokenizer.nextToken();

while (tokenizer.hasMoreTokens()) {

keyPath.mStrings.AppendElement(tokenizer.nextToken());

}

if (tokenizer.separatorAfterCurrentToken()) {

// There is a trailing comma, indicating the original KeyPath has

// a trailing empty string, i.e. [..., '']. We should append this

// empty string.

keyPath.mStrings.EmplaceBack();

}

return keyPath;

}

keyPath.SetType(KeyPathType::String);

keyPath.mStrings.AppendElement(aString);

return keyPath;

}

nsresult KeyPath::ToJSVal(JSContext* aCx,

JS::MutableHandle<JS::Value> aValue) const {

if (IsArray()) {

uint32_t len = mStrings.Length();

JS::Rooted<JSObject*> array(aCx, JS::NewArrayObject(aCx, len));

if (!array) {

IDB_WARNING("Failed to make array!");

return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;

}

for (uint32_t i = 0; i < len; ++i) {

JS::Rooted<JS::Value> val(aCx);

nsString tmp(mStrings[i]);

if (!xpc::StringToJsval(aCx, tmp, &val)) {

IDB_REPORT_INTERNAL_ERR();

return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;

}

if (!JS_DefineElement(aCx, array, i, val, JSPROP_ENUMERATE)) {

IDB_REPORT_INTERNAL_ERR();

return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;

}

}

aValue.setObject(*array);

return NS_OK;

}

if (IsString()) {

nsString tmp(mStrings[0]);

if (!xpc::StringToJsval(aCx, tmp, aValue)) {

IDB_REPORT_INTERNAL_ERR();

return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;

}

return NS_OK;

}

aValue.setNull();

return NS_OK;

}

nsresult KeyPath::ToJSVal(JSContext* aCx, JS::Heap<JS::Value>& aValue) const {

JS::Rooted<JS::Value> value(aCx);

nsresult rv = ToJSVal(aCx, &value);

if (NS_SUCCEEDED(rv)) {

aValue = value;

}

return rv;

}

bool KeyPath::IsAllowedForObjectStore(bool aAutoIncrement) const {

// Any keypath that passed validation is allowed for non-autoIncrement

// objectStores.

if (!aAutoIncrement) {

return true;

}

// Array keypaths are not allowed for autoIncrement objectStores.

if (IsArray()) {

return false;

}

// Neither are empty strings.

if (IsEmpty()) {

return false;

}

// Everything else is ok.

return true;

}

} // namespace mozilla::dom::indexedDB