caps/src/DomainPolicy.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /* vim: set ts=4 et sw=4 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "DomainPolicy.h"
   8 #include "nsScriptSecurityManager.h"
   9
  10 namespace mozilla {
  11 namespace hotness {
  12
  13 NS_IMPL_ISUPPORTS1(DomainPolicy, nsIDomainPolicy)
  14
  15 DomainPolicy::DomainPolicy() : mBlacklist(new DomainSet())
  16                              , mSuperBlacklist(new DomainSet())
  17                              , mWhitelist(new DomainSet())
  18                              , mSuperWhitelist(new DomainSet())
  19 {}
  20
  21 DomainPolicy::~DomainPolicy()
  22 {
  23     // The SSM holds a strong ref to the DomainPolicy until Deactivate() is
  24     // invoked, so we should never hit the destructor until that happens.
  25     MOZ_ASSERT(!mBlacklist && !mSuperBlacklist &&
  26                !mWhitelist && !mSuperWhitelist);
  27 }
  28
  29
  30 NS_IMETHODIMP
  31 DomainPolicy::GetBlacklist(nsIDomainSet** aSet)
  32 {
  33     nsCOMPtr<nsIDomainSet> set = mBlacklist;
  34     set.forget(aSet);
  35     return NS_OK;
  36 }
  37
  38 NS_IMETHODIMP
  39 DomainPolicy::GetSuperBlacklist(nsIDomainSet** aSet)
  40 {
  41     nsCOMPtr<nsIDomainSet> set = mSuperBlacklist;
  42     set.forget(aSet);
  43     return NS_OK;
  44 }
  45
  46 NS_IMETHODIMP
  47 DomainPolicy::GetWhitelist(nsIDomainSet** aSet)
  48 {
  49     nsCOMPtr<nsIDomainSet> set = mWhitelist;
  50     set.forget(aSet);
  51     return NS_OK;
  52 }
  53
  54 NS_IMETHODIMP
  55 DomainPolicy::GetSuperWhitelist(nsIDomainSet** aSet)
  56 {
  57     nsCOMPtr<nsIDomainSet> set = mSuperWhitelist;
  58     set.forget(aSet);
  59     return NS_OK;
  60 }
  61
  62 NS_IMETHODIMP
  63 DomainPolicy::Deactivate()
  64 {
  65     // Clear the hashtables first to free up memory, since script might
  66     // hold the doomed sets alive indefinitely.
  67     mBlacklist->Clear();
  68     mSuperBlacklist->Clear();
  69     mWhitelist->Clear();
  70     mSuperWhitelist->Clear();
  71
  72     // Null them out.
  73     mBlacklist = nullptr;
  74     mSuperBlacklist = nullptr;
  75     mWhitelist = nullptr;
  76     mSuperWhitelist = nullptr;
  77
  78     // Inform the SSM.
  79     nsScriptSecurityManager::GetScriptSecurityManager()->DeactivateDomainPolicy();
  80     return NS_OK;
  81 }
  82
  83 static already_AddRefed<nsIURI>
  84 GetCanonicalClone(nsIURI* aURI)
  85 {
  86     nsCOMPtr<nsIURI> clone;
  87     nsresult rv = aURI->Clone(getter_AddRefs(clone));
  88     NS_ENSURE_SUCCESS(rv, nullptr);
  89     rv = clone->SetUserPass(EmptyCString());
  90     NS_ENSURE_SUCCESS(rv, nullptr);
  91     rv = clone->SetPath(EmptyCString());
  92     NS_ENSURE_SUCCESS(rv, nullptr);
  93     return clone.forget();
  94 }
  95
  96 NS_IMPL_ISUPPORTS1(DomainSet, nsIDomainSet)
  97
  98 NS_IMETHODIMP
  99 DomainSet::Add(nsIURI* aDomain)
 100 {
 101     nsCOMPtr<nsIURI> clone = GetCanonicalClone(aDomain);
 102     NS_ENSURE_TRUE(clone, NS_ERROR_FAILURE);
 103     mHashTable.PutEntry(clone);
 104     return NS_OK;
 105 }
 106
 107 NS_IMETHODIMP
 108 DomainSet::Remove(nsIURI* aDomain)
 109 {
 110     nsCOMPtr<nsIURI> clone = GetCanonicalClone(aDomain);
 111     NS_ENSURE_TRUE(clone, NS_ERROR_FAILURE);
 112     mHashTable.RemoveEntry(clone);
 113     return NS_OK;
 114 }
 115
 116 NS_IMETHODIMP
 117 DomainSet::Clear()
 118 {
 119     mHashTable.Clear();
 120     return NS_OK;
 121 }
 122
 123 NS_IMETHODIMP
 124 DomainSet::Contains(nsIURI* aDomain, bool* aContains)
 125 {
 126     *aContains = false;
 127     nsCOMPtr<nsIURI> clone = GetCanonicalClone(aDomain);
 128     NS_ENSURE_TRUE(clone, NS_ERROR_FAILURE);
 129     *aContains = mHashTable.Contains(clone);
 130     return NS_OK;
 131 }
 132
 133 NS_IMETHODIMP
 134 DomainSet::ContainsSuperDomain(nsIURI* aDomain, bool* aContains)
 135 {
 136     *aContains = false;
 137     nsCOMPtr<nsIURI> clone = GetCanonicalClone(aDomain);
 138     NS_ENSURE_TRUE(clone, NS_ERROR_FAILURE);
 139     nsAutoCString domain;
 140     nsresult rv = clone->GetHost(domain);
 141     NS_ENSURE_SUCCESS(rv, rv);
 142     while (true) {
 143         // Check the current domain.
 144         if (mHashTable.Contains(clone)) {
 145             *aContains = true;
 146             return NS_OK;
 147         }
 148
 149         // Chop off everything before the first dot, or break if there are no
 150         // dots left.
 151         int32_t index = domain.Find(".");
 152         if (index == kNotFound)
 153             break;
 154         domain.Assign(Substring(domain, index + 1));
 155         rv = clone->SetHost(domain);
 156         NS_ENSURE_SUCCESS(rv, rv);
 157     }
 158
 159     // No match.
 160     return NS_OK;
 161
 162 }
 163
 164 } /* namespace hotness */
 165 } /* namespace mozilla */