dom/src/storage/nsDOMStorageMemoryDB.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* ***** BEGIN LICENSE BLOCK *****
   3  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   4  *
   5  * The contents of this file are subject to the Mozilla Public License Version
   6  * 1.1 (the "License"); you may not use this file except in compliance with
   7  * the License. You may obtain a copy of the License at
   8  * http://www.mozilla.org/MPL/
   9  *
  10  * Software distributed under the License is distributed on an "AS IS" basis,
  11  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12  * for the specific language governing rights and limitations under the
  13  * License.
  14  *
  15  * The Original Code is mozilla.org code.
  16  *
  17  * The Initial Developer of the Original Code is
  18  * Mozilla Corporation.
  19  * Portions created by the Initial Developer are Copyright (C) 2009
  20  * the Initial Developer. All Rights Reserved.
  21  *
  22  * Contributor(s):
  23  *   Neil Deakin <enndeakin@sympatico.ca>
  24  *   Honza Bambas <honzab@firemni.cz>
  25  *
  26  * Alternatively, the contents of this file may be used under the terms of
  27  * either of the GNU General Public License Version 2 or later (the "GPL"),
  28  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  29  * in which case the provisions of the GPL or the LGPL are applicable instead
  30  * of those above. If you wish to allow use of your version of this file only
  31  * under the terms of either the GPL or the LGPL, and not to allow others to
  32  * use your version of this file under the terms of the MPL, indicate your
  33  * decision by deleting the provisions above and replace them with the notice
  34  * and other provisions required by the GPL or the LGPL. If you do not delete
  35  * the provisions above, a recipient may use your version of this file under
  36  * the terms of any one of the MPL, the GPL or the LGPL.
  37  *
  38  * ***** END LICENSE BLOCK ***** */
  39
  40 #include "nsCOMPtr.h"
  41 #include "nsDOMError.h"
  42 #include "nsDOMStorage.h"
  43 #include "nsDOMStorageMemoryDB.h"
  44 #include "nsNetUtil.h"
  45
  46 nsresult
  47 nsDOMStorageMemoryDB::Init(nsDOMStoragePersistentDB* aPreloadDB)
  48 {
  49   if (!mData.Init(20))
  50     return NS_ERROR_OUT_OF_MEMORY;
  51
  52   mPreloadDB = aPreloadDB;
  53   return NS_OK;
  54 }
  55
  56 static PLDHashOperator
  57 AllKeyEnum(nsSessionStorageEntry* aEntry, void* userArg)
  58 {
  59   nsDOMStorageMemoryDB::nsStorageItemsTable *target =
  60       (nsDOMStorageMemoryDB::nsStorageItemsTable *)userArg;
  61
  62   nsDOMStorageMemoryDB::nsInMemoryItem* item =
  63       new nsDOMStorageMemoryDB::nsInMemoryItem();
  64   if (!item)
  65     return PL_DHASH_STOP;
  66
  67   aEntry->mItem->GetValue(item->mValue);
  68   nsresult rv = aEntry->mItem->GetSecure(&item->mSecure);
  69   if (NS_FAILED(rv))
  70     item->mSecure = PR_FALSE;
  71
  72   target->Put(aEntry->GetKey(), item);
  73   return PL_DHASH_NEXT;
  74 }
  75
  76 nsresult
  77 nsDOMStorageMemoryDB::GetItemsTable(nsDOMStorage* aStorage,
  78                                     nsInMemoryStorage** aMemoryStorage)
  79 {
  80   if (mData.Get(aStorage->GetScopeDBKey(), aMemoryStorage))
  81     return NS_OK;
  82
  83   *aMemoryStorage = nsnull;
  84
  85   nsInMemoryStorage* storageData = new nsInMemoryStorage();
  86   if (!storageData)
  87     return NS_ERROR_OUT_OF_MEMORY;
  88
  89   if (!storageData->mTable.Init()) {
  90     delete storageData;
  91     return NS_ERROR_OUT_OF_MEMORY;
  92   }
  93
  94   if (mPreloadDB) {
  95     nsresult rv;
  96
  97     nsTHashtable<nsSessionStorageEntry> keys;
  98     keys.Init();
  99
 100     rv = mPreloadDB->GetAllKeys(aStorage, &keys);
 101     NS_ENSURE_SUCCESS(rv, rv);
 102
 103     mPreloading = PR_TRUE;
 104     keys.EnumerateEntries(AllKeyEnum, &storageData->mTable);
 105     mPreloading = PR_FALSE;
 106   }
 107
 108   mData.Put(aStorage->GetScopeDBKey(), storageData);
 109   *aMemoryStorage = storageData;
 110
 111   return NS_OK;
 112 }
 113
 114 struct GetAllKeysEnumStruc
 115 {
 116   nsTHashtable<nsSessionStorageEntry>* mTarget;
 117   nsDOMStorage* mStorage;
 118 };
 119
 120 static PLDHashOperator
 121 GetAllKeysEnum(const nsAString& keyname,
 122                nsDOMStorageMemoryDB::nsInMemoryItem* item,
 123                void *closure)
 124 {
 125   GetAllKeysEnumStruc* struc = (GetAllKeysEnumStruc*)closure;
 126
 127   nsSessionStorageEntry* entry = struc->mTarget->PutEntry(keyname);
 128   if (!entry)
 129     return PL_DHASH_STOP;
 130
 131   entry->mItem = new nsDOMStorageItem(struc->mStorage,
 132                                       keyname,
 133                                       EmptyString(),
 134                                       item->mSecure);
 135   if (!entry->mItem)
 136     return PL_DHASH_STOP;
 137
 138   return PL_DHASH_NEXT;
 139 }
 140
 141 nsresult
 142 nsDOMStorageMemoryDB::GetAllKeys(nsDOMStorage* aStorage,
 143                                  nsTHashtable<nsSessionStorageEntry>* aKeys)
 144 {
 145   nsresult rv;
 146
 147   nsInMemoryStorage* storage;
 148   rv = GetItemsTable(aStorage, &storage);
 149   NS_ENSURE_SUCCESS(rv, rv);
 150
 151   GetAllKeysEnumStruc struc;
 152   struc.mTarget = aKeys;
 153   struc.mStorage = aStorage;
 154   storage->mTable.EnumerateRead(GetAllKeysEnum, &struc);
 155
 156   return NS_OK;
 157 }
 158
 159 nsresult
 160 nsDOMStorageMemoryDB::GetKeyValue(nsDOMStorage* aStorage,
 161                                   const nsAString& aKey,
 162                                   nsAString& aValue,
 163                                   PRBool* aSecure)
 164 {
 165   if (mPreloading) {
 166     NS_PRECONDITION(mPreloadDB, "Must have a preload DB set when preloading");
 167     return mPreloadDB->GetKeyValue(aStorage, aKey, aValue, aSecure);
 168   }
 169
 170   nsresult rv;
 171
 172   nsInMemoryStorage* storage;
 173   rv = GetItemsTable(aStorage, &storage);
 174   NS_ENSURE_SUCCESS(rv, rv);
 175
 176   nsInMemoryItem* item;
 177   if (!storage->mTable.Get(aKey, &item))
 178     return NS_ERROR_DOM_NOT_FOUND_ERR;
 179
 180   aValue = item->mValue;
 181   *aSecure = item->mSecure;
 182   return NS_OK;
 183 }
 184
 185 nsresult
 186 nsDOMStorageMemoryDB::SetKey(nsDOMStorage* aStorage,
 187                              const nsAString& aKey,
 188                              const nsAString& aValue,
 189                              PRBool aSecure,
 190                              PRInt32 aQuota,
 191                              PRBool aExcludeOfflineFromUsage,
 192                              PRInt32 *aNewUsage)
 193 {
 194   nsresult rv;
 195
 196   nsInMemoryStorage* storage;
 197   rv = GetItemsTable(aStorage, &storage);
 198   NS_ENSURE_SUCCESS(rv, rv);
 199
 200   PRInt32 usage = 0;
 201   if (!aStorage->GetQuotaDomainDBKey(!aExcludeOfflineFromUsage).IsEmpty()) {
 202     rv = GetUsage(aStorage, aExcludeOfflineFromUsage, &usage);
 203     NS_ENSURE_SUCCESS(rv, rv);
 204   }
 205
 206   usage += aKey.Length() + aValue.Length();
 207
 208   nsInMemoryItem* item;
 209   if (!storage->mTable.Get(aKey, &item)) {
 210     if (usage > aQuota) {
 211       return NS_ERROR_DOM_QUOTA_REACHED;
 212     }
 213
 214     item = new nsInMemoryItem();
 215     if (!item)
 216       return NS_ERROR_OUT_OF_MEMORY;
 217
 218     storage->mTable.Put(aKey, item);
 219     storage->mUsageDelta += aKey.Length();
 220   }
 221   else
 222   {
 223     usage -= aKey.Length() + item->mValue.Length();
 224     if (usage > aQuota) {
 225       return NS_ERROR_DOM_QUOTA_REACHED;
 226     }
 227   }
 228
 229   storage->mUsageDelta += aValue.Length() - item->mValue.Length();
 230
 231   item->mValue = aValue;
 232   item->mSecure = aSecure;
 233
 234   *aNewUsage = usage;
 235
 236   return NS_OK;
 237 }
 238
 239 nsresult
 240 nsDOMStorageMemoryDB::SetSecure(nsDOMStorage* aStorage,
 241                                 const nsAString& aKey,
 242                                 const PRBool aSecure)
 243 {
 244   nsresult rv;
 245
 246   nsInMemoryStorage* storage;
 247   rv = GetItemsTable(aStorage, &storage);
 248   NS_ENSURE_SUCCESS(rv, rv);
 249
 250   nsInMemoryItem* item;
 251   if (!storage->mTable.Get(aKey, &item))
 252     return NS_ERROR_DOM_NOT_FOUND_ERR;
 253
 254   item->mSecure = aSecure;
 255
 256   return NS_OK;
 257 }
 258
 259 nsresult
 260 nsDOMStorageMemoryDB::RemoveKey(nsDOMStorage* aStorage,
 261                                 const nsAString& aKey,
 262                                 PRBool aExcludeOfflineFromUsage,
 263                                 PRInt32 aKeyUsage)
 264 {
 265   nsresult rv;
 266
 267   nsInMemoryStorage* storage;
 268   rv = GetItemsTable(aStorage, &storage);
 269   NS_ENSURE_SUCCESS(rv, rv);
 270
 271   nsInMemoryItem* item;
 272   if (!storage->mTable.Get(aKey, &item))
 273     return NS_ERROR_DOM_NOT_FOUND_ERR;
 274
 275   storage->mUsageDelta -= aKey.Length() + item->mValue.Length();
 276   storage->mTable.Remove(aKey);
 277
 278   return NS_OK;
 279 }
 280
 281 static PLDHashOperator
 282 RemoveAllKeysEnum(const nsAString& keyname,
 283                   nsAutoPtr<nsDOMStorageMemoryDB::nsInMemoryItem>& item,
 284                   void *closure)
 285 {
 286   nsDOMStorageMemoryDB::nsInMemoryStorage* storage =
 287       (nsDOMStorageMemoryDB::nsInMemoryStorage*)closure;
 288
 289   storage->mUsageDelta -= keyname.Length() + item->mValue.Length();
 290   return PL_DHASH_REMOVE;
 291 }
 292
 293 nsresult
 294 nsDOMStorageMemoryDB::ClearStorage(nsDOMStorage* aStorage)
 295 {
 296   nsresult rv;
 297
 298   nsInMemoryStorage* storage;
 299   rv = GetItemsTable(aStorage, &storage);
 300   NS_ENSURE_SUCCESS(rv, rv);
 301
 302   storage->mTable.Enumerate(RemoveAllKeysEnum, storage);
 303   return NS_OK;
 304 }
 305
 306 nsresult
 307 nsDOMStorageMemoryDB::DropStorage(nsDOMStorage* aStorage)
 308 {
 309   mData.Remove(aStorage->GetScopeDBKey());
 310   return NS_OK;
 311 }
 312
 313 struct RemoveOwnersStruc
 314 {
 315   nsCString* mSubDomain;
 316   PRBool mMatch;
 317 };
 318
 319 static PLDHashOperator
 320 RemoveOwnersEnum(const nsACString& key,
 321                  nsAutoPtr<nsDOMStorageMemoryDB::nsInMemoryStorage>& storage,
 322                  void *closure)
 323 {
 324   RemoveOwnersStruc* struc = (RemoveOwnersStruc*)closure;
 325
 326   if (StringBeginsWith(key, *(struc->mSubDomain)) == struc->mMatch)
 327     return PL_DHASH_REMOVE;
 328
 329   return PL_DHASH_NEXT;
 330 }
 331
 332 nsresult
 333 nsDOMStorageMemoryDB::RemoveOwner(const nsACString& aOwner,
 334                                   PRBool aIncludeSubDomains)
 335 {
 336   nsCAutoString subdomainsDBKey;
 337   nsDOMStorageDBWrapper::CreateDomainScopeDBKey(aOwner, subdomainsDBKey);
 338
 339   if (!aIncludeSubDomains)
 340     subdomainsDBKey.AppendLiteral(":");
 341
 342   RemoveOwnersStruc struc;
 343   struc.mSubDomain = &subdomainsDBKey;
 344   struc.mMatch = PR_TRUE;
 345   mData.Enumerate(RemoveOwnersEnum, &struc);
 346
 347   return NS_OK;
 348 }
 349
 350
 351 nsresult
 352 nsDOMStorageMemoryDB::RemoveOwners(const nsTArray<nsString> &aOwners,
 353                                    PRBool aIncludeSubDomains,
 354                                    PRBool aMatch)
 355 {
 356   if (aOwners.Length() == 0) {
 357     if (aMatch) {
 358       return NS_OK;
 359     }
 360
 361     return RemoveAll();
 362   }
 363
 364   for (PRUint32 i = 0; i < aOwners.Length(); i++) {
 365     nsCAutoString quotaKey;
 366     nsresult rv;
 367     rv = nsDOMStorageDBWrapper::CreateDomainScopeDBKey(
 368       NS_ConvertUTF16toUTF8(aOwners[i]), quotaKey);
 369
 370     if (!aIncludeSubDomains)
 371       quotaKey.AppendLiteral(":");
 372
 373     RemoveOwnersStruc struc;
 374     struc.mSubDomain = &quotaKey;
 375     struc.mMatch = aMatch;
 376     mData.Enumerate(RemoveOwnersEnum, &struc);
 377   }
 378
 379   return NS_OK;
 380 }
 381
 382 nsresult
 383 nsDOMStorageMemoryDB::RemoveAll()
 384 {
 385   mData.Clear(); // XXX Check this releases all instances
 386   return NS_OK;
 387 }
 388
 389 nsresult
 390 nsDOMStorageMemoryDB::GetUsage(nsDOMStorage* aStorage,
 391                                PRBool aExcludeOfflineFromUsage, PRInt32 *aUsage)
 392 {
 393   return GetUsageInternal(aStorage->GetQuotaDomainDBKey(!aExcludeOfflineFromUsage),
 394                           aExcludeOfflineFromUsage, aUsage);
 395 }
 396
 397 nsresult
 398 nsDOMStorageMemoryDB::GetUsage(const nsACString& aDomain,
 399                                PRBool aIncludeSubDomains,
 400                                PRInt32 *aUsage)
 401 {
 402   nsresult rv;
 403
 404   nsCAutoString quotadomainDBKey;
 405   rv = nsDOMStorageDBWrapper::CreateQuotaDomainDBKey(aDomain,
 406                                                      aIncludeSubDomains,
 407                                                      PR_FALSE,
 408                                                      quotadomainDBKey);
 409   NS_ENSURE_SUCCESS(rv, rv);
 410
 411   return GetUsageInternal(quotadomainDBKey, PR_FALSE, aUsage);
 412 }
 413
 414 struct GetUsageEnumStruc
 415 {
 416   PRInt32 mUsage;
 417   PRInt32 mExcludeOfflineFromUsage;
 418   nsCString mSubdomain;
 419 };
 420
 421 static PLDHashOperator
 422 GetUsageEnum(const nsACString& key,
 423              nsDOMStorageMemoryDB::nsInMemoryStorage* storageData,
 424              void *closure)
 425 {
 426   GetUsageEnumStruc* struc = (GetUsageEnumStruc*)closure;
 427
 428   if (StringBeginsWith(key, struc->mSubdomain)) {
 429     if (struc->mExcludeOfflineFromUsage) {
 430       nsCAutoString domain;
 431       nsresult rv = nsDOMStorageDBWrapper::GetDomainFromScopeKey(key, domain);
 432       if (NS_SUCCEEDED(rv) && IsOfflineAllowed(domain))
 433         return PL_DHASH_NEXT;
 434     }
 435
 436     struc->mUsage += storageData->mUsageDelta;
 437   }
 438
 439   return PL_DHASH_NEXT;
 440 }
 441
 442 nsresult
 443 nsDOMStorageMemoryDB::GetUsageInternal(const nsACString& aQuotaDomainDBKey,
 444                                        PRBool aExcludeOfflineFromUsage,
 445                                        PRInt32 *aUsage)
 446 {
 447   GetUsageEnumStruc struc;
 448   struc.mUsage = 0;
 449   struc.mExcludeOfflineFromUsage = aExcludeOfflineFromUsage;
 450   struc.mSubdomain = aQuotaDomainDBKey;
 451
 452   if (mPreloadDB) {
 453     nsresult rv;
 454
 455     rv = mPreloadDB->GetUsageInternal(aQuotaDomainDBKey,
 456                                       aExcludeOfflineFromUsage, &struc.mUsage);
 457     NS_ENSURE_SUCCESS(rv, rv);
 458   }
 459
 460   mData.EnumerateRead(GetUsageEnum, &struc);
 461
 462   *aUsage = struc.mUsage;
 463   return NS_OK;
 464 }