dom/indexedDB/KeyPath.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "KeyPath.h"
   8 #include "IDBObjectStore.h"
   9 #include "Key.h"
  10 #include "ReportInternalError.h"
  11
  12 #include "nsCharSeparatedTokenizer.h"
  13 #include "nsJSUtils.h"
  14 #include "xpcpublic.h"
  15
  16 #include "mozilla/dom/BindingDeclarations.h"
  17
  18 USING_INDEXEDDB_NAMESPACE
  19
  20 namespace {
  21
  22 inline
  23 bool
  24 IgnoreWhitespace(char16_t c)
  25 {
  26   return false;
  27 }
  28
  29 typedef nsCharSeparatedTokenizerTemplate<IgnoreWhitespace> KeyPathTokenizer;
  30
  31 bool
  32 IsValidKeyPathString(JSContext* aCx, const nsAString& aKeyPath)
  33 {
  34   NS_ASSERTION(!aKeyPath.IsVoid(), "What?");
  35
  36   KeyPathTokenizer tokenizer(aKeyPath, '.');
  37
  38   while (tokenizer.hasMoreTokens()) {
  39     nsString token(tokenizer.nextToken());
  40
  41     if (!token.Length()) {
  42       return false;
  43     }
  44
  45     JS::Rooted<JS::Value> stringVal(aCx);
  46     if (!xpc::StringToJsval(aCx, token, &stringVal)) {
  47       return false;
  48     }
  49
  50     NS_ASSERTION(stringVal.toString(), "This should never happen");
  51     JS::Rooted<JSString*> str(aCx, stringVal.toString());
  52
  53     bool isIdentifier = false;
  54     if (!JS_IsIdentifier(aCx, str, &isIdentifier) || !isIdentifier) {
  55       return false;
  56     }
  57   }
  58
  59   // If the very last character was a '.', the tokenizer won't give us an empty
  60   // token, but the keyPath is still invalid.
  61   if (!aKeyPath.IsEmpty() &&
  62       aKeyPath.CharAt(aKeyPath.Length() - 1) == '.') {
  63     return false;
  64   }
  65
  66   return true;
  67 }
  68
  69 enum KeyExtractionOptions {
  70   DoNotCreateProperties,
  71   CreateProperties
  72 };
  73
  74 nsresult
  75 GetJSValFromKeyPathString(JSContext* aCx,
  76                           const JS::Value& aValue,
  77                           const nsAString& aKeyPathString,
  78                           JS::Value* aKeyJSVal,
  79                           KeyExtractionOptions aOptions,
  80                           KeyPath::ExtractOrCreateKeyCallback aCallback,
  81                           void* aClosure)
  82 {
  83   NS_ASSERTION(aCx, "Null pointer!");
  84   NS_ASSERTION(IsValidKeyPathString(aCx, aKeyPathString),
  85                "This will explode!");
  86   NS_ASSERTION(!(aCallback || aClosure) || aOptions == CreateProperties,
  87                "This is not allowed!");
  88   NS_ASSERTION(aOptions != CreateProperties || aCallback,
  89                "If properties are created, there must be a callback!");
  90
  91   nsresult rv = NS_OK;
  92   *aKeyJSVal = aValue;
  93
  94   KeyPathTokenizer tokenizer(aKeyPathString, '.');
  95
  96   nsString targetObjectPropName;
  97   JS::Rooted<JSObject*> targetObject(aCx, nullptr);
  98   JS::Rooted<JSObject*> obj(aCx,
  99     aValue.isPrimitive() ? nullptr : aValue.toObjectOrNull());
 100
 101   while (tokenizer.hasMoreTokens()) {
 102     const nsDependentSubstring& token = tokenizer.nextToken();
 103
 104     NS_ASSERTION(!token.IsEmpty(), "Should be a valid keypath");
 105
 106     const jschar* keyPathChars = token.BeginReading();
 107     const size_t keyPathLen = token.Length();
 108
 109     bool hasProp;
 110     if (!targetObject) {
 111       // We're still walking the chain of existing objects
 112       if (!obj) {
 113         return NS_ERROR_DOM_INDEXEDDB_DATA_ERR;
 114       }
 115
 116       bool ok = JS_HasUCProperty(aCx, obj, keyPathChars, keyPathLen,
 117                                  &hasProp);
 118       IDB_ENSURE_TRUE(ok, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR);
 119
 120       if (hasProp) {
 121         // Get if the property exists...
 122         JS::Rooted<JS::Value> intermediate(aCx);
 123         bool ok = JS_GetUCProperty(aCx, obj, keyPathChars, keyPathLen, &intermediate);
 124         IDB_ENSURE_TRUE(ok, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR);
 125
 126         // Treat explicitly undefined as an error.
 127         if (intermediate == JSVAL_VOID) {
 128           return NS_ERROR_DOM_INDEXEDDB_DATA_ERR;
 129         }
 130         if (tokenizer.hasMoreTokens()) {
 131           // ...and walk to it if there are more steps...
 132           if (intermediate.isPrimitive()) {
 133             return NS_ERROR_DOM_INDEXEDDB_DATA_ERR;
 134           }
 135           obj = intermediate.toObjectOrNull();
 136         }
 137         else {
 138           // ...otherwise use it as key
 139           *aKeyJSVal = intermediate;
 140         }
 141       }
 142       else {
 143         // If the property doesn't exist, fall into below path of starting
 144         // to define properties, if allowed.
 145         if (aOptions == DoNotCreateProperties) {
 146           return NS_ERROR_DOM_INDEXEDDB_DATA_ERR;
 147         }
 148
 149         targetObject = obj;
 150         targetObjectPropName = token;
 151       }
 152     }
 153
 154     if (targetObject) {
 155       // We have started inserting new objects or are about to just insert
 156       // the first one.
 157
 158       *aKeyJSVal = JSVAL_VOID;
 159
 160       if (tokenizer.hasMoreTokens()) {
 161         // If we're not at the end, we need to add a dummy object to the
 162         // chain.
 163         JS::Rooted<JSObject*> dummy(aCx, JS_NewObject(aCx, nullptr, JS::NullPtr(),
 164                                                       JS::NullPtr()));
 165         if (!dummy) {
 166           IDB_REPORT_INTERNAL_ERR();
 167           rv = NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
 168           break;
 169         }
 170
 171         if (!JS_DefineUCProperty(aCx, obj, token.BeginReading(),
 172                                  token.Length(), dummy, JSPROP_ENUMERATE)) {
 173           IDB_REPORT_INTERNAL_ERR();
 174           rv = NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
 175           break;
 176         }
 177
 178         obj = dummy;
 179       }
 180       else {
 181         JS::Rooted<JSObject*> dummy(aCx, JS_NewObject(aCx, &IDBObjectStore::sDummyPropJSClass,
 182                                                       JS::NullPtr(), JS::NullPtr()));
 183         if (!dummy) {
 184           IDB_REPORT_INTERNAL_ERR();
 185           rv = NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
 186           break;
 187         }
 188
 189         if (!JS_DefineUCProperty(aCx, obj, token.BeginReading(),
 190                                  token.Length(), dummy, JSPROP_ENUMERATE)) {
 191           IDB_REPORT_INTERNAL_ERR();
 192           rv = NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
 193           break;
 194         }
 195
 196         obj = dummy;
 197       }
 198     }
 199   }
 200
 201   // We guard on rv being a success because we need to run the property
 202   // deletion code below even if we should not be running the callback.
 203   if (NS_SUCCEEDED(rv) && aCallback) {
 204     rv = (*aCallback)(aCx, aClosure);
 205   }
 206
 207   if (targetObject) {
 208     // If this fails, we lose, and the web page sees a magical property
 209     // appear on the object :-(
 210     bool succeeded;
 211     if (!JS_DeleteUCProperty2(aCx, targetObject,
 212                               targetObjectPropName.get(),
 213                               targetObjectPropName.Length(),
 214                               &succeeded)) {
 215       IDB_REPORT_INTERNAL_ERR();
 216       return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
 217     }
 218     IDB_ENSURE_TRUE(succeeded, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR);
 219   }
 220
 221   NS_ENSURE_SUCCESS(rv, rv);
 222   return rv;
 223 }
 224
 225 } // anonymous namespace
 226
 227 // static
 228 nsresult
 229 KeyPath::Parse(JSContext* aCx, const nsAString& aString, KeyPath* aKeyPath)
 230 {
 231   KeyPath keyPath(0);
 232   keyPath.SetType(STRING);
 233
 234   if (!keyPath.AppendStringWithValidation(aCx, aString)) {
 235     return NS_ERROR_FAILURE;
 236   }
 237
 238   *aKeyPath = keyPath;
 239   return NS_OK;
 240 }
 241
 242 //static
 243 nsresult
 244 KeyPath::Parse(JSContext* aCx, const mozilla::dom::Sequence<nsString>& aStrings,
 245                KeyPath* aKeyPath)
 246 {
 247   KeyPath keyPath(0);
 248   keyPath.SetType(ARRAY);
 249
 250   for (uint32_t i = 0; i < aStrings.Length(); ++i) {
 251     if (!keyPath.AppendStringWithValidation(aCx, aStrings[i])) {
 252       return NS_ERROR_FAILURE;
 253     }
 254   }
 255
 256   *aKeyPath = keyPath;
 257   return NS_OK;
 258 }
 259
 260 // static
 261 nsresult
 262 KeyPath::Parse(JSContext* aCx, const JS::Value& aValue_, KeyPath* aKeyPath)
 263 {
 264   JS::Rooted<JS::Value> aValue(aCx, aValue_);
 265   KeyPath keyPath(0);
 266
 267   aKeyPath->SetType(NONEXISTENT);
 268
 269   // See if this is a JS array.
 270   if (JS_IsArrayObject(aCx, aValue)) {
 271
 272     JS::Rooted<JSObject*> obj(aCx, aValue.toObjectOrNull());
 273
 274     uint32_t length;
 275     if (!JS_GetArrayLength(aCx, obj, &length)) {
 276       return NS_ERROR_FAILURE;
 277     }
 278
 279     if (!length) {
 280       return NS_ERROR_FAILURE;
 281     }
 282
 283     keyPath.SetType(ARRAY);
 284
 285     for (uint32_t index = 0; index < length; index++) {
 286       JS::Rooted<JS::Value> val(aCx);
 287       JSString* jsstr;
 288       nsAutoJSString str;
 289       if (!JS_GetElement(aCx, obj, index, &val) ||
 290           !(jsstr = JS::ToString(aCx, val)) ||
 291           !str.init(aCx, jsstr)) {
 292         return NS_ERROR_FAILURE;
 293       }
 294
 295       if (!keyPath.AppendStringWithValidation(aCx, str)) {
 296         return NS_ERROR_FAILURE;
 297       }
 298     }
 299   }
 300   // Otherwise convert it to a string.
 301   else if (!aValue.isNull() && !aValue.isUndefined()) {
 302     JSString* jsstr;
 303     nsAutoJSString str;
 304     if (!(jsstr = JS::ToString(aCx, aValue)) ||
 305         !str.init(aCx, jsstr)) {
 306       return NS_ERROR_FAILURE;
 307     }
 308
 309     keyPath.SetType(STRING);
 310
 311     if (!keyPath.AppendStringWithValidation(aCx, str)) {
 312       return NS_ERROR_FAILURE;
 313     }
 314   }
 315
 316   *aKeyPath = keyPath;
 317   return NS_OK;
 318 }
 319
 320 void
 321 KeyPath::SetType(KeyPathType aType)
 322 {
 323   mType = aType;
 324   mStrings.Clear();
 325 }
 326
 327 bool
 328 KeyPath::AppendStringWithValidation(JSContext* aCx, const nsAString& aString)
 329 {
 330   if (!IsValidKeyPathString(aCx, aString)) {
 331     return false;
 332   }
 333
 334   if (IsString()) {
 335     NS_ASSERTION(mStrings.Length() == 0, "Too many strings!");
 336     mStrings.AppendElement(aString);
 337     return true;
 338   }
 339
 340   if (IsArray()) {
 341     mStrings.AppendElement(aString);
 342     return true;
 343   }
 344
 345   NS_NOTREACHED("What?!");
 346   return false;
 347 }
 348
 349 nsresult
 350 KeyPath::ExtractKey(JSContext* aCx, const JS::Value& aValue, Key& aKey) const
 351 {
 352   uint32_t len = mStrings.Length();
 353   JS::Rooted<JS::Value> value(aCx);
 354
 355   aKey.Unset();
 356
 357   for (uint32_t i = 0; i < len; ++i) {
 358     nsresult rv = GetJSValFromKeyPathString(aCx, aValue, mStrings[i],
 359                                             value.address(),
 360                                             DoNotCreateProperties, nullptr,
 361                                             nullptr);
 362     if (NS_FAILED(rv)) {
 363       return rv;
 364     }
 365
 366     if (NS_FAILED(aKey.AppendItem(aCx, IsArray() && i == 0, value))) {
 367       NS_ASSERTION(aKey.IsUnset(), "Encoding error should unset");
 368       return NS_ERROR_DOM_INDEXEDDB_DATA_ERR;
 369     }
 370   }
 371
 372   aKey.FinishArray();
 373
 374   return NS_OK;
 375 }
 376
 377 nsresult
 378 KeyPath::ExtractKeyAsJSVal(JSContext* aCx, const JS::Value& aValue,
 379                            JS::Value* aOutVal) const
 380 {
 381   NS_ASSERTION(IsValid(), "This doesn't make sense!");
 382
 383   if (IsString()) {
 384     return GetJSValFromKeyPathString(aCx, aValue, mStrings[0], aOutVal,
 385                                      DoNotCreateProperties, nullptr, nullptr);
 386   }
 387
 388   const uint32_t len = mStrings.Length();
 389   JS::Rooted<JSObject*> arrayObj(aCx, JS_NewArrayObject(aCx, len));
 390   if (!arrayObj) {
 391     return NS_ERROR_OUT_OF_MEMORY;
 392   }
 393
 394   JS::Rooted<JS::Value> value(aCx);
 395   for (uint32_t i = 0; i < len; ++i) {
 396     nsresult rv = GetJSValFromKeyPathString(aCx, aValue, mStrings[i],
 397                                             value.address(),
 398                                             DoNotCreateProperties, nullptr,
 399                                             nullptr);
 400     if (NS_FAILED(rv)) {
 401       return rv;
 402     }
 403
 404     if (!JS_SetElement(aCx, arrayObj, i, value)) {
 405       IDB_REPORT_INTERNAL_ERR();
 406       return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
 407     }
 408   }
 409
 410   *aOutVal = OBJECT_TO_JSVAL(arrayObj);
 411   return NS_OK;
 412 }
 413
 414 nsresult
 415 KeyPath::ExtractOrCreateKey(JSContext* aCx, const JS::Value& aValue,
 416                             Key& aKey, ExtractOrCreateKeyCallback aCallback,
 417                             void* aClosure) const
 418 {
 419   NS_ASSERTION(IsString(), "This doesn't make sense!");
 420
 421   JS::Rooted<JS::Value> value(aCx);
 422
 423   aKey.Unset();
 424
 425   nsresult rv = GetJSValFromKeyPathString(aCx, aValue, mStrings[0],
 426                                           value.address(),
 427                                           CreateProperties, aCallback,
 428                                           aClosure);
 429   if (NS_FAILED(rv)) {
 430     return rv;
 431   }
 432
 433   if (NS_FAILED(aKey.AppendItem(aCx, false, value))) {
 434     NS_ASSERTION(aKey.IsUnset(), "Should be unset");
 435     return value.isUndefined() ? NS_OK : NS_ERROR_DOM_INDEXEDDB_DATA_ERR;
 436   }
 437
 438   aKey.FinishArray();
 439
 440   return NS_OK;
 441 }
 442
 443 void
 444 KeyPath::SerializeToString(nsAString& aString) const
 445 {
 446   NS_ASSERTION(IsValid(), "Check to see if I'm valid first!");
 447
 448   if (IsString()) {
 449     aString = mStrings[0];
 450     return;
 451   }
 452
 453   if (IsArray()) {
 454     // We use a comma in the beginning to indicate that it's an array of
 455     // key paths. This is to be able to tell a string-keypath from an
 456     // array-keypath which contains only one item.
 457     // It also makes serializing easier :-)
 458     uint32_t len = mStrings.Length();
 459     for (uint32_t i = 0; i < len; ++i) {
 460       aString.Append(',');
 461       aString.Append(mStrings[i]);
 462     }
 463
 464     return;
 465   }
 466
 467   NS_NOTREACHED("What?");
 468 }
 469
 470 // static
 471 KeyPath
 472 KeyPath::DeserializeFromString(const nsAString& aString)
 473 {
 474   KeyPath keyPath(0);
 475
 476   if (!aString.IsEmpty() && aString.First() == ',') {
 477     keyPath.SetType(ARRAY);
 478
 479     // We use a comma in the beginning to indicate that it's an array of
 480     // key paths. This is to be able to tell a string-keypath from an
 481     // array-keypath which contains only one item.
 482     nsCharSeparatedTokenizerTemplate<IgnoreWhitespace> tokenizer(aString, ',');
 483     tokenizer.nextToken();
 484     while (tokenizer.hasMoreTokens()) {
 485       keyPath.mStrings.AppendElement(tokenizer.nextToken());
 486     }
 487
 488     return keyPath;
 489   }
 490
 491   keyPath.SetType(STRING);
 492   keyPath.mStrings.AppendElement(aString);
 493
 494   return keyPath;
 495 }
 496
 497 nsresult
 498 KeyPath::ToJSVal(JSContext* aCx, JS::MutableHandle<JS::Value> aValue) const
 499 {
 500   if (IsArray()) {
 501     uint32_t len = mStrings.Length();
 502     JS::Rooted<JSObject*> array(aCx, JS_NewArrayObject(aCx, len));
 503     if (!array) {
 504       IDB_WARNING("Failed to make array!");
 505       return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
 506     }
 507
 508     for (uint32_t i = 0; i < len; ++i) {
 509       JS::Rooted<JS::Value> val(aCx);
 510       nsString tmp(mStrings[i]);
 511       if (!xpc::StringToJsval(aCx, tmp, &val)) {
 512         IDB_REPORT_INTERNAL_ERR();
 513         return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
 514       }
 515
 516       if (!JS_SetElement(aCx, array, i, val)) {
 517         IDB_REPORT_INTERNAL_ERR();
 518         return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
 519       }
 520     }
 521
 522     aValue.setObject(*array);
 523     return NS_OK;
 524   }
 525
 526   if (IsString()) {
 527     nsString tmp(mStrings[0]);
 528     if (!xpc::StringToJsval(aCx, tmp, aValue)) {
 529       IDB_REPORT_INTERNAL_ERR();
 530       return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
 531     }
 532     return NS_OK;
 533   }
 534
 535   aValue.setNull();
 536   return NS_OK;
 537 }
 538
 539 nsresult
 540 KeyPath::ToJSVal(JSContext* aCx, JS::Heap<JS::Value>& aValue) const
 541 {
 542   JS::Rooted<JS::Value> value(aCx);
 543   nsresult rv = ToJSVal(aCx, &value);
 544   if (NS_SUCCEEDED(rv)) {
 545     aValue = value;
 546   }
 547   return rv;
 548 }
 549
 550 bool
 551 KeyPath::IsAllowedForObjectStore(bool aAutoIncrement) const
 552 {
 553   // Any keypath that passed validation is allowed for non-autoIncrement
 554   // objectStores.
 555   if (!aAutoIncrement) {
 556     return true;
 557   }
 558
 559   // Array keypaths are not allowed for autoIncrement objectStores.
 560   if (IsArray()) {
 561     return false;
 562   }
 563
 564   // Neither are empty strings.
 565   if (IsEmpty()) {
 566     return false;
 567   }
 568
 569   // Everything else is ok.
 570   return true;
 571 }