proxygen: fizz::AsyncFizzBase Class Reference

#include <AsyncFizzBase.h>

Inheritance diagram for fizz::AsyncFizzBase:

Classes
class	HandshakeTimeout

Public Types
using	UniquePtr = std::unique_ptr< AsyncFizzBase, folly::DelayedDestruction::Destructor >

using	ReadCallback = folly::AsyncTransportWrapper::ReadCallback

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
	AsyncFizzBase (folly::AsyncTransportWrapper::UniquePtr transport)

	~AsyncFizzBase () override

ReadCallback *	getReadCallback () const override

void	setReadCB (ReadCallback *callback) override

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

size_t	getAppBytesWritten () const override

size_t	getAppBytesReceived () const override

bool	good () const override=0

bool	readable () const override=0

bool	connecting () const override=0

bool	error () const override=0

folly::ssl::X509UniquePtr	getPeerCert () const override=0

const X509 *	getSelfCert () const override=0

const Cert *	getPeerCertificate () const override=0

const Cert *	getSelfCertificate () const override=0

bool	isReplaySafe () const override=0

void	setReplaySafetyCallback (folly::AsyncTransport::ReplaySafetyCallback *callback) override=0

std::string	getApplicationProtocol () const noexceptoverride=0

virtual folly::Optional< CipherSuite >	getCipher () const =0

virtual std::vector< SignatureScheme >	getSupportedSigSchemes () const =0

virtual Buf	getEkm (folly::StringPiece label, const Buf &context, uint16_t length) const =0

void	destroy () override

std::string	getSecurityProtocol () const override

void	attachTimeoutManager (folly::TimeoutManager *manager)

void	detachTimeoutManager ()

void	attachEventBase (folly::EventBase *eventBase) override

void	detachEventBase () override

bool	isDetachable () const override

Public Member Functions inherited from folly::WriteChainAsyncTransportWrapper< folly::AsyncTransportWrapper >
void	write (folly::AsyncTransportWrapper::WriteCallback callback, const void buf, size_t bytes, folly::WriteFlags flags=folly::WriteFlags::NONE) override

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

Public Member Functions inherited from folly::DecoratedAsyncTransportWrapper< folly::AsyncTransportWrapper >
	DecoratedAsyncTransportWrapper (typename folly::AsyncTransportWrapper::UniquePtr transport)

const AsyncTransportWrapper *	getWrappedTransport () const override

ReadCallback *	getReadCallback () const override

void	setReadCB (folly::AsyncTransportWrapper::ReadCallback *callback) override

folly::EventBase *	getEventBase () const override

void	attachEventBase (folly::EventBase *eventBase) override

void	close () override

void	closeNow () override

void	closeWithReset () override

bool	connecting () const override

void	detachEventBase () override

bool	error () const override

size_t	getAppBytesReceived () const override

size_t	getAppBytesWritten () const override

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

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

folly::ssl::X509UniquePtr	getPeerCert () const override

size_t	getRawBytesReceived () const override

size_t	getRawBytesWritten () const override

uint32_t	getSendTimeout () const override

bool	good () const override

bool	isDetachable () const override

bool	isEorTrackingEnabled () const override

bool	readable () const override

bool	writable () const override

void	setEorTracking (bool track) override

void	setSendTimeout (uint32_t timeoutInMs) override

void	shutdownWrite () override

void	shutdownWriteNow () override

std::string	getApplicationProtocol () const noexceptoverride

std::string	getSecurityProtocol () const override

bool	isReplaySafe () const override

void	setReplaySafetyCallback (folly::AsyncTransport::ReplaySafetyCallback *callback) override

const AsyncTransportCertificate *	getPeerCertificate () const override

const AsyncTransportCertificate *	getSelfCertificate () const override

Public Member Functions inherited from folly::AsyncTransportWrapper
template<class T >
const T *	getUnderlyingTransport () const

template<class T >
T *	getUnderlyingTransport ()

Public Member Functions inherited from folly::AsyncTransport
virtual bool	isPending () const

SocketAddress	getLocalAddress () const

void	getAddress (SocketAddress *address) const override

SocketAddress	getPeerAddress () const

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

