зеркало из https://github.com/mozilla/gecko-dev.git
468 строки
15 KiB
C++
468 строки
15 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
|
/* 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 "nsCOMPtr.h"
|
|
#include "nsAutoPtr.h"
|
|
#include "nsDirectoryService.h"
|
|
#include "nsLocalFile.h"
|
|
#include "nsDebug.h"
|
|
#include "nsGkAtoms.h"
|
|
#include "nsEnumeratorUtils.h"
|
|
|
|
#include "mozilla/SimpleEnumerator.h"
|
|
#include "nsICategoryManager.h"
|
|
#include "nsISimpleEnumerator.h"
|
|
|
|
#if defined(XP_WIN)
|
|
#include <windows.h>
|
|
#include <shlobj.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#elif defined(XP_UNIX)
|
|
#include <unistd.h>
|
|
#include <stdlib.h>
|
|
#include <sys/param.h>
|
|
#include "prenv.h"
|
|
#ifdef MOZ_WIDGET_COCOA
|
|
#include <CoreServices/CoreServices.h>
|
|
#include <Carbon/Carbon.h>
|
|
#endif
|
|
#endif
|
|
|
|
#include "SpecialSystemDirectory.h"
|
|
#include "nsAppFileLocationProvider.h"
|
|
#include "BinaryPath.h"
|
|
|
|
using namespace mozilla;
|
|
|
|
//----------------------------------------------------------------------------------------
|
|
nsresult nsDirectoryService::GetCurrentProcessDirectory(nsIFile** aFile)
|
|
//----------------------------------------------------------------------------------------
|
|
{
|
|
if (NS_WARN_IF(!aFile)) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
*aFile = nullptr;
|
|
|
|
// Set the component registry location:
|
|
if (!gService) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
nsCOMPtr<nsIFile> file;
|
|
gService->Get(NS_XPCOM_INIT_CURRENT_PROCESS_DIR, NS_GET_IID(nsIFile),
|
|
getter_AddRefs(file));
|
|
if (file) {
|
|
file.forget(aFile);
|
|
return NS_OK;
|
|
}
|
|
|
|
if (NS_SUCCEEDED(BinaryPath::GetFile(getter_AddRefs(file)))) {
|
|
return file->GetParent(aFile);
|
|
}
|
|
NS_ERROR("unable to get current process directory");
|
|
return NS_ERROR_FAILURE;
|
|
} // GetCurrentProcessDirectory()
|
|
|
|
StaticRefPtr<nsDirectoryService> nsDirectoryService::gService;
|
|
|
|
nsDirectoryService::nsDirectoryService() : mHashtable(128) {}
|
|
|
|
nsresult nsDirectoryService::Create(nsISupports* aOuter, REFNSIID aIID,
|
|
void** aResult) {
|
|
if (NS_WARN_IF(!aResult)) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
if (NS_WARN_IF(aOuter)) {
|
|
return NS_ERROR_NO_AGGREGATION;
|
|
}
|
|
|
|
if (!gService) {
|
|
return NS_ERROR_NOT_INITIALIZED;
|
|
}
|
|
|
|
return gService->QueryInterface(aIID, aResult);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsDirectoryService::Init() {
|
|
MOZ_ASSERT_UNREACHABLE("nsDirectoryService::Init() for internal use only!");
|
|
return NS_OK;
|
|
}
|
|
|
|
void nsDirectoryService::RealInit() {
|
|
NS_ASSERTION(!gService,
|
|
"nsDirectoryService::RealInit Mustn't initialize twice!");
|
|
|
|
gService = new nsDirectoryService();
|
|
|
|
// Let the list hold the only reference to the provider.
|
|
nsAppFileLocationProvider* defaultProvider = new nsAppFileLocationProvider;
|
|
gService->mProviders.AppendElement(defaultProvider);
|
|
}
|
|
|
|
nsDirectoryService::~nsDirectoryService() {}
|
|
|
|
NS_IMPL_ISUPPORTS(nsDirectoryService, nsIProperties, nsIDirectoryService,
|
|
nsIDirectoryServiceProvider, nsIDirectoryServiceProvider2)
|
|
|
|
NS_IMETHODIMP
|
|
nsDirectoryService::Undefine(const char* aProp) {
|
|
if (NS_WARN_IF(!aProp)) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
|
|
nsDependentCString key(aProp);
|
|
return mHashtable.Remove(key) ? NS_OK : NS_ERROR_FAILURE;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsDirectoryService::GetKeys(uint32_t* aCount, char*** aKeys) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
struct MOZ_STACK_CLASS FileData {
|
|
FileData(const char* aProperty, const nsIID& aUUID)
|
|
: property(aProperty), data(nullptr), persistent(true), uuid(aUUID) {}
|
|
|
|
const char* property;
|
|
nsCOMPtr<nsISupports> data;
|
|
bool persistent;
|
|
const nsIID& uuid;
|
|
};
|
|
|
|
static bool FindProviderFile(nsIDirectoryServiceProvider* aElement,
|
|
FileData* aData) {
|
|
nsresult rv;
|
|
if (aData->uuid.Equals(NS_GET_IID(nsISimpleEnumerator))) {
|
|
// Not all providers implement this iface
|
|
nsCOMPtr<nsIDirectoryServiceProvider2> prov2 = do_QueryInterface(aElement);
|
|
if (prov2) {
|
|
nsCOMPtr<nsISimpleEnumerator> newFiles;
|
|
rv = prov2->GetFiles(aData->property, getter_AddRefs(newFiles));
|
|
if (NS_SUCCEEDED(rv) && newFiles) {
|
|
if (aData->data) {
|
|
nsCOMPtr<nsISimpleEnumerator> unionFiles;
|
|
|
|
NS_NewUnionEnumerator(getter_AddRefs(unionFiles),
|
|
(nsISimpleEnumerator*)aData->data.get(),
|
|
newFiles);
|
|
|
|
if (unionFiles) {
|
|
unionFiles.swap(*(nsISimpleEnumerator**)&aData->data);
|
|
}
|
|
} else {
|
|
aData->data = newFiles;
|
|
}
|
|
|
|
aData->persistent = false; // Enumerators can never be persistent
|
|
return rv == NS_SUCCESS_AGGREGATE_RESULT;
|
|
}
|
|
}
|
|
} else {
|
|
rv = aElement->GetFile(aData->property, &aData->persistent,
|
|
(nsIFile**)&aData->data);
|
|
if (NS_SUCCEEDED(rv) && aData->data) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsDirectoryService::Get(const char* aProp, const nsIID& aUuid, void** aResult) {
|
|
if (NS_WARN_IF(!aProp)) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
|
|
nsDependentCString key(aProp);
|
|
|
|
nsCOMPtr<nsIFile> cachedFile = mHashtable.Get(key);
|
|
|
|
if (cachedFile) {
|
|
nsCOMPtr<nsIFile> cloneFile;
|
|
cachedFile->Clone(getter_AddRefs(cloneFile));
|
|
return cloneFile->QueryInterface(aUuid, aResult);
|
|
}
|
|
|
|
// it is not one of our defaults, lets check any providers
|
|
FileData fileData(aProp, aUuid);
|
|
|
|
for (int32_t i = mProviders.Length() - 1; i >= 0; i--) {
|
|
if (!FindProviderFile(mProviders[i], &fileData)) {
|
|
break;
|
|
}
|
|
}
|
|
if (fileData.data) {
|
|
if (fileData.persistent) {
|
|
Set(aProp, static_cast<nsIFile*>(fileData.data.get()));
|
|
}
|
|
nsresult rv = (fileData.data)->QueryInterface(aUuid, aResult);
|
|
fileData.data = nullptr; // AddRef occurs in FindProviderFile()
|
|
return rv;
|
|
}
|
|
|
|
FindProviderFile(static_cast<nsIDirectoryServiceProvider*>(this), &fileData);
|
|
if (fileData.data) {
|
|
if (fileData.persistent) {
|
|
Set(aProp, static_cast<nsIFile*>(fileData.data.get()));
|
|
}
|
|
nsresult rv = (fileData.data)->QueryInterface(aUuid, aResult);
|
|
fileData.data = nullptr; // AddRef occurs in FindProviderFile()
|
|
return rv;
|
|
}
|
|
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsDirectoryService::Set(const char* aProp, nsISupports* aValue) {
|
|
if (NS_WARN_IF(!aProp)) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
if (!aValue) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
nsDependentCString key(aProp);
|
|
if (auto entry = mHashtable.LookupForAdd(key)) {
|
|
return NS_ERROR_FAILURE;
|
|
} else {
|
|
nsCOMPtr<nsIFile> ourFile = do_QueryInterface(aValue);
|
|
if (ourFile) {
|
|
nsCOMPtr<nsIFile> cloneFile;
|
|
ourFile->Clone(getter_AddRefs(cloneFile));
|
|
entry.OrInsert([&cloneFile]() { return cloneFile.forget(); });
|
|
return NS_OK;
|
|
}
|
|
mHashtable.Remove(key); // another hashtable lookup, but should be rare
|
|
}
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsDirectoryService::Has(const char* aProp, bool* aResult) {
|
|
if (NS_WARN_IF(!aProp)) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
|
|
*aResult = false;
|
|
nsCOMPtr<nsIFile> value;
|
|
nsresult rv = Get(aProp, NS_GET_IID(nsIFile), getter_AddRefs(value));
|
|
if (NS_FAILED(rv)) {
|
|
return NS_OK;
|
|
}
|
|
|
|
if (value) {
|
|
*aResult = true;
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsDirectoryService::RegisterProvider(nsIDirectoryServiceProvider* aProv) {
|
|
if (!aProv) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
mProviders.AppendElement(aProv);
|
|
return NS_OK;
|
|
}
|
|
|
|
void nsDirectoryService::RegisterCategoryProviders() {
|
|
nsCOMPtr<nsICategoryManager> catman(
|
|
do_GetService(NS_CATEGORYMANAGER_CONTRACTID));
|
|
if (!catman) {
|
|
return;
|
|
}
|
|
|
|
nsCOMPtr<nsISimpleEnumerator> entries;
|
|
catman->EnumerateCategory(XPCOM_DIRECTORY_PROVIDER_CATEGORY,
|
|
getter_AddRefs(entries));
|
|
|
|
for (auto& categoryEntry : SimpleEnumerator<nsICategoryEntry>(entries)) {
|
|
nsAutoCString contractID;
|
|
categoryEntry->GetValue(contractID);
|
|
|
|
if (nsCOMPtr<nsIDirectoryServiceProvider> provider =
|
|
do_GetService(contractID.get())) {
|
|
RegisterProvider(provider);
|
|
}
|
|
}
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsDirectoryService::UnregisterProvider(nsIDirectoryServiceProvider* aProv) {
|
|
if (!aProv) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
mProviders.RemoveElement(aProv);
|
|
return NS_OK;
|
|
}
|
|
|
|
#if defined(MOZ_CONTENT_SANDBOX) && defined(XP_WIN)
|
|
static nsresult GetLowIntegrityTempBase(nsIFile** aLowIntegrityTempBase) {
|
|
nsCOMPtr<nsIFile> localFile;
|
|
nsresult rv =
|
|
GetSpecialSystemDirectory(Win_LocalAppdataLow, getter_AddRefs(localFile));
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
rv = localFile->Append(NS_LITERAL_STRING(MOZ_USER_DIR));
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
localFile.forget(aLowIntegrityTempBase);
|
|
return rv;
|
|
}
|
|
#endif
|
|
|
|
// DO NOT ADD ANY LOCATIONS TO THIS FUNCTION UNTIL YOU TALK TO:
|
|
// dougt@netscape.com. This is meant to be a place of xpcom or system specific
|
|
// file locations, not application specific locations. If you need the later,
|
|
// register a callback for your application.
|
|
|
|
NS_IMETHODIMP
|
|
nsDirectoryService::GetFile(const char* aProp, bool* aPersistent,
|
|
nsIFile** aResult) {
|
|
nsCOMPtr<nsIFile> localFile;
|
|
nsresult rv = NS_ERROR_FAILURE;
|
|
|
|
*aResult = nullptr;
|
|
*aPersistent = true;
|
|
|
|
RefPtr<nsAtom> inAtom = NS_Atomize(aProp);
|
|
|
|
// check to see if it is one of our defaults
|
|
|
|
if (inAtom == nsGkAtoms::DirectoryService_CurrentProcess ||
|
|
inAtom == nsGkAtoms::DirectoryService_OS_CurrentProcessDirectory) {
|
|
rv = GetCurrentProcessDirectory(getter_AddRefs(localFile));
|
|
}
|
|
|
|
// Unless otherwise set, the core pieces of the GRE exist
|
|
// in the current process directory.
|
|
else if (inAtom == nsGkAtoms::DirectoryService_GRE_Directory ||
|
|
inAtom == nsGkAtoms::DirectoryService_GRE_BinDirectory) {
|
|
rv = GetCurrentProcessDirectory(getter_AddRefs(localFile));
|
|
} else if (inAtom == nsGkAtoms::DirectoryService_OS_TemporaryDirectory) {
|
|
rv = GetSpecialSystemDirectory(OS_TemporaryDirectory,
|
|
getter_AddRefs(localFile));
|
|
} else if (inAtom == nsGkAtoms::DirectoryService_OS_CurrentProcessDirectory) {
|
|
rv = GetSpecialSystemDirectory(OS_CurrentProcessDirectory,
|
|
getter_AddRefs(localFile));
|
|
} else if (inAtom == nsGkAtoms::DirectoryService_OS_CurrentWorkingDirectory) {
|
|
rv = GetSpecialSystemDirectory(OS_CurrentWorkingDirectory,
|
|
getter_AddRefs(localFile));
|
|
}
|
|
#if defined(MOZ_WIDGET_COCOA)
|
|
else if (inAtom == nsGkAtoms::DirectoryService_SystemDirectory) {
|
|
rv = GetOSXFolderType(kClassicDomain, kSystemFolderType,
|
|
getter_AddRefs(localFile));
|
|
} else if (inAtom == nsGkAtoms::DirectoryService_UserLibDirectory) {
|
|
rv = GetOSXFolderType(kUserDomain, kDomainLibraryFolderType,
|
|
getter_AddRefs(localFile));
|
|
} else if (inAtom == nsGkAtoms::Home) {
|
|
rv = GetOSXFolderType(kUserDomain, kDomainTopLevelFolderType,
|
|
getter_AddRefs(localFile));
|
|
} else if (inAtom == nsGkAtoms::DirectoryService_DefaultDownloadDirectory) {
|
|
rv = GetOSXFolderType(kUserDomain, kDownloadsFolderType,
|
|
getter_AddRefs(localFile));
|
|
if (NS_FAILED(rv)) {
|
|
rv = GetOSXFolderType(kUserDomain, kDesktopFolderType,
|
|
getter_AddRefs(localFile));
|
|
}
|
|
} else if (inAtom == nsGkAtoms::DirectoryService_OS_DesktopDirectory) {
|
|
rv = GetOSXFolderType(kUserDomain, kDesktopFolderType,
|
|
getter_AddRefs(localFile));
|
|
} else if (inAtom == nsGkAtoms::DirectoryService_LocalApplicationsDirectory) {
|
|
rv = GetOSXFolderType(kLocalDomain, kApplicationsFolderType,
|
|
getter_AddRefs(localFile));
|
|
} else if (inAtom == nsGkAtoms::DirectoryService_UserPreferencesDirectory) {
|
|
rv = GetOSXFolderType(kUserDomain, kPreferencesFolderType,
|
|
getter_AddRefs(localFile));
|
|
} else if (inAtom == nsGkAtoms::DirectoryService_PictureDocumentsDirectory) {
|
|
rv = GetOSXFolderType(kUserDomain, kPictureDocumentsFolderType,
|
|
getter_AddRefs(localFile));
|
|
}
|
|
#elif defined(XP_WIN)
|
|
else if (inAtom == nsGkAtoms::DirectoryService_SystemDirectory) {
|
|
rv = GetSpecialSystemDirectory(Win_SystemDirectory,
|
|
getter_AddRefs(localFile));
|
|
} else if (inAtom == nsGkAtoms::DirectoryService_WindowsDirectory) {
|
|
rv = GetSpecialSystemDirectory(Win_WindowsDirectory,
|
|
getter_AddRefs(localFile));
|
|
} else if (inAtom == nsGkAtoms::DirectoryService_WindowsProgramFiles) {
|
|
rv = GetSpecialSystemDirectory(Win_ProgramFiles, getter_AddRefs(localFile));
|
|
} else if (inAtom == nsGkAtoms::Home) {
|
|
rv =
|
|
GetSpecialSystemDirectory(Win_HomeDirectory, getter_AddRefs(localFile));
|
|
} else if (inAtom == nsGkAtoms::DirectoryService_Programs) {
|
|
rv = GetSpecialSystemDirectory(Win_Programs, getter_AddRefs(localFile));
|
|
} else if (inAtom == nsGkAtoms::DirectoryService_Favorites) {
|
|
rv = GetSpecialSystemDirectory(Win_Favorites, getter_AddRefs(localFile));
|
|
} else if (inAtom == nsGkAtoms::DirectoryService_OS_DesktopDirectory) {
|
|
rv = GetSpecialSystemDirectory(Win_Desktopdirectory,
|
|
getter_AddRefs(localFile));
|
|
} else if (inAtom == nsGkAtoms::DirectoryService_Appdata) {
|
|
rv = GetSpecialSystemDirectory(Win_Appdata, getter_AddRefs(localFile));
|
|
} else if (inAtom == nsGkAtoms::DirectoryService_LocalAppdata) {
|
|
rv = GetSpecialSystemDirectory(Win_LocalAppdata, getter_AddRefs(localFile));
|
|
#if defined(MOZ_CONTENT_SANDBOX)
|
|
} else if (inAtom == nsGkAtoms::DirectoryService_LocalAppdataLow) {
|
|
rv = GetSpecialSystemDirectory(Win_LocalAppdataLow,
|
|
getter_AddRefs(localFile));
|
|
} else if (inAtom == nsGkAtoms::DirectoryService_LowIntegrityTempBase) {
|
|
rv = GetLowIntegrityTempBase(getter_AddRefs(localFile));
|
|
#endif
|
|
} else if (inAtom == nsGkAtoms::DirectoryService_WinCookiesDirectory) {
|
|
rv = GetSpecialSystemDirectory(Win_Cookies, getter_AddRefs(localFile));
|
|
} else if (inAtom == nsGkAtoms::DirectoryService_DefaultDownloadDirectory) {
|
|
rv = GetSpecialSystemDirectory(Win_Downloads, getter_AddRefs(localFile));
|
|
}
|
|
#elif defined(XP_UNIX)
|
|
else if (inAtom == nsGkAtoms::Home) {
|
|
rv = GetSpecialSystemDirectory(Unix_HomeDirectory,
|
|
getter_AddRefs(localFile));
|
|
} else if (inAtom == nsGkAtoms::DirectoryService_OS_DesktopDirectory) {
|
|
rv = GetSpecialSystemDirectory(Unix_XDG_Desktop, getter_AddRefs(localFile));
|
|
*aPersistent = false;
|
|
} else if (inAtom == nsGkAtoms::DirectoryService_DefaultDownloadDirectory) {
|
|
rv =
|
|
GetSpecialSystemDirectory(Unix_XDG_Download, getter_AddRefs(localFile));
|
|
*aPersistent = false;
|
|
}
|
|
#endif
|
|
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
|
|
if (!localFile) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
localFile.forget(aResult);
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsDirectoryService::GetFiles(const char* aProp, nsISimpleEnumerator** aResult) {
|
|
if (NS_WARN_IF(!aResult)) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
*aResult = nullptr;
|
|
|
|
return NS_ERROR_FAILURE;
|
|
}
|