Add m-esr52 at 52.6.0

1 files changed, 471 insertions, 0 deletions

diff --git a/netwerk/base/nsSocketTransport2.h b/netwerk/base/nsSocketTransport2.h
new file mode 100644
index 000000000..7c85ccdc4
--- /dev/null
+++ b/netwerk/base/nsSocketTransport2.h
@@ -0,0 +1,471 @@
+/* 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 nsSocketTransport2_h__
+#define nsSocketTransport2_h__
+
+#ifdef DEBUG_darinf
+#define ENABLE_SOCKET_TRACING
+#endif
+
+#include "mozilla/Mutex.h"
+#include "nsSocketTransportService2.h"
+#include "nsString.h"
+#include "nsCOMPtr.h"
+
+#include "nsIInterfaceRequestor.h"
+#include "nsISocketTransport.h"
+#include "nsIAsyncInputStream.h"
+#include "nsIAsyncOutputStream.h"
+#include "nsIDNSListener.h"
+#include "nsIClassInfo.h"
+#include "mozilla/net/DNS.h"
+#include "nsASocketHandler.h"
+#include "mozilla/Telemetry.h"
+
+#include "prerror.h"
+#include "nsAutoPtr.h"
+
+class nsICancelable;
+class nsIDNSRecord;
+class nsIInterfaceRequestor;
+
+//-----------------------------------------------------------------------------
+
+// after this short interval, we will return to PR_Poll
+#define NS_SOCKET_CONNECT_TIMEOUT PR_MillisecondsToInterval(20)
+
+//-----------------------------------------------------------------------------
+
+namespace mozilla {
+namespace net {
+
+nsresult
+ErrorAccordingToNSPR(PRErrorCode errorCode);
+
+class nsSocketTransport;
+
+class nsSocketInputStream : public nsIAsyncInputStream
+{
+public:
+    NS_DECL_ISUPPORTS_INHERITED
+    NS_DECL_NSIINPUTSTREAM
+    NS_DECL_NSIASYNCINPUTSTREAM
+
+    explicit nsSocketInputStream(nsSocketTransport *);
+    virtual ~nsSocketInputStream();
+
+    bool     IsReferenced() { return mReaderRefCnt > 0; }
+    nsresult Condition()    { return mCondition; }
+    uint64_t ByteCount()    { return mByteCount; }
+
+    // called by the socket transport on the socket thread...
+    void OnSocketReady(nsresult condition);
+
+private:
+    nsSocketTransport               *mTransport;
+    ThreadSafeAutoRefCnt             mReaderRefCnt;
+
+    // access to these is protected by mTransport->mLock
+    nsresult                         mCondition;
+    nsCOMPtr<nsIInputStreamCallback> mCallback;
+    uint32_t                         mCallbackFlags;
+    uint64_t                         mByteCount;
+};
+
+//-----------------------------------------------------------------------------
+
+class nsSocketOutputStream : public nsIAsyncOutputStream
+{
+public:
+    NS_DECL_ISUPPORTS_INHERITED
+    NS_DECL_NSIOUTPUTSTREAM
+    NS_DECL_NSIASYNCOUTPUTSTREAM
+
+    explicit nsSocketOutputStream(nsSocketTransport *);
+    virtual ~nsSocketOutputStream();
+
+    bool     IsReferenced() { return mWriterRefCnt > 0; }
+    nsresult Condition()    { return mCondition; }
+    uint64_t ByteCount()    { return mByteCount; }
+
+    // called by the socket transport on the socket thread...
+    void OnSocketReady(nsresult condition); 
+
+private:
+    static nsresult WriteFromSegments(nsIInputStream *, void *,
+                                      const char *, uint32_t offset,
+                                      uint32_t count, uint32_t *countRead);
+
+    nsSocketTransport                *mTransport;
+    ThreadSafeAutoRefCnt              mWriterRefCnt;
+
+    // access to these is protected by mTransport->mLock
+    nsresult                          mCondition;
+    nsCOMPtr<nsIOutputStreamCallback> mCallback;
+    uint32_t                          mCallbackFlags;
+    uint64_t                          mByteCount;
+};
+
+//-----------------------------------------------------------------------------
+
+class nsSocketTransport final : public nsASocketHandler
+                              , public nsISocketTransport
+                              , public nsIDNSListener
+                              , public nsIClassInfo
+                              , public nsIInterfaceRequestor
+{
+public:
+    NS_DECL_THREADSAFE_ISUPPORTS
+    NS_DECL_NSITRANSPORT
+    NS_DECL_NSISOCKETTRANSPORT
+    NS_DECL_NSIDNSLISTENER
+    NS_DECL_NSICLASSINFO
+    NS_DECL_NSIINTERFACEREQUESTOR
+
+    nsSocketTransport();
+
+    // this method instructs the socket transport to open a socket of the
+    // given type(s) to the given host or proxy.
+    nsresult Init(const char **socketTypes, uint32_t typeCount,
+                  const nsACString &host, uint16_t port,
+                  const nsACString &hostRoute, uint16_t portRoute,
+                  nsIProxyInfo *proxyInfo);
+
+    // Alternative Init method for when the IP-address of the host
+    // has been pre-resolved using a alternative means (e.g. FlyWeb service
+    // info).
+    nsresult InitPreResolved(const char **socketTypes, uint32_t typeCount,
+                             const nsACString &host, uint16_t port,
+                             const nsACString &hostRoute, uint16_t portRoute,
+                             nsIProxyInfo *proxyInfo,
+                             const mozilla::net::NetAddr* addr);
+
+    // this method instructs the socket transport to use an already connected
+    // socket with the given address.
+    nsresult InitWithConnectedSocket(PRFileDesc *socketFD,
+                                     const NetAddr *addr);
+
+    // this method instructs the socket transport to use an already connected
+    // socket with the given address, and additionally supplies security info.
+    nsresult InitWithConnectedSocket(PRFileDesc* aSocketFD,
+                                     const NetAddr* aAddr,
+                                     nsISupports* aSecInfo);
+
+    // This method instructs the socket transport to open a socket
+    // connected to the given Unix domain address. We can only create
+    // unlayered, simple, stream sockets.
+    nsresult InitWithFilename(const char *filename);
+
+    // nsASocketHandler methods:
+    void OnSocketReady(PRFileDesc *, int16_t outFlags) override;
+    void OnSocketDetached(PRFileDesc *) override;
+    void IsLocal(bool *aIsLocal) override;
+    void OnKeepaliveEnabledPrefChange(bool aEnabled) override final;
+
+    // called when a socket event is handled
+    void OnSocketEvent(uint32_t type, nsresult status, nsISupports *param);
+
+    uint64_t ByteCountReceived() override { return mInput.ByteCount(); }
+    uint64_t ByteCountSent() override { return mOutput.ByteCount(); }
+    static void CloseSocket(PRFileDesc *aFd, bool aTelemetryEnabled);
+    static void SendPRBlockingTelemetry(PRIntervalTime aStart,
+        Telemetry::ID aIDNormal,
+        Telemetry::ID aIDShutdown,
+        Telemetry::ID aIDConnectivityChange,
+        Telemetry::ID aIDLinkChange,
+        Telemetry::ID aIDOffline);
+protected:
+
+    virtual ~nsSocketTransport();
+    void     CleanupTypes();
+
+private:
+
+    // event types
+    enum {
+        MSG_ENSURE_CONNECT,
+        MSG_DNS_LOOKUP_COMPLETE,
+        MSG_RETRY_INIT_SOCKET,
+        MSG_TIMEOUT_CHANGED,
+        MSG_INPUT_CLOSED,
+        MSG_INPUT_PENDING,
+        MSG_OUTPUT_CLOSED,
+        MSG_OUTPUT_PENDING
+    };
+    nsresult PostEvent(uint32_t type, nsresult status = NS_OK, nsISupports *param = nullptr);
+
+    enum {
+        STATE_CLOSED,
+        STATE_IDLE,
+        STATE_RESOLVING,
+        STATE_CONNECTING,
+        STATE_TRANSFERRING
+    };
+
+    // Safer way to get and automatically release PRFileDesc objects.
+    class MOZ_STACK_CLASS PRFileDescAutoLock
+    {
+    public:
+      explicit PRFileDescAutoLock(nsSocketTransport *aSocketTransport,
+                                  nsresult *aConditionWhileLocked = nullptr)
+        : mSocketTransport(aSocketTransport)
+        , mFd(nullptr)
+      {
+        MOZ_ASSERT(aSocketTransport);
+        MutexAutoLock lock(mSocketTransport->mLock);
+        if (aConditionWhileLocked) {
+          *aConditionWhileLocked = mSocketTransport->mCondition;
+          if (NS_FAILED(mSocketTransport->mCondition)) {
+            return;
+          }
+        }
+        mFd = mSocketTransport->GetFD_Locked();
+      }
+      ~PRFileDescAutoLock() {
+        MutexAutoLock lock(mSocketTransport->mLock);
+        if (mFd) {
+          mSocketTransport->ReleaseFD_Locked(mFd);
+        }
+      }
+      bool IsInitialized() {
+        return mFd;
+      }
+      operator PRFileDesc*() {
+        return mFd;
+      }
+      nsresult SetKeepaliveEnabled(bool aEnable);
+      nsresult SetKeepaliveVals(bool aEnabled, int aIdleTime,
+                                int aRetryInterval, int aProbeCount);
+    private:
+      operator PRFileDescAutoLock*() { return nullptr; }
+
+      // Weak ptr to nsSocketTransport since this is a stack class only.
+      nsSocketTransport *mSocketTransport;
+      PRFileDesc        *mFd;
+    };
+    friend class PRFileDescAutoLock;
+
+    class LockedPRFileDesc
+    {
+    public:
+      explicit LockedPRFileDesc(nsSocketTransport *aSocketTransport)
+        : mSocketTransport(aSocketTransport)
+        , mFd(nullptr)
+      {
+        MOZ_ASSERT(aSocketTransport);
+      }
+      ~LockedPRFileDesc() {}
+      bool IsInitialized() {
+        return mFd;
+      }
+      LockedPRFileDesc& operator=(PRFileDesc *aFd) {
+        mSocketTransport->mLock.AssertCurrentThreadOwns();
+        mFd = aFd;
+        return *this;
+      }
+      operator PRFileDesc*() {
+        if (mSocketTransport->mAttached) {
+          mSocketTransport->mLock.AssertCurrentThreadOwns();
+        }
+        return mFd;
+      }
+      bool operator==(PRFileDesc *aFd) {
+        mSocketTransport->mLock.AssertCurrentThreadOwns();
+        return mFd == aFd;
+      }
+    private:
+      operator LockedPRFileDesc*() { return nullptr; }
+      // Weak ptr to nsSocketTransport since it owns this class.
+      nsSocketTransport *mSocketTransport;
+      PRFileDesc        *mFd;
+    };
+    friend class LockedPRFileDesc;
+
+    //-------------------------------------------------------------------------
+    // these members are "set" at initialization time and are never modified
+    // afterwards.  this allows them to be safely accessed from any thread.
+    //-------------------------------------------------------------------------
+
+    // socket type info:
+    char       **mTypes;
+    uint32_t     mTypeCount;
+    nsCString    mHost;
+    nsCString    mProxyHost;
+    nsCString    mOriginHost;
+    uint16_t     mPort;
+    nsCOMPtr<nsIProxyInfo> mProxyInfo;
+    uint16_t     mProxyPort;
+    uint16_t     mOriginPort;
+    bool mProxyTransparent;
+    bool mProxyTransparentResolvesHost;
+    bool mHttpsProxy;
+    uint32_t     mConnectionFlags;
+
+    // The origin attributes are used to create sockets.  The first party domain
+    // will eventually be used to isolate OCSP cache and is only non-empty when
+    // "privacy.firstparty.isolate" is enabled.  Setting this is the only way to
+    // carry origin attributes down to NSPR layers which are final consumers.
+    // It must be set before the socket transport is built.
+    NeckoOriginAttributes mOriginAttributes;
+    
+    uint16_t         SocketPort() { return (!mProxyHost.IsEmpty() && !mProxyTransparent) ? mProxyPort : mPort; }
+    const nsCString &SocketHost() { return (!mProxyHost.IsEmpty() && !mProxyTransparent) ? mProxyHost : mHost; }
+
+    //-------------------------------------------------------------------------
+    // members accessible only on the socket transport thread:
+    //  (the exception being initialization/shutdown time)
+    //-------------------------------------------------------------------------
+
+    // socket state vars:
+    uint32_t     mState;     // STATE_??? flags
+    bool mAttached;
+    bool mInputClosed;
+    bool mOutputClosed;
+
+    // The platform-specific network interface id that this socket
+    // associated with.
+    nsCString mNetworkInterfaceId;
+
+    // this flag is used to determine if the results of a host lookup arrive
+    // recursively or not.  this flag is not protected by any lock.
+    bool mResolving;
+
+    nsCOMPtr<nsICancelable> mDNSRequest;
+    nsCOMPtr<nsIDNSRecord>  mDNSRecord;
+
+    // mNetAddr/mSelfAddr is valid from GetPeerAddr()/GetSelfAddr() once we have
+    // reached STATE_TRANSFERRING. It must not change after that.
+    void                    SetSocketName(PRFileDesc *fd);
+    NetAddr                 mNetAddr;
+    NetAddr                 mSelfAddr; // getsockname()
+    Atomic<bool, Relaxed>   mNetAddrIsSet;
+    Atomic<bool, Relaxed>   mSelfAddrIsSet;
+    Atomic<bool, Relaxed>   mNetAddrPreResolved;
+
+    nsAutoPtr<NetAddr>      mBindAddr;
+
+    // socket methods (these can only be called on the socket thread):
+
+    void     SendStatus(nsresult status);
+    nsresult ResolveHost();
+    nsresult BuildSocket(PRFileDesc *&, bool &, bool &); 
+    nsresult InitiateSocket();
+    bool     RecoverFromError();
+
+    void OnMsgInputPending()
+    {
+        if (mState == STATE_TRANSFERRING)
+            mPollFlags |= (PR_POLL_READ | PR_POLL_EXCEPT);
+    }
+    void OnMsgOutputPending()
+    {
+        if (mState == STATE_TRANSFERRING)
+            mPollFlags |= (PR_POLL_WRITE | PR_POLL_EXCEPT);
+    }
+    void OnMsgInputClosed(nsresult reason);
+    void OnMsgOutputClosed(nsresult reason);
+
+    // called when the socket is connected
+    void OnSocketConnected();
+
+    //-------------------------------------------------------------------------
+    // socket input/output objects.  these may be accessed on any thread with
+    // the exception of some specific methods (XXX).
+
+    Mutex            mLock;  // protects members in this section.
+    LockedPRFileDesc mFD;
+    nsrefcnt         mFDref;       // mFD is closed when mFDref goes to zero.
+    bool             mFDconnected; // mFD is available to consumer when TRUE.
+
+    // A delete protector reference to gSocketTransportService held for lifetime
+    // of 'this'. Sometimes used interchangably with gSocketTransportService due
+    // to scoping.
+    RefPtr<nsSocketTransportService> mSocketTransportService;
+
+    nsCOMPtr<nsIInterfaceRequestor> mCallbacks;
+    nsCOMPtr<nsITransportEventSink> mEventSink;
+    nsCOMPtr<nsISupports>           mSecInfo;
+
+    nsSocketInputStream  mInput;
+    nsSocketOutputStream mOutput;
+
+    friend class nsSocketInputStream;
+    friend class nsSocketOutputStream;
+
+    // socket timeouts are not protected by any lock.
+    uint16_t mTimeouts[2];
+
+    // QoS setting for socket
+    uint8_t mQoSBits;
+
+    //
+    // mFD access methods: called with mLock held.
+    //
+    PRFileDesc *GetFD_Locked();
+    void        ReleaseFD_Locked(PRFileDesc *fd);
+
+    //
+    // stream state changes (called outside mLock):
+    //
+    void OnInputClosed(nsresult reason)
+    {
+        // no need to post an event if called on the socket thread
+        if (PR_GetCurrentThread() == gSocketThread)
+            OnMsgInputClosed(reason);
+        else
+            PostEvent(MSG_INPUT_CLOSED, reason);
+    }
+    void OnInputPending()
+    {
+        // no need to post an event if called on the socket thread
+        if (PR_GetCurrentThread() == gSocketThread)
+            OnMsgInputPending();
+        else
+            PostEvent(MSG_INPUT_PENDING);
+    }
+    void OnOutputClosed(nsresult reason)
+    {
+        // no need to post an event if called on the socket thread
+        if (PR_GetCurrentThread() == gSocketThread)
+            OnMsgOutputClosed(reason); // XXX need to not be inside lock!
+        else
+            PostEvent(MSG_OUTPUT_CLOSED, reason);
+    }
+    void OnOutputPending()
+    {
+        // no need to post an event if called on the socket thread
+        if (PR_GetCurrentThread() == gSocketThread)
+            OnMsgOutputPending();
+        else
+            PostEvent(MSG_OUTPUT_PENDING);
+    }
+
+#ifdef ENABLE_SOCKET_TRACING
+    void TraceInBuf(const char *buf, int32_t n);
+    void TraceOutBuf(const char *buf, int32_t n);
+#endif
+
+    // Reads prefs to get default keepalive config.
+    nsresult EnsureKeepaliveValsAreInitialized();
+
+    // Groups calls to fd.SetKeepaliveEnabled and fd.SetKeepaliveVals.
+    nsresult SetKeepaliveEnabledInternal(bool aEnable);
+
+    // True if keepalive has been enabled by the socket owner. Note: Keepalive
+    // must also be enabled globally for it to be enabled in TCP.
+    bool mKeepaliveEnabled;
+
+    // Keepalive config (support varies by platform).
+    int32_t mKeepaliveIdleTimeS;
+    int32_t mKeepaliveRetryIntervalS;
+    int32_t mKeepaliveProbeCount;
+
+    bool mDoNotRetryToConnect;
+};
+
+} // namespace net
+} // namespace mozilla
+
+#endif // !nsSocketTransport_h__