Protected Member Functions
virtual void	startTransportReads ()

virtual void	startHandshakeTimeout (std::chrono::milliseconds)

virtual void	cancelHandshakeTimeout ()

virtual void	deliverAppData (std::unique_ptr< folly::IOBuf > buf)

virtual void	deliverError (const folly::AsyncSocketException &ex, bool closeTransport=true)

virtual void	writeAppData (folly::AsyncTransportWrapper::WriteCallback *callback, std::unique_ptr< folly::IOBuf > &&buf, folly::WriteFlags flags=folly::WriteFlags::NONE)=0

virtual void	transportError (const folly::AsyncSocketException &ex)=0

virtual void	transportDataAvailable ()=0

Protected Member Functions inherited from folly::DecoratedAsyncTransportWrapper< folly::AsyncTransportWrapper >
	~DecoratedAsyncTransportWrapper () override

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 Member Functions inherited from folly::AsyncWriter::WriteCallback
virtual	~WriteCallback ()=default

Protected Attributes
folly::IOBufQueue	transportReadBuf_ {folly::IOBufQueue::cacheChainLength()}

Protected Attributes inherited from folly::DecoratedAsyncTransportWrapper< folly::AsyncTransportWrapper >
folly::AsyncTransportWrapper::UniquePtr	transport_

Private Member Functions
void	getReadBuffer (void *bufReturn, size_t lenReturn) override

void	readDataAvailable (size_t len) noexceptoverride

bool	isBufferMovable () noexceptoverride

void	readBufferAvailable (std::unique_ptr< folly::IOBuf > data) noexceptoverride

void	readEOF () noexceptoverride

void	readErr (const folly::AsyncSocketException &ex) noexceptoverride

void	writeSuccess () noexceptoverride

void	writeErr (size_t bytesWritten, const folly::AsyncSocketException &ex) noexceptoverride

void	checkBufLen ()

void	handshakeTimeoutExpired () noexcept

Private Member Functions inherited from folly::AsyncReader::ReadCallback
virtual	~ReadCallback ()=default

virtual size_t	maxBufferSize () const

Private Attributes
ReadCallback *	readCallback_ {nullptr}

std::unique_ptr< folly::IOBuf >	appDataBuf_

size_t	appBytesWritten_ {0}

size_t	appBytesReceived_ {0}

HandshakeTimeout	handshakeTimeout_

Detailed Description

This class is a wrapper around AsyncTransportWrapper to handle most app level interactions so that the derived client and server classes

Definition at line 24 of file AsyncFizzBase.h.

Member Typedef Documentation

using fizz::AsyncFizzBase::ReadCallback = folly::AsyncTransportWrapper::ReadCallback

Definition at line 31 of file AsyncFizzBase.h.

using fizz::AsyncFizzBase::UniquePtr = std::unique_ptr<AsyncFizzBase, folly::DelayedDestruction::Destructor>

Definition at line 30 of file AsyncFizzBase.h.

Constructor & Destructor Documentation

fizz::AsyncFizzBase::AsyncFizzBase ( folly::AsyncTransportWrapper::UniquePtr transport )

explicit

Definition at line 30 of file AsyncFizzBase.cpp.

     : folly::WriteChainAsyncTransportWrapper<folly::AsyncTransportWrapper>(
           std::move(transport)),
       handshakeTimeout_(*this, transport_->getEventBase()) {}

fizz::AsyncFizzBase::~AsyncFizzBase ( )

override

Definition at line 35 of file AsyncFizzBase.cpp.

References folly::DecoratedAsyncTransportWrapper< folly::AsyncTransportWrapper >::transport_.

                               {
   transport_->setReadCB(nullptr);
 }

Member Function Documentation

void fizz::AsyncFizzBase::attachEventBase ( folly::EventBase * eventBase )

inlineoverridevirtual

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 fizz::server::AsyncFizzServerT< SM >, and fizz::server::AsyncFizzServerT< fizz::server::test::MockServerStateMachineInstance >.

Definition at line 135 of file AsyncFizzBase.h.

References folly::AsyncTimeout::attachEventBase(), attachEventBase(), good(), handshakeTimeout_, readCallback_, startTransportReads(), and fizz::AsyncFizzBase::HandshakeTimeout::transport_.

