gecko-dev/netwerk/base/nsSocketTransport2.h

450 строки
15 KiB
C
Исходник Обычный вид История

2012-05-21 15:12:37 +04:00
/* 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"
2013-03-03 12:04:38 +04:00
#include "prerror.h"
#include "nsAutoPtr.h"
2013-03-03 12:04:38 +04:00
class nsSocketTransport;
class nsICancelable;
class nsIDNSRecord;
class nsIInterfaceRequestor;
2013-03-03 12:04:38 +04:00
nsresult
ErrorAccordingToNSPR(PRErrorCode errorCode);
//-----------------------------------------------------------------------------
// after this short interval, we will return to PR_Poll
#define NS_SOCKET_CONNECT_TIMEOUT PR_MillisecondsToInterval(20)
//-----------------------------------------------------------------------------
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;
mozilla::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 NS_METHOD WriteFromSegments(nsIInputStream *, void *,
const char *, uint32_t offset,
uint32_t count, uint32_t *countRead);
nsSocketTransport *mTransport;
mozilla::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
{
typedef mozilla::Mutex Mutex;
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);
// this method instructs the socket transport to use an already connected
// socket with the given address.
nsresult InitWithConnectedSocket(PRFileDesc *socketFD,
const mozilla::net::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 mozilla::net::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,
mozilla::Telemetry::ID aIDNormal,
mozilla::Telemetry::ID aIDShutdown,
mozilla::Telemetry::ID aIDConnectivityChange,
mozilla::Telemetry::ID aIDLinkChange,
mozilla::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:
typedef mozilla::MutexAutoLock MutexAutoLock;
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;
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);
mozilla::net::NetAddr mNetAddr;
mozilla::net::NetAddr mSelfAddr; // getsockname()
mozilla::Atomic<bool, mozilla::Relaxed> mNetAddrIsSet;
mozilla::Atomic<bool, mozilla::Relaxed> mSelfAddrIsSet;
nsAutoPtr<mozilla::net::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.
Bug 1207245 - part 6 - rename nsRefPtr<T> to RefPtr<T>; r=ehsan; a=Tomcat The bulk of this commit was generated with a script, executed at the top level of a typical source code checkout. The only non-machine-generated part was modifying MFBT's moz.build to reflect the new naming. CLOSED TREE makes big refactorings like this a piece of cake. # The main substitution. find . -name '*.cpp' -o -name '*.cc' -o -name '*.h' -o -name '*.mm' -o -name '*.idl'| \ xargs perl -p -i -e ' s/nsRefPtr\.h/RefPtr\.h/g; # handle includes s/nsRefPtr ?</RefPtr</g; # handle declarations and variables ' # Handle a special friend declaration in gfx/layers/AtomicRefCountedWithFinalize.h. perl -p -i -e 's/::nsRefPtr;/::RefPtr;/' gfx/layers/AtomicRefCountedWithFinalize.h # Handle nsRefPtr.h itself, a couple places that define constructors # from nsRefPtr, and code generators specially. We do this here, rather # than indiscriminantly s/nsRefPtr/RefPtr/, because that would rename # things like nsRefPtrHashtable. perl -p -i -e 's/nsRefPtr/RefPtr/g' \ mfbt/nsRefPtr.h \ xpcom/glue/nsCOMPtr.h \ xpcom/base/OwningNonNull.h \ ipc/ipdl/ipdl/lower.py \ ipc/ipdl/ipdl/builtin.py \ dom/bindings/Codegen.py \ python/lldbutils/lldbutils/utils.py # In our indiscriminate substitution above, we renamed # nsRefPtrGetterAddRefs, the class behind getter_AddRefs. Fix that up. find . -name '*.cpp' -o -name '*.h' -o -name '*.idl' | \ xargs perl -p -i -e 's/nsRefPtrGetterAddRefs/RefPtrGetterAddRefs/g' if [ -d .git ]; then git mv mfbt/nsRefPtr.h mfbt/RefPtr.h else hg mv mfbt/nsRefPtr.h mfbt/RefPtr.h fi --HG-- rename : mfbt/nsRefPtr.h => mfbt/RefPtr.h
2015-10-18 08:24:48 +03:00
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;
};
#endif // !nsSocketTransport_h__