folly::AsyncSocket Class Reference

#include <AsyncSocket.h>

Inheritance diagram for folly::AsyncSocket:

Classes
class	BytesWriteRequest
class	ConnectCallback
class	ErrMessageCallback
class	EvbChangeCallback
class	ImmediateReadCB
struct	IOBufInfo
class	IoHandler
class	OptionKey
struct	ReadResult
class	SendMsgParamsCallback
class	WriteRequest
struct	WriteResult
class	WriteTimeout

Public Types
enum	StateEnum : uint8_t {   StateEnum::UNINIT, StateEnum::CONNECTING, StateEnum::ESTABLISHED, StateEnum::CLOSED,   StateEnum::ERROR, StateEnum::FAST_OPEN }
typedef std::unique_ptr< AsyncSocket, Destructor >	UniquePtr
typedef std::map< OptionKey, int >	OptionMap
Public Types inherited from folly::AsyncTransportWrapper
using	UniquePtr = std::unique_ptr< AsyncTransportWrapper, Destructor >
using	ReadCallback = AsyncReader::ReadCallback
using	WriteCallback = AsyncWriter::WriteCallback
Public Types inherited from folly::AsyncTransport
typedef std::unique_ptr< AsyncTransport, Destructor >	UniquePtr

Public Member Functions
	AsyncSocket ()
	AsyncSocket (EventBase *evb)
void	setShutdownSocketSet (const std::weak_ptr< ShutdownSocketSet > &wSS)
	AsyncSocket (EventBase *evb, const folly::SocketAddress &address, uint32_t connectTimeout=0)
	AsyncSocket (EventBase *evb, const std::string &ip, uint16_t port, uint32_t connectTimeout=0)
	AsyncSocket (EventBase *evb, int fd, uint32_t zeroCopyBufId=0)
	AsyncSocket (AsyncSocket::UniquePtr)
void	destroy () override
EventBase *	getEventBase () const override
virtual int	getFd () const
virtual int	detachFd ()
virtual void	connect (ConnectCallback *callback, const folly::SocketAddress &address, int timeout=0, const OptionMap &options=emptyOptionMap, const folly::SocketAddress &bindAddr=anyAddress()) noexcept
void	connect (ConnectCallback *callback, const std::string &ip, uint16_t port, int timeout=0, const OptionMap &options=emptyOptionMap) noexcept
void	cancelConnect ()
void	setSendTimeout (uint32_t milliseconds) override
uint32_t	getSendTimeout () const override
void	setMaxReadsPerEvent (uint16_t maxReads)
uint16_t	getMaxReadsPerEvent () const
virtual void	setErrMessageCB (ErrMessageCallback *callback)
virtual ErrMessageCallback *	getErrMessageCallback () const
virtual void	setSendMsgParamCB (SendMsgParamsCallback *callback)
virtual SendMsgParamsCallback *	getSendMsgParamsCB () const
void	setReadCB (ReadCallback *callback) override
ReadCallback *	getReadCallback () const override
bool	setZeroCopy (bool enable)
bool	getZeroCopy () const
uint32_t	getZeroCopyBufId () const
size_t	getZeroCopyReenableThreshold () const
void	setZeroCopyReenableThreshold (size_t threshold)
void	write (WriteCallback *callback, const void *buf, size_t bytes, WriteFlags flags=WriteFlags::NONE) override
void	writev (WriteCallback *callback, const iovec *vec, size_t count, WriteFlags flags=WriteFlags::NONE) override
void	writeChain (WriteCallback *callback, std::unique_ptr< folly::IOBuf > &&buf, WriteFlags flags=WriteFlags::NONE) override
virtual void	writeRequest (WriteRequest *req)
void	writeRequestReady ()
void	close () override
void	closeNow () override
void	closeWithReset () override
void	shutdownWrite () override
void	shutdownWriteNow () override
bool	readable () const override
bool	writable () const override
bool	isPending () const override
virtual bool	hangup () const
bool	good () const override
bool	error () const override
void	attachEventBase (EventBase *eventBase) override
void	detachEventBase () override
bool	isDetachable () const override
void	getLocalAddress (folly::SocketAddress *address) const override
void	getPeerAddress (folly::SocketAddress *address) const override
bool	isEorTrackingEnabled () const override
void	setEorTracking (bool track) override
bool	connecting () const override
virtual bool	isClosedByPeer () const
virtual bool	isClosedBySelf () const
size_t	getAppBytesWritten () const override
size_t	getRawBytesWritten () const override
size_t	getAppBytesReceived () const override
size_t	getRawBytesReceived () const override
std::chrono::nanoseconds	getConnectTime () const
std::chrono::milliseconds	getConnectTimeout () const
std::chrono::steady_clock::time_point	getConnectStartTime () const
std::chrono::steady_clock::time_point	getConnectEndTime () const
bool	getTFOAttempted () const
bool	getTFOFinished () const
bool	getTFOSucceded () const
int	setNoDelay (bool noDelay)
void	setCloseOnExec ()
int	setCongestionFlavor (const std::string &cname)
int	setQuickAck (bool quickack)
int	setSendBufSize (size_t bufsize)
int	setRecvBufSize (size_t bufsize)
int	setTCPProfile (int profd)
template<typename T >
int	getSockOpt (int level, int optname, T *optval, socklen_t *optlen)
template<typename T >
int	setSockOpt (int level, int optname, const T *optval)
virtual int	getSockOptVirtual (int level, int optname, void *optval, socklen_t *optlen)
virtual int	setSockOptVirtual (int level, int optname, void const *optval, socklen_t optlen)
virtual void	setPreReceivedData (std::unique_ptr< IOBuf > data)
void	enableTFO ()
void	disableTransparentTls ()
void	disableTSocks ()
void	setBufferCallback (BufferCallback *cb)
void	setEvbChangedCallback (std::unique_ptr< EvbChangeCallback > cb)
void	cacheAddresses ()
bool	isZeroCopyWriteInProgress () const noexcept
bool	processZeroCopyWriteInProgress () noexcept
void	setPeerCertificate (std::unique_ptr< const AsyncTransportCertificate > cert)
const AsyncTransportCertificate *	getPeerCertificate () const override
void	setSelfCertificate (std::unique_ptr< const AsyncTransportCertificate > cert)
const AsyncTransportCertificate *	getSelfCertificate () const override
Public Member Functions inherited from folly::AsyncTransportWrapper
virtual const AsyncTransportWrapper *	getWrappedTransport () const
template<class T >
const T *	getUnderlyingTransport () const
template<class T >
T *	getUnderlyingTransport ()
Public Member Functions inherited from folly::AsyncTransport
SocketAddress	getLocalAddress () const
void	getAddress (SocketAddress *address) const override
SocketAddress	getPeerAddress () const
virtual ssl::X509UniquePtr	getPeerCert () const
virtual const X509 *	getSelfCert () const
virtual std::string	getApplicationProtocol () const noexcept
virtual std::string	getSecurityProtocol () const
virtual bool	isReplaySafe () const
virtual void	setReplaySafetyCallback (ReplaySafetyCallback *callback)
Public Member Functions inherited from folly::DelayedDestruction
bool	getDestroyPending () const
Public Member Functions inherited from folly::DelayedDestructionBase
virtual	~DelayedDestructionBase ()=default
Public Member Functions inherited from folly::AsyncSocketBase
virtual	~AsyncSocketBase ()=default

Static Public Member Functions
static std::shared_ptr< AsyncSocket >	newSocket (EventBase *evb)
static std::shared_ptr< AsyncSocket >	newSocket (EventBase *evb, const folly::SocketAddress &address, uint32_t connectTimeout=0)
static std::shared_ptr< AsyncSocket >	newSocket (EventBase *evb, const std::string &ip, uint16_t port, uint32_t connectTimeout=0)
static std::shared_ptr< AsyncSocket >	newSocket (EventBase *evb, int fd)
static const folly::SocketAddress &	anyAddress ()

Static Public Attributes
static const OptionMap	emptyOptionMap

Protected Types
enum	ReadResultEnum { READ_EOF = 0, READ_ERROR = -1, READ_BLOCKING = -2, READ_NO_ERROR = -3 }
enum	WriteResultEnum { WRITE_ERROR = -1 }
enum	ShutdownFlags { SHUT_WRITE_PENDING = 0x01, SHUT_WRITE = 0x02, SHUT_READ = 0x04 }

Protected Member Functions
	~AsyncSocket () override
void	init ()
void	scheduleImmediateRead () noexcept
void	scheduleInitialReadWrite () noexcept
void	ioReady (uint16_t events) noexcept
virtual void	checkForImmediateRead () noexcept
virtual void	handleInitialReadWrite () noexcept
virtual void	prepareReadBuffer (void **buf, size_t *buflen)
virtual size_t	handleErrMessages () noexcept
virtual void	handleRead () noexcept
virtual void	handleWrite () noexcept
virtual void	handleConnect () noexcept
void	timeoutExpired () noexcept
virtual ReadResult	performRead (void **buf, size_t *buflen, size_t *offset)
void	writeChainImpl (WriteCallback *callback, iovec *vec, size_t count, std::unique_ptr< folly::IOBuf > &&buf, WriteFlags flags)
void	writeImpl (WriteCallback *callback, const iovec *vec, size_t count, std::unique_ptr< folly::IOBuf > &&buf, WriteFlags flags=WriteFlags::NONE)
virtual WriteResult	performWrite (const iovec *vec, uint32_t count, WriteFlags flags, uint32_t *countWritten, uint32_t *partialWritten)
AsyncSocket::WriteResult	sendSocketMessage (int fd, struct msghdr *msg, int msg_flags)
virtual ssize_t	tfoSendMsg (int fd, struct msghdr *msg, int msg_flags)
int	socketConnect (const struct sockaddr *addr, socklen_t len)
virtual void	scheduleConnectTimeout ()
void	registerForConnectEvents ()
bool	updateEventRegistration ()
bool	updateEventRegistration (uint16_t enable, uint16_t disable)
void	doClose ()
void	startFail ()
void	finishFail ()
void	finishFail (const AsyncSocketException &ex)
void	invokeAllErrors (const AsyncSocketException &ex)
void	fail (const char *fn, const AsyncSocketException &ex)
void	failConnect (const char *fn, const AsyncSocketException &ex)
void	failRead (const char *fn, const AsyncSocketException &ex)
void	failErrMessageRead (const char *fn, const AsyncSocketException &ex)
void	failWrite (const char *fn, WriteCallback *callback, size_t bytesWritten, const AsyncSocketException &ex)
void	failWrite (const char *fn, const AsyncSocketException &ex)
void	failAllWrites (const AsyncSocketException &ex)
virtual void	invokeConnectErr (const AsyncSocketException &ex)
virtual void	invokeConnectSuccess ()
void	invalidState (ConnectCallback *callback)
void	invalidState (ErrMessageCallback *callback)
void	invalidState (ReadCallback *callback)
void	invalidState (WriteCallback *callback)
std::string	withAddr (const std::string &s)
void	cacheLocalAddress () const
void	cachePeerAddress () const
bool	isZeroCopyRequest (WriteFlags flags)
bool	isZeroCopyMsg (const cmsghdr &cmsg) const
void	processZeroCopyMsg (const cmsghdr &cmsg)
uint32_t	getNextZeroCopyBufId ()
void	adjustZeroCopyFlags (folly::WriteFlags &flags)
void	addZeroCopyBuf (std::unique_ptr< folly::IOBuf > &&buf)
void	addZeroCopyBuf (folly::IOBuf *ptr)
void	setZeroCopyBuf (std::unique_ptr< folly::IOBuf > &&buf)
bool	containsZeroCopyBuf (folly::IOBuf *ptr)
void	releaseZeroCopyBuf (uint32_t id)
Protected Member Functions inherited from folly::AsyncTransport
	~AsyncTransport () override=default
Protected Member Functions inherited from folly::DelayedDestruction
	~DelayedDestruction () override=default
	DelayedDestruction ()
Protected Member Functions inherited from folly::DelayedDestructionBase
	DelayedDestructionBase ()
uint32_t	getDestructorGuardCount () const
Protected Member Functions inherited from folly::AsyncReader
virtual	~AsyncReader ()=default
Protected Member Functions inherited from folly::AsyncWriter
virtual	~AsyncWriter ()=default

Protected Attributes
uint32_t	zeroCopyBufId_ {0}
std::unordered_map< uint32_t, folly::IOBuf * >	idZeroCopyBufPtrMap_
std::unordered_map< folly::IOBuf *, IOBufInfo >	idZeroCopyBufInfoMap_
StateEnum	state_
	StateEnum describing current state. More...
uint8_t	shutdownFlags_
	Shutdown state (ShutdownFlags) More...
uint16_t	eventFlags_
	EventBase::HandlerFlags settings. More...
int	fd_
	The socket file descriptor. More...
folly::SocketAddress	addr_
	The address we tried to connect to. More...
folly::SocketAddress	localAddr_
	The address we are connecting from. More...
uint32_t	sendTimeout_
	The send timeout, in milliseconds. More...
uint16_t	maxReadsPerEvent_
	Max reads per event loop iteration. More...
bool	isBufferMovable_ {false}
int8_t	readErr_ {READ_NO_ERROR}
	The read error encountered, if any. More...
EventBase *	eventBase_
	The EventBase. More...
WriteTimeout	writeTimeout_
	A timeout for connect and write. More...
IoHandler	ioHandler_
	A EventHandler to monitor the fd. More...
ImmediateReadCB	immediateReadHandler_
	LoopCallback for checking read. More...
ConnectCallback *	connectCallback_
	ConnectCallback. More...
ErrMessageCallback *	errMessageCallback_
	TimestampCallback. More...
SendMsgParamsCallback *	sendMsgParamCallback_
	< Callback for retrieving More...
ReadCallback *	readCallback_
	ReadCallback. More...
WriteRequest *	writeReqHead_
	Chain of WriteRequests. More...
WriteRequest *	writeReqTail_
	End of WriteRequest chain. More...
std::weak_ptr< ShutdownSocketSet >	wShutdownSocketSet_
size_t	appBytesReceived_
	Num of bytes received from socket. More...
size_t	appBytesWritten_
	Num of bytes written to socket. More...
std::unique_ptr< IOBuf >	preReceivedData_
std::chrono::steady_clock::time_point	connectStartTime_
std::chrono::steady_clock::time_point	connectEndTime_
std::chrono::milliseconds	connectTimeout_ {0}
std::unique_ptr< EvbChangeCallback >	evbChangeCb_ {nullptr}
BufferCallback *	bufferCallback_ {nullptr}
bool	tfoEnabled_ {false}
bool	tfoAttempted_ {false}
bool	tfoFinished_ {false}
bool	noTransparentTls_ {false}
bool	noTSocks_ {false}
bool	trackEor_ {false}
bool	zeroCopyEnabled_ {false}
bool	zeroCopyVal_ {false}
size_t	zeroCopyReenableThreshold_ {0}
size_t	zeroCopyReenableCounter_ {0}
std::unique_ptr< const AsyncTransportCertificate >	peerCertData_
std::unique_ptr< const AsyncTransportCertificate >	selfCertData_

Friends
std::ostream &	operator<< (std::ostream &os, const StateEnum &state)

Detailed Description

A class for performing asynchronous I/O on a socket.

AsyncSocket allows users to asynchronously wait for data on a socket, and to asynchronously send data.

The APIs for reading and writing are intentionally asymmetric. Waiting for data to read is a persistent API: a callback is installed, and is notified whenever new data is available. It continues to be notified of new events until it is uninstalled.

AsyncSocket does not provide read timeout functionality, because it typically cannot determine when the timeout should be active. Generally, a timeout should only be enabled when processing is blocked waiting on data from the remote endpoint. For server sockets, the timeout should not be active if the server is currently processing one or more outstanding requests for this socket. For client sockets, the timeout should not be active if there are no requests pending on the socket. Additionally, if a client has multiple pending requests, it will ususally want a separate timeout for each request, rather than a single read timeout.

The write API is fairly intuitive: a user can request to send a block of data, and a callback will be informed once the entire block has been transferred to the kernel, or on error. AsyncSocket does provide a send timeout, since most callers want to give up if the remote end stops responding and no further progress can be made sending the data.

Definition at line 81 of file AsyncSocket.h.

Member Typedef Documentation

typedef std::map<OptionKey, int> folly::AsyncSocket::OptionMap

Definition at line 376 of file AsyncSocket.h.

typedef std::unique_ptr<AsyncSocket, Destructor> folly::AsyncSocket::UniquePtr

Definition at line 83 of file AsyncSocket.h.

Member Enumeration Documentation

enum folly::AsyncSocket::ReadResultEnum

protected

Enumerator
READ_EOF
READ_ERROR
READ_BLOCKING
READ_NO_ERROR

Definition at line 940 of file AsyncSocket.h.

                      {
    READ_EOF = 0,
    READ_ERROR = -1,
    READ_BLOCKING = -2,
    READ_NO_ERROR = -3,
  };

enum folly::AsyncSocket::ShutdownFlags

protected

Enumerator
SHUT_WRITE_PENDING	shutdownWrite() called, but we are still waiting on writes to drain
SHUT_WRITE	writes have been completely shut down
SHUT_READ	Reads have been shutdown. At the moment we don't distinguish between remote read shutdown (received EOF from the remote end) and local read shutdown. We can only receive EOF when a read callback is set, and we immediately inform it of the EOF. Therefore there doesn't seem to be any reason to have a separate state of "received EOF but the local side may still want to read". We also don't currently provide any API for only shutting down the read side of a socket. (This is a no-op as far as TCP is concerned, anyway.)

Definition at line 962 of file AsyncSocket.h.

                     {
    SHUT_WRITE_PENDING = 0x01,
    SHUT_WRITE = 0x02,
    SHUT_READ = 0x04,
  };

enum folly::AsyncSocket::StateEnum : uint8_t

strong

Enumerator
UNINIT
CONNECTING
ESTABLISHED
CLOSED
ERROR
FAST_OPEN

Definition at line 797 of file AsyncSocket.h.

                       : uint8_t {
    UNINIT,
    CONNECTING,
    ESTABLISHED,
    CLOSED,
    ERROR,
    FAST_OPEN,
  };

enum folly::AsyncSocket::WriteResultEnum

protected

Enumerator
WRITE_ERROR

Definition at line 947 of file AsyncSocket.h.

                       {
    WRITE_ERROR = -1,
  };

Constructor & Destructor Documentation

folly::AsyncSocket::AsyncSocket ( )

explicit

Definition at line 277 of file AsyncSocket.cpp.

References init().

Referenced by folly::AsyncSocket::SendMsgParamsCallback::getFlagsImpl(), and newSocket().

    : eventBase_(nullptr),
      writeTimeout_(this, nullptr),
      ioHandler_(this, nullptr),
      immediateReadHandler_(this) {
  VLOG(5) << "new AsyncSocket()";
  init();
}

folly::AsyncSocket::AsyncSocket ( EventBase *  evb )

explicit

Create a new unconnected AsyncSocket.

connect() must later be called on this socket to establish a connection.

Definition at line 286 of file AsyncSocket.cpp.

References init().

    : eventBase_(evb),
      writeTimeout_(this, evb),
      ioHandler_(this, evb),
      immediateReadHandler_(this) {
  VLOG(5) << "new AsyncSocket(" << this << ", evb=" << evb << ")";
  init();
}

folly::AsyncSocket::AsyncSocket	(	EventBase *	evb,
		const folly::SocketAddress &	address,
		uint32_t	connectTimeout = 0
	)

Create a new AsyncSocket and begin the connection process.

Parameters

evb	EventBase that will manage this socket.
address	The address to connect to.
connectTimeout	Optional timeout in milliseconds for the connection attempt.

Definition at line 295 of file AsyncSocket.cpp.

References connect().

    : AsyncSocket(evb) {
  connect(nullptr, address, connectTimeout);
}

folly::AsyncSocket::AsyncSocket	(	EventBase *	evb,
		const std::string &	ip,
		uint16_t	port,
		uint32_t	connectTimeout = 0
	)

Create a new AsyncSocket and begin the connection process.

Parameters

evb	EventBase that will manage this socket.
ip	IP address to connect to (dotted-quad).
port	Destination port in host byte order.
connectTimeout	Optional timeout in milliseconds for the connection attempt.

Definition at line 303 of file AsyncSocket.cpp.

References connect().

    : AsyncSocket(evb) {
  connect(nullptr, ip, port, connectTimeout);
}

folly::AsyncSocket::AsyncSocket	(	EventBase *	evb,
		int	fd,
		uint32_t	zeroCopyBufId = 0
	)

Create a AsyncSocket from an already connected socket file descriptor.

Note that while AsyncSocket enables TCP_NODELAY for sockets it creates when connecting, it does not change the socket options when given an existing file descriptor. If callers want TCP_NODELAY enabled when using this version of the constructor, they need to explicitly call setNoDelay(true) after the constructor returns.

Parameters

evb	EventBase that will manage this socket.
fd	File descriptor to take over (should be a connected socket).
zeroCopyBufId	Zerocopy buf id to start with.

Definition at line 312 of file AsyncSocket.cpp.

References ESTABLISHED, fd_, init(), noTransparentTls_, noTSocks_, setCloseOnExec(), and state_.

    : zeroCopyBufId_(zeroCopyBufId),
      eventBase_(evb),
      writeTimeout_(this, evb),
      ioHandler_(this, evb, fd),
      immediateReadHandler_(this) {
  VLOG(5) << "new AsyncSocket(" << this << ", evb=" << evb << ", fd=" << fd
          << ", zeroCopyBufId=" << zeroCopyBufId << ")";
  init();
  fd_ = fd;
  disableTransparentFunctions(fd_, noTransparentTls_, noTSocks_);
  setCloseOnExec();
  state_ = StateEnum::ESTABLISHED;
}

folly::AsyncSocket::AsyncSocket ( AsyncSocket::UniquePtr  oldAsyncSocket )

explicit

Create an AsyncSocket from a different, already connected AsyncSocket.

Similar to AsyncSocket(evb, fd) when fd was previously owned by an AsyncSocket.

Definition at line 327 of file AsyncSocket.cpp.

References folly::gen::move, and preReceivedData_.

    : AsyncSocket(
          oldAsyncSocket->getEventBase(),
          oldAsyncSocket->detachFd(),
          oldAsyncSocket->getZeroCopyBufId()) {
  preReceivedData_ = std::move(oldAsyncSocket->preReceivedData_);
}

folly::AsyncSocket::~AsyncSocket ( )

overrideprotected

Protected destructor.

Users of AsyncSocket must never delete it directly. Instead, invoke destroy() instead. (See the documentation in DelayedDestruction.h for more details.)

Definition at line 358 of file AsyncSocket.cpp.

References eventBase_, fd_, and state_.

                          {
  VLOG(7) << "actual destruction of AsyncSocket(this=" << this
          << ", evb=" << eventBase_ << ", fd=" << fd_ << ", state=" << state_
          << ")";
}

Member Function Documentation

void folly::AsyncSocket::addZeroCopyBuf ( std::unique_ptr< folly::IOBuf > &&  buf )

protected

Definition at line 924 of file AsyncSocket.cpp.

References getNextZeroCopyBufId(), idZeroCopyBufInfoMap_, idZeroCopyBufPtrMap_, folly::gen::move, ptr, and uint32_t.

Referenced by getNextZeroCopyBufId(), folly::AsyncSocket::BytesWriteRequest::performWrite(), and writeImpl().

                                                                {
  uint32_t id = getNextZeroCopyBufId();
  folly::IOBuf* ptr = buf.get();

  idZeroCopyBufPtrMap_[id] = ptr;
  auto& p = idZeroCopyBufInfoMap_[ptr];
  p.count_++;
  CHECK(p.buf_.get() == nullptr);
  p.buf_ = std::move(buf);
}

void folly::AsyncSocket::addZeroCopyBuf ( folly::IOBuf *  ptr )

protected

Definition at line 935 of file AsyncSocket.cpp.

References getNextZeroCopyBufId(), idZeroCopyBufInfoMap_, idZeroCopyBufPtrMap_, ptr, and uint32_t.

                                                {
  uint32_t id = getNextZeroCopyBufId();
  idZeroCopyBufPtrMap_[id] = ptr;

  idZeroCopyBufInfoMap_[ptr].count_++;
}

void folly::AsyncSocket::adjustZeroCopyFlags ( folly::WriteFlags &  flags )

protected

Definition at line 909 of file AsyncSocket.cpp.

References folly::unSet(), folly::WRITE_MSG_ZEROCOPY, zeroCopyEnabled_, and zeroCopyReenableCounter_.

