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 (fddffdeab170)

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
/* -*- 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 "ARefBase.h"

extern PRLogModuleInfo *gHttpLog;

//-----------------------------------------------------------------------------
// 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 {

class nsHttpConnectionInfo: public ARefBase
{
public:
    nsHttpConnectionInfo(const nsACString &originHost,
                         int32_t originPort,
                         const nsACString &npnToken,
                         const nsACString &username,
                         nsProxyInfo *proxyInfo,
                         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 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; }

    // 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'; }

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

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

    // 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,
              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;

// for RefPtr
    NS_INLINE_DECL_THREADSAFE_REFCOUNTING(nsHttpConnectionInfo)
};

} // namespace net
} // namespace mozilla

#endif // nsHttpConnectionInfo_h__