summaryrefslogtreecommitdiffstats
path: root/netwerk/base/nsSocketTransport2.h
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /netwerk/base/nsSocketTransport2.h
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'netwerk/base/nsSocketTransport2.h')
-rw-r--r--netwerk/base/nsSocketTransport2.h471
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__