DXR is a code search and navigation tool aimed at making sense of large projects. It supports full-text and regex searches as well as structural queries.

Implementation

Mercurial (1aeaa33a64f9)

VCS Links

Line Code
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 187 188 189 190 191 192 193
/* -*- 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 OriginAttributes &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 OriginAttributes &originAttributes,
                       const nsACString &routedHost, int32_t routedPort);

 private:
  virtual ~nsHttpConnectionInfo() {
    MOZ_LOG(gHttpLog, LogLevel::Debug,
            ("Destroying nsHttpConnectionInfo @%p\n", this));
  }

  void BuildHashKey();

 public:
  const nsCString &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);
  MOZ_MUST_USE 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'; }

  void SetTlsFlags(uint32_t aTlsFlags);
  uint32_t GetTlsFlags() const { return mTlsFlags; }

  const nsCString &GetNetworkInterfaceId() const { return mNetworkInterfaceId; }

  const nsCString &GetNPNToken() { return mNPNToken; }
  const nsCString &GetUsername() { return mUsername; }

  const OriginAttributes &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 OriginAttributes &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;
  OriginAttributes mOriginAttributes;

  uint32_t mTlsFlags;

  // for RefPtr
  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(nsHttpConnectionInfo, override)
};

}  // namespace net
}  // namespace mozilla

#endif  // nsHttpConnectionInfo_h__