summaryrefslogtreecommitdiffstats
path: root/rdf/datasource/nsFileSystemDataSource.cpp
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /rdf/datasource/nsFileSystemDataSource.cpp
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'rdf/datasource/nsFileSystemDataSource.cpp')
-rw-r--r--rdf/datasource/nsFileSystemDataSource.cpp1328
1 files changed, 1328 insertions, 0 deletions
diff --git a/rdf/datasource/nsFileSystemDataSource.cpp b/rdf/datasource/nsFileSystemDataSource.cpp
new file mode 100644
index 000000000..35632d1a3
--- /dev/null
+++ b/rdf/datasource/nsFileSystemDataSource.cpp
@@ -0,0 +1,1328 @@
+/* -*- 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/. */
+
+/*
+ Implementation for a file system RDF data store.
+ */
+
+#include "nsFileSystemDataSource.h"
+
+#include <ctype.h> // for toupper()
+#include <stdio.h>
+#include "nsArrayEnumerator.h"
+#include "nsCOMArray.h"
+#include "nsIRDFDataSource.h"
+#include "nsIRDFObserver.h"
+#include "nsIServiceManager.h"
+#include "nsXPIDLString.h"
+#include "nsRDFCID.h"
+#include "rdfutil.h"
+#include "rdf.h"
+#include "nsEnumeratorUtils.h"
+#include "nsIURL.h"
+#include "nsIFileURL.h"
+#include "nsNetUtil.h"
+#include "nsIInputStream.h"
+#include "nsIChannel.h"
+#include "nsIFile.h"
+#include "nsEscape.h"
+#include "nsCRTGlue.h"
+#include "nsAutoPtr.h"
+#include "prtime.h"
+
+#ifdef XP_WIN
+#include "windef.h"
+#include "winbase.h"
+#include "nsILineInputStream.h"
+#include "nsDirectoryServiceDefs.h"
+#endif
+
+#define NS_MOZICON_SCHEME "moz-icon:"
+
+static const char kFileProtocol[] = "file://";
+
+bool
+FileSystemDataSource::isFileURI(nsIRDFResource *r)
+{
+ bool isFileURIFlag = false;
+ const char *uri = nullptr;
+
+ r->GetValueConst(&uri);
+ if ((uri) && (!strncmp(uri, kFileProtocol, sizeof(kFileProtocol) - 1)))
+ {
+ // XXX HACK HACK HACK
+ if (!strchr(uri, '#'))
+ {
+ isFileURIFlag = true;
+ }
+ }
+ return(isFileURIFlag);
+}
+
+
+
+bool
+FileSystemDataSource::isDirURI(nsIRDFResource* source)
+{
+ nsresult rv;
+ const char *uri = nullptr;
+
+ rv = source->GetValueConst(&uri);
+ if (NS_FAILED(rv)) return(false);
+
+ nsCOMPtr<nsIFile> aDir;
+
+ rv = NS_GetFileFromURLSpec(nsDependentCString(uri), getter_AddRefs(aDir));
+ if (NS_FAILED(rv)) return(false);
+
+ bool isDirFlag = false;
+
+ rv = aDir->IsDirectory(&isDirFlag);
+ if (NS_FAILED(rv)) return(false);
+
+ return(isDirFlag);
+}
+
+
+nsresult
+FileSystemDataSource::Init()
+{
+ nsresult rv;
+
+ mRDFService = do_GetService("@mozilla.org/rdf/rdf-service;1");
+ NS_ENSURE_TRUE(mRDFService, NS_ERROR_FAILURE);
+
+ rv = mRDFService->GetResource(NS_LITERAL_CSTRING("NC:FilesRoot"),
+ getter_AddRefs(mNC_FileSystemRoot));
+ nsresult tmp = mRDFService->GetResource(NS_LITERAL_CSTRING(NC_NAMESPACE_URI "child"),
+ getter_AddRefs(mNC_Child));
+ if (NS_FAILED(tmp)) {
+ rv = tmp;
+ }
+ tmp = mRDFService->GetResource(NS_LITERAL_CSTRING(NC_NAMESPACE_URI "Name"),
+ getter_AddRefs(mNC_Name));
+ if (NS_FAILED(tmp)) {
+ rv = tmp;
+ }
+ tmp = mRDFService->GetResource(NS_LITERAL_CSTRING(NC_NAMESPACE_URI "URL"),
+ getter_AddRefs(mNC_URL));
+ if (NS_FAILED(tmp)) {
+ rv = tmp;
+ }
+ tmp = mRDFService->GetResource(NS_LITERAL_CSTRING(NC_NAMESPACE_URI "Icon"),
+ getter_AddRefs(mNC_Icon));
+ if (NS_FAILED(tmp)) {
+ rv = tmp;
+ }
+ tmp = mRDFService->GetResource(NS_LITERAL_CSTRING(NC_NAMESPACE_URI "Content-Length"),
+ getter_AddRefs(mNC_Length));
+ if (NS_FAILED(tmp)) {
+ rv = tmp;
+ }
+ tmp = mRDFService->GetResource(NS_LITERAL_CSTRING(NC_NAMESPACE_URI "IsDirectory"),
+ getter_AddRefs(mNC_IsDirectory));
+ if (NS_FAILED(tmp)) {
+ rv = tmp;
+ }
+ tmp = mRDFService->GetResource(NS_LITERAL_CSTRING(WEB_NAMESPACE_URI "LastModifiedDate"),
+ getter_AddRefs(mWEB_LastMod));
+ if (NS_FAILED(tmp)) {
+ rv = tmp;
+ }
+ tmp = mRDFService->GetResource(NS_LITERAL_CSTRING(NC_NAMESPACE_URI "FileSystemObject"),
+ getter_AddRefs(mNC_FileSystemObject));
+ if (NS_FAILED(tmp)) {
+ rv = tmp;
+ }
+ tmp = mRDFService->GetResource(NS_LITERAL_CSTRING(NC_NAMESPACE_URI "pulse"),
+ getter_AddRefs(mNC_pulse));
+ if (NS_FAILED(tmp)) {
+ rv = tmp;
+ }
+ tmp = mRDFService->GetResource(NS_LITERAL_CSTRING(RDF_NAMESPACE_URI "instanceOf"),
+ getter_AddRefs(mRDF_InstanceOf));
+ if (NS_FAILED(tmp)) {
+ rv = tmp;
+ }
+ tmp = mRDFService->GetResource(NS_LITERAL_CSTRING(RDF_NAMESPACE_URI "type"),
+ getter_AddRefs(mRDF_type));
+
+ static const char16_t kTrue[] = {'t','r','u','e','\0'};
+ static const char16_t kFalse[] = {'f','a','l','s','e','\0'};
+
+ tmp = mRDFService->GetLiteral(kTrue, getter_AddRefs(mLiteralTrue));
+ if (NS_FAILED(tmp)) {
+ rv = tmp;
+ }
+ tmp = mRDFService->GetLiteral(kFalse, getter_AddRefs(mLiteralFalse));
+ if (NS_FAILED(tmp)) {
+ rv = tmp;
+ }
+ NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
+
+#ifdef USE_NC_EXTENSION
+ rv = mRDFService->GetResource(NS_LITERAL_CSTRING(NC_NAMESPACE_URI "extension"),
+ getter_AddRefs(mNC_extension));
+ NS_ENSURE_SUCCESS(rv, rv);
+#endif
+
+#ifdef XP_WIN
+ rv = mRDFService->GetResource(NS_LITERAL_CSTRING(NC_NAMESPACE_URI "IEFavorite"),
+ getter_AddRefs(mNC_IEFavoriteObject));
+ tmp = mRDFService->GetResource(NS_LITERAL_CSTRING(NC_NAMESPACE_URI "IEFavoriteFolder"),
+ getter_AddRefs(mNC_IEFavoriteFolder));
+ if (NS_FAILED(tmp)) {
+ rv = tmp;
+ }
+ NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
+
+ nsCOMPtr<nsIFile> file;
+ NS_GetSpecialDirectory(NS_WIN_FAVORITES_DIR, getter_AddRefs(file));
+ if (file)
+ {
+ nsCOMPtr<nsIURI> furi;
+ NS_NewFileURI(getter_AddRefs(furi), file);
+ NS_ENSURE_TRUE(furi, NS_ERROR_FAILURE);
+
+ file->GetNativePath(ieFavoritesDir);
+ }
+#endif
+
+ return NS_OK;
+}
+
+//static
+nsresult
+FileSystemDataSource::Create(nsISupports* aOuter, const nsIID& aIID, void **aResult)
+{
+ NS_ENSURE_NO_AGGREGATION(aOuter);
+
+ RefPtr<FileSystemDataSource> self = new FileSystemDataSource();
+ if (!self)
+ return NS_ERROR_OUT_OF_MEMORY;
+
+ nsresult rv = self->Init();
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ return self->QueryInterface(aIID, aResult);
+}
+
+NS_IMPL_ISUPPORTS(FileSystemDataSource, nsIRDFDataSource)
+
+NS_IMETHODIMP
+FileSystemDataSource::GetURI(char **uri)
+{
+ NS_PRECONDITION(uri != nullptr, "null ptr");
+ if (! uri)
+ return NS_ERROR_NULL_POINTER;
+
+ if ((*uri = NS_strdup("rdf:files")) == nullptr)
+ return NS_ERROR_OUT_OF_MEMORY;
+
+ return NS_OK;
+}
+
+
+
+NS_IMETHODIMP
+FileSystemDataSource::GetSource(nsIRDFResource* property,
+ nsIRDFNode* target,
+ bool tv,
+ nsIRDFResource** source /* out */)
+{
+ NS_PRECONDITION(property != nullptr, "null ptr");
+ if (! property)
+ return NS_ERROR_NULL_POINTER;
+
+ NS_PRECONDITION(target != nullptr, "null ptr");
+ if (! target)
+ return NS_ERROR_NULL_POINTER;
+
+ NS_PRECONDITION(source != nullptr, "null ptr");
+ if (! source)
+ return NS_ERROR_NULL_POINTER;
+
+ *source = nullptr;
+ return NS_RDF_NO_VALUE;
+}
+
+
+
+NS_IMETHODIMP
+FileSystemDataSource::GetSources(nsIRDFResource *property,
+ nsIRDFNode *target,
+ bool tv,
+ nsISimpleEnumerator **sources /* out */)
+{
+// NS_NOTYETIMPLEMENTED("write me");
+ return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+
+
+NS_IMETHODIMP
+FileSystemDataSource::GetTarget(nsIRDFResource *source,
+ nsIRDFResource *property,
+ bool tv,
+ nsIRDFNode **target /* out */)
+{
+ NS_PRECONDITION(source != nullptr, "null ptr");
+ if (! source)
+ return NS_ERROR_NULL_POINTER;
+
+ NS_PRECONDITION(property != nullptr, "null ptr");
+ if (! property)
+ return NS_ERROR_NULL_POINTER;
+
+ NS_PRECONDITION(target != nullptr, "null ptr");
+ if (! target)
+ return NS_ERROR_NULL_POINTER;
+
+ *target = nullptr;
+
+ nsresult rv = NS_RDF_NO_VALUE;
+
+ // we only have positive assertions in the file system data source.
+ if (! tv)
+ return NS_RDF_NO_VALUE;
+
+ if (source == mNC_FileSystemRoot)
+ {
+ if (property == mNC_pulse)
+ {
+ nsIRDFLiteral *pulseLiteral;
+ mRDFService->GetLiteral(u"12", &pulseLiteral);
+ *target = pulseLiteral;
+ return NS_OK;
+ }
+ }
+ else if (isFileURI(source))
+ {
+ if (property == mNC_Name)
+ {
+ nsCOMPtr<nsIRDFLiteral> name;
+ rv = GetName(source, getter_AddRefs(name));
+ if (NS_FAILED(rv)) return(rv);
+ if (!name) rv = NS_RDF_NO_VALUE;
+ if (rv == NS_RDF_NO_VALUE) return(rv);
+ return name->QueryInterface(NS_GET_IID(nsIRDFNode), (void**) target);
+ }
+ else if (property == mNC_URL)
+ {
+ nsCOMPtr<nsIRDFLiteral> url;
+ rv = GetURL(source, nullptr, getter_AddRefs(url));
+ if (NS_FAILED(rv)) return(rv);
+ if (!url) rv = NS_RDF_NO_VALUE;
+ if (rv == NS_RDF_NO_VALUE) return(rv);
+
+ return url->QueryInterface(NS_GET_IID(nsIRDFNode), (void**) target);
+ }
+ else if (property == mNC_Icon)
+ {
+ nsCOMPtr<nsIRDFLiteral> url;
+ bool isFavorite = false;
+ rv = GetURL(source, &isFavorite, getter_AddRefs(url));
+ if (NS_FAILED(rv)) return(rv);
+ if (isFavorite || !url) rv = NS_RDF_NO_VALUE;
+ if (rv == NS_RDF_NO_VALUE) return(rv);
+
+ const char16_t *uni = nullptr;
+ url->GetValueConst(&uni);
+ if (!uni) return(NS_RDF_NO_VALUE);
+ nsAutoString urlStr;
+ urlStr.AssignLiteral(NS_MOZICON_SCHEME);
+ urlStr.Append(uni);
+
+ rv = mRDFService->GetLiteral(urlStr.get(), getter_AddRefs(url));
+ if (NS_FAILED(rv) || !url) return(NS_RDF_NO_VALUE);
+ return url->QueryInterface(NS_GET_IID(nsIRDFNode), (void**) target);
+ }
+ else if (property == mNC_Length)
+ {
+ nsCOMPtr<nsIRDFInt> fileSize;
+ rv = GetFileSize(source, getter_AddRefs(fileSize));
+ if (NS_FAILED(rv)) return(rv);
+ if (!fileSize) rv = NS_RDF_NO_VALUE;
+ if (rv == NS_RDF_NO_VALUE) return(rv);
+
+ return fileSize->QueryInterface(NS_GET_IID(nsIRDFNode), (void**) target);
+ }
+ else if (property == mNC_IsDirectory)
+ {
+ *target = (isDirURI(source)) ? mLiteralTrue : mLiteralFalse;
+ NS_ADDREF(*target);
+ return NS_OK;
+ }
+ else if (property == mWEB_LastMod)
+ {
+ nsCOMPtr<nsIRDFDate> lastMod;
+ rv = GetLastMod(source, getter_AddRefs(lastMod));
+ if (NS_FAILED(rv)) return(rv);
+ if (!lastMod) rv = NS_RDF_NO_VALUE;
+ if (rv == NS_RDF_NO_VALUE) return(rv);
+
+ return lastMod->QueryInterface(NS_GET_IID(nsIRDFNode), (void**) target);
+ }
+ else if (property == mRDF_type)
+ {
+ nsCString type;
+ rv = mNC_FileSystemObject->GetValueUTF8(type);
+ if (NS_FAILED(rv)) return(rv);
+
+#ifdef XP_WIN
+ // under Windows, if its an IE favorite, return that type
+ if (!ieFavoritesDir.IsEmpty())
+ {
+ nsCString uri;
+ rv = source->GetValueUTF8(uri);
+ if (NS_FAILED(rv)) return(rv);
+
+ NS_ConvertUTF8toUTF16 theURI(uri);
+
+ if (theURI.Find(ieFavoritesDir) == 0)
+ {
+ if (theURI[theURI.Length() - 1] == '/')
+ {
+ rv = mNC_IEFavoriteFolder->GetValueUTF8(type);
+ }
+ else
+ {
+ rv = mNC_IEFavoriteObject->GetValueUTF8(type);
+ }
+ if (NS_FAILED(rv)) return(rv);
+ }
+ }
+#endif
+
+ NS_ConvertUTF8toUTF16 url(type);
+ nsCOMPtr<nsIRDFLiteral> literal;
+ mRDFService->GetLiteral(url.get(), getter_AddRefs(literal));
+ rv = literal->QueryInterface(NS_GET_IID(nsIRDFNode), (void**) target);
+ return(rv);
+ }
+ else if (property == mNC_pulse)
+ {
+ nsCOMPtr<nsIRDFLiteral> pulseLiteral;
+ mRDFService->GetLiteral(u"12", getter_AddRefs(pulseLiteral));
+ rv = pulseLiteral->QueryInterface(NS_GET_IID(nsIRDFNode), (void**) target);
+ return(rv);
+ }
+ else if (property == mNC_Child)
+ {
+ // Oh this is evil. Somebody kill me now.
+ nsCOMPtr<nsISimpleEnumerator> children;
+ rv = GetFolderList(source, false, true, getter_AddRefs(children));
+ if (NS_FAILED(rv) || (rv == NS_RDF_NO_VALUE)) return(rv);
+
+ bool hasMore;
+ rv = children->HasMoreElements(&hasMore);
+ if (NS_FAILED(rv)) return(rv);
+
+ if (hasMore)
+ {
+ nsCOMPtr<nsISupports> isupports;
+ rv = children->GetNext(getter_AddRefs(isupports));
+ if (NS_FAILED(rv)) return(rv);
+
+ return isupports->QueryInterface(NS_GET_IID(nsIRDFNode), (void**) target);
+ }
+ }
+#ifdef USE_NC_EXTENSION
+ else if (property == mNC_extension)
+ {
+ nsCOMPtr<nsIRDFLiteral> extension;
+ rv = GetExtension(source, getter_AddRefs(extension));
+ if (!extension) rv = NS_RDF_NO_VALUE;
+ if (rv == NS_RDF_NO_VALUE) return(rv);
+ return extension->QueryInterface(NS_GET_IID(nsIRDFNode), (void**) target);
+ }
+#endif
+ }
+
+ return(NS_RDF_NO_VALUE);
+}
+
+
+
+NS_IMETHODIMP
+FileSystemDataSource::GetTargets(nsIRDFResource *source,
+ nsIRDFResource *property,
+ bool tv,
+ nsISimpleEnumerator **targets /* out */)
+{
+ NS_PRECONDITION(source != nullptr, "null ptr");
+ if (! source)
+ return NS_ERROR_NULL_POINTER;
+
+ NS_PRECONDITION(property != nullptr, "null ptr");
+ if (! property)
+ return NS_ERROR_NULL_POINTER;
+
+ NS_PRECONDITION(targets != nullptr, "null ptr");
+ if (! targets)
+ return NS_ERROR_NULL_POINTER;
+
+ *targets = nullptr;
+
+ // we only have positive assertions in the file system data source.
+ if (! tv)
+ return NS_RDF_NO_VALUE;
+
+ nsresult rv;
+
+ if (source == mNC_FileSystemRoot)
+ {
+ if (property == mNC_Child)
+ {
+ return GetVolumeList(targets);
+ }
+ else if (property == mNC_pulse)
+ {
+ nsCOMPtr<nsIRDFLiteral> pulseLiteral;
+ mRDFService->GetLiteral(u"12",
+ getter_AddRefs(pulseLiteral));
+ return NS_NewSingletonEnumerator(targets, pulseLiteral);
+ }
+ }
+ else if (isFileURI(source))
+ {
+ if (property == mNC_Child)
+ {
+ return GetFolderList(source, false, false, targets);
+ }
+ else if (property == mNC_Name)
+ {
+ nsCOMPtr<nsIRDFLiteral> name;
+ rv = GetName(source, getter_AddRefs(name));
+ if (NS_FAILED(rv)) return rv;
+
+ return NS_NewSingletonEnumerator(targets, name);
+ }
+ else if (property == mNC_URL)
+ {
+ nsCOMPtr<nsIRDFLiteral> url;
+ rv = GetURL(source, nullptr, getter_AddRefs(url));
+ if (NS_FAILED(rv)) return rv;
+
+ return NS_NewSingletonEnumerator(targets, url);
+ }
+ else if (property == mRDF_type)
+ {
+ nsCString uri;
+ rv = mNC_FileSystemObject->GetValueUTF8(uri);
+ if (NS_FAILED(rv)) return rv;
+
+ NS_ConvertUTF8toUTF16 url(uri);
+
+ nsCOMPtr<nsIRDFLiteral> literal;
+ rv = mRDFService->GetLiteral(url.get(), getter_AddRefs(literal));
+ if (NS_FAILED(rv)) return rv;
+
+ return NS_NewSingletonEnumerator(targets, literal);
+ }
+ else if (property == mNC_pulse)
+ {
+ nsCOMPtr<nsIRDFLiteral> pulseLiteral;
+ rv = mRDFService->GetLiteral(u"12",
+ getter_AddRefs(pulseLiteral));
+ if (NS_FAILED(rv)) return rv;
+
+ return NS_NewSingletonEnumerator(targets, pulseLiteral);
+ }
+ }
+
+ return NS_NewEmptyEnumerator(targets);
+}
+
+
+
+NS_IMETHODIMP
+FileSystemDataSource::Assert(nsIRDFResource *source,
+ nsIRDFResource *property,
+ nsIRDFNode *target,
+ bool tv)
+{
+ return NS_RDF_ASSERTION_REJECTED;
+}
+
+
+
+NS_IMETHODIMP
+FileSystemDataSource::Unassert(nsIRDFResource *source,
+ nsIRDFResource *property,
+ nsIRDFNode *target)
+{
+ return NS_RDF_ASSERTION_REJECTED;
+}
+
+
+
+NS_IMETHODIMP
+FileSystemDataSource::Change(nsIRDFResource* aSource,
+ nsIRDFResource* aProperty,
+ nsIRDFNode* aOldTarget,
+ nsIRDFNode* aNewTarget)
+{
+ return NS_RDF_ASSERTION_REJECTED;
+}
+
+
+
+NS_IMETHODIMP
+FileSystemDataSource::Move(nsIRDFResource* aOldSource,
+ nsIRDFResource* aNewSource,
+ nsIRDFResource* aProperty,
+ nsIRDFNode* aTarget)
+{
+ return NS_RDF_ASSERTION_REJECTED;
+}
+
+
+
+NS_IMETHODIMP
+FileSystemDataSource::HasAssertion(nsIRDFResource *source,
+ nsIRDFResource *property,
+ nsIRDFNode *target,
+ bool tv,
+ bool *hasAssertion /* out */)
+{
+ NS_PRECONDITION(source != nullptr, "null ptr");
+ if (! source)
+ return NS_ERROR_NULL_POINTER;
+
+ NS_PRECONDITION(property != nullptr, "null ptr");
+ if (! property)
+ return NS_ERROR_NULL_POINTER;
+
+ NS_PRECONDITION(target != nullptr, "null ptr");
+ if (! target)
+ return NS_ERROR_NULL_POINTER;
+
+ NS_PRECONDITION(hasAssertion != nullptr, "null ptr");
+ if (! hasAssertion)
+ return NS_ERROR_NULL_POINTER;
+
+ // we only have positive assertions in the file system data source.
+ *hasAssertion = false;
+
+ if (! tv) {
+ return NS_OK;
+ }
+
+ if ((source == mNC_FileSystemRoot) || isFileURI(source))
+ {
+ if (property == mRDF_type)
+ {
+ nsCOMPtr<nsIRDFResource> resource( do_QueryInterface(target) );
+ if (resource.get() == mRDF_type)
+ {
+ *hasAssertion = true;
+ }
+ }
+#ifdef USE_NC_EXTENSION
+ else if (property == mNC_extension)
+ {
+ // Cheat just a little here by making dirs always match
+ if (isDirURI(source))
+ {
+ *hasAssertion = true;
+ }
+ else
+ {
+ nsCOMPtr<nsIRDFLiteral> extension;
+ GetExtension(source, getter_AddRefs(extension));
+ if (extension.get() == target)
+ {
+ *hasAssertion = true;
+ }
+ }
+ }
+#endif
+ else if (property == mNC_IsDirectory)
+ {
+ bool isDir = isDirURI(source);
+ bool isEqual = false;
+ target->EqualsNode(mLiteralTrue, &isEqual);
+ if (isEqual)
+ {
+ *hasAssertion = isDir;
+ }
+ else
+ {
+ target->EqualsNode(mLiteralFalse, &isEqual);
+ if (isEqual)
+ *hasAssertion = !isDir;
+ }
+ }
+ }
+
+ return NS_OK;
+}
+
+
+
+NS_IMETHODIMP
+FileSystemDataSource::HasArcIn(nsIRDFNode *aNode, nsIRDFResource *aArc, bool *result)
+{
+ return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+
+
+NS_IMETHODIMP
+FileSystemDataSource::HasArcOut(nsIRDFResource *aSource, nsIRDFResource *aArc, bool *result)
+{
+ *result = false;
+
+ if (aSource == mNC_FileSystemRoot)
+ {
+ *result = (aArc == mNC_Child || aArc == mNC_pulse);
+ }
+ else if (isFileURI(aSource))
+ {
+ if (aArc == mNC_pulse)
+ {
+ *result = true;
+ }
+ else if (isDirURI(aSource))
+ {
+#ifdef XP_WIN
+ *result = isValidFolder(aSource);
+#else
+ *result = true;
+#endif
+ }
+ else if (aArc == mNC_pulse || aArc == mNC_Name || aArc == mNC_Icon ||
+ aArc == mNC_URL || aArc == mNC_Length || aArc == mWEB_LastMod ||
+ aArc == mNC_FileSystemObject || aArc == mRDF_InstanceOf ||
+ aArc == mRDF_type)
+ {
+ *result = true;
+ }
+ }
+ return NS_OK;
+}
+
+
+
+NS_IMETHODIMP
+FileSystemDataSource::ArcLabelsIn(nsIRDFNode *node,
+ nsISimpleEnumerator ** labels /* out */)
+{
+// NS_NOTYETIMPLEMENTED("write me");
+ return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+
+
+NS_IMETHODIMP
+FileSystemDataSource::ArcLabelsOut(nsIRDFResource *source,
+ nsISimpleEnumerator **labels /* out */)
+{
+ NS_PRECONDITION(source != nullptr, "null ptr");
+ if (! source)
+ return NS_ERROR_NULL_POINTER;
+
+ NS_PRECONDITION(labels != nullptr, "null ptr");
+ if (! labels)
+ return NS_ERROR_NULL_POINTER;
+
+ if (source == mNC_FileSystemRoot)
+ {
+ nsCOMArray<nsIRDFResource> resources;
+ resources.SetCapacity(2);
+
+ resources.AppendObject(mNC_Child);
+ resources.AppendObject(mNC_pulse);
+
+ return NS_NewArrayEnumerator(labels, resources);
+ }
+ else if (isFileURI(source))
+ {
+ nsCOMArray<nsIRDFResource> resources;
+ resources.SetCapacity(2);
+
+ if (isDirURI(source))
+ {
+#ifdef XP_WIN
+ if (isValidFolder(source))
+ {
+ resources.AppendObject(mNC_Child);
+ }
+#else
+ resources.AppendObject(mNC_Child);
+#endif
+ resources.AppendObject(mNC_pulse);
+ }
+
+ return NS_NewArrayEnumerator(labels, resources);
+ }
+
+ return NS_NewEmptyEnumerator(labels);
+}
+
+
+
+NS_IMETHODIMP
+FileSystemDataSource::GetAllResources(nsISimpleEnumerator** aCursor)
+{
+ NS_NOTYETIMPLEMENTED("sorry!");
+ return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+
+
+NS_IMETHODIMP
+FileSystemDataSource::AddObserver(nsIRDFObserver *n)
+{
+ return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+
+
+NS_IMETHODIMP
+FileSystemDataSource::RemoveObserver(nsIRDFObserver *n)
+{
+ return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+
+
+NS_IMETHODIMP
+FileSystemDataSource::GetAllCmds(nsIRDFResource* source,
+ nsISimpleEnumerator/*<nsIRDFResource>*/** commands)
+{
+ return(NS_NewEmptyEnumerator(commands));
+}
+
+
+
+NS_IMETHODIMP
+FileSystemDataSource::IsCommandEnabled(nsISupports/*<nsIRDFResource>*/* aSources,
+ nsIRDFResource* aCommand,
+ nsISupports/*<nsIRDFResource>*/* aArguments,
+ bool* aResult)
+{
+ return(NS_ERROR_NOT_IMPLEMENTED);
+}
+
+
+
+NS_IMETHODIMP
+FileSystemDataSource::DoCommand(nsISupports/*<nsIRDFResource>*/* aSources,
+ nsIRDFResource* aCommand,
+ nsISupports/*<nsIRDFResource>*/* aArguments)
+{
+ return(NS_ERROR_NOT_IMPLEMENTED);
+}
+
+
+
+NS_IMETHODIMP
+FileSystemDataSource::BeginUpdateBatch()
+{
+ return NS_OK;
+}
+
+
+
+NS_IMETHODIMP
+FileSystemDataSource::EndUpdateBatch()
+{
+ return NS_OK;
+}
+
+
+
+nsresult
+FileSystemDataSource::GetVolumeList(nsISimpleEnumerator** aResult)
+{
+ nsCOMArray<nsIRDFResource> volumes;
+ nsCOMPtr<nsIRDFResource> vol;
+
+#ifdef XP_WIN
+
+ int32_t driveType;
+ wchar_t drive[32];
+ int32_t volNum;
+
+ for (volNum = 0; volNum < 26; volNum++)
+ {
+ swprintf_s(drive, 32, L"%c:\\", volNum + (char16_t)'A');
+
+ driveType = GetDriveTypeW(drive);
+ if (driveType != DRIVE_UNKNOWN && driveType != DRIVE_NO_ROOT_DIR)
+ {
+ nsAutoCString url;
+ url.AppendPrintf("file:///%c|/", volNum + 'A');
+ nsresult rv = mRDFService->GetResource(url, getter_AddRefs(vol));
+ if (NS_FAILED(rv))
+ return rv;
+
+ volumes.AppendObject(vol);
+ }
+ }
+#endif
+
+#ifdef XP_UNIX
+ mRDFService->GetResource(NS_LITERAL_CSTRING("file:///"), getter_AddRefs(vol));
+ volumes.AppendObject(vol);
+#endif
+
+ return NS_NewArrayEnumerator(aResult, volumes);
+}
+
+
+
+#ifdef XP_WIN
+bool
+FileSystemDataSource::isValidFolder(nsIRDFResource *source)
+{
+ bool isValid = true;
+ if (ieFavoritesDir.IsEmpty()) return(isValid);
+
+ nsresult rv;
+ nsCString uri;
+ rv = source->GetValueUTF8(uri);
+ if (NS_FAILED(rv)) return(isValid);
+
+ NS_ConvertUTF8toUTF16 theURI(uri);
+ if (theURI.Find(ieFavoritesDir) == 0)
+ {
+ isValid = false;
+
+ nsCOMPtr<nsISimpleEnumerator> folderEnum;
+ if (NS_SUCCEEDED(rv = GetFolderList(source, true, false, getter_AddRefs(folderEnum))))
+ {
+ bool hasAny = false, hasMore;
+ while (NS_SUCCEEDED(folderEnum->HasMoreElements(&hasMore)) &&
+ hasMore)
+ {
+ hasAny = true;
+
+ nsCOMPtr<nsISupports> isupports;
+ if (NS_FAILED(rv = folderEnum->GetNext(getter_AddRefs(isupports))))
+ break;
+ nsCOMPtr<nsIRDFResource> res = do_QueryInterface(isupports);
+ if (!res) break;
+
+ nsCOMPtr<nsIRDFLiteral> nameLiteral;
+ if (NS_FAILED(rv = GetName(res, getter_AddRefs(nameLiteral))))
+ break;
+
+ const char16_t *uniName;
+ if (NS_FAILED(rv = nameLiteral->GetValueConst(&uniName)))
+ break;
+ nsAutoString name(uniName);
+
+ // An empty folder, or a folder that contains just "desktop.ini",
+ // is considered to be a IE Favorite; otherwise, its a folder
+ if (!name.LowerCaseEqualsLiteral("desktop.ini"))
+ {
+ isValid = true;
+ break;
+ }
+ }
+ if (!hasAny) isValid = true;
+ }
+ }
+ return(isValid);
+}
+#endif
+
+
+
+nsresult
+FileSystemDataSource::GetFolderList(nsIRDFResource *source, bool allowHidden,
+ bool onlyFirst, nsISimpleEnumerator** aResult)
+{
+ if (!isDirURI(source))
+ return(NS_RDF_NO_VALUE);
+
+ nsresult rv;
+
+ const char *parentURI = nullptr;
+ rv = source->GetValueConst(&parentURI);
+ if (NS_FAILED(rv))
+ return(rv);
+ if (!parentURI)
+ return(NS_ERROR_UNEXPECTED);
+
+ nsCOMPtr<nsIURI> aIURI;
+ if (NS_FAILED(rv = NS_NewURI(getter_AddRefs(aIURI), nsDependentCString(parentURI))))
+ return(rv);
+
+ nsCOMPtr<nsIFileURL> fileURL = do_QueryInterface(aIURI);
+ if (!fileURL)
+ return NS_OK;
+
+ nsCOMPtr<nsIFile> aDir;
+ if (NS_FAILED(rv = fileURL->GetFile(getter_AddRefs(aDir))))
+ return(rv);
+
+ // ensure that we DO NOT resolve aliases
+ aDir->SetFollowLinks(false);
+
+ nsCOMPtr<nsISimpleEnumerator> dirContents;
+ if (NS_FAILED(rv = aDir->GetDirectoryEntries(getter_AddRefs(dirContents))))
+ return(rv);
+ if (!dirContents)
+ return(NS_ERROR_UNEXPECTED);
+
+ nsCOMArray<nsIRDFResource> resources;
+ bool hasMore;
+ while(NS_SUCCEEDED(rv = dirContents->HasMoreElements(&hasMore)) &&
+ hasMore)
+ {
+ nsCOMPtr<nsISupports> isupports;
+ if (NS_FAILED(rv = dirContents->GetNext(getter_AddRefs(isupports))))
+ break;
+
+ nsCOMPtr<nsIFile> aFile = do_QueryInterface(isupports);
+ if (!aFile)
+ break;
+
+ if (!allowHidden)
+ {
+ bool hiddenFlag = false;
+ if (NS_FAILED(rv = aFile->IsHidden(&hiddenFlag)))
+ break;
+ if (hiddenFlag)
+ continue;
+ }
+
+ nsAutoString leafStr;
+ if (NS_FAILED(rv = aFile->GetLeafName(leafStr)))
+ break;
+ if (leafStr.IsEmpty())
+ continue;
+
+ nsAutoCString fullURI;
+ fullURI.Assign(parentURI);
+ if (fullURI.Last() != '/')
+ {
+ fullURI.Append('/');
+ }
+
+ nsAutoCString leaf;
+ bool escaped = NS_Escape(NS_ConvertUTF16toUTF8(leafStr), leaf, url_Path);
+ leafStr.Truncate();
+
+ if (!escaped) {
+ continue;
+ }
+
+ // using nsEscape() [above] doesn't escape slashes, so do that by hand
+ int32_t aOffset;
+ while ((aOffset = leaf.FindChar('/')) >= 0)
+ {
+ leaf.Cut((uint32_t)aOffset, 1);
+ leaf.Insert("%2F", (uint32_t)aOffset);
+ }
+
+ // append the encoded name
+ fullURI.Append(leaf);
+
+ bool dirFlag = false;
+ rv = aFile->IsDirectory(&dirFlag);
+ if (NS_SUCCEEDED(rv) && dirFlag)
+ {
+ fullURI.Append('/');
+ }
+
+ nsCOMPtr<nsIRDFResource> fileRes;
+ mRDFService->GetResource(fullURI, getter_AddRefs(fileRes));
+
+ resources.AppendObject(fileRes);
+
+ if (onlyFirst)
+ break;
+ }
+
+ return NS_NewArrayEnumerator(aResult, resources);
+}
+
+nsresult
+FileSystemDataSource::GetLastMod(nsIRDFResource *source, nsIRDFDate **aResult)
+{
+ *aResult = nullptr;
+
+ nsresult rv;
+ const char *uri = nullptr;
+
+ rv = source->GetValueConst(&uri);
+ if (NS_FAILED(rv)) return(rv);
+ if (!uri)
+ return(NS_ERROR_UNEXPECTED);
+
+ nsCOMPtr<nsIURI> aIURI;
+ if (NS_FAILED(rv = NS_NewURI(getter_AddRefs(aIURI), nsDependentCString(uri))))
+ return(rv);
+
+ nsCOMPtr<nsIFileURL> fileURL = do_QueryInterface(aIURI);
+ if (!fileURL)
+ return NS_OK;
+
+ nsCOMPtr<nsIFile> aFile;
+ if (NS_FAILED(rv = fileURL->GetFile(getter_AddRefs(aFile))))
+ return(rv);
+ if (!aFile)
+ return(NS_ERROR_UNEXPECTED);
+
+ // ensure that we DO NOT resolve aliases
+ aFile->SetFollowLinks(false);
+
+ PRTime lastModDate;
+ if (NS_FAILED(rv = aFile->GetLastModifiedTime(&lastModDate)))
+ return(rv);
+
+ // convert from milliseconds to seconds
+ mRDFService->GetDateLiteral(lastModDate * PR_MSEC_PER_SEC, aResult);
+
+ return(NS_OK);
+}
+
+
+
+nsresult
+FileSystemDataSource::GetFileSize(nsIRDFResource *source, nsIRDFInt **aResult)
+{
+ *aResult = nullptr;
+
+ nsresult rv;
+ const char *uri = nullptr;
+
+ rv = source->GetValueConst(&uri);
+ if (NS_FAILED(rv))
+ return(rv);
+ if (!uri)
+ return(NS_ERROR_UNEXPECTED);
+
+ nsCOMPtr<nsIURI> aIURI;
+ if (NS_FAILED(rv = NS_NewURI(getter_AddRefs(aIURI), nsDependentCString(uri))))
+ return(rv);
+
+ nsCOMPtr<nsIFileURL> fileURL = do_QueryInterface(aIURI);
+ if (!fileURL)
+ return NS_OK;
+
+ nsCOMPtr<nsIFile> aFile;
+ if (NS_FAILED(rv = fileURL->GetFile(getter_AddRefs(aFile))))
+ return(rv);
+ if (!aFile)
+ return(NS_ERROR_UNEXPECTED);
+
+ // ensure that we DO NOT resolve aliases
+ aFile->SetFollowLinks(false);
+
+ // don't do anything with directories
+ bool isDir = false;
+ if (NS_FAILED(rv = aFile->IsDirectory(&isDir)))
+ return(rv);
+ if (isDir)
+ return(NS_RDF_NO_VALUE);
+
+ int64_t aFileSize64;
+ if (NS_FAILED(rv = aFile->GetFileSize(&aFileSize64)))
+ return(rv);
+
+ // convert 64bits to 32bits
+ int32_t aFileSize32 = int32_t(aFileSize64);
+ mRDFService->GetIntLiteral(aFileSize32, aResult);
+
+ return(NS_OK);
+}
+
+
+
+nsresult
+FileSystemDataSource::GetName(nsIRDFResource *source, nsIRDFLiteral **aResult)
+{
+ nsresult rv;
+ const char *uri = nullptr;
+
+ rv = source->GetValueConst(&uri);
+ if (NS_FAILED(rv))
+ return(rv);
+ if (!uri)
+ return(NS_ERROR_UNEXPECTED);
+
+ nsCOMPtr<nsIURI> aIURI;
+ if (NS_FAILED(rv = NS_NewURI(getter_AddRefs(aIURI), nsDependentCString(uri))))
+ return(rv);
+
+ nsCOMPtr<nsIFileURL> fileURL = do_QueryInterface(aIURI);
+ if (!fileURL)
+ return NS_OK;
+
+ nsCOMPtr<nsIFile> aFile;
+ if (NS_FAILED(rv = fileURL->GetFile(getter_AddRefs(aFile))))
+ return(rv);
+ if (!aFile)
+ return(NS_ERROR_UNEXPECTED);
+
+ // ensure that we DO NOT resolve aliases
+ aFile->SetFollowLinks(false);
+
+ nsAutoString name;
+ if (NS_FAILED(rv = aFile->GetLeafName(name)))
+ return(rv);
+ if (name.IsEmpty())
+ return(NS_ERROR_UNEXPECTED);
+
+#ifdef XP_WIN
+ // special hack for IE favorites under Windows; strip off the
+ // trailing ".url" or ".lnk" at the end of IE favorites names
+ int32_t nameLen = name.Length();
+ if ((strncmp(uri, ieFavoritesDir.get(), ieFavoritesDir.Length()) == 0) && (nameLen > 4))
+ {
+ nsAutoString extension;
+ name.Right(extension, 4);
+ if (extension.LowerCaseEqualsLiteral(".url") ||
+ extension.LowerCaseEqualsLiteral(".lnk"))
+ {
+ name.Truncate(nameLen - 4);
+ }
+ }
+#endif
+
+ mRDFService->GetLiteral(name.get(), aResult);
+
+ return NS_OK;
+}
+
+
+
+#ifdef USE_NC_EXTENSION
+nsresult
+FileSystemDataSource::GetExtension(nsIRDFResource *source, nsIRDFLiteral **aResult)
+{
+ nsCOMPtr<nsIRDFLiteral> name;
+ nsresult rv = GetName(source, getter_AddRefs(name));
+ if (NS_FAILED(rv))
+ return rv;
+
+ const char16_t* unicodeLeafName;
+ rv = name->GetValueConst(&unicodeLeafName);
+ if (NS_FAILED(rv))
+ return rv;
+
+ nsAutoString filename(unicodeLeafName);
+ int32_t lastDot = filename.RFindChar('.');
+ if (lastDot == -1)
+ {
+ mRDFService->GetLiteral(EmptyString().get(), aResult);
+ }
+ else
+ {
+ nsAutoString extension;
+ filename.Right(extension, (filename.Length() - lastDot));
+ mRDFService->GetLiteral(extension.get(), aResult);
+ }
+
+ return NS_OK;
+}
+#endif
+
+#ifdef XP_WIN
+nsresult
+FileSystemDataSource::getIEFavoriteURL(nsIRDFResource *source, nsString aFileURL, nsIRDFLiteral **urlLiteral)
+{
+ nsresult rv = NS_OK;
+
+ *urlLiteral = nullptr;
+
+ nsCOMPtr<nsIFile> f;
+ NS_GetFileFromURLSpec(NS_ConvertUTF16toUTF8(aFileURL), getter_AddRefs(f));
+
+ bool value;
+
+ if (NS_SUCCEEDED(f->IsDirectory(&value)) && value)
+ {
+ if (isValidFolder(source))
+ return(NS_RDF_NO_VALUE);
+ aFileURL.AppendLiteral("desktop.ini");
+ }
+ else if (aFileURL.Length() > 4)
+ {
+ nsAutoString extension;
+
+ aFileURL.Right(extension, 4);
+ if (!extension.LowerCaseEqualsLiteral(".url"))
+ {
+ return(NS_RDF_NO_VALUE);
+ }
+ }
+
+ nsCOMPtr<nsIInputStream> strm;
+ NS_NewLocalFileInputStream(getter_AddRefs(strm),f);
+ nsCOMPtr<nsILineInputStream> linereader = do_QueryInterface(strm, &rv);
+
+ nsAutoString line;
+ nsAutoCString cLine;
+ while(NS_SUCCEEDED(rv))
+ {
+ bool isEOF;
+ rv = linereader->ReadLine(cLine, &isEOF);
+ CopyASCIItoUTF16(cLine, line);
+
+ if (isEOF)
+ {
+ if (line.Find("URL=", true) == 0)
+ {
+ line.Cut(0, 4);
+ rv = mRDFService->GetLiteral(line.get(), urlLiteral);
+ break;
+ }
+ else if (line.Find("CDFURL=", true) == 0)
+ {
+ line.Cut(0, 7);
+ rv = mRDFService->GetLiteral(line.get(), urlLiteral);
+ break;
+ }
+ line.Truncate();
+ }
+ }
+
+ return(rv);
+}
+#endif
+
+
+
+nsresult
+FileSystemDataSource::GetURL(nsIRDFResource *source, bool *isFavorite, nsIRDFLiteral** aResult)
+{
+ if (isFavorite) *isFavorite = false;
+
+ nsresult rv;
+ nsCString uri;
+
+ rv = source->GetValueUTF8(uri);
+ if (NS_FAILED(rv))
+ return(rv);
+
+ NS_ConvertUTF8toUTF16 url(uri);
+
+#ifdef XP_WIN
+ // under Windows, if its an IE favorite, munge the URL
+ if (!ieFavoritesDir.IsEmpty())
+ {
+ if (url.Find(ieFavoritesDir) == 0)
+ {
+ if (isFavorite) *isFavorite = true;
+ rv = getIEFavoriteURL(source, url, aResult);
+ return(rv);
+ }
+ }
+#endif
+
+ // if we fall through to here, its not any type of bookmark
+ // stored in the platform native file system, so just set the URL
+
+ mRDFService->GetLiteral(url.get(), aResult);
+
+ return(NS_OK);
+}