The Tor Browser: comparison xpcom/io/nsLocalFileWin.cpp

--1:000000000000
+:7ca4cbf3a00c
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+* License, v. 2.0. If a copy of the MPL was not distributed with this
+* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/DebugOnly.h"
+#include "mozilla/WindowsVersion.h"
+#include "nsCOMPtr.h"
+#include "nsAutoPtr.h"
+#include "nsMemory.h"
+#include "nsLocalFile.h"
+#include "nsIDirectoryEnumerator.h"
+#include "nsNativeCharsetUtils.h"
+#include "nsISimpleEnumerator.h"
+#include "nsIComponentManager.h"
+#include "prio.h"
+#include "private/pprio.h"  // To get PR_ImportFile
+#include "prprf.h"
+#include "prmem.h"
+#include "nsHashKeys.h"
+#include "nsXPIDLString.h"
+#include "nsReadableUtils.h"
+#include <direct.h>
+#include <windows.h>
+#include <shlwapi.h>
+#include <aclapi.h>
+#include "shellapi.h"
+#include "shlguid.h"
+#include  <io.h>
+#include  <stdio.h>
+#include  <stdlib.h>
+#include  <mbstring.h>
+#include "nsXPIDLString.h"
+#include "prproces.h"
+#include "prlink.h"
+#include "mozilla/Mutex.h"
+#include "SpecialSystemDirectory.h"
+#include "nsTraceRefcnt.h"
+#include "nsXPCOMCIDInternal.h"
+#include "nsThreadUtils.h"
+#include "nsXULAppAPI.h"
+using namespace mozilla;
+#define CHECK_mWorkingPath()                    \
+PR_BEGIN_MACRO                              \
+if (mWorkingPath.IsEmpty())             \
+return NS_ERROR_NOT_INITIALIZED;    \
+PR_END_MACRO
+// CopyFileEx only supports unbuffered I/O in Windows Vista and above
+#ifndef COPY_FILE_NO_BUFFERING
+#define COPY_FILE_NO_BUFFERING 0x00001000
+#endif
+#ifndef FILE_ATTRIBUTE_NOT_CONTENT_INDEXED
+#define FILE_ATTRIBUTE_NOT_CONTENT_INDEXED  0x00002000
+#endif
+#ifndef DRIVE_REMOTE
+#define DRIVE_REMOTE 4
+#endif
+/**
+* A runnable to dispatch back to the main thread when
+* AsyncLocalFileWinOperation completes.
+*/
+class AsyncLocalFileWinDone : public nsRunnable
+{
+public:
+AsyncLocalFileWinDone() :
+mWorkerThread(do_GetCurrentThread())
+{
+// Objects of this type must only be created on worker threads
+MOZ_ASSERT(!NS_IsMainThread());
+}
+NS_IMETHOD Run() {
+// This event shuts down the worker thread and so must be main thread.
+MOZ_ASSERT(NS_IsMainThread());
+// If we don't destroy the thread when we're done with it, it will hang
+// around forever... and that is bad!
+mWorkerThread->Shutdown();
+return NS_OK;
+}
+private:
+nsCOMPtr<nsIThread> mWorkerThread;
+};
+/**
+* A runnable to dispatch from the main thread when an async operation should
+* be performed.
+*/
+class AsyncLocalFileWinOperation : public nsRunnable
+{
+public:
+enum FileOp { RevealOp, LaunchOp };
+AsyncLocalFileWinOperation(AsyncLocalFileWinOperation::FileOp aOperation,
+const nsAString &aResolvedPath) :
+mOperation(aOperation),
+mResolvedPath(aResolvedPath)
+{
+}
+NS_IMETHOD Run() {
+MOZ_ASSERT(!NS_IsMainThread(),
+"AsyncLocalFileWinOperation should not be run on the main thread!");
+CoInitialize(nullptr);
+switch(mOperation) {
+case RevealOp: {
+Reveal();
+}
+break;
+case LaunchOp: {
+Launch();
+}
+break;
+}
+CoUninitialize();
+// Send the result back to the main thread so that it can shutdown
+nsCOMPtr<nsIRunnable> resultrunnable = new AsyncLocalFileWinDone();
+NS_DispatchToMainThread(resultrunnable);
+return NS_OK;
+}
+private:
+// Reveals the path in explorer.
+nsresult Reveal()
+{
+DWORD attributes = GetFileAttributesW(mResolvedPath.get());
+if (INVALID_FILE_ATTRIBUTES == attributes) {
+return NS_ERROR_FILE_INVALID_PATH;
+}
+HRESULT hr;
+if (attributes & FILE_ATTRIBUTE_DIRECTORY) {
+// We have a directory so we should open the directory itself.
+ITEMIDLIST *dir = ILCreateFromPathW(mResolvedPath.get());
+if (!dir) {
+return NS_ERROR_FAILURE;
+}
+const ITEMIDLIST* selection[] = { dir };
+UINT count = ArrayLength(selection);
+//Perform the open of the directory.
+hr = SHOpenFolderAndSelectItems(dir, count, selection, 0);
+CoTaskMemFree(dir);
+} else {
+int32_t len = mResolvedPath.Length();
+// We don't currently handle UNC long paths of the form \\?\ anywhere so
+// this should be fine.
+if (len > MAX_PATH) {
+return NS_ERROR_FILE_INVALID_PATH;
+}
+WCHAR parentDirectoryPath[MAX_PATH + 1] = { 0 };
+wcsncpy(parentDirectoryPath, mResolvedPath.get(), MAX_PATH);
+PathRemoveFileSpecW(parentDirectoryPath);
+// We have a file so we should open the parent directory.
+ITEMIDLIST *dir = ILCreateFromPathW(parentDirectoryPath);
+if (!dir) {
+return NS_ERROR_FAILURE;
+}
+// Set the item in the directory to select to the file we want to reveal.
+ITEMIDLIST *item = ILCreateFromPathW(mResolvedPath.get());
+if (!item) {
+CoTaskMemFree(dir);
+return NS_ERROR_FAILURE;
+}
+const ITEMIDLIST* selection[] = { item };
+UINT count = ArrayLength(selection);
+//Perform the selection of the file.
+hr = SHOpenFolderAndSelectItems(dir, count, selection, 0);
+CoTaskMemFree(dir);
+CoTaskMemFree(item);
+}
+return SUCCEEDED(hr) ? NS_OK : NS_ERROR_FAILURE;
+}
+// Launches the default shell operation for the file path
+nsresult Launch()
+{
+// use the app registry name to launch a shell execute....
+SHELLEXECUTEINFOW seinfo;
+memset(&seinfo, 0, sizeof(seinfo));
+seinfo.cbSize = sizeof(SHELLEXECUTEINFOW);
+if (XRE_GetWindowsEnvironment() == WindowsEnvironmentType_Metro) {
+seinfo.fMask  = SEE_MASK_FLAG_LOG_USAGE;
+}
+seinfo.hwnd   = nullptr;
+seinfo.lpVerb = nullptr;
+seinfo.lpFile = mResolvedPath.get();
+seinfo.lpParameters =  nullptr;
+seinfo.lpDirectory  = nullptr;
+seinfo.nShow  = SW_SHOWNORMAL;
+// Use the directory of the file we're launching as the working
+// directory.  That way if we have a self extracting EXE it won't
+// suggest to extract to the install directory.
+WCHAR workingDirectory[MAX_PATH + 1] = { L'\0' };
+wcsncpy(workingDirectory,  mResolvedPath.get(), MAX_PATH);
+if (PathRemoveFileSpecW(workingDirectory)) {
+seinfo.lpDirectory = workingDirectory;
+} else {
+NS_WARNING("Could not set working directory for launched file.");
+}
+if (ShellExecuteExW(&seinfo)) {
+return NS_OK;
+}
+DWORD r = GetLastError();
+// if the file has no association, we launch windows'
+// "what do you want to do" dialog
+if (r == SE_ERR_NOASSOC) {
+nsAutoString shellArg;
+shellArg.Assign(NS_LITERAL_STRING("shell32.dll,OpenAs_RunDLL ") +
+mResolvedPath);
+seinfo.lpFile = L"RUNDLL32.EXE";
+seinfo.lpParameters = shellArg.get();
+if (ShellExecuteExW(&seinfo))
+return NS_OK;
+r = GetLastError();
+}
+if (r < 32) {
+switch (r) {
+case 0:
+case SE_ERR_OOM:
+return NS_ERROR_OUT_OF_MEMORY;
+case ERROR_FILE_NOT_FOUND:
+return NS_ERROR_FILE_NOT_FOUND;
+case ERROR_PATH_NOT_FOUND:
+return NS_ERROR_FILE_UNRECOGNIZED_PATH;
+case ERROR_BAD_FORMAT:
+return NS_ERROR_FILE_CORRUPTED;
+case SE_ERR_ACCESSDENIED:
+return NS_ERROR_FILE_ACCESS_DENIED;
+case SE_ERR_ASSOCINCOMPLETE:
+case SE_ERR_NOASSOC:
+return NS_ERROR_UNEXPECTED;
+case SE_ERR_DDEBUSY:
+case SE_ERR_DDEFAIL:
+case SE_ERR_DDETIMEOUT:
+return NS_ERROR_NOT_AVAILABLE;
+case SE_ERR_DLLNOTFOUND:
+return NS_ERROR_FAILURE;
+case SE_ERR_SHARE:
+return NS_ERROR_FILE_IS_LOCKED;
+default:
+return NS_ERROR_FILE_EXECUTION_FAILED;
+}
+}
+return NS_OK;
+}
+// Stores the operation that will be performed on the thread
+AsyncLocalFileWinOperation::FileOp mOperation;
+// Stores the path to perform the operation on
+nsString mResolvedPath;
+};
+class nsDriveEnumerator : public nsISimpleEnumerator
+{
+public:
+nsDriveEnumerator();
+virtual ~nsDriveEnumerator();
+NS_DECL_ISUPPORTS
+NS_DECL_NSISIMPLEENUMERATOR
+nsresult Init();
+private:
+/* mDrives stores the null-separated drive names.
+* Init sets them.
+* HasMoreElements checks mStartOfCurrentDrive.
+* GetNext advances mStartOfCurrentDrive.
+*/
+nsString mDrives;
+nsAString::const_iterator mStartOfCurrentDrive;
+nsAString::const_iterator mEndOfDrivesString;
+};
+//----------------------------------------------------------------------------
+// short cut resolver
+//----------------------------------------------------------------------------
+class ShortcutResolver
+{
+public:
+ShortcutResolver();
+// nonvirtual since we're not subclassed
+~ShortcutResolver();
+nsresult Init();
+nsresult Resolve(const WCHAR* in, WCHAR* out);
+nsresult SetShortcut(bool updateExisting,
+const WCHAR* shortcutPath,
+const WCHAR* targetPath,
+const WCHAR* workingDir,
+const WCHAR* args,
+const WCHAR* description,
+const WCHAR* iconFile,
+int32_t iconIndex);
+private:
+Mutex                  mLock;
+nsRefPtr<IPersistFile> mPersistFile;
+nsRefPtr<IShellLinkW>  mShellLink;
+};
+ShortcutResolver::ShortcutResolver() :
+mLock("ShortcutResolver.mLock")
+{
+CoInitialize(nullptr);
+}
+ShortcutResolver::~ShortcutResolver()
+{
+CoUninitialize();
+}
+nsresult
+ShortcutResolver::Init()
+{
+// Get a pointer to the IPersistFile interface.
+if (FAILED(CoCreateInstance(CLSID_ShellLink,
+nullptr,
+CLSCTX_INPROC_SERVER,
+IID_IShellLinkW,
+getter_AddRefs(mShellLink))) ||
+FAILED(mShellLink->QueryInterface(IID_IPersistFile,
+getter_AddRefs(mPersistFile)))) {
+mShellLink = nullptr;
+return NS_ERROR_FAILURE;
+}
+return NS_OK;
+}
+// |out| must be an allocated buffer of size MAX_PATH
+nsresult
+ShortcutResolver::Resolve(const WCHAR* in, WCHAR* out)
+{
+if (!mShellLink)
+return NS_ERROR_FAILURE;
+MutexAutoLock lock(mLock);
+if (FAILED(mPersistFile->Load(in, STGM_READ)) ||
+FAILED(mShellLink->Resolve(nullptr, SLR_NO_UI)) ||
+FAILED(mShellLink->GetPath(out, MAX_PATH, nullptr, SLGP_UNCPRIORITY)))
+return NS_ERROR_FAILURE;
+return NS_OK;
+}
+nsresult
+ShortcutResolver::SetShortcut(bool updateExisting,
+const WCHAR* shortcutPath,
+const WCHAR* targetPath,
+const WCHAR* workingDir,
+const WCHAR* args,
+const WCHAR* description,
+const WCHAR* iconPath,
+int32_t iconIndex)
+{
+if (!mShellLink) {
+return NS_ERROR_FAILURE;
+}
+if (!shortcutPath) {
+return NS_ERROR_FAILURE;
+}
+MutexAutoLock lock(mLock);
+if (updateExisting) {
+if (FAILED(mPersistFile->Load(shortcutPath, STGM_READWRITE))) {
+return NS_ERROR_FAILURE;
+}
+} else {
+if (!targetPath) {
+return NS_ERROR_FILE_TARGET_DOES_NOT_EXIST;
+}
+// Since we reuse our IPersistFile, we have to clear out any values that
+// may be left over from previous calls to SetShortcut.
+if (FAILED(mShellLink->SetWorkingDirectory(L""))
+|| FAILED(mShellLink->SetArguments(L""))
+|| FAILED(mShellLink->SetDescription(L""))
+|| FAILED(mShellLink->SetIconLocation(L"", 0))) {
+return NS_ERROR_FAILURE;
+}
+}
+if (targetPath && FAILED(mShellLink->SetPath(targetPath))) {
+return NS_ERROR_FAILURE;
+}
+if (workingDir && FAILED(mShellLink->SetWorkingDirectory(workingDir))) {
+return NS_ERROR_FAILURE;
+}
+if (args && FAILED(mShellLink->SetArguments(args))) {
+return NS_ERROR_FAILURE;
+}
+if (description && FAILED(mShellLink->SetDescription(description))) {
+return NS_ERROR_FAILURE;
+}
+if (iconPath && FAILED(mShellLink->SetIconLocation(iconPath, iconIndex))) {
+return NS_ERROR_FAILURE;
+}
+if (FAILED(mPersistFile->Save(shortcutPath,
+TRUE))) {
+// Second argument indicates whether the file path specified in the
+// first argument should become the "current working file" for this
+// IPersistFile
+return NS_ERROR_FAILURE;
+}
+return NS_OK;
+}
+static ShortcutResolver * gResolver = nullptr;
+static nsresult NS_CreateShortcutResolver()
+{
+gResolver = new ShortcutResolver();
+if (!gResolver)
+return NS_ERROR_OUT_OF_MEMORY;
+return gResolver->Init();
+}
+static void NS_DestroyShortcutResolver()
+{
+delete gResolver;
+gResolver = nullptr;
+}
+//-----------------------------------------------------------------------------
+// static helper functions
+//-----------------------------------------------------------------------------
+// certainly not all the error that can be
+// encountered, but many of them common ones
+static nsresult ConvertWinError(DWORD winErr)
+{
+nsresult rv;
+switch (winErr)
+{
+case ERROR_FILE_NOT_FOUND:
+case ERROR_PATH_NOT_FOUND:
+case ERROR_INVALID_DRIVE:
+rv = NS_ERROR_FILE_NOT_FOUND;
+break;
+case ERROR_ACCESS_DENIED:
+case ERROR_NOT_SAME_DEVICE:
+rv = NS_ERROR_FILE_ACCESS_DENIED;
+break;
+case ERROR_SHARING_VIOLATION: // CreateFile without sharing flags
+case ERROR_LOCK_VIOLATION: // LockFile, LockFileEx
+rv = NS_ERROR_FILE_IS_LOCKED;
+break;
+case ERROR_NOT_ENOUGH_MEMORY:
+case ERROR_INVALID_BLOCK:
+case ERROR_INVALID_HANDLE:
+case ERROR_ARENA_TRASHED:
+rv = NS_ERROR_OUT_OF_MEMORY;
+break;
+case ERROR_CURRENT_DIRECTORY:
+rv = NS_ERROR_FILE_DIR_NOT_EMPTY;
+break;
+case ERROR_WRITE_PROTECT:
+rv = NS_ERROR_FILE_READ_ONLY;
+break;
+case ERROR_HANDLE_DISK_FULL:
+rv = NS_ERROR_FILE_TOO_BIG;
+break;
+case ERROR_FILE_EXISTS:
+case ERROR_ALREADY_EXISTS:
+case ERROR_CANNOT_MAKE:
+rv = NS_ERROR_FILE_ALREADY_EXISTS;
+break;
+case ERROR_FILENAME_EXCED_RANGE:
+rv = NS_ERROR_FILE_NAME_TOO_LONG;
+break;
+case ERROR_DIRECTORY:
+rv = NS_ERROR_FILE_NOT_DIRECTORY;
+break;
+case 0:
+rv = NS_OK;
+break;
+default:
+rv = NS_ERROR_FAILURE;
+break;
+}
+return rv;
+}
+// as suggested in the MSDN documentation on SetFilePointer
+static __int64
+MyFileSeek64(HANDLE aHandle, __int64 aDistance, DWORD aMoveMethod)
+{
+LARGE_INTEGER li;
+li.QuadPart = aDistance;
+li.LowPart = SetFilePointer(aHandle, li.LowPart, &li.HighPart, aMoveMethod);
+if (li.LowPart == INVALID_SET_FILE_POINTER && GetLastError() != NO_ERROR)
+{
+li.QuadPart = -1;
+}
+return li.QuadPart;
+}
+static bool
+IsShortcutPath(const nsAString &path)
+{
+// Under Windows, the shortcuts are just files with a ".lnk" extension.
+// Note also that we don't resolve links in the middle of paths.
+// i.e. "c:\foo.lnk\bar.txt" is invalid.
+NS_ABORT_IF_FALSE(!path.IsEmpty(), "don't pass an empty string");
+int32_t len = path.Length();
+return len >= 4 && (StringTail(path, 4).LowerCaseEqualsASCII(".lnk"));
+}
+//-----------------------------------------------------------------------------
+// We need the following three definitions to make |OpenFile| convert a file
+// handle to an NSPR file descriptor correctly when |O_APPEND| flag is
+// specified. It is defined in a private header of NSPR (primpl.h) we can't
+// include. As a temporary workaround until we decide how to extend
+// |PR_ImportFile|, we define it here. Currently, |_PR_HAVE_PEEK_BUFFER|
+// and |PR_STRICT_ADDR_LEN| are not defined for the 'w95'-dependent portion
+// of NSPR so that fields of |PRFilePrivate| #ifdef'd by them are not copied.
+// Similarly, |_MDFileDesc| is taken from nsprpub/pr/include/md/_win95.h.
+// In an unlikely case we switch to 'NT'-dependent NSPR AND this temporary
+// workaround last beyond the switch, |PRFilePrivate| and |_MDFileDesc|
+// need to be changed to match the definitions for WinNT.
+//-----------------------------------------------------------------------------
+typedef enum {
+_PR_TRI_TRUE = 1,
+_PR_TRI_FALSE = 0,
+_PR_TRI_UNKNOWN = -1
+} _PRTriStateBool;
+struct _MDFileDesc {
+PROsfd osfd;
+};
+struct PRFilePrivate {
+int32_t state;
+bool nonblocking;
+_PRTriStateBool inheritable;
+PRFileDesc *next;
+int lockCount;      /*   0: not locked
+*  -1: a native lockfile call is in progress
+* > 0: # times the file is locked */
+bool    appendMode;
+_MDFileDesc md;
+};
+//-----------------------------------------------------------------------------
+// Six static methods defined below (OpenFile,  FileTimeToPRTime, GetFileInfo,
+// OpenDir, CloseDir, ReadDir) should go away once the corresponding
+// UTF-16 APIs are implemented on all the supported platforms (or at least
+// Windows 9x/ME) in NSPR. Currently, they're only implemented on
+// Windows NT4 or later. (bug 330665)
+//-----------------------------------------------------------------------------
+// copied from nsprpub/pr/src/{io/prfile.c | md/windows/w95io.c} :
+// PR_Open and _PR_MD_OPEN
+nsresult
+OpenFile(const nsAFlatString &name, int osflags, int mode,
+PRFileDesc **fd)
+{
+int32_t access = 0;
+int32_t disposition = 0;
+int32_t attributes = 0;
+if (osflags & PR_SYNC)
+attributes = FILE_FLAG_WRITE_THROUGH;
+if (osflags & PR_RDONLY || osflags & PR_RDWR)
+access |= GENERIC_READ;
+if (osflags & PR_WRONLY || osflags & PR_RDWR)
+access |= GENERIC_WRITE;
+if ( osflags & PR_CREATE_FILE && osflags & PR_EXCL )
+disposition = CREATE_NEW;
+else if (osflags & PR_CREATE_FILE) {
+if (osflags & PR_TRUNCATE)
+disposition = CREATE_ALWAYS;
+else
+disposition = OPEN_ALWAYS;
+} else {
+if (osflags & PR_TRUNCATE)
+disposition = TRUNCATE_EXISTING;
+else
+disposition = OPEN_EXISTING;
+}
+if (osflags & nsIFile::DELETE_ON_CLOSE) {
+attributes |= FILE_FLAG_DELETE_ON_CLOSE;
+}
+if (osflags & nsIFile::OS_READAHEAD) {
+attributes |= FILE_FLAG_SEQUENTIAL_SCAN;
+}
+// If no write permissions are requested, and if we are possibly creating
+// the file, then set the new file as read only.
+// The flag has no effect if we happen to open the file.
+if (!(mode & (PR_IWUSR | PR_IWGRP | PR_IWOTH)) &&
+disposition != OPEN_EXISTING) {
+attributes |= FILE_ATTRIBUTE_READONLY;
+}
+HANDLE file = ::CreateFileW(name.get(), access,
+FILE_SHARE_READ|FILE_SHARE_WRITE,
+nullptr, disposition, attributes, nullptr);
+if (file == INVALID_HANDLE_VALUE) {
+*fd = nullptr;
+return ConvertWinError(GetLastError());
+}
+*fd = PR_ImportFile((PROsfd) file);
+if (*fd) {
+// On Windows, _PR_HAVE_O_APPEND is not defined so that we have to
+// add it manually. (see |PR_Open| in nsprpub/pr/src/io/prfile.c)
+(*fd)->secret->appendMode = (PR_APPEND & osflags) ? true : false;
+return NS_OK;
+}
+nsresult rv = NS_ErrorAccordingToNSPR();
+CloseHandle(file);
+return rv;
+}
+// copied from nsprpub/pr/src/{io/prfile.c | md/windows/w95io.c} :
+// PR_FileTimeToPRTime and _PR_FileTimeToPRTime
+static
+void FileTimeToPRTime(const FILETIME *filetime, PRTime *prtm)
+{
+#ifdef __GNUC__
+const PRTime _pr_filetime_offset = 116444736000000000LL;
+#else
+const PRTime _pr_filetime_offset = 116444736000000000i64;
+#endif
+PR_ASSERT(sizeof(FILETIME) == sizeof(PRTime));
+::CopyMemory(prtm, filetime, sizeof(PRTime));
+#ifdef __GNUC__
+*prtm = (*prtm - _pr_filetime_offset) / 10LL;
+#else
+*prtm = (*prtm - _pr_filetime_offset) / 10i64;
+#endif
+}
+// copied from nsprpub/pr/src/{io/prfile.c | md/windows/w95io.c} with some
+// changes : PR_GetFileInfo64, _PR_MD_GETFILEINFO64
+static nsresult
+GetFileInfo(const nsAFlatString &name, PRFileInfo64 *info)
+{
+WIN32_FILE_ATTRIBUTE_DATA fileData;
+if (name.IsEmpty() || name.FindCharInSet(MOZ_UTF16("?*")) != kNotFound)
+return NS_ERROR_INVALID_ARG;
+if (!::GetFileAttributesExW(name.get(), GetFileExInfoStandard, &fileData))
+return ConvertWinError(GetLastError());
+if (fileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
+info->type = PR_FILE_DIRECTORY;
+} else {
+info->type = PR_FILE_FILE;
+}
+info->size = fileData.nFileSizeHigh;
+info->size = (info->size << 32) + fileData.nFileSizeLow;
+FileTimeToPRTime(&fileData.ftLastWriteTime, &info->modifyTime);
+if (0 == fileData.ftCreationTime.dwLowDateTime &&
+0 == fileData.ftCreationTime.dwHighDateTime) {
+info->creationTime = info->modifyTime;
+} else {
+FileTimeToPRTime(&fileData.ftCreationTime, &info->creationTime);
+}
+return NS_OK;
+}
+struct nsDir
+{
+HANDLE   handle;
+WIN32_FIND_DATAW data;
+bool     firstEntry;
+};
+static nsresult
+OpenDir(const nsAFlatString &name, nsDir * *dir)
+{
+if (NS_WARN_IF(!dir))
+return NS_ERROR_INVALID_ARG;
+*dir = nullptr;
+if (name.Length() + 3 >= MAX_PATH)
+return NS_ERROR_FILE_NAME_TOO_LONG;
+nsDir *d  = PR_NEW(nsDir);
+if (!d)
+return NS_ERROR_OUT_OF_MEMORY;
+nsAutoString filename(name);
+//If 'name' ends in a slash or backslash, do not append
+//another backslash.
+if (filename.Last() == L'/' || filename.Last() == L'\\')
+filename.Append('*');
+else
+filename.AppendLiteral("\\*");
+filename.ReplaceChar(L'/', L'\\');
+// FindFirstFileW Will have a last error of ERROR_DIRECTORY if
+// <file_path>\* is passed in.  If <unknown_path>\* is passed in then
+// ERROR_PATH_NOT_FOUND will be the last error.
+d->handle = ::FindFirstFileW(filename.get(), &(d->data) );
+if (d->handle == INVALID_HANDLE_VALUE) {
+PR_Free(d);
+return ConvertWinError(GetLastError());
+}
+d->firstEntry = true;
+*dir = d;
+return NS_OK;
+}
+static nsresult
+ReadDir(nsDir *dir, PRDirFlags flags, nsString& name)
+{
+name.Truncate();
+if (NS_WARN_IF(!dir))
+return NS_ERROR_INVALID_ARG;
+while (1) {
+BOOL rv;
+if (dir->firstEntry)
+{
+dir->firstEntry = false;
+rv = 1;
+} else
+rv = ::FindNextFileW(dir->handle, &(dir->data));
+if (rv == 0)
+break;
+const wchar_t *fileName;
+nsString tmp;
+fileName = (dir)->data.cFileName;
+if ((flags & PR_SKIP_DOT) &&
+(fileName[0] == L'.') && (fileName[1] == L'\0'))
+continue;
+if ((flags & PR_SKIP_DOT_DOT) &&
+(fileName[0] == L'.') && (fileName[1] == L'.') &&
+(fileName[2] == L'\0'))
+continue;
+DWORD attrib =  dir->data.dwFileAttributes;
+if ((flags & PR_SKIP_HIDDEN) && (attrib & FILE_ATTRIBUTE_HIDDEN))
+continue;
+if (fileName == tmp.get())
+name = tmp;
+else
+name = fileName;
+return NS_OK;
+}
+DWORD err = GetLastError();
+return err == ERROR_NO_MORE_FILES ? NS_OK : ConvertWinError(err);
+}
+static nsresult
+CloseDir(nsDir *&d)
+{
+if (NS_WARN_IF(!d))
+return NS_ERROR_INVALID_ARG;
+BOOL isOk = FindClose(d->handle);
+// PR_DELETE also nulls out the passed in pointer.
+PR_DELETE(d);
+return isOk ? NS_OK : ConvertWinError(GetLastError());
+}
+//-----------------------------------------------------------------------------
+// nsDirEnumerator
+//-----------------------------------------------------------------------------
+class nsDirEnumerator MOZ_FINAL : public nsISimpleEnumerator,
+public nsIDirectoryEnumerator
+{
+public:
+NS_DECL_ISUPPORTS
+nsDirEnumerator() : mDir(nullptr)
+{
+}
+nsresult Init(nsIFile* parent)
+{
+nsAutoString filepath;
+parent->GetTarget(filepath);
+if (filepath.IsEmpty())
+{
+parent->GetPath(filepath);
+}
+if (filepath.IsEmpty())
+{
+return NS_ERROR_UNEXPECTED;
+}
+// IsDirectory is not needed here because OpenDir will return
+// NS_ERROR_FILE_NOT_DIRECTORY if the passed in path is a file.
+nsresult rv = OpenDir(filepath, &mDir);
+if (NS_FAILED(rv))
+return rv;
+mParent = parent;
+return NS_OK;
+}
+NS_IMETHOD HasMoreElements(bool *result)
+{
+nsresult rv;
+if (mNext == nullptr && mDir)
+{
+nsString name;
+rv = ReadDir(mDir, PR_SKIP_BOTH, name);
+if (NS_FAILED(rv))
+return rv;
+if (name.IsEmpty())
+{
+// end of dir entries
+if (NS_FAILED(CloseDir(mDir)))
+return NS_ERROR_FAILURE;
+*result = false;
+return NS_OK;
+}
+nsCOMPtr<nsIFile> file;
+rv = mParent->Clone(getter_AddRefs(file));
+if (NS_FAILED(rv))
+return rv;
+rv = file->Append(name);
+if (NS_FAILED(rv))
+return rv;
+mNext = do_QueryInterface(file);
+}
+*result = mNext != nullptr;
+if (!*result)
+Close();
+return NS_OK;
+}
+NS_IMETHOD GetNext(nsISupports **result)
+{
+nsresult rv;
+bool hasMore;
+rv = HasMoreElements(&hasMore);
+if (NS_FAILED(rv)) return rv;
+*result = mNext;        // might return nullptr
+NS_IF_ADDREF(*result);
+mNext = nullptr;
+return NS_OK;
+}
+NS_IMETHOD GetNextFile(nsIFile **result)
+{
+*result = nullptr;
+bool hasMore = false;
+nsresult rv = HasMoreElements(&hasMore);
+if (NS_FAILED(rv) || !hasMore)
+return rv;
+*result = mNext;
+NS_IF_ADDREF(*result);
+mNext = nullptr;
+return NS_OK;
+}
+NS_IMETHOD Close()
+{
+if (mDir)
+{
+nsresult rv = CloseDir(mDir);
+NS_ASSERTION(NS_SUCCEEDED(rv), "close failed");
+if (NS_FAILED(rv))
+return NS_ERROR_FAILURE;
+}
+return NS_OK;
+}
+// dtor can be non-virtual since there are no subclasses, but must be
+// public to use the class on the stack.
+~nsDirEnumerator()
+{
+Close();
+}
+protected:
+nsDir*             mDir;
+nsCOMPtr<nsIFile>  mParent;
+nsCOMPtr<nsIFile>  mNext;
+};
+NS_IMPL_ISUPPORTS(nsDirEnumerator, nsISimpleEnumerator, nsIDirectoryEnumerator)
+//-----------------------------------------------------------------------------
+// nsLocalFile <public>
+//-----------------------------------------------------------------------------
+nsLocalFile::nsLocalFile()
+: mDirty(true)
+, mResolveDirty(true)
+, mFollowSymlinks(false)
+{
+}
+nsresult
+nsLocalFile::nsLocalFileConstructor(nsISupports* outer, const nsIID& aIID, void* *aInstancePtr)
+{
+if (NS_WARN_IF(!aInstancePtr))
+return NS_ERROR_INVALID_ARG;
+if (NS_WARN_IF(outer))
+return NS_ERROR_NO_AGGREGATION;
+nsLocalFile* inst = new nsLocalFile();
+if (inst == nullptr)
+return NS_ERROR_OUT_OF_MEMORY;
+nsresult rv = inst->QueryInterface(aIID, aInstancePtr);
+if (NS_FAILED(rv))
+{
+delete inst;
+return rv;
+}
+return NS_OK;
+}
+//-----------------------------------------------------------------------------
+// nsLocalFile::nsISupports
+//-----------------------------------------------------------------------------
+NS_IMPL_ISUPPORTS(nsLocalFile,
+nsILocalFile,
+nsIFile,
+nsILocalFileWin,
+nsIHashable)
+//-----------------------------------------------------------------------------
+// nsLocalFile <private>
+//-----------------------------------------------------------------------------
+nsLocalFile::nsLocalFile(const nsLocalFile& other)
+: mDirty(true)
+, mResolveDirty(true)
+, mFollowSymlinks(other.mFollowSymlinks)
+, mWorkingPath(other.mWorkingPath)
+{
+}
+// Resolve the shortcut file from mWorkingPath and write the path
+// it points to into mResolvedPath.
+nsresult
+nsLocalFile::ResolveShortcut()
+{
+// we can't do anything without the resolver
+if (!gResolver)
+return NS_ERROR_FAILURE;
+mResolvedPath.SetLength(MAX_PATH);
+if (mResolvedPath.Length() != MAX_PATH)
+return NS_ERROR_OUT_OF_MEMORY;
+wchar_t *resolvedPath = wwc(mResolvedPath.BeginWriting());
+// resolve this shortcut
+nsresult rv = gResolver->Resolve(mWorkingPath.get(), resolvedPath);
+size_t len = NS_FAILED(rv) ? 0 : wcslen(resolvedPath);
+mResolvedPath.SetLength(len);
+return rv;
+}
+// Resolve any shortcuts and stat the resolved path. After a successful return
+// the path is guaranteed valid and the members of mFileInfo64 can be used.
+nsresult
+nsLocalFile::ResolveAndStat()
+{
+// if we aren't dirty then we are already done
+if (!mDirty)
+return NS_OK;
+// we can't resolve/stat anything that isn't a valid NSPR addressable path
+if (mWorkingPath.IsEmpty())
+return NS_ERROR_FILE_INVALID_PATH;
+// this is usually correct
+mResolvedPath.Assign(mWorkingPath);
+// slutty hack designed to work around bug 134796 until it is fixed
+nsAutoString nsprPath(mWorkingPath.get());
+if (mWorkingPath.Length() == 2 && mWorkingPath.CharAt(1) == L':')
+nsprPath.Append('\\');
+// first we will see if the working path exists. If it doesn't then
+// there is nothing more that can be done
+nsresult rv = GetFileInfo(nsprPath, &mFileInfo64);
+if (NS_FAILED(rv))
+return rv;
+// if this isn't a shortcut file or we aren't following symlinks then we're done
+if (!mFollowSymlinks
+|| mFileInfo64.type != PR_FILE_FILE
+|| !IsShortcutPath(mWorkingPath))
+{
+mDirty = false;
+mResolveDirty = false;
+return NS_OK;
+}
+// we need to resolve this shortcut to what it points to, this will
+// set mResolvedPath. Even if it fails we need to have the resolved
+// path equal to working path for those functions that always use
+// the resolved path.
+rv = ResolveShortcut();
+if (NS_FAILED(rv))
+{
+mResolvedPath.Assign(mWorkingPath);
+return rv;
+}
+mResolveDirty = false;
+// get the details of the resolved path
+rv = GetFileInfo(mResolvedPath, &mFileInfo64);
+if (NS_FAILED(rv))
+return rv;
+mDirty = false;
+return NS_OK;
+}
+/**
+* Fills the mResolvedPath member variable with the file or symlink target
+* if follow symlinks is on.  This is a copy of the Resolve parts from
+* ResolveAndStat. ResolveAndStat is much slower though because of the stat.
+*
+* @return NS_OK on success.
+*/
+nsresult
+nsLocalFile::Resolve()
+{
+// if we aren't dirty then we are already done
+if (!mResolveDirty) {
+return NS_OK;
+}
+// we can't resolve/stat anything that isn't a valid NSPR addressable path
+if (mWorkingPath.IsEmpty()) {
+return NS_ERROR_FILE_INVALID_PATH;
+}
+// this is usually correct
+mResolvedPath.Assign(mWorkingPath);
+// if this isn't a shortcut file or we aren't following symlinks then
+// we're done.
+if (!mFollowSymlinks ||
+!IsShortcutPath(mWorkingPath)) {
+mResolveDirty = false;
+return NS_OK;
+}
+// we need to resolve this shortcut to what it points to, this will
+// set mResolvedPath. Even if it fails we need to have the resolved
+// path equal to working path for those functions that always use
+// the resolved path.
+nsresult rv = ResolveShortcut();
+if (NS_FAILED(rv)) {
+mResolvedPath.Assign(mWorkingPath);
+return rv;
+}
+mResolveDirty = false;
+return NS_OK;
+}
+//-----------------------------------------------------------------------------
+// nsLocalFile::nsIFile,nsILocalFile
+//-----------------------------------------------------------------------------
+NS_IMETHODIMP
+nsLocalFile::Clone(nsIFile **file)
+{
+// Just copy-construct ourselves
+*file = new nsLocalFile(*this);
+if (!*file)
+return NS_ERROR_OUT_OF_MEMORY;
+NS_ADDREF(*file);
+return NS_OK;
+}
+NS_IMETHODIMP
+nsLocalFile::InitWithFile(nsIFile *aFile)
+{
+if (NS_WARN_IF(!aFile))
+return NS_ERROR_INVALID_ARG;
+nsAutoString path;
+aFile->GetPath(path);
+if (path.IsEmpty())
+return NS_ERROR_INVALID_ARG;
+return InitWithPath(path);
+}
+NS_IMETHODIMP
+nsLocalFile::InitWithPath(const nsAString &filePath)
+{
+MakeDirty();
+nsAString::const_iterator begin, end;
+filePath.BeginReading(begin);
+filePath.EndReading(end);
+// input string must not be empty
+if (begin == end)
+return NS_ERROR_FAILURE;
+char16_t firstChar = *begin;
+char16_t secondChar = *(++begin);
+// just do a sanity check.  if it has any forward slashes, it is not a Native path
+// on windows.  Also, it must have a colon at after the first char.
+if (FindCharInReadable(L'/', begin, end))
+return NS_ERROR_FILE_UNRECOGNIZED_PATH;
+if (secondChar != L':' && (secondChar != L'\\' || firstChar != L'\\'))
+return NS_ERROR_FILE_UNRECOGNIZED_PATH;
+if (secondChar == L':') {
+// Make sure we have a valid drive, later code assumes the drive letter
+// is a single char a-z or A-Z.
+if (PathGetDriveNumberW(filePath.Data()) == -1) {
+return NS_ERROR_FILE_UNRECOGNIZED_PATH;
+}
+}
+mWorkingPath = filePath;
+// kill any trailing '\'
+if (mWorkingPath.Last() == L'\\')
+mWorkingPath.Truncate(mWorkingPath.Length() - 1);
+return NS_OK;
+}
+NS_IMETHODIMP
+nsLocalFile::OpenNSPRFileDesc(int32_t flags, int32_t mode, PRFileDesc **_retval)
+{
+nsresult rv = Resolve();
+if (NS_FAILED(rv))
+return rv;
+return OpenFile(mResolvedPath, flags, mode, _retval);
+}
+NS_IMETHODIMP
+nsLocalFile::OpenANSIFileDesc(const char *mode, FILE * *_retval)
+{
+nsresult rv = ResolveAndStat();
+if (NS_FAILED(rv) && rv != NS_ERROR_FILE_NOT_FOUND)
+return rv;
+*_retval = _wfopen(mResolvedPath.get(), NS_ConvertASCIItoUTF16(mode).get());
+if (*_retval)
+return NS_OK;
+return NS_ERROR_FAILURE;
+}
+NS_IMETHODIMP
+nsLocalFile::Create(uint32_t type, uint32_t attributes)
+{
+if (type != NORMAL_FILE_TYPE && type != DIRECTORY_TYPE)
+return NS_ERROR_FILE_UNKNOWN_TYPE;
+nsresult rv = ResolveAndStat();
+if (NS_FAILED(rv) && rv != NS_ERROR_FILE_NOT_FOUND)
+return rv;
+// create directories to target
+//
+// A given local file can be either one of these forms:
+//
+//   - normal:    X:\some\path\on\this\drive
+//                       ^--- start here
+//
+//   - UNC path:  \\machine\volume\some\path\on\this\drive
+//                                     ^--- start here
+//
+// Skip the first 'X:\' for the first form, and skip the first full
+// '\\machine\volume\' segment for the second form.
+wchar_t* path = wwc(mResolvedPath.BeginWriting());
+if (path[0] == L'\\' && path[1] == L'\\')
+{
+// dealing with a UNC path here; skip past '\\machine\'
+path = wcschr(path + 2, L'\\');
+if (!path)
+return NS_ERROR_FILE_INVALID_PATH;
+++path;
+}
+// search for first slash after the drive (or volume) name
+wchar_t* slash = wcschr(path, L'\\');
+nsresult directoryCreateError = NS_OK;
+if (slash)
+{
+// skip the first '\\'
+++slash;
+slash = wcschr(slash, L'\\');
+while (slash)
+{
+*slash = L'\0';
+if (!::CreateDirectoryW(mResolvedPath.get(), nullptr)) {
+rv = ConvertWinError(GetLastError());
+if (NS_ERROR_FILE_NOT_FOUND == rv &&
+NS_ERROR_FILE_ACCESS_DENIED == directoryCreateError) {
+// If a previous CreateDirectory failed due to access, return that.
+return NS_ERROR_FILE_ACCESS_DENIED;
+}
+// perhaps the base path already exists, or perhaps we don't have
+// permissions to create the directory.  NOTE: access denied could
+// occur on a parent directory even though it exists.
+else if (NS_ERROR_FILE_ALREADY_EXISTS != rv &&
+NS_ERROR_FILE_ACCESS_DENIED != rv) {
+return rv;
+}
+directoryCreateError = rv;
+}
+*slash = L'\\';
+++slash;
+slash = wcschr(slash, L'\\');
+}
+}
+if (type == NORMAL_FILE_TYPE)
+{
+PRFileDesc* file;
+rv = OpenFile(mResolvedPath,
+PR_RDONLY | PR_CREATE_FILE | PR_APPEND | PR_EXCL, attributes,
+&file);
+if (file)
+PR_Close(file);
+if (rv == NS_ERROR_FILE_ACCESS_DENIED)
+{
+// need to return already-exists for directories (bug 452217)
+bool isdir;
+if (NS_SUCCEEDED(IsDirectory(&isdir)) && isdir)
+rv = NS_ERROR_FILE_ALREADY_EXISTS;
+} else if (NS_ERROR_FILE_NOT_FOUND == rv &&
+NS_ERROR_FILE_ACCESS_DENIED == directoryCreateError) {
+// If a previous CreateDirectory failed due to access, return that.
+return NS_ERROR_FILE_ACCESS_DENIED;
+}
+return rv;
+}
+if (type == DIRECTORY_TYPE)
+{
+if (!::CreateDirectoryW(mResolvedPath.get(), nullptr)) {
+rv = ConvertWinError(GetLastError());
+if (NS_ERROR_FILE_NOT_FOUND == rv &&
+NS_ERROR_FILE_ACCESS_DENIED == directoryCreateError) {
+// If a previous CreateDirectory failed due to access, return that.
+return NS_ERROR_FILE_ACCESS_DENIED;
+} else {
+return rv;
+}
+}
+else
+return NS_OK;
+}
+return NS_ERROR_FILE_UNKNOWN_TYPE;
+}
+NS_IMETHODIMP
+nsLocalFile::Append(const nsAString &node)
+{
+// append this path, multiple components are not permitted
+return AppendInternal(PromiseFlatString(node), false);
+}
+NS_IMETHODIMP
+nsLocalFile::AppendRelativePath(const nsAString &node)
+{
+// append this path, multiple components are permitted
+return AppendInternal(PromiseFlatString(node), true);
+}
+nsresult
+nsLocalFile::AppendInternal(const nsAFlatString &node, bool multipleComponents)
+{
+if (node.IsEmpty())
+return NS_OK;
+// check the relative path for validity
+if (node.First() == L'\\'                                   // can't start with an '\'
+|| node.FindChar(L'/') != kNotFound                     // can't contain /
+|| node.EqualsASCII(".."))                              // can't be ..
+return NS_ERROR_FILE_UNRECOGNIZED_PATH;
+if (multipleComponents)
+{
+// can't contain .. as a path component. Ensure that the valid components
+// "foo..foo", "..foo", and "foo.." are not falsely detected,
+// but the invalid paths "..\", "foo\..", "foo\..\foo",
+// "..\foo", etc are.
+NS_NAMED_LITERAL_STRING(doubleDot, "\\..");
+nsAString::const_iterator start, end, offset;
+node.BeginReading(start);
+node.EndReading(end);
+offset = end;
+while (FindInReadable(doubleDot, start, offset))
+{
+if (offset == end || *offset == L'\\')
+return NS_ERROR_FILE_UNRECOGNIZED_PATH;
+start = offset;
+offset = end;
+}
+// catches the remaining cases of prefixes
+if (StringBeginsWith(node, NS_LITERAL_STRING("..\\")))
+return NS_ERROR_FILE_UNRECOGNIZED_PATH;
+}
+// single components can't contain '\'
+else if (node.FindChar(L'\\') != kNotFound)
+return NS_ERROR_FILE_UNRECOGNIZED_PATH;
+MakeDirty();
+mWorkingPath.Append(NS_LITERAL_STRING("\\") + node);
+return NS_OK;
+}
+#define TOUPPER(u) (((u) >= L'a' && (u) <= L'z') ? \
+(u) - (L'a' - L'A') : (u))
+NS_IMETHODIMP
+nsLocalFile::Normalize()
+{
+// XXX See bug 187957 comment 18 for possible problems with this implementation.
+if (mWorkingPath.IsEmpty())
+return NS_OK;
+nsAutoString path(mWorkingPath);
+// find the index of the root backslash for the path. Everything before
+// this is considered fully normalized and cannot be ascended beyond
+// using ".."  For a local drive this is the first slash (e.g. "c:\").
+// For a UNC path it is the slash following the share name
+// (e.g. "\\server\share\").
+int32_t rootIdx = 2;        // default to local drive
+if (path.First() == L'\\')   // if a share then calculate the rootIdx
+{
+rootIdx = path.FindChar(L'\\', 2);   // skip \\ in front of the server
+if (rootIdx == kNotFound)
+return NS_OK;                   // already normalized
+rootIdx = path.FindChar(L'\\', rootIdx+1);
+if (rootIdx == kNotFound)
+return NS_OK;                   // already normalized
+}
+else if (path.CharAt(rootIdx) != L'\\')
+{
+// The path has been specified relative to the current working directory
+// for that drive. To normalize it, the current working directory for
+// that drive needs to be inserted before the supplied relative path
+// which will provide an absolute path (and the rootIdx will still be 2).
+WCHAR cwd[MAX_PATH];
+WCHAR * pcwd = cwd;
+int drive = TOUPPER(path.First()) - 'A' + 1;
+/* We need to worry about IPH, for details read bug 419326.
+* _getdrives - http://msdn2.microsoft.com/en-us/library/xdhk0xd2.aspx
+* uses a bitmask, bit 0 is 'a:'
+* _chdrive - http://msdn2.microsoft.com/en-us/library/0d1409hb.aspx
+* _getdcwd - http://msdn2.microsoft.com/en-us/library/7t2zk3s4.aspx
+* take an int, 1 is 'a:'.
+*
+* Because of this, we need to do some math. Subtract 1 to convert from
+* _chdrive/_getdcwd format to _getdrives drive numbering.
+* Shift left x bits to convert from integer indexing to bitfield indexing.
+* And of course, we need to find out if the drive is in the bitmask.
+*
+* If we're really unlucky, we can still lose, but only if the user
+* manages to eject the drive between our call to _getdrives() and
+* our *calls* to _wgetdcwd.
+*/
+if (!((1 << (drive - 1)) & _getdrives()))
+return NS_ERROR_FILE_INVALID_PATH;
+if (!_wgetdcwd(drive, pcwd, MAX_PATH))
+pcwd = _wgetdcwd(drive, 0, 0);
+if (!pcwd)
+return NS_ERROR_OUT_OF_MEMORY;
+nsAutoString currentDir(pcwd);
+if (pcwd != cwd)
+free(pcwd);
+if (currentDir.Last() == '\\')
+path.Replace(0, 2, currentDir);
+else
+path.Replace(0, 2, currentDir + NS_LITERAL_STRING("\\"));
+}
+NS_POSTCONDITION(0 < rootIdx && rootIdx < (int32_t)path.Length(), "rootIdx is invalid");
+NS_POSTCONDITION(path.CharAt(rootIdx) == '\\', "rootIdx is invalid");
+// if there is nothing following the root path then it is already normalized
+if (rootIdx + 1 == (int32_t)path.Length())
+return NS_OK;
+// assign the root
+const char16_t * pathBuffer = path.get();  // simplify access to the buffer
+mWorkingPath.SetCapacity(path.Length()); // it won't ever grow longer
+mWorkingPath.Assign(pathBuffer, rootIdx);
+// Normalize the path components. The actions taken are:
+//
+//  "\\"    condense to single backslash
+//  "."     remove from path
+//  ".."    up a directory
+//  "..."   remove from path (any number of dots > 2)
+//
+// The last form is something that Windows 95 and 98 supported and
+// is a shortcut for changing up multiple directories. Windows XP
+// and ilk ignore it in a path, as is done here.
+int32_t len, begin, end = rootIdx;
+while (end < (int32_t)path.Length())
+{
+// find the current segment (text between the backslashes) to
+// be examined, this will set the following variables:
+//  begin == index of first char in segment
+//  end   == index 1 char after last char in segment
+//  len   == length of segment
+begin = end + 1;
+end = path.FindChar('\\', begin);
+if (end == kNotFound)
+end = path.Length();
+len = end - begin;
+// ignore double backslashes
+if (len == 0)
+continue;
+// len != 0, and interesting paths always begin with a dot
+if (pathBuffer[begin] == '.')
+{
+// ignore single dots
+if (len == 1)
+continue;
+// handle multiple dots
+if (len >= 2 && pathBuffer[begin+1] == L'.')
+{
+// back up a path component on double dot
+if (len == 2)
+{
+int32_t prev = mWorkingPath.RFindChar('\\');
+if (prev >= rootIdx)
+mWorkingPath.Truncate(prev);
+continue;
+}
+// length is > 2 and the first two characters are dots.
+// if the rest of the string is dots, then ignore it.
+int idx = len - 1;
+for (; idx >= 2; --idx)
+{
+if (pathBuffer[begin+idx] != L'.')
+break;
+}
+// this is true if the loop above didn't break
+// and all characters in this segment are dots.
+if (idx < 2)
+continue;
+}
+}
+// add the current component to the path, including the preceding backslash
+mWorkingPath.Append(pathBuffer + begin - 1, len + 1);
+}
+// kill trailing dots and spaces.
+int32_t filePathLen = mWorkingPath.Length() - 1;
+while(filePathLen > 0 && (mWorkingPath[filePathLen] == L' ' ||
+mWorkingPath[filePathLen] == L'.'))
+{
+mWorkingPath.Truncate(filePathLen--);
+}
+MakeDirty();
+return NS_OK;
+}
+NS_IMETHODIMP
+nsLocalFile::GetLeafName(nsAString &aLeafName)
+{
+aLeafName.Truncate();
+if (mWorkingPath.IsEmpty())
+return NS_ERROR_FILE_UNRECOGNIZED_PATH;
+int32_t offset = mWorkingPath.RFindChar(L'\\');
+// if the working path is just a node without any lashes.
+if (offset == kNotFound)
+aLeafName = mWorkingPath;
+else
+aLeafName = Substring(mWorkingPath, offset + 1);
+return NS_OK;
+}
+NS_IMETHODIMP
+nsLocalFile::SetLeafName(const nsAString &aLeafName)
+{
+MakeDirty();
+if (mWorkingPath.IsEmpty())
+return NS_ERROR_FILE_UNRECOGNIZED_PATH;
+// cannot use nsCString::RFindChar() due to 0x5c problem
+int32_t offset = mWorkingPath.RFindChar(L'\\');
+if (offset)
+{
+mWorkingPath.Truncate(offset+1);
+}
+mWorkingPath.Append(aLeafName);
+return NS_OK;
+}
+NS_IMETHODIMP
+nsLocalFile::GetPath(nsAString &_retval)
+{
+_retval = mWorkingPath;
+return NS_OK;
+}
+NS_IMETHODIMP
+nsLocalFile::GetCanonicalPath(nsAString &aResult)
+{
+EnsureShortPath();
+aResult.Assign(mShortWorkingPath);
+return NS_OK;
+}
+typedef struct {
+WORD wLanguage;
+WORD wCodePage;
+} LANGANDCODEPAGE;
+NS_IMETHODIMP
+nsLocalFile::GetVersionInfoField(const char* aField, nsAString& _retval)
+{
+nsresult rv = ResolveAndStat();
+if (NS_FAILED(rv))
+return rv;
+rv = NS_ERROR_FAILURE;
+const WCHAR *path = mFollowSymlinks ? mResolvedPath.get() : mWorkingPath.get();
+DWORD dummy;
+DWORD size = ::GetFileVersionInfoSizeW(path, &dummy);
+if (!size)
+return rv;
+void* ver = calloc(size, 1);
+if (!ver)
+return NS_ERROR_OUT_OF_MEMORY;
+if (::GetFileVersionInfoW(path, 0, size, ver))
+{
+LANGANDCODEPAGE* translate = nullptr;
+UINT pageCount;
+BOOL queryResult = ::VerQueryValueW(ver, L"\\VarFileInfo\\Translation",
+(void**)&translate, &pageCount);
+if (queryResult && translate)
+{
+for (int32_t i = 0; i < 2; ++i)
+{
+wchar_t subBlock[MAX_PATH];
+_snwprintf(subBlock, MAX_PATH,
+L"\\StringFileInfo\\%04x%04x\\%s",
+(i == 0 ? translate[0].wLanguage
+: ::GetUserDefaultLangID()),
+translate[0].wCodePage,
+NS_ConvertASCIItoUTF16(
+nsDependentCString(aField)).get());
+subBlock[MAX_PATH - 1] = 0;
+LPVOID value = nullptr;
+UINT size;
+queryResult = ::VerQueryValueW(ver, subBlock, &value, &size);
+if (queryResult && value)
+{
+_retval.Assign(static_cast<char16_t*>(value));
+if (!_retval.IsEmpty())
+{
+rv = NS_OK;
+break;
+}
+}
+}
+}
+}
+free(ver);
+return rv;
+}
+NS_IMETHODIMP
+nsLocalFile::SetShortcut(nsIFile* targetFile,
+nsIFile* workingDir,
+const char16_t* args,
+const char16_t* description,
+nsIFile* iconFile,
+int32_t iconIndex)
+{
+bool exists;
+nsresult rv = this->Exists(&exists);
+if (NS_FAILED(rv)) {
+return rv;
+}
+const WCHAR* targetFilePath = nullptr;
+const WCHAR* workingDirPath = nullptr;
+const WCHAR* iconFilePath = nullptr;
+nsAutoString targetFilePathAuto;
+if (targetFile) {
+rv = targetFile->GetPath(targetFilePathAuto);
+if (NS_FAILED(rv)) {
+return rv;
+}
+targetFilePath = targetFilePathAuto.get();
+}
+nsAutoString workingDirPathAuto;
+if (workingDir) {
+rv = workingDir->GetPath(workingDirPathAuto);
+if (NS_FAILED(rv)) {
+return rv;
+}
+workingDirPath = workingDirPathAuto.get();
+}
+nsAutoString iconPathAuto;
+if (iconFile) {
+rv = iconFile->GetPath(iconPathAuto);
+if (NS_FAILED(rv)) {
+return rv;
+}
+iconFilePath = iconPathAuto.get();
+}
+rv = gResolver->SetShortcut(exists,
+mWorkingPath.get(),
+targetFilePath,
+workingDirPath,
+char16ptr_t(args),
+char16ptr_t(description),
+iconFilePath,
+iconFilePath? iconIndex : 0);
+if (targetFilePath && NS_SUCCEEDED(rv)) {
+MakeDirty();
+}
+return rv;
+}
+/**
+* Determines if the drive type for the specified file is rmeote or local.
+*
+* @param path   The path of the file to check
+* @param remote Out parameter, on function success holds true if the specified
+*               file path is remote, or false if the file path is local.
+* @return true  on success. The return value implies absolutely nothing about
+*               wether the file is local or remote.
+*/
+static bool
+IsRemoteFilePath(LPCWSTR path, bool &remote)
+{
+// Obtain the parent directory path and make sure it ends with
+// a trailing backslash.
+WCHAR dirPath[MAX_PATH + 1] = { 0 };
+wcsncpy(dirPath, path, MAX_PATH);
+if (!PathRemoveFileSpecW(dirPath)) {
+return false;
+}
+size_t len = wcslen(dirPath);
+// In case the dirPath holds exaclty MAX_PATH and remains unchanged, we
+// recheck the required length here since we need to terminate it with
+// a backslash.
+if (len >= MAX_PATH) {
+return false;
+}
+dirPath[len] = L'\\';
+dirPath[len + 1] = L'\0';
+UINT driveType = GetDriveTypeW(dirPath);
+remote = driveType == DRIVE_REMOTE;
+return true;
+}
+nsresult
+nsLocalFile::CopySingleFile(nsIFile *sourceFile, nsIFile *destParent,
+const nsAString &newName, uint32_t options)
+{
+nsresult rv = NS_OK;
+nsAutoString filePath;
+bool move = options & (Move | Rename);
+// get the path that we are going to copy to.
+// Since windows does not know how to auto
+// resolve shortcuts, we must work with the
+// target.
+nsAutoString destPath;
+destParent->GetTarget(destPath);
+destPath.Append('\\');
+if (newName.IsEmpty())
+{
+nsAutoString aFileName;
+sourceFile->GetLeafName(aFileName);
+destPath.Append(aFileName);
+}
+else
+{
+destPath.Append(newName);
+}
+if (options & FollowSymlinks)
+{
+rv = sourceFile->GetTarget(filePath);
+if (filePath.IsEmpty())
+rv = sourceFile->GetPath(filePath);
+}
+else
+{
+rv = sourceFile->GetPath(filePath);
+}
+if (NS_FAILED(rv))
+return rv;
+// Pass the flag COPY_FILE_NO_BUFFERING to CopyFileEx as we may be copying
+// to a SMBV2 remote drive. Without this parameter subsequent append mode
+// file writes can cause the resultant file to become corrupt. We only need to do
+// this if the major version of Windows is > 5(Only Windows Vista and above
+// can support SMBV2).  With a 7200RPM hard drive:
+// Copying a 1KB file with COPY_FILE_NO_BUFFERING takes about 30-60ms.
+// Copying a 1KB file without COPY_FILE_NO_BUFFERING takes < 1ms.
+// So we only use COPY_FILE_NO_BUFFERING when we have a remote drive.
+int copyOK;
+DWORD dwCopyFlags = COPY_FILE_ALLOW_DECRYPTED_DESTINATION;
+if (IsVistaOrLater()) {
+bool path1Remote, path2Remote;
+if (!IsRemoteFilePath(filePath.get(), path1Remote) ||
+!IsRemoteFilePath(destPath.get(), path2Remote) ||
+path1Remote || path2Remote) {
+dwCopyFlags |= COPY_FILE_NO_BUFFERING;
+}
+}
+if (!move)
+{
+copyOK = ::CopyFileExW(filePath.get(), destPath.get(), nullptr,
+nullptr, nullptr, dwCopyFlags);
+}
+else
+{
+copyOK = ::MoveFileExW(filePath.get(), destPath.get(), MOVEFILE_REPLACE_EXISTING);
+// Check if copying the source file to a different volume,
+// as this could be an SMBV2 mapped drive.
+if (!copyOK && GetLastError() == ERROR_NOT_SAME_DEVICE)
+{
+if (options & Rename) {
+return NS_ERROR_FILE_ACCESS_DENIED;
+}
+copyOK = CopyFileExW(filePath.get(), destPath.get(), nullptr,
+nullptr, nullptr, dwCopyFlags);
+if (copyOK)
+DeleteFileW(filePath.get());
+}
+}
+if (!copyOK)  // CopyFileEx and MoveFileEx return zero at failure.
+rv = ConvertWinError(GetLastError());
+else if (move && !(options & SkipNtfsAclReset))
+{
+// Set security permissions to inherit from parent.
+// Note: propagates to all children: slow for big file trees
+PACL pOldDACL = nullptr;
+PSECURITY_DESCRIPTOR pSD = nullptr;
+::GetNamedSecurityInfoW((LPWSTR)destPath.get(), SE_FILE_OBJECT,
+DACL_SECURITY_INFORMATION,
+nullptr, nullptr, &pOldDACL, nullptr, &pSD);
+if (pOldDACL)
+::SetNamedSecurityInfoW((LPWSTR)destPath.get(), SE_FILE_OBJECT,
+DACL_SECURITY_INFORMATION |
+UNPROTECTED_DACL_SECURITY_INFORMATION,
+nullptr, nullptr, pOldDACL, nullptr);
+if (pSD)
+LocalFree((HLOCAL)pSD);
+}
+return rv;
+}
+nsresult
+nsLocalFile::CopyMove(nsIFile *aParentDir, const nsAString &newName, uint32_t options)
+{
+bool move = options & (Move | Rename);
+bool followSymlinks = options & FollowSymlinks;
+nsCOMPtr<nsIFile> newParentDir = aParentDir;
+// check to see if this exists, otherwise return an error.
+// we will check this by resolving.  If the user wants us
+// to follow links, then we are talking about the target,
+// hence we can use the |FollowSymlinks| option.
+nsresult rv  = ResolveAndStat();
+if (NS_FAILED(rv))
+return rv;
+if (!newParentDir)
+{
+// no parent was specified.  We must rename.
+if (newName.IsEmpty())
+return NS_ERROR_INVALID_ARG;
+rv = GetParent(getter_AddRefs(newParentDir));
+if (NS_FAILED(rv))
+return rv;
+}
+if (!newParentDir)
+return NS_ERROR_FILE_DESTINATION_NOT_DIR;
+// make sure it exists and is a directory.  Create it if not there.
+bool exists;
+newParentDir->Exists(&exists);
+if (!exists)
+{
+rv = newParentDir->Create(DIRECTORY_TYPE, 0644);  // TODO, what permissions should we use
+if (NS_FAILED(rv))
+return rv;
+}
+else
+{
+bool isDir;
+newParentDir->IsDirectory(&isDir);
+if (!isDir)
+{
+if (followSymlinks)
+{
+bool isLink;
+newParentDir->IsSymlink(&isLink);
+if (isLink)
+{
+nsAutoString target;
+newParentDir->GetTarget(target);
+nsCOMPtr<nsIFile> realDest = new nsLocalFile();
+if (realDest == nullptr)
+return NS_ERROR_OUT_OF_MEMORY;
+rv = realDest->InitWithPath(target);
+if (NS_FAILED(rv))
+return rv;
+return CopyMove(realDest, newName, options);
+}
+}
+else
+{
+return NS_ERROR_FILE_DESTINATION_NOT_DIR;
+}
+}
+}
+// Try different ways to move/copy files/directories
+bool done = false;
+bool isDir;
+IsDirectory(&isDir);
+bool isSymlink;
+IsSymlink(&isSymlink);
+// Try to move the file or directory, or try to copy a single file (or non-followed symlink)
+if (move || !isDir || (isSymlink && !followSymlinks))
+{
+// Copy/Move single file, or move a directory
+if (!aParentDir) {
+options |= SkipNtfsAclReset;
+}
+rv = CopySingleFile(this, newParentDir, newName, options);
+done = NS_SUCCEEDED(rv);
+// If we are moving a directory and that fails, fallback on directory
+// enumeration.  See bug 231300 for details.
+if (!done && !(move && isDir))
+return rv;
+}
+// Not able to copy or move directly, so enumerate it
+if (!done)
+{
+// create a new target destination in the new parentDir;
+nsCOMPtr<nsIFile> target;
+rv = newParentDir->Clone(getter_AddRefs(target));
+if (NS_FAILED(rv))
+return rv;
+nsAutoString allocatedNewName;
+if (newName.IsEmpty())
+{
+bool isLink;
+IsSymlink(&isLink);
+if (isLink)
+{
+nsAutoString temp;
+GetTarget(temp);
+int32_t offset = temp.RFindChar(L'\\');
+if (offset == kNotFound)
+allocatedNewName = temp;
+else
+allocatedNewName = Substring(temp, offset + 1);
+}
+else
+{
+GetLeafName(allocatedNewName);// this should be the leaf name of the
+}
+}
+else
+{
+allocatedNewName = newName;
+}
+rv = target->Append(allocatedNewName);
+if (NS_FAILED(rv))
+return rv;
+allocatedNewName.Truncate();
+// check if the destination directory already exists
+target->Exists(&exists);
+if (!exists)
+{
+// if the destination directory cannot be created, return an error
+rv = target->Create(DIRECTORY_TYPE, 0644);  // TODO, what permissions should we use
+if (NS_FAILED(rv))
+return rv;
+}
+else
+{
+// check if the destination directory is writable and empty
+bool isWritable;
+target->IsWritable(&isWritable);
+if (!isWritable)
+return NS_ERROR_FILE_ACCESS_DENIED;
+nsCOMPtr<nsISimpleEnumerator> targetIterator;
+rv = target->GetDirectoryEntries(getter_AddRefs(targetIterator));
+if (NS_FAILED(rv))
+return rv;
+bool more;
+targetIterator->HasMoreElements(&more);
+// return error if target directory is not empty
+if (more)
+return NS_ERROR_FILE_DIR_NOT_EMPTY;
+}
+nsDirEnumerator dirEnum;
+rv = dirEnum.Init(this);
+if (NS_FAILED(rv)) {
+NS_WARNING("dirEnum initialization failed");
+return rv;
+}
+bool more = false;
+while (NS_SUCCEEDED(dirEnum.HasMoreElements(&more)) && more)
+{
+nsCOMPtr<nsISupports> item;
+nsCOMPtr<nsIFile> file;
+dirEnum.GetNext(getter_AddRefs(item));
+file = do_QueryInterface(item);
+if (file)
+{
+bool isDir, isLink;
+file->IsDirectory(&isDir);
+file->IsSymlink(&isLink);
+if (move)
+{
+if (followSymlinks)
+return NS_ERROR_FAILURE;
+rv = file->MoveTo(target, EmptyString());
+if (NS_FAILED(rv))
+return rv;
+}
+else
+{
+if (followSymlinks)
+rv = file->CopyToFollowingLinks(target, EmptyString());
+else
+rv = file->CopyTo(target, EmptyString());
+if (NS_FAILED(rv))
+return rv;
+}
+}
+}
+// we've finished moving all the children of this directory
+// in the new directory.  so now delete the directory
+// note, we don't need to do a recursive delete.
+// MoveTo() is recursive.  At this point,
+// we've already moved the children of the current folder
+// to the new location.  nothing should be left in the folder.
+if (move)
+{
+rv = Remove(false /* recursive */);
+if (NS_FAILED(rv))
+return rv;
+}
+}
+// If we moved, we want to adjust this.
+if (move)
+{
+MakeDirty();
+nsAutoString newParentPath;
+newParentDir->GetPath(newParentPath);
+if (newParentPath.IsEmpty())
+return NS_ERROR_FAILURE;
+if (newName.IsEmpty())
+{
+nsAutoString aFileName;
+GetLeafName(aFileName);
+InitWithPath(newParentPath);
+Append(aFileName);
+}
+else
+{
+InitWithPath(newParentPath);
+Append(newName);
+}
+}
+return NS_OK;
+}
+NS_IMETHODIMP
+nsLocalFile::CopyTo(nsIFile *newParentDir, const nsAString &newName)
+{
+return CopyMove(newParentDir, newName, 0);
+}
+NS_IMETHODIMP
+nsLocalFile::CopyToFollowingLinks(nsIFile *newParentDir, const nsAString &newName)
+{
+return CopyMove(newParentDir, newName, FollowSymlinks);
+}
+NS_IMETHODIMP
+nsLocalFile::MoveTo(nsIFile *newParentDir, const nsAString &newName)
+{
+return CopyMove(newParentDir, newName, Move);
+}
+NS_IMETHODIMP
+nsLocalFile::RenameTo(nsIFile *newParentDir, const nsAString & newName)
+{
+nsCOMPtr<nsIFile> targetParentDir = newParentDir;
+// check to see if this exists, otherwise return an error.
+// we will check this by resolving.  If the user wants us
+// to follow links, then we are talking about the target,
+// hence we can use the |followSymlinks| parameter.
+nsresult rv = ResolveAndStat();
+if (NS_FAILED(rv)) {
+return rv;
+}
+if (!targetParentDir) {
+// no parent was specified.  We must rename.
+if (newName.IsEmpty()) {
+return NS_ERROR_INVALID_ARG;
+}
+rv = GetParent(getter_AddRefs(targetParentDir));
+if (NS_FAILED(rv)) {
+return rv;
+}
+}
+if (!targetParentDir) {
+return NS_ERROR_FILE_DESTINATION_NOT_DIR;
+}
+// make sure it exists and is a directory.  Create it if not there.
+bool exists;
+targetParentDir->Exists(&exists);
+if (!exists) {
+rv = targetParentDir->Create(DIRECTORY_TYPE, 0644);
+if (NS_FAILED(rv)) {
+return rv;
+}
+} else {
+bool isDir;
+targetParentDir->IsDirectory(&isDir);
+if (!isDir) {
+return NS_ERROR_FILE_DESTINATION_NOT_DIR;
+}
+}
+uint32_t options = Rename;
+if (!newParentDir) {
+options |= SkipNtfsAclReset;
+}
+// Move single file, or move a directory
+return CopySingleFile(this, targetParentDir, newName, options);
+}
+NS_IMETHODIMP
+nsLocalFile::Load(PRLibrary * *_retval)
+{
+// Check we are correctly initialized.
+CHECK_mWorkingPath();
+bool isFile;
+nsresult rv = IsFile(&isFile);
+if (NS_FAILED(rv))
+return rv;
+if (! isFile)
+return NS_ERROR_FILE_IS_DIRECTORY;
+#ifdef NS_BUILD_REFCNT_LOGGING
+nsTraceRefcnt::SetActivityIsLegal(false);
+#endif
+PRLibSpec libSpec;
+libSpec.value.pathname_u = mResolvedPath.get();
+libSpec.type = PR_LibSpec_PathnameU;
+*_retval =  PR_LoadLibraryWithFlags(libSpec, 0);
+#ifdef NS_BUILD_REFCNT_LOGGING
+nsTraceRefcnt::SetActivityIsLegal(true);
+#endif
+if (*_retval)
+return NS_OK;
+return NS_ERROR_NULL_POINTER;
+}
+NS_IMETHODIMP
+nsLocalFile::Remove(bool recursive)
+{
+// NOTE:
+//
+// if the working path points to a shortcut, then we will only
+// delete the shortcut itself.  even if the shortcut points to
+// a directory, we will not recurse into that directory or
+// delete that directory itself.  likewise, if the shortcut
+// points to a normal file, we will not delete the real file.
+// this is done to be consistent with the other platforms that
+// behave this way.  we do this even if the followLinks attribute
+// is set to true.  this helps protect against misuse that could
+// lead to security bugs (e.g., bug 210588).
+//
+// Since shortcut files are no longer permitted to be used as unix-like
+// symlinks interspersed in the path (e.g. "c:/file.lnk/foo/bar.txt")
+// this processing is a lot simpler. Even if the shortcut file is
+// pointing to a directory, only the mWorkingPath value is used and so
+// only the shortcut file will be deleted.
+// Check we are correctly initialized.
+CHECK_mWorkingPath();
+bool isDir, isLink;
+nsresult rv;
+isDir = false;
+rv = IsSymlink(&isLink);
+if (NS_FAILED(rv))
+return rv;
+// only check to see if we have a directory if it isn't a link
+if (!isLink)
+{
+rv = IsDirectory(&isDir);
+if (NS_FAILED(rv))
+return rv;
+}
+if (isDir)
+{
+if (recursive)
+{
+nsDirEnumerator dirEnum;
+rv = dirEnum.Init(this);
+if (NS_FAILED(rv))
+return rv;
+bool more = false;
+while (NS_SUCCEEDED(dirEnum.HasMoreElements(&more)) && more)
+{
+nsCOMPtr<nsISupports> item;
+dirEnum.GetNext(getter_AddRefs(item));
+nsCOMPtr<nsIFile> file = do_QueryInterface(item);
+if (file)
+file->Remove(recursive);
+}
+}
+if (RemoveDirectoryW(mWorkingPath.get()) == 0)
+return ConvertWinError(GetLastError());
+}
+else
+{
+if (DeleteFileW(mWorkingPath.get()) == 0)
+return ConvertWinError(GetLastError());
+}
+MakeDirty();
+return rv;
+}
+NS_IMETHODIMP
+nsLocalFile::GetLastModifiedTime(PRTime *aLastModifiedTime)
+{
+// Check we are correctly initialized.
+CHECK_mWorkingPath();
+if (NS_WARN_IF(!aLastModifiedTime))
+return NS_ERROR_INVALID_ARG;
+// get the modified time of the target as determined by mFollowSymlinks
+// If true, then this will be for the target of the shortcut file,
+// otherwise it will be for the shortcut file itself (i.e. the same
+// results as GetLastModifiedTimeOfLink)
+nsresult rv = ResolveAndStat();
+if (NS_FAILED(rv))
+return rv;
+// microseconds -> milliseconds
+*aLastModifiedTime = mFileInfo64.modifyTime / PR_USEC_PER_MSEC;
+return NS_OK;
+}
+NS_IMETHODIMP
+nsLocalFile::GetLastModifiedTimeOfLink(PRTime *aLastModifiedTime)
+{
+// Check we are correctly initialized.
+CHECK_mWorkingPath();
+if (NS_WARN_IF(!aLastModifiedTime))
+return NS_ERROR_INVALID_ARG;
+// The caller is assumed to have already called IsSymlink
+// and to have found that this file is a link.
+PRFileInfo64 info;
+nsresult rv = GetFileInfo(mWorkingPath, &info);
+if (NS_FAILED(rv))
+return rv;
+// microseconds -> milliseconds
+*aLastModifiedTime = info.modifyTime / PR_USEC_PER_MSEC;
+return NS_OK;
+}
+NS_IMETHODIMP
+nsLocalFile::SetLastModifiedTime(PRTime aLastModifiedTime)
+{
+// Check we are correctly initialized.
+CHECK_mWorkingPath();
+nsresult rv = ResolveAndStat();
+if (NS_FAILED(rv))
+return rv;
+// set the modified time of the target as determined by mFollowSymlinks
+// If true, then this will be for the target of the shortcut file,
+// otherwise it will be for the shortcut file itself (i.e. the same
+// results as SetLastModifiedTimeOfLink)
+rv = SetModDate(aLastModifiedTime, mResolvedPath.get());
+if (NS_SUCCEEDED(rv))
+MakeDirty();
+return rv;
+}
+NS_IMETHODIMP
+nsLocalFile::SetLastModifiedTimeOfLink(PRTime aLastModifiedTime)
+{
+// The caller is assumed to have already called IsSymlink
+// and to have found that this file is a link.
+nsresult rv = SetModDate(aLastModifiedTime, mWorkingPath.get());
+if (NS_SUCCEEDED(rv))
+MakeDirty();
+return rv;
+}
+nsresult
+nsLocalFile::SetModDate(PRTime aLastModifiedTime, const wchar_t *filePath)
+{
+// The FILE_FLAG_BACKUP_SEMANTICS is required in order to change the
+// modification time for directories.
+HANDLE file = ::CreateFileW(filePath,          // pointer to name of the file
+GENERIC_WRITE,     // access (write) mode
+0,                 // share mode
+nullptr,           // pointer to security attributes
+OPEN_EXISTING,     // how to create
+FILE_FLAG_BACKUP_SEMANTICS,  // file attributes
+nullptr);
+if (file == INVALID_HANDLE_VALUE)
+{
+return ConvertWinError(GetLastError());
+}
+FILETIME ft;
+SYSTEMTIME st;
+PRExplodedTime pret;
+// PR_ExplodeTime expects usecs...
+PR_ExplodeTime(aLastModifiedTime * PR_USEC_PER_MSEC, PR_GMTParameters, &pret);
+st.wYear            = pret.tm_year;
+st.wMonth           = pret.tm_month + 1; // Convert start offset -- Win32: Jan=1; NSPR: Jan=0
+st.wDayOfWeek       = pret.tm_wday;
+st.wDay             = pret.tm_mday;
+st.wHour            = pret.tm_hour;
+st.wMinute          = pret.tm_min;
+st.wSecond          = pret.tm_sec;
+st.wMilliseconds    = pret.tm_usec/1000;
+nsresult rv = NS_OK;
+// if at least one of these fails...
+if (!(SystemTimeToFileTime(&st, &ft) != 0 &&
+SetFileTime(file, nullptr, &ft, &ft) != 0))
+{
+rv = ConvertWinError(GetLastError());
+}
+CloseHandle(file);
+return rv;
+}
+NS_IMETHODIMP
+nsLocalFile::GetPermissions(uint32_t *aPermissions)
+{
+if (NS_WARN_IF(!aPermissions))
+return NS_ERROR_INVALID_ARG;
+// get the permissions of the target as determined by mFollowSymlinks
+// If true, then this will be for the target of the shortcut file,
+// otherwise it will be for the shortcut file itself (i.e. the same
+// results as GetPermissionsOfLink)
+nsresult rv = ResolveAndStat();
+if (NS_FAILED(rv))
+return rv;
+bool isWritable, isExecutable;
+IsWritable(&isWritable);
+IsExecutable(&isExecutable);
+*aPermissions = PR_IRUSR|PR_IRGRP|PR_IROTH;         // all read
+if (isWritable)
+*aPermissions |= PR_IWUSR|PR_IWGRP|PR_IWOTH;    // all write
+if (isExecutable)
+*aPermissions |= PR_IXUSR|PR_IXGRP|PR_IXOTH;    // all execute
+return NS_OK;
+}
+NS_IMETHODIMP
+nsLocalFile::GetPermissionsOfLink(uint32_t *aPermissions)
+{
+// Check we are correctly initialized.
+CHECK_mWorkingPath();
+if (NS_WARN_IF(!aPermissions))
+return NS_ERROR_INVALID_ARG;
+// The caller is assumed to have already called IsSymlink
+// and to have found that this file is a link. It is not
+// possible for a link file to be executable.
+DWORD word = ::GetFileAttributesW(mWorkingPath.get());
+if (word == INVALID_FILE_ATTRIBUTES)
+return NS_ERROR_FILE_INVALID_PATH;
+bool isWritable = !(word & FILE_ATTRIBUTE_READONLY);
+*aPermissions = PR_IRUSR|PR_IRGRP|PR_IROTH;         // all read
+if (isWritable)
+*aPermissions |= PR_IWUSR|PR_IWGRP|PR_IWOTH;    // all write
+return NS_OK;
+}
+NS_IMETHODIMP
+nsLocalFile::SetPermissions(uint32_t aPermissions)
+{
+// Check we are correctly initialized.
+CHECK_mWorkingPath();
+// set the permissions of the target as determined by mFollowSymlinks
+// If true, then this will be for the target of the shortcut file,
+// otherwise it will be for the shortcut file itself (i.e. the same
+// results as SetPermissionsOfLink)
+nsresult rv = ResolveAndStat();
+if (NS_FAILED(rv))
+return rv;
+// windows only knows about the following permissions
+int mode = 0;
+if (aPermissions & (PR_IRUSR|PR_IRGRP|PR_IROTH))    // any read
+mode |= _S_IREAD;
+if (aPermissions & (PR_IWUSR|PR_IWGRP|PR_IWOTH))    // any write
+mode |= _S_IWRITE;
+if (_wchmod(mResolvedPath.get(), mode) == -1)
+return NS_ERROR_FAILURE;
+return NS_OK;
+}
+NS_IMETHODIMP
+nsLocalFile::SetPermissionsOfLink(uint32_t aPermissions)
+{
+// The caller is assumed to have already called IsSymlink
+// and to have found that this file is a link.
+// windows only knows about the following permissions
+int mode = 0;
+if (aPermissions & (PR_IRUSR|PR_IRGRP|PR_IROTH))    // any read
+mode |= _S_IREAD;
+if (aPermissions & (PR_IWUSR|PR_IWGRP|PR_IWOTH))    // any write
+mode |= _S_IWRITE;
+if (_wchmod(mWorkingPath.get(), mode) == -1)
+return NS_ERROR_FAILURE;
+return NS_OK;
+}
+NS_IMETHODIMP
+nsLocalFile::GetFileSize(int64_t *aFileSize)
+{
+if (NS_WARN_IF(!aFileSize))
+return NS_ERROR_INVALID_ARG;
+nsresult rv = ResolveAndStat();
+if (NS_FAILED(rv))
+return rv;
+*aFileSize = mFileInfo64.size;
+return NS_OK;
+}
+NS_IMETHODIMP
+nsLocalFile::GetFileSizeOfLink(int64_t *aFileSize)
+{
+// Check we are correctly initialized.
+CHECK_mWorkingPath();
+if (NS_WARN_IF(!aFileSize))
+return NS_ERROR_INVALID_ARG;
+// The caller is assumed to have already called IsSymlink
+// and to have found that this file is a link.
+PRFileInfo64 info;
+if (NS_FAILED(GetFileInfo(mWorkingPath, &info)))
+return NS_ERROR_FILE_INVALID_PATH;
+*aFileSize = info.size;
+return NS_OK;
+}
+NS_IMETHODIMP
+nsLocalFile::SetFileSize(int64_t aFileSize)
+{
+// Check we are correctly initialized.
+CHECK_mWorkingPath();
+nsresult rv = ResolveAndStat();
+if (NS_FAILED(rv))
+return rv;
+HANDLE hFile = ::CreateFileW(mResolvedPath.get(),// pointer to name of the file
+GENERIC_WRITE,      // access (write) mode
+FILE_SHARE_READ,    // share mode
+nullptr,            // pointer to security attributes
+OPEN_EXISTING,          // how to create
+FILE_ATTRIBUTE_NORMAL,  // file attributes
+nullptr);
+if (hFile == INVALID_HANDLE_VALUE)
+{
+return ConvertWinError(GetLastError());
+}
+// seek the file pointer to the new, desired end of file
+// and then truncate the file at that position
+rv = NS_ERROR_FAILURE;
+aFileSize = MyFileSeek64(hFile, aFileSize, FILE_BEGIN);
+if (aFileSize != -1 && SetEndOfFile(hFile))
+{
+MakeDirty();
+rv = NS_OK;
+}
+CloseHandle(hFile);
+return rv;
+}
+NS_IMETHODIMP
+nsLocalFile::GetDiskSpaceAvailable(int64_t *aDiskSpaceAvailable)
+{
+// Check we are correctly initialized.
+CHECK_mWorkingPath();
+if (NS_WARN_IF(!aDiskSpaceAvailable))
+return NS_ERROR_INVALID_ARG;
+ResolveAndStat();
+if (mFileInfo64.type == PR_FILE_FILE) {
+// Since GetDiskFreeSpaceExW works only on directories, use the parent.
+nsCOMPtr<nsIFile> parent;
+if (NS_SUCCEEDED(GetParent(getter_AddRefs(parent))) && parent) {
+return parent->GetDiskSpaceAvailable(aDiskSpaceAvailable);
+}
+}
+ULARGE_INTEGER liFreeBytesAvailableToCaller, liTotalNumberOfBytes;
+if (::GetDiskFreeSpaceExW(mResolvedPath.get(), &liFreeBytesAvailableToCaller,
+&liTotalNumberOfBytes, nullptr))
+{
+*aDiskSpaceAvailable = liFreeBytesAvailableToCaller.QuadPart;
+return NS_OK;
+}
+*aDiskSpaceAvailable = 0;
+return NS_OK;
+}
+NS_IMETHODIMP
+nsLocalFile::GetParent(nsIFile * *aParent)
+{
+// Check we are correctly initialized.
+CHECK_mWorkingPath();
+if (NS_WARN_IF(!aParent))
+return NS_ERROR_INVALID_ARG;
+// A two-character path must be a drive such as C:, so it has no parent
+if (mWorkingPath.Length() == 2) {
+*aParent = nullptr;
+return NS_OK;
+}
+int32_t offset = mWorkingPath.RFindChar(char16_t('\\'));
+// adding this offset check that was removed in bug 241708 fixes mail
+// directories that aren't relative to/underneath the profile dir.
+// e.g., on a different drive. Before you remove them, please make
+// sure local mail directories that aren't underneath the profile dir work.
+if (offset == kNotFound)
+return NS_ERROR_FILE_UNRECOGNIZED_PATH;
+// A path of the form \\NAME is a top-level path and has no parent
+if (offset == 1 && mWorkingPath[0] == L'\\') {
+*aParent = nullptr;
+return NS_OK;
+}
+nsAutoString parentPath(mWorkingPath);
+if (offset > 0)
+parentPath.Truncate(offset);
+else
+parentPath.AssignLiteral("\\\\.");
+nsCOMPtr<nsIFile> localFile;
+nsresult rv = NS_NewLocalFile(parentPath, mFollowSymlinks, getter_AddRefs(localFile));
+if (NS_FAILED(rv)) {
+return rv;
+}
+localFile.forget(aParent);
+return NS_OK;
+}
+NS_IMETHODIMP
+nsLocalFile::Exists(bool *_retval)
+{
+// Check we are correctly initialized.
+CHECK_mWorkingPath();
+if (NS_WARN_IF(!_retval))
+return NS_ERROR_INVALID_ARG;
+*_retval = false;
+MakeDirty();
+nsresult rv = ResolveAndStat();
+*_retval = NS_SUCCEEDED(rv) || rv == NS_ERROR_FILE_IS_LOCKED;
+return NS_OK;
+}
+NS_IMETHODIMP
+nsLocalFile::IsWritable(bool *aIsWritable)
+{
+// Check we are correctly initialized.
+CHECK_mWorkingPath();
+// The read-only attribute on a FAT directory only means that it can't
+// be deleted. It is still possible to modify the contents of the directory.
+nsresult rv = IsDirectory(aIsWritable);
+if (rv == NS_ERROR_FILE_ACCESS_DENIED) {
+*aIsWritable = true;
+return NS_OK;
+} else if (rv == NS_ERROR_FILE_IS_LOCKED) {
+// If the file is normally allowed write access
+// we should still return that the file is writable.
+} else if (NS_FAILED(rv)) {
+return rv;
+}
+if (*aIsWritable)
+return NS_OK;
+// writable if the file doesn't have the readonly attribute
+rv = HasFileAttribute(FILE_ATTRIBUTE_READONLY, aIsWritable);
+if (rv == NS_ERROR_FILE_ACCESS_DENIED) {
+*aIsWritable = false;
+return NS_OK;
+} else if (rv == NS_ERROR_FILE_IS_LOCKED) {
+// If the file is normally allowed write access
+// we should still return that the file is writable.
+} else if (NS_FAILED(rv)) {
+return rv;
+}
+*aIsWritable = !*aIsWritable;
+// If the read only attribute is not set, check to make sure
+// we can open the file with write access.
+if (*aIsWritable) {
+PRFileDesc* file;
+rv = OpenFile(mResolvedPath, PR_WRONLY, 0, &file);
+if (NS_SUCCEEDED(rv)) {
+PR_Close(file);
+} else if (rv == NS_ERROR_FILE_ACCESS_DENIED) {
+*aIsWritable = false;
+} else if (rv == NS_ERROR_FILE_IS_LOCKED) {
+// If it is locked and read only we would have
+// gotten access denied
+*aIsWritable = true;
+} else {
+return rv;
+}
+}
+return NS_OK;
+}
+NS_IMETHODIMP
+nsLocalFile::IsReadable(bool *_retval)
+{
+// Check we are correctly initialized.
+CHECK_mWorkingPath();
+if (NS_WARN_IF(!_retval))
+return NS_ERROR_INVALID_ARG;
+*_retval = false;
+nsresult rv = ResolveAndStat();
+if (NS_FAILED(rv))
+return rv;
+*_retval = true;
+return NS_OK;
+}
+NS_IMETHODIMP
+nsLocalFile::IsExecutable(bool *_retval)
+{
+// Check we are correctly initialized.
+CHECK_mWorkingPath();
+if (NS_WARN_IF(!_retval))
+return NS_ERROR_INVALID_ARG;
+*_retval = false;
+nsresult rv;
+// only files can be executables
+bool isFile;
+rv = IsFile(&isFile);
+if (NS_FAILED(rv))
+return rv;
+if (!isFile)
+return NS_OK;
+//TODO: shouldn't we be checking mFollowSymlinks here?
+bool symLink;
+rv = IsSymlink(&symLink);
+if (NS_FAILED(rv))
+return rv;
+nsAutoString path;
+if (symLink)
+GetTarget(path);
+else
+GetPath(path);
+// kill trailing dots and spaces.
+int32_t filePathLen = path.Length() - 1;
+while(filePathLen > 0 && (path[filePathLen] == L' ' || path[filePathLen] == L'.'))
+{
+path.Truncate(filePathLen--);
+}
+// Get extension.
+int32_t dotIdx = path.RFindChar(char16_t('.'));
+if ( dotIdx != kNotFound ) {
+// Convert extension to lower case.
+char16_t *p = path.BeginWriting();
+for( p+= dotIdx + 1; *p; p++ )
+*p +=  (*p >= L'A' && *p <= L'Z') ? 'a' - 'A' : 0;
+// Search for any of the set of executable extensions.
+static const char * const executableExts[] = {
+"ad",
+"ade",         // access project extension
+"adp",
+"air",         // Adobe AIR installer
+"app",         // executable application
+"application", // from bug 348763
+"asp",
+"bas",
+"bat",
+"chm",
+"cmd",
+"com",
+"cpl",
+"crt",
+"exe",
+"fxp",         // FoxPro compiled app
+"hlp",
+"hta",
+"inf",
+"ins",
+"isp",
+"jar",         // java application bundle
+"js",
+"jse",
+"lnk",
+"mad",         // Access Module Shortcut
+"maf",         // Access
+"mag",         // Access Diagram Shortcut
+"mam",         // Access Macro Shortcut
+"maq",         // Access Query Shortcut
+"mar",         // Access Report Shortcut
+"mas",         // Access Stored Procedure
+"mat",         // Access Table Shortcut
+"mau",         // Media Attachment Unit
+"mav",         // Access View Shortcut
+"maw",         // Access Data Access Page
+"mda",         // Access Add-in, MDA Access 2 Workgroup
+"mdb",
+"mde",
+"mdt",         // Access Add-in Data
+"mdw",         // Access Workgroup Information
+"mdz",         // Access Wizard Template
+"msc",
+"msh",         // Microsoft Shell
+"mshxml",      // Microsoft Shell
+"msi",
+"msp",
+"mst",
+"ops",         // Office Profile Settings
+"pcd",
+"pif",
+"plg",         // Developer Studio Build Log
+"prf",         // windows system file
+"prg",
+"pst",
+"reg",
+"scf",         // Windows explorer command
+"scr",
+"sct",
+"shb",
+"shs",
+"url",
+"vb",
+"vbe",
+"vbs",
+"vsd",
+"vsmacros",    // Visual Studio .NET Binary-based Macro Project
+"vss",
+"vst",
+"vsw",
+"ws",
+"wsc",
+"wsf",
+"wsh"};
+nsDependentSubstring ext = Substring(path, dotIdx + 1);
+for ( size_t i = 0; i < ArrayLength(executableExts); i++ ) {
+if ( ext.EqualsASCII(executableExts[i])) {
+// Found a match.  Set result and quit.
+*_retval = true;
+break;
+}
+}
+}
+return NS_OK;
+}
+NS_IMETHODIMP
+nsLocalFile::IsDirectory(bool *_retval)
+{
+return HasFileAttribute(FILE_ATTRIBUTE_DIRECTORY, _retval);
+}
+NS_IMETHODIMP
+nsLocalFile::IsFile(bool *_retval)
+{
+nsresult rv = HasFileAttribute(FILE_ATTRIBUTE_DIRECTORY, _retval);
+if (NS_SUCCEEDED(rv)) {
+*_retval = !*_retval;
+}
+return rv;
+}
+NS_IMETHODIMP
+nsLocalFile::IsHidden(bool *_retval)
+{
+return HasFileAttribute(FILE_ATTRIBUTE_HIDDEN, _retval);
+}
+nsresult
+nsLocalFile::HasFileAttribute(DWORD fileAttrib, bool *_retval)
+{
+if (NS_WARN_IF(!_retval))
+return NS_ERROR_INVALID_ARG;
+nsresult rv = Resolve();
+if (NS_FAILED(rv)) {
+return rv;
+}
+DWORD attributes = GetFileAttributesW(mResolvedPath.get());
+if (INVALID_FILE_ATTRIBUTES == attributes) {
+return ConvertWinError(GetLastError());
+}
+*_retval = ((attributes & fileAttrib) != 0);
+return NS_OK;
+}
+NS_IMETHODIMP
+nsLocalFile::IsSymlink(bool *_retval)
+{
+// Check we are correctly initialized.
+CHECK_mWorkingPath();
+if (NS_WARN_IF(!_retval))
+return NS_ERROR_INVALID_ARG;
+// unless it is a valid shortcut path it's not a symlink
+if (!IsShortcutPath(mWorkingPath)) {
+*_retval = false;
+return NS_OK;
+}
+// we need to know if this is a file or directory
+nsresult rv = ResolveAndStat();
+if (NS_FAILED(rv)) {
+return rv;
+}
+// We should not check mFileInfo64.type here for PR_FILE_FILE because lnk
+// files can point to directories or files.  Important security checks
+// depend on correctly identifying lnk files.  mFileInfo64 now holds info
+// about the target of the lnk file, not the actual lnk file!
+*_retval = true;
+return NS_OK;
+}
+NS_IMETHODIMP
+nsLocalFile::IsSpecial(bool *_retval)
+{
+return HasFileAttribute(FILE_ATTRIBUTE_SYSTEM, _retval);
+}
+NS_IMETHODIMP
+nsLocalFile::Equals(nsIFile *inFile, bool *_retval)
+{
+if (NS_WARN_IF(!inFile))
+return NS_ERROR_INVALID_ARG;
+if (NS_WARN_IF(!_retval))
+return NS_ERROR_INVALID_ARG;
+EnsureShortPath();
+nsCOMPtr<nsILocalFileWin> lf(do_QueryInterface(inFile));
+if (!lf) {
+*_retval = false;
+return NS_OK;
+}
+nsAutoString inFilePath;
+lf->GetCanonicalPath(inFilePath);
+// Ok : Win9x
+*_retval = _wcsicmp(mShortWorkingPath.get(), inFilePath.get()) == 0;
+return NS_OK;
+}
+NS_IMETHODIMP
+nsLocalFile::Contains(nsIFile *inFile, bool recur, bool *_retval)
+{
+// Check we are correctly initialized.
+CHECK_mWorkingPath();
+*_retval = false;
+nsAutoString myFilePath;
+if (NS_FAILED(GetTarget(myFilePath)))
+GetPath(myFilePath);
+uint32_t myFilePathLen = myFilePath.Length();
+nsAutoString inFilePath;
+if (NS_FAILED(inFile->GetTarget(inFilePath)))
+inFile->GetPath(inFilePath);
+// make sure that the |inFile|'s path has a trailing separator.
+if (inFilePath.Length() >= myFilePathLen && inFilePath[myFilePathLen] == L'\\')
+{
+if (_wcsnicmp(myFilePath.get(), inFilePath.get(), myFilePathLen) == 0)
+{
+*_retval = true;
+}
+}
+return NS_OK;
+}
+NS_IMETHODIMP
+nsLocalFile::GetTarget(nsAString &_retval)
+{
+_retval.Truncate();
+#if STRICT_FAKE_SYMLINKS
+bool symLink;
+nsresult rv = IsSymlink(&symLink);
+if (NS_FAILED(rv))
+return rv;
+if (!symLink)
+{
+return NS_ERROR_FILE_INVALID_PATH;
+}
+#endif
+ResolveAndStat();
+_retval = mResolvedPath;
+return NS_OK;
+}
+/* attribute bool followLinks; */
+NS_IMETHODIMP
+nsLocalFile::GetFollowLinks(bool *aFollowLinks)
+{
+*aFollowLinks = mFollowSymlinks;
+return NS_OK;
+}
+NS_IMETHODIMP
+nsLocalFile::SetFollowLinks(bool aFollowLinks)
+{
+MakeDirty();
+mFollowSymlinks = aFollowLinks;
+return NS_OK;
+}
+NS_IMETHODIMP
+nsLocalFile::GetDirectoryEntries(nsISimpleEnumerator * *entries)
+{
+nsresult rv;
+*entries = nullptr;
+if (mWorkingPath.EqualsLiteral("\\\\.")) {
+nsDriveEnumerator *drives = new nsDriveEnumerator;
+if (!drives)
+return NS_ERROR_OUT_OF_MEMORY;
+NS_ADDREF(drives);
+rv = drives->Init();
+if (NS_FAILED(rv)) {
+NS_RELEASE(drives);
+return rv;
+}
+*entries = drives;
+return NS_OK;
+}
+nsDirEnumerator* dirEnum = new nsDirEnumerator();
+if (dirEnum == nullptr)
+return NS_ERROR_OUT_OF_MEMORY;
+NS_ADDREF(dirEnum);
+rv = dirEnum->Init(this);
+if (NS_FAILED(rv))
+{
+NS_RELEASE(dirEnum);
+return rv;
+}
+*entries = dirEnum;
+return NS_OK;
+}
+NS_IMETHODIMP
+nsLocalFile::GetPersistentDescriptor(nsACString &aPersistentDescriptor)
+{
+CopyUTF16toUTF8(mWorkingPath, aPersistentDescriptor);
+return NS_OK;
+}
+NS_IMETHODIMP
+nsLocalFile::SetPersistentDescriptor(const nsACString &aPersistentDescriptor)
+{
+if (IsUTF8(aPersistentDescriptor))
+return InitWithPath(NS_ConvertUTF8toUTF16(aPersistentDescriptor));
+else
+return InitWithNativePath(aPersistentDescriptor);
+}
+/* attrib unsigned long fileAttributesWin; */
+NS_IMETHODIMP
+nsLocalFile::GetFileAttributesWin(uint32_t *aAttribs)
+{
+*aAttribs = 0;
+DWORD dwAttrs = GetFileAttributesW(mWorkingPath.get());
+if (dwAttrs == INVALID_FILE_ATTRIBUTES)
+return NS_ERROR_FILE_INVALID_PATH;
+if (!(dwAttrs & FILE_ATTRIBUTE_NOT_CONTENT_INDEXED))
+*aAttribs |= WFA_SEARCH_INDEXED;
+return NS_OK;
+}
+NS_IMETHODIMP
+nsLocalFile::SetFileAttributesWin(uint32_t aAttribs)
+{
+DWORD dwAttrs = GetFileAttributesW(mWorkingPath.get());
+if (dwAttrs == INVALID_FILE_ATTRIBUTES)
+return NS_ERROR_FILE_INVALID_PATH;
+if (aAttribs & WFA_SEARCH_INDEXED) {
+dwAttrs &= ~FILE_ATTRIBUTE_NOT_CONTENT_INDEXED;
+} else {
+dwAttrs |= FILE_ATTRIBUTE_NOT_CONTENT_INDEXED;
+}
+if (aAttribs & WFA_READONLY) {
+dwAttrs |= FILE_ATTRIBUTE_READONLY;
+} else if ((aAttribs & WFA_READWRITE) &&
+(dwAttrs & FILE_ATTRIBUTE_READONLY)) {
+dwAttrs &= ~FILE_ATTRIBUTE_READONLY;
+}
+if (SetFileAttributesW(mWorkingPath.get(), dwAttrs) == 0)
+return NS_ERROR_FAILURE;
+return NS_OK;
+}
+NS_IMETHODIMP
+nsLocalFile::Reveal()
+{
+// This API should be main thread only
+MOZ_ASSERT(NS_IsMainThread());
+// make sure mResolvedPath is set
+nsresult rv = Resolve();
+if (NS_FAILED(rv) && rv != NS_ERROR_FILE_NOT_FOUND) {
+return rv;
+}
+// To create a new thread, get the thread manager
+nsCOMPtr<nsIThreadManager> tm = do_GetService(NS_THREADMANAGER_CONTRACTID);
+nsCOMPtr<nsIThread> mythread;
+rv = tm->NewThread(0, 0, getter_AddRefs(mythread));
+if (NS_FAILED(rv)) {
+return rv;
+}
+nsCOMPtr<nsIRunnable> runnable =
+new AsyncLocalFileWinOperation(AsyncLocalFileWinOperation::RevealOp,
+mResolvedPath);
+// After the dispatch, the result runnable will shut down the worker
+// thread, so we can let it go.
+mythread->Dispatch(runnable, NS_DISPATCH_NORMAL);
+return NS_OK;
+}
+NS_IMETHODIMP
+nsLocalFile::Launch()
+{
+// This API should be main thread only
+MOZ_ASSERT(NS_IsMainThread());
+// make sure mResolvedPath is set
+nsresult rv = Resolve();
+if (NS_FAILED(rv))
+return rv;
+// To create a new thread, get the thread manager
+nsCOMPtr<nsIThreadManager> tm = do_GetService(NS_THREADMANAGER_CONTRACTID);
+nsCOMPtr<nsIThread> mythread;
+rv = tm->NewThread(0, 0, getter_AddRefs(mythread));
+if (NS_FAILED(rv)) {
+return rv;
+}
+nsCOMPtr<nsIRunnable> runnable =
+new AsyncLocalFileWinOperation(AsyncLocalFileWinOperation::LaunchOp,
+mResolvedPath);
+// After the dispatch, the result runnable will shut down the worker
+// thread, so we can let it go.
+mythread->Dispatch(runnable, NS_DISPATCH_NORMAL);
+return NS_OK;
+}
+nsresult
+NS_NewLocalFile(const nsAString &path, bool followLinks, nsIFile* *result)
+{
+nsLocalFile* file = new nsLocalFile();
+if (file == nullptr)
+return NS_ERROR_OUT_OF_MEMORY;
+NS_ADDREF(file);
+file->SetFollowLinks(followLinks);
+if (!path.IsEmpty()) {
+nsresult rv = file->InitWithPath(path);
+if (NS_FAILED(rv)) {
+NS_RELEASE(file);
+return rv;
+}
+}
+*result = file;
+return NS_OK;
+}
+//-----------------------------------------------------------------------------
+// Native (lossy) interface
+//-----------------------------------------------------------------------------
+NS_IMETHODIMP
+nsLocalFile::InitWithNativePath(const nsACString &filePath)
+{
+nsAutoString tmp;
+nsresult rv = NS_CopyNativeToUnicode(filePath, tmp);
+if (NS_SUCCEEDED(rv))
+return InitWithPath(tmp);
+return rv;
+}
+NS_IMETHODIMP
+nsLocalFile::AppendNative(const nsACString &node)
+{
+nsAutoString tmp;
+nsresult rv = NS_CopyNativeToUnicode(node, tmp);
+if (NS_SUCCEEDED(rv))
+return Append(tmp);
+return rv;
+}
+NS_IMETHODIMP
+nsLocalFile::AppendRelativeNativePath(const nsACString &node)
+{
+nsAutoString tmp;
+nsresult rv = NS_CopyNativeToUnicode(node, tmp);
+if (NS_SUCCEEDED(rv))
+return AppendRelativePath(tmp);
+return rv;
+}
+NS_IMETHODIMP
+nsLocalFile::GetNativeLeafName(nsACString &aLeafName)
+{
+//NS_WARNING("This API is lossy. Use GetLeafName !");
+nsAutoString tmp;
+nsresult rv = GetLeafName(tmp);
+if (NS_SUCCEEDED(rv))
+rv = NS_CopyUnicodeToNative(tmp, aLeafName);
+return rv;
+}
+NS_IMETHODIMP
+nsLocalFile::SetNativeLeafName(const nsACString &aLeafName)
+{
+nsAutoString tmp;
+nsresult rv = NS_CopyNativeToUnicode(aLeafName, tmp);
+if (NS_SUCCEEDED(rv))
+return SetLeafName(tmp);
+return rv;
+}
+NS_IMETHODIMP
+nsLocalFile::GetNativePath(nsACString &_retval)
+{
+//NS_WARNING("This API is lossy. Use GetPath !");
+nsAutoString tmp;
+nsresult rv = GetPath(tmp);
+if (NS_SUCCEEDED(rv))
+rv = NS_CopyUnicodeToNative(tmp, _retval);
+return rv;
+}
+NS_IMETHODIMP
+nsLocalFile::GetNativeCanonicalPath(nsACString &aResult)
+{
+NS_WARNING("This method is lossy. Use GetCanonicalPath !");
+EnsureShortPath();
+NS_CopyUnicodeToNative(mShortWorkingPath, aResult);
+return NS_OK;
+}
+NS_IMETHODIMP
+nsLocalFile::CopyToNative(nsIFile *newParentDir, const nsACString &newName)
+{
+// Check we are correctly initialized.
+CHECK_mWorkingPath();
+if (newName.IsEmpty())
+return CopyTo(newParentDir, EmptyString());
+nsAutoString tmp;
+nsresult rv = NS_CopyNativeToUnicode(newName, tmp);
+if (NS_SUCCEEDED(rv))
+return CopyTo(newParentDir, tmp);
+return rv;
+}
+NS_IMETHODIMP
+nsLocalFile::CopyToFollowingLinksNative(nsIFile *newParentDir, const nsACString &newName)
+{
+if (newName.IsEmpty())
+return CopyToFollowingLinks(newParentDir, EmptyString());
+nsAutoString tmp;
+nsresult rv = NS_CopyNativeToUnicode(newName, tmp);
+if (NS_SUCCEEDED(rv))
+return CopyToFollowingLinks(newParentDir, tmp);
+return rv;
+}
+NS_IMETHODIMP
+nsLocalFile::MoveToNative(nsIFile *newParentDir, const nsACString &newName)
+{
+// Check we are correctly initialized.
+CHECK_mWorkingPath();
+if (newName.IsEmpty())
+return MoveTo(newParentDir, EmptyString());
+nsAutoString tmp;
+nsresult rv = NS_CopyNativeToUnicode(newName, tmp);
+if (NS_SUCCEEDED(rv))
+return MoveTo(newParentDir, tmp);
+return rv;
+}
+NS_IMETHODIMP
+nsLocalFile::GetNativeTarget(nsACString &_retval)
+{
+// Check we are correctly initialized.
+CHECK_mWorkingPath();
+NS_WARNING("This API is lossy. Use GetTarget !");
+nsAutoString tmp;
+nsresult rv = GetTarget(tmp);
+if (NS_SUCCEEDED(rv))
+rv = NS_CopyUnicodeToNative(tmp, _retval);
+return rv;
+}
+nsresult
+NS_NewNativeLocalFile(const nsACString &path, bool followLinks, nsIFile* *result)
+{
+nsAutoString buf;
+nsresult rv = NS_CopyNativeToUnicode(path, buf);
+if (NS_FAILED(rv)) {
+*result = nullptr;
+return rv;
+}
+return NS_NewLocalFile(buf, followLinks, result);
+}
+void
+nsLocalFile::EnsureShortPath()
+{
+if (!mShortWorkingPath.IsEmpty())
+return;
+WCHAR shortPath[MAX_PATH + 1];
+DWORD lengthNeeded = ::GetShortPathNameW(mWorkingPath.get(), shortPath,
+ArrayLength(shortPath));
+// If an error occurred then lengthNeeded is set to 0 or the length of the
+// needed buffer including null termination.  If it succeeds the number of
+// wide characters not including null termination is returned.
+if (lengthNeeded != 0 && lengthNeeded < ArrayLength(shortPath))
+mShortWorkingPath.Assign(shortPath);
+else
+mShortWorkingPath.Assign(mWorkingPath);
+}
+// nsIHashable
+NS_IMETHODIMP
+nsLocalFile::Equals(nsIHashable* aOther, bool *aResult)
+{
+nsCOMPtr<nsIFile> otherfile(do_QueryInterface(aOther));
+if (!otherfile) {
+*aResult = false;
+return NS_OK;
+}
+return Equals(otherfile, aResult);
+}
+NS_IMETHODIMP
+nsLocalFile::GetHashCode(uint32_t *aResult)
+{
+// In order for short and long path names to hash to the same value we
+// always hash on the short pathname.
+EnsureShortPath();
+*aResult = HashString(mShortWorkingPath);
+return NS_OK;
+}
+//-----------------------------------------------------------------------------
+// nsLocalFile <static members>
+//-----------------------------------------------------------------------------
+void
+nsLocalFile::GlobalInit()
+{
+DebugOnly<nsresult> rv = NS_CreateShortcutResolver();
+NS_ASSERTION(NS_SUCCEEDED(rv), "Shortcut resolver could not be created");
+}
+void
+nsLocalFile::GlobalShutdown()
+{
+NS_DestroyShortcutResolver();
+}
+NS_IMPL_ISUPPORTS(nsDriveEnumerator, nsISimpleEnumerator)
+nsDriveEnumerator::nsDriveEnumerator()
+{
+}
+nsDriveEnumerator::~nsDriveEnumerator()
+{
+}
+nsresult nsDriveEnumerator::Init()
+{
+/* If the length passed to GetLogicalDriveStrings is smaller
+* than the length of the string it would return, it returns
+* the length required for the string. */
+DWORD length = GetLogicalDriveStringsW(0, 0);
+/* The string is null terminated */
+if (!mDrives.SetLength(length+1, fallible_t()))
+return NS_ERROR_OUT_OF_MEMORY;
+if (!GetLogicalDriveStringsW(length, wwc(mDrives.BeginWriting())))
+return NS_ERROR_FAILURE;
+mDrives.BeginReading(mStartOfCurrentDrive);
+mDrives.EndReading(mEndOfDrivesString);
+return NS_OK;
+}
+NS_IMETHODIMP nsDriveEnumerator::HasMoreElements(bool *aHasMore)
+{
+*aHasMore = *mStartOfCurrentDrive != L'\0';
+return NS_OK;
+}
+NS_IMETHODIMP nsDriveEnumerator::GetNext(nsISupports **aNext)
+{
+/* GetLogicalDrives stored in mDrives is a concatenation
+* of null terminated strings, followed by a null terminator.
+* mStartOfCurrentDrive is an iterator pointing at the first
+* character of the current drive. */
+if (*mStartOfCurrentDrive == L'\0') {
+*aNext = nullptr;
+return NS_OK;
+}
+nsAString::const_iterator driveEnd = mStartOfCurrentDrive;
+FindCharInReadable(L'\0', driveEnd, mEndOfDrivesString);
+nsString drive(Substring(mStartOfCurrentDrive, driveEnd));
+mStartOfCurrentDrive = ++driveEnd;
+nsIFile *file;
+nsresult rv = NS_NewLocalFile(drive, false, &file);
+*aNext = file;
+return rv;
+}

The Tor Browser / file comparison

comparison: xpcom/io/nsLocalFileWin.cpp

xpcom/io/nsLocalFileWin.cpp