eee822b6b3
Backed out changeset b13265489a7a (bug 1928020) Backed out changeset bbf8b7208dc4 (bug 1928020) Backed out changeset 4473a69a450c (bug 1928020) Backed out changeset 0ce2a98a7a53 (bug 1928020)
405 lines
13 KiB
C++
405 lines
13 KiB
C++
/* vim: sw=2 ts=2 et lcs=trail\:.,tab\:>~ :
|
|
* 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 "Helpers.h"
|
|
#include "mozIStorageError.h"
|
|
#include "prio.h"
|
|
#include "nsIFile.h"
|
|
#include "nsReadableUtils.h"
|
|
#include "nsString.h"
|
|
#include "nsNavHistory.h"
|
|
#include "nsNetUtil.h"
|
|
#include "mozilla/Base64.h"
|
|
#include "mozilla/HashFunctions.h"
|
|
#include "mozilla/RandomNum.h"
|
|
#include <algorithm>
|
|
#include "mozilla/Services.h"
|
|
|
|
// The length of guids that are used by history and bookmarks.
|
|
#define GUID_LENGTH 12
|
|
|
|
// Maximum number of chars to use for calculating hashes. This value has been
|
|
// picked to ensure low hash collisions on a real world common places.sqlite.
|
|
// While collisions are not a big deal for functionality, a low ratio allows
|
|
// for slightly more efficient SELECTs.
|
|
#define MAX_CHARS_TO_HASH 1500U
|
|
|
|
extern "C" {
|
|
|
|
// Generates a new Places GUID. This function uses C linkage because it's
|
|
// called from the Rust synced bookmarks mirror, on the storage thread.
|
|
nsresult NS_GeneratePlacesGUID(nsACString* _guid) {
|
|
return mozilla::places::GenerateGUID(*_guid);
|
|
}
|
|
|
|
} // extern "C"
|
|
|
|
namespace mozilla {
|
|
namespace places {
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
//// AsyncStatementCallback
|
|
|
|
NS_IMPL_ISUPPORTS(AsyncStatementCallback, mozIStorageStatementCallback)
|
|
|
|
NS_IMETHODIMP
|
|
WeakAsyncStatementCallback::HandleResult(mozIStorageResultSet* aResultSet) {
|
|
MOZ_ASSERT(false, "Was not expecting a resultset, but got it.");
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
WeakAsyncStatementCallback::HandleCompletion(uint16_t aReason) { return NS_OK; }
|
|
|
|
NS_IMETHODIMP
|
|
WeakAsyncStatementCallback::HandleError(mozIStorageError* aError) {
|
|
#ifdef DEBUG
|
|
int32_t result;
|
|
nsresult rv = aError->GetResult(&result);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
nsAutoCString message;
|
|
rv = aError->GetMessage(message);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
nsAutoCString warnMsg;
|
|
warnMsg.AppendLiteral(
|
|
"An error occurred while executing an async statement: ");
|
|
warnMsg.AppendInt(result);
|
|
warnMsg.Append(' ');
|
|
warnMsg.Append(message);
|
|
NS_WARNING(warnMsg.get());
|
|
#endif
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
#define URI_TO_URLCSTRING(uri, spec) \
|
|
nsAutoCString spec; \
|
|
if (NS_FAILED(aURI->GetSpec(spec))) { \
|
|
return NS_ERROR_UNEXPECTED; \
|
|
}
|
|
|
|
// Bind URI to statement by index.
|
|
nsresult // static
|
|
URIBinder::Bind(mozIStorageStatement* aStatement, int32_t aIndex,
|
|
nsIURI* aURI) {
|
|
NS_ASSERTION(aStatement, "Must have non-null statement");
|
|
NS_ASSERTION(aURI, "Must have non-null uri");
|
|
|
|
URI_TO_URLCSTRING(aURI, spec);
|
|
return URIBinder::Bind(aStatement, aIndex, spec);
|
|
}
|
|
|
|
// Statement URLCString to statement by index.
|
|
nsresult // static
|
|
URIBinder::Bind(mozIStorageStatement* aStatement, int32_t index,
|
|
const nsACString& aURLString) {
|
|
NS_ASSERTION(aStatement, "Must have non-null statement");
|
|
return aStatement->BindUTF8StringByIndex(
|
|
index, StringHead(aURLString, URI_LENGTH_MAX));
|
|
}
|
|
|
|
// Bind URI to statement by name.
|
|
nsresult // static
|
|
URIBinder::Bind(mozIStorageStatement* aStatement, const nsACString& aName,
|
|
nsIURI* aURI) {
|
|
NS_ASSERTION(aStatement, "Must have non-null statement");
|
|
NS_ASSERTION(aURI, "Must have non-null uri");
|
|
|
|
URI_TO_URLCSTRING(aURI, spec);
|
|
return URIBinder::Bind(aStatement, aName, spec);
|
|
}
|
|
|
|
// Bind URLCString to statement by name.
|
|
nsresult // static
|
|
URIBinder::Bind(mozIStorageStatement* aStatement, const nsACString& aName,
|
|
const nsACString& aURLString) {
|
|
NS_ASSERTION(aStatement, "Must have non-null statement");
|
|
return aStatement->BindUTF8StringByName(
|
|
aName, StringHead(aURLString, URI_LENGTH_MAX));
|
|
}
|
|
|
|
// Bind URI to params by index.
|
|
nsresult // static
|
|
URIBinder::Bind(mozIStorageBindingParams* aParams, int32_t aIndex,
|
|
nsIURI* aURI) {
|
|
NS_ASSERTION(aParams, "Must have non-null statement");
|
|
NS_ASSERTION(aURI, "Must have non-null uri");
|
|
|
|
URI_TO_URLCSTRING(aURI, spec);
|
|
return URIBinder::Bind(aParams, aIndex, spec);
|
|
}
|
|
|
|
// Bind URLCString to params by index.
|
|
nsresult // static
|
|
URIBinder::Bind(mozIStorageBindingParams* aParams, int32_t index,
|
|
const nsACString& aURLString) {
|
|
NS_ASSERTION(aParams, "Must have non-null statement");
|
|
return aParams->BindUTF8StringByIndex(index,
|
|
StringHead(aURLString, URI_LENGTH_MAX));
|
|
}
|
|
|
|
// Bind URI to params by name.
|
|
nsresult // static
|
|
URIBinder::Bind(mozIStorageBindingParams* aParams, const nsACString& aName,
|
|
nsIURI* aURI) {
|
|
NS_ASSERTION(aParams, "Must have non-null params array");
|
|
NS_ASSERTION(aURI, "Must have non-null uri");
|
|
|
|
URI_TO_URLCSTRING(aURI, spec);
|
|
return URIBinder::Bind(aParams, aName, spec);
|
|
}
|
|
|
|
// Bind URLCString to params by name.
|
|
nsresult // static
|
|
URIBinder::Bind(mozIStorageBindingParams* aParams, const nsACString& aName,
|
|
const nsACString& aURLString) {
|
|
NS_ASSERTION(aParams, "Must have non-null params array");
|
|
|
|
nsresult rv = aParams->BindUTF8StringByName(
|
|
aName, StringHead(aURLString, URI_LENGTH_MAX));
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
return NS_OK;
|
|
}
|
|
|
|
#undef URI_TO_URLCSTRING
|
|
|
|
nsresult GetReversedHostname(nsIURI* aURI, nsString& aRevHost) {
|
|
nsAutoCString forward8;
|
|
nsresult rv = aURI->GetHost(forward8);
|
|
// Not all URIs have a host.
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
// can't do reversing in UTF8, better use 16-bit chars
|
|
GetReversedHostname(NS_ConvertUTF8toUTF16(forward8), aRevHost);
|
|
return NS_OK;
|
|
}
|
|
|
|
void GetReversedHostname(const nsString& aForward, nsString& aRevHost) {
|
|
ReverseString(aForward, aRevHost);
|
|
aRevHost.Append(char16_t('.'));
|
|
}
|
|
|
|
void ReverseString(const nsString& aInput, nsString& aReversed) {
|
|
aReversed.Truncate(0);
|
|
for (int32_t i = aInput.Length() - 1; i >= 0; i--) {
|
|
aReversed.Append(aInput[i]);
|
|
}
|
|
}
|
|
|
|
nsresult GenerateGUID(nsACString& _guid) {
|
|
_guid.Truncate();
|
|
|
|
// Request raw random bytes and base64url encode them. For each set of three
|
|
// bytes, we get one character.
|
|
const uint32_t kRequiredBytesLength =
|
|
static_cast<uint32_t>(GUID_LENGTH / 4 * 3);
|
|
|
|
uint8_t buffer[kRequiredBytesLength];
|
|
if (!mozilla::GenerateRandomBytesFromOS(buffer, kRequiredBytesLength)) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
nsresult rv = Base64URLEncode(kRequiredBytesLength, buffer,
|
|
Base64URLEncodePaddingPolicy::Omit, _guid);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
NS_ASSERTION(_guid.Length() == GUID_LENGTH, "GUID is not the right size!");
|
|
return NS_OK;
|
|
}
|
|
|
|
bool IsValidGUID(const nsACString& aGUID) {
|
|
nsCString::size_type len = aGUID.Length();
|
|
if (len != GUID_LENGTH) {
|
|
return false;
|
|
}
|
|
|
|
for (nsCString::size_type i = 0; i < len; i++) {
|
|
char c = aGUID[i];
|
|
if ((c >= 'a' && c <= 'z') || // a-z
|
|
(c >= 'A' && c <= 'Z') || // A-Z
|
|
(c >= '0' && c <= '9') || // 0-9
|
|
c == '-' || c == '_') { // - or _
|
|
continue;
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void TruncateTitle(const nsACString& aTitle, nsACString& aTrimmed) {
|
|
if (aTitle.IsVoid()) {
|
|
return;
|
|
}
|
|
aTrimmed = aTitle;
|
|
if (aTitle.Length() > TITLE_LENGTH_MAX) {
|
|
aTrimmed = StringHead(aTitle, TITLE_LENGTH_MAX);
|
|
}
|
|
}
|
|
|
|
PRTime RoundToMilliseconds(PRTime aTime) {
|
|
return aTime - (aTime % PR_USEC_PER_MSEC);
|
|
}
|
|
|
|
PRTime RoundedPRNow() { return RoundToMilliseconds(PR_Now()); }
|
|
|
|
nsresult HashURL(const nsACString& aSpec, const nsACString& aMode,
|
|
uint64_t* _hash) {
|
|
NS_ENSURE_ARG_POINTER(_hash);
|
|
|
|
// HashString doesn't stop at the string boundaries if a length is passed to
|
|
// it, so ensure to pass a proper value.
|
|
const uint32_t maxLenToHash =
|
|
std::min(static_cast<uint32_t>(aSpec.Length()), MAX_CHARS_TO_HASH);
|
|
|
|
if (aMode.IsEmpty()) {
|
|
// URI-like strings (having a prefix before a colon), are handled specially,
|
|
// as a 48 bit hash, where first 16 bits are the prefix hash, while the
|
|
// other 32 are the string hash.
|
|
// The 16 bits have been decided based on the fact hashing all of the IANA
|
|
// known schemes, plus "places", does not generate collisions.
|
|
// Since we only care about schemes, we just search in the first 50 chars.
|
|
// The longest known IANA scheme, at this time, is 30 chars.
|
|
const nsDependentCSubstring& strHead = StringHead(aSpec, 50);
|
|
nsACString::const_iterator start, tip, end;
|
|
strHead.BeginReading(tip);
|
|
start = tip;
|
|
strHead.EndReading(end);
|
|
uint32_t strHash = HashString(aSpec.BeginReading(), maxLenToHash);
|
|
if (FindCharInReadable(':', tip, end)) {
|
|
const nsDependentCSubstring& prefix = Substring(start, tip);
|
|
uint64_t prefixHash =
|
|
static_cast<uint64_t>(HashString(prefix) & 0x0000FFFF);
|
|
// The second half of the url is more likely to be unique, so we add it.
|
|
*_hash = (prefixHash << 32) + strHash;
|
|
} else {
|
|
*_hash = strHash;
|
|
}
|
|
} else if (aMode.EqualsLiteral("prefix_lo")) {
|
|
// Keep only 16 bits.
|
|
*_hash = static_cast<uint64_t>(
|
|
HashString(aSpec.BeginReading(), maxLenToHash) & 0x0000FFFF)
|
|
<< 32;
|
|
} else if (aMode.EqualsLiteral("prefix_hi")) {
|
|
// Keep only 16 bits.
|
|
*_hash = static_cast<uint64_t>(
|
|
HashString(aSpec.BeginReading(), maxLenToHash) & 0x0000FFFF)
|
|
<< 32;
|
|
// Make this a prefix upper bound by filling the lowest 32 bits.
|
|
*_hash += 0xFFFFFFFF;
|
|
} else {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
bool GetHiddenState(bool aIsRedirect, uint32_t aTransitionType) {
|
|
return aTransitionType == nsINavHistoryService::TRANSITION_FRAMED_LINK ||
|
|
aTransitionType == nsINavHistoryService::TRANSITION_EMBED ||
|
|
aIsRedirect;
|
|
}
|
|
|
|
nsresult TokenizeQueryString(const nsACString& aQuery,
|
|
nsTArray<QueryKeyValuePair>* aTokens) {
|
|
// Strip off the "place:" prefix
|
|
const uint32_t prefixlen = 6; // = strlen("place:");
|
|
nsCString query;
|
|
if (aQuery.Length() >= prefixlen &&
|
|
Substring(aQuery, 0, prefixlen).EqualsLiteral("place:"))
|
|
query = Substring(aQuery, prefixlen);
|
|
else
|
|
query = aQuery;
|
|
|
|
int32_t keyFirstIndex = 0;
|
|
int32_t equalsIndex = 0;
|
|
for (uint32_t i = 0; i < query.Length(); i++) {
|
|
if (query[i] == '&') {
|
|
// new clause, save last one
|
|
if (i - keyFirstIndex > 1) {
|
|
// XXX(Bug 1631371) Check if this should use a fallible operation as it
|
|
// pretended earlier, or change the return type to void.
|
|
aTokens->AppendElement(
|
|
QueryKeyValuePair(query, keyFirstIndex, equalsIndex, i));
|
|
}
|
|
keyFirstIndex = equalsIndex = i + 1;
|
|
} else if (query[i] == '=') {
|
|
equalsIndex = i;
|
|
}
|
|
}
|
|
|
|
// handle last pair, if any
|
|
if (query.Length() - keyFirstIndex > 1) {
|
|
// XXX(Bug 1631371) Check if this should use a fallible operation as it
|
|
// pretended earlier, or change the return type to void.
|
|
aTokens->AppendElement(
|
|
QueryKeyValuePair(query, keyFirstIndex, equalsIndex, query.Length()));
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
void TokensToQueryString(const nsTArray<QueryKeyValuePair>& aTokens,
|
|
nsACString& aQuery) {
|
|
aQuery = "place:"_ns;
|
|
StringJoinAppend(aQuery, "&"_ns, aTokens,
|
|
[](nsACString& dst, const QueryKeyValuePair& token) {
|
|
dst.Append(token.key);
|
|
dst.AppendLiteral("=");
|
|
dst.Append(token.value);
|
|
});
|
|
}
|
|
|
|
nsresult BackupDatabaseFile(nsIFile* aDBFile, const nsAString& aBackupFileName,
|
|
nsIFile* aBackupParentDirectory, nsIFile** backup) {
|
|
nsresult rv;
|
|
nsCOMPtr<nsIFile> parentDir = aBackupParentDirectory;
|
|
if (!parentDir) {
|
|
// This argument is optional, and defaults to the same parent directory
|
|
// as the current file.
|
|
rv = aDBFile->GetParent(getter_AddRefs(parentDir));
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
}
|
|
|
|
nsCOMPtr<nsIFile> backupDB;
|
|
rv = parentDir->Clone(getter_AddRefs(backupDB));
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
rv = backupDB->Append(aBackupFileName);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
rv = backupDB->CreateUnique(nsIFile::NORMAL_FILE_TYPE, 0600);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
nsAutoString fileName;
|
|
rv = backupDB->GetLeafName(fileName);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
rv = backupDB->Remove(false);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
backupDB.forget(backup);
|
|
return aDBFile->CopyTo(parentDir, fileName);
|
|
}
|
|
|
|
already_AddRefed<nsIURI> GetExposableURI(nsIURI* aURI) {
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
MOZ_ASSERT(aURI);
|
|
|
|
nsresult rv;
|
|
nsCOMPtr<nsIIOService> ioService = do_GetIOService(&rv);
|
|
if (NS_FAILED(rv)) {
|
|
NS_WARNING("Failed to get nsIIOService");
|
|
return nsCOMPtr<nsIURI>(aURI).forget();
|
|
}
|
|
|
|
nsCOMPtr<nsIURI> uri;
|
|
rv = ioService->CreateExposableURI(aURI, getter_AddRefs(uri));
|
|
if (NS_FAILED(rv)) {
|
|
NS_WARNING("Failed to create exposable URI");
|
|
return nsCOMPtr<nsIURI>(aURI).forget();
|
|
}
|
|
|
|
return uri.forget();
|
|
}
|
|
|
|
} // namespace places
|
|
} // namespace mozilla
|