mirror of
https://github.com/matrix-construct/construct
synced 2024-09-06 08:45:20 +02:00
989 lines
20 KiB
C++
989 lines
20 KiB
C++
/*
|
|
* Copyright (C) 2017 Charybdis Development Team
|
|
* Copyright (C) 2017 Jason Volk <jason@zemos.net>
|
|
*
|
|
* Permission to use, copy, modify, and/or distribute this software for any
|
|
* purpose with or without fee is hereby granted, provided that the above
|
|
* copyright notice and this permission notice is present in all copies.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
|
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
|
|
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
|
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
|
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
|
|
* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#include <ircd/asio.h>
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// net.h
|
|
//
|
|
|
|
namespace ircd::net
|
|
{
|
|
ip::tcp::resolver *resolver;
|
|
}
|
|
|
|
ircd::net::init::init()
|
|
{
|
|
net::resolver = new ip::tcp::resolver{*ircd::ios};
|
|
}
|
|
|
|
ircd::net::init::~init()
|
|
{
|
|
assert(net::resolver);
|
|
delete net::resolver;
|
|
net::resolver = nullptr;
|
|
}
|
|
|
|
//
|
|
// net.h
|
|
//
|
|
|
|
std::string
|
|
ircd::net::string(const hostport &pair)
|
|
{
|
|
std::string ret(256, char{});
|
|
ret.resize(string(pair, mutable_buffer{ret}).size());
|
|
return ret;
|
|
}
|
|
|
|
ircd::string_view
|
|
ircd::net::string(const hostport &pair,
|
|
const mutable_buffer &buf)
|
|
{
|
|
const auto len
|
|
{
|
|
fmt::sprintf(buf, "%s:%u", pair.first, pair.second)
|
|
};
|
|
|
|
return { data(buf), size_t(len) };
|
|
}
|
|
|
|
size_t
|
|
ircd::net::read(socket &socket,
|
|
iov<mutable_buffer> &bufs)
|
|
{
|
|
const size_t read(socket.read_some(bufs));
|
|
const size_t consumed(buffer::consume(bufs, read));
|
|
assert(read == consumed);
|
|
return read;
|
|
}
|
|
|
|
size_t
|
|
ircd::net::read(socket &socket,
|
|
const iov<mutable_buffer> &bufs)
|
|
{
|
|
return socket.read(bufs);
|
|
}
|
|
|
|
size_t
|
|
ircd::net::read(socket &socket,
|
|
const mutable_buffer &buf)
|
|
{
|
|
const ilist<mutable_buffer> bufs{buf};
|
|
return socket.read(bufs);
|
|
}
|
|
|
|
size_t
|
|
ircd::net::write(socket &socket,
|
|
iov<const_buffer> &bufs)
|
|
{
|
|
const size_t wrote(socket.write_some(bufs));
|
|
const size_t consumed(consume(bufs, wrote));
|
|
assert(wrote == consumed);
|
|
return consumed;
|
|
}
|
|
|
|
size_t
|
|
ircd::net::write(socket &socket,
|
|
const iov<const_buffer> &bufs)
|
|
{
|
|
const size_t wrote(socket.write(bufs));
|
|
assert(wrote == size(bufs));
|
|
return wrote;
|
|
}
|
|
|
|
size_t
|
|
ircd::net::write(socket &socket,
|
|
const const_buffer &buf)
|
|
{
|
|
const ilist<const_buffer> bufs{buf};
|
|
const size_t wrote(socket.write(bufs));
|
|
assert(wrote == size(bufs));
|
|
return wrote;
|
|
}
|
|
|
|
size_t
|
|
ircd::net::write(socket &socket,
|
|
const ilist<const_buffer> &bufs)
|
|
{
|
|
const size_t wrote(socket.write(bufs));
|
|
assert(wrote == size(bufs));
|
|
return wrote;
|
|
}
|
|
|
|
//
|
|
// ircd::net::listener
|
|
//
|
|
|
|
ircd::net::listener::listener(const std::string &opts)
|
|
:listener{json::object{opts}}
|
|
{
|
|
}
|
|
|
|
ircd::net::listener::listener(const json::object &opts)
|
|
:acceptor{std::make_unique<struct acceptor>(opts)}
|
|
{
|
|
}
|
|
|
|
ircd::net::listener::~listener()
|
|
noexcept
|
|
{
|
|
}
|
|
|
|
//
|
|
// ircd::net::listener::acceptor
|
|
//
|
|
|
|
struct ircd::net::listener::acceptor
|
|
{
|
|
using error_code = boost::system::error_code;
|
|
|
|
static log::log log;
|
|
|
|
std::string name;
|
|
size_t backlog;
|
|
asio::ssl::context ssl;
|
|
ip::tcp::endpoint ep;
|
|
ip::tcp::acceptor a;
|
|
|
|
explicit operator std::string() const;
|
|
void configure(const json::object &opts);
|
|
|
|
// Handshake stack
|
|
bool handshake_error(const error_code &ec);
|
|
void handshake(const error_code &ec, std::shared_ptr<socket>) noexcept;
|
|
|
|
// Acceptance stack
|
|
bool accept_error(const error_code &ec);
|
|
void accept(const error_code &ec, std::shared_ptr<socket>) noexcept;
|
|
|
|
// Accept next
|
|
void next();
|
|
|
|
acceptor(const json::object &opts);
|
|
~acceptor() noexcept;
|
|
};
|
|
|
|
//
|
|
// ircd::net::listener::acceptor
|
|
//
|
|
|
|
ircd::log::log
|
|
ircd::net::listener::acceptor::log
|
|
{
|
|
"listener"
|
|
};
|
|
|
|
ircd::net::listener::acceptor::acceptor(const json::object &opts)
|
|
try
|
|
:name
|
|
{
|
|
unquote(opts.get("name", "IRCd (ssl)"s))
|
|
}
|
|
,backlog
|
|
{
|
|
opts.get<size_t>("backlog", asio::socket_base::max_connections - 2)
|
|
}
|
|
,ssl
|
|
{
|
|
asio::ssl::context::method::sslv23_server
|
|
}
|
|
,ep
|
|
{
|
|
ip::address::from_string(unquote(opts.get("host", "127.0.0.1"s))),
|
|
opts.get<uint16_t>("port", 6667)
|
|
}
|
|
,a
|
|
{
|
|
*ircd::ios
|
|
}
|
|
{
|
|
static const ip::tcp::acceptor::reuse_address reuse_address{true};
|
|
|
|
configure(opts);
|
|
|
|
log.debug("%s configured listener SSL",
|
|
std::string(*this));
|
|
|
|
a.open(ep.protocol());
|
|
a.set_option(reuse_address);
|
|
log.debug("%s opened listener socket",
|
|
std::string(*this));
|
|
|
|
a.bind(ep);
|
|
log.debug("%s bound listener socket",
|
|
std::string(*this));
|
|
|
|
a.listen(backlog);
|
|
log.debug("%s listening (backlog: %lu)",
|
|
std::string(*this),
|
|
backlog);
|
|
|
|
next();
|
|
}
|
|
catch(const boost::system::system_error &e)
|
|
{
|
|
throw error("listener: %s", e.what());
|
|
}
|
|
|
|
ircd::net::listener::acceptor::~acceptor()
|
|
noexcept
|
|
{
|
|
a.cancel();
|
|
}
|
|
|
|
void
|
|
ircd::net::listener::acceptor::next()
|
|
try
|
|
{
|
|
auto sock(std::make_shared<ircd::socket>(ssl));
|
|
log.debug("%s: listening with next socket(%p)",
|
|
std::string(*this),
|
|
sock.get());
|
|
|
|
// The context blocks here until the next client is connected.
|
|
auto accept(std::bind(&acceptor::accept, this, ph::_1, sock));
|
|
a.async_accept(sock->sd, accept);
|
|
}
|
|
catch(const std::exception &e)
|
|
{
|
|
log.critical("%s: %s",
|
|
std::string(*this),
|
|
e.what());
|
|
|
|
if(ircd::debugmode)
|
|
throw;
|
|
}
|
|
|
|
void
|
|
ircd::net::listener::acceptor::accept(const error_code &ec,
|
|
const std::shared_ptr<socket> sock)
|
|
noexcept try
|
|
{
|
|
if(accept_error(ec))
|
|
return;
|
|
|
|
log.debug("%s: accepted %s",
|
|
std::string(*this),
|
|
string(sock->remote()));
|
|
|
|
/*
|
|
static const asio::socket_base::keep_alive keep_alive(true);
|
|
static const asio::socket_base::linger linger(true, 30);
|
|
sock->sd.set_option(keep_alive);
|
|
sock->sd.set_option(linger);
|
|
sock->sd.non_blocking(true);
|
|
*/
|
|
|
|
static const auto handshake_type
|
|
{
|
|
socket::handshake_type::server
|
|
};
|
|
|
|
auto handshake
|
|
{
|
|
std::bind(&acceptor::handshake, this, ph::_1, sock)
|
|
};
|
|
|
|
sock->ssl.async_handshake(handshake_type, handshake);
|
|
}
|
|
catch(const std::exception &e)
|
|
{
|
|
log.error("%s: in accept(): socket(%p): %s",
|
|
std::string(*this),
|
|
sock.get(),
|
|
e.what());
|
|
next();
|
|
}
|
|
|
|
bool
|
|
ircd::net::listener::acceptor::accept_error(const error_code &ec)
|
|
{
|
|
switch(ec.value())
|
|
{
|
|
using namespace boost::system::errc;
|
|
|
|
case success:
|
|
return false;
|
|
|
|
case operation_canceled:
|
|
return true;
|
|
|
|
default:
|
|
throw boost::system::system_error(ec);
|
|
}
|
|
}
|
|
|
|
void
|
|
ircd::net::listener::acceptor::handshake(const error_code &ec,
|
|
const std::shared_ptr<socket> sock)
|
|
noexcept try
|
|
{
|
|
if(handshake_error(ec))
|
|
return;
|
|
|
|
log.debug("%s SSL handshook %s",
|
|
std::string(*this),
|
|
string(sock->remote()));
|
|
|
|
add_client(sock);
|
|
next();
|
|
}
|
|
catch(const std::exception &e)
|
|
{
|
|
log.error("%s: in handshake(): socket(%p)[%s]: %s",
|
|
std::string(*this),
|
|
sock.get(),
|
|
string(sock->remote()),
|
|
e.what());
|
|
}
|
|
|
|
bool
|
|
ircd::net::listener::acceptor::handshake_error(const error_code &ec)
|
|
{
|
|
switch(ec.value())
|
|
{
|
|
using namespace boost::system::errc;
|
|
|
|
case success:
|
|
return false;
|
|
|
|
case operation_canceled:
|
|
return true;
|
|
|
|
default:
|
|
throw boost::system::system_error(ec);
|
|
}
|
|
}
|
|
|
|
void
|
|
ircd::net::listener::acceptor::configure(const json::object &opts)
|
|
{
|
|
log.debug("%s preparing listener socket configuration...",
|
|
std::string(*this));
|
|
|
|
ssl.set_options
|
|
(
|
|
ssl.default_workarounds
|
|
//| ssl.no_tlsv1
|
|
//| ssl.no_tlsv1_1
|
|
| ssl.no_tlsv1_2
|
|
//| ssl.no_sslv2
|
|
| ssl.no_sslv3
|
|
//| ssl.single_dh_use
|
|
);
|
|
|
|
//TODO: XXX
|
|
ssl.set_password_callback([this]
|
|
(const auto &size, const auto &purpose)
|
|
{
|
|
log.debug("%s asking for password with purpose '%s' (size: %zu)",
|
|
std::string(*this),
|
|
purpose,
|
|
size);
|
|
|
|
//XXX: TODO
|
|
return "foobar";
|
|
});
|
|
|
|
if(opts.has("ssl_certificate_chain_file"))
|
|
{
|
|
const std::string filename
|
|
{
|
|
unquote(opts["ssl_certificate_chain_file"])
|
|
};
|
|
|
|
ssl.use_certificate_chain_file(filename);
|
|
log.info("%s using certificate chain file '%s'",
|
|
std::string(*this),
|
|
filename);
|
|
}
|
|
|
|
if(opts.has("ssl_certificate_file_pem"))
|
|
{
|
|
const std::string filename
|
|
{
|
|
unquote(opts["ssl_certificate_file_pem"])
|
|
};
|
|
|
|
ssl.use_certificate_file(filename, asio::ssl::context::pem);
|
|
log.info("%s using certificate file '%s'",
|
|
std::string(*this),
|
|
filename);
|
|
}
|
|
|
|
if(opts.has("ssl_private_key_file_pem"))
|
|
{
|
|
const std::string filename
|
|
{
|
|
unquote(opts["ssl_private_key_file_pem"])
|
|
};
|
|
|
|
ssl.use_private_key_file(filename, asio::ssl::context::pem);
|
|
log.info("%s using private key file '%s'",
|
|
std::string(*this),
|
|
filename);
|
|
}
|
|
|
|
if(opts.has("ssl_tmp_dh_file"))
|
|
{
|
|
const std::string filename
|
|
{
|
|
unquote(opts["ssl_tmp_dh_file"])
|
|
};
|
|
|
|
ssl.use_tmp_dh_file(filename);
|
|
log.info("%s using tmp dh file '%s'",
|
|
std::string(*this),
|
|
filename);
|
|
}
|
|
}
|
|
|
|
ircd::net::listener::acceptor::operator std::string()
|
|
const
|
|
{
|
|
std::string ret(256, char{});
|
|
const auto length
|
|
{
|
|
fmt::sprintf(mutable_buffer{ret}, "'%s' @ [%s]:%u",
|
|
name,
|
|
string(ep.address()),
|
|
ep.port())
|
|
};
|
|
|
|
ret.resize(length);
|
|
return ret;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// socket.h
|
|
//
|
|
|
|
boost::asio::ssl::context
|
|
ircd::net::sslv23_client
|
|
{
|
|
boost::asio::ssl::context::method::sslv23_client
|
|
};
|
|
|
|
size_t
|
|
ircd::net::available(const socket &s)
|
|
{
|
|
return s.sd.available();
|
|
}
|
|
|
|
ircd::net::hostport
|
|
ircd::net::local_hostport(const socket &socket)
|
|
{
|
|
const auto &ep(socket.local());
|
|
return { hostaddr(ep), port(ep) };
|
|
}
|
|
|
|
ircd::net::hostport
|
|
ircd::net::remote_hostport(const socket &socket)
|
|
{
|
|
const auto &ep(socket.remote());
|
|
return { hostaddr(ep), port(ep) };
|
|
}
|
|
|
|
bool
|
|
ircd::net::connected(const socket &s)
|
|
noexcept
|
|
{
|
|
return s.connected();
|
|
}
|
|
|
|
uint16_t
|
|
ircd::net::port(const ip::tcp::endpoint &ep)
|
|
{
|
|
return ep.port();
|
|
}
|
|
|
|
std::string
|
|
ircd::net::hostaddr(const ip::tcp::endpoint &ep)
|
|
{
|
|
return string(address(ep));
|
|
}
|
|
|
|
std::string
|
|
ircd::net::string(const ip::address &addr)
|
|
{
|
|
return addr.to_string();
|
|
}
|
|
|
|
std::string
|
|
ircd::net::string(const ip::tcp::endpoint &ep)
|
|
{
|
|
std::string ret(256, char{});
|
|
ret.resize(fmt::sprintf(mutable_buffer{ret}, "%s:%u", string(address(ep)), port(ep)));
|
|
return ret;
|
|
}
|
|
|
|
boost::asio::ip::address
|
|
ircd::net::address(const ip::tcp::endpoint &ep)
|
|
{
|
|
return ep.address();
|
|
}
|
|
|
|
//
|
|
// socket::io
|
|
//
|
|
|
|
ircd::net::socket::io::io(struct socket &sock,
|
|
struct stat &stat,
|
|
const std::function<size_t ()> &closure)
|
|
:sock{sock}
|
|
,stat{stat}
|
|
,bytes{closure()}
|
|
{
|
|
stat.bytes += bytes;
|
|
stat.calls++;
|
|
}
|
|
|
|
ircd::net::socket::io::operator size_t()
|
|
const
|
|
{
|
|
return bytes;
|
|
}
|
|
|
|
//
|
|
// socket::scope_timeout
|
|
//
|
|
|
|
ircd::net::socket::scope_timeout::scope_timeout(socket &socket,
|
|
const milliseconds &timeout)
|
|
:s{&socket}
|
|
{
|
|
socket.set_timeout(timeout, [&socket]
|
|
(const error_code &ec)
|
|
{
|
|
if(!ec)
|
|
socket.sd.cancel();
|
|
});
|
|
}
|
|
|
|
ircd::net::socket::scope_timeout::scope_timeout(socket &socket,
|
|
const milliseconds &timeout,
|
|
const socket::handler &handler)
|
|
:s{&socket}
|
|
{
|
|
socket.set_timeout(timeout, handler);
|
|
}
|
|
|
|
ircd::net::socket::scope_timeout::~scope_timeout()
|
|
noexcept
|
|
{
|
|
s->timer.cancel();
|
|
}
|
|
|
|
//
|
|
// socket
|
|
//
|
|
|
|
ircd::net::socket::socket(const std::string &host,
|
|
const uint16_t &port,
|
|
const milliseconds &timeout,
|
|
asio::ssl::context &ssl,
|
|
boost::asio::io_service *const &ios)
|
|
:socket
|
|
{
|
|
[&host, &port]() -> ip::tcp::endpoint
|
|
{
|
|
assert(resolver);
|
|
const ip::tcp::resolver::query query(host, string(lex_cast(port)));
|
|
auto epit(resolver->async_resolve(query, yield_context{to_asio{}}));
|
|
static const ip::tcp::resolver::iterator end;
|
|
if(epit == end)
|
|
throw nxdomain("host '%s' not found", host.data());
|
|
|
|
log::debug("resolved remote %s:%u => %s",
|
|
host,
|
|
port,
|
|
string(*epit));
|
|
|
|
return *epit;
|
|
}(),
|
|
timeout,
|
|
ssl,
|
|
ios
|
|
}
|
|
{
|
|
}
|
|
|
|
ircd::net::socket::socket(const ip::tcp::endpoint &remote,
|
|
const milliseconds &timeout,
|
|
asio::ssl::context &ssl,
|
|
boost::asio::io_service *const &ios)
|
|
try
|
|
:socket{ssl, ios}
|
|
{
|
|
log::debug("socket(%p) connecting to remote: %s timeout: %ld$ms",
|
|
this,
|
|
string(remote),
|
|
timeout.count());
|
|
|
|
connect(remote, timeout);
|
|
|
|
log::debug("socket(%p) connected to remote: %s from local: %s",
|
|
this,
|
|
string(remote),
|
|
string(local()));
|
|
}
|
|
catch(const std::exception &e)
|
|
{
|
|
log::debug("socket(%p) failed to connect to remote %s: %s",
|
|
this,
|
|
string(remote),
|
|
e.what());
|
|
}
|
|
|
|
ircd::net::socket::socket(asio::ssl::context &ssl,
|
|
boost::asio::io_service *const &ios)
|
|
:ssl
|
|
{
|
|
*ios, ssl
|
|
}
|
|
,sd
|
|
{
|
|
this->ssl.next_layer()
|
|
}
|
|
,timer
|
|
{
|
|
*ios
|
|
}
|
|
,timedout
|
|
{
|
|
false
|
|
}
|
|
{
|
|
}
|
|
|
|
ircd::net::socket::~socket()
|
|
noexcept
|
|
{
|
|
}
|
|
|
|
void
|
|
ircd::net::socket::connect(const ip::tcp::endpoint &ep,
|
|
const milliseconds &timeout)
|
|
{
|
|
const scope_timeout ts(*this, timeout);
|
|
sd.async_connect(ep, yield_context{to_asio{}});
|
|
ssl.async_handshake(socket::handshake_type::client, yield_context{to_asio{}});
|
|
}
|
|
|
|
void
|
|
ircd::net::socket::disconnect(const dc &type)
|
|
{
|
|
if(timer.expires_from_now() > 0ms)
|
|
timer.cancel();
|
|
|
|
if(sd.is_open()) switch(type)
|
|
{
|
|
default:
|
|
case dc::RST: sd.close(); break;
|
|
case dc::FIN: sd.shutdown(ip::tcp::socket::shutdown_both); break;
|
|
case dc::FIN_SEND: sd.shutdown(ip::tcp::socket::shutdown_send); break;
|
|
case dc::FIN_RECV: sd.shutdown(ip::tcp::socket::shutdown_receive); break;
|
|
|
|
case dc::SSL_NOTIFY:
|
|
{
|
|
ssl.async_shutdown([socket(shared_from_this())]
|
|
(boost::system::error_code ec)
|
|
{
|
|
if(!ec)
|
|
socket->sd.close(ec);
|
|
|
|
if(ec)
|
|
log::warning("socket(%p): disconnect(): %s",
|
|
socket.get(),
|
|
ec.message());
|
|
});
|
|
break;
|
|
}
|
|
|
|
case dc::SSL_NOTIFY_YIELD:
|
|
{
|
|
ssl.async_shutdown(yield_context{to_asio{}});
|
|
sd.close();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
ircd::net::socket::cancel()
|
|
{
|
|
timer.cancel();
|
|
sd.cancel();
|
|
}
|
|
|
|
/// Asynchronous callback when the socket is ready
|
|
///
|
|
/// Overload for operator() without a timeout. see: operator()
|
|
///
|
|
void
|
|
ircd::net::socket::operator()(handler h)
|
|
{
|
|
operator()(milliseconds(-1), std::move(h));
|
|
}
|
|
|
|
/// Asynchronous callback when the socket is ready
|
|
///
|
|
/// This function calls back the handler when the socket has received
|
|
/// something and is ready to be read from.
|
|
///
|
|
/// The purpose here is to allow waiting for data from the socket without
|
|
/// blocking any context and using any stack space whatsoever, i.e full
|
|
/// asynchronous mode.
|
|
///
|
|
/// boost::asio has no direct way to accomplish this because the buffer size
|
|
/// must be positive so we use a little trick to read a single byte with
|
|
/// MSG_PEEK as our indication. This is done directly on the socket and
|
|
/// not through the SSL cipher, but we don't want this byte anyway. This
|
|
/// isn't such a great trick.
|
|
///
|
|
void
|
|
ircd::net::socket::operator()(const milliseconds &timeout,
|
|
handler callback)
|
|
{
|
|
static const auto flags
|
|
{
|
|
ip::tcp::socket::message_peek
|
|
};
|
|
|
|
static char buffer[1];
|
|
static const asio::mutable_buffers_1 buffers
|
|
{
|
|
buffer, sizeof(buffer)
|
|
};
|
|
|
|
auto handler
|
|
{
|
|
std::bind(&socket::handle, this, weak_from(*this), std::move(callback), ph::_1, ph::_2)
|
|
};
|
|
|
|
set_timeout(timeout);
|
|
sd.async_receive(buffers, flags, std::move(handler));
|
|
}
|
|
|
|
void
|
|
ircd::net::socket::handle(const std::weak_ptr<socket> wp,
|
|
const handler callback,
|
|
const error_code &ec,
|
|
const size_t &bytes)
|
|
noexcept
|
|
{
|
|
// This handler may still be registered with asio after the socket destructs, so
|
|
// the weak_ptr will indicate that fact. However, this is never intended and is
|
|
// a debug assertion which should be corrected.
|
|
if(unlikely(wp.expired()))
|
|
{
|
|
log::warning("socket(%p): belated callback to handler...", this);
|
|
assert(0);
|
|
return;
|
|
}
|
|
|
|
// This handler and the timeout handler are responsible for canceling each other
|
|
// when one or the other is entered. If the timeout handler has already fired for
|
|
// a timeout on the socket, `timedout` will be `true` and this handler will be
|
|
// entered with an `operation_canceled` error.
|
|
if(!timedout)
|
|
timer.cancel();
|
|
else
|
|
assert(ec == boost::system::errc::operation_canceled);
|
|
|
|
// We can handle a few errors at this level which don't ever need to invoke the
|
|
// user's callback. Otherwise they are passed up.
|
|
if(!handle_error(ec))
|
|
{
|
|
log::debug("socket(%p): %s", this, ec.message());
|
|
return;
|
|
}
|
|
|
|
call_user(callback, ec);
|
|
}
|
|
|
|
void
|
|
ircd::net::socket::call_user(const handler &callback,
|
|
const error_code &ec)
|
|
noexcept try
|
|
{
|
|
callback(ec);
|
|
}
|
|
catch(const std::exception &e)
|
|
{
|
|
log::error("socket(%p): async handler: unhandled exception: %s",
|
|
this,
|
|
e.what());
|
|
|
|
if(ircd::debugmode)
|
|
std::terminate();
|
|
}
|
|
|
|
bool
|
|
ircd::net::socket::handle_error(const error_code &ec)
|
|
{
|
|
using namespace boost::system::errc;
|
|
|
|
switch(ec.value())
|
|
{
|
|
// A success is not an error; can call the user handler
|
|
case success:
|
|
return true;
|
|
|
|
// A cancel is triggered either by the timeout handler or by
|
|
// a request to shutdown/close the socket. We only call the user's
|
|
// handler for a timeout, otherwise this is hidden from the user.
|
|
case operation_canceled:
|
|
return timedout;
|
|
|
|
// This indicates the remote closed the socket, we still
|
|
// pass this up to the user so they can handle it.
|
|
case boost::asio::error::eof:
|
|
return true;
|
|
|
|
// This is a condition which we hide from the user.
|
|
case bad_file_descriptor:
|
|
return false;
|
|
|
|
// Everything else is passed up to the user.
|
|
default:
|
|
return true;
|
|
}
|
|
}
|
|
|
|
void
|
|
ircd::net::socket::handle_timeout(const std::weak_ptr<socket> wp,
|
|
const error_code &ec)
|
|
{
|
|
using namespace boost::system::errc;
|
|
|
|
if(!wp.expired()) switch(ec.value())
|
|
{
|
|
// A 'success' for this handler means there was a timeout on the socket
|
|
case success:
|
|
timedout = true;
|
|
cancel();
|
|
break;
|
|
|
|
// A cancelation means there was no timeout.
|
|
case operation_canceled:
|
|
timedout = false;
|
|
break;
|
|
|
|
// All other errors are unexpected, logged and ignored here.
|
|
default:
|
|
log::error("socket::handle_timeout(): unexpected: %s\n",
|
|
ec.message());
|
|
break;
|
|
}
|
|
}
|
|
|
|
bool
|
|
ircd::net::socket::connected()
|
|
const noexcept try
|
|
{
|
|
return sd.is_open();
|
|
}
|
|
catch(const boost::system::system_error &e)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
void
|
|
ircd::net::socket::set_timeout(const milliseconds &t)
|
|
{
|
|
if(t < milliseconds(0))
|
|
return;
|
|
|
|
timer.expires_from_now(t);
|
|
timer.async_wait(std::bind(&socket::handle_timeout, this, weak_from(*this), ph::_1));
|
|
}
|
|
|
|
void
|
|
ircd::net::socket::set_timeout(const milliseconds &t,
|
|
handler h)
|
|
{
|
|
if(t < milliseconds(0))
|
|
return;
|
|
|
|
timer.expires_from_now(t);
|
|
timer.async_wait(std::move(h));
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// buffer.h - provide definition for the null buffers and asio conversion
|
|
//
|
|
|
|
const ircd::buffer::mutable_buffer
|
|
ircd::buffer::null_buffer
|
|
{
|
|
nullptr, nullptr
|
|
};
|
|
|
|
const ircd::ilist<ircd::buffer::mutable_buffer>
|
|
ircd::buffer::null_buffers
|
|
{{
|
|
null_buffer
|
|
}};
|
|
|
|
ircd::buffer::mutable_buffer::operator
|
|
boost::asio::mutable_buffer()
|
|
const
|
|
{
|
|
return boost::asio::mutable_buffer
|
|
{
|
|
data(*this), size(*this)
|
|
};
|
|
}
|
|
|
|
ircd::buffer::const_buffer::operator
|
|
boost::asio::const_buffer()
|
|
const
|
|
{
|
|
return boost::asio::const_buffer
|
|
{
|
|
data(*this), size(*this)
|
|
};
|
|
}
|
|
|
|
ircd::buffer::mutable_raw_buffer::operator
|
|
boost::asio::mutable_buffer()
|
|
const
|
|
{
|
|
return boost::asio::mutable_buffer
|
|
{
|
|
data(*this), size(*this)
|
|
};
|
|
}
|
|
|
|
ircd::buffer::const_raw_buffer::operator
|
|
boost::asio::const_buffer()
|
|
const
|
|
{
|
|
return boost::asio::const_buffer
|
|
{
|
|
data(*this), size(*this)
|
|
};
|
|
}
|