Referenced by getNextZeroCopyBufId(), folly::AsyncSocket::BytesWriteRequest::performWrite(), and writeChain().

                                                            {
  if (!zeroCopyEnabled_) {
    // if the zeroCopyReenableCounter_ is > 0
    // we try to dec and if we reach 0
    // we set zeroCopyEnabled_ to true
    if (zeroCopyReenableCounter_) {
      if (0 == --zeroCopyReenableCounter_) {
        zeroCopyEnabled_ = true;
        return;
      }
    }
    flags = unSet(flags, folly::WriteFlags::WRITE_MSG_ZEROCOPY);
  }
}

const folly::SocketAddress & folly::AsyncSocket::anyAddress ( )

static

Definition at line 394 of file AsyncSocket.cpp.

Referenced by connect(), folly::AsyncSSLSocket::getSecurityProtocol(), main(), and proxygen::HTTPConnector::Callback::~Callback().

                                                  {
  static const folly::SocketAddress anyAddress =
      folly::SocketAddress("0.0.0.0", 0);
  return anyAddress;
}

void folly::AsyncSocket::attachEventBase ( EventBase *  eventBase )

overridevirtual

Attach the transport to a EventBase.

This may only be called if the transport is not currently attached to a EventBase (by an earlier call to detachEventBase()).

This method must be invoked in the EventBase's thread.

Implements folly::AsyncTransport.

Reimplemented in folly::AsyncSSLSocket.

Definition at line 1500 of file AsyncSocket.cpp.

References folly::EventHandler::attachEventBase(), folly::AsyncTimeout::attachEventBase(), folly::EventBase::dcheckIsInEventBaseThread(), evbChangeCb_, eventBase_, eventFlags_, fd_, ioHandler_, state_, updateEventRegistration(), and writeTimeout_.

Referenced by folly::AsyncSSLSocket::attachEventBase(), and writeRequestReady().

                                                      {
  VLOG(5) << "AsyncSocket::attachEventBase(this=" << this << ", fd=" << fd_
          << ", old evb=" << eventBase_ << ", new evb=" << eventBase
          << ", state=" << state_ << ", events=" << std::hex << eventFlags_
          << ")";
  assert(eventBase_ == nullptr);
  eventBase->dcheckIsInEventBaseThread();

  eventBase_ = eventBase;
  ioHandler_.attachEventBase(eventBase);

  updateEventRegistration();

  writeTimeout_.attachEventBase(eventBase);
  if (evbChangeCb_) {
    evbChangeCb_->evbAttached(this);
  }
}

void folly::AsyncSocket::cacheAddresses

(

)

Attempt to cache the current local and peer addresses (if not already cached) so that they are available from getPeerAddress() and getLocalAddress() even after the socket is closed.

Definition at line 1544 of file AsyncSocket.cpp.

References cacheLocalAddress(), cachePeerAddress(), and fd_.

Referenced by setEvbChangedCallback(), folly::AsyncSSLSocket::sslAccept(), and folly::AsyncSSLSocket::sslConn().

                                 {
  if (fd_ >= 0) {
    try {
      cacheLocalAddress();
      cachePeerAddress();
    } catch (const std::system_error& e) {
      if (e.code() != std::error_code(ENOTCONN, std::system_category())) {
        VLOG(2) << "Error caching addresses: " << e.code().value() << ", "
                << e.code().message();
      }
    }
  }
}

void folly::AsyncSocket::cacheLocalAddress ( ) const

protected

Definition at line 1558 of file AsyncSocket.cpp.

References fd_, folly::SocketAddress::isInitialized(), localAddr_, and folly::SocketAddress::setFromLocalAddress().

Referenced by cacheAddresses(), getLocalAddress(), scheduleInitialReadWrite(), and setErrMessageCB().

                                          {
  if (!localAddr_.isInitialized()) {
    localAddr_.setFromLocalAddress(fd_);
  }
}

void folly::AsyncSocket::cachePeerAddress ( ) const

protected

Definition at line 1564 of file AsyncSocket.cpp.

References addr_, fd_, folly::SocketAddress::isInitialized(), and folly::SocketAddress::setFromPeerAddress().

Referenced by cacheAddresses(), getPeerAddress(), and scheduleInitialReadWrite().

                                         {
  if (!addr_.isInitialized()) {
    addr_.setFromPeerAddress(fd_);
  }
}

void folly::AsyncSocket::cancelConnect

(

)

If a connect request is in-flight, cancels it and closes the socket immediately. Otherwise, this is a no-op.

This does not invoke any connection related callbacks. Call this to prevent any connect callback while cleaning up, etc.

Definition at line 659 of file AsyncSocket.cpp.

References closeNow(), connectCallback_, CONNECTING, FAST_OPEN, and state_.

                                {
  connectCallback_ = nullptr;
  if (state_ == StateEnum::CONNECTING || state_ == StateEnum::FAST_OPEN) {
    closeNow();
  }
}

void folly::AsyncSocket::checkForImmediateRead ( )

protectedvirtualnoexcept

Reimplemented in AsyncSocketImmediateRead, and folly::AsyncSSLSocket.

Definition at line 2147 of file AsyncSocket.cpp.

References handleRead(), and preReceivedData_.

Referenced by folly::AsyncSSLSocket::checkForImmediateRead(), handleInitialReadWrite(), scheduleInitialReadWrite(), and setReadCB().

                                                 {
  // We currently don't attempt to perform optimistic reads in AsyncSocket.
  // (However, note that some subclasses do override this method.)
  //
  // Simply calling handleRead() here would be bad, as this would call
  // readCallback_->getReadBuffer(), forcing the callback to allocate a read
  // buffer even though no data may be available.  This would waste lots of
  // memory, since the buffer will sit around unused until the socket actually
  // becomes readable.
  //
  // Checking if the socket is readable now also seems like it would probably
  // be a pessimism.  In most cases it probably wouldn't be readable, and we
  // would just waste an extra system call.  Even if it is readable, waiting to
  // find out from libevent on the next event loop doesn't seem that bad.
  //
  // The exception to this is if we have pre-received data. In that case there
  // is definitely data available immediately.
  if (preReceivedData_ && !preReceivedData_->empty()) {
    handleRead();
  }
}

void folly::AsyncSocket::close ( )

overridevirtual

Close the transport.

This gracefully closes the transport, waiting for all pending write requests to complete before actually closing the underlying transport.

If a read callback is set, readEOF() will be called immediately. If there are outstanding write requests, the close will be delayed until all remaining writes have completed. No new writes may be started after close() has been called.

Implements folly::AsyncTransport.

Definition at line 1198 of file AsyncSocket.cpp.

References closeNow(), CONNECTING, folly::EventBase::dcheckIsInEventBaseThread(), ERROR, ESTABLISHED, eventBase_, fd_, folly::EventHandler::READ, readCallback_, folly::AsyncReader::ReadCallback::readEOF(), SHUT_READ, SHUT_WRITE_PENDING, shutdownFlags_, state_, updateEventRegistration(), and writeReqHead_.

Referenced by doClose(), folly::AsyncSSLSocket::shutdownWrite(), TEST(), and writeRequestReady().

                        {
  VLOG(5) << "AsyncSocket::close(): this=" << this << ", fd_=" << fd_
          << ", state=" << state_ << ", shutdownFlags=" << std::hex
          << (int)shutdownFlags_;

  // close() is only different from closeNow() when there are pending writes
  // that need to drain before we can close.  In all other cases, just call
  // closeNow().
  //
  // Note that writeReqHead_ can be non-nullptr even in STATE_CLOSED or
  // STATE_ERROR if close() is invoked while a previous closeNow() or failure
  // is still running.  (e.g., If there are multiple pending writes, and we
  // call writeError() on the first one, it may call close().  In this case we
  // will already be in STATE_CLOSED or STATE_ERROR, but the remaining pending
  // writes will still be in the queue.)
  //
  // We only need to drain pending writes if we are still in STATE_CONNECTING
  // or STATE_ESTABLISHED
  if ((writeReqHead_ == nullptr) ||
      !(state_ == StateEnum::CONNECTING || state_ == StateEnum::ESTABLISHED)) {
    closeNow();
    return;
  }

  // Declare a DestructorGuard to ensure that the AsyncSocket cannot be
  // destroyed until close() returns.
  DestructorGuard dg(this);
  eventBase_->dcheckIsInEventBaseThread();

  // Since there are write requests pending, we have to set the
  // SHUT_WRITE_PENDING flag, and wait to perform the real close until the
  // connect finishes and we finish writing these requests.
  //
  // Set SHUT_READ to indicate that reads are shut down, and set the
  // SHUT_WRITE_PENDING flag to mark that we want to shutdown once the
  // pending writes complete.
  shutdownFlags_ |= (SHUT_READ | SHUT_WRITE_PENDING);

  // If a read callback is set, invoke readEOF() immediately to inform it that
  // the socket has been closed and no more data can be read.
  if (readCallback_) {
    // Disable reads if they are enabled
    if (!updateEventRegistration(0, EventHandler::READ)) {
      // We're now in the error state; callbacks have been cleaned up
      assert(state_ == StateEnum::ERROR);
      assert(readCallback_ == nullptr);
    } else {
      ReadCallback* callback = readCallback_;
      readCallback_ = nullptr;
      callback->readEOF();
    }
  }
}

void folly::AsyncSocket::closeNow ( )

overridevirtual

Close the transport immediately.

This closes the transport immediately, dropping any outstanding data waiting to be written.

If a read callback is set, readEOF() will be called immediately. If there are outstanding write requests, these requests will be aborted and writeError() will be invoked immediately on all outstanding write callbacks.

Implements folly::AsyncTransport.

Reimplemented in folly::AsyncSSLSocket.

Definition at line 1252 of file AsyncSocket.cpp.

References folly::EventBase::LoopCallback::cancelLoopCallback(), folly::AsyncTimeout::cancelTimeout(), folly::EventHandler::changeHandlerFD(), CLOSED, connectCallback_, CONNECTING, folly::EventBase::dcheckIsInEventBaseThread(), folly::DFATAL, doClose(), ERROR, ESTABLISHED, eventBase_, eventFlags_, failAllWrites(), FAST_OPEN, fd_, immediateReadHandler_, invokeConnectErr(), ioHandler_, folly::EventBase::LoopCallback::isLoopCallbackScheduled(), folly::EventHandler::NONE, readCallback_, folly::AsyncReader::ReadCallback::readEOF(), SHUT_READ, SHUT_WRITE, shutdownFlags_, folly::socketClosedLocallyEx, state_, UNINIT, updateEventRegistration(), writeReqHead_, and writeTimeout_.

Referenced by cancelConnect(), close(), folly::AsyncSSLSocket::closeNow(), closeWithReset(), folly::test::MockAsyncSocket::connect(), destroy(), detachFd(), shutdownWriteNow(), and writeRequestReady().

                           {
  VLOG(5) << "AsyncSocket::closeNow(): this=" << this << ", fd_=" << fd_
          << ", state=" << state_ << ", shutdownFlags=" << std::hex
          << (int)shutdownFlags_;
  DestructorGuard dg(this);
  if (eventBase_) {
    eventBase_->dcheckIsInEventBaseThread();
  }

  switch (state_) {
    case StateEnum::ESTABLISHED:
    case StateEnum::CONNECTING:
    case StateEnum::FAST_OPEN: {
      shutdownFlags_ |= (SHUT_READ | SHUT_WRITE);
      state_ = StateEnum::CLOSED;

      // If the write timeout was set, cancel it.
      writeTimeout_.cancelTimeout();

      // If we are registered for I/O events, unregister.
      if (eventFlags_ != EventHandler::NONE) {
        eventFlags_ = EventHandler::NONE;
        if (!updateEventRegistration()) {
          // We will have been moved into the error state.
          assert(state_ == StateEnum::ERROR);
          return;
        }
      }

      if (immediateReadHandler_.isLoopCallbackScheduled()) {
        immediateReadHandler_.cancelLoopCallback();
      }

      if (fd_ >= 0) {
        ioHandler_.changeHandlerFD(-1);
        doClose();
      }

      invokeConnectErr(socketClosedLocallyEx);

      failAllWrites(socketClosedLocallyEx);

      if (readCallback_) {
        ReadCallback* callback = readCallback_;
        readCallback_ = nullptr;
        callback->readEOF();
      }
      return;
    }
    case StateEnum::CLOSED:
      // Do nothing.  It's possible that we are being called recursively
      // from inside a callback that we invoked inside another call to close()
      // that is still running.
      return;
    case StateEnum::ERROR:
      // Do nothing.  The error handling code has performed (or is performing)
      // cleanup.
      return;
    case StateEnum::UNINIT:
      assert(eventFlags_ == EventHandler::NONE);
      assert(connectCallback_ == nullptr);
      assert(readCallback_ == nullptr);
      assert(writeReqHead_ == nullptr);
      shutdownFlags_ |= (SHUT_READ | SHUT_WRITE);
      state_ = StateEnum::CLOSED;
      return;
  }

  LOG(DFATAL) << "AsyncSocket::closeNow() (this=" << this << ", fd=" << fd_
              << ") called in unknown state " << state_;
}

void folly::AsyncSocket::closeWithReset ( )

overridevirtual

Reset the transport immediately.

This closes the transport immediately, sending a reset to the remote peer if possible to indicate abnormal shutdown.

Note that not all subclasses implement this reset functionality: some subclasses may treat reset() the same as closeNow(). Subclasses that use TCP transports should terminate the connection with a TCP reset.

Reimplemented from folly::AsyncTransport.

Definition at line 1324 of file AsyncSocket.cpp.

References closeNow(), fd_, and setSockOpt().

Referenced by writeRequestReady().

                                 {
  // Enable SO_LINGER, with the linger timeout set to 0.
  // This will trigger a TCP reset when we close the socket.
  if (fd_ >= 0) {
    struct linger optLinger = {1, 0};
    if (setSockOpt(SOL_SOCKET, SO_LINGER, &optLinger) != 0) {
      VLOG(2) << "AsyncSocket::closeWithReset(): error setting SO_LINGER "
              << "on " << fd_ << ": errno=" << errno;
    }
  }

  // Then let closeNow() take care of the rest
  closeNow();
}

void folly::AsyncSocket::connect ( ConnectCallback *  callback, const folly::SocketAddress &  address, int  timeout = 0, const OptionMap &  options = emptyOptionMap, const folly::SocketAddress &  bindAddr = anyAddress()  )

virtualnoexcept

Initiate a connection.

Parameters

callback	The callback to inform when the connection attempt completes.
address	The address to connect to.
timeout	A timeout value, in milliseconds. If the connection does not succeed within this period, callback->connectError() will be invoked.

Reimplemented in folly::AsyncSSLSocket, folly::test::MockAsyncSSLSocket, and folly::test::MockAsyncSocket.

Definition at line 431 of file AsyncSocket.cpp.

References folly::ShutdownSocketSet::add(), addr_, anyAddress(), folly::netops::bind(), folly::EventHandler::changeHandlerFD(), connectCallback_, connectEndTime_, CONNECTING, connectStartTime_, connectTimeout_, folly::EventBase::dcheckIsInEventBaseThread(), doClose(), errMessageCallback_, ESTABLISHED, eventBase_, failConnect(), FAST_OPEN, fd_, folly::SocketAddress::getActualSize(), folly::AsyncSocketException::INTERNAL_ERROR, invalidState(), invokeConnectSuccess(), ioHandler_, name, folly::AsyncSocketException::NOT_OPEN, noTransparentTls_, noTSocks_, now(), readCallback_, setCloseOnExec(), setNoDelay(), folly::netops::setsockopt(), setZeroCopy(), folly::test::shutdownSocketSet, folly::netops::socket(), socketConnect(), state_, tfoAttempted_, tfoEnabled_, folly::detail::timeout, UNINIT, withAddr(), writeReqHead_, wShutdownSocketSet_, and zeroCopyVal_.

Referenced by AsyncSocket(), folly::AsyncSSLSocket::connect(), connect(), folly::AsyncSSLSocket::getSecurityProtocol(), SSLCacheClient::start(), and TEST().

                                                 {
  DestructorGuard dg(this);
  eventBase_->dcheckIsInEventBaseThread();

  addr_ = address;

  // Make sure we're in the uninitialized state
  if (state_ != StateEnum::UNINIT) {
    return invalidState(callback);
  }

  connectTimeout_ = std::chrono::milliseconds(timeout);
  connectStartTime_ = std::chrono::steady_clock::now();
  // Make connect end time at least >= connectStartTime.
  connectEndTime_ = connectStartTime_;

  assert(fd_ == -1);
  state_ = StateEnum::CONNECTING;
  connectCallback_ = callback;

  sockaddr_storage addrStorage;
  sockaddr* saddr = reinterpret_cast<sockaddr*>(&addrStorage);

  try {
    // Create the socket
    // Technically the first parameter should actually be a protocol family
    // constant (PF_xxx) rather than an address family (AF_xxx), but the
    // distinction is mainly just historical.  In pretty much all
    // implementations the PF_foo and AF_foo constants are identical.
    fd_ = fsp::socket(address.getFamily(), SOCK_STREAM, 0);
    if (fd_ < 0) {
      auto errnoCopy = errno;
      throw AsyncSocketException(
          AsyncSocketException::INTERNAL_ERROR,
          withAddr("failed to create socket"),
          errnoCopy);
    }
    disableTransparentFunctions(fd_, noTransparentTls_, noTSocks_);
    if (const auto shutdownSocketSet = wShutdownSocketSet_.lock()) {
      shutdownSocketSet->add(fd_);
    }
    ioHandler_.changeHandlerFD(fd_);

    setCloseOnExec();

    // Put the socket in non-blocking mode
    int flags = fcntl(fd_, F_GETFL, 0);
    if (flags == -1) {
      auto errnoCopy = errno;
      throw AsyncSocketException(
          AsyncSocketException::INTERNAL_ERROR,
          withAddr("failed to get socket flags"),
          errnoCopy);
    }
    int rv = fcntl(fd_, F_SETFL, flags | O_NONBLOCK);
    if (rv == -1) {
      auto errnoCopy = errno;
      throw AsyncSocketException(
          AsyncSocketException::INTERNAL_ERROR,
          withAddr("failed to put socket in non-blocking mode"),
          errnoCopy);
    }

#if !defined(MSG_NOSIGNAL) && defined(F_SETNOSIGPIPE)
    // iOS and OS X don't support MSG_NOSIGNAL; set F_SETNOSIGPIPE instead
    rv = fcntl(fd_, F_SETNOSIGPIPE, 1);
    if (rv == -1) {
      auto errnoCopy = errno;
      throw AsyncSocketException(
          AsyncSocketException::INTERNAL_ERROR,
          "failed to enable F_SETNOSIGPIPE on socket",
          errnoCopy);
    }
#endif

    // By default, turn on TCP_NODELAY
    // If setNoDelay() fails, we continue anyway; this isn't a fatal error.
    // setNoDelay() will log an error message if it fails.
    // Also set the cached zeroCopyVal_ since it cannot be set earlier if the fd
    // is not created
    if (address.getFamily() != AF_UNIX) {
      (void)setNoDelay(true);
      setZeroCopy(zeroCopyVal_);
    }

    VLOG(5) << "AsyncSocket::connect(this=" << this << ", evb=" << eventBase_
            << ", fd=" << fd_ << ", host=" << address.describe().c_str();

    // bind the socket
    if (bindAddr != anyAddress()) {
      int one = 1;
      if (setsockopt(fd_, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one))) {
        auto errnoCopy = errno;
        doClose();
        throw AsyncSocketException(
            AsyncSocketException::NOT_OPEN,
            "failed to setsockopt prior to bind on " + bindAddr.describe(),
            errnoCopy);
      }

      bindAddr.getAddress(&addrStorage);

      if (bind(fd_, saddr, bindAddr.getActualSize()) != 0) {
        auto errnoCopy = errno;
        doClose();
        throw AsyncSocketException(
            AsyncSocketException::NOT_OPEN,
            "failed to bind to async socket: " + bindAddr.describe(),
            errnoCopy);
      }
    }

    // Apply the additional options if any.
    for (const auto& opt : options) {
      rv = opt.first.apply(fd_, opt.second);
      if (rv != 0) {
        auto errnoCopy = errno;
        throw AsyncSocketException(
            AsyncSocketException::INTERNAL_ERROR,
            withAddr("failed to set socket option"),
            errnoCopy);
      }
    }

    // Perform the connect()
    address.getAddress(&addrStorage);

    if (tfoEnabled_) {
      state_ = StateEnum::FAST_OPEN;
      tfoAttempted_ = true;
    } else {
      if (socketConnect(saddr, addr_.getActualSize()) < 0) {
        return;
      }
    }

    // If we're still here the connect() succeeded immediately.
    // Fall through to call the callback outside of this try...catch block
  } catch (const AsyncSocketException& ex) {
    return failConnect(__func__, ex);
  } catch (const std::exception& ex) {
    // shouldn't happen, but handle it just in case
    VLOG(4) << "AsyncSocket::connect(this=" << this << ", fd=" << fd_
            << "): unexpected " << typeid(ex).name()
            << " exception: " << ex.what();
    AsyncSocketException tex(
        AsyncSocketException::INTERNAL_ERROR,
        withAddr(string("unexpected exception: ") + ex.what()));
    return failConnect(__func__, tex);
  }

  // The connection succeeded immediately
  // The read callback may not have been set yet, and no writes may be pending
  // yet, so we don't have to register for any events at the moment.
  VLOG(8) << "AsyncSocket::connect succeeded immediately; this=" << this;
  assert(errMessageCallback_ == nullptr);
  assert(readCallback_ == nullptr);
  assert(writeReqHead_ == nullptr);
  if (state_ != StateEnum::FAST_OPEN) {
    state_ = StateEnum::ESTABLISHED;
  }
  invokeConnectSuccess();
}

void folly::AsyncSocket::connect ( ConnectCallback *  callback, const std::string &  ip, uint16_t  port, int  timeout = 0, const OptionMap &  options = emptyOptionMap  )

noexcept

Definition at line 643 of file AsyncSocket.cpp.

References connect(), connectCallback_, failConnect(), folly::AsyncSocketException::INTERNAL_ERROR, and folly::detail::timeout.

                                       {
  DestructorGuard dg(this);
  try {
    connectCallback_ = callback;
    connect(callback, folly::SocketAddress(ip, port), timeout, options);
  } catch (const std::exception& ex) {
    AsyncSocketException tex(AsyncSocketException::INTERNAL_ERROR, ex.what());
    return failConnect(__func__, tex);
  }
}

bool folly::AsyncSocket::connecting ( ) const

inlineoverridevirtual

Determine if transport is connected to the endpoint

Returns

false iff the transport is connected, otherwise true

Implements folly::AsyncTransport.

Reimplemented in folly::AsyncSSLSocket.

Definition at line 567 of file AsyncSocket.h.

References CONNECTING, and state_.

Referenced by folly::AsyncSSLSocket::connecting(), and writeImpl().

                                   {
    return (state_ == StateEnum::CONNECTING);
  }

bool folly::AsyncSocket::containsZeroCopyBuf ( folly::IOBuf *  ptr )

protected

Definition at line 963 of file AsyncSocket.cpp.

References idZeroCopyBufInfoMap_.

Referenced by getNextZeroCopyBufId(), and folly::AsyncSocket::BytesWriteRequest::performWrite().

                                                     {
  return (idZeroCopyBufInfoMap_.find(ptr) != idZeroCopyBufInfoMap_.end());
}

void folly::AsyncSocket::destroy ( )

overridevirtual

Destroy the socket.

AsyncSocket::destroy() must be called to destroy the socket. The normal destructor is private, and should not be invoked directly. This prevents callers from deleting a AsyncSocket while it is invoking a callback.

Reimplemented from folly::DelayedDestruction.

Definition at line 364 of file AsyncSocket.cpp.

References closeNow(), folly::DelayedDestruction::destroy(), eventBase_, fd_, and state_.

Referenced by newSocket(), SSLCacheClient::start(), folly::AsyncSocket::WriteRequest::start(), and SSLCacheClient::~SSLCacheClient().

                          {
  VLOG(5) << "AsyncSocket::destroy(this=" << this << ", evb=" << eventBase_
          << ", fd=" << fd_ << ", state=" << state_;
  // When destroy is called, close the socket immediately
  closeNow();

  // Then call DelayedDestruction::destroy() to take care of
  // whether or not we need immediate or delayed destruction
  DelayedDestruction::destroy();
}

void folly::AsyncSocket::detachEventBase ( )

overridevirtual

Detach the transport from its EventBase.

This may only be called when the transport is idle and has no reads or writes pending. Once detached, the transport may not be used again until it is re-attached to a EventBase by calling attachEventBase().

This method must be called from the current EventBase's thread.

Implements folly::AsyncTransport.

Reimplemented in folly::AsyncSSLSocket.

