diff options
Diffstat (limited to 'netwerk/protocol/http/nsHttpConnectionInfo.h')
| -rw-r--r-- | netwerk/protocol/http/nsHttpConnectionInfo.h | 186 |
1 files changed, 186 insertions, 0 deletions
diff --git a/netwerk/protocol/http/nsHttpConnectionInfo.h b/netwerk/protocol/http/nsHttpConnectionInfo.h new file mode 100644 index 000000000..9c5d29d72 --- /dev/null +++ b/netwerk/protocol/http/nsHttpConnectionInfo.h @@ -0,0 +1,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__ |