netwerk/cookie/CookieStorage.h

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #ifndef mozilla_net_CookieStorage_h
   7 #define mozilla_net_CookieStorage_h
   8
   9 #include "CookieKey.h"
  10
  11 #include "nsICookieNotification.h"
  12 #include "nsIObserver.h"
  13 #include "nsTHashtable.h"
  14 #include "nsWeakReference.h"
  15 #include <functional>
  16 #include "CookieCommons.h"
  17
  18 class nsIArray;
  19 class nsICookie;
  20 class nsICookieTransactionCallback;
  21 class nsIPrefBranch;
  22
  23 namespace mozilla {
  24 namespace net {
  25
  26 class Cookie;
  27
  28 // Inherit from CookieKey so this can be stored in nsTHashTable
  29 // TODO: why aren't we using nsClassHashTable<CookieKey, ArrayType>?
  30 class CookieEntry : public CookieKey {
  31  public:
  32   // Hash methods
  33   using ArrayType = nsTArray<RefPtr<Cookie>>;
  34   using IndexType = ArrayType::index_type;
  35
  36   explicit CookieEntry(KeyTypePointer aKey) : CookieKey(aKey) {}
  37
  38   CookieEntry(const CookieEntry& toCopy) {
  39     // if we end up here, things will break. nsTHashtable shouldn't
  40     // allow this, since we set ALLOW_MEMMOVE to true.
  41     MOZ_ASSERT_UNREACHABLE("CookieEntry copy constructor is forbidden!");
  42   }
  43
  44   ~CookieEntry() = default;
  45
  46   inline ArrayType& GetCookies() { return mCookies; }
  47   inline const ArrayType& GetCookies() const { return mCookies; }
  48
  49   size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const;
  50
  51  private:
  52   ArrayType mCookies;
  53 };
  54
  55 // stores the CookieEntry entryclass and an index into the cookie array within
  56 // that entryclass, for purposes of storing an iteration state that points to a
  57 // certain cookie.
  58 struct CookieListIter {
  59   // default (non-initializing) constructor.
  60   CookieListIter() = default;
  61
  62   // explicit constructor to a given iterator state with entryclass 'aEntry'
  63   // and index 'aIndex'.
  64   explicit CookieListIter(CookieEntry* aEntry, CookieEntry::IndexType aIndex)
  65       : entry(aEntry), index(aIndex) {}
  66
  67   // get the Cookie * the iterator currently points to.
  68   mozilla::net::Cookie* Cookie() const { return entry->GetCookies()[index]; }
  69
  70   CookieEntry* entry;
  71   CookieEntry::IndexType index;
  72 };
  73
  74 class CookieStorage : public nsIObserver, public nsSupportsWeakReference {
  75  public:
  76   NS_DECL_THREADSAFE_ISUPPORTS
  77   NS_DECL_NSIOBSERVER
  78
  79   size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const;
  80
  81   void GetCookies(nsTArray<RefPtr<nsICookie>>& aCookies) const;
  82
  83   void GetSessionCookies(nsTArray<RefPtr<nsICookie>>& aCookies) const;
  84
  85   bool FindCookie(const nsACString& aBaseDomain,
  86                   const OriginAttributes& aOriginAttributes,
  87                   const nsACString& aHost, const nsACString& aName,
  88                   const nsACString& aPath, CookieListIter& aIter);
  89
  90   uint32_t CountCookiesFromHost(const nsACString& aBaseDomain,
  91                                 uint32_t aPrivateBrowsingId);
  92
  93   void GetAll(nsTArray<RefPtr<nsICookie>>& aResult) const;
  94
  95   const nsTArray<RefPtr<Cookie>>* GetCookiesFromHost(
  96       const nsACString& aBaseDomain, const OriginAttributes& aOriginAttributes);
  97
  98   void GetCookiesWithOriginAttributes(const OriginAttributesPattern& aPattern,
  99                                       const nsACString& aBaseDomain,
 100                                       nsTArray<RefPtr<nsICookie>>& aResult);
 101
 102   void RemoveCookie(const nsACString& aBaseDomain,
 103                     const OriginAttributes& aOriginAttributes,
 104                     const nsACString& aHost, const nsACString& aName,
 105                     const nsACString& aPath);
 106
 107   virtual void RemoveCookiesWithOriginAttributes(
 108       const OriginAttributesPattern& aPattern, const nsACString& aBaseDomain);
 109
 110   virtual void RemoveCookiesFromExactHost(
 111       const nsACString& aHost, const nsACString& aBaseDomain,
 112       const OriginAttributesPattern& aPattern);
 113
 114   void RemoveAll();
 115
 116   void NotifyChanged(nsISupports* aSubject,
 117                      nsICookieNotification::Action aAction,
 118                      const nsACString& aBaseDomain,
 119                      dom::BrowsingContext* aBrowsingContext = nullptr,
 120                      bool aOldCookieIsSession = false);
 121
 122   void AddCookie(nsIConsoleReportCollector* aCRC, const nsACString& aBaseDomain,
 123                  const OriginAttributes& aOriginAttributes, Cookie* aCookie,
 124                  int64_t aCurrentTimeInUsec, nsIURI* aHostURI,
 125                  const nsACString& aCookieHeader, bool aFromHttp,
 126                  dom::BrowsingContext* aBrowsingContext);
 127
 128   static void CreateOrUpdatePurgeList(nsCOMPtr<nsIArray>& aPurgedList,
 129                                       nsICookie* aCookie);
 130
 131   virtual void StaleCookies(const nsTArray<Cookie*>& aCookieList,
 132                             int64_t aCurrentTimeInUsec) = 0;
 133
 134   virtual void Close() = 0;
 135
 136   virtual void EnsureInitialized() = 0;
 137
 138   virtual nsresult RunInTransaction(
 139       nsICookieTransactionCallback* aCallback) = 0;
 140
 141  protected:
 142   CookieStorage() = default;
 143   virtual ~CookieStorage() = default;
 144
 145   void Init();
 146
 147   void AddCookieToList(const nsACString& aBaseDomain,
 148                        const OriginAttributes& aOriginAttributes,
 149                        Cookie* aCookie);
 150
 151   virtual void StoreCookie(const nsACString& aBaseDomain,
 152                            const OriginAttributes& aOriginAttributes,
 153                            Cookie* aCookie) = 0;
 154
 155   virtual const char* NotificationTopic() const = 0;
 156
 157   virtual void NotifyChangedInternal(nsICookieNotification* aSubject,
 158                                      bool aOldCookieIsSession) = 0;
 159
 160   virtual void RemoveAllInternal() = 0;
 161
 162   // This method calls RemoveCookieFromDB + RemoveCookieFromListInternal.
 163   void RemoveCookieFromList(const CookieListIter& aIter);
 164
 165   void RemoveCookieFromListInternal(const CookieListIter& aIter);
 166
 167   virtual void RemoveCookieFromDB(const Cookie& aCookie) = 0;
 168
 169   already_AddRefed<nsIArray> PurgeCookiesWithCallbacks(
 170       int64_t aCurrentTimeInUsec, uint16_t aMaxNumberOfCookies,
 171       int64_t aCookiePurgeAge,
 172       std::function<void(const CookieListIter&)>&& aRemoveCookieCallback,
 173       std::function<void()>&& aFinalizeCallback);
 174
 175   nsTHashtable<CookieEntry> mHostTable;
 176
 177   uint32_t mCookieCount{0};
 178
 179  private:
 180   void PrefChanged(nsIPrefBranch* aPrefBranch);
 181
 182   bool FindSecureCookie(const nsACString& aBaseDomain,
 183                         const OriginAttributes& aOriginAttributes,
 184                         Cookie* aCookie);
 185
 186   static void FindStaleCookies(CookieEntry* aEntry, int64_t aCurrentTime,
 187                                bool aIsSecure,
 188                                nsTArray<CookieListIter>& aOutput,
 189                                uint32_t aLimit);
 190
 191   void UpdateCookieOldestTime(Cookie* aCookie);
 192
 193   void MergeCookieSchemeMap(Cookie* aOldCookie, Cookie* aNewCookie);
 194
 195   static already_AddRefed<nsIArray> CreatePurgeList(nsICookie* aCookie);
 196
 197   virtual already_AddRefed<nsIArray> PurgeCookies(int64_t aCurrentTimeInUsec,
 198                                                   uint16_t aMaxNumberOfCookies,
 199                                                   int64_t aCookiePurgeAge) = 0;
 200
 201   int64_t mCookieOldestTime{INT64_MAX};
 202
 203   uint16_t mMaxNumberOfCookies{kMaxNumberOfCookies};
 204   uint16_t mMaxCookiesPerHost{kMaxCookiesPerHost};
 205   uint16_t mCookieQuotaPerHost{kCookieQuotaPerHost};
 206   int64_t mCookiePurgeAge{kCookiePurgeAge};
 207 };
 208
 209 }  // namespace net
 210 }  // namespace mozilla
 211
 212 #endif  // mozilla_net_CookieStorage_h