xpcom/io/nsLocalFileCommon.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 "nsLocalFile.h"  // includes platform-specific headers
   8
   9 #include "nsString.h"
  10 #include "nsCOMPtr.h"
  11 #include "nsReadableUtils.h"
  12 #include "nsPrintfCString.h"
  13 #include "nsCRT.h"
  14 #include "nsNativeCharsetUtils.h"
  15 #include "nsUTF8Utils.h"
  16 #include "nsArray.h"
  17 #include "nsLocalFileCommon.h"
  18
  19 #ifdef XP_WIN
  20 #  include <string.h>
  21 #endif
  22
  23 // Extensions that should be considered 'executable', ie will not allow users
  24 // to open immediately without first saving to disk, and potentially provoke
  25 // other warnings. PLEASE read the longer comment in
  26 // toolkit/components/reputationservice/ApplicationReputation.cpp
  27 // before modifying this list!
  28 // If you update this list, make sure to update the length of sExecutableExts
  29 // in nsLocalFileCommmon.h.
  30 /* static */
  31 const char* const sExecutableExts[] = {
  32     // clang-format off
  33   ".accda",       // MS Access database
  34   ".accdb",       // MS Access database
  35   ".accde",       // MS Access database
  36   ".accdr",       // MS Access database
  37   ".ad",
  38   ".ade",         // access project extension
  39   ".adp",
  40   ".afploc",      // Apple Filing Protocol Location
  41   ".air",         // Adobe AIR installer
  42   ".app",         // executable application
  43   ".application", // from bug 348763
  44   ".appref-ms",   // ClickOnce link
  45   ".appx",
  46   ".appxbundle",
  47   ".asp",
  48   ".atloc",       // Appletalk Location
  49   ".bas",
  50   ".bat",
  51   ".cer",         // Signed certificate file
  52   ".chm",
  53   ".cmd",
  54   ".com",
  55   ".cpl",
  56   ".crt",
  57   ".der",
  58   ".diagcab",     // Windows archive
  59   ".exe",
  60   ".fileloc",     // Apple finder internet location data file
  61   ".ftploc",      // Apple FTP Location
  62   ".fxp",         // FoxPro compiled app
  63   ".hlp",
  64   ".hta",
  65   ".inetloc",     // Apple finder internet location data file
  66   ".inf",
  67   ".ins",
  68   ".isp",
  69   ".jar",         // java application bundle
  70 #ifndef MOZ_ESR
  71   ".jnlp",
  72 #endif
  73   ".js",
  74   ".jse",
  75   ".lnk",
  76   ".mad",         // Access Module Shortcut
  77   ".maf",         // Access
  78   ".mag",         // Access Diagram Shortcut
  79   ".mam",         // Access Macro Shortcut
  80   ".maq",         // Access Query Shortcut
  81   ".mar",         // Access Report Shortcut
  82   ".mas",         // Access Stored Procedure
  83   ".mat",         // Access Table Shortcut
  84   ".mau",         // Media Attachment Unit
  85   ".mav",         // Access View Shortcut
  86   ".maw",         // Access Data Access Page
  87   ".mda",         // Access Add-in, MDA Access 2 Workgroup
  88   ".mdb",
  89   ".mde",
  90   ".mdt",         // Access Add-in Data
  91   ".mdw",         // Access Workgroup Information
  92   ".mdz",         // Access Wizard Template
  93   ".msc",
  94   ".msh",         // Microsoft Shell
  95   ".msh1",        // Microsoft Shell
  96   ".msh1xml",     // Microsoft Shell
  97   ".msh2",        // Microsoft Shell
  98   ".msh2xml",     // Microsoft Shell
  99   ".mshxml",      // Microsoft Shell
 100   ".msi",
 101   ".msix",
 102   ".msixbundle",
 103   ".msp",
 104   ".mst",
 105   ".ops",         // Office Profile Settings
 106   ".pcd",
 107   ".pif",
 108   ".plg",         // Developer Studio Build Log
 109   ".prf",         // windows system file
 110   ".prg",
 111   ".pst",
 112   ".reg",
 113   ".scf",         // Windows explorer command
 114   ".scr",
 115   ".sct",
 116   ".settingcontent-ms",
 117   ".shb",
 118   ".shs",
 119   ".url",
 120   ".vb",
 121   ".vbe",
 122   ".vbs",
 123   ".vdx",
 124   ".vsd",
 125   ".vsdm",
 126   ".vsdx",
 127   ".vsmacros",    // Visual Studio .NET Binary-based Macro Project
 128   ".vss",
 129   ".vssm",
 130   ".vssx",
 131   ".vst",
 132   ".vstm",
 133   ".vstx",
 134   ".vsw",
 135   ".vsx",
 136   ".vtx",
 137   ".webloc",       // MacOS website location file
 138   ".ws",
 139   ".wsc",
 140   ".wsf",
 141   ".wsh",
 142   ".xll"         // MS Excel dynamic link library
 143     // clang-format on
 144 };
 145
 146 #if !defined(MOZ_WIDGET_COCOA) && !defined(XP_WIN)
 147 NS_IMETHODIMP
 148 nsLocalFile::InitWithFile(nsIFile* aFile) {
 149   if (NS_WARN_IF(!aFile)) {
 150     return NS_ERROR_INVALID_ARG;
 151   }
 152
 153   nsAutoCString path;
 154   aFile->GetNativePath(path);
 155   if (path.IsEmpty()) {
 156     return NS_ERROR_INVALID_ARG;
 157   }
 158   return InitWithNativePath(path);
 159 }
 160 #endif
 161
 162 #define kMaxFilenameLength 255
 163 #define kMaxExtensionLength 100
 164 #define kMaxSequenceNumberLength 5  // "-9999"
 165 // requirement: kMaxExtensionLength <
 166 //                kMaxFilenameLength - kMaxSequenceNumberLength
 167
 168 NS_IMETHODIMP
 169 nsLocalFile::CreateUnique(uint32_t aType, uint32_t aAttributes) {
 170   nsresult rv;
 171   bool longName;
 172
 173 #ifdef XP_WIN
 174   nsAutoString pathName, leafName, rootName, suffix;
 175   rv = GetPath(pathName);
 176 #else
 177   nsAutoCString pathName, leafName, rootName, suffix;
 178   rv = GetNativePath(pathName);
 179 #endif
 180   if (NS_FAILED(rv)) {
 181     return rv;
 182   }
 183
 184   auto FailedBecauseExists = [&](nsresult aRv) {
 185     if (aRv == NS_ERROR_FILE_ACCESS_DENIED) {
 186       bool exists;
 187       return NS_SUCCEEDED(Exists(&exists)) && exists;
 188     }
 189     return aRv == NS_ERROR_FILE_ALREADY_EXISTS;
 190   };
 191
 192   longName =
 193       (pathName.Length() + kMaxSequenceNumberLength > kMaxFilenameLength);
 194   if (!longName) {
 195     rv = Create(aType, aAttributes);
 196     if (!FailedBecauseExists(rv)) {
 197       return rv;
 198     }
 199   }
 200
 201 #ifdef XP_WIN
 202   rv = GetLeafName(leafName);
 203   if (NS_FAILED(rv)) {
 204     return rv;
 205   }
 206
 207   const int32_t lastDot = leafName.RFindChar(char16_t('.'));
 208 #else
 209   rv = GetNativeLeafName(leafName);
 210   if (NS_FAILED(rv)) {
 211     return rv;
 212   }
 213
 214   const int32_t lastDot = leafName.RFindChar('.');
 215 #endif
 216
 217   if (lastDot == kNotFound) {
 218     rootName = leafName;
 219   } else {
 220     suffix = Substring(leafName, lastDot);       // include '.'
 221     rootName = Substring(leafName, 0, lastDot);  // strip suffix and dot
 222   }
 223
 224   if (longName) {
 225     int32_t maxRootLength =
 226         (kMaxFilenameLength - (pathName.Length() - leafName.Length()) -
 227          suffix.Length() - kMaxSequenceNumberLength);
 228
 229     // We cannot create an item inside a directory whose name is too long.
 230     // Also, ensure that at least one character remains after we truncate
 231     // the root name, as we don't want to end up with an empty leaf name.
 232     if (maxRootLength < 2) {
 233       return NS_ERROR_FILE_UNRECOGNIZED_PATH;
 234     }
 235
 236 #ifdef XP_WIN
 237     // ensure that we don't cut the name in mid-UTF16-character
 238     rootName.SetLength(NS_IS_LOW_SURROGATE(rootName[maxRootLength])
 239                            ? maxRootLength - 1
 240                            : maxRootLength);
 241     SetLeafName(rootName + suffix);
 242 #else
 243     if (NS_IsNativeUTF8()) {
 244       // ensure that we don't cut the name in mid-UTF8-character
 245       // (assume the name is valid UTF8 to begin with)
 246       while (UTF8traits::isInSeq(rootName[maxRootLength])) {
 247         --maxRootLength;
 248       }
 249
 250       // Another check to avoid ending up with an empty leaf name.
 251       if (maxRootLength == 0 && suffix.IsEmpty()) {
 252         return NS_ERROR_FILE_UNRECOGNIZED_PATH;
 253       }
 254     }
 255
 256     rootName.SetLength(maxRootLength);
 257     SetNativeLeafName(rootName + suffix);
 258 #endif
 259     nsresult rvCreate = Create(aType, aAttributes);
 260     if (!FailedBecauseExists(rvCreate)) {
 261       return rvCreate;
 262     }
 263   }
 264
 265   for (int indx = 1; indx < 10000; ++indx) {
 266     // start with "Picture-1.jpg" after "Picture.jpg" exists
 267 #ifdef XP_WIN
 268     SetLeafName(rootName +
 269                 NS_ConvertASCIItoUTF16(nsPrintfCString("-%d", indx)) + suffix);
 270 #else
 271     SetNativeLeafName(rootName + nsPrintfCString("-%d", indx) + suffix);
 272 #endif
 273     rv = Create(aType, aAttributes);
 274     if (NS_SUCCEEDED(rv) || !FailedBecauseExists(rv)) {
 275       return rv;
 276     }
 277   }
 278
 279   // The disk is full, sort of
 280   return NS_ERROR_FILE_TOO_BIG;
 281 }
 282
 283 #if defined(XP_WIN)
 284 static const char16_t kPathSeparatorChar = '\\';
 285 #elif defined(XP_UNIX)
 286 static const char16_t kPathSeparatorChar = '/';
 287 #else
 288 #  error Need to define file path separator for your platform
 289 #endif
 290
 291 static void SplitPath(char16_t* aPath, nsTArray<char16_t*>& aNodeArray) {
 292   if (*aPath == 0) {
 293     return;
 294   }
 295
 296   if (*aPath == kPathSeparatorChar) {
 297     aPath++;
 298   }
 299   aNodeArray.AppendElement(aPath);
 300
 301   for (char16_t* cp = aPath; *cp != 0; ++cp) {
 302     if (*cp == kPathSeparatorChar) {
 303       *cp++ = 0;
 304       if (*cp == 0) {
 305         break;
 306       }
 307       aNodeArray.AppendElement(cp);
 308     }
 309   }
 310 }
 311
 312 NS_IMETHODIMP
 313 nsLocalFile::GetRelativeDescriptor(nsIFile* aFromFile, nsACString& aResult) {
 314   if (NS_WARN_IF(!aFromFile)) {
 315     return NS_ERROR_INVALID_ARG;
 316   }
 317
 318   //
 319   // aResult will be UTF-8 encoded
 320   //
 321
 322   nsresult rv;
 323   aResult.Truncate(0);
 324
 325   nsAutoString thisPath, fromPath;
 326   AutoTArray<char16_t*, 32> thisNodes;
 327   AutoTArray<char16_t*, 32> fromNodes;
 328
 329   rv = GetPath(thisPath);
 330   if (NS_FAILED(rv)) {
 331     return rv;
 332   }
 333   rv = aFromFile->GetPath(fromPath);
 334   if (NS_FAILED(rv)) {
 335     return rv;
 336   }
 337
 338   // get raw pointer to mutable string buffer
 339   char16_t* thisPathPtr = thisPath.BeginWriting();
 340   char16_t* fromPathPtr = fromPath.BeginWriting();
 341
 342   SplitPath(thisPathPtr, thisNodes);
 343   SplitPath(fromPathPtr, fromNodes);
 344
 345   size_t nodeIndex;
 346   for (nodeIndex = 0;
 347        nodeIndex < thisNodes.Length() && nodeIndex < fromNodes.Length();
 348        ++nodeIndex) {
 349 #ifdef XP_WIN
 350     if (_wcsicmp(char16ptr_t(thisNodes[nodeIndex]),
 351                  char16ptr_t(fromNodes[nodeIndex]))) {
 352       break;
 353     }
 354 #else
 355     if (nsCRT::strcmp(thisNodes[nodeIndex], fromNodes[nodeIndex])) {
 356       break;
 357     }
 358 #endif
 359   }
 360
 361   size_t branchIndex = nodeIndex;
 362   for (nodeIndex = branchIndex; nodeIndex < fromNodes.Length(); ++nodeIndex) {
 363     aResult.AppendLiteral("../");
 364   }
 365   StringJoinAppend(aResult, "/"_ns, mozilla::Span{thisNodes}.From(branchIndex),
 366                    [](nsACString& dest, const auto& thisNode) {
 367                      // XXX(Bug 1682869) We wouldn't need to reconstruct a
 368                      // nsDependentString here if SplitPath already returned
 369                      // nsDependentString. In fact, it seems SplitPath might be
 370                      // replaced by ParseString?
 371                      AppendUTF16toUTF8(nsDependentString{thisNode}, dest);
 372                    });
 373
 374   return NS_OK;
 375 }
 376
 377 NS_IMETHODIMP
 378 nsLocalFile::SetRelativeDescriptor(nsIFile* aFromFile,
 379                                    const nsACString& aRelativeDesc) {
 380   constexpr auto kParentDirStr = "../"_ns;
 381
 382   nsCOMPtr<nsIFile> targetFile;
 383   nsresult rv = aFromFile->Clone(getter_AddRefs(targetFile));
 384   if (NS_FAILED(rv)) {
 385     return rv;
 386   }
 387
 388   //
 389   // aRelativeDesc is UTF-8 encoded
 390   //
 391
 392   nsCString::const_iterator strBegin, strEnd;
 393   aRelativeDesc.BeginReading(strBegin);
 394   aRelativeDesc.EndReading(strEnd);
 395
 396   nsCString::const_iterator nodeBegin(strBegin), nodeEnd(strEnd);
 397   nsCString::const_iterator pos(strBegin);
 398
 399   nsCOMPtr<nsIFile> parentDir;
 400   while (FindInReadable(kParentDirStr, nodeBegin, nodeEnd)) {
 401     rv = targetFile->GetParent(getter_AddRefs(parentDir));
 402     if (NS_FAILED(rv)) {
 403       return rv;
 404     }
 405     if (!parentDir) {
 406       return NS_ERROR_FILE_UNRECOGNIZED_PATH;
 407     }
 408     targetFile = parentDir;
 409
 410     nodeBegin = nodeEnd;
 411     pos = nodeEnd;
 412     nodeEnd = strEnd;
 413   }
 414
 415   nodeBegin = nodeEnd = pos;
 416   while (nodeEnd != strEnd) {
 417     FindCharInReadable('/', nodeEnd, strEnd);
 418     targetFile->Append(NS_ConvertUTF8toUTF16(Substring(nodeBegin, nodeEnd)));
 419     if (nodeEnd != strEnd) {  // If there's more left in the string, inc over
 420                               // the '/' nodeEnd is on.
 421       ++nodeEnd;
 422     }
 423     nodeBegin = nodeEnd;
 424   }
 425
 426   return InitWithFile(targetFile);
 427 }
 428
 429 NS_IMETHODIMP
 430 nsLocalFile::GetRelativePath(nsIFile* aFromFile, nsACString& aResult) {
 431   return GetRelativeDescriptor(aFromFile, aResult);
 432 }
 433
 434 NS_IMETHODIMP
 435 nsLocalFile::SetRelativePath(nsIFile* aFromFile,
 436                              const nsACString& aRelativePath) {
 437   return SetRelativeDescriptor(aFromFile, aRelativePath);
 438 }