dom/fs/api/FileSystemHandle.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=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 "FileSystemHandle.h"
   8
   9 #include "FileSystemDirectoryHandle.h"
  10 #include "FileSystemFileHandle.h"
  11 #include "fs/FileSystemRequestHandler.h"
  12 #include "js/StructuredClone.h"
  13 #include "mozilla/ErrorResult.h"
  14 #include "mozilla/dom/FileSystemHandleBinding.h"
  15 #include "mozilla/dom/FileSystemLog.h"
  16 #include "mozilla/dom/FileSystemManager.h"
  17 #include "mozilla/dom/Promise-inl.h"
  18 #include "mozilla/dom/Promise.h"
  19 #include "mozilla/dom/StorageManager.h"
  20 #include "mozilla/dom/StructuredCloneHolder.h"
  21 #include "mozilla/dom/quota/QuotaCommon.h"
  22 #include "mozilla/ipc/PBackgroundSharedTypes.h"
  23 #include "nsJSPrincipals.h"
  24 #include "nsString.h"
  25 #include "prio.h"
  26 #include "private/pprio.h"
  27 #include "xpcpublic.h"
  28
  29 namespace mozilla::dom {
  30
  31 namespace {
  32
  33 bool ConstructHandleMetadata(JSContext* aCx, nsIGlobalObject* aGlobal,
  34                              JSStructuredCloneReader* aReader,
  35                              const bool aDirectory,
  36                              fs::FileSystemEntryMetadata& aMetadata) {
  37   using namespace mozilla::dom::fs;
  38
  39   EntryId entryId;
  40   if (!entryId.SetLength(32u, fallible)) {
  41     return false;
  42   }
  43
  44   if (!JS_ReadBytes(aReader, static_cast<void*>(entryId.BeginWriting()), 32u)) {
  45     return false;
  46   }
  47
  48   Name name;
  49   if (!StructuredCloneHolder::ReadString(aReader, name)) {
  50     return false;
  51   }
  52
  53   mozilla::ipc::PrincipalInfo storageKey;
  54   if (!nsJSPrincipals::ReadPrincipalInfo(aReader, storageKey)) {
  55     return false;
  56   }
  57
  58   QM_TRY_UNWRAP(auto hasEqualStorageKey,
  59                 aGlobal->HasEqualStorageKey(storageKey), false);
  60
  61   if (!hasEqualStorageKey) {
  62     LOG(("Blocking deserialization of %s due to cross-origin",
  63          NS_ConvertUTF16toUTF8(name).get()));
  64     return false;
  65   }
  66
  67   LOG_VERBOSE(("Deserializing %s", NS_ConvertUTF16toUTF8(name).get()));
  68
  69   aMetadata = fs::FileSystemEntryMetadata(entryId, name, aDirectory);
  70   return true;
  71 }
  72
  73 }  // namespace
  74
  75 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(FileSystemHandle)
  76   NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
  77   NS_INTERFACE_MAP_ENTRY(nsISupports)
  78 NS_INTERFACE_MAP_END
  79
  80 NS_IMPL_CYCLE_COLLECTING_ADDREF(FileSystemHandle)
  81 NS_IMPL_CYCLE_COLLECTING_RELEASE(FileSystemHandle)
  82
  83 NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(FileSystemHandle)
  84 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(FileSystemHandle)
  85   NS_IMPL_CYCLE_COLLECTION_UNLINK(mGlobal)
  86   // Don't unlink mManager!
  87   NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER
  88 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
  89 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(FileSystemHandle)
  90   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mGlobal)
  91   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mManager)
  92 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
  93
  94 FileSystemHandle::FileSystemHandle(
  95     nsIGlobalObject* aGlobal, RefPtr<FileSystemManager>& aManager,
  96     const fs::FileSystemEntryMetadata& aMetadata,
  97     fs::FileSystemRequestHandler* aRequestHandler)
  98     : mGlobal(aGlobal),
  99       mManager(aManager),
 100       mMetadata(aMetadata),
 101       mRequestHandler(aRequestHandler) {
 102   MOZ_ASSERT(!mMetadata.entryId().IsEmpty());
 103 }
 104
 105 // WebIDL Boilerplate
 106
 107 nsIGlobalObject* FileSystemHandle::GetParentObject() const { return mGlobal; }
 108
 109 JSObject* FileSystemHandle::WrapObject(JSContext* aCx,
 110                                        JS::Handle<JSObject*> aGivenProto) {
 111   return FileSystemHandle_Binding::Wrap(aCx, this, aGivenProto);
 112 }
 113
 114 // WebIDL Interface
 115
 116 void FileSystemHandle::GetName(nsAString& aResult) {
 117   aResult = mMetadata.entryName();
 118 }
 119
 120 already_AddRefed<Promise> FileSystemHandle::IsSameEntry(
 121     FileSystemHandle& aOther, ErrorResult& aError) const {
 122   RefPtr<Promise> promise = Promise::Create(GetParentObject(), aError);
 123   if (aError.Failed()) {
 124     return nullptr;
 125   }
 126
 127   // Handles the case of "dir = createdir foo; removeEntry(foo); file =
 128   // createfile foo; issameentry(dir, file)"
 129   const bool result = mMetadata.entryId().Equals(aOther.mMetadata.entryId()) &&
 130                       Kind() == aOther.Kind();
 131   promise->MaybeResolve(result);
 132
 133   return promise.forget();
 134 }
 135
 136 already_AddRefed<Promise> FileSystemHandle::Move(const nsAString& aName,
 137                                                  ErrorResult& aError) {
 138   LOG(("Move %s to %s", NS_ConvertUTF16toUTF8(mMetadata.entryName()).get(),
 139        NS_ConvertUTF16toUTF8(aName).get()));
 140
 141   fs::EntryId parent;  // empty means same directory
 142   return Move(parent, aName, aError);
 143 }
 144
 145 already_AddRefed<Promise> FileSystemHandle::Move(
 146     FileSystemDirectoryHandle& aParent, ErrorResult& aError) {
 147   LOG(("Move %s to %s/%s", NS_ConvertUTF16toUTF8(mMetadata.entryName()).get(),
 148        NS_ConvertUTF16toUTF8(aParent.mMetadata.entryName()).get(),
 149        NS_ConvertUTF16toUTF8(mMetadata.entryName()).get()));
 150   return Move(aParent, mMetadata.entryName(), aError);
 151 }
 152
 153 already_AddRefed<Promise> FileSystemHandle::Move(
 154     FileSystemDirectoryHandle& aParent, const nsAString& aName,
 155     ErrorResult& aError) {
 156   LOG(("Move %s to %s/%s", NS_ConvertUTF16toUTF8(mMetadata.entryName()).get(),
 157        NS_ConvertUTF16toUTF8(aParent.mMetadata.entryName()).get(),
 158        NS_ConvertUTF16toUTF8(aName).get()));
 159   return Move(aParent.mMetadata.entryId(), aName, aError);
 160 }
 161
 162 already_AddRefed<Promise> FileSystemHandle::Move(const fs::EntryId& aParentId,
 163                                                  const nsAString& aName,
 164                                                  ErrorResult& aError) {
 165   RefPtr<Promise> promise = Promise::Create(GetParentObject(), aError);
 166   if (aError.Failed()) {
 167     return nullptr;
 168   }
 169
 170   fs::FileSystemChildMetadata newMetadata;
 171   newMetadata.parentId() = aParentId;
 172   newMetadata.childName() = aName;
 173   if (!aParentId.IsEmpty()) {
 174     mRequestHandler->MoveEntry(mManager, this, &mMetadata, newMetadata, promise,
 175                                aError);
 176   } else {
 177     mRequestHandler->RenameEntry(mManager, this, &mMetadata,
 178                                  newMetadata.childName(), promise, aError);
 179   }
 180   if (aError.Failed()) {
 181     return nullptr;
 182   }
 183
 184   // Other handles to this will be broken, and the spec is ok with this, but we
 185   // need to update our EntryId and name
 186   promise->AddCallbacksWithCycleCollectedArgs(
 187       [newMetadata](JSContext* aCx, JS::Handle<JS::Value> aValue,
 188                     ErrorResult& aRv, FileSystemHandle* aHandle) {
 189         // XXX Fix entryId!
 190         LOG(("Changing FileSystemHandle name from %s to %s",
 191              NS_ConvertUTF16toUTF8(aHandle->mMetadata.entryName()).get(),
 192              NS_ConvertUTF16toUTF8(newMetadata.childName()).get()));
 193         aHandle->mMetadata.entryName() = newMetadata.childName();
 194       },
 195       [](JSContext* aCx, JS::Handle<JS::Value> aValue, ErrorResult& aRv,
 196          FileSystemHandle* aHandle) {
 197         LOG(("reject of move for %s",
 198              NS_ConvertUTF16toUTF8(aHandle->mMetadata.entryName()).get()));
 199       },
 200       RefPtr(this));
 201
 202   return promise.forget();
 203 }
 204
 205 // [Serializable] implementation
 206
 207 // static
 208 already_AddRefed<FileSystemHandle> FileSystemHandle::ReadStructuredClone(
 209     JSContext* aCx, nsIGlobalObject* aGlobal,
 210     JSStructuredCloneReader* aReader) {
 211   LOG_VERBOSE(("Reading File/DirectoryHandle"));
 212
 213   uint32_t kind = UINT32_MAX;
 214
 215   if (!JS_ReadBytes(aReader, reinterpret_cast<void*>(&kind),
 216                     sizeof(uint32_t))) {
 217     return nullptr;
 218   }
 219
 220   if (kind == static_cast<uint32_t>(FileSystemHandleKind::Directory)) {
 221     RefPtr<FileSystemHandle> result =
 222         FileSystemHandle::ConstructDirectoryHandle(aCx, aGlobal, aReader);
 223     return result.forget();
 224   }
 225
 226   if (kind == static_cast<uint32_t>(FileSystemHandleKind::File)) {
 227     RefPtr<FileSystemHandle> result =
 228         FileSystemHandle::ConstructFileHandle(aCx, aGlobal, aReader);
 229     return result.forget();
 230   }
 231
 232   return nullptr;
 233 }
 234
 235 bool FileSystemHandle::WriteStructuredClone(
 236     JSContext* aCx, JSStructuredCloneWriter* aWriter) const {
 237   LOG_VERBOSE(("Writing File/DirectoryHandle"));
 238   MOZ_ASSERT(mMetadata.entryId().Length() == 32);
 239
 240   auto kind = static_cast<uint32_t>(Kind());
 241   if (NS_WARN_IF(!JS_WriteBytes(aWriter, static_cast<void*>(&kind),
 242                                 sizeof(uint32_t)))) {
 243     return false;
 244   }
 245
 246   if (NS_WARN_IF(!JS_WriteBytes(
 247           aWriter, static_cast<const void*>(mMetadata.entryId().get()),
 248           mMetadata.entryId().Length()))) {
 249     return false;
 250   }
 251
 252   if (!StructuredCloneHolder::WriteString(aWriter, mMetadata.entryName())) {
 253     return false;
 254   }
 255
 256   // Needed to make sure the destination nsIGlobalObject is from the same
 257   // origin/principal
 258   QM_TRY_INSPECT(const auto& storageKey, mGlobal->GetStorageKey(), false);
 259
 260   return nsJSPrincipals::WritePrincipalInfo(aWriter, storageKey);
 261 }
 262
 263 // static
 264 already_AddRefed<FileSystemFileHandle> FileSystemHandle::ConstructFileHandle(
 265     JSContext* aCx, nsIGlobalObject* aGlobal,
 266     JSStructuredCloneReader* aReader) {
 267   LOG(("Reading FileHandle"));
 268
 269   fs::FileSystemEntryMetadata metadata;
 270   if (!ConstructHandleMetadata(aCx, aGlobal, aReader, /* aDirectory */ false,
 271                                metadata)) {
 272     return nullptr;
 273   }
 274
 275   RefPtr<StorageManager> storageManager = aGlobal->GetStorageManager();
 276   if (!storageManager) {
 277     return nullptr;
 278   }
 279
 280   // Note that the actor may not exist or may not be connected yet.
 281   RefPtr<FileSystemManager> fileSystemManager =
 282       storageManager->GetFileSystemManager();
 283
 284   RefPtr<FileSystemFileHandle> fsHandle =
 285       new FileSystemFileHandle(aGlobal, fileSystemManager, metadata);
 286
 287   return fsHandle.forget();
 288 }
 289
 290 // static
 291 already_AddRefed<FileSystemDirectoryHandle>
 292 FileSystemHandle::ConstructDirectoryHandle(JSContext* aCx,
 293                                            nsIGlobalObject* aGlobal,
 294                                            JSStructuredCloneReader* aReader) {
 295   LOG(("Reading DirectoryHandle"));
 296
 297   fs::FileSystemEntryMetadata metadata;
 298   if (!ConstructHandleMetadata(aCx, aGlobal, aReader, /* aDirectory */ true,
 299                                metadata)) {
 300     return nullptr;
 301   }
 302
 303   RefPtr<StorageManager> storageManager = aGlobal->GetStorageManager();
 304   if (!storageManager) {
 305     return nullptr;
 306   }
 307
 308   // Note that the actor may not exist or may not be connected yet.
 309   RefPtr<FileSystemManager> fileSystemManager =
 310       storageManager->GetFileSystemManager();
 311
 312   RefPtr<FileSystemDirectoryHandle> fsHandle =
 313       new FileSystemDirectoryHandle(aGlobal, fileSystemManager, metadata);
 314
 315   return fsHandle.forget();
 316 }
 317
 318 }  // namespace mozilla::dom