Definition at line 1519 of file AsyncSocket.cpp.

References folly::EventBase::dcheckIsInEventBaseThread(), folly::EventHandler::detachEventBase(), folly::AsyncTimeout::detachEventBase(), evbChangeCb_, eventBase_, eventFlags_, fd_, ioHandler_, state_, folly::EventHandler::unregisterHandler(), and writeTimeout_.

Referenced by folly::AsyncSSLSocket::detachEventBase(), and writeRequestReady().

                                  {
  VLOG(5) << "AsyncSocket::detachEventBase(this=" << this << ", fd=" << fd_
          << ", old evb=" << eventBase_ << ", state=" << state_
          << ", events=" << std::hex << eventFlags_ << ")";
  assert(eventBase_ != nullptr);
  eventBase_->dcheckIsInEventBaseThread();

  eventBase_ = nullptr;

  ioHandler_.unregisterHandler();

  ioHandler_.detachEventBase();
  writeTimeout_.detachEventBase();
  if (evbChangeCb_) {
    evbChangeCb_->evbDetached(this);
  }
}

int folly::AsyncSocket::detachFd ( )

virtual

Extract the file descriptor from the AsyncSocket.

This will immediately cause any installed callbacks to be invoked with an error. The AsyncSocket may no longer be used after the file descriptor has been extracted.

This method should be used with care as the resulting fd is not guaranteed to perfectly reflect the state of the AsyncSocket (security state, pre-received data, etc.).

Returns the file descriptor. The caller assumes ownership of the descriptor, and it will not be closed when the AsyncSocket is destroyed.

Definition at line 375 of file AsyncSocket.cpp.

References folly::EventHandler::changeHandlerFD(), closeNow(), eventBase_, eventFlags_, fd_, ioHandler_, state_, and wShutdownSocketSet_.

Referenced by folly::test::MockAsyncSocket::connect(), SSLCacheClient::connectSuccess(), and getFd().

                          {
  VLOG(6) << "AsyncSocket::detachFd(this=" << this << ", fd=" << fd_
          << ", evb=" << eventBase_ << ", state=" << state_
          << ", events=" << std::hex << eventFlags_ << ")";
  // Extract the fd, and set fd_ to -1 first, so closeNow() won't
  // actually close the descriptor.
  if (const auto socketSet = wShutdownSocketSet_.lock()) {
    socketSet->remove(fd_);
  }
  int fd = fd_;
  fd_ = -1;
  // Call closeNow() to invoke all pending callbacks with an error.
  closeNow();
  // Update the EventHandler to stop using this fd.
  // This can only be done after closeNow() unregisters the handler.
  ioHandler_.changeHandlerFD(-1);
  return fd;
}

void folly::AsyncSocket::disableTransparentTls ( )

inline

Definition at line 789 of file AsyncSocket.h.

References noTransparentTls_.

Referenced by fizz::client::AsyncFizzClientT< SM >::connect().

                               {
    noTransparentTls_ = true;
  }

void folly::AsyncSocket::disableTSocks ( )

inline

Definition at line 793 of file AsyncSocket.h.

References noTSocks_.

                       {
    noTSocks_ = true;
  }

void folly::AsyncSocket::doClose ( )

protected

Definition at line 2790 of file AsyncSocket.cpp.

References folly::ShutdownSocketSet::close(), close(), fd_, idZeroCopyBufInfoMap_, idZeroCopyBufPtrMap_, folly::test::shutdownSocketSet, and wShutdownSocketSet_.

Referenced by closeNow(), connect(), handleWrite(), scheduleInitialReadWrite(), and startFail().

                          {
  if (fd_ == -1) {
    return;
  }
  if (const auto shutdownSocketSet = wShutdownSocketSet_.lock()) {
    shutdownSocketSet->close(fd_);
  } else {
    ::close(fd_);
  }
  fd_ = -1;

  // we also want to clear the zerocopy maps
  // if the fd has been closed
  idZeroCopyBufPtrMap_.clear();
  idZeroCopyBufInfoMap_.clear();
}

void folly::AsyncSocket::enableTFO ( )

inline

Enables TFO behavior on the AsyncSocket if FOLLY_ALLOW_TFO is set.

Definition at line 782 of file AsyncSocket.h.

References tfoEnabled_.

                   {
    // No-op if folly does not allow tfo
#if FOLLY_ALLOW_TFO
    tfoEnabled_ = true;
#endif
  }

bool folly::AsyncSocket::error ( ) const

overridevirtual

Determine if an error has occurred with this transport.

Returns

true iff an error has occurred (not EOF).

Implements folly::AsyncTransport.

Definition at line 1496 of file AsyncSocket.cpp.

References ERROR, and state_.

Referenced by handleConnect(), folly::AsyncSSLSocket::handleInitialReadWrite(), and writeRequestReady().

                              {
  return (state_ == StateEnum::ERROR);
}

void folly::AsyncSocket::fail ( const char *  fn, const AsyncSocketException &  ex  )

protected

Definition at line 2569 of file AsyncSocket.cpp.

References addr_, folly::SocketAddress::describe(), fd_, finishFail(), startFail(), and state_.

Referenced by gtest_xml_test_utils.GTestXMLTestCase::_GetChildren(), fatal_test.FatalTests::is_debug_build(), scheduleInitialReadWrite(), and updateEventRegistration().

                                                                     {
  VLOG(4) << "AsyncSocket(this=" << this << ", fd=" << fd_
          << ", state=" << state_ << " host=" << addr_.describe()
          << "): failed in " << fn << "(): " << ex.what();
  startFail();
  finishFail();
}

void folly::AsyncSocket::failAllWrites ( const AsyncSocketException &  ex )

protected

Definition at line 2661 of file AsyncSocket.cpp.

References folly::AsyncSocket::WriteRequest::destroy(), folly::AsyncSocket::WriteRequest::getCallback(), folly::AsyncSocket::WriteRequest::getNext(), folly::AsyncSocket::WriteRequest::getTotalBytesWritten(), folly::AsyncWriter::WriteCallback::writeErr(), and writeReqHead_.

Referenced by closeNow(), invokeAllErrors(), scheduleInitialReadWrite(), and shutdownWriteNow().

                                                              {
  // Invoke writeError() on all write callbacks.
  // This is used when writes are forcibly shutdown with write requests
  // pending, or when an error occurs with writes pending.
  while (writeReqHead_ != nullptr) {
    WriteRequest* req = writeReqHead_;
    writeReqHead_ = req->getNext();
    WriteCallback* callback = req->getCallback();
    if (callback) {
      callback->writeErr(req->getTotalBytesWritten(), ex);
    }
    req->destroy();
  }
}

void folly::AsyncSocket::failConnect ( const char *  fn, const AsyncSocketException &  ex  )

protected

Definition at line 2577 of file AsyncSocket.cpp.

References addr_, folly::SocketAddress::describe(), fd_, finishFail(), invokeConnectErr(), startFail(), and state_.

Referenced by connect(), handleConnect(), scheduleInitialReadWrite(), and timeoutExpired().

                                                                            {
  VLOG(5) << "AsyncSocket(this=" << this << ", fd=" << fd_
          << ", state=" << state_ << " host=" << addr_.describe()
          << "): failed while connecting in " << fn << "(): " << ex.what();
  startFail();

  invokeConnectErr(ex);
  finishFail(ex);
}

void folly::AsyncSocket::failErrMessageRead ( const char *  fn, const AsyncSocketException &  ex  )

protected

Definition at line 2602 of file AsyncSocket.cpp.

References addr_, folly::SocketAddress::describe(), errMessageCallback_, folly::AsyncSocket::ErrMessageCallback::errMessageError(), fd_, finishFail(), startFail(), and state_.

Referenced by handleErrMessages(), and scheduleInitialReadWrite().

                                    {
  VLOG(5) << "AsyncSocket(this=" << this << ", fd=" << fd_
          << ", state=" << state_ << " host=" << addr_.describe()
          << "): failed while reading message in " << fn << "(): " << ex.what();
  startFail();

  if (errMessageCallback_ != nullptr) {
    ErrMessageCallback* callback = errMessageCallback_;
    errMessageCallback_ = nullptr;
    callback->errMessageError(ex);
  }

  finishFail();
}

void folly::AsyncSocket::failRead ( const char *  fn, const AsyncSocketException &  ex  )

protected

Definition at line 2587 of file AsyncSocket.cpp.

References addr_, folly::SocketAddress::describe(), fd_, finishFail(), readCallback_, folly::AsyncReader::ReadCallback::readErr(), startFail(), and state_.

Referenced by handleRead(), and scheduleInitialReadWrite().

                                                                         {
  VLOG(5) << "AsyncSocket(this=" << this << ", fd=" << fd_
          << ", state=" << state_ << " host=" << addr_.describe()
          << "): failed while reading in " << fn << "(): " << ex.what();
  startFail();

  if (readCallback_ != nullptr) {
    ReadCallback* callback = readCallback_;
    readCallback_ = nullptr;
    callback->readErr(ex);
  }

  finishFail();
}

void folly::AsyncSocket::failWrite ( const char *  fn, WriteCallback *  callback, size_t  bytesWritten, const AsyncSocketException &  ex  )

protected

Definition at line 2642 of file AsyncSocket.cpp.

References addr_, folly::SocketAddress::describe(), fd_, finishFail(), startFail(), state_, and folly::AsyncWriter::WriteCallback::writeErr().

Referenced by handleWrite(), scheduleInitialReadWrite(), setSendTimeout(), timeoutExpired(), and writeImpl().

                                    {
  // This version of failWrite() is used when the failure occurs before
  // we've added the callback to writeReqHead_.
  VLOG(4) << "AsyncSocket(this=" << this << ", fd=" << fd_
          << ", state=" << state_ << " host=" << addr_.describe()
          << "): failed while writing in " << fn << "(): " << ex.what();
  startFail();

  if (callback != nullptr) {
    callback->writeErr(bytesWritten, ex);
  }

  finishFail();
}

void folly::AsyncSocket::failWrite ( const char *  fn, const AsyncSocketException &  ex  )

protected

Definition at line 2619 of file AsyncSocket.cpp.

References addr_, folly::SocketAddress::describe(), folly::AsyncSocket::WriteRequest::destroy(), fd_, finishFail(), folly::AsyncSocket::WriteRequest::getCallback(), folly::AsyncSocket::WriteRequest::getNext(), folly::AsyncSocket::WriteRequest::getTotalBytesWritten(), startFail(), state_, uint32_t, folly::AsyncWriter::WriteCallback::writeErr(), and writeReqHead_.

                                                                          {
  VLOG(5) << "AsyncSocket(this=" << this << ", fd=" << fd_
          << ", state=" << state_ << " host=" << addr_.describe()
          << "): failed while writing in " << fn << "(): " << ex.what();
  startFail();

  // Only invoke the first write callback, since the error occurred while
  // writing this request.  Let any other pending write callbacks be invoked in
  // finishFail().
  if (writeReqHead_ != nullptr) {
    WriteRequest* req = writeReqHead_;
    writeReqHead_ = req->getNext();
    WriteCallback* callback = req->getCallback();
    uint32_t bytesWritten = req->getTotalBytesWritten();
    req->destroy();
    if (callback) {
      callback->writeErr(bytesWritten, ex);
    }
  }

  finishFail();
}

void folly::AsyncSocket::finishFail ( )

protected

Definition at line 2553 of file AsyncSocket.cpp.

References ERROR, folly::DelayedDestructionBase::getDestructorGuardCount(), folly::AsyncSocketException::INTERNAL_ERROR, invokeAllErrors(), state_, and withAddr().

Referenced by fail(), failConnect(), failErrMessageRead(), folly::AsyncSSLSocket::failHandshake(), failRead(), failWrite(), invalidState(), and scheduleInitialReadWrite().

                             {
  assert(state_ == StateEnum::ERROR);
  assert(getDestructorGuardCount() > 0);

  AsyncSocketException ex(
      AsyncSocketException::INTERNAL_ERROR,
      withAddr("socket closing after error"));
  invokeAllErrors(ex);
}

void folly::AsyncSocket::finishFail ( const AsyncSocketException &  ex )

protected

Definition at line 2563 of file AsyncSocket.cpp.

References ERROR, folly::DelayedDestructionBase::getDestructorGuardCount(), invokeAllErrors(), and state_.

                                                           {
  assert(state_ == StateEnum::ERROR);
  assert(getDestructorGuardCount() > 0);
  invokeAllErrors(ex);
}

size_t folly::AsyncSocket::getAppBytesReceived ( ) const

inlineoverridevirtual

Implements folly::AsyncTransport.

Definition at line 591 of file AsyncSocket.h.

References appBytesReceived_.

Referenced by getRawBytesReceived().

                                              {
    return appBytesReceived_;
  }

size_t folly::AsyncSocket::getAppBytesWritten ( ) const

inlineoverridevirtual

Implements folly::AsyncTransport.

Definition at line 583 of file AsyncSocket.h.

References appBytesWritten_.

Referenced by getRawBytesWritten().

                                             {
    return appBytesWritten_;
  }

std::chrono::steady_clock::time_point folly::AsyncSocket::getConnectEndTime ( ) const

inline

Definition at line 611 of file AsyncSocket.h.

References connectEndTime_.

                                                            {
    return connectEndTime_;
  }

std::chrono::steady_clock::time_point folly::AsyncSocket::getConnectStartTime ( ) const

inline

Definition at line 607 of file AsyncSocket.h.

References connectStartTime_.

                                                              {
    return connectStartTime_;
  }

std::chrono::nanoseconds folly::AsyncSocket::getConnectTime ( ) const

inline

Definition at line 599 of file AsyncSocket.h.

References connectEndTime_, and connectStartTime_.

                                              {
    return connectEndTime_ - connectStartTime_;
  }

std::chrono::milliseconds folly::AsyncSocket::getConnectTimeout ( ) const

inline

Definition at line 603 of file AsyncSocket.h.

References connectTimeout_.

                                                  {
    return connectTimeout_;
  }

AsyncSocket::ErrMessageCallback * folly::AsyncSocket::getErrMessageCallback ( ) const

virtual

Get a pointer to ErrMessageCallback implementation currently registered with this socket.

Definition at line 756 of file AsyncSocket.cpp.

References errMessageCallback_.

Referenced by getMaxReadsPerEvent().

                                                                        {
  return errMessageCallback_;
}

EventBase* folly::AsyncSocket::getEventBase ( ) const

inlineoverridevirtual

Get the EventBase used by this socket.

Implements folly::AsyncSocketBase.

Definition at line 328 of file AsyncSocket.h.

References eventBase_.

Referenced by folly::HandshakeTimeoutCallback::connAccepted(), folly::TestSSLAsyncCacheServer::getSessionCallback(), and tmpDisableReads().

                                           {
    return eventBase_;
  }

virtual int folly::AsyncSocket::getFd ( ) const

inlinevirtual

Get the file descriptor used by the AsyncSocket.

Definition at line 335 of file AsyncSocket.h.

References detachFd(), and fd_.

Referenced by folly::SSLServerAcceptCallbackDelay::connAccepted(), folly::test::MockAsyncSocket::connect(), wangle::SSLSessionCacheManager::getSession(), wangle::TransportInfo::readRTT(), and folly::AsyncSSLSocket::sslAccept().

                            {
    return fd_;
  }

void folly::AsyncSocket::getLocalAddress ( folly::SocketAddress *  address ) const

overridevirtual

Get the address of the local endpoint of this transport.

This function may throw AsyncSocketException on error.

Parameters

address

The local address will be stored in the specified SocketAddress.

Implements folly::AsyncTransport.

Definition at line 1575 of file AsyncSocket.cpp.

References cacheLocalAddress(), and localAddr_.

                                                                   {
  cacheLocalAddress();
  *address = localAddr_;
}

uint16_t folly::AsyncSocket::getMaxReadsPerEvent ( ) const

inline

Get the maximum number of reads this object will execute from the underlying socket each time the EventBase detects that new ingress data is available.

Returns

Maximum number of reads per data-available event; a value of zero means unlimited.

Definition at line 463 of file AsyncSocket.h.

References getErrMessageCallback(), getReadCallback(), getSendMsgParamsCB(), maxReadsPerEvent_, setErrMessageCB(), setReadCB(), setSendMsgParamCB(), and setZeroCopy().

                                       {
    return maxReadsPerEvent_;
  }

uint32_t folly::AsyncSocket::getNextZeroCopyBufId ( )

inlineprotected

Definition at line 1202 of file AsyncSocket.h.

References addZeroCopyBuf(), adjustZeroCopyFlags(), containsZeroCopyBuf(), ptr, releaseZeroCopyBuf(), setZeroCopyBuf(), uint32_t, and zeroCopyBufId_.

Referenced by addZeroCopyBuf().

                                  {
    return zeroCopyBufId_++;
  }

void folly::AsyncSocket::getPeerAddress ( folly::SocketAddress *  address ) const

overridevirtual

Get the address of the remote endpoint to which this transport is connected.

This function may throw AsyncSocketException on error.

Parameters

address

The remote endpoint's address will be stored in the specified SocketAddress.

Implements folly::AsyncTransport.

Definition at line 1580 of file AsyncSocket.cpp.

References addr_, and cachePeerAddress().

                                                                  {
  cachePeerAddress();
  *address = addr_;
}

const AsyncTransportCertificate* folly::AsyncSocket::getPeerCertificate ( ) const

inlineoverridevirtual

Get the peer certificate information if any

Reimplemented from folly::AsyncTransport.

Reimplemented in folly::AsyncSSLSocket.

Definition at line 837 of file AsyncSocket.h.

References peerCertData_.

                                                                       {
    return peerCertData_.get();
  }

size_t folly::AsyncSocket::getRawBytesReceived ( ) const

inlineoverridevirtual

Implements folly::AsyncTransport.

Reimplemented in folly::AsyncSSLSocket.

Definition at line 595 of file AsyncSocket.h.

References getAppBytesReceived().

                                              {
    return getAppBytesReceived();
  }

size_t folly::AsyncSocket::getRawBytesWritten ( ) const

inlineoverridevirtual

Implements folly::AsyncTransport.

Reimplemented in folly::AsyncSSLSocket.

Definition at line 587 of file AsyncSocket.h.

References getAppBytesWritten().

Referenced by folly::test::MockAsyncSocket::connect().

                                             {
    return getAppBytesWritten();
  }

AsyncSocket::ReadCallback * folly::AsyncSocket::getReadCallback ( ) const

overridevirtual

Implements folly::AsyncTransportWrapper.

Definition at line 856 of file AsyncSocket.cpp.

References readCallback_.

Referenced by getMaxReadsPerEvent(), and wangle::SocketPeeker::~SocketPeeker().

                                                            {
  return readCallback_;
}

const AsyncTransportCertificate* folly::AsyncSocket::getSelfCertificate ( ) const

inlineoverridevirtual

Get the certificate information of this transport, if any

Reimplemented from folly::AsyncTransport.

Reimplemented in folly::AsyncSSLSocket.

Definition at line 846 of file AsyncSocket.h.

References selfCertData_.

                                                                       {
    return selfCertData_.get();
  }

AsyncSocket::SendMsgParamsCallback * folly::AsyncSocket::getSendMsgParamsCB ( ) const

virtual

Get a pointer to SendMsgParamsCallback implementation currently registered with this socket.

Definition at line 764 of file AsyncSocket.cpp.

References sendMsgParamCallback_.

Referenced by getMaxReadsPerEvent().

                                                                        {
  return sendMsgParamCallback_;
}

uint32_t folly::AsyncSocket::getSendTimeout ( ) const

inlineoverridevirtual

Get the send timeout.

Returns

Returns the current send timeout, in milliseconds. A return value of 0 indicates that no timeout is set.

Implements folly::AsyncTransport.

Definition at line 437 of file AsyncSocket.h.

References sendTimeout_.

                                           {
    return sendTimeout_;
  }

template<typename T >

int folly::AsyncSocket::getSockOpt ( int  level, int  optname, T *  optval, socklen_t *  optlen  )

inline

Generic API for reading a socket option.

Parameters

level	same as the "level" parameter in getsockopt().
optname	same as the "optname" parameter in getsockopt().
optval	pointer to the variable in which the option value should be returned.
optlen	value-result argument, initially containing the size of the buffer pointed to by optval, and modified on return to indicate the actual size of the value returned.

Returns

same as the return value of getsockopt().

Definition at line 714 of file AsyncSocket.h.

References fd_, and folly::netops::getsockopt().

                                                                       {
    return getsockopt(fd_, level, optname, (void*)optval, optlen);
  }

virtual int folly::AsyncSocket::getSockOptVirtual ( int  level, int  optname, void *  optval, socklen_t *  optlen  )

inlinevirtual

Virtual method for reading a socket option returning integer value, which is the most typical case. Convenient for overriding and mocking.

Parameters

level	same as the "level" parameter in getsockopt().
optname	same as the "optname" parameter in getsockopt().
optval	same as "optval" parameter in getsockopt().
optlen	same as "optlen" parameter in getsockopt().

Returns

same as the return value of getsockopt().

Definition at line 743 of file AsyncSocket.h.

References fd_, and folly::netops::getsockopt().

                                                                             {
    return getsockopt(fd_, level, optname, optval, optlen);
  }

bool folly::AsyncSocket::getTFOAttempted ( ) const

inline

Definition at line 615 of file AsyncSocket.h.

References tfoAttempted_.

                               {
    return tfoAttempted_;
  }

bool folly::AsyncSocket::getTFOFinished ( ) const

inline

Returns whether or not the attempt to use TFO finished successfully. This does not necessarily mean TFO worked, just that trying to use TFO succeeded.

Definition at line 625 of file AsyncSocket.h.

References getTFOSucceded(), setCloseOnExec(), setCongestionFlavor(), setNoDelay(), setQuickAck(), setRecvBufSize(), setSendBufSize(), string, and tfoFinished_.

                              {
    return tfoFinished_;
  }

bool folly::AsyncSocket::getTFOSucceded

(

)

const

Returns whether or not TFO attempt succeded on this connection. For servers this is pretty straightforward API and can be invoked right after the connection is accepted. This API will perform one syscall. This API is a bit tricky to use for clients, since clients only know this for sure after the SYN-ACK is returned. So it's appropriate to call this only after the first application data is read from the socket when the caller knows that the SYN has been ACKed by the server.

Definition at line 1585 of file AsyncSocket.cpp.

References fd_, and folly::detail::tfo_succeeded().

Referenced by getTFOFinished().

                                       {
  return detail::tfo_succeeded(fd_);
}

bool folly::AsyncSocket::getZeroCopy ( ) const

inline

Definition at line 504 of file AsyncSocket.h.

References zeroCopyEnabled_.

Referenced by folly::AsyncSocket::BytesWriteRequest::performWrite().

                           {
    return zeroCopyEnabled_;
  }

uint32_t folly::AsyncSocket::getZeroCopyBufId ( ) const

inline

Definition at line 508 of file AsyncSocket.h.

References zeroCopyBufId_.

                                    {
    return zeroCopyBufId_;
  }

size_t folly::AsyncSocket::getZeroCopyReenableThreshold ( ) const

inline

Definition at line 512 of file AsyncSocket.h.

References count, folly::NONE, setZeroCopyReenableThreshold(), write(), writeChain(), writeRequest(), writev(), and zeroCopyReenableThreshold_.

                                              {
    return zeroCopyReenableThreshold_;
  }

bool folly::AsyncSocket::good ( ) const

overridevirtual

Determine if transport is open and ready to read or write.

Note that this function returns false on EOF; you must also call error() to distinguish between an EOF and an error.

Returns

true iff the transport is open and ready, false otherwise.

Implements folly::AsyncTransport.

Reimplemented in folly::AsyncSSLSocket.

Definition at line 1489 of file AsyncSocket.cpp.

References CONNECTING, ESTABLISHED, eventBase_, FAST_OPEN, shutdownFlags_, and state_.

Referenced by folly::test::MockAsyncSocket::connect(), folly::AsyncSSLSocket::connecting(), folly::AsyncSSLSocket::good(), scheduleImmediateRead(), scheduleInitialReadWrite(), and writeRequestReady().

                             {
  return (
      (state_ == StateEnum::CONNECTING || state_ == StateEnum::FAST_OPEN ||
       state_ == StateEnum::ESTABLISHED) &&
      (shutdownFlags_ == 0) && (eventBase_ != nullptr));
}

void folly::AsyncSocket::handleConnect ( )

protectedvirtualnoexcept

Reimplemented in folly::AsyncSSLSocket.

Definition at line 2206 of file AsyncSocket.cpp.

