mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
e4e2da55c9
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
446 lines
15 KiB
C++
446 lines
15 KiB
C++
/* 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 nsSocketTransport;
|
|
class nsICancelable;
|
|
class nsIDNSRecord;
|
|
class nsIInterfaceRequestor;
|
|
|
|
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;
|
|
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 is valid from GetPeerAddr() once we have
|
|
// reached STATE_TRANSFERRING. It must not change after that.
|
|
mozilla::net::NetAddr mNetAddr;
|
|
bool mNetAddrIsSet;
|
|
|
|
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.
|
|
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__
|