1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* vim: set sw=4 ts=8 et tw=80 : */
/* 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/. */
#ifndef nsHttpConnectionInfo_h__
#define nsHttpConnectionInfo_h__
#include "nsHttp.h"
#include "nsProxyInfo.h"
#include "nsCOMPtr.h"
#include "nsStringFwd.h"
#include "mozilla/Logging.h"
#include "mozilla/BasePrincipal.h"
#include "ARefBase.h"
//-----------------------------------------------------------------------------
// nsHttpConnectionInfo - holds the properties of a connection
//-----------------------------------------------------------------------------
// http:// uris through a proxy will all share the same CI, because they can
// all use the same connection. (modulo pb and anonymous flags). They just use
// the proxy as the origin host name.
// however, https:// uris tunnel through the proxy so they will have different
// CIs - the CI reflects both the proxy and the origin.
// however, proxy conenctions made with http/2 (or spdy) can tunnel to the origin
// and multiplex non tunneled transactions at the same time, so they have a
// special wildcard CI that accepts all origins through that proxy.
namespace mozilla { namespace net {
extern LazyLogModule gHttpLog;
class nsHttpConnectionInfo: public ARefBase
{
public:
nsHttpConnectionInfo(const nsACString &originHost,
int32_t originPort,
const nsACString &npnToken,
const nsACString &username,
nsProxyInfo *proxyInfo,
const NeckoOriginAttributes &originAttributes,
bool endToEndSSL = false);
// this version must use TLS and you may supply separate
// connection (aka routing) information than the authenticated
// origin information
nsHttpConnectionInfo(const nsACString &originHost,
int32_t originPort,
const nsACString &npnToken,
const nsACString &username,
nsProxyInfo *proxyInfo,
const NeckoOriginAttributes &originAttributes,
const nsACString &routedHost,
int32_t routedPort);
private:
virtual ~nsHttpConnectionInfo()
{
MOZ_LOG(gHttpLog, LogLevel::Debug, ("Destroying nsHttpConnectionInfo @%x\n", this));
}
void BuildHashKey();
public:
const nsAFlatCString &HashKey() const { return mHashKey; }
const nsCString &GetOrigin() const { return mOrigin; }
const char *Origin() const { return mOrigin.get(); }
int32_t OriginPort() const { return mOriginPort; }
const nsCString &GetRoutedHost() const { return mRoutedHost; }
const char *RoutedHost() const { return mRoutedHost.get(); }
int32_t RoutedPort() const { return mRoutedPort; }
// With overhead rebuilding the hash key. The initial
// network interface is empty. So you can reduce one call
// if there's no explicit route after ctor.
void SetNetworkInterfaceId(const nsACString& aNetworkInterfaceId);
// OK to treat these as an infalible allocation
nsHttpConnectionInfo* Clone() const;
void CloneAsDirectRoute(nsHttpConnectionInfo **outParam);
nsresult CreateWildCard(nsHttpConnectionInfo **outParam);
const char *ProxyHost() const { return mProxyInfo ? mProxyInfo->Host().get() : nullptr; }
int32_t ProxyPort() const { return mProxyInfo ? mProxyInfo->Port() : -1; }
const char *ProxyType() const { return mProxyInfo ? mProxyInfo->Type() : nullptr; }
const char *ProxyUsername() const { return mProxyInfo ? mProxyInfo->Username().get() : nullptr; }
const char *ProxyPassword() const { return mProxyInfo ? mProxyInfo->Password().get() : nullptr; }
// Compare this connection info to another...
// Two connections are 'equal' if they end up talking the same
// protocol to the same server. This is needed to properly manage
// persistent connections to proxies
// Note that we don't care about transparent proxies -
// it doesn't matter if we're talking via socks or not, since
// a request will end up at the same host.
bool Equals(const nsHttpConnectionInfo *info)
{
return mHashKey.Equals(info->HashKey());
}
const char *Username() const { return mUsername.get(); }
nsProxyInfo *ProxyInfo() const { return mProxyInfo; }
int32_t DefaultPort() const { return mEndToEndSSL ? NS_HTTPS_DEFAULT_PORT : NS_HTTP_DEFAULT_PORT; }
void SetAnonymous(bool anon)
{ mHashKey.SetCharAt(anon ? 'A' : '.', 2); }
bool GetAnonymous() const { return mHashKey.CharAt(2) == 'A'; }
void SetPrivate(bool priv) { mHashKey.SetCharAt(priv ? 'P' : '.', 3); }
bool GetPrivate() const { return mHashKey.CharAt(3) == 'P'; }
void SetInsecureScheme(bool insecureScheme)
{ mHashKey.SetCharAt(insecureScheme ? 'I' : '.', 4); }
bool GetInsecureScheme() const { return mHashKey.CharAt(4) == 'I'; }
void SetNoSpdy(bool aNoSpdy)
{ mHashKey.SetCharAt(aNoSpdy ? 'X' : '.', 5); }
bool GetNoSpdy() const { return mHashKey.CharAt(5) == 'X'; }
void SetBeConservative(bool aBeConservative)
{ mHashKey.SetCharAt(aBeConservative ? 'C' : '.', 6); }
bool GetBeConservative() const { return mHashKey.CharAt(6) == 'C'; }
const nsCString &GetNetworkInterfaceId() const { return mNetworkInterfaceId; }
const nsCString &GetNPNToken() { return mNPNToken; }
const nsCString &GetUsername() { return mUsername; }
const NeckoOriginAttributes &GetOriginAttributes() { return mOriginAttributes; }
// Returns true for any kind of proxy (http, socks, https, etc..)
bool UsingProxy();
// Returns true when proxying over HTTP or HTTPS
bool UsingHttpProxy() const { return mUsingHttpProxy || mUsingHttpsProxy; }
// Returns true when proxying over HTTPS
bool UsingHttpsProxy() const { return mUsingHttpsProxy; }
// Returns true when a resource is in SSL end to end (e.g. https:// uri)
bool EndToEndSSL() const { return mEndToEndSSL; }
// Returns true when at least first hop is SSL (e.g. proxy over https or https uri)
bool FirstHopSSL() const { return mEndToEndSSL || mUsingHttpsProxy; }
// Returns true when CONNECT is used to tunnel through the proxy (e.g. https:// or ws://)
bool UsingConnect() const { return mUsingConnect; }
// Returns true when origin/proxy is an RFC1918 literal.
bool HostIsLocalIPLiteral() const;
private:
void Init(const nsACString &host,
int32_t port,
const nsACString &npnToken,
const nsACString &username,
nsProxyInfo* proxyInfo,
const NeckoOriginAttributes &originAttributes,
bool EndToEndSSL);
void SetOriginServer(const nsACString &host, int32_t port);
nsCString mOrigin;
int32_t mOriginPort;
nsCString mRoutedHost;
int32_t mRoutedPort;
nsCString mHashKey;
nsCString mNetworkInterfaceId;
nsCString mUsername;
nsCOMPtr<nsProxyInfo> mProxyInfo;
bool mUsingHttpProxy;
bool mUsingHttpsProxy;
bool mEndToEndSSL;
bool mUsingConnect; // if will use CONNECT with http proxy
nsCString mNPNToken;
NeckoOriginAttributes mOriginAttributes;
// for RefPtr
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(nsHttpConnectionInfo)
};
} // namespace net
} // namespace mozilla
#endif // nsHttpConnectionInfo_h__
|
