gecko-dev/netwerk/protocol/http/nsHttpConnectionInfo.h

/* -*- 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 @%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 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;

// for RefPtr
    NS_INLINE_DECL_THREADSAFE_REFCOUNTING(nsHttpConnectionInfo)
};

} // namespace net
} // namespace mozilla

#endif // nsHttpConnectionInfo_h__