return;
}
}
- sslSocket_->sslConn(this, timeoutLeft);
+ sslSocket_->sslConn(this, std::chrono::milliseconds(timeoutLeft));
}
void connectErr(const AsyncSocketException& ex) noexcept override {
}
}
-void AsyncSSLSocket::sslAccept(HandshakeCB* callback, uint32_t timeout,
- const SSLContext::SSLVerifyPeerEnum& verifyPeer) {
+void AsyncSSLSocket::sslAccept(
+ HandshakeCB* callback,
+ std::chrono::milliseconds timeout,
+ const SSLContext::SSLVerifyPeerEnum& verifyPeer) {
DestructorGuard dg(this);
assert(eventBase_->isInEventBaseThread());
verifyPeer_ = verifyPeer;
sslState_ = STATE_ACCEPTING;
handshakeCallback_ = callback;
- if (timeout > 0) {
+ if (timeout > std::chrono::milliseconds::zero()) {
handshakeTimeout_.scheduleTimeout(timeout);
}
return true;
}
-void AsyncSSLSocket::sslConn(HandshakeCB* callback, uint64_t timeout,
- const SSLContext::SSLVerifyPeerEnum& verifyPeer) {
+void AsyncSSLSocket::sslConn(
+ HandshakeCB* callback,
+ std::chrono::milliseconds timeout,
+ const SSLContext::SSLVerifyPeerEnum& verifyPeer) {
DestructorGuard dg(this);
assert(eventBase_->isInEventBaseThread());
handshakeStartTime_ = std::chrono::steady_clock::now();
// Make end time at least >= start time.
handshakeEndTime_ = handshakeStartTime_;
- if (handshakeConnectTimeout_ > 0) {
- handshakeTimeout_.scheduleTimeout(
- std::chrono::milliseconds(handshakeConnectTimeout_));
+ if (handshakeConnectTimeout_ > std::chrono::milliseconds::zero()) {
+ handshakeTimeout_.scheduleTimeout(handshakeConnectTimeout_);
}
handleConnect();
}
* context by default, can be set explcitly to override the
* method in the context
*/
- virtual void sslAccept(HandshakeCB* callback, uint32_t timeout = 0,
+ virtual void sslAccept(
+ HandshakeCB* callback,
+ std::chrono::milliseconds timeout = std::chrono::milliseconds::zero(),
const folly::SSLContext::SSLVerifyPeerEnum& verifyPeer =
- folly::SSLContext::SSLVerifyPeerEnum::USE_CTX);
+ folly::SSLContext::SSLVerifyPeerEnum::USE_CTX);
/**
* Invoke SSL accept following an asynchronous session cache lookup
* SSL_VERIFY_PEER and invokes
* HandshakeCB::handshakeVer().
*/
- virtual void sslConn(HandshakeCB *callback, uint64_t timeout = 0,
- const folly::SSLContext::SSLVerifyPeerEnum& verifyPeer =
- folly::SSLContext::SSLVerifyPeerEnum::USE_CTX);
+ virtual void sslConn(
+ HandshakeCB* callback,
+ std::chrono::milliseconds timeout = std::chrono::milliseconds::zero(),
+ const folly::SSLContext::SSLVerifyPeerEnum& verifyPeer =
+ folly::SSLContext::SSLVerifyPeerEnum::USE_CTX);
enum SSLStateEnum {
STATE_UNINIT,
// Time taken to complete the ssl handshake.
std::chrono::steady_clock::time_point handshakeStartTime_;
std::chrono::steady_clock::time_point handshakeEndTime_;
- uint64_t handshakeConnectTimeout_{0};
+ std::chrono::milliseconds handshakeConnectTimeout_{0};
bool sessionResumptionAttempted_{false};
};
std::cerr << "SSLServerAcceptCallback::connAccepted" << std::endl;
hcb_->setSocket(sock);
- sock->sslAccept(hcb_, timeout_);
+ sock->sslAccept(hcb_, std::chrono::milliseconds(timeout_));
EXPECT_EQ(sock->getSSLState(),
AsyncSSLSocket::STATE_ACCEPTING);
std::cerr << "SSLServerAcceptCallback::connAccepted" << std::endl;
hcb_->setSocket(sock);
- sock->sslAccept(hcb_, timeout_);
+ sock->sslAccept(hcb_, std::chrono::milliseconds(timeout_));
ASSERT_TRUE((sock->getSSLState() ==
AsyncSSLSocket::STATE_ACCEPTING) ||
(sock->getSSLState() ==
}
}
- socket_->sslConn(this, 100);
+ socket_->sslConn(this, std::chrono::milliseconds(100));
}
struct iovec* getIovec() const {
bufSize_(2500 * 2000),
bytesRead_(0) {
buf_.reset(new uint8_t[bufSize_]);
- socket_->sslAccept(this, 100);
+ socket_->sslAccept(this, std::chrono::milliseconds(100));
}
void checkBuffer(struct iovec* iov, uint32_t count) const {
bool preverifyResult,
bool verifyResult) :
SSLHandshakeBase(std::move(socket), preverifyResult, verifyResult) {
- socket_->sslConn(this, 0);
+ socket_->sslConn(this, std::chrono::milliseconds::zero());
}
};
bool preverifyResult,
bool verifyResult) :
SSLHandshakeBase(std::move(socket), preverifyResult, verifyResult) {
- socket_->sslConn(this, 0,
- folly::SSLContext::SSLVerifyPeerEnum::NO_VERIFY);
+ socket_->sslConn(
+ this,
+ std::chrono::milliseconds::zero(),
+ folly::SSLContext::SSLVerifyPeerEnum::NO_VERIFY);
}
};
bool preverifyResult,
bool verifyResult) :
SSLHandshakeBase(std::move(socket), preverifyResult, verifyResult) {
- socket_->sslConn(this, 0,
- folly::SSLContext::SSLVerifyPeerEnum::VERIFY);
+ socket_->sslConn(
+ this,
+ std::chrono::milliseconds::zero(),
+ folly::SSLContext::SSLVerifyPeerEnum::VERIFY);
}
};
bool preverifyResult,
bool verifyResult)
: SSLHandshakeBase(std::move(socket), preverifyResult, verifyResult) {
- socket_->sslAccept(this, 0);
+ socket_->sslAccept(this, std::chrono::milliseconds::zero());
}
};
bool verifyResult)
: SSLHandshakeBase(std::move(socket), preverifyResult, verifyResult) {
socket_->enableClientHelloParsing();
- socket_->sslAccept(this, 0);
+ socket_->sslAccept(this, std::chrono::milliseconds::zero());
}
std::string clientCiphers_, sharedCiphers_, serverCiphers_, chosenCipher_;
bool preverifyResult,
bool verifyResult)
: SSLHandshakeBase(std::move(socket), preverifyResult, verifyResult) {
- socket_->sslAccept(this, 0,
- folly::SSLContext::SSLVerifyPeerEnum::NO_VERIFY);
+ socket_->sslAccept(
+ this,
+ std::chrono::milliseconds::zero(),
+ folly::SSLContext::SSLVerifyPeerEnum::NO_VERIFY);
}
};
bool preverifyResult,
bool verifyResult)
: SSLHandshakeBase(std::move(socket), preverifyResult, verifyResult) {
- socket_->sslAccept(this, 0,
- folly::SSLContext::SSLVerifyPeerEnum::VERIFY_REQ_CLIENT_CERT);
+ socket_->sslAccept(
+ this,
+ std::chrono::milliseconds::zero(),
+ folly::SSLContext::SSLVerifyPeerEnum::VERIFY_REQ_CLIENT_CERT);
}
};
MOCK_METHOD1(setReadCB, void(ReadCallback*));
void sslConn(
- AsyncSSLSocket::HandshakeCB* cb,
- uint64_t timeout,
- const SSLContext::SSLVerifyPeerEnum& verify)
- override {
- if (timeout > 0) {
- handshakeTimeout_.scheduleTimeout((uint32_t)timeout);
+ AsyncSSLSocket::HandshakeCB* cb,
+ std::chrono::milliseconds timeout,
+ const SSLContext::SSLVerifyPeerEnum& verify) override {
+ if (timeout > std::chrono::milliseconds::zero()) {
+ handshakeTimeout_.scheduleTimeout(timeout);
}
state_ = StateEnum::ESTABLISHED;
}
void sslAccept(
- AsyncSSLSocket::HandshakeCB* cb,
- uint32_t timeout,
- const SSLContext::SSLVerifyPeerEnum& verify)
- override {
- if (timeout > 0) {
+ AsyncSSLSocket::HandshakeCB* cb,
+ std::chrono::milliseconds timeout,
+ const SSLContext::SSLVerifyPeerEnum& verify) override {
+ if (timeout > std::chrono::milliseconds::zero()) {
handshakeTimeout_.scheduleTimeout(timeout);
}
}
MOCK_METHOD3(
- sslConnectMockable,
- void(AsyncSSLSocket::HandshakeCB*, uint64_t,
- const SSLContext::SSLVerifyPeerEnum&));
+ sslConnectMockable,
+ void(
+ AsyncSSLSocket::HandshakeCB*,
+ std::chrono::milliseconds,
+ const SSLContext::SSLVerifyPeerEnum&));
MOCK_METHOD3(
- sslAcceptMockable,
- void(AsyncSSLSocket::HandshakeCB*, uint32_t,
- const SSLContext::SSLVerifyPeerEnum&));
+ sslAcceptMockable,
+ void(
+ AsyncSSLSocket::HandshakeCB*,
+ std::chrono::milliseconds,
+ const SSLContext::SSLVerifyPeerEnum&));
};
}}