References addr_, folly::AsyncTimeout::cancelTimeout(), CONNECTING, folly::SocketAddress::describe(), error(), ESTABLISHED, eventBase_, eventFlags_, failConnect(), fd_, folly::netops::getsockopt(), handleInitialReadWrite(), folly::AsyncSocketException::INTERNAL_ERROR, invokeConnectSuccess(), folly::EventHandler::NONE, folly::AsyncSocketException::NOT_OPEN, SHUT_READ, SHUT_WRITE, SHUT_WRITE_PENDING, folly::shutdown(), shutdownFlags_, state_, withAddr(), folly::EventHandler::WRITE, writeReqHead_, and writeTimeout_.

Referenced by folly::AsyncSSLSocket::handleConnect(), handleWrite(), and scheduleInitialReadWrite().

                                         {
  VLOG(5) << "AsyncSocket::handleConnect() this=" << this << ", fd=" << fd_
          << ", state=" << state_;
  assert(state_ == StateEnum::CONNECTING);
  // SHUT_WRITE can never be set while we are still connecting;
  // SHUT_WRITE_PENDING may be set, be we only set SHUT_WRITE once the connect
  // finishes
  assert((shutdownFlags_ & SHUT_WRITE) == 0);

  // In case we had a connect timeout, cancel the timeout
  writeTimeout_.cancelTimeout();
  // We don't use a persistent registration when waiting on a connect event,
  // so we have been automatically unregistered now.  Update eventFlags_ to
  // reflect reality.
  assert(eventFlags_ == EventHandler::WRITE);
  eventFlags_ = EventHandler::NONE;

  // Call getsockopt() to check if the connect succeeded
  int error;
  socklen_t len = sizeof(error);
  int rv = getsockopt(fd_, SOL_SOCKET, SO_ERROR, &error, &len);
  if (rv != 0) {
    auto errnoCopy = errno;
    AsyncSocketException ex(
        AsyncSocketException::INTERNAL_ERROR,
        withAddr("error calling getsockopt() after connect"),
        errnoCopy);
    VLOG(4) << "AsyncSocket::handleConnect(this=" << this << ", fd=" << fd_
            << " host=" << addr_.describe() << ") exception:" << ex.what();
    return failConnect(__func__, ex);
  }

  if (error != 0) {
    AsyncSocketException ex(
        AsyncSocketException::NOT_OPEN, "connect failed", error);
    VLOG(2) << "AsyncSocket::handleConnect(this=" << this << ", fd=" << fd_
            << " host=" << addr_.describe() << ") exception: " << ex.what();
    return failConnect(__func__, ex);
  }

  // Move into STATE_ESTABLISHED
  state_ = StateEnum::ESTABLISHED;

  // If SHUT_WRITE_PENDING is set and we don't have any write requests to
  // perform, immediately shutdown the write half of the socket.
  if ((shutdownFlags_ & SHUT_WRITE_PENDING) && writeReqHead_ == nullptr) {
    // SHUT_READ shouldn't be set.  If close() is called on the socket while we
    // are still connecting we just abort the connect rather than waiting for
    // it to complete.
    assert((shutdownFlags_ & SHUT_READ) == 0);
    shutdown(fd_, SHUT_WR);
    shutdownFlags_ |= SHUT_WRITE;
  }

  VLOG(7) << "AsyncSocket " << this << ": fd " << fd_
          << "successfully connected; state=" << state_;

  // Remember the EventBase we are attached to, before we start invoking any
  // callbacks (since the callbacks may call detachEventBase()).
  EventBase* originalEventBase = eventBase_;

  invokeConnectSuccess();
  // Note that the connect callback may have changed our state.
  // (set or unset the read callback, called write(), closed the socket, etc.)
  // The following code needs to handle these situations correctly.
  //
  // If the socket has been closed, readCallback_ and writeReqHead_ will
  // always be nullptr, so that will prevent us from trying to read or write.
  //
  // The main thing to check for is if eventBase_ is still originalEventBase.
  // If not, we have been detached from this event base, so we shouldn't
  // perform any more operations.
  if (eventBase_ != originalEventBase) {
    return;
  }

  handleInitialReadWrite();
}

size_t folly::AsyncSocket::handleErrMessages ( )

protectedvirtualnoexcept

Definition at line 1804 of file AsyncSocket.cpp.

References folly::data(), folly::AsyncSocket::ErrMessageCallback::errMessage(), errMessageCallback_, failErrMessageRead(), fd_, idZeroCopyBufPtrMap_, folly::AsyncSocketException::INTERNAL_ERROR, isZeroCopyMsg(), processZeroCopyMsg(), folly::netops::recvmsg(), state_, uint8_t, and withAddr().

Referenced by ioReady(), processZeroCopyWriteInProgress(), and scheduleInitialReadWrite().

                                               {
  // This method has non-empty implementation only for platforms
  // supporting per-socket error queues.
  VLOG(5) << "AsyncSocket::handleErrMessages() this=" << this << ", fd=" << fd_
          << ", state=" << state_;
  if (errMessageCallback_ == nullptr && idZeroCopyBufPtrMap_.empty()) {
    VLOG(7) << "AsyncSocket::handleErrMessages(): "
            << "no callback installed - exiting.";
    return 0;
  }

#ifdef FOLLY_HAVE_MSG_ERRQUEUE
  uint8_t ctrl[1024];
  unsigned char data;
  struct msghdr msg;
  iovec entry;

  entry.iov_base = &data;
  entry.iov_len = sizeof(data);
  msg.msg_iov = &entry;
  msg.msg_iovlen = 1;
  msg.msg_name = nullptr;
  msg.msg_namelen = 0;
  msg.msg_control = ctrl;
  msg.msg_controllen = sizeof(ctrl);
  msg.msg_flags = 0;

  int ret;
  size_t num = 0;
  while (true) {
    ret = recvmsg(fd_, &msg, MSG_ERRQUEUE);
    VLOG(5) << "AsyncSocket::handleErrMessages(): recvmsg returned " << ret;

    if (ret < 0) {
      if (errno != EAGAIN) {
        auto errnoCopy = errno;
        LOG(ERROR) << "::recvmsg exited with code " << ret
                   << ", errno: " << errnoCopy;
        AsyncSocketException ex(
            AsyncSocketException::INTERNAL_ERROR,
            withAddr("recvmsg() failed"),
            errnoCopy);
        failErrMessageRead(__func__, ex);
      }

      return num;
    }

    for (struct cmsghdr* cmsg = CMSG_FIRSTHDR(&msg);
         cmsg != nullptr && cmsg->cmsg_len != 0;
         cmsg = CMSG_NXTHDR(&msg, cmsg)) {
      ++num;
      if (isZeroCopyMsg(*cmsg)) {
        processZeroCopyMsg(*cmsg);
      } else {
        if (errMessageCallback_) {
          errMessageCallback_->errMessage(*cmsg);
        }
      }
    }
  }
#else
  return 0;
#endif // FOLLY_HAVE_MSG_ERRQUEUE
}

void folly::AsyncSocket::handleInitialReadWrite ( )

protectedvirtualnoexcept

Reimplemented in folly::AsyncSSLSocket.

Definition at line 2169 of file AsyncSocket.cpp.

References checkForImmediateRead(), ERROR, ESTABLISHED, eventFlags_, handleWrite(), folly::EventHandler::READ, readCallback_, SHUT_READ, shutdownFlags_, state_, updateEventRegistration(), folly::EventHandler::WRITE, and writeReqHead_.

Referenced by folly::AsyncSSLSocket::handleConnect(), handleConnect(), folly::AsyncSSLSocket::handleReturnFromSSLAccept(), and scheduleInitialReadWrite().

                                                  {
  // Our callers should already be holding a DestructorGuard, but grab
  // one here just to make sure, in case one of our calling code paths ever
  // changes.
  DestructorGuard dg(this);
  // If we have a readCallback_, make sure we enable read events.  We
  // may already be registered for reads if connectSuccess() set
  // the read calback.
  if (readCallback_ && !(eventFlags_ & EventHandler::READ)) {
    assert(state_ == StateEnum::ESTABLISHED);
    assert((shutdownFlags_ & SHUT_READ) == 0);
    if (!updateEventRegistration(EventHandler::READ, 0)) {
      assert(state_ == StateEnum::ERROR);
      return;
    }
    checkForImmediateRead();
  } else if (readCallback_ == nullptr) {
    // Unregister for read events.
    updateEventRegistration(0, EventHandler::READ);
  }

  // If we have write requests pending, try to send them immediately.
  // Since we just finished accepting, there is a very good chance that we can
  // write without blocking.
  //
  // However, we only process them if EventHandler::WRITE is not already set,
  // which means that we're already blocked on a write attempt.  (This can
  // happen if connectSuccess() called write() before returning.)
  if (writeReqHead_ && !(eventFlags_ & EventHandler::WRITE)) {
    // Call handleWrite() to perform write processing.
    handleWrite();
  } else if (writeReqHead_ == nullptr) {
    // Unregister for write event.
    updateEventRegistration(0, EventHandler::WRITE);
  }
}

void folly::AsyncSocket::handleRead ( )

protectedvirtualnoexcept

Reimplemented in folly::AsyncSSLSocket.

Definition at line 1881 of file AsyncSocket.cpp.

References folly::AsyncSocketException::BAD_ARGS, ERROR, ESTABLISHED, eventBase_, eventFlags_, failRead(), fd_, folly::AsyncSocketException::INTERNAL_ERROR, isBufferMovable_, kOpenSslModeMoveBufferOwnership, maxReadsPerEvent_, folly::gen::move, performRead(), prepareReadBuffer(), folly::EventHandler::READ, READ_BLOCKING, READ_EOF, READ_ERROR, fizz::detail::readBuf(), folly::AsyncReader::ReadCallback::readBufferAvailable(), readCallback_, folly::AsyncReader::ReadCallback::readDataAvailable(), folly::AsyncReader::ReadCallback::readEOF(), readErr_, scheduleImmediateRead(), SHUT_READ, shutdownFlags_, state_, folly::IOBuf::takeOwnership(), uint16_t, updateEventRegistration(), and withAddr().

Referenced by folly::AsyncSSLSocket::checkForImmediateRead(), checkForImmediateRead(), AsyncSocketImmediateRead::checkForImmediateRead(), folly::AsyncSSLSocket::handleRead(), ioReady(), and scheduleInitialReadWrite().

                                      {
  VLOG(5) << "AsyncSocket::handleRead() this=" << this << ", fd=" << fd_
          << ", state=" << state_;
  assert(state_ == StateEnum::ESTABLISHED);
  assert((shutdownFlags_ & SHUT_READ) == 0);
  assert(readCallback_ != nullptr);
  assert(eventFlags_ & EventHandler::READ);

  // Loop until:
  // - a read attempt would block
  // - readCallback_ is uninstalled
  // - the number of loop iterations exceeds the optional maximum
  // - this AsyncSocket is moved to another EventBase
  //
  // When we invoke readDataAvailable() it may uninstall the readCallback_,
  // which is why need to check for it here.
  //
  // The last bullet point is slightly subtle.  readDataAvailable() may also
  // detach this socket from this EventBase.  However, before
  // readDataAvailable() returns another thread may pick it up, attach it to
  // a different EventBase, and install another readCallback_.  We need to
  // exit immediately after readDataAvailable() returns if the eventBase_ has
  // changed.  (The caller must perform some sort of locking to transfer the
  // AsyncSocket between threads properly.  This will be sufficient to ensure
  // that this thread sees the updated eventBase_ variable after
  // readDataAvailable() returns.)
  uint16_t numReads = 0;
  EventBase* originalEventBase = eventBase_;
  while (readCallback_ && eventBase_ == originalEventBase) {
    // Get the buffer to read into.
    void* buf = nullptr;
    size_t buflen = 0, offset = 0;
    try {
      prepareReadBuffer(&buf, &buflen);
      VLOG(5) << "prepareReadBuffer() buf=" << buf << ", buflen=" << buflen;
    } catch (const AsyncSocketException& ex) {
      return failRead(__func__, ex);
    } catch (const std::exception& ex) {
      AsyncSocketException tex(
          AsyncSocketException::BAD_ARGS,
          string("ReadCallback::getReadBuffer() "
                 "threw exception: ") +
              ex.what());
      return failRead(__func__, tex);
    } catch (...) {
      AsyncSocketException ex(
          AsyncSocketException::BAD_ARGS,
          "ReadCallback::getReadBuffer() threw "
          "non-exception type");
      return failRead(__func__, ex);
    }
    if (!isBufferMovable_ && (buf == nullptr || buflen == 0)) {
      AsyncSocketException ex(
          AsyncSocketException::BAD_ARGS,
          "ReadCallback::getReadBuffer() returned "
          "empty buffer");
      return failRead(__func__, ex);
    }

    // Perform the read
    auto readResult = performRead(&buf, &buflen, &offset);
    auto bytesRead = readResult.readReturn;
    VLOG(4) << "this=" << this << ", AsyncSocket::handleRead() got "
            << bytesRead << " bytes";
    if (bytesRead > 0) {
      if (!isBufferMovable_) {
        readCallback_->readDataAvailable(size_t(bytesRead));
      } else {
        CHECK(kOpenSslModeMoveBufferOwnership);
        VLOG(5) << "this=" << this << ", AsyncSocket::handleRead() got "
                << "buf=" << buf << ", " << bytesRead << "/" << buflen
                << ", offset=" << offset;
        auto readBuf = folly::IOBuf::takeOwnership(buf, buflen);
        readBuf->trimStart(offset);
        readBuf->trimEnd(buflen - offset - bytesRead);
        readCallback_->readBufferAvailable(std::move(readBuf));
      }

      // Fall through and continue around the loop if the read
      // completely filled the available buffer.
      // Note that readCallback_ may have been uninstalled or changed inside
      // readDataAvailable().
      if (size_t(bytesRead) < buflen) {
        return;
      }
    } else if (bytesRead == READ_BLOCKING) {
      // No more data to read right now.
      return;
    } else if (bytesRead == READ_ERROR) {
      readErr_ = READ_ERROR;
      if (readResult.exception) {
        return failRead(__func__, *readResult.exception);
      }
      auto errnoCopy = errno;
      AsyncSocketException ex(
          AsyncSocketException::INTERNAL_ERROR,
          withAddr("recv() failed"),
          errnoCopy);
      return failRead(__func__, ex);
    } else {
      assert(bytesRead == READ_EOF);
      readErr_ = READ_EOF;
      // EOF
      shutdownFlags_ |= SHUT_READ;
      if (!updateEventRegistration(0, EventHandler::READ)) {
        // we've already been moved into STATE_ERROR
        assert(state_ == StateEnum::ERROR);
        assert(readCallback_ == nullptr);
        return;
      }

      ReadCallback* callback = readCallback_;
      readCallback_ = nullptr;
      callback->readEOF();
      return;
    }
    if (maxReadsPerEvent_ && (++numReads >= maxReadsPerEvent_)) {
      if (readCallback_ != nullptr) {
        // We might still have data in the socket.
        // (e.g. see comment in AsyncSSLSocket::checkForImmediateRead)
        scheduleImmediateRead();
      }
      return;
    }
  }
}

void folly::AsyncSocket::handleWrite ( )

protectedvirtualnoexcept

This function attempts to write as much data as possible, until no more data can be written.

• If it sends all available data, it unregisters for write events, and stops the writeTimeout_.
• If not all of the data can be sent immediately, it reschedules writeTimeout_ (if a non-zero timeout is set), and ensures the handler is registered for write events.

Reimplemented in folly::AsyncSSLSocket.

Definition at line 2019 of file AsyncSocket.cpp.

References bufferCallback_, folly::AsyncTimeout::cancelTimeout(), folly::EventHandler::changeHandlerFD(), CLOSED, connectCallback_, CONNECTING, folly::AsyncSocket::WriteRequest::consume(), folly::AsyncSocket::WriteRequest::destroy(), doClose(), ERROR, ESTABLISHED, eventBase_, eventFlags_, failWrite(), fd_, folly::AsyncSocket::WriteRequest::getCallback(), folly::AsyncSocket::WriteRequest::getNext(), handleConnect(), folly::AsyncSocketException::INTERNAL_ERROR, ioHandler_, folly::AsyncSocket::WriteRequest::isComplete(), folly::AsyncTimeout::isScheduled(), folly::AsyncTransport::BufferCallback::onEgressBufferCleared(), folly::AsyncTransport::BufferCallback::onEgressBuffered(), folly::AsyncSocket::WriteRequest::performWrite(), readCallback_, folly::AsyncTimeout::scheduleTimeout(), sendTimeout_, SHUT_READ, SHUT_WRITE, SHUT_WRITE_PENDING, folly::shutdown(), shutdownFlags_, state_, updateEventRegistration(), withAddr(), folly::EventHandler::WRITE, writeReqHead_, writeReqTail_, folly::AsyncWriter::WriteCallback::writeSuccess(), and writeTimeout_.

Referenced by handleInitialReadWrite(), folly::AsyncSSLSocket::handleWrite(), ioReady(), scheduleInitialReadWrite(), and writeRequestReady().

                                       {
  VLOG(5) << "AsyncSocket::handleWrite() this=" << this << ", fd=" << fd_
          << ", state=" << state_;
  DestructorGuard dg(this);

  if (state_ == StateEnum::CONNECTING) {
    handleConnect();
    return;
  }

  // Normal write
  assert(state_ == StateEnum::ESTABLISHED);
  assert((shutdownFlags_ & SHUT_WRITE) == 0);
  assert(writeReqHead_ != nullptr);

  // Loop until we run out of write requests,
  // or until this socket is moved to another EventBase.
  // (See the comment in handleRead() explaining how this can happen.)
  EventBase* originalEventBase = eventBase_;
  while (writeReqHead_ != nullptr && eventBase_ == originalEventBase) {
    auto writeResult = writeReqHead_->performWrite();
    if (writeResult.writeReturn < 0) {
      if (writeResult.exception) {
        return failWrite(__func__, *writeResult.exception);
      }
      auto errnoCopy = errno;
      AsyncSocketException ex(
          AsyncSocketException::INTERNAL_ERROR,
          withAddr("writev() failed"),
          errnoCopy);
      return failWrite(__func__, ex);
    } else if (writeReqHead_->isComplete()) {
      // We finished this request
      WriteRequest* req = writeReqHead_;
      writeReqHead_ = req->getNext();

      if (writeReqHead_ == nullptr) {
        writeReqTail_ = nullptr;
        // This is the last write request.
        // Unregister for write events and cancel the send timer
        // before we invoke the callback.  We have to update the state properly
        // before calling the callback, since it may want to detach us from
        // the EventBase.
        if (eventFlags_ & EventHandler::WRITE) {
          if (!updateEventRegistration(0, EventHandler::WRITE)) {
            assert(state_ == StateEnum::ERROR);
            return;
          }
          // Stop the send timeout
          writeTimeout_.cancelTimeout();
        }
        assert(!writeTimeout_.isScheduled());

        // If SHUT_WRITE_PENDING is set, we should shutdown the socket after
        // we finish sending the last write request.
        //
        // We have to do this before invoking writeSuccess(), since
        // writeSuccess() may detach us from our EventBase.
        if (shutdownFlags_ & SHUT_WRITE_PENDING) {
          assert(connectCallback_ == nullptr);
          shutdownFlags_ |= SHUT_WRITE;

          if (shutdownFlags_ & SHUT_READ) {
            // Reads have already been shutdown.  Fully close the socket and
            // move to STATE_CLOSED.
            //
            // Note: This code currently moves us to STATE_CLOSED even if
            // close() hasn't ever been called.  This can occur if we have
            // received EOF from the peer and shutdownWrite() has been called
            // locally.  Should we bother staying in STATE_ESTABLISHED in this
            // case, until close() is actually called?  I can't think of a
            // reason why we would need to do so.  No other operations besides
            // calling close() or destroying the socket can be performed at
            // this point.
            assert(readCallback_ == nullptr);
            state_ = StateEnum::CLOSED;
            if (fd_ >= 0) {
              ioHandler_.changeHandlerFD(-1);
              doClose();
            }
          } else {
            // Reads are still enabled, so we are only doing a half-shutdown
            shutdown(fd_, SHUT_WR);
          }
        }
      }

      // Invoke the callback
      WriteCallback* callback = req->getCallback();
      req->destroy();
      if (callback) {
        callback->writeSuccess();
      }
      // We'll continue around the loop, trying to write another request
    } else {
      // Partial write.
      if (bufferCallback_) {
        bufferCallback_->onEgressBuffered();
      }
      writeReqHead_->consume();
      // Stop after a partial write; it's highly likely that a subsequent write
      // attempt will just return EAGAIN.
      //
      // Ensure that we are registered for write events.
      if ((eventFlags_ & EventHandler::WRITE) == 0) {
        if (!updateEventRegistration(EventHandler::WRITE, 0)) {
          assert(state_ == StateEnum::ERROR);
          return;
        }
      }

      // Reschedule the send timeout, since we have made some write progress.
      if (sendTimeout_ > 0) {
        if (!writeTimeout_.scheduleTimeout(sendTimeout_)) {
          AsyncSocketException ex(
              AsyncSocketException::INTERNAL_ERROR,
              withAddr("failed to reschedule write timeout"));
          return failWrite(__func__, ex);
        }
      }
      return;
    }
  }
  if (!writeReqHead_ && bufferCallback_) {
    bufferCallback_->onEgressBufferCleared();
  }
}

bool folly::AsyncSocket::hangup ( ) const

virtual

Definition at line 1471 of file AsyncSocket.cpp.

References fd_, and folly::netops::poll().

Referenced by folly::test::MockAsyncSocket::connect(), folly::test::MockAsyncSSLSocket::connect(), and writeRequestReady().

                               {
  if (fd_ == -1) {
    // sanity check, no one should ask for hangup if we are not connected.
    assert(false);
    return false;
  }
#ifdef POLLRDHUP // Linux-only
  struct pollfd fds[1];
  fds[0].fd = fd_;
  fds[0].events = POLLRDHUP | POLLHUP;
  fds[0].revents = 0;
  poll(fds, 1, 0);
  return (fds[0].revents & (POLLRDHUP | POLLHUP)) != 0;
#else
  return false;
#endif
}

void folly::AsyncSocket::init ( )

protected

Definition at line 337 of file AsyncSocket.cpp.

References appBytesReceived_, appBytesWritten_, connectCallback_, folly::EventBase::dcheckIsInEventBaseThread(), errMessageCallback_, eventBase_, eventFlags_, fd_, maxReadsPerEvent_, folly::EventHandler::NONE, readCallback_, sendMsgParamCallback_, sendTimeout_, shutdownFlags_, state_, UNINIT, writeReqHead_, writeReqTail_, and wShutdownSocketSet_.

Referenced by AsyncSocket().

                       {
  if (eventBase_) {
    eventBase_->dcheckIsInEventBaseThread();
  }
  shutdownFlags_ = 0;
  state_ = StateEnum::UNINIT;
  eventFlags_ = EventHandler::NONE;
  fd_ = -1;
  sendTimeout_ = 0;
  maxReadsPerEvent_ = 16;
  connectCallback_ = nullptr;
  errMessageCallback_ = nullptr;
  readCallback_ = nullptr;
  writeReqHead_ = nullptr;
  writeReqTail_ = nullptr;
  wShutdownSocketSet_.reset();
  appBytesWritten_ = 0;
  appBytesReceived_ = 0;
  sendMsgParamCallback_ = &defaultSendMsgParamsCallback;
}

void folly::AsyncSocket::invalidState ( ConnectCallback *  callback )

protected

Definition at line 2676 of file AsyncSocket.cpp.

References folly::AsyncSocketException::ALREADY_OPEN, CLOSED, connectEndTime_, folly::AsyncSocket::ConnectCallback::connectErr(), ERROR, fd_, finishFail(), now(), startFail(), and state_.

Referenced by connect(), scheduleInitialReadWrite(), setErrMessageCB(), setReadCB(), and writeImpl().

                                                        {
  VLOG(5) << "AsyncSocket(this=" << this << ", fd=" << fd_
          << "): connect() called in invalid state " << state_;

  /*
   * The invalidState() methods don't use the normal failure mechanisms,
   * since we don't know what state we are in.  We don't want to call
   * startFail()/finishFail() recursively if we are already in the middle of
   * cleaning up.
   */

  AsyncSocketException ex(
      AsyncSocketException::ALREADY_OPEN,
      "connect() called with socket in invalid state");
  connectEndTime_ = std::chrono::steady_clock::now();
  if (state_ == StateEnum::CLOSED || state_ == StateEnum::ERROR) {
    if (callback) {
      callback->connectErr(ex);
    }
  } else {
    // We can't use failConnect() here since connectCallback_
    // may already be set to another callback.  Invoke this ConnectCallback
    // here; any other connectCallback_ will be invoked in finishFail()
    startFail();
    if (callback) {
      callback->connectErr(ex);
    }
    finishFail();
  }
}

