Source code

Revision control

Copy as Markdown

Other Tools

//* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-/
/* 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 */
#ifndef nsUrlClassifierDBService_h_
#define nsUrlClassifierDBService_h_
#include <nsISupportsUtils.h>
#include "nsID.h"
#include "nsInterfaceHashtable.h"
#include "nsIObserver.h"
#include "nsUrlClassifierPrefixSet.h"
#include "nsIUrlClassifierHashCompleter.h"
#include "nsIUrlClassifierDBService.h"
#include "nsIUrlClassifierInfo.h"
#include "nsIURIClassifier.h"
#include "mozilla/Attributes.h"
#include "mozilla/Mutex.h"
#include "mozilla/TimeStamp.h"
#include "Entries.h"
#include "LookupCache.h"
#include "HashStore.h"
// The hash length for a domain key.
// The hash length of a partial hash entry.
// The hash length of a complete hash entry.
// Comma-separated lists
#define DISALLOW_COMPLETION_TABLE_PREF "urlclassifier.disallow_completions"
using namespace mozilla::safebrowsing;
class nsUrlClassifierDBServiceWorker;
class nsIThread;
class nsIURI;
class UrlClassifierDBServiceWorkerProxy;
namespace mozilla {
namespace safebrowsing {
class Classifier;
class ProtocolParser;
nsresult TablesToResponse(const nsACString& tables);
} // namespace safebrowsing
namespace net {
class AsyncUrlChannelClassifier;
} // namespace mozilla
// This is a proxy class that just creates a background thread and delegates
// calls to the background thread.
class nsUrlClassifierDBService final : public nsIUrlClassifierDBService,
public nsIURIClassifier,
public nsIUrlClassifierInfo,
public nsIObserver {
friend class mozilla::net::AsyncUrlChannelClassifier;
class FeatureHolder;
// This is thread safe. It throws an exception if the thread is busy.
nsresult Init();
static already_AddRefed<nsUrlClassifierDBService> GetInstance(
nsresult* result);
bool CanComplete(const nsACString& tableName);
bool GetCompleter(const nsACString& tableName,
nsIUrlClassifierHashCompleter** completer);
nsresult CacheCompletions(
const mozilla::safebrowsing::ConstCacheResultArray& results);
static nsIThread* BackgroundThread();
static bool ShutdownHasStarted();
// This method is used only by AsyncUrlChannelClassifier. If you want to use
// it, please contact a safebrowsing/URL-Classifier peer.
static nsUrlClassifierDBServiceWorker* GetWorker();
// No subclassing
// Disallow copy constructor
nsresult LookupURI(const nsACString& aKey, FeatureHolder* aHolder,
nsIUrlClassifierCallback* c);
// Post an event to worker thread to release objects when receive
// 'quit-application'
nsresult PreShutdown();
// Close db connection and join the background thread if it exists.
nsresult Shutdown();
nsresult ReadDisallowCompletionsTablesFromPrefs();
// This method checks if the classification can be done just using
// preferences. It returns true if the operation has been completed.
bool AsyncClassifyLocalWithFeaturesUsingPreferences(
nsIURI* aURI, const nsTArray<RefPtr<nsIUrlClassifierFeature>>& aFeatures,
nsIUrlClassifierFeature::listType aListType,
nsIUrlClassifierFeatureCallback* aCallback);
RefPtr<nsUrlClassifierDBServiceWorker> mWorker;
RefPtr<UrlClassifierDBServiceWorkerProxy> mWorkerProxy;
nsInterfaceHashtable<nsCStringHashKey, nsIUrlClassifierHashCompleter>
// TRUE if a BeginUpdate() has been called without an accompanying
// CancelUpdate()/FinishUpdate(). This is used to prevent competing
// updates, not to determine whether an update is still being
// processed.
bool mInUpdate;
// The list of tables that should never be hash completed.
nsTArray<nsCString> mDisallowCompletionsTables;
// Thread that we do the updates on.
static nsIThread* gDbBackgroundThread;
class nsUrlClassifierDBServiceWorker final : public nsIUrlClassifierDBService {
nsresult Init(uint32_t aGethashNoise, nsCOMPtr<nsIFile> aCacheDir,
nsUrlClassifierDBService* aDBService);
// Queue a lookup for the worker to perform, called in the main thread.
nsresult QueueLookup(const nsACString& aLookupKey,
nsUrlClassifierDBService::FeatureHolder* aFeatureHolder,
nsIUrlClassifierLookupCallback* aLallback);
// Handle any queued-up lookups. We call this function during long-running
// update operations to prevent lookups from blocking for too long.
nsresult HandlePendingLookups();
// Perform a blocking classifier lookup for a given url fragments set.
// Can be called on either the main thread or the worker thread.
nsresult DoSingleLocalLookupWithURIFragments(
const nsTArray<nsCString>& aSpecFragments, const nsACString& aTable,
LookupResultArray& aResults);
// Open the DB connection
nsresult OpenDb();
// Provide a way to forcibly close the db connection.
nsresult CloseDb();
nsresult PreShutdown();
nsresult CacheCompletions(const ConstCacheResultArray& aEntries);
// Used to probe the state of the worker thread. When the update begins,
// mUpdateObserver will be set. When the update finished, mUpdateObserver
// will be nulled out in NotifyUpdateObserver.
bool IsBusyUpdating() {
mozilla::MutexAutoLock lock(mUpdateObserverLock);
return !!mUpdateObserver;
// Delegate Classifier to disable async update. If there is an
// ongoing update on the update thread, we will be blocked until
// the background update is done and callback is fired.
// Should be called on the worker thread.
void FlushAndDisableAsyncUpdate();
// A synchronous call to get cache information for the given table.
// This is only used by about:url-classifier now.
nsresult GetCacheInfo(const nsACString& aTable,
nsIUrlClassifierCacheInfo** aCache);
// No subclassing
// Disallow copy constructor
nsresult NotifyUpdateObserver(nsresult aUpdateStatus);
// Reset the in-progress update stream
void ResetStream();
// Reset the in-progress update
void ResetUpdate();
// Perform a classifier lookup for a given url.
nsresult DoLookup(const nsACString& spec,
nsUrlClassifierDBService::FeatureHolder* aFeatureHolder,
nsIUrlClassifierLookupCallback* c);
nsresult AddNoise(const Prefix aPrefix, const nsCString tableName,
uint32_t aCount, LookupResultArray& results);
nsresult CacheResultToTableUpdate(RefPtr<const CacheResult> aCacheResult,
RefPtr<TableUpdate> aUpdate);
bool IsSameAsLastResults(const ConstCacheResultArray& aResult) const;
RefPtr<mozilla::safebrowsing::Classifier> mClassifier;
// The class that actually parses the update chunks.
mozilla::UniquePtr<ProtocolParser> mProtocolParser;
// Directory where to store the SB databases.
nsCOMPtr<nsIFile> mCacheDir;
RefPtr<nsUrlClassifierDBService> mDBService;
TableUpdateArray mTableUpdates;
uint32_t mUpdateWaitSec;
// Stores the last results that triggered a table update.
ConstCacheResultArray mLastResults;
nsresult mUpdateStatus;
nsTArray<nsCString> mUpdateTables;
// The mUpdateObserver will be accessed by both the main thread and the worker
// thread. The lock is used to protect the mUpdateObserver.
mozilla::Mutex mUpdateObserverLock;
nsCOMPtr<nsIUrlClassifierUpdateObserver> mUpdateObserver
bool mInStream;
// The number of noise entries to add to the set of lookup results.
uint32_t mGethashNoise;
// Pending lookups are stored in a queue for processing. The queue
// is protected by mPendingLookupLock.
mozilla::Mutex mPendingLookupLock MOZ_UNANNOTATED;
class PendingLookup {
mozilla::TimeStamp mStartTime;
nsCString mKey;
RefPtr<nsUrlClassifierDBService::FeatureHolder> mFeatureHolder;
nsCOMPtr<nsIUrlClassifierLookupCallback> mCallback;
// list of pending lookups
nsTArray<PendingLookup> mPendingLookups;
// The raw update response for debugging.
nsCString mRawTableUpdates;
#endif // nsUrlClassifierDBService_h_