37 #include <sys/types.h> 38 #include <condition_variable> 58 socket_->setSendMsgParamCB(
this);
105 ancillaryData_.swap(
data);
109 if (ancillaryData_.size()) {
110 std::cerr <<
"getAncillaryData: copying data" << std::endl;
111 memcpy(
data, ancillaryData_.data(), ancillaryData_.size());
118 if (ancillaryData_.size()) {
119 std::cerr <<
"getAncillaryDataSize: returning size" << std::endl;
120 return ancillaryData_.size();
144 mcb_->setSocket(socket);
149 std::cerr <<
"writeSuccess" << std::endl;
154 size_t nBytesWritten,
156 std::cerr <<
"writeError: bytesWritten " << nBytesWritten <<
", exception " 157 << ex.what() << std::endl;
160 this->bytesWritten = nBytesWritten;
181 AsyncSocketException::AsyncSocketExceptionType::NETWORK_ERROR);
188 #ifdef FOLLY_HAVE_MSG_ERRQUEUE 191 enum SOF_TIMESTAMPING {
192 SOF_TIMESTAMPING_TX_SOFTWARE = (1 << 1),
193 SOF_TIMESTAMPING_SOFTWARE = (1 << 4),
194 SOF_TIMESTAMPING_OPT_ID = (1 << 7),
195 SOF_TIMESTAMPING_TX_SCHED = (1 << 8),
196 SOF_TIMESTAMPING_TX_ACK = (1 << 9),
197 SOF_TIMESTAMPING_OPT_TSONLY = (1 << 11),
205 ~WriteCheckTimestampCallback()
override {
211 void setSocket(
const std::shared_ptr<AsyncSSLSocket>&
socket)
override {
215 int flags = SOF_TIMESTAMPING_OPT_ID | SOF_TIMESTAMPING_OPT_TSONLY |
216 SOF_TIMESTAMPING_SOFTWARE;
222 void checkForTimestampNotifications()
noexcept {
224 std::vector<char> ctrl(1024, 0);
229 memset(&msg, 0,
sizeof(msg));
230 entry.iov_base = &
data;
231 entry.iov_len =
sizeof(
data);
232 msg.msg_iov = &entry;
234 msg.msg_control = ctrl.data();
235 msg.msg_controllen = ctrl.size();
239 ret =
recvmsg(fd, &msg, MSG_ERRQUEUE);
241 if (errno != EAGAIN) {
242 auto errnoCopy = errno;
243 std::cerr <<
"::recvmsg exited with code " << ret
244 <<
", errno: " << errnoCopy << std::endl;
254 for (
struct cmsghdr* cmsg = CMSG_FIRSTHDR(&msg);
255 cmsg !=
nullptr && cmsg->cmsg_len != 0;
256 cmsg = CMSG_NXTHDR(&msg, cmsg)) {
257 if (cmsg->cmsg_level == SOL_SOCKET &&
258 cmsg->cmsg_type == SCM_TIMESTAMPING) {
259 gotTimestamp_ =
true;
263 if ((cmsg->cmsg_level == SOL_IP && cmsg->cmsg_type == IP_RECVERR) ||
264 (cmsg->cmsg_level == SOL_IPV6 && cmsg->cmsg_type == IPV6_RECVERR)) {
272 bool gotTimestamp_{
false};
273 bool gotByteSeq_{
false};
275 #endif // FOLLY_HAVE_MSG_ERRQUEUE 298 std::cerr <<
"readError " << ex.what() << std::endl;
304 std::cerr <<
"readEOF" << std::endl;
320 for (std::vector<Buffer>::iterator it = buffers.begin();
325 currentBuffer.free();
329 if (!currentBuffer.buffer) {
330 currentBuffer.allocate(4096);
332 *bufReturn = currentBuffer.buffer;
333 *lenReturn = currentBuffer.length;
337 std::cerr <<
"readDataAvailable, len " << len << std::endl;
339 currentBuffer.length = len;
344 socket_->write(wcb_, currentBuffer.buffer, len);
346 buffers.push_back(currentBuffer);
347 currentBuffer.reset();
361 assert(
buffer ==
nullptr);
362 this->
buffer =
static_cast<char*
>(malloc(len));
384 *bufReturn =
nullptr;
395 std::cerr <<
"ReadErrorCallback::readError" << std::endl;
406 *bufReturn =
nullptr;
426 std::cerr <<
"readDataAvailable, len " << len << std::endl;
428 currentBuffer.length = len;
437 [&] {
socket_->write(wcb_, currentBuffer.buffer, len); });
445 buffers.push_back(currentBuffer);
446 currentBuffer.reset();
450 std::cerr <<
"readError " << ex.what() << std::endl;
460 std::cerr <<
"readError " << ex.what() << std::endl;
468 std::cerr <<
"readEOF" << std::endl;
498 std::lock_guard<std::mutex>
g(
mutex_);
501 std::cerr <<
"HandshakeCallback::connectionAccepted" << std::endl;
503 sock->setReadCB(rcb_);
509 std::lock_guard<std::mutex>
g(
mutex_);
511 std::cerr <<
"HandshakeCallback::handshakeError " << ex.what() << std::endl;
513 if (expect_ == EXPECT_ERROR) {
517 errorString_ = ex.what();
543 std::condition_variable
cv_;
563 const std::shared_ptr<folly::AsyncSSLSocket>&
s)
noexcept override {
565 std::cerr <<
"SSLServerAcceptCallback::connAccepted" << std::endl;
567 hcb_->setSocket(sock);
568 sock->
sslAccept(hcb_, std::chrono::milliseconds(timeout_));
581 const std::shared_ptr<folly::AsyncSSLSocket>&
s)
noexcept override {
584 std::cerr <<
"SSLServerAcceptCallbackDelay::connAccepted" << std::endl;
585 int fd = sock->
getFd();
591 socklen_t valueLength =
sizeof(
value);
592 int rc =
getsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &value, &valueLength);
600 socklen_t valueLength =
sizeof(
value);
601 int rc =
setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &value, valueLength);
604 rc =
getsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &value, &valueLength);
620 const std::shared_ptr<folly::AsyncSSLSocket>&
s)
noexcept override {
623 std::cerr <<
"SSLServerAcceptCallback::connAccepted" << std::endl;
625 hcb_->setSocket(sock);
626 sock->
sslAccept(hcb_, std::chrono::milliseconds(timeout_));
641 const std::shared_ptr<folly::AsyncSSLSocket>&
s)
noexcept override {
644 std::cerr <<
"HandshakeErrorCallback::connAccepted" << std::endl;
647 hcb_->setSocket(sock);
653 callback2.setSocket(sock);
654 sock->sslAccept(&callback2);
673 const std::shared_ptr<folly::AsyncSSLSocket>&
s)
noexcept override {
674 std::cerr <<
"HandshakeErrorCallback::connAccepted" << std::endl;
678 hcb_->setSocket(sock);
681 std::cerr <<
"Delayed SSL accept, client will have close by now" 685 hcb_->socket_->sslAccept(hcb_);
705 const std::shared_ptr<folly::AsyncSSLSocket>&
s)
noexcept override {
706 std::cerr <<
"ConnectTimeoutCallback::connAccepted" << std::endl;
710 s->getEventBase()->tryRunAfterDelay([=] {
s->close(); }, 100);
718 int lookupDelay = 100)
720 SSL_CTX* sslCtx =
ctx_->getSSLCtx();
721 #ifdef SSL_ERROR_WANT_SESS_CACHE_LOOKUP 722 SSL_CTX_sess_set_get_cb(
725 SSL_CTX_set_session_cache_mode(
726 sslCtx, SSL_SESS_CACHE_NO_INTERNAL | SSL_SESS_CACHE_SERVER);
729 lookupDelay_ = lookupDelay;
733 return asyncCallbacks_;
736 return asyncLookups_;
752 #ifdef SSL_ERROR_WANT_SESS_CACHE_LOOKUP 753 if (!SSL_want_sess_cache_lookup(ssl)) {
755 std::cerr <<
"no async support" << std::endl;
760 assert(sslSocket !=
nullptr);
762 if (asyncCallbacks_ % 2 == 0) {
764 std::cerr <<
"returning miss" << std::endl;
767 std::cerr <<
"async lookup" << std::endl;
771 *copyflag = SSL_SESSION_CB_WOULD_BLOCK;
782 std::shared_ptr<folly::SSLContext> clientCtx,
783 std::shared_ptr<folly::SSLContext> serverCtx);
796 buf_ = std::make_unique<uint8_t[]>(bufLen_);
797 for (
uint32_t n = 0; n <
sizeof(buf_); ++n) {
802 iov_ = std::make_unique<struct iovec[]>(iovCount_);
803 for (
uint32_t n = 0; n < iovCount_; ++n) {
804 iov_[n].iov_base = buf_.get() + n;
806 iov_[n].iov_len = n % bufLen_;
808 iov_[n].iov_len = bufLen_ - (n % bufLen_);
812 socket_->sslConn(
this, std::chrono::milliseconds(100));
824 socket_->writev(
this, iov_.get(), iovCount_);
829 ADD_FAILURE() <<
"client handshake error: " << ex.what();
837 ADD_FAILURE() <<
"client write error after " << bytesWritten
838 <<
" bytes: " << ex.what();
844 std::unique_ptr<uint8_t[]>
buf_;
845 std::unique_ptr<struct iovec[]>
iov_;
852 :
socket_(
std::
move(socket)), bufSize_(2500 * 2000), bytesRead_(0) {
853 buf_ = std::make_unique<uint8_t[]>(bufSize_);
854 socket_->sslAccept(
this, std::chrono::milliseconds(100));
860 size_t bytesLeft = bytesRead_ - idx;
864 std::min(iov[n].iov_len, bytesLeft));
866 FAIL() <<
"buffer mismatch at iovec " << n <<
"/" << count
869 if (iov[n].iov_len > bytesLeft) {
870 FAIL() <<
"server did not read enough data: " 871 <<
"ended at byte " << bytesLeft <<
"/" << iov[n].iov_len
872 <<
" in iovec " << n <<
"/" <<
count;
875 idx += iov[n].iov_len;
877 if (idx != bytesRead_) {
878 ADD_FAILURE() <<
"server read extra data: " << bytesRead_
879 <<
" bytes read; expected " << idx;
886 socket_->getEventBase()->tryRunAfterDelay(
887 [
this] {
socket_->setReadCB(
this); }, 10);
892 ADD_FAILURE() <<
"server handshake error: " << ex.what();
895 *bufReturn = buf_.get() + bytesRead_;
896 *lenReturn = bufSize_ - bytesRead_;
901 socket_->getEventBase()->tryRunAfterDelay(
902 [
this] {
socket_->setReadCB(
this); }, 2);
908 ADD_FAILURE() <<
"server read error: " << ex.what();
914 std::unique_ptr<uint8_t[]>
buf_;
931 socket_->getSelectedNextProtocol(&nextProto, &nextProtoLength);
944 ADD_FAILURE() <<
"client write error after " << bytesWritten
945 <<
" bytes: " << ex.what();
965 socket_->getSelectedNextProtocol(&nextProto, &nextProtoLength);
980 ADD_FAILURE() <<
"server read error: " << ex.what();
999 LOG(
INFO) <<
"Renegotiating server handshake success";
1005 ADD_FAILURE() <<
"Renegotiating server handshake error: " << ex.what();
1008 *lenReturn =
sizeof(buf);
1014 LOG(
INFO) <<
"server got read error " << ex.what();
1019 ASSERT_NE(std::string::npos, exStr.find(sslEx.what()));
1020 renegotiationError_ =
true;
1024 unsigned char buf[128];
1025 bool renegotiationError_{
false};
1028 #ifndef OPENSSL_NO_TLSEXT 1041 serverNameMatch =
socket_->isServerNameMatch();
1046 ADD_FAILURE() <<
"client handshake error: " << ex.what();
1052 size_t bytesWritten,
1054 ADD_FAILURE() <<
"client write error after " << bytesWritten
1055 <<
" bytes: " << ex.what();
1066 const std::shared_ptr<folly::SSLContext>& ctx,
1067 const std::shared_ptr<folly::SSLContext>& sniCtx,
1069 : serverNameMatch(false),
1072 expectedServerName_(expectedServerName) {
1073 ctx->setServerNameCallback(
1085 ADD_FAILURE() <<
"server handshake error: " << ex.what();
1095 ADD_FAILURE() <<
"server read error: " << ex.what();
1099 const char* sn = SSL_get_servername(ssl, TLSEXT_NAMETYPE_host_name);
1100 if (sniCtx_ && sn && !strcasecmp(expectedServerName_.c_str(), sn)) {
1102 sslSocket->switchServerSSLContext(sniCtx_);
1103 serverNameMatch =
true;
1104 return folly::SSLContext::SERVER_NAME_FOUND;
1106 serverNameMatch =
false;
1107 return folly::SSLContext::SERVER_NAME_NOT_FOUND;
1124 std::shared_ptr<folly::SSLContext>
ctx_;
1139 static constexpr
size_t kMaxReadsPerEvent = 2;
1141 static constexpr
size_t kMaxReadBufferSz =
1142 sizeof(decltype(readbuf_)) / kMaxReadsPerEvent / 2;
1150 : eventBase_(eventBase),
1152 requests_(requests),
1159 writeAfterConnectErrors_(0) {
1161 ctx_->setOptions(SSL_OP_NO_TICKET);
1162 ctx_->ciphers(
"ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH");
1163 memset(buf_,
'a',
sizeof(buf_));
1168 SSL_SESSION_free(session_);
1188 return writeAfterConnectErrors_;
1193 if (session_ !=
nullptr) {
1194 sslSocket_->setSSLSession(session_);
1197 sslSocket_->connect(
this, address_, timeout_);
1198 if (sslSocket_ && writeNow) {
1200 sslSocket_->write(
this, buf_,
sizeof(buf_));
1205 std::cerr <<
"client SSL socket connected" << std::endl;
1206 if (sslSocket_->getSSLSessionReused()) {
1210 if (session_ !=
nullptr) {
1211 SSL_SESSION_free(session_);
1213 session_ = sslSocket_->getSSLSession();
1217 sslSocket_->setMaxReadsPerEvent(kMaxReadsPerEvent);
1218 sslSocket_->write(
this, buf_,
sizeof(buf_));
1219 sslSocket_->setReadCB(
this);
1220 memset(readbuf_,
'b',
sizeof(readbuf_));
1225 std::cerr <<
"SSLClient::connectError: " << ex.what() << std::endl;
1231 std::cerr <<
"client write success" << std::endl;
1237 std::cerr <<
"client writeError: " << ex.what() << std::endl;
1239 writeAfterConnectErrors_++;
1244 *bufReturn = readbuf_ + bytesRead_;
1245 *lenReturn =
std::min(kMaxReadBufferSz,
sizeof(readbuf_) - bytesRead_);
1249 std::cerr <<
"client readEOF" << std::endl;
1253 std::cerr <<
"client readError: " << ex.what() << std::endl;
1257 std::cerr <<
"client read data: " << len << std::endl;
1259 if (bytesRead_ ==
sizeof(buf_)) {
1260 EXPECT_EQ(memcmp(buf_, readbuf_, bytesRead_), 0);
1261 sslSocket_->closeNow();
1263 if (requests_ != 0) {
1275 bool preverifyResult,
1277 : handshakeVerify_(false),
1278 handshakeSuccess_(false),
1279 handshakeError_(false),
1281 preverifyResult_(preverifyResult),
1282 verifyResult_(verifyResult) {}
1302 X509_STORE_CTX* )
noexcept override {
1303 handshakeVerify_ =
true;
1305 EXPECT_EQ(preverifyResult_, preverifyOk);
1306 return verifyResult_;
1310 LOG(
INFO) <<
"Handshake success";
1311 handshakeSuccess_ =
true;
1313 handshakeTime = socket_->getHandshakeTime();
1320 LOG(
INFO) <<
"Handshake error " << ex.what();
1321 handshakeError_ =
true;
1323 handshakeTime = socket_->getHandshakeTime();
1335 size_t bytesWritten,
1337 ADD_FAILURE() <<
"client write error after " << bytesWritten
1338 <<
" bytes: " << ex.what();
1346 bool preverifyResult,
1349 socket_->sslConn(
this, std::chrono::milliseconds::zero());
1357 bool preverifyResult,
1362 std::chrono::milliseconds::zero(),
1363 folly::SSLContext::SSLVerifyPeerEnum::NO_VERIFY);
1371 bool preverifyResult,
1376 std::chrono::milliseconds::zero(),
1377 folly::SSLContext::SSLVerifyPeerEnum::VERIFY);
1385 bool preverifyResult,
1388 socket_->sslAccept(
this, std::chrono::milliseconds::zero());
1396 bool preverifyResult,
1399 socket_->enableClientHelloParsing();
1400 socket_->sslAccept(
this, std::chrono::milliseconds::zero());
1407 handshakeSuccess_ =
true;
1408 sock->getSSLSharedCiphers(sharedCiphers_);
1409 sock->getSSLServerCiphers(serverCiphers_);
1410 sock->getSSLClientCiphers(clientCiphers_);
1411 chosenCipher_ = sock->getNegotiatedCipherName();
1419 bool preverifyResult,
1424 std::chrono::milliseconds::zero(),
1425 folly::SSLContext::SSLVerifyPeerEnum::NO_VERIFY);
1433 bool preverifyResult,
1438 std::chrono::milliseconds::zero(),
1439 folly::SSLContext::SSLVerifyPeerEnum::VERIFY_REQ_CLIENT_CERT);
1447 eventBase_(eventBase) {
1448 scheduleTimeout(timeoutMS);
1452 FAIL() <<
"test timed out";
1453 eventBase_->terminateLoopSoon();
1468 finallyFunc =
std::move(finallyFunc)]()
mutable {
1469 finallyFunc(acceptFunc());
1485 [finallyFunc =
std::move(finallyFunc)]()
mutable { finallyFunc(-1); });
1500 auto ret = acceptFunc();
1520 sslBase = sslBase_]()
mutable {
1521 auto ret = acceptFunc();
void setState(StateEnum s)
std::vector< uint8_t > buffer(kBufferSize+16)
void writeSuccess() noexceptoverride
uint32_t writeAfterConnectErrors_
void resetData(std::vector< char > &&data)
~ReadCallbackBase() override
void getReadBuffer(void **bufReturn, size_t *lenReturn) override
std::string expectedServerName_
void handshakeSuc(AsyncSSLSocket *) noexceptoverride
void writeSuccess() noexceptoverride
uint32_t getAsyncCallbacks() const
uint32_t getWriteAfterConnectErrors() const
int connect(NetworkSocket s, const sockaddr *name, socklen_t namelen)
uint32_t getAncillaryDataSize(folly::WriteFlags flags) noexceptoverride
const struct message requests[]
void readEOF() noexceptoverride
~RenegotiatingServer() override
SSLServerAsyncCacheAcceptCallback(HandshakeCallback *hcb, uint32_t timeout=0)
void connAccepted(const std::shared_ptr< folly::AsyncSSLSocket > &s) noexceptoverride
SSLServerAcceptCallbackDelay(HandshakeCallback *hcb)
SSLClient(EventBase *eventBase, const folly::SocketAddress &address, uint32_t requests, uint32_t timeout=0)
ReadEOFCallback(WriteCallbackBase *wcb)
void handshakeSuc(AsyncSSLSocket *) noexceptoverride
AsyncSSLSocket::UniquePtr socket_
virtual void setSocket(const std::shared_ptr< AsyncSSLSocket > &socket)
folly::Optional< AsyncSocketException > except
void connAccepted(const std::shared_ptr< folly::AsyncSSLSocket > &s) noexceptoverride
int setsockopt(NetworkSocket s, int level, int optname, const void *optval, socklen_t optlen)
AlpnClient(AsyncSSLSocket::UniquePtr socket)
void readDataAvailable(size_t len) noexceptoverride
void connAccepted(const std::shared_ptr< folly::AsyncSSLSocket > &s) noexceptoverride
ReadCallbackBase(WriteCallbackBase *wcb)
AsyncSSLSocket::UniquePtr socket_
#define EXPECT_EQ(val1, val2)
void handshakeErr(AsyncSSLSocket *, const AsyncSocketException &ex) noexceptoverride
void readErr(const AsyncSocketException &ex) noexceptoverride
folly::Optional< AsyncSocketException > except
void writeSuccess() noexceptoverride
constexpr detail::Map< Move > move
bool tryRunAfterDelay(Func cob, uint32_t milliseconds, InternalEnum internal=InternalEnum::NORMAL)
uint32_t getErrors() const
virtual void sslAccept(HandshakeCB *callback, std::chrono::milliseconds timeout=std::chrono::milliseconds::zero(), const folly::SSLContext::SSLVerifyPeerEnum &verifyPeer=folly::SSLContext::SSLVerifyPeerEnum::USE_CTX)
void run(Function< int()> acceptFunc, Function< void(int)> finallyFunc) const override
static uint32_t lookupDelay_
void readDataAvailable(size_t) noexceptoverride
void setSocket(const std::shared_ptr< AsyncSSLSocket > &socket)
~SSLServerAcceptCallback() override
void writeSuccess() noexceptoverride
void connectSuccess() noexceptoverride
folly::AsyncSocket::SendMsgParamsCallback * oldCallback_
AsyncSSLSocket::UniquePtr socket_
std::vector< Buffer > buffers
AlpnServer(AsyncSSLSocket::UniquePtr socket)
folly::SSLContext::ServerNameCallbackResult serverNameCallback(SSL *ssl)
SSLHandshakeServer(AsyncSSLSocket::UniquePtr socket, bool preverifyResult, bool verifyResult)
void readEOF() noexceptoverride
WriteCallbackBase(SendMsgParamsCallbackBase *mcb=nullptr)
TestSSLAsyncCacheServer(SSLServerAcceptCallbackBase *acb, int lookupDelay=100)
void connAccepted(const std::shared_ptr< folly::AsyncSSLSocket > &s) noexceptoverride
void sslsocketpair(EventBase *eventBase, AsyncSSLSocket::UniquePtr *clientSock, AsyncSSLSocket::UniquePtr *serverSock)
std::shared_ptr< folly::SSLContext > sniCtx_
SSLHandshakeBase(AsyncSSLSocket::UniquePtr socket, bool preverifyResult, bool verifyResult)
—— Concurrent Priority Queue Implementation ——
void setState(StateEnum s)
SSLHandshakeClient(AsyncSSLSocket::UniquePtr socket, bool preverifyResult, bool verifyResult)
void readEOF() noexceptoverride
void readDataAvailable(size_t len) noexceptoverride
auto msvcSuppressAbortOnInvalidParams(Func func) -> decltype(func())
HandshakeCallback(ReadCallbackBase *rcb, ExpectType expect=EXPECT_SUCCESS)
SSLHandshakeBase * sslBase_
void getReadBuffer(void **bufReturn, size_t *lenReturn) override
void readErr(const AsyncSocketException &ex) noexceptoverride
SSLAcceptCloseRunner(EventBase *evb, folly::AsyncSSLSocket *sock)
requires E e noexcept(noexcept(s.error(std::move(e))))
void getReadBuffer(void **bufReturn, size_t *lenReturn) override
void handshakeErr(AsyncSSLSocket *, const AsyncSocketException &ex) noexceptoverride
void readEOF() noexceptoverride
void readDataAvailable(size_t) noexceptoverride
void readErr(const AsyncSocketException &ex) noexceptoverride
std::shared_ptr< FizzServerContext > ctx_
std::condition_variable cv_
void writeErr(size_t nBytesWritten, const AsyncSocketException &ex) noexceptoverride
std::condition_variable cv_
~WriteCallbackBase() override
void handshakeErr(AsyncSSLSocket *, const AsyncSocketException &ex) noexceptoverride
void writeSuccess() noexceptoverride
void writeErr(size_t bytesWritten, const AsyncSocketException &ex) noexceptoverride
void setSocket(const std::shared_ptr< AsyncSSLSocket > &socket)
SNIServer(AsyncSSLSocket::UniquePtr socket, const std::shared_ptr< folly::SSLContext > &ctx, const std::shared_ptr< folly::SSLContext > &sniCtx, const std::string &expectedServerName)
SSLHandshakeClientDoVerify(AsyncSSLSocket::UniquePtr socket, bool preverifyResult, bool verifyResult)
void readDataAvailable(size_t) noexceptoverride
void readErr(const AsyncSocketException &ex) noexceptoverride
void connAccepted(const std::shared_ptr< folly::AsyncSSLSocket > &s) noexceptoverride
SendMsgParamsCallbackBase()
static std::shared_ptr< AsyncSSLSocket > newSocket(const std::shared_ptr< folly::SSLContext > &ctx, EventBase *evb, int fd, bool server=true, bool deferSecurityNegotiation=false)
AsyncSSLSocket::UniquePtr moveSocket()&&
std::shared_ptr< AsyncSSLSocket > socket_
ReadErrorCallback(WriteCallbackBase *wcb)
~HandshakeCallback() override
std::unique_ptr< AsyncSSLSocket, Destructor > UniquePtr
SSLAcceptDestroyRunner(EventBase *evb, SSLHandshakeBase *base)
AsyncSSLSocket::UniquePtr socket_
bool handshakeVer(AsyncSSLSocket *, bool preverifyOk, X509_STORE_CTX *) noexceptoverride
~ExpectWriteErrorCallback() override
void handshakeSuc(AsyncSSLSocket *sock) noexceptoverride
folly::SocketAddress address_
std::unique_ptr< uint8_t[]> buf_
void run(Function< int()> acceptFunc, Function< void(int)> finallyFunc) const override
void readErr(const AsyncSocketException &ex) noexceptoverride
uint32_t getAncillaryDataSize(folly::WriteFlags flags) noexceptoverride
void handshakeSuc(AsyncSSLSocket *sock) noexceptoverride
void connAccepted(const std::shared_ptr< folly::AsyncSSLSocket > &s) noexceptoverride
void handshakeErr(AsyncSSLSocket *, const AsyncSocketException &ex) noexceptoverride
SSLHandshakeServerParseClientHello(AsyncSSLSocket::UniquePtr socket, bool preverifyResult, bool verifyResult)
std::vector< char > ancillaryData_
HandshakeTimeoutCallback(HandshakeCallback *hcb)
BlockingWriteServer(AsyncSSLSocket::UniquePtr socket)
virtual void getAncillaryData(folly::WriteFlags, void *) noexcept
const unsigned char * nextProto
void readDataAvailable(size_t) noexceptoverride
std::unique_ptr< uint8_t[]> buf_
void timeoutExpired() noexceptoverride
constexpr auto data(C &c) -> decltype(c.data())
void getAncillaryData(folly::WriteFlags flags, void *data) noexceptoverride
int getFlagsImpl(folly::WriteFlags flags, int) noexceptoverride
EventBaseAborter(EventBase *eventBase, uint32_t timeoutMS)
WriteErrorCallback(WriteCallbackBase *wcb)
void readEOF() noexceptoverride
uint32_t getAsyncLookups() const
ExpectWriteErrorCallback(SendMsgParamsCallbackBase *mcb=nullptr)
void handshakeErr(AsyncSSLSocket *, const AsyncSocketException &ex) noexceptoverride
void handshakeErr(AsyncSSLSocket *, const AsyncSocketException &ex) noexceptoverride
auto lock(Synchronized< D, M > &synchronized, Args &&...args)
SNIClient(AsyncSSLSocket::UniquePtr socket)
int getsockopt(NetworkSocket s, int level, int optname, void *optval, socklen_t *optlen)
int getFlagsImpl(folly::WriteFlags flags, int) noexceptoverride
void readDataAvailable(size_t len) noexceptoverride
std::shared_ptr< AsyncSSLSocket > socket_
AsyncSSLSocket::UniquePtr socket_
virtual int getFd() const
int getFlags(folly::WriteFlags flags, bool zeroCopyEnabled) noexcept
AsyncSSLSocket::UniquePtr socket_
void readEOF() noexceptoverride
void readErr(const AsyncSocketException &ex) noexceptoverride
NetworkSocket socket(int af, int type, int protocol)
Buffer(char *buf, size_t len)
static SSL_SESSION * getSessionCallback(SSL *ssl, unsigned char *, int, int *copyflag)
void handshakeErr(AsyncSSLSocket *, const AsyncSocketException &ex) noexceptoverride
std::shared_ptr< AsyncSSLSocket > sslSocket_
void expect(LineReader &lr, const char *expected)
void getAncillaryData(folly::WriteFlags flags, void *data) noexceptoverride
std::shared_ptr< folly::SSLContext > ctx_
folly::AsyncSSLSocket * socket_
void getReadBuffer(void **bufReturn, size_t *lenReturn) override
void handshakeSuc(AsyncSSLSocket *) noexceptoverride
SSLHandshakeServerDoVerify(AsyncSSLSocket::UniquePtr socket, bool preverifyResult, bool verifyResult)
void readErr(const AsyncSocketException &ex) noexceptoverride
ssize_t recvmsg(NetworkSocket s, msghdr *message, int flags)
AsyncSSLSocket::UniquePtr socket_
#define EXPECT_TRUE(condition)
std::chrono::nanoseconds handshakeTime
void checkBuffer(struct iovec *iov, uint32_t count) const
struct iovec * getIovec() const
uint32_t getIovecCount() const
void resetFlags(int flags)
void allocate(size_t len)
std::shared_ptr< AsyncSSLSocket > getSocket()
void writeErr(size_t bytesWritten, const AsyncSocketException &ex) noexceptoverride
void readEOF() noexceptoverride
int bind(NetworkSocket s, const sockaddr *name, socklen_t namelen)
void readErr(const AsyncSocketException &ex) noexceptoverride
void getctx(std::shared_ptr< folly::SSLContext > clientCtx, std::shared_ptr< folly::SSLContext > serverCtx)
void connectErr(const AsyncSocketException &ex) noexceptoverride
#define EXPECT_NE(val1, val2)
void handshakeSuc(AsyncSSLSocket *) noexceptoverride
HandshakeErrorCallback(HandshakeCallback *hcb)
EventBase * getEventBase() const override
uint64_t value(const typename LockFreeRingBuffer< T, Atom >::Cursor &rbcursor)
void writeSuccess() noexceptoverride
SSLServerAcceptCallback(HandshakeCallback *hcb, uint32_t timeout=0)
void writeErr(size_t, const AsyncSocketException &ex) noexceptoverride
std::unique_ptr< struct iovec[]> iov_
void handshakeSuc(AsyncSSLSocket *) noexceptoverride
virtual uint32_t getAncillaryDataSize(folly::WriteFlags) noexcept
static uint32_t asyncLookups_
#define ASSERT_NE(val1, val2)
void readDataAvailable(size_t) noexceptoverride
AsyncSocketException exception
SSLAcceptEvbRunner(EventBase *evb)
AsyncSSLSocket::UniquePtr socket_
void connect(bool writeNow=false)
void getReadBuffer(void **, size_t *lenReturn) override
SendMsgParamsCallbackBase * mcb_
std::string sharedCiphers_
std::shared_ptr< AsyncSocket > tcpSocket_
#define ASSERT_TRUE(condition)
std::shared_ptr< AsyncSSLSocket > socket_
void handshakeSuc(AsyncSSLSocket *) noexceptoverride
void readErr(const AsyncSocketException &ex) noexceptoverride
void writeErr(size_t bytesWritten, const AsyncSocketException &ex) noexceptoverride
void getReadBuffer(void **bufReturn, size_t *lenReturn) override
int close(NetworkSocket s)
void handshakeErr(AsyncSSLSocket *, const AsyncSocketException &ex) noexceptoverride
void getReadBuffer(void **bufReturn, size_t *lenReturn) override
std::shared_ptr< AsyncSSLSocket > socket_
int apply(int fd, int val) const
static AsyncSSLSocket * getFromSSL(const SSL *ssl)
RenegotiatingServer(AsyncSSLSocket::UniquePtr socket)
BlockingWriteClient(AsyncSSLSocket::UniquePtr socket)
void handshakeErr(AsyncSSLSocket *, const AsyncSocketException &ex) noexceptoverride
void writeErr(size_t bytesWritten, const AsyncSocketException &ex) noexceptoverride
static uint32_t asyncCallbacks_
SSLHandshakeServerNoVerify(AsyncSSLSocket::UniquePtr socket, bool preverifyResult, bool verifyResult)
void readDataAvailable(size_t len) noexceptoverride
void run(Function< int()>, Function< void(int)> finallyFunc) const override
SSLAcceptErrorRunner(EventBase *evb)
void run(Function< int()> acceptFunc, Function< void(int)> finallyFunc) const override
void getReadBuffer(void **, size_t *lenReturn) override
SSLHandshakeClientNoVerify(AsyncSSLSocket::UniquePtr socket, bool preverifyResult, bool verifyResult)
void readEOF() noexceptoverride
void setSocket(const std::shared_ptr< AsyncSSLSocket > &socket)
const unsigned char * nextProto
void handshakeSuc(AsyncSSLSocket *) noexceptoverride
void handshakeSuc(AsyncSSLSocket *) noexceptoverride
ReadCallback(WriteCallbackBase *wcb)