void folly::AsyncSocket::invalidState ( ErrMessageCallback *  callback )

protected

Definition at line 2707 of file AsyncSocket.cpp.

References CLOSED, folly::AsyncSocket::ErrMessageCallback::errMessageError(), ERROR, fd_, finishFail(), folly::AsyncSocketException::NOT_OPEN, startFail(), and state_.

                                                           {
  VLOG(4) << "AsyncSocket(this=" << this << ", fd=" << fd_
          << "): setErrMessageCB(" << callback << ") called in invalid state "
          << state_;

  AsyncSocketException ex(
      AsyncSocketException::NOT_OPEN,
      msgErrQueueSupported
          ? "setErrMessageCB() called with socket in invalid state"
          : "This platform does not support socket error message notifications");
  if (state_ == StateEnum::CLOSED || state_ == StateEnum::ERROR) {
    if (callback) {
      callback->errMessageError(ex);
    }
  } else {
    startFail();
    if (callback) {
      callback->errMessageError(ex);
    }
    finishFail();
  }
}

void folly::AsyncSocket::invalidState ( ReadCallback *  callback )

protected

Definition at line 2748 of file AsyncSocket.cpp.

References CLOSED, ERROR, fd_, finishFail(), folly::AsyncSocketException::NOT_OPEN, folly::AsyncReader::ReadCallback::readErr(), startFail(), and state_.

                                                     {
  VLOG(4) << "AsyncSocket(this=" << this << ", fd=" << fd_
          << "): setReadCallback(" << callback << ") called in invalid state "
          << state_;

  AsyncSocketException ex(
      AsyncSocketException::NOT_OPEN,
      "setReadCallback() called with socket in "
      "invalid state");
  if (state_ == StateEnum::CLOSED || state_ == StateEnum::ERROR) {
    if (callback) {
      callback->readErr(ex);
    }
  } else {
    startFail();
    if (callback) {
      callback->readErr(ex);
    }
    finishFail();
  }
}

void folly::AsyncSocket::invalidState ( WriteCallback *  callback )

protected

Definition at line 2770 of file AsyncSocket.cpp.

References CLOSED, ERROR, fd_, finishFail(), folly::AsyncSocketException::NOT_OPEN, startFail(), state_, withAddr(), and folly::AsyncWriter::WriteCallback::writeErr().

                                                      {
  VLOG(4) << "AsyncSocket(this=" << this << ", fd=" << fd_
          << "): write() called in invalid state " << state_;

  AsyncSocketException ex(
      AsyncSocketException::NOT_OPEN,
      withAddr("write() called with socket in invalid state"));
  if (state_ == StateEnum::CLOSED || state_ == StateEnum::ERROR) {
    if (callback) {
      callback->writeErr(0, ex);
    }
  } else {
    startFail();
    if (callback) {
      callback->writeErr(0, ex);
    }
    finishFail();
  }
}

void folly::AsyncSocket::invokeAllErrors ( const AsyncSocketException &  ex )

protected

Definition at line 2542 of file AsyncSocket.cpp.

References failAllWrites(), invokeConnectErr(), readCallback_, and folly::AsyncReader::ReadCallback::readErr().

Referenced by finishFail(), and scheduleInitialReadWrite().

                                                                {
  invokeConnectErr(ex);
  failAllWrites(ex);

  if (readCallback_) {
    ReadCallback* callback = readCallback_;
    readCallback_ = nullptr;
    callback->readErr(ex);
  }
}

void folly::AsyncSocket::invokeConnectErr ( const AsyncSocketException &  ex )

protectedvirtual

Reimplemented in folly::AsyncSSLSocket.

Definition at line 2730 of file AsyncSocket.cpp.

References connectCallback_, connectEndTime_, folly::AsyncSocket::ConnectCallback::connectErr(), and now().

Referenced by closeNow(), failConnect(), invokeAllErrors(), folly::AsyncSSLSocket::invokeConnectErr(), and scheduleInitialReadWrite().

                                                                 {
  connectEndTime_ = std::chrono::steady_clock::now();
  if (connectCallback_) {
    ConnectCallback* callback = connectCallback_;
    connectCallback_ = nullptr;
    callback->connectErr(ex);
  }
}

void folly::AsyncSocket::invokeConnectSuccess ( )

protectedvirtual

Reimplemented in folly::AsyncSSLSocket.

Definition at line 2739 of file AsyncSocket.cpp.

References connectCallback_, connectEndTime_, folly::AsyncSocket::ConnectCallback::connectSuccess(), and now().

Referenced by connect(), handleConnect(), folly::AsyncSSLSocket::invokeConnectSuccess(), and scheduleInitialReadWrite().

                                       {
  connectEndTime_ = std::chrono::steady_clock::now();
  if (connectCallback_) {
    ConnectCallback* callback = connectCallback_;
    connectCallback_ = nullptr;
    callback->connectSuccess();
  }
}

void folly::AsyncSocket::ioReady ( uint16_t  events )

protectednoexcept

Definition at line 1713 of file AsyncSocket.cpp.

References folly::EventBase::dcheckIsInEventBaseThread(), eventBase_, fd_, handleErrMessages(), handleRead(), handleWrite(), folly::EventHandler::READ, folly::EventHandler::READ_WRITE, readCallback_, state_, uint16_t, and folly::EventHandler::WRITE.

Referenced by scheduleInitialReadWrite().

                                                  {
  VLOG(7) << "AsyncSocket::ioRead() this=" << this << ", fd=" << fd_
          << ", events=" << std::hex << events << ", state=" << state_;
  DestructorGuard dg(this);
  assert(events & EventHandler::READ_WRITE);
  eventBase_->dcheckIsInEventBaseThread();

  uint16_t relevantEvents = uint16_t(events & EventHandler::READ_WRITE);
  EventBase* originalEventBase = eventBase_;
  // If we got there it means that either EventHandler::READ or
  // EventHandler::WRITE is set. Any of these flags can
  // indicate that there are messages available in the socket
  // error message queue.
  // Return if we handle any error messages - this is to avoid
  // unnecessary read/write calls
  if (handleErrMessages()) {
    return;
  }

  // Return now if handleErrMessages() detached us from our EventBase
  if (eventBase_ != originalEventBase) {
    return;
  }

  if (relevantEvents == EventHandler::READ) {
    handleRead();
  } else if (relevantEvents == EventHandler::WRITE) {
    handleWrite();
  } else if (relevantEvents == EventHandler::READ_WRITE) {
    // If both read and write events are ready, process writes first.
    handleWrite();

    // Return now if handleWrite() detached us from our EventBase
    if (eventBase_ != originalEventBase) {
      return;
    }

    // Only call handleRead() if a read callback is still installed.
    // (It's possible that the read callback was uninstalled during
    // handleWrite().)
    if (readCallback_) {
      handleRead();
    }
  } else {
    VLOG(4) << "AsyncSocket::ioRead() called with unexpected events "
            << std::hex << events << "(this=" << this << ")";
    abort();
  }
}

virtual bool folly::AsyncSocket::isClosedByPeer ( ) const

inlinevirtual

Definition at line 571 of file AsyncSocket.h.

References CLOSED, READ_EOF, READ_ERROR, readErr_, and state_.

Referenced by proxygen::HTTPSession::connCloseByRemote(), and TEST().

                                      {
    return (
        state_ == StateEnum::CLOSED &&
        (readErr_ == READ_EOF || readErr_ == READ_ERROR));
  }

virtual bool folly::AsyncSocket::isClosedBySelf ( ) const

inlinevirtual

Definition at line 577 of file AsyncSocket.h.

References CLOSED, READ_EOF, READ_ERROR, readErr_, and state_.

Referenced by TEST().

                                      {
    return (
        state_ == StateEnum::CLOSED &&
        (readErr_ != READ_EOF && readErr_ != READ_ERROR));
  }

bool folly::AsyncSocket::isDetachable ( ) const

overridevirtual

Determine if the transport can be detached.

This method must be called from the current EventBase's thread.

Implements folly::AsyncTransport.

Reimplemented in folly::AsyncSSLSocket.

Definition at line 1537 of file AsyncSocket.cpp.

References folly::EventBase::dcheckIsInEventBaseThread(), eventBase_, folly::AsyncTimeout::isScheduled(), and writeTimeout_.

Referenced by folly::AsyncSSLSocket::isDetachable(), and writeRequestReady().

                                     {
  DCHECK(eventBase_ != nullptr);
  eventBase_->dcheckIsInEventBaseThread();

  return !writeTimeout_.isScheduled();
}

bool folly::AsyncSocket::isEorTrackingEnabled ( ) const

inlineoverridevirtual

Returns

True iff end of record tracking is enabled

Implements folly::AsyncTransport.

Definition at line 559 of file AsyncSocket.h.

References trackEor_.

Referenced by folly::AsyncSSLSocket::eorAwareSSLWrite(), and folly::AsyncSSLSocket::setEorTracking().

                                             {
    return trackEor_;
  }

bool folly::AsyncSocket::isPending ( ) const

overridevirtual

Determine if the there is pending data on the transport.

Returns

true iff the if the there is pending data, false otherwise.

Reimplemented from folly::AsyncTransport.

Definition at line 1467 of file AsyncSocket.cpp.

References ioHandler_, and folly::EventHandler::isPending().

Referenced by writeRequestReady().

                                  {
  return ioHandler_.isPending();
}

bool folly::AsyncSocket::isZeroCopyMsg ( const cmsghdr &  cmsg ) const

protected

Definition at line 967 of file AsyncSocket.cpp.

References SO_EE_ORIGIN_ZEROCOPY.

Referenced by handleErrMessages(), and scheduleInitialReadWrite().

                                                         {
#ifdef FOLLY_HAVE_MSG_ERRQUEUE
  if ((cmsg.cmsg_level == SOL_IP && cmsg.cmsg_type == IP_RECVERR) ||
      (cmsg.cmsg_level == SOL_IPV6 && cmsg.cmsg_type == IPV6_RECVERR)) {
    const struct sock_extended_err* serr =
        reinterpret_cast<const struct sock_extended_err*>(CMSG_DATA(&cmsg));
    return (
        (serr->ee_errno == 0) && (serr->ee_origin == SO_EE_ORIGIN_ZEROCOPY));
  }
#endif
  (void)cmsg;
  return false;
}

bool folly::AsyncSocket::isZeroCopyRequest ( WriteFlags  flags )

protected

Definition at line 905 of file AsyncSocket.cpp.

References folly::isSet(), folly::WRITE_MSG_ZEROCOPY, and zeroCopyEnabled_.

Referenced by folly::AsyncSocket::BytesWriteRequest::consume(), folly::AsyncSocket::BytesWriteRequest::performWrite(), scheduleInitialReadWrite(), and writeImpl().

                                                    {
  return (zeroCopyEnabled_ && isSet(flags, WriteFlags::WRITE_MSG_ZEROCOPY));
}

bool folly::AsyncSocket::isZeroCopyWriteInProgress ( ) const

noexcept

Returns true if there is any zero copy write in progress Needs to be called from within the socket's EVB thread

Definition at line 1570 of file AsyncSocket.cpp.

References folly::EventBase::dcheckIsInEventBaseThread(), eventBase_, and idZeroCopyBufPtrMap_.

Referenced by setEvbChangedCallback().

                                                           {
  eventBase_->dcheckIsInEventBaseThread();
  return (!idZeroCopyBufPtrMap_.empty());
}

static std::shared_ptr<AsyncSocket> folly::AsyncSocket::newSocket ( EventBase *  evb )

inlinestatic

Helper function to create a shared_ptr<AsyncSocket>.

This passes in the correct destructor object, since AsyncSocket's destructor is protected and cannot be invoked directly.

Definition at line 281 of file AsyncSocket.h.

References AsyncSocket().

Referenced by TestServer::acceptAsync(), wangle::ClientBootstrap< DefaultPipeline >::connect(), ProxyService::ProxyHandler::onRequest(), folly::TEST(), TEST(), TEST_P(), and testConnectOptWrite().

                                                              {
    return std::shared_ptr<AsyncSocket>(new AsyncSocket(evb), Destructor());
  }

static std::shared_ptr<AsyncSocket> folly::AsyncSocket::newSocket ( EventBase *  evb, const folly::SocketAddress &  address, uint32_t  connectTimeout = 0  )

inlinestatic

Helper function to create a shared_ptr<AsyncSocket>.

Definition at line 288 of file AsyncSocket.h.

References AsyncSocket().

                                   {
    return std::shared_ptr<AsyncSocket>(
        new AsyncSocket(evb, address, connectTimeout), Destructor());
  }

static std::shared_ptr<AsyncSocket> folly::AsyncSocket::newSocket ( EventBase *  evb, const std::string &  ip, uint16_t  port, uint32_t  connectTimeout = 0  )

inlinestatic

Helper function to create a shared_ptr<AsyncSocket>.

Definition at line 299 of file AsyncSocket.h.

References AsyncSocket().

                                   {
    return std::shared_ptr<AsyncSocket>(
        new AsyncSocket(evb, ip, port, connectTimeout), Destructor());
  }

static std::shared_ptr<AsyncSocket> folly::AsyncSocket::newSocket ( EventBase *  evb, int  fd  )

inlinestatic

Helper function to create a shared_ptr<AsyncSocket>.

Definition at line 311 of file AsyncSocket.h.

References AsyncSocket(), and destroy().

                                                                      {
    return std::shared_ptr<AsyncSocket>(new AsyncSocket(evb, fd), Destructor());
  }

AsyncSocket::ReadResult folly::AsyncSocket::performRead ( void **  buf, size_t *  buflen, size_t *  offset  )

protectedvirtual

Attempt to read from the socket.

Parameters

buf	The buffer to read data into.
buflen	The length of the buffer.

Returns

Returns a read result. See read result for details.

Reimplemented in folly::AsyncSSLSocket.

Definition at line 1764 of file AsyncSocket.cpp.

References appBytesReceived_, folly::IOBufQueue::append(), fd_, folly::IOBufQueue::move(), folly::gen::move, preReceivedData_, folly::io::detail::CursorBase< Derived, BufType >::pullAtMost(), READ_BLOCKING, READ_ERROR, folly::netops::recv(), and folly::IOBufQueue::trimStart().

Referenced by handleRead(), folly::AsyncSSLSocket::performRead(), and scheduleInitialReadWrite().

                                                              {
  VLOG(5) << "AsyncSocket::performRead() this=" << this << ", buf=" << *buf
          << ", buflen=" << *buflen;

  if (preReceivedData_ && !preReceivedData_->empty()) {
    VLOG(5) << "AsyncSocket::performRead() this=" << this
            << ", reading pre-received data";

    io::Cursor cursor(preReceivedData_.get());
    auto len = cursor.pullAtMost(*buf, *buflen);

    IOBufQueue queue;
    queue.append(std::move(preReceivedData_));
    queue.trimStart(len);
    preReceivedData_ = queue.move();

    appBytesReceived_ += len;
    return ReadResult(len);
  }

  ssize_t bytes = recv(fd_, *buf, *buflen, MSG_DONTWAIT);
  if (bytes < 0) {
    if (errno == EAGAIN || errno == EWOULDBLOCK) {
      // No more data to read right now.
      return ReadResult(READ_BLOCKING);
    } else {
      return ReadResult(READ_ERROR);
    }
  } else {
    appBytesReceived_ += bytes;
    return ReadResult(bytes);
  }
}

AsyncSocket::WriteResult folly::AsyncSocket::performWrite ( const iovec *  vec, uint32_t  count, WriteFlags  flags, uint32_t *  countWritten, uint32_t *  partialWritten  )

protectedvirtual

Attempt to write to the socket.

Parameters

vec	The iovec array pointing to the buffers to write.
count	The length of the iovec array.
flags	Set of write flags.
countWritten	On return, the value pointed to by this parameter will contain the number of iovec entries that were fully written.
partialWritten	On return, the value pointed to by this parameter will contain the number of bytes written in the partially written iovec entry.

Returns

Returns a WriteResult. See WriteResult for more details.

Reimplemented in folly::AsyncSSLSocket.

Definition at line 2387 of file AsyncSocket.cpp.

References appBytesWritten_, count, fd_, folly::AsyncSocket::SendMsgParamsCallback::getAncillaryData(), folly::AsyncSocket::SendMsgParamsCallback::getAncillaryDataSize(), folly::AsyncSocket::SendMsgParamsCallback::getFlags(), folly::kIovMax, folly::AsyncSocket::SendMsgParamsCallback::maxAncillaryDataSize, sendMsgParamCallback_, sendSocketMessage(), uint32_t, zeroCopyEnabled_, zeroCopyReenableCounter_, and zeroCopyReenableThreshold_.

Referenced by folly::AsyncSocket::BytesWriteRequest::performWrite(), folly::AsyncSSLSocket::performWrite(), scheduleInitialReadWrite(), folly::AsyncSocket::WriteRequest::start(), and writeImpl().

                              {
  // We use sendmsg() instead of writev() so that we can pass in MSG_NOSIGNAL
  // We correctly handle EPIPE errors, so we never want to receive SIGPIPE
  // (since it may terminate the program if the main program doesn't explicitly
  // ignore it).
  struct msghdr msg;
  msg.msg_name = nullptr;
  msg.msg_namelen = 0;
  msg.msg_iov = const_cast<iovec*>(vec);
  msg.msg_iovlen = std::min<size_t>(count, kIovMax);
  msg.msg_flags = 0;
  msg.msg_controllen = sendMsgParamCallback_->getAncillaryDataSize(flags);
  CHECK_GE(
      AsyncSocket::SendMsgParamsCallback::maxAncillaryDataSize,
      msg.msg_controllen);

  if (msg.msg_controllen != 0) {
    msg.msg_control = reinterpret_cast<char*>(alloca(msg.msg_controllen));
    sendMsgParamCallback_->getAncillaryData(flags, msg.msg_control);
  } else {
    msg.msg_control = nullptr;
  }
  int msg_flags = sendMsgParamCallback_->getFlags(flags, zeroCopyEnabled_);

  auto writeResult = sendSocketMessage(fd_, &msg, msg_flags);
  auto totalWritten = writeResult.writeReturn;
  if (totalWritten < 0 && zeroCopyEnabled_ && errno == ENOBUFS) {
    // workaround for running with zerocopy enabled but without a big enough
    // memlock value - see ulimit -l
    zeroCopyEnabled_ = false;
    zeroCopyReenableCounter_ = zeroCopyReenableThreshold_;
    msg_flags = sendMsgParamCallback_->getFlags(flags, zeroCopyEnabled_);
    writeResult = sendSocketMessage(fd_, &msg, msg_flags);
    totalWritten = writeResult.writeReturn;
  }
  if (totalWritten < 0) {
    bool tryAgain = (errno == EAGAIN);
#ifdef __APPLE__
    // Apple has a bug where doing a second write on a socket which we
    // have opened with TFO causes an ENOTCONN to be thrown. However the
    // socket is really connected, so treat ENOTCONN as a EAGAIN until
    // this bug is fixed.
    tryAgain |= (errno == ENOTCONN);
#endif

    if (!writeResult.exception && tryAgain) {
      // TCP buffer is full; we can't write any more data right now.
      *countWritten = 0;
      *partialWritten = 0;
      return WriteResult(0);
    }
    // error
    *countWritten = 0;
    *partialWritten = 0;
    return writeResult;
  }

  appBytesWritten_ += totalWritten;

  uint32_t bytesWritten;
  uint32_t n;
  for (bytesWritten = uint32_t(totalWritten), n = 0; n < count; ++n) {
    const iovec* v = vec + n;
    if (v->iov_len > bytesWritten) {
      // Partial write finished in the middle of this iovec
      *countWritten = n;
      *partialWritten = bytesWritten;
      return WriteResult(totalWritten);
    }

    bytesWritten -= uint32_t(v->iov_len);
  }

  assert(bytesWritten == 0);
  *countWritten = n;
  *partialWritten = 0;
  return WriteResult(totalWritten);
}

void folly::AsyncSocket::prepareReadBuffer ( void **  buf, size_t *  buflen  )

protectedvirtual

Reimplemented in folly::AsyncSSLSocket.

Definition at line 1798 of file AsyncSocket.cpp.

References folly::AsyncReader::ReadCallback::getReadBuffer(), and readCallback_.

Referenced by handleRead(), and scheduleInitialReadWrite().

                                                              {
  // no matter what, buffer should be preapared for non-ssl socket
  CHECK(readCallback_);
  readCallback_->getReadBuffer(buf, buflen);
}

void folly::AsyncSocket::processZeroCopyMsg ( const cmsghdr &  cmsg )

protected

Definition at line 981 of file AsyncSocket.cpp.

References fd_, i, releaseZeroCopyBuf(), SO_EE_CODE_ZEROCOPY_COPIED, uint32_t, and zeroCopyEnabled_.

Referenced by handleErrMessages(), and scheduleInitialReadWrite().

                                                        {
#ifdef FOLLY_HAVE_MSG_ERRQUEUE
  const struct sock_extended_err* serr =
      reinterpret_cast<const struct sock_extended_err*>(CMSG_DATA(&cmsg));
  uint32_t hi = serr->ee_data;
  uint32_t lo = serr->ee_info;
  // disable zero copy if the buffer was actually copied
  if ((serr->ee_code & SO_EE_CODE_ZEROCOPY_COPIED) && zeroCopyEnabled_) {
    VLOG(2) << "AsyncSocket::processZeroCopyMsg(): setting "
            << "zeroCopyEnabled_ = false due to SO_EE_CODE_ZEROCOPY_COPIED "
            << "on " << fd_;
    zeroCopyEnabled_ = false;
  }

  for (uint32_t i = lo; i <= hi; i++) {
    releaseZeroCopyBuf(i);
  }
#else
  (void)cmsg;
#endif
}

bool folly::AsyncSocket::processZeroCopyWriteInProgress ( )

noexcept

Tries to process the msg error queue And returns true if there are no more zero copy writes in progress

Definition at line 1870 of file AsyncSocket.cpp.

References folly::EventBase::dcheckIsInEventBaseThread(), eventBase_, handleErrMessages(), and idZeroCopyBufPtrMap_.

Referenced by setEvbChangedCallback().

                                                          {
  eventBase_->dcheckIsInEventBaseThread();
  if (idZeroCopyBufPtrMap_.empty()) {
    return true;
  }

  handleErrMessages();

  return idZeroCopyBufPtrMap_.empty();
}

bool folly::AsyncSocket::readable ( ) const

overridevirtual

Determine if the transport is readable or not.

Returns

true iff the transport is readable, false otherwise.

Implements folly::AsyncTransport.

Definition at line 1443 of file AsyncSocket.cpp.

References fd_, and folly::netops::poll().

Referenced by folly::test::MockAsyncSocket::connect(), folly::test::MockAsyncSSLSocket::connect(), and writeRequestReady().

                                 {
  if (fd_ == -1) {
    return false;
  }
  struct pollfd fds[1];
  fds[0].fd = fd_;
  fds[0].events = POLLIN;
  fds[0].revents = 0;
  int rc = poll(fds, 1, 0);
  return rc == 1;
}

void folly::AsyncSocket::registerForConnectEvents ( )

protected

Definition at line 630 of file AsyncSocket.cpp.

References eventFlags_, folly::AsyncSocketException::INTERNAL_ERROR, ioHandler_, folly::EventHandler::NONE, folly::EventHandler::registerHandler(), withAddr(), and folly::EventHandler::WRITE.

Referenced by scheduleInitialReadWrite(), sendSocketMessage(), and socketConnect().

                                           {
  // Register for write events, so we'll
  // be notified when the connection finishes/fails.
  // Note that we don't register for a persistent event here.
  assert(eventFlags_ == EventHandler::NONE);
  eventFlags_ = EventHandler::WRITE;
  if (!ioHandler_.registerHandler(eventFlags_)) {
    throw AsyncSocketException(
        AsyncSocketException::INTERNAL_ERROR,
        withAddr("failed to register AsyncSocket connect handler"));
  }
}

void folly::AsyncSocket::releaseZeroCopyBuf ( uint32_t  id )

protected

Definition at line 942 of file AsyncSocket.cpp.

References idZeroCopyBufInfoMap_, idZeroCopyBufPtrMap_, and ptr.

Referenced by getNextZeroCopyBufId(), and processZeroCopyMsg().

                                                {
  auto iter = idZeroCopyBufPtrMap_.find(id);
  CHECK(iter != idZeroCopyBufPtrMap_.end());
  auto ptr = iter->second;
  auto iter1 = idZeroCopyBufInfoMap_.find(ptr);
  CHECK(iter1 != idZeroCopyBufInfoMap_.end());
  if (0 == --iter1->second.count_) {
    idZeroCopyBufInfoMap_.erase(iter1);
  }

  idZeroCopyBufPtrMap_.erase(iter);
}