Referenced by fizz::server::AsyncFizzServerT< SM >::attachEventBase(), and attachEventBase().

                                                            {
     handshakeTimeout_.attachEventBase(eventBase);
     transport_->attachEventBase(eventBase);
     // we want to avoid setting a read cb on a bad transport (i.e. closed or
     // disconnected) unless we have a read callback we can pass the errors to.
     if (transport_->good() || readCallback_) {
       startTransportReads();
     }
   }

void fizz::AsyncFizzBase::attachTimeoutManager ( folly::TimeoutManager * manager )

inline

EventBase operations.

Definition at line 129 of file AsyncFizzBase.h.

References folly::AsyncTimeout::attachTimeoutManager(), and handshakeTimeout_.

                                                           {
     handshakeTimeout_.attachTimeoutManager(manager);
   }

void fizz::AsyncFizzBase::cancelHandshakeTimeout ( )

protectedvirtual

Definition at line 96 of file AsyncFizzBase.cpp.

References folly::AsyncTimeout::cancelTimeout(), and handshakeTimeout_.

Referenced by fizz::client::AsyncFizzClientT< SM >::deliverHandshakeError(), and isDetachable().

                                            {
   handshakeTimeout_.cancelTimeout();
 }

void fizz::AsyncFizzBase::checkBufLen ( )

private

Definition at line 222 of file AsyncFizzBase.cpp.

References appDataBuf_, folly::IOBufQueue::chainLength(), fizz::kMaxBufSize, readCallback_, folly::DecoratedAsyncTransportWrapper< folly::AsyncTransportWrapper >::transport_, and transportReadBuf_.

Referenced by deliverAppData(), readBufferAvailable(), and readDataAvailable().

                                 {
   if (!readCallback_ &&
       (transportReadBuf_.chainLength() >= kMaxBufSize ||
        (appDataBuf_ && appDataBuf_->computeChainDataLength() >= kMaxBufSize))) {
     transport_->setReadCB(nullptr);
   }
 }

bool fizz::AsyncFizzBase::connecting ( ) const

overridepure virtual

Determine if transport is connected to the endpoint

Returns: false iff the transport is connected, otherwise true

Implements folly::AsyncTransport.

Implemented in fizz::client::AsyncFizzClientT< SM >, fizz::client::AsyncFizzClientT< fizz::client::test::MockClientStateMachineInstance >, fizz::server::AsyncFizzServerT< SM >, and fizz::server::AsyncFizzServerT< fizz::server::test::MockServerStateMachineInstance >.

void fizz::AsyncFizzBase::deliverAppData ( std::unique_ptr< folly::IOBuf > buf )

protectedvirtual

Interfaces for the derived class to interact with the app level read callback.

Definition at line 100 of file AsyncFizzBase.cpp.

References appBytesReceived_, appDataBuf_, folly::AsyncSocketException::BAD_ARGS, checkBufLen(), folly::IOBuf::computeChainDataLength(), deliverError(), folly::AsyncReader::ReadCallback::getReadBuffer(), folly::AsyncReader::ReadCallback::isBufferMovable(), min, folly::gen::move, folly::AsyncReader::ReadCallback::readBufferAvailable(), readCallback_, and folly::AsyncReader::ReadCallback::readDataAvailable().

Referenced by isDetachable(), and setReadCB().

                                                                  {
   if (data) {
     appBytesReceived_ += data->computeChainDataLength();
   }
 
   if (appDataBuf_) {
     if (data) {
       appDataBuf_->prependChain(std::move(data));
     }
     data = std::move(appDataBuf_);
   }
 
   if (readCallback_ && data) {
     if (readCallback_->isBufferMovable()) {
       return readCallback_->readBufferAvailable(std::move(data));
     } else {
       folly::io::Cursor cursor(data.get());
       size_t available = 0;
       while ((available = cursor.totalLength()) != 0 && readCallback_) {
         void* buf = nullptr;
         size_t buflen = 0;
         try {
           readCallback_->getReadBuffer(&buf, &buflen);
         } catch (const AsyncSocketException& ase) {
           return deliverError(ase);
         } catch (const std::exception& e) {
           AsyncSocketException ase(
               AsyncSocketException::BAD_ARGS,
               folly::to<std::string>("getReadBuffer() threw ", e.what()));
           return deliverError(ase);
         } catch (...) {
           AsyncSocketException ase(
               AsyncSocketException::BAD_ARGS,
               "getReadBuffer() threw unknown exception");
           return deliverError(ase);
         }
         if (buflen == 0 || buf == nullptr) {
           AsyncSocketException ase(
               AsyncSocketException::BAD_ARGS,
               "getReadBuffer() returned empty buffer");
           return deliverError(ase);
         }
 
         size_t bytesToRead = std::min(buflen, available);
         cursor.pull(buf, bytesToRead);
         readCallback_->readDataAvailable(bytesToRead);
       }
       if (available != 0) {
         cursor.clone(appDataBuf_, available);
       }
     }
   } else if (data) {
     appDataBuf_ = std::move(data);
   }
 
   checkBufLen();
 }

void fizz::AsyncFizzBase::deliverError	(	const folly::AsyncSocketException &	ex,
		bool	closeTransport = `true`
	)

protectedvirtual

Definition at line 158 of file AsyncFizzBase.cpp.

References folly::AsyncSocketException::END_OF_FILE, folly::AsyncSocketException::getType(), readCallback_, folly::AsyncReader::ReadCallback::readEOF(), and folly::DecoratedAsyncTransportWrapper< folly::AsyncTransportWrapper >::transport_.

Referenced by fizz::server::AsyncFizzServerT< SM >::deliverAllErrors(), fizz::client::AsyncFizzClientT< SM >::deliverAllErrors(), deliverAppData(), isDetachable(), and setReadCB().

                          {
   DelayedDestruction::DestructorGuard dg(this);
 
   if (readCallback_) {
     auto readCallback = readCallback_;
     readCallback_ = nullptr;
     if (ex.getType() == AsyncSocketException::END_OF_FILE) {
       readCallback->readEOF();
     } else {
       readCallback->readErr(ex);
     }
   }
   if (closeTransport) {
     transport_->close();
   }
 }

void fizz::AsyncFizzBase::destroy ( )

overridevirtual

Clean up transport on destruction

Reimplemented from folly::DelayedDestruction.

Definition at line 39 of file AsyncFizzBase.cpp.

References destroy(), and folly::DecoratedAsyncTransportWrapper< folly::AsyncTransportWrapper >::transport_.

                             {
   transport_->closeNow();
   transport_->setReadCB(nullptr);
   DelayedDestruction::destroy();
 }

void fizz::AsyncFizzBase::detachEventBase ( )

inlineoverridevirtual

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.

Definition at line 144 of file AsyncFizzBase.h.

References folly::AsyncTimeout::detachEventBase(), detachEventBase(), handshakeTimeout_, setReadCB(), and fizz::AsyncFizzBase::HandshakeTimeout::transport_.

Referenced by detachEventBase().

                                   {
     handshakeTimeout_.detachEventBase();
     transport_->setReadCB(nullptr);
     transport_->detachEventBase();
   }

void fizz::AsyncFizzBase::detachTimeoutManager ( )

inline

Definition at line 132 of file AsyncFizzBase.h.

References folly::AsyncTimeout::detachTimeoutManager(), and handshakeTimeout_.

                               {
     handshakeTimeout_.detachTimeoutManager();
   }

bool fizz::AsyncFizzBase::error ( ) const

overridepure virtual

Determine if an error has occurred with this transport.

Returns: true iff an error has occurred (not EOF).

Implements folly::AsyncTransport.

size_t fizz::AsyncFizzBase::getAppBytesReceived ( ) const

overridevirtual

Implements folly::AsyncTransport.

Definition at line 84 of file AsyncFizzBase.cpp.

References appBytesReceived_.

                                                 {
   return appBytesReceived_;
 }

size_t fizz::AsyncFizzBase::getAppBytesWritten ( ) const

overridevirtual

App data usage accounting.

Implements folly::AsyncTransport.

Definition at line 80 of file AsyncFizzBase.cpp.

References appBytesWritten_.

                                                {
   return appBytesWritten_;
 }

std::string fizz::AsyncFizzBase::getApplicationProtocol ( ) const

overridepure virtualnoexcept

Return the application protocol being used by the underlying transport protocol. This is useful for transports which are used to tunnel other protocols.

Reimplemented from folly::AsyncTransport.

Implemented in fizz::test::MockAsyncFizzBase, fizz::client::AsyncFizzClientT< SM >, fizz::client::AsyncFizzClientT< fizz::client::test::MockClientStateMachineInstance >, fizz::server::AsyncFizzServerT< SM >, fizz::server::AsyncFizzServerT< fizz::server::test::MockServerStateMachineInstance >, and fizz::test::AsyncFizzBaseTest.

virtual folly::Optional<CipherSuite> fizz::AsyncFizzBase::getCipher ( ) const

pure virtual

Get the CipherSuite negotiated in this transport.

Referenced by fizz::ExportedAuthenticator::getAuthenticator(), and fizz::ExportedAuthenticator::validateAuthenticator().

virtual Buf fizz::AsyncFizzBase::getEkm	(	folly::StringPiece	label,
		const Buf &	context,
		uint16_t	length
	)		const

pure virtual

Get the exported material.

Referenced by fizz::ExportedAuthenticator::getAuthenticator(), and fizz::ExportedAuthenticator::validateAuthenticator().

folly::ssl::X509UniquePtr fizz::AsyncFizzBase::getPeerCert ( ) const

overridepure virtual

Information about the current security state. To be implemented by derived classes.

Reimplemented from folly::AsyncTransport.

const Cert* fizz::AsyncFizzBase::getPeerCertificate ( ) const

overridepure virtual

Get the certificates in fizz::Cert form.

Reimplemented from folly::AsyncTransport.

void fizz::AsyncFizzBase::getReadBuffer	(	void **	bufReturn,
		size_t *	lenReturn
	)

overrideprivatevirtual

ReadCallback implementation.

Implements folly::AsyncReader::ReadCallback.

Definition at line 177 of file AsyncFizzBase.cpp.

References folly::IOBufQueue::preallocate(), and transportReadBuf_.

                                                                      {
   std::pair<void*, uint32_t> readSpace =
       transportReadBuf_.preallocate(kMinReadSize, kMaxReadSize);
   *bufReturn = readSpace.first;
   *lenReturn = readSpace.second;
 }

AsyncFizzBase::ReadCallback * fizz::AsyncFizzBase::getReadCallback ( ) const

overridevirtual

App level information for reading/writing app data.

Implements folly::AsyncTransportWrapper.

Definition at line 45 of file AsyncFizzBase.cpp.

References readCallback_.

Referenced by isDetachable().

                                                                 {
   return readCallback_;
 }

std::string fizz::AsyncFizzBase::getSecurityProtocol ( ) const

inlineoverridevirtual

Identify the transport as Fizz.

Reimplemented from folly::AsyncTransport.

Definition at line 122 of file AsyncFizzBase.h.

                                                  {
     return "Fizz";
   }

const X509* fizz::AsyncFizzBase::getSelfCert ( ) const

overridepure virtual

The local certificate used for this connection. May be null

Reimplemented from folly::AsyncTransport.

const Cert* fizz::AsyncFizzBase::getSelfCertificate ( ) const

overridepure virtual

Get the certificate information of this transport, if any

Reimplemented from folly::AsyncTransport.

virtual std::vector<SignatureScheme> fizz::AsyncFizzBase::getSupportedSigSchemes ( ) const

pure virtual

Get the supported signature schemes in this transport.

Referenced by fizz::ExportedAuthenticator::getAuthenticator().

bool fizz::AsyncFizzBase::good ( ) const

overridepure virtual

Information about the current transport state. To be implemented by derived classes.

Implements folly::AsyncTransport.

Referenced by attachEventBase(), and setReadCB().

void fizz::AsyncFizzBase::handshakeTimeoutExpired ( )

privatenoexcept

Definition at line 230 of file AsyncFizzBase.cpp.

References folly::AsyncSocketException::TIMED_OUT, and transportError().

Referenced by fizz::AsyncFizzBase::HandshakeTimeout::timeoutExpired().

                                                      {
   AsyncSocketException eof(
       AsyncSocketException::TIMED_OUT, "handshake timeout expired");
   transportError(eof);
 }

bool fizz::AsyncFizzBase::isBufferMovable ( )

overrideprivatevirtualnoexcept

When data becomes available, isBufferMovable() will be invoked to figure out which API will be used, readBufferAvailable() or readDataAvailable(). If isBufferMovable() returns true, that means ReadCallback supports the IOBuf ownership transfer and readBufferAvailable() will be used. Otherwise, not.

By default, isBufferMovable() always return false. If readBufferAvailable() is implemented and to be invoked, You should overwrite isBufferMovable() and return true in the inherited class.

This method allows the AsyncSocket/AsyncSSLSocket do buffer allocation by itself until data becomes available. Compared with the pre/post buffer allocation in getReadBuffer()/readDataAvailabe(), readBufferAvailable() has two advantages. First, this can avoid memcpy. E.g., in AsyncSSLSocket, the decrypted data was copied from the openssl internal buffer to the readbuf buffer. With the buffer ownership transfer, the internal buffer can be directly "moved" to ReadCallback. Second, the memory allocation can be more precise. The reason is AsyncSocket/AsyncSSLSocket can allocate the memory of precise size because they have more context about the available data than ReadCallback. Think about the getReadBuffer() pre-allocate 4072 bytes buffer, but the available data is always 16KB (max OpenSSL record size).

Reimplemented from folly::AsyncReader::ReadCallback.

Definition at line 192 of file AsyncFizzBase.cpp.

                                              {
   return true;
 }

bool fizz::AsyncFizzBase::isDetachable ( ) const

inlineoverridevirtual

Determine if the transport can be detached.

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

Implements folly::AsyncTransport.

Reimplemented in fizz::server::AsyncFizzServerT< SM >, and fizz::server::AsyncFizzServerT< fizz::server::test::MockServerStateMachineInstance >.

Definition at line 149 of file AsyncFizzBase.h.

References cancelHandshakeTimeout(), deliverAppData(), deliverError(), getReadCallback(), handshakeTimeout_, isDetachable(), folly::AsyncTimeout::isScheduled(), folly::NONE, setReadCB(), startHandshakeTimeout(), startTransportReads(), fizz::AsyncFizzBase::HandshakeTimeout::transport_, transportDataAvailable(), transportError(), and writeAppData().

Referenced by fizz::server::AsyncFizzServerT< SM >::isDetachable(), and isDetachable().

                                      {
     if (handshakeTimeout_.isScheduled()) {
       return false;
     }
     // Since we always have a read callback on the underlying transport,
     // transport_->isDetachable() would always return false.  We need to see if
     // the transport is detachable independent of our callback.
     auto readCb = transport_->getReadCallback();
     transport_->setReadCB(nullptr);
     auto result = transport_->isDetachable();
     transport_->setReadCB(readCb);
     return result;
   }

bool fizz::AsyncFizzBase::isReplaySafe ( ) const

overridepure virtual

False if the transport does not have replay protection, but will in the future.

Reimplemented from folly::AsyncTransport.

bool fizz::AsyncFizzBase::readable ( ) const

overridepure virtual

Determine if the transport is readable or not.

Returns: true iff the transport is readable, false otherwise.

Implements folly::AsyncTransport.

void fizz::AsyncFizzBase::readBufferAvailable ( std::unique_ptr< folly::IOBuf > )

overrideprivatevirtualnoexcept

readBufferAvailable() will be invoked when data has been successfully read.

Note that only either readBufferAvailable() or readDataAvailable() will be invoked according to the return value of isBufferMovable(). The timing and aftereffect of readBufferAvailable() are the same as readDataAvailable()

Parameters

readBuf The unique pointer of read buffer.

Reimplemented from folly::AsyncReader::ReadCallback.

Definition at line 196 of file AsyncFizzBase.cpp.

References folly::IOBufQueue::append(), checkBufLen(), data, folly::gen::move, transportDataAvailable(), and transportReadBuf_.

                                              {
   DelayedDestruction::DestructorGuard dg(this);
 
   transportReadBuf_.append(std::move(data));
   transportDataAvailable();
   checkBufLen();
 }

void fizz::AsyncFizzBase::readDataAvailable ( size_t len )

overrideprivatevirtualnoexcept

readDataAvailable() will be invoked when data has been successfully read into the buffer returned by the last call to getReadBuffer().

The read callback remains installed after readDataAvailable() returns. It must be explicitly uninstalled to stop receiving read events. getReadBuffer() will be called at least once before each call to readDataAvailable(). getReadBuffer() will also be called before any call to readEOF().

Parameters

len	The number of bytes placed in the buffer.

Implements folly::AsyncReader::ReadCallback.

Definition at line 184 of file AsyncFizzBase.cpp.

References checkBufLen(), folly::IOBufQueue::postallocate(), transportDataAvailable(), and transportReadBuf_.

                                                          {
   DelayedDestruction::DestructorGuard dg(this);
 
   transportReadBuf_.postallocate(len);
   transportDataAvailable();
   checkBufLen();
 }

void fizz::AsyncFizzBase::readEOF ( )

overrideprivatevirtualnoexcept

readEOF() will be invoked when the transport is closed.

The read callback will be automatically uninstalled immediately before readEOF() is invoked.

Implements folly::AsyncReader::ReadCallback.

Definition at line 205 of file AsyncFizzBase.cpp.

References folly::AsyncSocketException::END_OF_FILE, and transportError().

                                      {
   AsyncSocketException eof(AsyncSocketException::END_OF_FILE, "readEOF()");
   transportError(eof);
 }

void fizz::AsyncFizzBase::readErr ( const folly::AsyncSocketException & ex )

overrideprivatevirtualnoexcept

readError() will be invoked if an error occurs reading from the transport.

The read callback will be automatically uninstalled immediately before readError() is invoked.

Parameters

ex	An exception describing the error that occurred.

Implements folly::AsyncReader::ReadCallback.

Definition at line 210 of file AsyncFizzBase.cpp.

References transportError().

                                                                         {
   transportError(ex);
 }

void fizz::AsyncFizzBase::setReadCB ( AsyncFizzBase::ReadCallback * callback )

overridevirtual

Implements folly::AsyncTransportWrapper.

Definition at line 49 of file AsyncFizzBase.cpp.

References appDataBuf_, deliverAppData(), deliverError(), good(), folly::AsyncSocketException::NOT_OPEN, readCallback_, and startTransportReads().

Referenced by detachEventBase(), and isDetachable().

                                                                  {
   readCallback_ = callback;
 
   if (readCallback_) {
     if (appDataBuf_) {
       deliverAppData(nullptr);
     }
 
     if (!good()) {
       AsyncSocketException ex(
           AsyncSocketException::NOT_OPEN,
           "setReadCB() called with transport in bad state");
       deliverError(ex);
     } else {
       // The read callback may have been unset earlier if our buffer was full.
       startTransportReads();
     }
   }
 }

void fizz::AsyncFizzBase::setReplaySafetyCallback ( folly::AsyncTransport::ReplaySafetyCallback * callback )

overridepure virtual

Set the ReplaySafeCallback on this transport.

This should only be called if isReplaySafe() returns false.

Reimplemented from folly::AsyncTransport.

void fizz::AsyncFizzBase::startHandshakeTimeout ( std::chrono::milliseconds timeout )

protectedvirtual

Interface for the derived class to schedule a handshake timeout.

transportError() will be called if the timeout fires before it is cancelled.

Definition at line 92 of file AsyncFizzBase.cpp.

References handshakeTimeout_, and folly::AsyncTimeout::scheduleTimeout().

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

                                                                        {
   handshakeTimeout_.scheduleTimeout(timeout);
 }

void fizz::AsyncFizzBase::startTransportReads ( )

protectedvirtual

Start reading raw data from the transport.

Definition at line 88 of file AsyncFizzBase.cpp.

References folly::DecoratedAsyncTransportWrapper< folly::AsyncTransportWrapper >::transport_.

Referenced by fizz::server::AsyncFizzServerT< SM >::accept(), attachEventBase(), fizz::client::AsyncFizzClientT< SM >::connect(), fizz::client::AsyncFizzClientT< SM >::connectSuccess(), isDetachable(), and setReadCB().

                                         {
   transport_->setReadCB(this);
 }

virtual void fizz::AsyncFizzBase::transportDataAvailable ( )

protectedpure virtual

Alert the derived class that additional data is available in transportReadBuf_.

Referenced by isDetachable(), readBufferAvailable(), and readDataAvailable().

virtual void fizz::AsyncFizzBase::transportError ( const folly::AsyncSocketException & ex )

protectedpure virtual

Alert the derived class that a transport error occured.

Referenced by handshakeTimeoutExpired(), isDetachable(), readEOF(), readErr(), and writeErr().

virtual void fizz::AsyncFizzBase::writeAppData	(	folly::AsyncTransportWrapper::WriteCallback *	callback,
		std::unique_ptr< folly::IOBuf > &&	buf,
		folly::WriteFlags	flags = `folly::WriteFlags::NONE`
	)

protectedpure virtual

Interface for the derived class to implement to receive app data from the app layer.

Referenced by isDetachable(), and writeChain().

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

overridevirtual

It only makes sense to use this class if you override writeChain, so force derived classes to do that.

Implements folly::WriteChainAsyncTransportWrapper< folly::AsyncTransportWrapper >.

Definition at line 69 of file AsyncFizzBase.cpp.

References appBytesWritten_, folly::gen::move, and writeAppData().

                            {
   appBytesWritten_ += buf->computeChainDataLength();
 
   // TODO: break up buf into multiple records
 
   writeAppData(callback, std::move(buf), flags);
 }

void fizz::AsyncFizzBase::writeErr	(	size_t	bytesWritten,
		const folly::AsyncSocketException &	ex
	)

overrideprivatevirtualnoexcept

writeError() will be invoked if an error occurs writing the data.

Parameters

bytesWritten	The number of bytes that were successfull
ex	An exception describing the error that occurred.

Implements folly::AsyncWriter::WriteCallback.

Definition at line 216 of file AsyncFizzBase.cpp.

References transportError().

                                                   {
   transportError(ex);
 }

void fizz::AsyncFizzBase::writeSuccess ( )

overrideprivatevirtualnoexcept

WriteCallback implementation, for use with handshake messages.

Implements folly::AsyncWriter::WriteCallback.

Definition at line 214 of file AsyncFizzBase.cpp.

214 {}

Member Data Documentation

size_t fizz::AsyncFizzBase::appBytesReceived_ {0}

private

Definition at line 236 of file AsyncFizzBase.h.

Referenced by deliverAppData(), and getAppBytesReceived().

size_t fizz::AsyncFizzBase::appBytesWritten_ {0}

private

Definition at line 235 of file AsyncFizzBase.h.

Referenced by getAppBytesWritten(), and writeChain().

std::unique_ptr<folly::IOBuf> fizz::AsyncFizzBase::appDataBuf_

private

Definition at line 233 of file AsyncFizzBase.h.

Referenced by checkBufLen(), deliverAppData(), and setReadCB().

HandshakeTimeout fizz::AsyncFizzBase::handshakeTimeout_

private

Definition at line 238 of file AsyncFizzBase.h.

Referenced by attachEventBase(), attachTimeoutManager(), cancelHandshakeTimeout(), detachEventBase(), detachTimeoutManager(), isDetachable(), and startHandshakeTimeout().

ReadCallback* fizz::AsyncFizzBase::readCallback_ {nullptr}

private

Definition at line 232 of file AsyncFizzBase.h.

Referenced by attachEventBase(), checkBufLen(), deliverAppData(), deliverError(), getReadCallback(), and setReadCB().

folly::IOBufQueue fizz::AsyncFizzBase::transportReadBuf_ {folly::IOBufQueue::cacheChainLength()}

protected

Definition at line 206 of file AsyncFizzBase.h.

Referenced by checkBufLen(), getReadBuffer(), readBufferAvailable(), and readDataAvailable().

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

proxygen/fizz/fizz/protocol/AsyncFizzBase.h
proxygen/fizz/fizz/protocol/AsyncFizzBase.cpp

Classes

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation