xpcom/io/FileDescriptorFile.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 "FileDescriptorFile.h"
   8
   9 #include "mozilla/ipc/FileDescriptorUtils.h"
  10 #include "mozilla/ipc/URIUtils.h"
  11 #include "mozilla/net/NeckoChild.h"
  12 #include "nsNetUtil.h"
  13 #include "nsProxyRelease.h"
  14 #include "nsThreadUtils.h"
  15 #include "private/pprio.h"
  16 #include "SerializedLoadContext.h"
  17
  18 namespace mozilla {
  19 namespace net {
  20
  21 NS_IMPL_ISUPPORTS(FileDescriptorFile, nsIFile)
  22
  23 LazyLogModule gFDFileLog("FDFile");
  24 #undef DBG
  25 #define DBG(...) MOZ_LOG(gFDFileLog, LogLevel::Debug, (__VA_ARGS__))
  26
  27 FileDescriptorFile::FileDescriptorFile(const FileDescriptor& aFD,
  28                                        nsIFile* aFile) {
  29   MOZ_ASSERT(aFD.IsValid());
  30   auto platformHandle = aFD.ClonePlatformHandle();
  31   mFD = FileDescriptor(platformHandle.get());
  32   mFile = aFile;
  33 }
  34
  35 FileDescriptorFile::FileDescriptorFile(const FileDescriptorFile& aOther) {
  36   auto platformHandle = aOther.mFD.ClonePlatformHandle();
  37   mFD = FileDescriptor(platformHandle.get());
  38   aOther.mFile->Clone(getter_AddRefs(mFile));
  39 }
  40
  41 //-----------------------------------------------------------------------------
  42 // FileDescriptorFile::nsIFile functions that we override logic for
  43 //-----------------------------------------------------------------------------
  44
  45 NS_IMETHODIMP
  46 FileDescriptorFile::Clone(nsIFile** aFileOut) {
  47   RefPtr<FileDescriptorFile> fdFile = new FileDescriptorFile(*this);
  48   fdFile.forget(aFileOut);
  49   return NS_OK;
  50 }
  51
  52 NS_IMETHODIMP
  53 FileDescriptorFile::OpenNSPRFileDesc(int32_t aFlags, int32_t aMode,
  54                                      PRFileDesc** aRetval) {
  55   // Remove optional OS_READAHEAD flag so we test against PR_RDONLY
  56   aFlags &= ~nsIFile::OS_READAHEAD;
  57
  58   // Remove optional/deprecated DELETE_ON_CLOSE flag
  59   aFlags &= ~nsIFile::DELETE_ON_CLOSE;
  60
  61   // All other flags require write access to the file and
  62   // this implementation only provides read access.
  63   if (aFlags != PR_RDONLY) {
  64     DBG("OpenNSPRFileDesc flags error (%" PRIu32 ")\n", aFlags);
  65     return NS_ERROR_NOT_AVAILABLE;
  66   }
  67
  68   if (!mFD.IsValid()) {
  69     DBG("OpenNSPRFileDesc error: no file descriptor\n");
  70     return NS_ERROR_NOT_AVAILABLE;
  71   }
  72
  73   auto platformHandle = mFD.ClonePlatformHandle();
  74   *aRetval = PR_ImportFile(PROsfd(platformHandle.release()));
  75
  76   if (!*aRetval) {
  77     DBG("OpenNSPRFileDesc Clone failure\n");
  78     return NS_ERROR_NOT_AVAILABLE;
  79   }
  80
  81   return NS_OK;
  82 }
  83
  84 //-----------------------------------------------------------------------------
  85 // FileDescriptorFile::nsIFile functions that we delegate to underlying nsIFile
  86 //-----------------------------------------------------------------------------
  87
  88 nsresult FileDescriptorFile::GetLeafName(nsAString& aLeafName) {
  89   return mFile->GetLeafName(aLeafName);
  90 }
  91
  92 NS_IMETHODIMP
  93 FileDescriptorFile::GetNativeLeafName(nsACString& aLeafName) {
  94   return mFile->GetNativeLeafName(aLeafName);
  95 }
  96
  97 NS_IMETHODIMP FileDescriptorFile::GetDisplayName(nsAString& aLeafName) {
  98   return mFile->GetDisplayName(aLeafName);
  99 }
 100
 101 nsresult FileDescriptorFile::GetTarget(nsAString& aRetVal) {
 102   return mFile->GetTarget(aRetVal);
 103 }
 104
 105 NS_IMETHODIMP
 106 FileDescriptorFile::GetNativeTarget(nsACString& aRetVal) {
 107   return mFile->GetNativeTarget(aRetVal);
 108 }
 109
 110 nsresult FileDescriptorFile::GetPath(nsAString& aRetVal) {
 111   return mFile->GetPath(aRetVal);
 112 }
 113
 114 PathString FileDescriptorFile::NativePath() { return mFile->NativePath(); }
 115
 116 NS_IMETHODIMP
 117 FileDescriptorFile::Equals(nsIFile* aOther, bool* aRetVal) {
 118   return mFile->Equals(aOther, aRetVal);
 119 }
 120
 121 NS_IMETHODIMP
 122 FileDescriptorFile::Contains(nsIFile* aOther, bool* aRetVal) {
 123   return mFile->Contains(aOther, aRetVal);
 124 }
 125
 126 NS_IMETHODIMP
 127 FileDescriptorFile::GetParent(nsIFile** aParent) {
 128   return mFile->GetParent(aParent);
 129 }
 130
 131 NS_IMETHODIMP
 132 FileDescriptorFile::GetPersistentDescriptor(nsACString& aPersistentDescriptor) {
 133   return mFile->GetPersistentDescriptor(aPersistentDescriptor);
 134 }
 135
 136 //-----------------------------------------------------------------------------
 137 // FileDescriptorFile::nsIFile functions that are not currently supported
 138 //-----------------------------------------------------------------------------
 139
 140 nsresult FileDescriptorFile::Append(const nsAString& aNode) {
 141   return NS_ERROR_NOT_IMPLEMENTED;
 142 }
 143
 144 NS_IMETHODIMP
 145 FileDescriptorFile::AppendNative(const nsACString& aFragment) {
 146   return NS_ERROR_NOT_IMPLEMENTED;
 147 }
 148
 149 NS_IMETHODIMP
 150 FileDescriptorFile::Normalize() { return NS_ERROR_NOT_IMPLEMENTED; }
 151
 152 NS_IMETHODIMP
 153 FileDescriptorFile::Create(uint32_t aType, uint32_t aPermissions,
 154                            bool aSkipAncestors) {
 155   return NS_ERROR_NOT_IMPLEMENTED;
 156 }
 157
 158 nsresult FileDescriptorFile::SetLeafName(const nsAString& aLeafName) {
 159   return NS_ERROR_NOT_IMPLEMENTED;
 160 }
 161
 162 NS_IMETHODIMP
 163 FileDescriptorFile::SetNativeLeafName(const nsACString& aLeafName) {
 164   return NS_ERROR_NOT_IMPLEMENTED;
 165 }
 166
 167 nsresult FileDescriptorFile::InitWithPath(const nsAString& aPath) {
 168   return NS_ERROR_NOT_IMPLEMENTED;
 169 }
 170
 171 NS_IMETHODIMP
 172 FileDescriptorFile::InitWithNativePath(const nsACString& aPath) {
 173   return NS_ERROR_NOT_IMPLEMENTED;
 174 }
 175
 176 NS_IMETHODIMP
 177 FileDescriptorFile::InitWithFile(nsIFile* aFile) {
 178   return NS_ERROR_NOT_IMPLEMENTED;
 179 }
 180
 181 nsresult FileDescriptorFile::AppendRelativePath(const nsAString& aNode) {
 182   return NS_ERROR_NOT_IMPLEMENTED;
 183 }
 184
 185 NS_IMETHODIMP
 186 FileDescriptorFile::AppendRelativeNativePath(const nsACString& aFragment) {
 187   return NS_ERROR_NOT_IMPLEMENTED;
 188 }
 189
 190 NS_IMETHODIMP
 191 FileDescriptorFile::SetPersistentDescriptor(
 192     const nsACString& aPersistentDescriptor) {
 193   return NS_ERROR_NOT_IMPLEMENTED;
 194 }
 195
 196 NS_IMETHODIMP
 197 FileDescriptorFile::GetRelativeDescriptor(nsIFile* aFromFile,
 198                                           nsACString& aRetVal) {
 199   return NS_ERROR_NOT_IMPLEMENTED;
 200 }
 201
 202 NS_IMETHODIMP
 203 FileDescriptorFile::SetRelativeDescriptor(nsIFile* aFromFile,
 204                                           const nsACString& aRelativeDesc) {
 205   return NS_ERROR_NOT_IMPLEMENTED;
 206 }
 207
 208 NS_IMETHODIMP
 209 FileDescriptorFile::GetRelativePath(nsIFile* aFromFile, nsACString& aRetVal) {
 210   return NS_ERROR_NOT_IMPLEMENTED;
 211 }
 212
 213 NS_IMETHODIMP
 214 FileDescriptorFile::SetRelativePath(nsIFile* aFromFile,
 215                                     const nsACString& aRelativePath) {
 216   return NS_ERROR_NOT_IMPLEMENTED;
 217 }
 218
 219 nsresult FileDescriptorFile::CopyTo(nsIFile* aNewParentDir,
 220                                     const nsAString& aNewName) {
 221   return NS_ERROR_NOT_IMPLEMENTED;
 222 }
 223
 224 NS_IMETHODIMP
 225 FileDescriptorFile::CopyToNative(nsIFile* aNewParent,
 226                                  const nsACString& aNewName) {
 227   return NS_ERROR_NOT_IMPLEMENTED;
 228 }
 229
 230 nsresult FileDescriptorFile::CopyToFollowingLinks(nsIFile* aNewParentDir,
 231                                                   const nsAString& aNewName) {
 232   return NS_ERROR_NOT_IMPLEMENTED;
 233 }
 234
 235 NS_IMETHODIMP
 236 FileDescriptorFile::CopyToFollowingLinksNative(nsIFile* aNewParent,
 237                                                const nsACString& aNewName) {
 238   return NS_ERROR_NOT_IMPLEMENTED;
 239 }
 240
 241 nsresult FileDescriptorFile::MoveTo(nsIFile* aNewParentDir,
 242                                     const nsAString& aNewName) {
 243   return NS_ERROR_NOT_IMPLEMENTED;
 244 }
 245
 246 NS_IMETHODIMP
 247 FileDescriptorFile::MoveToNative(nsIFile* aNewParent,
 248                                  const nsACString& aNewName) {
 249   return NS_ERROR_NOT_IMPLEMENTED;
 250 }
 251
 252 NS_IMETHODIMP
 253 FileDescriptorFile::MoveToFollowingLinks(nsIFile* aNewParent,
 254                                          const nsAString& aNewName) {
 255   return NS_ERROR_NOT_IMPLEMENTED;
 256 }
 257
 258 NS_IMETHODIMP
 259 FileDescriptorFile::MoveToFollowingLinksNative(nsIFile* aNewParent,
 260                                                const nsACString& aNewName) {
 261   return NS_ERROR_NOT_IMPLEMENTED;
 262 }
 263
 264 NS_IMETHODIMP
 265 FileDescriptorFile::RenameTo(nsIFile* aNewParentDir,
 266                              const nsAString& aNewName) {
 267   return NS_ERROR_NOT_IMPLEMENTED;
 268 }
 269
 270 NS_IMETHODIMP
 271 FileDescriptorFile::RenameToNative(nsIFile* aNewParentDir,
 272                                    const nsACString& aNewName) {
 273   return NS_ERROR_NOT_IMPLEMENTED;
 274 }
 275
 276 NS_IMETHODIMP
 277 FileDescriptorFile::Remove(bool aRecursive, uint32_t* aRemoveCount) {
 278   return NS_ERROR_NOT_IMPLEMENTED;
 279 }
 280
 281 NS_IMETHODIMP
 282 FileDescriptorFile::GetPermissions(uint32_t* aPermissions) {
 283   return NS_ERROR_NOT_IMPLEMENTED;
 284 }
 285
 286 NS_IMETHODIMP
 287 FileDescriptorFile::SetPermissions(uint32_t aPermissions) {
 288   return NS_ERROR_NOT_IMPLEMENTED;
 289 }
 290
 291 NS_IMETHODIMP
 292 FileDescriptorFile::GetPermissionsOfLink(uint32_t* aPermissionsOfLink) {
 293   return NS_ERROR_NOT_IMPLEMENTED;
 294 }
 295
 296 NS_IMETHODIMP
 297 FileDescriptorFile::SetPermissionsOfLink(uint32_t aPermissions) {
 298   return NS_ERROR_NOT_IMPLEMENTED;
 299 }
 300
 301 NS_IMETHODIMP
 302 FileDescriptorFile::GetLastAccessedTime(PRTime* aLastAccessedTime) {
 303   return NS_ERROR_NOT_IMPLEMENTED;
 304 }
 305
 306 NS_IMETHODIMP
 307 FileDescriptorFile::SetLastAccessedTime(PRTime aLastAccessedTime) {
 308   return NS_ERROR_NOT_IMPLEMENTED;
 309 }
 310
 311 NS_IMETHODIMP
 312 FileDescriptorFile::GetLastAccessedTimeOfLink(PRTime* aLastAccessedTime) {
 313   return NS_ERROR_NOT_IMPLEMENTED;
 314 }
 315
 316 NS_IMETHODIMP
 317 FileDescriptorFile::SetLastAccessedTimeOfLink(PRTime aLastAccessedTime) {
 318   return NS_ERROR_NOT_IMPLEMENTED;
 319 }
 320
 321 NS_IMETHODIMP
 322 FileDescriptorFile::GetLastModifiedTime(PRTime* aLastModTime) {
 323   return NS_ERROR_NOT_IMPLEMENTED;
 324 }
 325
 326 NS_IMETHODIMP
 327 FileDescriptorFile::SetLastModifiedTime(PRTime aLastModTime) {
 328   return NS_ERROR_NOT_IMPLEMENTED;
 329 }
 330
 331 NS_IMETHODIMP
 332 FileDescriptorFile::GetLastModifiedTimeOfLink(PRTime* aLastModTimeOfLink) {
 333   return NS_ERROR_NOT_IMPLEMENTED;
 334 }
 335
 336 NS_IMETHODIMP
 337 FileDescriptorFile::SetLastModifiedTimeOfLink(PRTime aLastModTimeOfLink) {
 338   return NS_ERROR_NOT_IMPLEMENTED;
 339 }
 340
 341 NS_IMETHODIMP
 342 FileDescriptorFile::GetCreationTime(PRTime* aCreationTime) {
 343   return NS_ERROR_NOT_IMPLEMENTED;
 344 }
 345
 346 NS_IMETHODIMP
 347 FileDescriptorFile::GetCreationTimeOfLink(PRTime* aCreationTime) {
 348   return NS_ERROR_NOT_IMPLEMENTED;
 349 }
 350
 351 NS_IMETHODIMP
 352 FileDescriptorFile::GetFileSize(int64_t* aFileSize) {
 353   return NS_ERROR_NOT_IMPLEMENTED;
 354 }
 355
 356 NS_IMETHODIMP
 357 FileDescriptorFile::SetFileSize(int64_t aFileSize) {
 358   return NS_ERROR_NOT_IMPLEMENTED;
 359 }
 360
 361 NS_IMETHODIMP
 362 FileDescriptorFile::GetFileSizeOfLink(int64_t* aFileSize) {
 363   return NS_ERROR_NOT_IMPLEMENTED;
 364 }
 365
 366 NS_IMETHODIMP
 367 FileDescriptorFile::Exists(bool* aRetVal) { return NS_ERROR_NOT_IMPLEMENTED; }
 368
 369 NS_IMETHODIMP
 370 FileDescriptorFile::IsWritable(bool* aRetVal) {
 371   return NS_ERROR_NOT_IMPLEMENTED;
 372 }
 373
 374 NS_IMETHODIMP
 375 FileDescriptorFile::IsReadable(bool* aRetVal) {
 376   return NS_ERROR_NOT_IMPLEMENTED;
 377 }
 378
 379 NS_IMETHODIMP
 380 FileDescriptorFile::IsExecutable(bool* aRetVal) {
 381   return NS_ERROR_NOT_IMPLEMENTED;
 382 }
 383
 384 NS_IMETHODIMP
 385 FileDescriptorFile::IsHidden(bool* aRetVal) { return NS_ERROR_NOT_IMPLEMENTED; }
 386
 387 NS_IMETHODIMP
 388 FileDescriptorFile::IsDirectory(bool* aRetVal) {
 389   return NS_ERROR_NOT_IMPLEMENTED;
 390 }
 391
 392 NS_IMETHODIMP
 393 FileDescriptorFile::IsFile(bool* aRetVal) { return NS_ERROR_NOT_IMPLEMENTED; }
 394
 395 NS_IMETHODIMP
 396 FileDescriptorFile::IsSymlink(bool* aRetVal) {
 397   return NS_ERROR_NOT_IMPLEMENTED;
 398 }
 399
 400 NS_IMETHODIMP
 401 FileDescriptorFile::IsSpecial(bool* aRetVal) {
 402   return NS_ERROR_NOT_IMPLEMENTED;
 403 }
 404
 405 NS_IMETHODIMP
 406 FileDescriptorFile::CreateUnique(uint32_t aType, uint32_t aAttributes) {
 407   return NS_ERROR_NOT_IMPLEMENTED;
 408 }
 409
 410 NS_IMETHODIMP
 411 FileDescriptorFile::GetDirectoryEntriesImpl(nsIDirectoryEnumerator** aEntries) {
 412   return NS_ERROR_NOT_IMPLEMENTED;
 413 }
 414
 415 NS_IMETHODIMP
 416 FileDescriptorFile::OpenANSIFileDesc(const char* aMode, FILE** aRetVal) {
 417   return NS_ERROR_NOT_IMPLEMENTED;
 418 }
 419
 420 NS_IMETHODIMP
 421 FileDescriptorFile::Load(PRLibrary** aRetVal) {
 422   return NS_ERROR_NOT_IMPLEMENTED;
 423 }
 424
 425 NS_IMETHODIMP
 426 FileDescriptorFile::GetDiskSpaceAvailable(int64_t* aDiskSpaceAvailable) {
 427   return NS_ERROR_NOT_IMPLEMENTED;
 428 }
 429
 430 NS_IMETHODIMP
 431 FileDescriptorFile::GetDiskCapacity(int64_t* aDiskCapacity) {
 432   return NS_ERROR_NOT_IMPLEMENTED;
 433 }
 434
 435 NS_IMETHODIMP
 436 FileDescriptorFile::Reveal() { return NS_ERROR_NOT_IMPLEMENTED; }
 437
 438 NS_IMETHODIMP
 439 FileDescriptorFile::Launch() { return NS_ERROR_NOT_IMPLEMENTED; }
 440
 441 }  // namespace net
 442 }  // namespace mozilla