void folly::AsyncSocket::scheduleConnectTimeout ( )

protectedvirtual

Reimplemented in folly::AsyncSSLSocket.

Definition at line 617 of file AsyncSocket.cpp.

References connectTimeout_, folly::AsyncSocketException::INTERNAL_ERROR, folly::AsyncTimeout::scheduleTimeout(), folly::detail::timeout, uint32_t, withAddr(), and writeTimeout_.

Referenced by folly::AsyncSSLSocket::scheduleConnectTimeout(), scheduleInitialReadWrite(), sendSocketMessage(), and socketConnect().

                                         {
  // Connection in progress.
  auto timeout = connectTimeout_.count();
  if (timeout > 0) {
    // Start a timer in case the connection takes too long.
    if (!writeTimeout_.scheduleTimeout(uint32_t(timeout))) {
      throw AsyncSocketException(
          AsyncSocketException::INTERNAL_ERROR,
          withAddr("failed to schedule AsyncSocket connect timeout"));
    }
  }
}

void folly::AsyncSocket::scheduleImmediateRead ( )

inlineprotectednoexcept

Schedule checkForImmediateRead to be executed in the next loop iteration.

Definition at line 1031 of file AsyncSocket.h.

References eventBase_, good(), immediateReadHandler_, and folly::EventBase::runInLoop().

Referenced by handleRead().

                                        {
    if (good()) {
      eventBase_->runInLoop(&immediateReadHandler_);
    }
  }

void folly::AsyncSocket::scheduleInitialReadWrite ( )

inlineprotectednoexcept

Schedule handleInitalReadWrite to run in the next iteration.

Definition at line 1040 of file AsyncSocket.h.

References addr, cacheLocalAddress(), cachePeerAddress(), checkForImmediateRead(), doClose(), eventBase_, fail(), failAllWrites(), failConnect(), failErrMessageRead(), failRead(), failWrite(), finishFail(), good(), handleConnect(), handleErrMessages(), handleInitialReadWrite(), handleRead(), handleWrite(), invalidState(), invokeAllErrors(), invokeConnectErr(), invokeConnectSuccess(), ioReady(), isZeroCopyMsg(), isZeroCopyRequest(), folly::pushmi::__adl::noexcept(), folly::NONE, performRead(), performWrite(), prepareReadBuffer(), processZeroCopyMsg(), registerForConnectEvents(), folly::EventBase::runInLoop(), s, scheduleConnectTimeout(), sendSocketMessage(), socketConnect(), startFail(), string, tfoSendMsg(), timeoutExpired(), uint16_t, uint32_t, updateEventRegistration(), withAddr(), writeChainImpl(), and writeImpl().

Referenced by sendSocketMessage().

                                           {
    if (good()) {
      DestructorGuard dg(this);
      eventBase_->runInLoop([this, dg] {
        if (good()) {
          handleInitialReadWrite();
        }
      });
    }
  }

AsyncSocket::WriteResult folly::AsyncSocket::sendSocketMessage ( int  fd, struct msghdr *  msg, int  msg_flags  )

protected

Sends the message over the socket using sendmsg

Parameters

msg	Message to send
msg_flags	Flags to pass to sendmsg

Definition at line 2321 of file AsyncSocket.cpp.

References addr, addr_, CONNECTING, ESTABLISHED, FAST_OPEN, fd_, folly::SocketAddress::getAddress(), registerForConnectEvents(), scheduleConnectTimeout(), scheduleInitialReadWrite(), folly::netops::sendmsg(), socketConnect(), state_, tfoFinished_, tfoSendMsg(), folly::AsyncSocketException::UNKNOWN, and WRITE_ERROR.

Referenced by performWrite(), and scheduleInitialReadWrite().

                                                                        {
  ssize_t totalWritten = 0;
  if (state_ == StateEnum::FAST_OPEN) {
    sockaddr_storage addr;
    auto len = addr_.getAddress(&addr);
    msg->msg_name = &addr;
    msg->msg_namelen = len;
    totalWritten = tfoSendMsg(fd_, msg, msg_flags);
    if (totalWritten >= 0) {
      tfoFinished_ = true;
      state_ = StateEnum::ESTABLISHED;
      // We schedule this asynchrously so that we don't end up
      // invoking initial read or write while a write is in progress.
      scheduleInitialReadWrite();
    } else if (errno == EINPROGRESS) {
      VLOG(4) << "TFO falling back to connecting";
      // A normal sendmsg doesn't return EINPROGRESS, however
      // TFO might fallback to connecting if there is no
      // cookie.
      state_ = StateEnum::CONNECTING;
      try {
        scheduleConnectTimeout();
        registerForConnectEvents();
      } catch (const AsyncSocketException& ex) {
        return WriteResult(
            WRITE_ERROR, std::make_unique<AsyncSocketException>(ex));
      }
      // Let's fake it that no bytes were written and return an errno.
      errno = EAGAIN;
      totalWritten = -1;
    } else if (errno == EOPNOTSUPP) {
      // Try falling back to connecting.
      VLOG(4) << "TFO not supported";
      state_ = StateEnum::CONNECTING;
      try {
        int ret = socketConnect((const sockaddr*)&addr, len);
        if (ret == 0) {
          // connect succeeded immediately
          // Treat this like no data was written.
          state_ = StateEnum::ESTABLISHED;
          scheduleInitialReadWrite();
        }
        // If there was no exception during connections,
        // we would return that no bytes were written.
        errno = EAGAIN;
        totalWritten = -1;
      } catch (const AsyncSocketException& ex) {
        return WriteResult(
            WRITE_ERROR, std::make_unique<AsyncSocketException>(ex));
      }
    } else if (errno == EAGAIN) {
      // Normally sendmsg would indicate that the write would block.
      // However in the fast open case, it would indicate that sendmsg
      // fell back to a connect. This is a return code from connect()
      // instead, and is an error condition indicating no fds available.
      return WriteResult(
          WRITE_ERROR,
          std::make_unique<AsyncSocketException>(
              AsyncSocketException::UNKNOWN, "No more free local ports"));
    }
  } else {
    totalWritten = ::sendmsg(fd, msg, msg_flags);
  }
  return WriteResult(totalWritten);
}

void folly::AsyncSocket::setBufferCallback

(

BufferCallback *

cb

)

Definition at line 2829 of file AsyncSocket.cpp.

References bufferCallback_.

Referenced by proxygen::HTTPSession::checkForShutdown(), and proxygen::HTTPUpstreamSession::HTTPUpstreamSession().

                                                      {
  bufferCallback_ = cb;
}

void folly::AsyncSocket::setCloseOnExec

(

)

Set the FD_CLOEXEC flag so that the socket will be closed if the program later forks and execs.

Definition at line 420 of file AsyncSocket.cpp.

References fd_, folly::AsyncSocketException::INTERNAL_ERROR, and withAddr().

Referenced by AsyncSocket(), connect(), and getTFOFinished().

                                 {
  int rv = fcntl(fd_, F_SETFD, FD_CLOEXEC);
  if (rv != 0) {
    auto errnoCopy = errno;
    throw AsyncSocketException(
        AsyncSocketException::INTERNAL_ERROR,
        withAddr("failed to set close-on-exec flag"),
        errnoCopy);
  }
}

int folly::AsyncSocket::setCongestionFlavor

(

const std::string &

cname

)

Definition at line 1608 of file AsyncSocket.cpp.

References folly::errnoStr(), fd_, folly::netops::setsockopt(), state_, and TCP_CONGESTION.

Referenced by getTFOFinished().

                                                           {
#ifndef TCP_CONGESTION
#define TCP_CONGESTION 13
#endif

  if (fd_ < 0) {
    VLOG(4) << "AsyncSocket::setCongestionFlavor() called on non-open "
            << "socket " << this << "(state=" << state_ << ")";
    return EINVAL;
  }

  if (setsockopt(
          fd_,
          IPPROTO_TCP,
          TCP_CONGESTION,
          cname.c_str(),
          socklen_t(cname.length() + 1)) != 0) {
    int errnoCopy = errno;
    VLOG(2) << "failed to update TCP_CONGESTION option on AsyncSocket " << this
            << "(fd=" << fd_ << ", state=" << state_
            << "): " << errnoStr(errnoCopy);
    return errnoCopy;
  }

  return 0;
}

void folly::AsyncSocket::setEorTracking ( bool  track )

inlineoverridevirtual

Implements folly::AsyncTransport.

Reimplemented in folly::AsyncSSLSocket.

Definition at line 563 of file AsyncSocket.h.

References trackEor_.

Referenced by folly::AsyncSSLSocket::setEorTracking().

                                           {
    trackEor_ = track;
  }

void folly::AsyncSocket::setErrMessageCB ( ErrMessageCallback *  callback )

virtual

Set a pointer to ErrMessageCallback implementation which will be receiving notifications for messages posted to the error queue associated with the socket. ErrMessageCallback is implemented only for platforms with per-socket error message queus support (recvmsg() system call must )

Definition at line 691 of file AsyncSocket.cpp.

References cacheLocalAddress(), CLOSED, CONNECTING, folly::EventBase::dcheckIsInEventBaseThread(), errMessageCallback_, ERROR, ESTABLISHED, eventBase_, FAST_OPEN, fd_, folly::SocketAddress::getFamily(), invalidState(), localAddr_, state_, and UNINIT.

Referenced by folly::test::MockAsyncSocket::connect(), and getMaxReadsPerEvent().

                                                              {
  VLOG(6) << "AsyncSocket::setErrMessageCB() this=" << this << ", fd=" << fd_
          << ", callback=" << callback << ", state=" << state_;

  // In the latest stable kernel 4.14.3 as of 2017-12-04, unix domain
  // socket does not support MSG_ERRQUEUE. So recvmsg(MSG_ERRQUEUE)
  // will read application data from unix doamin socket as error
  // message, which breaks the message flow in application.  Feel free
  // to remove the next code block if MSG_ERRQUEUE is added for unix
  // domain socket in the future.
  if (callback != nullptr) {
    cacheLocalAddress();
    if (localAddr_.getFamily() == AF_UNIX) {
      LOG(ERROR) << "Failed to set ErrMessageCallback=" << callback
                 << " for Unix Doamin Socket where MSG_ERRQUEUE is unsupported,"
                 << " fd=" << fd_;
      return;
    }
  }

  // Short circuit if callback is the same as the existing errMessageCallback_.
  if (callback == errMessageCallback_) {
    return;
  }

  if (!msgErrQueueSupported) {
    // Per-socket error message queue is not supported on this platform.
    return invalidState(callback);
  }

  DestructorGuard dg(this);
  eventBase_->dcheckIsInEventBaseThread();

  if (callback == nullptr) {
    // We should be able to reset the callback regardless of the
    // socket state. It's important to have a reliable callback
    // cancellation mechanism.
    errMessageCallback_ = callback;
    return;
  }

  switch ((StateEnum)state_) {
    case StateEnum::CONNECTING:
    case StateEnum::FAST_OPEN:
    case StateEnum::ESTABLISHED: {
      errMessageCallback_ = callback;
      return;
    }
    case StateEnum::CLOSED:
    case StateEnum::ERROR:
      // We should never reach here.  SHUT_READ should always be set
      // if we are in STATE_CLOSED or STATE_ERROR.
      assert(false);
      return invalidState(callback);
    case StateEnum::UNINIT:
      // We do not allow setReadCallback() to be called before we start
      // connecting.
      return invalidState(callback);
  }

  // We don't put a default case in the switch statement, so that the compiler
  // will warn us to update the switch statement if a new state is added.
  return invalidState(callback);
}

void folly::AsyncSocket::setEvbChangedCallback ( std::unique_ptr< EvbChangeCallback >  cb )

inline

Definition at line 810 of file AsyncSocket.h.

References cacheAddresses(), evbChangeCb_, isZeroCopyWriteInProgress(), folly::gen::move, folly::pushmi::__adl::noexcept(), and processZeroCopyWriteInProgress().

                                                                  {
    evbChangeCb_ = std::move(cb);
  }

void folly::AsyncSocket::setMaxReadsPerEvent ( uint16_t  maxReads )

inline

Set the maximum number of reads to execute from the underlying socket each time the EventBase detects that new ingress data is available. The default is unlimited, but callers can use this method to limit the amount of data read from the socket per event loop iteration.

Parameters

maxReads

Maximum number of reads per data-available event; a value of zero means unlimited.

Definition at line 451 of file AsyncSocket.h.

References maxReadsPerEvent_.

Referenced by wangle::Acceptor::connectionReady(), and TEST().

                                              {
    maxReadsPerEvent_ = maxReads;
  }

int folly::AsyncSocket::setNoDelay

(

bool

noDelay

)

Force writes to be transmitted immediately.

This controls the TCP_NODELAY socket option. When enabled, TCP segments are sent as soon as possible, even if it is not a full frame of data. When disabled, the data may be buffered briefly to try and wait for a full frame of data.

By default, TCP_NODELAY is enabled for AsyncSocket objects.

This method will fail if the socket is not currently open.

Returns

Returns 0 if the TCP_NODELAY flag was successfully updated, or a non-zero errno value on error.

Definition at line 1589 of file AsyncSocket.cpp.

References folly::errnoStr(), fd_, folly::netops::setsockopt(), state_, and folly::value().

Referenced by connect(), and getTFOFinished().

                                        {
  if (fd_ < 0) {
    VLOG(4) << "AsyncSocket::setNoDelay() called on non-open socket " << this
            << "(state=" << state_ << ")";
    return EINVAL;
  }

  int value = noDelay ? 1 : 0;
  if (setsockopt(fd_, IPPROTO_TCP, TCP_NODELAY, &value, sizeof(value)) != 0) {
    int errnoCopy = errno;
    VLOG(2) << "failed to update TCP_NODELAY option on AsyncSocket " << this
            << " (fd=" << fd_ << ", state=" << state_
            << "): " << errnoStr(errnoCopy);
    return errnoCopy;
  }

  return 0;
}

void folly::AsyncSocket::setPeerCertificate ( std::unique_ptr< const AsyncTransportCertificate >  cert )

inline

Definition at line 833 of file AsyncSocket.h.

References folly::gen::move, and peerCertData_.

                                                           {
    peerCertData_ = std::move(cert);
  }

virtual void folly::AsyncSocket::setPreReceivedData ( std::unique_ptr< IOBuf >  data )

inlinevirtual

Set pre-received data, to be returned to read callback before any data from the socket.

Reimplemented in folly::test::MockAsyncSocket.

Definition at line 770 of file AsyncSocket.h.

References folly::gen::move, and preReceivedData_.

Referenced by wangle::SocketPeeker::readDataAvailable().

                                                             {
    if (preReceivedData_) {
      preReceivedData_->prependChain(std::move(data));
    } else {
      preReceivedData_ = std::move(data);
    }
  }

int folly::AsyncSocket::setQuickAck

(

bool

quickack

)

Definition at line 1635 of file AsyncSocket.cpp.

References folly::errnoStr(), fd_, folly::netops::setsockopt(), state_, and folly::value().

Referenced by getTFOFinished().

                                          {
  (void)quickack;
  if (fd_ < 0) {
    VLOG(4) << "AsyncSocket::setQuickAck() called on non-open socket " << this
            << "(state=" << state_ << ")";
    return EINVAL;
  }

#ifdef TCP_QUICKACK // Linux-only
  int value = quickack ? 1 : 0;
  if (setsockopt(fd_, IPPROTO_TCP, TCP_QUICKACK, &value, sizeof(value)) != 0) {
    int errnoCopy = errno;
    VLOG(2) << "failed to update TCP_QUICKACK option on AsyncSocket" << this
            << "(fd=" << fd_ << ", state=" << state_
            << "): " << errnoStr(errnoCopy);
    return errnoCopy;
  }

  return 0;
#else
  return ENOSYS;
#endif
}

void folly::AsyncSocket::setReadCB ( ReadCallback *  callback )

overridevirtual

Implements folly::AsyncTransportWrapper.

Reimplemented in folly::AsyncSSLSocket.

Definition at line 768 of file AsyncSocket.cpp.

References folly::EventBase::LoopCallback::cancelLoopCallback(), checkForImmediateRead(), CLOSED, CONNECTING, folly::EventBase::dcheckIsInEventBaseThread(), ERROR, ESTABLISHED, eventBase_, eventFlags_, FAST_OPEN, fd_, immediateReadHandler_, invalidState(), folly::EventBase::LoopCallback::isLoopCallbackScheduled(), folly::EventHandler::READ, readCallback_, SHUT_READ, shutdownFlags_, state_, uint16_t, UNINIT, and updateEventRegistration().

Referenced by folly::test::MockAsyncSocket::connect(), getMaxReadsPerEvent(), wangle::SocketPeeker::readDataAvailable(), wangle::SocketPeeker::readErr(), folly::AsyncSSLSocket::setReadCB(), wangle::SocketPeeker::start(), TEST(), testConnectOptWrite(), tmpDisableReads(), and wangle::SocketPeeker::~SocketPeeker().

                                                  {
  VLOG(6) << "AsyncSocket::setReadCallback() this=" << this << ", fd=" << fd_
          << ", callback=" << callback << ", state=" << state_;

  // Short circuit if callback is the same as the existing readCallback_.
  //
  // Note that this is needed for proper functioning during some cleanup cases.
  // During cleanup we allow setReadCallback(nullptr) to be called even if the
  // read callback is already unset and we have been detached from an event
  // base.  This check prevents us from asserting
  // eventBase_->isInEventBaseThread() when eventBase_ is nullptr.
  if (callback == readCallback_) {
    return;
  }

  /* We are removing a read callback */
  if (callback == nullptr && immediateReadHandler_.isLoopCallbackScheduled()) {
    immediateReadHandler_.cancelLoopCallback();
  }

  if (shutdownFlags_ & SHUT_READ) {
    // Reads have already been shut down on this socket.
    //
    // Allow setReadCallback(nullptr) to be called in this case, but don't
    // allow a new callback to be set.
    //
    // For example, setReadCallback(nullptr) can happen after an error if we
    // invoke some other error callback before invoking readError().  The other
    // error callback that is invoked first may go ahead and clear the read
    // callback before we get a chance to invoke readError().
    if (callback != nullptr) {
      return invalidState(callback);
    }
    assert((eventFlags_ & EventHandler::READ) == 0);
    readCallback_ = nullptr;
    return;
  }

  DestructorGuard dg(this);
  eventBase_->dcheckIsInEventBaseThread();

  switch ((StateEnum)state_) {
    case StateEnum::CONNECTING:
    case StateEnum::FAST_OPEN:
      // For convenience, we allow the read callback to be set while we are
      // still connecting.  We just store the callback for now.  Once the
      // connection completes we'll register for read events.
      readCallback_ = callback;
      return;
    case StateEnum::ESTABLISHED: {
      readCallback_ = callback;
      uint16_t oldFlags = eventFlags_;
      if (readCallback_) {
        eventFlags_ |= EventHandler::READ;
      } else {
        eventFlags_ &= ~EventHandler::READ;
      }

      // Update our registration if our flags have changed
      if (eventFlags_ != oldFlags) {
        // We intentionally ignore the return value here.
        // updateEventRegistration() will move us into the error state if it
        // fails, and we don't need to do anything else here afterwards.
        (void)updateEventRegistration();
      }

      if (readCallback_) {
        checkForImmediateRead();
      }
      return;
    }
    case StateEnum::CLOSED:
    case StateEnum::ERROR:
      // We should never reach here.  SHUT_READ should always be set
      // if we are in STATE_CLOSED or STATE_ERROR.
      assert(false);
      return invalidState(callback);
    case StateEnum::UNINIT:
      // We do not allow setReadCallback() to be called before we start
      // connecting.
      return invalidState(callback);
  }

  // We don't put a default case in the switch statement, so that the compiler
  // will warn us to update the switch statement if a new state is added.
  return invalidState(callback);
}

int folly::AsyncSocket::setRecvBufSize

(

size_t

bufsize

)

Set the recv bufsize

Definition at line 1677 of file AsyncSocket.cpp.

References folly::errnoStr(), fd_, folly::netops::setsockopt(), and state_.

Referenced by getTFOFinished().

                                              {
  if (fd_ < 0) {
    VLOG(4) << "AsyncSocket::setRecvBufSize() called on non-open socket "
            << this << "(state=" << state_ << ")";
    return EINVAL;
  }

  if (setsockopt(fd_, SOL_SOCKET, SO_RCVBUF, &bufsize, sizeof(bufsize)) != 0) {
    int errnoCopy = errno;
    VLOG(2) << "failed to update SO_RCVBUF option on AsyncSocket" << this
            << "(fd=" << fd_ << ", state=" << state_
            << "): " << errnoStr(errnoCopy);
    return errnoCopy;
  }

  return 0;
}

void folly::AsyncSocket::setSelfCertificate ( std::unique_ptr< const AsyncTransportCertificate >  cert )

inline

Definition at line 841 of file AsyncSocket.h.

References folly::gen::move, and selfCertData_.

                                                           {
    selfCertData_ = std::move(cert);
  }

int folly::AsyncSocket::setSendBufSize

(

size_t

bufsize

)

Set the send bufsize

Definition at line 1659 of file AsyncSocket.cpp.

References folly::errnoStr(), fd_, folly::netops::setsockopt(), and state_.

Referenced by getTFOFinished().

                                              {
  if (fd_ < 0) {
    VLOG(4) << "AsyncSocket::setSendBufSize() called on non-open socket "
            << this << "(state=" << state_ << ")";
    return EINVAL;
  }

  if (setsockopt(fd_, SOL_SOCKET, SO_SNDBUF, &bufsize, sizeof(bufsize)) != 0) {
    int errnoCopy = errno;
    VLOG(2) << "failed to update SO_SNDBUF option on AsyncSocket" << this
            << "(fd=" << fd_ << ", state=" << state_
            << "): " << errnoStr(errnoCopy);
    return errnoCopy;
  }

  return 0;
}

void folly::AsyncSocket::setSendMsgParamCB ( SendMsgParamsCallback *  callback )

virtual

Set a pointer to SendMsgParamsCallback implementation which will be used to form sendmsg() system call parameters

Definition at line 760 of file AsyncSocket.cpp.

References sendMsgParamCallback_.

Referenced by folly::test::MockAsyncSocket::connect(), and getMaxReadsPerEvent().

                                                                   {
  sendMsgParamCallback_ = callback;
}

void folly::AsyncSocket::setSendTimeout ( uint32_t  milliseconds )

overridevirtual

Set the send timeout.

If write requests do not make any progress for more than the specified number of milliseconds, fail all pending writes and close the socket.

If write requests are currently pending when setSendTimeout() is called, the timeout interval is immediately restarted using the new value.

(See the comments for AsyncSocket for an explanation of why AsyncSocket provides setSendTimeout() but not setRecvTimeout().)

Parameters

milliseconds

The timeout duration, in milliseconds. If 0, no timeout will be used.

Implements folly::AsyncTransport.

Definition at line 666 of file AsyncSocket.cpp.

References folly::AsyncTimeout::cancelTimeout(), CONNECTING, folly::EventBase::dcheckIsInEventBaseThread(), ESTABLISHED, eventBase_, eventFlags_, failWrite(), FAST_OPEN, folly::AsyncSocketException::INTERNAL_ERROR, folly::AsyncTimeout::scheduleTimeout(), sendTimeout_, SHUT_WRITE, shutdownFlags_, state_, withAddr(), folly::EventHandler::WRITE, and writeTimeout_.

                                                      {
  sendTimeout_ = milliseconds;
  if (eventBase_) {
    eventBase_->dcheckIsInEventBaseThread();
  }

  // If we are currently pending on write requests, immediately update
  // writeTimeout_ with the new value.
  if ((eventFlags_ & EventHandler::WRITE) &&
      (state_ != StateEnum::CONNECTING && state_ != StateEnum::FAST_OPEN)) {
    assert(state_ == StateEnum::ESTABLISHED);
    assert((shutdownFlags_ & SHUT_WRITE) == 0);
    if (sendTimeout_ > 0) {
      if (!writeTimeout_.scheduleTimeout(sendTimeout_)) {
        AsyncSocketException ex(
            AsyncSocketException::INTERNAL_ERROR,
            withAddr("failed to reschedule send timeout in setSendTimeout"));
        return failWrite(__func__, ex);
      }
    } else {
      writeTimeout_.cancelTimeout();
    }
  }
}

void folly::AsyncSocket::setShutdownSocketSet

(

const std::weak_ptr< ShutdownSocketSet > &

wSS

)

Definition at line 400 of file AsyncSocket.cpp.

References fd_, folly::ShutdownSocketSet::remove(), folly::test::shutdownSocketSet, and wShutdownSocketSet_.

