The Tor Browser / file comparison

comparison: netwerk/protocol/http/nsHttpAuthCache.h

netwerk/protocol/http/nsHttpAuthCache.h

branch
TOR_BUG_9701
changeset 11
deefc01c0e14
equal deleted inserted replaced
-1:000000000000 0:b18a05334496
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 nsHttpAuthCache_h__
7 #define nsHttpAuthCache_h__
8
9 #include "nsError.h"
10 #include "nsTArray.h"
11 #include "nsAutoPtr.h"
12 #include "nsCOMPtr.h"
13 #include "plhash.h"
14 #include "nsIObserver.h"
15
16 class nsCString;
17
18 namespace mozilla {
19 namespace net {
20
21 struct nsHttpAuthPath {
22 struct nsHttpAuthPath *mNext;
23 char mPath[1];
24 };
25
26 //-----------------------------------------------------------------------------
27 // nsHttpAuthIdentity
28 //-----------------------------------------------------------------------------
29
30 class nsHttpAuthIdentity
31 {
32 public:
33 nsHttpAuthIdentity()
34 : mUser(nullptr)
35 , mPass(nullptr)
36 , mDomain(nullptr)
37 {
38 }
39 nsHttpAuthIdentity(const char16_t *domain,
40 const char16_t *user,
41 const char16_t *password)
42 : mUser(nullptr)
43 {
44 Set(domain, user, password);
45 }
46 ~nsHttpAuthIdentity()
47 {
48 Clear();
49 }
50
51 const char16_t *Domain() const { return mDomain; }
52 const char16_t *User() const { return mUser; }
53 const char16_t *Password() const { return mPass; }
54
55 nsresult Set(const char16_t *domain,
56 const char16_t *user,
57 const char16_t *password);
58 nsresult Set(const nsHttpAuthIdentity &other) { return Set(other.mDomain, other.mUser, other.mPass); }
59 void Clear();
60
61 bool Equals(const nsHttpAuthIdentity &other) const;
62 bool IsEmpty() const { return !mUser; }
63
64 private:
65 // allocated as one contiguous blob, starting at mUser.
66 char16_t *mUser;
67 char16_t *mPass;
68 char16_t *mDomain;
69 };
70
71 //-----------------------------------------------------------------------------
72 // nsHttpAuthEntry
73 //-----------------------------------------------------------------------------
74
75 class nsHttpAuthEntry
76 {
77 public:
78 const char *Realm() const { return mRealm; }
79 const char *Creds() const { return mCreds; }
80 const char *Challenge() const { return mChallenge; }
81 const char16_t *Domain() const { return mIdent.Domain(); }
82 const char16_t *User() const { return mIdent.User(); }
83 const char16_t *Pass() const { return mIdent.Password(); }
84 nsHttpAuthPath *RootPath() { return mRoot; }
85
86 const nsHttpAuthIdentity &Identity() const { return mIdent; }
87
88 nsresult AddPath(const char *aPath);
89
90 nsCOMPtr<nsISupports> mMetaData;
91
92 private:
93 nsHttpAuthEntry(const char *path,
94 const char *realm,
95 const char *creds,
96 const char *challenge,
97 const nsHttpAuthIdentity *ident,
98 nsISupports *metadata)
99 : mRoot(nullptr)
100 , mTail(nullptr)
101 , mRealm(nullptr)
102 {
103 Set(path, realm, creds, challenge, ident, metadata);
104 }
105 ~nsHttpAuthEntry();
106
107 nsresult Set(const char *path,
108 const char *realm,
109 const char *creds,
110 const char *challenge,
111 const nsHttpAuthIdentity *ident,
112 nsISupports *metadata);
113
114 nsHttpAuthIdentity mIdent;
115
116 nsHttpAuthPath *mRoot; //root pointer
117 nsHttpAuthPath *mTail; //tail pointer
118
119 // allocated together in one blob, starting with mRealm.
120 char *mRealm;
121 char *mCreds;
122 char *mChallenge;
123
124 friend class nsHttpAuthNode;
125 friend class nsHttpAuthCache;
126 friend class nsAutoPtr<nsHttpAuthEntry>; // needs to call the destructor
127 };
128
129 //-----------------------------------------------------------------------------
130 // nsHttpAuthNode
131 //-----------------------------------------------------------------------------
132
133 class nsHttpAuthNode
134 {
135 private:
136 nsHttpAuthNode();
137 ~nsHttpAuthNode();
138
139 // path can be null, in which case we'll search for an entry
140 // with a null path.
141 nsHttpAuthEntry *LookupEntryByPath(const char *path);
142
143 // realm must not be null
144 nsHttpAuthEntry *LookupEntryByRealm(const char *realm);
145
146 // if a matching entry is found, then credentials will be changed.
147 nsresult SetAuthEntry(const char *path,
148 const char *realm,
149 const char *credentials,
150 const char *challenge,
151 const nsHttpAuthIdentity *ident,
152 nsISupports *metadata);
153
154 void ClearAuthEntry(const char *realm);
155
156 uint32_t EntryCount() { return mList.Length(); }
157
158 private:
159 nsTArray<nsAutoPtr<nsHttpAuthEntry> > mList;
160
161 friend class nsHttpAuthCache;
162 };
163
164 //-----------------------------------------------------------------------------
165 // nsHttpAuthCache
166 // (holds a hash table from host:port to nsHttpAuthNode)
167 //-----------------------------------------------------------------------------
168
169 class nsHttpAuthCache
170 {
171 public:
172 nsHttpAuthCache();
173 ~nsHttpAuthCache();
174
175 nsresult Init();
176
177 // |scheme|, |host|, and |port| are required
178 // |path| can be null
179 // |entry| is either null or a weak reference
180 nsresult GetAuthEntryForPath(const char *scheme,
181 const char *host,
182 int32_t port,
183 const char *path,
184 uint32_t appId,
185 bool inBrowserElement,
186 nsHttpAuthEntry **entry);
187
188 // |scheme|, |host|, and |port| are required
189 // |realm| must not be null
190 // |entry| is either null or a weak reference
191 nsresult GetAuthEntryForDomain(const char *scheme,
192 const char *host,
193 int32_t port,
194 const char *realm,
195 uint32_t appId,
196 bool inBrowserElement,
197 nsHttpAuthEntry **entry);
198
199 // |scheme|, |host|, and |port| are required
200 // |path| can be null
201 // |realm| must not be null
202 // if |credentials|, |user|, |pass|, and |challenge| are each
203 // null, then the entry is deleted.
204 nsresult SetAuthEntry(const char *scheme,
205 const char *host,
206 int32_t port,
207 const char *directory,
208 const char *realm,
209 const char *credentials,
210 const char *challenge,
211 uint32_t appId,
212 bool inBrowserElement,
213 const nsHttpAuthIdentity *ident,
214 nsISupports *metadata);
215
216 void ClearAuthEntry(const char *scheme,
217 const char *host,
218 int32_t port,
219 const char *realm,
220 uint32_t appId,
221 bool inBrowserElement);
222
223 // expire all existing auth list entries including proxy auths.
224 nsresult ClearAll();
225
226 private:
227 nsHttpAuthNode *LookupAuthNode(const char *scheme,
228 const char *host,
229 int32_t port,
230 uint32_t appId,
231 bool inBrowserElement,
232 nsCString &key);
233
234 // hash table allocation functions
235 static void* AllocTable(void *, size_t size);
236 static void FreeTable(void *, void *item);
237 static PLHashEntry* AllocEntry(void *, const void *key);
238 static void FreeEntry(void *, PLHashEntry *he, unsigned flag);
239
240 static PLHashAllocOps gHashAllocOps;
241
242 class AppDataClearObserver : public nsIObserver {
243 public:
244 NS_DECL_ISUPPORTS
245 NS_DECL_NSIOBSERVER
246 AppDataClearObserver(nsHttpAuthCache* aOwner) : mOwner(aOwner) {}
247 virtual ~AppDataClearObserver() {}
248 nsHttpAuthCache* mOwner;
249 };
250
251 void ClearAppData(uint32_t appId, bool browserOnly);
252
253 private:
254 PLHashTable *mDB; // "host:port" --> nsHttpAuthNode
255 nsRefPtr<AppDataClearObserver> mObserver;
256 };
257
258 }} // namespace mozilla::net
259
260 #endif // nsHttpAuthCache_h__

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial