proxygen
folly::MockAsyncSSLSocket Class Reference
Inheritance diagram for folly::MockAsyncSSLSocket:
folly::AsyncSSLSocket folly::AsyncSocket folly::AsyncTransportWrapper folly::AsyncTransport folly::AsyncReader folly::AsyncWriter folly::DelayedDestruction folly::AsyncSocketBase folly::DelayedDestructionBase

Public Member Functions

 MockAsyncSSLSocket (const std::shared_ptr< SSLContext > &ctx, EventBase *evb)
 
 MOCK_METHOD3 (sslWriteImpl, int(SSL *ssl, const void *buf, int n))
 
 MOCK_CONST_METHOD0 (getRawBytesWritten, size_t())
 
WriteResult testPerformWrite (const iovec *vec, uint32_t count, WriteFlags flags, uint32_t *countWritten, uint32_t *partialWritten)
 
void checkEor (size_t appEor, size_t rawEor)
 
void setAppBytesWritten (size_t n)
 
- Public Member Functions inherited from folly::AsyncSSLSocket
 AsyncSSLSocket (const std::shared_ptr< folly::SSLContext > &ctx, EventBase *evb, bool deferSecurityNegotiation=false)
 
 AsyncSSLSocket (const std::shared_ptr< folly::SSLContext > &ctx, EventBase *evb, int fd, bool server=true, bool deferSecurityNegotiation=false)
 
 AsyncSSLSocket (const std::shared_ptr< folly::SSLContext > &ctx, AsyncSocket::UniquePtr oldAsyncSocket, bool server=true, bool deferSecurityNegotiation=false)
 
void closeNow () override
 
void shutdownWrite () override
 
void shutdownWriteNow () override
 
bool good () const override
 
bool connecting () const override
 
std::string getApplicationProtocol () const noexceptoverride
 
std::string getSecurityProtocol () const override
 
void setEorTracking (bool track) override
 
size_t getRawBytesWritten () const override
 
size_t getRawBytesReceived () const override
 
void enableClientHelloParsing ()
 
virtual void sslAccept (HandshakeCB *callback, std::chrono::milliseconds timeout=std::chrono::milliseconds::zero(), const folly::SSLContext::SSLVerifyPeerEnum &verifyPeer=folly::SSLContext::SSLVerifyPeerEnum::USE_CTX)
 
void restartSSLAccept ()
 
void connect (ConnectCallback *callback, const folly::SocketAddress &address, int timeout=0, const OptionMap &options=emptyOptionMap, const folly::SocketAddress &bindAddr=anyAddress()) noexceptoverride
 
virtual void connect (ConnectCallback *callback, const folly::SocketAddress &address, std::chrono::milliseconds connectTimeout, std::chrono::milliseconds totalConnectTimeout, const OptionMap &options=emptyOptionMap, const folly::SocketAddress &bindAddr=anyAddress()) noexcept
 
virtual void sslConn (HandshakeCB *callback, std::chrono::milliseconds timeout=std::chrono::milliseconds::zero(), const folly::SSLContext::SSLVerifyPeerEnum &verifyPeer=folly::SSLContext::SSLVerifyPeerEnum::USE_CTX)
 
SSLStateEnum getSSLState () const
 
SSL_SESSION * getSSLSession ()
 
const SSL * getSSL () const
 
void setSSLSession (SSL_SESSION *session, bool takeOwnership=false)
 
virtual void getSelectedNextProtocol (const unsigned char **protoName, unsigned *protoLen) const
 
virtual bool getSelectedNextProtocolNoThrow (const unsigned char **protoName, unsigned *protoLen) const
 
virtual bool getSSLSessionReused () const
 
bool sessionIDResumed () const
 
void setSessionIDResumed (bool resumed)
 
virtual const char * getNegotiatedCipherName () const
 
const char * getSSLServerName () const
 
const char * getSSLServerNameNoThrow () const
 
int getSSLVersion () const
 
const char * getSSLCertSigAlgName () const
 
int getSSLCertSize () const
 
const X509 * getSelfCert () const override
 
void attachEventBase (EventBase *eventBase) override
 
void detachEventBase () override
 
bool isDetachable () const override
 
virtual void attachTimeoutManager (TimeoutManager *manager)
 
virtual void detachTimeoutManager ()
 
const std::shared_ptr< folly::SSLContext > & getSSLContext () const
 
void timeoutExpired (std::chrono::milliseconds timeout) noexcept
 
void getSSLClientCiphers (std::string &clientCiphers, bool convertToString=true) const
 
std::string getSSLClientComprMethods () const
 
std::string getSSLClientExts () const
 
std::string getSSLClientSigAlgs () const
 
std::string getSSLClientSupportedVersions () const
 
std::string getSSLAlertsReceived () const
 
void setSSLCertVerificationAlert (std::string alert)
 
std::string getSSLCertVerificationAlert () const
 
void getSSLSharedCiphers (std::string &sharedCiphers) const
 
void getSSLServerCiphers (std::string &serverCiphers) const
 
bool needsPeerVerification () const
 
void resetClientHelloParsing (SSL *ssl)
 
ssl::ClientHelloInfogetClientHelloInfo () const
 
virtual std::chrono::nanoseconds getHandshakeTime () const
 
void setMinWriteSize (size_t minWriteSize)
 
size_t getMinWriteSize () const
 
void setReadCB (ReadCallback *callback) override
 
void setBufferMovableEnabled (bool enabled)
 
const AsyncTransportCertificategetPeerCertificate () const override
 
const AsyncTransportCertificategetSelfCertificate () const override
 
ssl::X509UniquePtr getPeerCert () const override
 
void forceCacheAddrOnFailure (bool force)
 
const std::stringgetSessionKey () const
 
void setSessionKey (std::string sessionKey)
 
void setCertCacheHit (bool hit)
 
bool getCertCacheHit () const
 
bool sessionResumptionAttempted () const
 
std::chrono::milliseconds getTotalConnectTimeout () const
 
void setAsyncOperationFinishCallback (std::unique_ptr< ReadCallback > cb)
 
- Public Member Functions inherited from folly::AsyncSocket
 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
 
EventBasegetEventBase () const override
 
virtual int getFd () const
 
virtual int detachFd ()
 
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 ErrMessageCallbackgetErrMessageCallback () const
 
virtual void setSendMsgParamCB (SendMsgParamsCallback *callback)
 
virtual SendMsgParamsCallbackgetSendMsgParamsCB () const
 
ReadCallbackgetReadCallback () 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 closeWithReset () override
 
bool readable () const override
 
bool writable () const override
 
bool isPending () const override
 
virtual bool hangup () const
 
bool error () const override
 
void getLocalAddress (folly::SocketAddress *address) const override
 
void getPeerAddress (folly::SocketAddress *address) const override
 
bool isEorTrackingEnabled () const override
 
virtual bool isClosedByPeer () const
 
virtual bool isClosedBySelf () const
 
size_t getAppBytesWritten () const override
 
size_t getAppBytesReceived () 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)
 
void setSelfCertificate (std::unique_ptr< const AsyncTransportCertificate > cert)
 
- Public Member Functions inherited from folly::AsyncTransportWrapper
virtual const AsyncTransportWrappergetWrappedTransport () const
 
template<class T >
const TgetUnderlyingTransport () const
 
template<class T >
TgetUnderlyingTransport ()
 
- Public Member Functions inherited from folly::AsyncTransport
SocketAddress getLocalAddress () const
 
void getAddress (SocketAddress *address) const override
 
SocketAddress getPeerAddress () 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< MockAsyncSSLSocketnewSocket (const std::shared_ptr< SSLContext > &ctx, EventBase *evb)
 
- Static Public Member Functions inherited from folly::AsyncSSLSocket
static std::shared_ptr< AsyncSSLSocketnewSocket (const std::shared_ptr< folly::SSLContext > &ctx, EventBase *evb, int fd, bool server=true, bool deferSecurityNegotiation=false)
 
static std::shared_ptr< AsyncSSLSocketnewSocket (const std::shared_ptr< folly::SSLContext > &ctx, EventBase *evb, bool deferSecurityNegotiation=false)
 
static int getSSLExDataIndex ()
 
static AsyncSSLSocketgetFromSSL (const SSL *ssl)
 
static int bioWrite (BIO *b, const char *in, int inl)
 
static int bioRead (BIO *b, char *out, int outl)
 
static void clientHelloParsingCallback (int write_p, int version, int content_type, const void *buf, size_t len, SSL *ssl, void *arg)
 
static const char * getSSLServerNameFromSSL (SSL *ssl)
 
- Static Public Member Functions inherited from folly::AsyncSocket
static std::shared_ptr< AsyncSocketnewSocket (EventBase *evb)
 
static std::shared_ptr< AsyncSocketnewSocket (EventBase *evb, const folly::SocketAddress &address, uint32_t connectTimeout=0)
 
static std::shared_ptr< AsyncSocketnewSocket (EventBase *evb, const std::string &ip, uint16_t port, uint32_t connectTimeout=0)
 
static std::shared_ptr< AsyncSocketnewSocket (EventBase *evb, int fd)
 
static const folly::SocketAddressanyAddress ()
 

Additional Inherited Members

- Public Types inherited from folly::AsyncSSLSocket
enum  SSLStateEnum {
  STATE_UNINIT, STATE_UNENCRYPTED, STATE_ACCEPTING, STATE_CACHE_LOOKUP,
  STATE_ASYNC_PENDING, STATE_CONNECTING, STATE_ESTABLISHED, STATE_REMOTE_CLOSED,
  STATE_CLOSING, STATE_CONNECTING_CLOSING, STATE_CLOSED, STATE_ERROR
}
 
typedef std::unique_ptr< AsyncSSLSocket, DestructorUniquePtr
 
using X509_deleter = folly::static_function_deleter< X509,&X509_free >
 
- Public Types inherited from folly::AsyncSocket
enum  StateEnum : uint8_t {
  StateEnum::UNINIT, StateEnum::CONNECTING, StateEnum::ESTABLISHED, StateEnum::CLOSED,
  StateEnum::ERROR, StateEnum::FAST_OPEN
}
 
typedef std::unique_ptr< AsyncSocket, DestructorUniquePtr
 
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, DestructorUniquePtr
 
- Static Public Attributes inherited from folly::AsyncSocket
static const OptionMap emptyOptionMap
 
- Protected Types inherited from folly::AsyncSocket
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 inherited from folly::AsyncSSLSocket
 ~AsyncSSLSocket () override
 
void prepareReadBuffer (void **buf, size_t *buflen) override
 
void handleRead () noexceptoverride
 
void handleWrite () noexceptoverride
 
void handleAccept () noexcept
 
void handleConnect () noexceptoverride
 
void invalidState (HandshakeCB *callback)
 
bool willBlock (int ret, int *sslErrorOut, unsigned long *errErrorOut) noexcept
 
void checkForImmediateRead () noexceptoverride
 
void handleInitialReadWrite () noexceptoverride
 
WriteResult interpretSSLError (int rc, int error)
 
ReadResult performRead (void **buf, size_t *buflen, size_t *offset) override
 
WriteResult performWrite (const iovec *vec, uint32_t count, WriteFlags flags, uint32_t *countWritten, uint32_t *partialWritten) override
 
ssize_t performWriteIovec (const iovec *vec, uint32_t count, WriteFlags flags, uint32_t *countWritten, uint32_t *partialWritten)
 
virtual int sslWriteImpl (SSL *ssl, const void *buf, int n)
 
void applyVerificationOptions (const ssl::SSLUniquePtr &ssl)
 
bool setupSSLBio ()
 
int eorAwareSSLWrite (const ssl::SSLUniquePtr &ssl, const void *buf, int n, bool eor)
 
void failHandshake (const char *fn, const AsyncSocketException &ex)
 
void invokeHandshakeErr (const AsyncSocketException &ex)
 
void invokeHandshakeCB ()
 
void invokeConnectErr (const AsyncSocketException &ex) override
 
void invokeConnectSuccess () override
 
void scheduleConnectTimeout () override
 
void startSSLConnect ()
 
- Protected Member Functions inherited from folly::AsyncSocket
 ~AsyncSocket () override
 
void init ()
 
void scheduleImmediateRead () noexcept
 
void scheduleInitialReadWrite () noexcept
 
void ioReady (uint16_t events) noexcept
 
virtual size_t handleErrMessages () noexcept
 
void timeoutExpired () noexcept
 
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)
 
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)
 
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)
 
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
 
- Static Protected Member Functions inherited from folly::AsyncSSLSocket
static void sslInfoCallback (const SSL *ssl, int type, int val)
 
static int sslVerifyCallback (int preverifyOk, X509_STORE_CTX *ctx)
 
- Protected Attributes inherited from folly::AsyncSSLSocket
bool corkCurrentWrite_ {false}
 
bool server_ {false}
 
bool handshakeComplete_ {false}
 
bool renegotiateAttempted_ {false}
 
SSLStateEnum sslState_ {STATE_UNINIT}
 
std::shared_ptr< folly::SSLContextctx_
 
HandshakeCBhandshakeCallback_ {nullptr}
 
ssl::SSLUniquePtr ssl_
 
SSL_SESSION * sslSession_ {nullptr}
 
Timeout handshakeTimeout_
 
Timeout connectionTimeout_
 
size_t appEorByteNo_ {0}
 
size_t minWriteSize_ {1500}
 
size_t minEorRawByteNo_ {0}
 
std::string sessionKey_
 
folly::SSLContext::SSLVerifyPeerEnum verifyPeer_
 
bool parseClientHello_ {false}
 
bool cacheAddrOnFailure_ {false}
 
bool bufferMovableEnabled_ {false}
 
bool certCacheHit_ {false}
 
std::unique_ptr< ssl::ClientHelloInfoclientHelloInfo_
 
std::vector< std::pair< char, StringPiece > > alertsReceived_
 
std::chrono::steady_clock::time_point handshakeStartTime_
 
std::chrono::steady_clock::time_point handshakeEndTime_
 
std::chrono::milliseconds handshakeConnectTimeout_ {0}
 
std::chrono::milliseconds totalConnectTimeout_ {0}
 
std::string sslVerificationAlert_
 
bool sessionResumptionAttempted_ {false}
 
bool sessionIDResumed_ {false}
 
std::unique_ptr< ReadCallbackasyncOperationFinishCallback_
 
- Protected Attributes inherited from folly::AsyncSocket
uint32_t zeroCopyBufId_ {0}
 
std::unordered_map< uint32_t, folly::IOBuf * > idZeroCopyBufPtrMap_
 
std::unordered_map< folly::IOBuf *, IOBufInfoidZeroCopyBufInfoMap_
 
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...
 
EventBaseeventBase_
 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...
 
ConnectCallbackconnectCallback_
 ConnectCallback. More...
 
ErrMessageCallbackerrMessageCallback_
 TimestampCallback. More...
 
SendMsgParamsCallbacksendMsgParamCallback_
 < Callback for retrieving More...
 
ReadCallbackreadCallback_
 ReadCallback. More...
 
WriteRequestwriteReqHead_
 Chain of WriteRequests. More...
 
WriteRequestwriteReqTail_
 End of WriteRequest chain. More...
 
std::weak_ptr< ShutdownSocketSetwShutdownSocketSet_
 
size_t appBytesReceived_
 Num of bytes received from socket. More...
 
size_t appBytesWritten_
 Num of bytes written to socket. More...
 
std::unique_ptr< IOBufpreReceivedData_
 
std::chrono::steady_clock::time_point connectStartTime_
 
std::chrono::steady_clock::time_point connectEndTime_
 
std::chrono::milliseconds connectTimeout_ {0}
 
std::unique_ptr< EvbChangeCallbackevbChangeCb_ {nullptr}
 
BufferCallbackbufferCallback_ {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 AsyncTransportCertificatepeerCertData_
 
std::unique_ptr< const AsyncTransportCertificateselfCertData_
 

Detailed Description

Definition at line 31 of file AsyncSSLSocketWriteTest.cpp.

Constructor & Destructor Documentation

folly::MockAsyncSSLSocket::MockAsyncSSLSocket ( const std::shared_ptr< SSLContext > &  ctx,
EventBase evb 
)
inline

Definition at line 45 of file AsyncSSLSocketWriteTest.cpp.

References MOCK_CONST_METHOD0, and MOCK_METHOD3.

46  : AsyncSocket(evb), AsyncSSLSocket(ctx, evb) {
48  sslState_ = AsyncSSLSocket::SSLStateEnum::STATE_ESTABLISHED;
49  }
AsyncSSLSocket(const std::shared_ptr< folly::SSLContext > &ctx, EventBase *evb, bool deferSecurityNegotiation=false)
StateEnum state_
StateEnum describing current state.
Definition: AsyncSocket.h:1226

Member Function Documentation

void folly::MockAsyncSSLSocket::checkEor ( size_t  appEor,
size_t  rawEor 
)
inline

Definition at line 67 of file AsyncSSLSocketWriteTest.cpp.

References EXPECT_EQ.

67  {
68  EXPECT_EQ(appEor, appEorByteNo_);
69  EXPECT_EQ(rawEor, minEorRawByteNo_);
70  }
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922
folly::MockAsyncSSLSocket::MOCK_CONST_METHOD0 ( getRawBytesWritten  ,
size_t()   
)
folly::MockAsyncSSLSocket::MOCK_METHOD3 ( sslWriteImpl  ,
int(SSL *ssl, const void *buf, int n)   
)
static std::shared_ptr<MockAsyncSSLSocket> folly::MockAsyncSSLSocket::newSocket ( const std::shared_ptr< SSLContext > &  ctx,
EventBase evb 
)
inlinestatic

Definition at line 33 of file AsyncSSLSocketWriteTest.cpp.

35  {
36  auto sock = std::shared_ptr<MockAsyncSSLSocket>(
37  new MockAsyncSSLSocket(ctx, evb), Destructor());
38  sock->ssl_.reset(SSL_new(ctx->getSSLCtx()));
39  SSL_set_fd(sock->ssl_.get(), -1);
40  return sock;
41  }
MockAsyncSSLSocket(const std::shared_ptr< SSLContext > &ctx, EventBase *evb)
void folly::MockAsyncSSLSocket::setAppBytesWritten ( size_t  n)
inline

Definition at line 72 of file AsyncSSLSocketWriteTest.cpp.

72  {
73  appBytesWritten_ = n;
74  }
size_t appBytesWritten_
Num of bytes written to socket.
Definition: AsyncSocket.h:1254
WriteResult folly::MockAsyncSSLSocket::testPerformWrite ( const iovec *  vec,
uint32_t  count,
WriteFlags  flags,
uint32_t countWritten,
uint32_t partialWritten 
)
inline

Definition at line 58 of file AsyncSSLSocketWriteTest.cpp.

63  {
64  return performWrite(vec, count, flags, countWritten, partialWritten);
65  }
flags
Definition: http_parser.h:127
WriteResult performWrite(const iovec *vec, uint32_t count, WriteFlags flags, uint32_t *countWritten, uint32_t *partialWritten) override
Definition: Traits.h:588
int * count

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