Referenced by folly::AsyncSocket::SendMsgParamsCallback::getFlagsImpl().

                                                  {
  const auto newSS = wNewSS.lock();
  const auto shutdownSocketSet = wShutdownSocketSet_.lock();

  if (newSS == shutdownSocketSet) {
    return;
  }

  if (shutdownSocketSet && fd_ != -1) {
    shutdownSocketSet->remove(fd_);
  }

  if (newSS && fd_ != -1) {
    newSS->add(fd_);
  }

  wShutdownSocketSet_ = wNewSS;
}

template<typename T >

int folly::AsyncSocket::setSockOpt ( int  level, int  optname, const T *  optval  )

inline

Generic API for setting a socket option.

Parameters

level	same as the "level" parameter in getsockopt().
optname	same as the "optname" parameter in getsockopt().
optval	the option value to set.

Returns

same as the return value of setsockopt().

Definition at line 727 of file AsyncSocket.h.

References fd_, folly::netops::setsockopt(), and folly::T.

Referenced by closeWithReset().

                                                          {
    return setsockopt(fd_, level, optname, optval, sizeof(T));
  }

virtual int folly::AsyncSocket::setSockOptVirtual ( int  level, int  optname, void const *  optval, socklen_t  optlen  )

inlinevirtual

Virtual method for setting a socket option accepting integer value, which is the most typical case. Convenient for overriding and mocking.

Parameters

level	same as the "level" parameter in setsockopt().
optname	same as the "optname" parameter in setsockopt().
optval	same as "optval" parameter in setsockopt().
optlen	same as "optlen" parameter in setsockopt().

Returns

same as the return value of setsockopt().

Definition at line 758 of file AsyncSocket.h.

References fd_, and folly::netops::setsockopt().

Referenced by folly::test::MockAsyncSocket::connect().

                        {
    return setsockopt(fd_, level, optname, optval, optlen);
  }

int folly::AsyncSocket::setTCPProfile

(

int

profd

)

Definition at line 1695 of file AsyncSocket.cpp.

References folly::errnoStr(), fd_, folly::netops::setsockopt(), SO_SET_NAMESPACE, and state_.

                                        {
  if (fd_ < 0) {
    VLOG(4) << "AsyncSocket::setTCPProfile() called on non-open socket " << this
            << "(state=" << state_ << ")";
    return EINVAL;
  }

  if (setsockopt(fd_, SOL_SOCKET, SO_SET_NAMESPACE, &profd, sizeof(int)) != 0) {
    int errnoCopy = errno;
    VLOG(2) << "failed to set socket namespace option on AsyncSocket" << this
            << "(fd=" << fd_ << ", state=" << state_
            << "): " << errnoStr(errnoCopy);
    return errnoCopy;
  }

  return 0;
}

bool folly::AsyncSocket::setZeroCopy

(

bool

enable

)

Definition at line 860 of file AsyncSocket.cpp.

References fd_, folly::netops::getsockopt(), folly::netops::setsockopt(), SO_ZEROCOPY, val, zeroCopyEnabled_, and zeroCopyVal_.

Referenced by connect(), and getMaxReadsPerEvent().

                                         {
  if (msgErrQueueSupported) {
    zeroCopyVal_ = enable;

    if (fd_ < 0) {
      return false;
    }

    int val = enable ? 1 : 0;
    int ret = setsockopt(fd_, SOL_SOCKET, SO_ZEROCOPY, &val, sizeof(val));

    // if enable == false, set zeroCopyEnabled_ = false regardless
    // if SO_ZEROCOPY is set or not
    if (!enable) {
      zeroCopyEnabled_ = enable;
      return true;
    }

    /* if the setsockopt failed, try to see if the socket inherited the flag
     * since we cannot set SO_ZEROCOPY on a socket s = accept
     */
    if (ret) {
      val = 0;
      socklen_t optlen = sizeof(val);
      ret = getsockopt(fd_, SOL_SOCKET, SO_ZEROCOPY, &val, &optlen);

      if (!ret) {
        enable = val ? true : false;
      }
    }

    if (!ret) {
      zeroCopyEnabled_ = enable;

      return true;
    }
  }

  return false;
}

void folly::AsyncSocket::setZeroCopyBuf ( std::unique_ptr< folly::IOBuf > &&  buf )

protected

Definition at line 955 of file AsyncSocket.cpp.

References idZeroCopyBufInfoMap_, folly::gen::move, and ptr.

Referenced by getNextZeroCopyBufId(), and folly::AsyncSocket::BytesWriteRequest::performWrite().

                                                                {
  folly::IOBuf* ptr = buf.get();
  auto& p = idZeroCopyBufInfoMap_[ptr];
  CHECK(p.buf_.get() == nullptr);

  p.buf_ = std::move(buf);
}

void folly::AsyncSocket::setZeroCopyReenableThreshold

(

size_t

threshold

)

Definition at line 901 of file AsyncSocket.cpp.

References zeroCopyReenableThreshold_.

Referenced by getZeroCopyReenableThreshold().

                                                               {
  zeroCopyReenableThreshold_ = threshold;
}

void folly::AsyncSocket::shutdownWrite ( )

overridevirtual

Perform a half-shutdown of the write side of the transport.

The caller should not make any more calls to write() or writev() after shutdownWrite() is called. Any future write attempts will fail immediately.

Not all transport types support half-shutdown. If the underlying transport does not support half-shutdown, it will fully shutdown both the read and write sides of the transport. (Fully shutting down the socket is better than doing nothing at all, since the caller may rely on the shutdownWrite() call to notify the other end of the connection that no more data can be read.)

If there is pending data still waiting to be written on the transport, the actual shutdown will be delayed until the pending data has been written.

Note: There is no corresponding shutdownRead() equivalent. Simply uninstall the read callback if you wish to stop reading. (On TCP sockets at least, shutting down the read side of the socket is a no-op anyway.)

Implements folly::AsyncTransport.

Reimplemented in folly::AsyncSSLSocket.

Definition at line 1339 of file AsyncSocket.cpp.

References folly::EventBase::dcheckIsInEventBaseThread(), eventBase_, fd_, SHUT_WRITE_PENDING, shutdownFlags_, shutdownWriteNow(), state_, and writeReqHead_.

Referenced by writeRequestReady().

                                {
  VLOG(5) << "AsyncSocket::shutdownWrite(): this=" << this << ", fd=" << fd_
          << ", state=" << state_ << ", shutdownFlags=" << std::hex
          << (int)shutdownFlags_;

  // If there are no pending writes, shutdownWrite() is identical to
  // shutdownWriteNow().
  if (writeReqHead_ == nullptr) {
    shutdownWriteNow();
    return;
  }

  eventBase_->dcheckIsInEventBaseThread();

  // There are pending writes.  Set SHUT_WRITE_PENDING so that the actual
  // shutdown will be performed once all writes complete.
  shutdownFlags_ |= SHUT_WRITE_PENDING;
}

void folly::AsyncSocket::shutdownWriteNow ( )

overridevirtual

Perform a half-shutdown of the write side of the transport.

shutdownWriteNow() is identical to shutdownWrite(), except that it immediately performs the shutdown, rather than waiting for pending writes to complete. Any pending write requests will be immediately failed when shutdownWriteNow() is called.

Implements folly::AsyncTransport.

Reimplemented in folly::AsyncSSLSocket.

Definition at line 1358 of file AsyncSocket.cpp.

References folly::AsyncTimeout::cancelTimeout(), CLOSED, closeNow(), CONNECTING, folly::EventBase::dcheckIsInEventBaseThread(), folly::DFATAL, ERROR, ESTABLISHED, eventBase_, failAllWrites(), FAST_OPEN, fd_, SHUT_READ, SHUT_WRITE, SHUT_WRITE_PENDING, folly::shutdown(), shutdownFlags_, folly::socketShutdownForWritesEx, state_, UNINIT, updateEventRegistration(), folly::EventHandler::WRITE, and writeTimeout_.

Referenced by shutdownWrite(), and writeRequestReady().

                                   {
  VLOG(5) << "AsyncSocket::shutdownWriteNow(): this=" << this << ", fd=" << fd_
          << ", state=" << state_ << ", shutdownFlags=" << std::hex
          << (int)shutdownFlags_;

  if (shutdownFlags_ & SHUT_WRITE) {
    // Writes are already shutdown; nothing else to do.
    return;
  }

  // If SHUT_READ is already set, just call closeNow() to completely
  // close the socket.  This can happen if close() was called with writes
  // pending, and then shutdownWriteNow() is called before all pending writes
  // complete.
  if (shutdownFlags_ & SHUT_READ) {
    closeNow();
    return;
  }

  DestructorGuard dg(this);
  if (eventBase_) {
    eventBase_->dcheckIsInEventBaseThread();
  }

  switch (static_cast<StateEnum>(state_)) {
    case StateEnum::ESTABLISHED: {
      shutdownFlags_ |= SHUT_WRITE;

      // If the write timeout was set, cancel it.
      writeTimeout_.cancelTimeout();

      // If we are registered for write events, unregister.
      if (!updateEventRegistration(0, EventHandler::WRITE)) {
        // We will have been moved into the error state.
        assert(state_ == StateEnum::ERROR);
        return;
      }

      // Shutdown writes on the file descriptor
      shutdown(fd_, SHUT_WR);

      // Immediately fail all write requests
      failAllWrites(socketShutdownForWritesEx);
      return;
    }
    case StateEnum::CONNECTING: {
      // Set the SHUT_WRITE_PENDING flag.
      // When the connection completes, it will check this flag,
      // shutdown the write half of the socket, and then set SHUT_WRITE.
      shutdownFlags_ |= SHUT_WRITE_PENDING;

      // Immediately fail all write requests
      failAllWrites(socketShutdownForWritesEx);
      return;
    }
    case StateEnum::UNINIT:
      // Callers normally shouldn't call shutdownWriteNow() before the socket
      // even starts connecting.  Nonetheless, go ahead and set
      // SHUT_WRITE_PENDING.  Once the socket eventually connects it will
      // immediately shut down the write side of the socket.
      shutdownFlags_ |= SHUT_WRITE_PENDING;
      return;
    case StateEnum::FAST_OPEN:
      // In fast open state we haven't call connected yet, and if we shutdown
      // the writes, we will never try to call connect, so shut everything down
      shutdownFlags_ |= SHUT_WRITE;
      // Immediately fail all write requests
      failAllWrites(socketShutdownForWritesEx);
      return;
    case StateEnum::CLOSED:
    case StateEnum::ERROR:
      // We should never get here.  SHUT_WRITE should always be set
      // in STATE_CLOSED and STATE_ERROR.
      VLOG(4) << "AsyncSocket::shutdownWriteNow() (this=" << this
              << ", fd=" << fd_ << ") in unexpected state " << state_
              << " with SHUT_WRITE not set (" << std::hex << (int)shutdownFlags_
              << ")";
      assert(false);
      return;
  }

  LOG(DFATAL) << "AsyncSocket::shutdownWriteNow() (this=" << this
              << ", fd=" << fd_ << ") called in unknown state " << state_;
}

int folly::AsyncSocket::socketConnect ( const struct sockaddr *  addr, socklen_t  len  )

protected

Definition at line 600 of file AsyncSocket.cpp.

References folly::netops::connect(), fd_, folly::AsyncSocketException::NOT_OPEN, registerForConnectEvents(), and scheduleConnectTimeout().

Referenced by connect(), scheduleInitialReadWrite(), and sendSocketMessage().

                                                                          {
  int rv = fsp::connect(fd_, saddr, len);
  if (rv < 0) {
    auto errnoCopy = errno;
    if (errnoCopy == EINPROGRESS) {
      scheduleConnectTimeout();
      registerForConnectEvents();
    } else {
      throw AsyncSocketException(
          AsyncSocketException::NOT_OPEN,
          "connect failed (immediately)",
          errnoCopy);
    }
  }
  return rv;
}

void folly::AsyncSocket::startFail ( )

protected

Definition at line 2516 of file AsyncSocket.cpp.

References folly::EventBase::LoopCallback::cancelLoopCallback(), folly::AsyncTimeout::cancelTimeout(), folly::EventHandler::changeHandlerFD(), doClose(), ERROR, eventFlags_, fd_, folly::DelayedDestructionBase::getDestructorGuardCount(), immediateReadHandler_, ioHandler_, folly::EventBase::LoopCallback::isLoopCallbackScheduled(), folly::EventHandler::NONE, SHUT_READ, SHUT_WRITE, shutdownFlags_, state_, folly::EventHandler::unregisterHandler(), and writeTimeout_.

Referenced by fail(), failConnect(), failErrMessageRead(), folly::AsyncSSLSocket::failHandshake(), failRead(), failWrite(), invalidState(), and scheduleInitialReadWrite().

                            {
  // startFail() should only be called once
  assert(state_ != StateEnum::ERROR);
  assert(getDestructorGuardCount() > 0);
  state_ = StateEnum::ERROR;
  // Ensure that SHUT_READ and SHUT_WRITE are set,
  // so all future attempts to read or write will be rejected
  shutdownFlags_ |= (SHUT_READ | SHUT_WRITE);

  // Cancel any scheduled immediate read.
  if (immediateReadHandler_.isLoopCallbackScheduled()) {
    immediateReadHandler_.cancelLoopCallback();
  }

  if (eventFlags_ != EventHandler::NONE) {
    eventFlags_ = EventHandler::NONE;
    ioHandler_.unregisterHandler();
  }
  writeTimeout_.cancelTimeout();

  if (fd_ >= 0) {
    ioHandler_.changeHandlerFD(-1);
    doClose();
  }
}

ssize_t folly::AsyncSocket::tfoSendMsg ( int  fd, struct msghdr *  msg, int  msg_flags  )

protectedvirtual

Definition at line 2316 of file AsyncSocket.cpp.

References folly::detail::tfo_sendmsg().

Referenced by scheduleInitialReadWrite(), and sendSocketMessage().

                                                                         {
  return detail::tfo_sendmsg(fd, msg, msg_flags);
}

void folly::AsyncSocket::timeoutExpired ( )

protectednoexcept

Definition at line 2285 of file AsyncSocket.cpp.

References connectCallback_, CONNECTING, connectTimeout_, folly::EventBase::dcheckIsInEventBaseThread(), eventBase_, eventFlags_, failConnect(), failWrite(), fd_, sendTimeout_, folly::sformat(), state_, and folly::AsyncSocketException::TIMED_OUT.

Referenced by folly::AsyncSSLSocket::getSSLContext(), and scheduleInitialReadWrite().

                                          {
  VLOG(7) << "AsyncSocket " << this << ", fd " << fd_ << ": timeout expired: "
          << "state=" << state_ << ", events=" << std::hex << eventFlags_;
  DestructorGuard dg(this);
  eventBase_->dcheckIsInEventBaseThread();

  if (state_ == StateEnum::CONNECTING) {
    // connect() timed out
    // Unregister for I/O events.
    if (connectCallback_) {
      AsyncSocketException ex(
          AsyncSocketException::TIMED_OUT,
          folly::sformat(
              "connect timed out after {}ms", connectTimeout_.count()));
      failConnect(__func__, ex);
    } else {
      // we faced a connect error without a connect callback, which could
      // happen due to TFO.
      AsyncSocketException ex(
          AsyncSocketException::TIMED_OUT, "write timed out during connection");
      failWrite(__func__, ex);
    }
  } else {
    // a normal write operation timed out
    AsyncSocketException ex(
        AsyncSocketException::TIMED_OUT,
        folly::sformat("write timed out after {}ms", sendTimeout_));
    failWrite(__func__, ex);
  }
}

bool folly::AsyncSocket::updateEventRegistration ( )

protected

Re-register the EventHandler after eventFlags_ has changed.

If an error occurs, fail() is called to move the socket into the error state and call all currently installed callbacks. After an error, the AsyncSocket is completely unregistered.

Returns

Returns true on success, or false on error.

Definition at line 2480 of file AsyncSocket.cpp.

References folly::EventBase::dcheckIsInEventBaseThread(), eventBase_, eventFlags_, fail(), fd_, folly::AsyncSocketException::INTERNAL_ERROR, ioHandler_, folly::EventHandler::NONE, folly::EventHandler::PERSIST, folly::EventHandler::registerHandler(), state_, uint16_t, folly::EventHandler::unregisterHandler(), and withAddr().

Referenced by attachEventBase(), close(), closeNow(), folly::AsyncSSLSocket::handleAccept(), folly::AsyncSSLSocket::handleConnect(), handleInitialReadWrite(), handleRead(), folly::AsyncSSLSocket::handleReturnFromSSLAccept(), handleWrite(), scheduleInitialReadWrite(), setReadCB(), shutdownWriteNow(), folly::AsyncSSLSocket::sslAccept(), updateEventRegistration(), folly::AsyncSSLSocket::willBlock(), and writeImpl().

                                          {
  VLOG(5) << "AsyncSocket::updateEventRegistration(this=" << this
          << ", fd=" << fd_ << ", evb=" << eventBase_ << ", state=" << state_
          << ", events=" << std::hex << eventFlags_;
  eventBase_->dcheckIsInEventBaseThread();
  if (eventFlags_ == EventHandler::NONE) {
    ioHandler_.unregisterHandler();
    return true;
  }

  // Always register for persistent events, so we don't have to re-register
  // after being called back.
  if (!ioHandler_.registerHandler(
          uint16_t(eventFlags_ | EventHandler::PERSIST))) {
    eventFlags_ = EventHandler::NONE; // we're not registered after error
    AsyncSocketException ex(
        AsyncSocketException::INTERNAL_ERROR,
        withAddr("failed to update AsyncSocket event registration"));
    fail("updateEventRegistration", ex);
    return false;
  }

  return true;
}

bool folly::AsyncSocket::updateEventRegistration ( uint16_t  enable, uint16_t  disable  )

protected

Update event registration.

Parameters

enable	Flags of events to enable. Set it to 0 if no events need to be enabled in this call.
disable	Flags of events to disable. Set it to 0 if no events need to be disabled in this call.

Returns

true iff the update is successful.

Definition at line 2505 of file AsyncSocket.cpp.

References eventFlags_, uint16_t, and updateEventRegistration().

                                                                           {
  uint16_t oldFlags = eventFlags_;
  eventFlags_ |= enable;
  eventFlags_ &= ~disable;
  if (eventFlags_ == oldFlags) {
    return true;
  } else {
    return updateEventRegistration();
  }
}

std::string folly::AsyncSocket::withAddr ( const std::string &  s )

protected

Definition at line 2814 of file AsyncSocket.cpp.

References folly::SocketAddress::describe(), folly::AsyncTransport::getLocalAddress(), folly::AsyncTransport::getPeerAddress(), and folly::fibers::local().

Referenced by connect(), finishFail(), handleConnect(), handleErrMessages(), handleRead(), handleWrite(), invalidState(), registerForConnectEvents(), folly::AsyncSSLSocket::scheduleConnectTimeout(), scheduleConnectTimeout(), scheduleInitialReadWrite(), setCloseOnExec(), setSendTimeout(), updateEventRegistration(), and writeImpl().

                                                  {
  // Don't use addr_ directly because it may not be initialized
  // e.g. if constructed from fd
  folly::SocketAddress peer, local;
  try {
    getPeerAddress(&peer);
    getLocalAddress(&local);
  } catch (const std::exception&) {
    // ignore
  } catch (...) {
    // ignore
  }
  return s + " (peer=" + peer.describe() + ", local=" + local.describe() + ")";
}

bool folly::AsyncSocket::writable ( ) const

overridevirtual

Determine if the transport is writable or not.

Returns

true iff the transport is writable, false otherwise.

Reimplemented from folly::AsyncTransport.

Definition at line 1455 of file AsyncSocket.cpp.

References fd_, and folly::netops::poll().

Referenced by writeRequestReady().

                                 {
  if (fd_ == -1) {
    return false;
  }
  struct pollfd fds[1];
  fds[0].fd = fd_;
  fds[0].events = POLLOUT;
  fds[0].revents = 0;
  int rc = poll(fds, 1, 0);
  return rc == 1;
}

void folly::AsyncSocket::write ( WriteCallback *  callback, const void *  buf, size_t  bytes, WriteFlags  flags = WriteFlags::NONE  )

overridevirtual

If you supply a non-null WriteCallback, exactly one of writeSuccess() or writeErr() will be invoked when the write completes. If you supply the same WriteCallback object for multiple write() calls, it will be invoked exactly once per call. The only way to cancel outstanding write requests is to close the socket (e.g., with closeNow() or shutdownWriteNow()). When closing the socket this way, writeErr() will still be invoked once for each outstanding write operation.

Implements folly::AsyncTransportWrapper.

Definition at line 1003 of file AsyncSocket.cpp.

References writeImpl().

Referenced by getZeroCopyReenableThreshold(), and TEST().

                      {
  iovec op;
  op.iov_base = const_cast<void*>(buf);
  op.iov_len = bytes;
  writeImpl(callback, &op, 1, unique_ptr<IOBuf>(), flags);
}

void folly::AsyncSocket::writeChain ( WriteCallback *  callback, std::unique_ptr< folly::IOBuf > &&  buf, WriteFlags  flags = WriteFlags::NONE  )

overridevirtual

If you supply a non-null WriteCallback, exactly one of writeSuccess() or writeErr() will be invoked when the write completes. If you supply the same WriteCallback object for multiple write() calls, it will be invoked exactly once per call. The only way to cancel outstanding write requests is to close the socket (e.g., with closeNow() or shutdownWriteNow()). When closing the socket this way, writeErr() will still be invoked once for each outstanding write operation.

Implements folly::AsyncTransportWrapper.

Definition at line 1022 of file AsyncSocket.cpp.

References adjustZeroCopyFlags(), count, FOLLY_GNU_DISABLE_WARNING, FOLLY_HAVE_VLA_01, FOLLY_POP_WARNING, FOLLY_PUSH_WARNING, folly::gen::move, and writeChainImpl().

Referenced by getZeroCopyReenableThreshold().

                      {
  adjustZeroCopyFlags(flags);

  constexpr size_t kSmallSizeMax = 64;
  size_t count = buf->countChainElements();
  if (count <= kSmallSizeMax) {
    // suppress "warning: variable length array 'vec' is used [-Wvla]"
    FOLLY_PUSH_WARNING
    FOLLY_GNU_DISABLE_WARNING("-Wvla")
    iovec vec[BOOST_PP_IF(FOLLY_HAVE_VLA_01, count, kSmallSizeMax)];
    FOLLY_POP_WARNING

    writeChainImpl(callback, vec, count, std::move(buf), flags);
  } else {
    iovec* vec = new iovec[count];
    writeChainImpl(callback, vec, count, std::move(buf), flags);
    delete[] vec;
  }
}

void folly::AsyncSocket::writeChainImpl ( WriteCallback *  callback, iovec *  vec, size_t  count, std::unique_ptr< folly::IOBuf > &&  buf, WriteFlags  flags  )

protected

Populate an iovec array from an IOBuf and attempt to write it.

Parameters

callback	Write completion/error callback.
vec	Target iovec array; caller retains ownership.
count	Number of IOBufs to write, beginning at start of buf.
buf	Chain of iovecs.
flags	set of flags for the underlying write calls, like cork

Definition at line 1045 of file AsyncSocket.cpp.

References folly::gen::move, and writeImpl().

Referenced by scheduleInitialReadWrite(), and writeChain().

                      {
  size_t veclen = buf->fillIov(vec, count);
  writeImpl(callback, vec, veclen, std::move(buf), flags);
}

void folly::AsyncSocket::writeImpl ( WriteCallback *  callback, const iovec *  vec, size_t  count, std::unique_ptr< folly::IOBuf > &&  buf, WriteFlags  flags = WriteFlags::NONE  )

protected

Write as much data as possible to the socket without blocking, and queue up any leftover data to send when the socket can handle writes again.

Parameters

callback	The callback to invoke when the write is completed.
vec	Array of buffers to write; this method will make a copy of the vector (but not the buffers themselves) if the write has to be completed asynchronously.
count	Number of elements in vec.
buf	The IOBuf that manages the buffers referenced by vec, or a pointer to nullptr if the buffers are not associated with an IOBuf. Note that ownership of the IOBuf is transferred here; upon completion of the write, the AsyncSocket deletes the IOBuf.
flags	Set of write flags.

Definition at line 1055 of file AsyncSocket.cpp.

