diff --git a/src/generic_io.h b/src/generic_io.h
index eb4597b369ded6f2a7b204f319495fa792e3b7f8..857bd6e149184083b947a278431f4ac7fb721b71 100644
--- a/src/generic_io.h
+++ b/src/generic_io.h
@@ -24,6 +24,7 @@
#include <functional>
#include <vector>
+#include <chrono>
#include <system_error>
#include <cstdint>
@@ -72,7 +73,7 @@ public:
/// \note error code is not set in case of timeout, but set only in case of io error
/// (i.e. socket deconnection).
/// \todo make a std::chrono version for the timeout
- virtual int waitForData(unsigned ms_timeout, std::error_code& ec) const = 0;
+ virtual int waitForData(std::chrono::milliseconds timeout, std::error_code& ec) const = 0;
/// Write a given amount of data.
/// \param buf data to write.
diff --git a/src/ice_socket.h b/src/ice_socket.h
index 7faa3d64e52b6f7be80a26c0654eb6197842699c..0e8862d574b03deb34b1d428d2de22a69995dd54 100644
--- a/src/ice_socket.h
+++ b/src/ice_socket.h
@@ -47,7 +47,7 @@ class IceSocket
void close();
ssize_t recv(unsigned char* buf, size_t len);
ssize_t send(const unsigned char* buf, size_t len);
- ssize_t waitForData(unsigned int timeout);
+ ssize_t waitForData(std::chrono::milliseconds timeout);
void setOnRecv(IceRecvCb cb);
uint16_t getTransportOverhead();
};
@@ -82,7 +82,7 @@ public:
int maxPayload() const override;
- int waitForData(unsigned ms_timeout, std::error_code& ec) const override;
+ int waitForData(std::chrono::milliseconds timeout, std::error_code& ec) const override;
std::size_t write(const ValueType* buf, std::size_t len, std::error_code& ec) override;
diff --git a/src/ice_transport.cpp b/src/ice_transport.cpp
index 6522a5918dc41fa7ff8984a2887179c761e85043..0f65d61b74df7f98839be3f1a8fe019c5ed7d326 100644
--- a/src/ice_transport.cpp
+++ b/src/ice_transport.cpp
@@ -1322,10 +1322,10 @@ IceTransport::send(int comp_id, const unsigned char* buf, size_t len)
}
int
-IceTransport::waitForInitialization(unsigned timeout)
+IceTransport::waitForInitialization(std::chrono::milliseconds timeout)
{
std::unique_lock<std::mutex> lk(pimpl_->iceMutex_);
- if (!pimpl_->iceCV_.wait_for(lk, std::chrono::seconds(timeout),
+ if (!pimpl_->iceCV_.wait_for(lk, timeout,
[this]{ return pimpl_->_isInitialized() or pimpl_->_isFailed(); })) {
JAMI_WARN("[ice:%p] waitForInitialization: timeout", this);
return -1;
@@ -1334,10 +1334,10 @@ IceTransport::waitForInitialization(unsigned timeout)
}
int
-IceTransport::waitForNegotiation(unsigned timeout)
+IceTransport::waitForNegotiation(std::chrono::milliseconds timeout)
{
std::unique_lock<std::mutex> lk(pimpl_->iceMutex_);
- if (!pimpl_->iceCV_.wait_for(lk, std::chrono::seconds(timeout),
+ if (!pimpl_->iceCV_.wait_for(lk, timeout,
[this]{ return pimpl_->_isRunning() or pimpl_->_isFailed(); })) {
JAMI_WARN("[ice:%p] waitForIceNegotiation: timeout", this);
return -1;
@@ -1352,9 +1352,9 @@ IceTransport::isDataAvailable(int comp_id)
}
ssize_t
-IceTransport::waitForData(int comp_id, unsigned int timeout, std::error_code& ec)
+IceTransport::waitForData(int comp_id, std::chrono::milliseconds timeout, std::error_code& ec)
{
- return pimpl_->peerChannels_.at(comp_id).wait(std::chrono::milliseconds(timeout));
+ return pimpl_->peerChannels_.at(comp_id).wait(timeout);
}
std::vector<SDP>
@@ -1478,10 +1478,10 @@ IceSocketTransport::maxPayload() const
}
int
-IceSocketTransport::waitForData(unsigned ms_timeout, std::error_code& ec) const
+IceSocketTransport::waitForData(std::chrono::milliseconds timeout, std::error_code& ec) const
{
if (!ice_->isRunning()) return -1;
- return ice_->waitForData(compId_, ms_timeout, ec);
+ return ice_->waitForData(compId_, timeout, ec);
}
std::size_t
@@ -1553,7 +1553,7 @@ IceSocket::send(const unsigned char* buf, size_t len)
}
ssize_t
-IceSocket::waitForData(unsigned int timeout)
+IceSocket::waitForData(std::chrono::milliseconds timeout)
{
if (!ice_transport_.get())
return -1;
diff --git a/src/ice_transport.h b/src/ice_transport.h
index 264285218e862f85e9f61e68c225f53e7579161b..432ed3d7edb3e5c567eaf83521e36df2a66eff13 100644
--- a/src/ice_transport.h
+++ b/src/ice_transport.h
@@ -188,11 +188,11 @@ public:
ssize_t send(int comp_id, const unsigned char* buf, size_t len);
- int waitForInitialization(unsigned timeout);
+ int waitForInitialization(std::chrono::milliseconds timeout);
- int waitForNegotiation(unsigned timeout);
+ int waitForNegotiation(std::chrono::milliseconds timeout);
- ssize_t waitForData(int comp_id, unsigned int timeout, std::error_code& ec);
+ ssize_t waitForData(int comp_id, std::chrono::milliseconds timeout, std::error_code& ec);
/**
* Return without waiting how many bytes are ready to read
diff --git a/src/jamidht/p2p.cpp b/src/jamidht/p2p.cpp
index 8d392d06208ba9f49dc04d2aa016cca81cfa1910..b75ca11b7921cb93b0a0fb3e977b491aa516ca96 100644
--- a/src/jamidht/p2p.cpp
+++ b/src/jamidht/p2p.cpp
@@ -45,11 +45,12 @@
namespace jami {
-static constexpr auto DHT_MSG_TIMEOUT = std::chrono::seconds(30);
-static constexpr auto NET_CONNECTION_TIMEOUT = std::chrono::seconds(10);
-static constexpr auto SOCK_TIMEOUT = std::chrono::seconds(3);
-static constexpr auto ICE_READY_TIMEOUT = std::chrono::seconds(10);
-static constexpr int ICE_INIT_TIMEOUT{10};
+static constexpr std::chrono::seconds DHT_MSG_TIMEOUT{30};
+static constexpr std::chrono::seconds NET_CONNECTION_TIMEOUT{10};
+static constexpr std::chrono::seconds SOCK_TIMEOUT{3};
+static constexpr std::chrono::seconds ICE_READY_TIMEOUT{10};
+static constexpr std::chrono::seconds ICE_INIT_TIMEOUT{10};
+static constexpr std::chrono::seconds ICE_NOGOTIATION_TIMEOUT{10};
using Clock = std::chrono::system_clock;
using ValueIdDist = std::uniform_int_distribution<dht::Value::Id>;
@@ -432,7 +433,7 @@ private:
break;
}
- parent_.ice_->waitForNegotiation(10);
+ parent_.ice_->waitForNegotiation(ICE_NOGOTIATION_TIMEOUT);
if (parent_.ice_->isRunning()) {
peer_ep = std::make_shared<IceSocketEndpoint>(parent_.ice_, true);
JAMI_DBG("[Account:%s] ICE negotiation succeed. Starting file transfer",
@@ -743,7 +744,7 @@ DhtPeerConnector::Impl::answerToRequest(PeerConnectionMsg&& request,
}
if (!hasPubIp) {
- ice_->waitForNegotiation(10);
+ ice_->waitForNegotiation(ICE_NOGOTIATION_TIMEOUT);
if (ice_->isRunning()) {
sendIce = true;
JAMI_DBG("[Account:%s] ICE negotiation succeed. Answering with local SDP", account.getAccountID().c_str());
@@ -793,9 +794,8 @@ DhtPeerConnector::Impl::answerToRequest(PeerConnectionMsg&& request,
request.from, request.respond(addresses));
if (sendIce) {
-
if (hasPubIp) {
- ice_->waitForNegotiation(10);
+ ice_->waitForNegotiation(ICE_NOGOTIATION_TIMEOUT);
if (ice_->isRunning()) {
JAMI_DBG("[Account:%s] ICE negotiation succeed. Answering with local SDP", account.getAccountID().c_str());
} else {
diff --git a/src/jamidht/sips_transport_ice.cpp b/src/jamidht/sips_transport_ice.cpp
index 1c5af73b2454186e6e5e9deda9e245b090735b3e..dc87790fe6a07b84d1b80e839fc25bef6801cf5b 100644
--- a/src/jamidht/sips_transport_ice.cpp
+++ b/src/jamidht/sips_transport_ice.cpp
@@ -729,7 +729,7 @@ SipsIceTransport::eventLoop()
{
while(!stopLoop_) {
std::error_code err;
- if (tls_ && tls_->waitForData(100, err)) {
+ if (tls_ && tls_->waitForData(std::chrono::milliseconds(100), err)) {
std::vector<uint8_t> pkt;
pkt.resize(PJSIP_MAX_PKT_LEN);
auto read = tls_->read(pkt.data(), PJSIP_MAX_PKT_LEN, err);
diff --git a/src/manager.cpp b/src/manager.cpp
index 4ba8b2320fa98650ec8b1e38fc82e3a40bd1b3ba..179a0f042f3bc3b488c73426cf1ecb656a64112e 100644
--- a/src/manager.cpp
+++ b/src/manager.cpp
@@ -111,7 +111,7 @@ using ConferenceMap = std::map<std::string, std::shared_ptr<Conference>>;
/** To store uniquely a list of Call ids */
using CallIDSet = std::set<std::string>;
-static constexpr int ICE_INIT_TIMEOUT {10};
+static constexpr std::chrono::seconds ICE_INIT_TIMEOUT{10};
static constexpr const char* PACKAGE_OLD = "ring";
std::atomic_bool Manager::initialized = {false};
diff --git a/src/peer_connection.cpp b/src/peer_connection.cpp
index a6cc488aa019597beb4d590c8355178c5f4cc0b0..148dc271c95062eff1319c3a8b81b263e81a5ce7 100644
--- a/src/peer_connection.cpp
+++ b/src/peer_connection.cpp
@@ -135,7 +135,7 @@ TlsTurnEndpoint::Impl::verifyCertificate(gnutls_session_t session)
}
void
-TlsTurnEndpoint::Impl::onTlsStateChange(tls::TlsSessionState state)
+TlsTurnEndpoint::Impl::onTlsStateChange(tls::TlsSessionState)
{}
void
@@ -221,9 +221,9 @@ TlsTurnEndpoint::peerCertificate() const
}
int
-TlsTurnEndpoint::waitForData(unsigned ms_timeout, std::error_code& ec) const
+TlsTurnEndpoint::waitForData(std::chrono::milliseconds timeout, std::error_code& ec) const
{
- return pimpl_->tls->waitForData(ms_timeout, ec);
+ return pimpl_->tls->waitForData(timeout, ec);
}
//==============================================================================
@@ -249,9 +249,9 @@ TcpSocketEndpoint::~TcpSocketEndpoint()
}
void
-TcpSocketEndpoint::connect(const std::chrono::steady_clock::duration& timeout)
+TcpSocketEndpoint::connect(const std::chrono::milliseconds& timeout)
{
- int ms = std::chrono::duration_cast<std::chrono::milliseconds>(timeout).count();
+ int ms = timeout.count();
setsockopt(sock_, SOL_SOCKET, SO_RCVTIMEO, (const char *)&ms, sizeof(ms));
setsockopt(sock_, SOL_SOCKET, SO_SNDTIMEO, (const char *)&ms, sizeof(ms));
@@ -260,12 +260,12 @@ TcpSocketEndpoint::connect(const std::chrono::steady_clock::duration& timeout)
}
int
-TcpSocketEndpoint::waitForData(unsigned ms_timeout, std::error_code& ec) const
+TcpSocketEndpoint::waitForData(std::chrono::milliseconds timeout, std::error_code& ec) const
{
for (;;) {
struct timeval tv;
- tv.tv_sec = ms_timeout / 1000;
- tv.tv_usec = (ms_timeout % 1000) * 1000;
+ tv.tv_sec = timeout.count() / 1000;
+ tv.tv_usec = (timeout.count() % 1000) * 1000;
fd_set read_fds;
FD_ZERO(&read_fds);
@@ -331,11 +331,11 @@ IceSocketEndpoint::shutdown() {
}
int
-IceSocketEndpoint::waitForData(unsigned ms_timeout, std::error_code& ec) const
+IceSocketEndpoint::waitForData(std::chrono::milliseconds timeout, std::error_code& ec) const
{
if (ice_) {
if (!ice_->isRunning()) return -1;
- return iceIsSender ? ice_->isDataAvailable(compId_) : ice_->waitForData(compId_, ms_timeout, ec);
+ return iceIsSender ? ice_->isDataAvailable(compId_) : ice_->waitForData(compId_, timeout, ec);
}
return -1;
}
@@ -531,15 +531,15 @@ TlsSocketEndpoint::write(const ValueType* buf, std::size_t len, std::error_code&
}
void
-TlsSocketEndpoint::waitForReady(const std::chrono::steady_clock::duration& timeout)
+TlsSocketEndpoint::waitForReady(const std::chrono::milliseconds& timeout)
{
pimpl_->tls->waitForReady(timeout);
}
int
-TlsSocketEndpoint::waitForData(unsigned ms_timeout, std::error_code& ec) const
+TlsSocketEndpoint::waitForData(std::chrono::milliseconds timeout, std::error_code& ec) const
{
- return pimpl_->tls->waitForData(ms_timeout, ec);
+ return pimpl_->tls->waitForData(timeout, ec);
}
//==============================================================================
@@ -670,7 +670,7 @@ PeerConnection::PeerConnectionImpl::eventLoop()
msg = ctrlChannel.receive();
} else {
std::error_code ec;
- if (endpoint_->waitForData(100, ec) > 0) {
+ if (endpoint_->waitForData(std::chrono::milliseconds(100), ec) > 0) {
std::vector<uint8_t> buf(IO_BUFFER_SIZE);
JAMI_DBG("A good buffer arrived before any input or output attachment");
auto size = endpoint_->read(buf, ec);
@@ -734,7 +734,7 @@ PeerConnection::PeerConnectionImpl::eventLoop()
if (!bufferPool_.empty()) {
stream->write(bufferPool_);
bufferPool_.clear();
- } else if (endpoint_->waitForData(0, ec) > 0) {
+ } else if (endpoint_->waitForData(std::chrono::milliseconds(0), ec) > 0) {
buf.resize(IO_BUFFER_SIZE);
endpoint_->read(buf, ec);
if (ec)
@@ -762,7 +762,7 @@ PeerConnection::PeerConnectionImpl::eventLoop()
if (!bufferPool_.empty()) {
stream->write(bufferPool_);
bufferPool_.clear();
- } else if (endpoint_->waitForData(0, ec) > 0) {
+ } else if (endpoint_->waitForData(std::chrono::milliseconds(0), ec) > 0) {
buf.resize(IO_BUFFER_SIZE);
endpoint_->read(buf, ec);
if (ec)
diff --git a/src/peer_connection.h b/src/peer_connection.h
index 30698d6c7e2fa32a3fc0d4d1085f9fa99d7e78ae..99df375505da226946d8eb81d8ec9d8db3a1ee49 100644
--- a/src/peer_connection.h
+++ b/src/peer_connection.h
@@ -96,8 +96,7 @@ public:
void setOnRecv(RecvCb&&) override {
throw std::logic_error("TlsTurnEndpoint::setOnRecv not implemented");
}
- int waitForData(unsigned, std::error_code&) const override;
-
+ int waitForData(std::chrono::milliseconds, std::error_code&) const override;
void waitForReady(const std::chrono::steady_clock::duration& timeout = {});
const dht::crypto::Certificate& peerCertificate() const;
@@ -112,7 +111,7 @@ private:
class AbstractSocketEndpoint : public GenericSocket<uint8_t>
{
public:
- virtual void connect(const std::chrono::steady_clock::duration &timeout = {}) {};
+ virtual void connect(const std::chrono::milliseconds& = {}) {};
void setOnRecv(RecvCb &&) override {
throw std::logic_error("AbstractSocketEndpoint::setOnRecv not implemented");
@@ -130,10 +129,10 @@ public:
bool isReliable() const override { return true; }
bool isInitiator() const override { return true; }
int maxPayload() const override { return 1280; }
- int waitForData(unsigned ms_timeout, std::error_code& ec) const override;
+ int waitForData(std::chrono::milliseconds timeout, std::error_code& ec) const override;
std::size_t read(ValueType* buf, std::size_t len, std::error_code& ec) override;
std::size_t write(const ValueType* buf, std::size_t len, std::error_code& ec) override;
- void connect(const std::chrono::steady_clock::duration& timeout = {}) override;
+ void connect(const std::chrono::milliseconds& timeout = {}) override;
private:
const IpAddr addr_;
@@ -151,7 +150,7 @@ public:
bool isReliable() const override { return ice_ ? ice_->isRunning() : false; }
bool isInitiator() const override { return ice_ ? ice_->isInitiator() : true; }
int maxPayload() const override { return 65536 /* The max for a RTP packet used to wrap data here */; }
- int waitForData(unsigned ms_timeout, std::error_code& ec) const override;
+ int waitForData(std::chrono::milliseconds timeout, std::error_code& ec) const override;
std::size_t read(ValueType* buf, std::size_t len, std::error_code& ec) override;
std::size_t write(const ValueType* buf, std::size_t len, std::error_code& ec) override;
@@ -198,9 +197,9 @@ public:
void setOnRecv(RecvCb&&) override {
throw std::logic_error("TlsSocketEndpoint::setOnRecv not implemented");
}
- int waitForData(unsigned, std::error_code&) const override;
+ int waitForData(std::chrono::milliseconds timeout, std::error_code&) const override;
- void waitForReady(const std::chrono::steady_clock::duration& timeout = {});
+ void waitForReady(const std::chrono::milliseconds& timeout = {});
private:
class Impl;
diff --git a/src/security/tls_session.cpp b/src/security/tls_session.cpp
index 6189018825d445b3bec213157404c44ef1a85a1c..7099218cbbe384390eec6fc0b84e252297d9eb8c 100644
--- a/src/security/tls_session.cpp
+++ b/src/security/tls_session.cpp
@@ -217,7 +217,7 @@ public:
ssize_t sendRaw(const void*, size_t);
ssize_t sendRawVec(const giovec_t*, int);
ssize_t recvRaw(void*, size_t);
- int waitForRawData(unsigned);
+ int waitForRawData(std::chrono::milliseconds);
bool initFromRecordState(int offset=0);
void handleDataPacket(std::vector<ValueType>&&, uint64_t);
@@ -531,7 +531,7 @@ TlsSession::TlsSessionImpl::commonSessionInit()
gnutls_transport_set_pull_timeout_function(session_,
[](gnutls_transport_ptr_t t, unsigned ms) -> int {
auto this_ = reinterpret_cast<TlsSessionImpl*>(t);
- return this_->waitForRawData(ms);
+ return this_->waitForRawData(std::chrono::milliseconds(ms));
});
return true;
@@ -660,7 +660,7 @@ TlsSession::TlsSessionImpl::recvRaw(void* buf, size_t size)
// 'timeout' is in milliseconds.
// Should return 0 on timeout, a positive number if data are available for read, or -1 on error.
int
-TlsSession::TlsSessionImpl::waitForRawData(unsigned timeout)
+TlsSession::TlsSessionImpl::waitForRawData(std::chrono::milliseconds timeout)
{
if (transport_.isReliable()) {
std::error_code ec;
@@ -677,13 +677,13 @@ TlsSession::TlsSessionImpl::waitForRawData(unsigned timeout)
// non-reliable uses callback installed with setOnRecv()
std::unique_lock<std::mutex> lk {rxMutex_};
- rxCv_.wait_for(lk, std::chrono::milliseconds(timeout), [this]{ return !rxQueue_.empty() or state_ == TlsSessionState::SHUTDOWN; });
+ rxCv_.wait_for(lk, timeout, [this]{ return !rxQueue_.empty() or state_ == TlsSessionState::SHUTDOWN; });
if (state_ == TlsSessionState::SHUTDOWN) {
gnutls_transport_set_errno(session_, EINTR);
return -1;
}
if (rxQueue_.empty()) {
- JAMI_ERR("[TLS] waitForRawData: timeout after %u ms", timeout);
+ JAMI_ERR("[TLS] waitForRawData: timeout after %u ms", timeout.count());
return 0;
}
return 1;
@@ -1355,9 +1355,9 @@ TlsSession::waitForReady(const std::chrono::steady_clock::duration& timeout)
}
int
-TlsSession::waitForData(unsigned ms_timeout, std::error_code& ec) const
+TlsSession::waitForData(std::chrono::milliseconds timeout, std::error_code& ec) const
{
- if (!pimpl_->transport_.waitForData(ms_timeout, ec))
+ if (!pimpl_->transport_.waitForData(timeout, ec))
return 0;
return 1;
}
diff --git a/src/security/tls_session.h b/src/security/tls_session.h
index 459b310b77bd975a6270d70f8a0614467e26a281..4b779e9ddeff370a2e04c276304ee872a695119e 100644
--- a/src/security/tls_session.h
+++ b/src/security/tls_session.h
@@ -139,7 +139,7 @@ public:
/// Return a positive number for number of bytes read, or 0 and \a ec set in case of error.
std::size_t read(ValueType* data, std::size_t size, std::error_code& ec) override;
- int waitForData(unsigned, std::error_code&) const override;
+ int waitForData(std::chrono::milliseconds, std::error_code&) const override;
private:
class TlsSessionImpl;
diff --git a/src/sip/sipcall.cpp b/src/sip/sipcall.cpp
index bc6b73ce872850a9c23ae1e8345a76953b919b95..d0281a2c41a3b97fb6dfc1cdc58f6b400ab92123 100644
--- a/src/sip/sipcall.cpp
+++ b/src/sip/sipcall.cpp
@@ -66,8 +66,8 @@ getVideoSettings()
}
#endif
-static constexpr int DEFAULT_ICE_INIT_TIMEOUT {35}; // seconds
-static constexpr int DEFAULT_ICE_NEGO_TIMEOUT {60}; // seconds
+static constexpr std::chrono::seconds DEFAULT_ICE_INIT_TIMEOUT {35}; // seconds
+static constexpr std::chrono::seconds DEFAULT_ICE_NEGO_TIMEOUT {60}; // seconds
// SDP media Ids
static constexpr int SDP_AUDIO_MEDIA_ID {0};
diff --git a/src/turn_transport.cpp b/src/turn_transport.cpp
index 7546bf3d754d8c7dcd17a38a672557cd958e7a23..d7e9e75ad0d0a9772b875c67ea3ac3404351c893 100644
--- a/src/turn_transport.cpp
+++ b/src/turn_transport.cpp
@@ -460,13 +460,13 @@ TurnTransport::peerAddresses() const
}
int
-TurnTransport::waitForData(const IpAddr& peer, unsigned ms_timeout, std::error_code& ec) const
+TurnTransport::waitForData(const IpAddr& peer, std::chrono::milliseconds timeout, std::error_code& ec) const
{
(void)ec; ///< \todo handle errors
MutexLock lk {pimpl_->apiMutex_};
auto& channel = pimpl_->peerChannels_.at(peer);
lk.unlock();
- return channel.wait(std::chrono::milliseconds(ms_timeout));
+ return channel.wait(timeout);
}
//==============================================================================
@@ -483,9 +483,9 @@ ConnectedTurnTransport::shutdown()
}
int
-ConnectedTurnTransport::waitForData(unsigned ms_timeout, std::error_code& ec) const
+ConnectedTurnTransport::waitForData(std::chrono::milliseconds timeout, std::error_code& ec) const
{
- return turn_.waitForData(peer_, ms_timeout, ec);
+ return turn_.waitForData(peer_, timeout, ec);
}
std::size_t
diff --git a/src/turn_transport.h b/src/turn_transport.h
index 1b9c363d7136e7e18ef93b290e3cb44ec3d516a0..d3dfef606c71fd145b9276090875350a37e627b1 100644
--- a/src/turn_transport.h
+++ b/src/turn_transport.h
@@ -135,7 +135,7 @@ public:
///
bool sendto(const IpAddr& peer, const char* const buffer, std::size_t size);
- int waitForData(const IpAddr& peer, unsigned ms_timeout, std::error_code& ec) const;
+ int waitForData(const IpAddr& peer, std::chrono::milliseconds timeout, std::error_code& ec) const;
public:
// Move semantic only, not copiable
@@ -159,7 +159,7 @@ public:
bool isInitiator() const override { return turn_.isInitiator(); }
int maxPayload() const override { return 3000; }
- int waitForData(unsigned ms_timeout, std::error_code& ec) const override;
+ int waitForData(std::chrono::milliseconds timeout, std::error_code& ec) const override;
std::size_t read(ValueType* buf, std::size_t length, std::error_code& ec) override;
std::size_t write(const ValueType* buf, std::size_t length, std::error_code& ec) override;