References addZeroCopyBuf(), folly::AsyncSocket::WriteRequest::append(), bufferCallback_, connecting(), folly::AsyncSocket::WriteRequest::consume(), folly::EventBase::dcheckIsInEventBaseThread(), ERROR, ESTABLISHED, eventBase_, eventFlags_, failWrite(), FAST_OPEN, fd_, folly::AsyncSocketException::INTERNAL_ERROR, invalidState(), isZeroCopyRequest(), folly::gen::move, folly::AsyncSocket::BytesWriteRequest::newRequest(), folly::AsyncTransport::BufferCallback::onEgressBuffered(), performWrite(), folly::AsyncTimeout::scheduleTimeout(), sendTimeout_, SHUT_WRITE, SHUT_WRITE_PENDING, shutdownFlags_, state_, uint32_t, updateEventRegistration(), withAddr(), folly::EventHandler::WRITE, writeReqHead_, writeReqTail_, folly::AsyncWriter::WriteCallback::writeSuccess(), and writeTimeout_.

Referenced by scheduleInitialReadWrite(), write(), writeChainImpl(), and writev().

                      {
  VLOG(6) << "AsyncSocket::writev() this=" << this << ", fd=" << fd_
          << ", callback=" << callback << ", count=" << count
          << ", state=" << state_;
  DestructorGuard dg(this);
  unique_ptr<IOBuf> ioBuf(std::move(buf));
  eventBase_->dcheckIsInEventBaseThread();

  if (shutdownFlags_ & (SHUT_WRITE | SHUT_WRITE_PENDING)) {
    // No new writes may be performed after the write side of the socket has
    // been shutdown.
    //
    // We could just call callback->writeError() here to fail just this write.
    // However, fail hard and use invalidState() to fail all outstanding
    // callbacks and move the socket into the error state.  There's most likely
    // a bug in the caller's code, so we abort everything rather than trying to
    // proceed as best we can.
    return invalidState(callback);
  }

  uint32_t countWritten = 0;
  uint32_t partialWritten = 0;
  ssize_t bytesWritten = 0;
  bool mustRegister = false;
  if ((state_ == StateEnum::ESTABLISHED || state_ == StateEnum::FAST_OPEN) &&
      !connecting()) {
    if (writeReqHead_ == nullptr) {
      // If we are established and there are no other writes pending,
      // we can attempt to perform the write immediately.
      assert(writeReqTail_ == nullptr);
      assert((eventFlags_ & EventHandler::WRITE) == 0);

      auto writeResult = performWrite(
          vec, uint32_t(count), flags, &countWritten, &partialWritten);
      bytesWritten = writeResult.writeReturn;
      if (bytesWritten < 0) {
        auto errnoCopy = errno;
        if (writeResult.exception) {
          return failWrite(__func__, callback, 0, *writeResult.exception);
        }
        AsyncSocketException ex(
            AsyncSocketException::INTERNAL_ERROR,
            withAddr("writev failed"),
            errnoCopy);
        return failWrite(__func__, callback, 0, ex);
      } else if (countWritten == count) {
        // done, add the whole buffer
        if (countWritten && isZeroCopyRequest(flags)) {
          addZeroCopyBuf(std::move(ioBuf));
        }
        // We successfully wrote everything.
        // Invoke the callback and return.
        if (callback) {
          callback->writeSuccess();
        }
        return;
      } else { // continue writing the next writeReq
        // add just the ptr
        if (bytesWritten && isZeroCopyRequest(flags)) {
          addZeroCopyBuf(ioBuf.get());
        }
        if (bufferCallback_) {
          bufferCallback_->onEgressBuffered();
        }
      }
      if (!connecting()) {
        // Writes might put the socket back into connecting state
        // if TFO is enabled, and using TFO fails.
        // This means that write timeouts would not be active, however
        // connect timeouts would affect this stage.
        mustRegister = true;
      }
    }
  } else if (!connecting()) {
    // Invalid state for writing
    return invalidState(callback);
  }

  // Create a new WriteRequest to add to the queue
  WriteRequest* req;
  try {
    req = BytesWriteRequest::newRequest(
        this,
        callback,
        vec + countWritten,
        uint32_t(count - countWritten),
        partialWritten,
        uint32_t(bytesWritten),
        std::move(ioBuf),
        flags);
  } catch (const std::exception& ex) {
    // we mainly expect to catch std::bad_alloc here
    AsyncSocketException tex(
        AsyncSocketException::INTERNAL_ERROR,
        withAddr(string("failed to append new WriteRequest: ") + ex.what()));
    return failWrite(__func__, callback, size_t(bytesWritten), tex);
  }
  req->consume();
  if (writeReqTail_ == nullptr) {
    assert(writeReqHead_ == nullptr);
    writeReqHead_ = writeReqTail_ = req;
  } else {
    writeReqTail_->append(req);
    writeReqTail_ = req;
  }

  // Register for write events if are established and not currently
  // waiting on write events
  if (mustRegister) {
    assert(state_ == StateEnum::ESTABLISHED);
    assert((eventFlags_ & EventHandler::WRITE) == 0);
    if (!updateEventRegistration(EventHandler::WRITE, 0)) {
      assert(state_ == StateEnum::ERROR);
      return;
    }
    if (sendTimeout_ > 0) {
      // Schedule a timeout to fire if the write takes too long.
      if (!writeTimeout_.scheduleTimeout(sendTimeout_)) {
        AsyncSocketException ex(
            AsyncSocketException::INTERNAL_ERROR,
            withAddr("failed to schedule send timeout"));
        return failWrite(__func__, ex);
      }
    }
  }
}

void folly::AsyncSocket::writeRequest ( WriteRequest *  req )

virtual

Definition at line 1187 of file AsyncSocket.cpp.

References folly::AsyncSocket::WriteRequest::append(), folly::AsyncSocket::WriteRequest::start(), writeReqHead_, and writeReqTail_.

Referenced by getZeroCopyReenableThreshold().

                                                {
  if (writeReqTail_ == nullptr) {
    assert(writeReqHead_ == nullptr);
    writeReqHead_ = writeReqTail_ = req;
    req->start();
  } else {
    writeReqTail_->append(req);
    writeReqTail_ = req;
  }
}

void folly::AsyncSocket::writeRequestReady ( )

inline

Definition at line 535 of file AsyncSocket.h.

References attachEventBase(), close(), closeNow(), closeWithReset(), detachEventBase(), error(), folly::AsyncTransport::getLocalAddress(), folly::AsyncTransport::getPeerAddress(), good(), handleWrite(), hangup(), isDetachable(), isPending(), readable(), shutdownWrite(), shutdownWriteNow(), and writable().

                           {
    handleWrite();
  }

void folly::AsyncSocket::writev ( WriteCallback *  callback, const iovec *  vec, size_t  count, WriteFlags  flags = WriteFlags::NONE  )

overridevirtual

If you supply a non-null WriteCallback, exactly one of writeSuccess() or writeErr() will be invoked when the write completes. If you supply the same WriteCallback object for multiple write() calls, it will be invoked exactly once per call. The only way to cancel outstanding write requests is to close the socket (e.g., with closeNow() or shutdownWriteNow()). When closing the socket this way, writeErr() will still be invoked once for each outstanding write operation.

Implements folly::AsyncTransportWrapper.

Definition at line 1014 of file AsyncSocket.cpp.

References writeImpl().

Referenced by getZeroCopyReenableThreshold().

                      {
  writeImpl(callback, vec, count, unique_ptr<IOBuf>(), flags);
}

Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  os, const StateEnum &  state  )

friend

Definition at line 2807 of file AsyncSocket.cpp.

                                       {
  os << static_cast<int>(state);
  return os;
}

Member Data Documentation

folly::SocketAddress folly::AsyncSocket::addr_

mutableprotected

The address we tried to connect to.

Definition at line 1230 of file AsyncSocket.h.

Referenced by cachePeerAddress(), connect(), fail(), failConnect(), failErrMessageRead(), failRead(), failWrite(), getPeerAddress(), handleConnect(), and sendSocketMessage().

size_t folly::AsyncSocket::appBytesReceived_

protected

Num of bytes received from socket.

Definition at line 1253 of file AsyncSocket.h.

Referenced by getAppBytesReceived(), init(), folly::AsyncSSLSocket::performRead(), and performRead().

size_t folly::AsyncSocket::appBytesWritten_

protected

Num of bytes written to socket.

Definition at line 1254 of file AsyncSocket.h.

Referenced by folly::AsyncSSLSocket::eorAwareSSLWrite(), getAppBytesWritten(), init(), and performWrite().

BufferCallback* folly::AsyncSocket::bufferCallback_ {nullptr}

protected

Definition at line 1267 of file AsyncSocket.h.

Referenced by handleWrite(), setBufferCallback(), and writeImpl().

ConnectCallback* folly::AsyncSocket::connectCallback_

protected

ConnectCallback.

Definition at line 1245 of file AsyncSocket.h.

Referenced by cancelConnect(), closeNow(), connect(), handleWrite(), init(), invokeConnectErr(), invokeConnectSuccess(), folly::AsyncSSLSocket::scheduleConnectTimeout(), and timeoutExpired().

std::chrono::steady_clock::time_point folly::AsyncSocket::connectEndTime_

protected

Definition at line 1261 of file AsyncSocket.h.

Referenced by connect(), getConnectEndTime(), getConnectTime(), invalidState(), invokeConnectErr(), and invokeConnectSuccess().

std::chrono::steady_clock::time_point folly::AsyncSocket::connectStartTime_

protected

Definition at line 1260 of file AsyncSocket.h.

Referenced by connect(), getConnectStartTime(), and getConnectTime().

std::chrono::milliseconds folly::AsyncSocket::connectTimeout_ {0}

protected

Definition at line 1263 of file AsyncSocket.h.

Referenced by connect(), getConnectTimeout(), folly::AsyncSSLSocket::scheduleConnectTimeout(), scheduleConnectTimeout(), and timeoutExpired().

const AsyncSocket::OptionMap folly::AsyncSocket::emptyOptionMap

static

Definition at line 378 of file AsyncSocket.h.

Referenced by folly::AsyncSSLSocket::getSecurityProtocol(), and proxygen::HTTPConnector::Callback::~Callback().

ErrMessageCallback* folly::AsyncSocket::errMessageCallback_

protected

TimestampCallback.

Definition at line 1246 of file AsyncSocket.h.

Referenced by connect(), failErrMessageRead(), getErrMessageCallback(), handleErrMessages(), init(), and setErrMessageCB().

std::unique_ptr<EvbChangeCallback> folly::AsyncSocket::evbChangeCb_ {nullptr}

protected

Definition at line 1265 of file AsyncSocket.h.

Referenced by attachEventBase(), detachEventBase(), and setEvbChangedCallback().

EventBase* folly::AsyncSocket::eventBase_

protected

The EventBase.

Definition at line 1240 of file AsyncSocket.h.

Referenced by attachEventBase(), close(), closeNow(), connect(), destroy(), detachEventBase(), detachFd(), getEventBase(), good(), folly::AsyncSSLSocket::handleConnect(), handleConnect(), handleRead(), folly::AsyncSSLSocket::handleReturnFromSSLAccept(), handleWrite(), init(), ioReady(), isDetachable(), isZeroCopyWriteInProgress(), processZeroCopyWriteInProgress(), scheduleImmediateRead(), scheduleInitialReadWrite(), setErrMessageCB(), setReadCB(), setSendTimeout(), shutdownWrite(), shutdownWriteNow(), folly::AsyncSSLSocket::sslAccept(), folly::AsyncSSLSocket::sslConn(), timeoutExpired(), updateEventRegistration(), folly::AsyncSSLSocket::willBlock(), writeImpl(), ~AsyncSocket(), and folly::AsyncSSLSocket::~AsyncSSLSocket().

uint16_t folly::AsyncSocket::eventFlags_

protected

EventBase::HandlerFlags settings.

Definition at line 1228 of file AsyncSocket.h.

Referenced by attachEventBase(), closeNow(), detachEventBase(), detachFd(), folly::AsyncSSLSocket::handleAccept(), folly::AsyncSSLSocket::handleConnect(), handleConnect(), handleInitialReadWrite(), folly::AsyncSSLSocket::handleRead(), handleRead(), folly::AsyncSSLSocket::handleReturnFromSSLAccept(), folly::AsyncSSLSocket::handleWrite(), handleWrite(), init(), folly::AsyncSSLSocket::interpretSSLError(), folly::AsyncSSLSocket::invalidState(), folly::AsyncSSLSocket::performRead(), folly::AsyncSSLSocket::performWrite(), registerForConnectEvents(), folly::AsyncSSLSocket::restartSSLAccept(), setReadCB(), setSendTimeout(), startFail(), timeoutExpired(), updateEventRegistration(), folly::AsyncSSLSocket::willBlock(), writeImpl(), and folly::AsyncSSLSocket::~AsyncSSLSocket().

int folly::AsyncSocket::fd_

protected

The socket file descriptor.

Definition at line 1229 of file AsyncSocket.h.

Referenced by AsyncSocket(), attachEventBase(), cacheAddresses(), cacheLocalAddress(), cachePeerAddress(), close(), folly::AsyncSSLSocket::closeNow(), closeNow(), closeWithReset(), connect(), destroy(), detachEventBase(), detachFd(), doClose(), fail(), failConnect(), failErrMessageRead(), failRead(), failWrite(), getFd(), getSockOpt(), getSockOptVirtual(), getTFOSucceded(), folly::AsyncSSLSocket::handleAccept(), folly::AsyncSSLSocket::handleConnect(), handleConnect(), handleErrMessages(), folly::AsyncSSLSocket::handleRead(), handleRead(), folly::AsyncSSLSocket::handleReturnFromSSLAccept(), folly::AsyncSSLSocket::handleWrite(), handleWrite(), hangup(), init(), folly::AsyncSSLSocket::interpretSSLError(), folly::AsyncSSLSocket::invalidState(), invalidState(), ioReady(), folly::AsyncSSLSocket::performRead(), performRead(), folly::AsyncSSLSocket::performWrite(), performWrite(), processZeroCopyMsg(), readable(), folly::AsyncSSLSocket::restartSSLAccept(), sendSocketMessage(), setCloseOnExec(), setCongestionFlavor(), setErrMessageCB(), setNoDelay(), setQuickAck(), setReadCB(), setRecvBufSize(), setSendBufSize(), setShutdownSocketSet(), setSockOpt(), setSockOptVirtual(), setTCPProfile(), folly::AsyncSSLSocket::setupSSLBio(), setZeroCopy(), shutdownWrite(), shutdownWriteNow(), socketConnect(), folly::AsyncSSLSocket::sslConn(), startFail(), timeoutExpired(), updateEventRegistration(), folly::AsyncSSLSocket::willBlock(), writable(), writeImpl(), ~AsyncSocket(), and folly::AsyncSSLSocket::~AsyncSSLSocket().

std::unordered_map<folly::IOBuf*, IOBufInfo> folly::AsyncSocket::idZeroCopyBufInfoMap_

protected

Definition at line 1224 of file AsyncSocket.h.

Referenced by addZeroCopyBuf(), containsZeroCopyBuf(), doClose(), releaseZeroCopyBuf(), and setZeroCopyBuf().

std::unordered_map<uint32_t, folly::IOBuf*> folly::AsyncSocket::idZeroCopyBufPtrMap_

protected

Definition at line 1223 of file AsyncSocket.h.

Referenced by addZeroCopyBuf(), doClose(), handleErrMessages(), isZeroCopyWriteInProgress(), processZeroCopyWriteInProgress(), and releaseZeroCopyBuf().

ImmediateReadCB folly::AsyncSocket::immediateReadHandler_

protected

LoopCallback for checking read.

Definition at line 1243 of file AsyncSocket.h.

Referenced by closeNow(), scheduleImmediateRead(), setReadCB(), and startFail().

IoHandler folly::AsyncSocket::ioHandler_

protected

A EventHandler to monitor the fd.

Definition at line 1242 of file AsyncSocket.h.

Referenced by attachEventBase(), closeNow(), connect(), detachEventBase(), detachFd(), handleWrite(), isPending(), registerForConnectEvents(), startFail(), and updateEventRegistration().

bool folly::AsyncSocket::isBufferMovable_ {false}

protected

Definition at line 1236 of file AsyncSocket.h.

Referenced by handleRead(), folly::AsyncSSLSocket::performRead(), folly::AsyncSSLSocket::prepareReadBuffer(), and folly::AsyncSSLSocket::setReadCB().

folly::SocketAddress folly::AsyncSocket::localAddr_

mutableprotected

The address we are connecting from.

Definition at line 1231 of file AsyncSocket.h.

Referenced by cacheLocalAddress(), getLocalAddress(), and setErrMessageCB().

uint16_t folly::AsyncSocket::maxReadsPerEvent_

protected

Max reads per event loop iteration.

Definition at line 1234 of file AsyncSocket.h.

Referenced by getMaxReadsPerEvent(), handleRead(), init(), and setMaxReadsPerEvent().

bool folly::AsyncSocket::noTransparentTls_ {false}

protected

Definition at line 1271 of file AsyncSocket.h.

Referenced by AsyncSocket(), folly::AsyncSSLSocket::AsyncSSLSocket(), connect(), folly::AsyncSSLSocket::connect(), and disableTransparentTls().

bool folly::AsyncSocket::noTSocks_ {false}

protected

Definition at line 1272 of file AsyncSocket.h.

Referenced by AsyncSocket(), connect(), and disableTSocks().

std::unique_ptr<const AsyncTransportCertificate> folly::AsyncSocket::peerCertData_

mutableprotected

Initial value:

{
      nullptr}

Definition at line 1282 of file AsyncSocket.h.

Referenced by folly::AsyncSSLSocket::getPeerCertificate(), getPeerCertificate(), and setPeerCertificate().

std::unique_ptr<IOBuf> folly::AsyncSocket::preReceivedData_

protected

Definition at line 1258 of file AsyncSocket.h.

Referenced by AsyncSocket(), checkForImmediateRead(), performRead(), and setPreReceivedData().

ReadCallback* folly::AsyncSocket::readCallback_

protected

ReadCallback.

Definition at line 1249 of file AsyncSocket.h.

Referenced by close(), closeNow(), connect(), failRead(), getReadCallback(), handleInitialReadWrite(), handleRead(), handleWrite(), init(), invokeAllErrors(), ioReady(), folly::AsyncSSLSocket::prepareReadBuffer(), prepareReadBuffer(), and setReadCB().

int8_t folly::AsyncSocket::readErr_ {READ_NO_ERROR}

protected

The read error encountered, if any.

Definition at line 1238 of file AsyncSocket.h.

Referenced by handleRead(), isClosedByPeer(), and isClosedBySelf().

std::unique_ptr<const AsyncTransportCertificate> folly::AsyncSocket::selfCertData_

mutableprotected

Initial value:

{
      nullptr}

Definition at line 1284 of file AsyncSocket.h.

Referenced by folly::AsyncSSLSocket::getSelfCertificate(), getSelfCertificate(), and setSelfCertificate().

SendMsgParamsCallback* folly::AsyncSocket::sendMsgParamCallback_

protected

< Callback for retrieving

sendmsg() parameters

Definition at line 1248 of file AsyncSocket.h.

Referenced by getSendMsgParamsCB(), init(), performWrite(), and setSendMsgParamCB().

uint32_t folly::AsyncSocket::sendTimeout_

protected

The send timeout, in milliseconds.

Definition at line 1233 of file AsyncSocket.h.

Referenced by getSendTimeout(), handleWrite(), init(), setSendTimeout(), timeoutExpired(), and writeImpl().

uint8_t folly::AsyncSocket::shutdownFlags_

protected

Shutdown state (ShutdownFlags)

Definition at line 1227 of file AsyncSocket.h.

Referenced by close(), closeNow(), good(), handleConnect(), handleInitialReadWrite(), handleRead(), handleWrite(), init(), setReadCB(), setSendTimeout(), shutdownWrite(), shutdownWriteNow(), startFail(), and writeImpl().

StateEnum folly::AsyncSocket::state_

protected

StateEnum describing current state.

Definition at line 1226 of file AsyncSocket.h.

Referenced by AsyncSocket(), attachEventBase(), cancelConnect(), close(), closeNow(), connect(), folly::AsyncSSLSocket::connect(), connecting(), destroy(), detachEventBase(), detachFd(), error(), fail(), failConnect(), failErrMessageRead(), failRead(), failWrite(), finishFail(), good(), folly::AsyncSSLSocket::handleAccept(), folly::AsyncSSLSocket::handleConnect(), handleConnect(), handleErrMessages(), handleInitialReadWrite(), folly::AsyncSSLSocket::handleRead(), handleRead(), folly::AsyncSSLSocket::handleReturnFromSSLAccept(), folly::AsyncSSLSocket::handleWrite(), handleWrite(), init(), folly::AsyncSSLSocket::interpretSSLError(), folly::AsyncSSLSocket::invalidState(), invalidState(), ioReady(), isClosedByPeer(), isClosedBySelf(), folly::AsyncSSLSocket::performRead(), folly::AsyncSSLSocket::performWrite(), folly::AsyncSSLSocket::restartSSLAccept(), sendSocketMessage(), setCongestionFlavor(), setErrMessageCB(), setNoDelay(), setQuickAck(), setReadCB(), setRecvBufSize(), setSendBufSize(), setSendTimeout(), setTCPProfile(), shutdownWrite(), shutdownWriteNow(), folly::test::MockAsyncSSLSocket::sslAccept(), folly::test::MockAsyncSSLSocket::sslConn(), startFail(), folly::AsyncSSLSocket::timeoutExpired(), timeoutExpired(), updateEventRegistration(), folly::AsyncSSLSocket::willBlock(), writeImpl(), ~AsyncSocket(), and folly::AsyncSSLSocket::~AsyncSSLSocket().

bool folly::AsyncSocket::tfoAttempted_ {false}

protected

Definition at line 1269 of file AsyncSocket.h.

Referenced by connect(), getTFOAttempted(), and folly::AsyncSSLSocket::invokeConnectSuccess().

bool folly::AsyncSocket::tfoEnabled_ {false}

protected

Definition at line 1268 of file AsyncSocket.h.

Referenced by connect(), and enableTFO().

bool folly::AsyncSocket::tfoFinished_ {false}

protected

Definition at line 1270 of file AsyncSocket.h.

Referenced by getTFOFinished(), and sendSocketMessage().

bool folly::AsyncSocket::trackEor_ {false}

protected

Definition at line 1274 of file AsyncSocket.h.

Referenced by isEorTrackingEnabled(), and setEorTracking().

WriteRequest* folly::AsyncSocket::writeReqHead_

protected

Chain of WriteRequests.

Definition at line 1250 of file AsyncSocket.h.

Referenced by close(), closeNow(), connect(), failAllWrites(), failWrite(), handleConnect(), handleInitialReadWrite(), handleWrite(), init(), shutdownWrite(), writeImpl(), and writeRequest().

WriteRequest* folly::AsyncSocket::writeReqTail_

protected

End of WriteRequest chain.

Definition at line 1251 of file AsyncSocket.h.

Referenced by handleWrite(), init(), writeImpl(), and writeRequest().

WriteTimeout folly::AsyncSocket::writeTimeout_

protected

A timeout for connect and write.

Definition at line 1241 of file AsyncSocket.h.

Referenced by attachEventBase(), closeNow(), detachEventBase(), handleConnect(), handleWrite(), isDetachable(), scheduleConnectTimeout(), setSendTimeout(), shutdownWriteNow(), startFail(), and writeImpl().

std::weak_ptr<ShutdownSocketSet> folly::AsyncSocket::wShutdownSocketSet_

protected

Definition at line 1252 of file AsyncSocket.h.

Referenced by connect(), detachFd(), doClose(), init(), and setShutdownSocketSet().

uint32_t folly::AsyncSocket::zeroCopyBufId_ {0}

protected

Definition at line 1216 of file AsyncSocket.h.

Referenced by getNextZeroCopyBufId(), and getZeroCopyBufId().

bool folly::AsyncSocket::zeroCopyEnabled_ {false}

protected

Definition at line 1275 of file AsyncSocket.h.

Referenced by adjustZeroCopyFlags(), getZeroCopy(), isZeroCopyRequest(), performWrite(), processZeroCopyMsg(), and setZeroCopy().

size_t folly::AsyncSocket::zeroCopyReenableCounter_ {0}

protected

Definition at line 1279 of file AsyncSocket.h.

Referenced by adjustZeroCopyFlags(), and performWrite().

size_t folly::AsyncSocket::zeroCopyReenableThreshold_ {0}

protected

Definition at line 1278 of file AsyncSocket.h.

Referenced by getZeroCopyReenableThreshold(), performWrite(), and setZeroCopyReenableThreshold().

bool folly::AsyncSocket::zeroCopyVal_ {false}

protected

Definition at line 1276 of file AsyncSocket.h.

Referenced by connect(), and setZeroCopy().

---

The documentation for this class was generated from the following files:

• proxygen/folly/folly/io/async/AsyncSocket.h
• proxygen/folly/folly/io/async/AsyncSocket.cpp