2007-01-25 07:40:21 +01:00
|
|
|
/*
|
2007-12-03 17:59:25 +01:00
|
|
|
* charybdis: an advanced ircd.
|
2007-01-25 07:40:21 +01:00
|
|
|
* client.c: Controls clients.
|
|
|
|
*
|
|
|
|
* Copyright (C) 1990 Jarkko Oikarinen and University of Oulu, Co Center
|
|
|
|
* Copyright (C) 1996-2002 Hybrid Development Team
|
|
|
|
* Copyright (C) 2002-2005 ircd-ratbox development team
|
2007-12-03 17:59:25 +01:00
|
|
|
* Copyright (C) 2007 William Pitcock
|
2016-09-10 21:57:33 +02:00
|
|
|
* Copyright (C) 2016 Charybdis Development Team
|
|
|
|
* Copyright (C) 2016 Jason Volk <jason@zemos.net>
|
2007-01-25 07:40:21 +01:00
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
|
|
|
|
* USA
|
|
|
|
*/
|
|
|
|
|
2017-09-21 04:31:54 +02:00
|
|
|
#include <ircd/asio.h>
|
2016-09-12 23:07:46 +02:00
|
|
|
|
2016-09-23 08:59:24 +02:00
|
|
|
namespace ircd {
|
|
|
|
|
2017-08-23 23:50:37 +02:00
|
|
|
// Default time limit for how long a client connection can be in "async mode"
|
|
|
|
// (or idle mode) after which it is disconnected.
|
2017-03-14 02:39:54 +01:00
|
|
|
const auto async_timeout
|
|
|
|
{
|
2017-11-30 20:44:23 +01:00
|
|
|
40s
|
2017-03-14 02:39:54 +01:00
|
|
|
};
|
|
|
|
|
2017-08-23 23:50:37 +02:00
|
|
|
// Time limit for how long a connected client can be in "request mode." This
|
|
|
|
// should never be hit unless there's an error in the handling code.
|
2017-03-14 02:39:54 +01:00
|
|
|
const auto request_timeout
|
|
|
|
{
|
2017-11-30 20:44:23 +01:00
|
|
|
20s
|
2017-03-14 02:39:54 +01:00
|
|
|
};
|
|
|
|
|
2017-08-23 23:50:37 +02:00
|
|
|
// The pool of request contexts. When a client makes a request it does so by acquiring
|
|
|
|
// a stack from this pool. The request handling and response logic can then be written
|
|
|
|
// in a synchronous manner as if each connection had its own thread.
|
2016-11-29 16:23:38 +01:00
|
|
|
ctx::pool request
|
2016-09-11 08:05:38 +02:00
|
|
|
{
|
2017-11-30 20:44:23 +01:00
|
|
|
"request", 4_MiB
|
2016-09-23 08:59:24 +02:00
|
|
|
};
|
2016-09-11 08:05:38 +02:00
|
|
|
|
2017-08-23 23:50:37 +02:00
|
|
|
// Container for all active clients (connections) for iteration purposes.
|
|
|
|
client::list client::clients;
|
2016-09-23 08:59:24 +02:00
|
|
|
|
2017-10-27 00:36:31 +02:00
|
|
|
static bool handle_ec(client &, const net::error_code &);
|
2016-11-29 16:23:38 +01:00
|
|
|
void async_recv_next(std::shared_ptr<client>, const milliseconds &timeout);
|
|
|
|
void async_recv_next(std::shared_ptr<client>);
|
2007-01-25 07:40:21 +01:00
|
|
|
|
2017-10-27 00:36:31 +02:00
|
|
|
void disconnect(client &, const net::dc & = net::dc::RST);
|
2016-11-29 16:23:38 +01:00
|
|
|
void disconnect_all();
|
2016-08-24 01:08:40 +02:00
|
|
|
|
2016-11-29 16:23:38 +01:00
|
|
|
template<class... args> std::shared_ptr<client> make_client(args&&...);
|
2016-09-23 08:59:24 +02:00
|
|
|
|
2016-11-29 16:23:38 +01:00
|
|
|
} // namespace ircd
|
2016-09-23 08:59:24 +02:00
|
|
|
|
2016-11-29 16:23:38 +01:00
|
|
|
ircd::client::init::init()
|
2016-09-11 08:05:38 +02:00
|
|
|
{
|
2017-11-30 20:44:23 +01:00
|
|
|
request.add(32);
|
2016-09-11 08:05:38 +02:00
|
|
|
}
|
2016-08-22 03:57:43 +02:00
|
|
|
|
2017-11-06 21:14:50 +01:00
|
|
|
void
|
|
|
|
ircd::client::init::interrupt()
|
2016-09-11 08:05:38 +02:00
|
|
|
{
|
2017-11-06 21:14:50 +01:00
|
|
|
if(request.active() || !client::clients.empty())
|
|
|
|
log::warning("Interrupting %zu requests; dropping %zu requests; disconnecting %zu clients...",
|
|
|
|
request.active(),
|
|
|
|
request.pending(),
|
|
|
|
client::clients.size());
|
2017-09-21 04:31:54 +02:00
|
|
|
|
2016-11-29 16:23:38 +01:00
|
|
|
request.interrupt();
|
|
|
|
disconnect_all();
|
2017-11-06 21:14:50 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
ircd::client::init::~init()
|
|
|
|
noexcept
|
|
|
|
{
|
|
|
|
interrupt();
|
|
|
|
|
2017-11-26 03:25:35 +01:00
|
|
|
if(request.active())
|
2017-11-06 21:14:50 +01:00
|
|
|
log::warning("Joining %zu active of %zu remaining request contexts...",
|
|
|
|
request.active(),
|
|
|
|
request.size());
|
2017-11-26 03:25:35 +01:00
|
|
|
else
|
|
|
|
log::debug("Waiting for %zu request contexts to join...",
|
|
|
|
request.size());
|
2017-11-06 21:14:50 +01:00
|
|
|
|
2017-09-20 07:23:49 +02:00
|
|
|
request.join();
|
2017-11-06 21:14:50 +01:00
|
|
|
|
|
|
|
if(unlikely(!client::clients.empty()))
|
|
|
|
{
|
|
|
|
log::error("%zu clients are unterminated...", client::clients.size());
|
|
|
|
assert(client::clients.empty());
|
|
|
|
}
|
2016-09-11 08:05:38 +02:00
|
|
|
}
|
2016-08-22 03:57:43 +02:00
|
|
|
|
2017-12-29 23:55:26 +01:00
|
|
|
ircd::ipport
|
2017-09-30 08:04:41 +02:00
|
|
|
ircd::local(const client &client)
|
2017-03-11 02:46:25 +01:00
|
|
|
{
|
|
|
|
if(!client.sock)
|
2017-12-29 23:55:26 +01:00
|
|
|
return {};
|
2017-03-11 02:46:25 +01:00
|
|
|
|
2017-12-29 23:55:26 +01:00
|
|
|
return net::local_ipport(*client.sock);
|
2017-03-11 02:46:25 +01:00
|
|
|
}
|
|
|
|
|
2017-12-29 23:55:26 +01:00
|
|
|
ircd::ipport
|
2017-09-30 08:04:41 +02:00
|
|
|
ircd::remote(const client &client)
|
2017-03-11 02:46:25 +01:00
|
|
|
{
|
|
|
|
if(!client.sock)
|
2017-12-29 23:55:26 +01:00
|
|
|
return {};
|
2017-03-11 02:46:25 +01:00
|
|
|
|
2017-12-29 23:55:26 +01:00
|
|
|
return net::remote_ipport(*client.sock);
|
2017-03-11 02:46:25 +01:00
|
|
|
}
|
|
|
|
|
2017-03-14 02:39:54 +01:00
|
|
|
ircd::http::response::write_closure
|
|
|
|
ircd::write_closure(client &client)
|
|
|
|
{
|
2017-03-31 00:46:40 +02:00
|
|
|
// returns a function that can be called to send an iovector of data to a client
|
2017-09-12 18:28:41 +02:00
|
|
|
return [&client](const ilist<const_buffer> &iov)
|
2017-03-14 02:39:54 +01:00
|
|
|
{
|
2017-12-23 01:38:05 +01:00
|
|
|
//std::cout << "<<<< " << size(iov) << std::endl;
|
2017-08-23 23:13:57 +02:00
|
|
|
//std::cout << iov << std::endl;
|
2017-12-23 01:38:05 +01:00
|
|
|
//std::cout << "---- " << std::endl;
|
2017-08-23 23:13:57 +02:00
|
|
|
const auto written
|
|
|
|
{
|
|
|
|
write(*client.sock, iov)
|
|
|
|
};
|
2017-03-14 02:39:54 +01:00
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
ircd::parse::read_closure
|
|
|
|
ircd::read_closure(client &client)
|
|
|
|
{
|
2017-03-31 00:46:40 +02:00
|
|
|
// Returns a function the parser can call when it wants more data
|
2017-03-14 02:39:54 +01:00
|
|
|
return [&client](char *&start, char *const &stop)
|
|
|
|
{
|
|
|
|
try
|
|
|
|
{
|
2017-12-23 01:38:05 +01:00
|
|
|
char *const got(start);
|
2017-03-14 02:39:54 +01:00
|
|
|
read(client, start, stop);
|
2017-12-23 01:38:05 +01:00
|
|
|
//std::cout << ">>>> " << std::distance(got, start) << std::endl;
|
2017-08-23 23:13:57 +02:00
|
|
|
//std::cout << string_view{got, start} << std::endl;
|
|
|
|
//std::cout << "----" << std::endl;
|
2017-03-14 02:39:54 +01:00
|
|
|
}
|
|
|
|
catch(const boost::system::system_error &e)
|
|
|
|
{
|
2017-10-19 10:04:52 +02:00
|
|
|
using namespace boost::system::errc;
|
|
|
|
|
|
|
|
switch(e.code().value())
|
|
|
|
{
|
|
|
|
case operation_canceled:
|
|
|
|
throw http::error(http::REQUEST_TIMEOUT);
|
|
|
|
|
|
|
|
default:
|
|
|
|
throw;
|
|
|
|
}
|
2017-03-14 02:39:54 +01:00
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2017-10-12 02:44:00 +02:00
|
|
|
char *
|
|
|
|
ircd::read(client &client,
|
|
|
|
char *&start,
|
|
|
|
char *const &stop)
|
|
|
|
{
|
|
|
|
auto &sock(*client.sock);
|
|
|
|
const std::array<mutable_buffer, 1> bufs
|
|
|
|
{{
|
|
|
|
{ start, stop }
|
|
|
|
}};
|
|
|
|
|
|
|
|
char *const base(start);
|
|
|
|
start += sock.read_some(bufs);
|
|
|
|
return base;
|
|
|
|
}
|
|
|
|
|
|
|
|
const char *
|
|
|
|
ircd::write(client &client,
|
|
|
|
const char *&start,
|
|
|
|
const char *const &stop)
|
|
|
|
{
|
|
|
|
auto &sock(*client.sock);
|
|
|
|
const std::array<const_buffer, 1> bufs
|
|
|
|
{{
|
|
|
|
{ start, stop }
|
|
|
|
}};
|
|
|
|
|
|
|
|
const char *const base(start);
|
|
|
|
start += sock.write(bufs);
|
|
|
|
return base;
|
|
|
|
}
|
|
|
|
|
2017-12-24 08:34:11 +01:00
|
|
|
void
|
|
|
|
ircd::async_recv_next(std::shared_ptr<client> client)
|
|
|
|
{
|
|
|
|
async_recv_next(std::move(client), milliseconds(-1));
|
|
|
|
}
|
|
|
|
|
|
|
|
///
|
|
|
|
/// This function is the basis for the client's request loop. We still use
|
|
|
|
/// an asynchronous pattern until there is activity on the socket (a request)
|
|
|
|
/// in which case the switch to synchronous mode is made by jumping into an
|
|
|
|
/// ircd::context drawn from the request pool. When the request is finished,
|
|
|
|
/// the client exits back into asynchronous mode until the next request is
|
|
|
|
/// received and rinse and repeat.
|
|
|
|
//
|
|
|
|
/// This sequence exists to avoid any possible c10k-style limitation imposed by
|
|
|
|
/// dedicating a context and its stack space to the lifetime of a connection.
|
|
|
|
/// This is similar to the thread-per-request pattern before async was in vogue.
|
|
|
|
//
|
|
|
|
/// Developers: Pay close attention to the comments to know exactly where you
|
|
|
|
/// are and what you can do at any given point in this sequence.
|
|
|
|
///
|
|
|
|
void
|
|
|
|
ircd::async_recv_next(std::shared_ptr<client> client,
|
|
|
|
const milliseconds &timeout)
|
|
|
|
{
|
|
|
|
assert(bool(client));
|
|
|
|
assert(bool(client->sock));
|
|
|
|
|
|
|
|
// This call returns immediately so we no longer block the current context and
|
|
|
|
// its stack while waiting for activity on idle connections between requests.
|
|
|
|
|
|
|
|
auto &sock(*client->sock);
|
2018-01-01 10:42:00 +01:00
|
|
|
static const auto op{sock.sd.wait_read};
|
|
|
|
sock(op, timeout, [client(std::move(client)), timeout](const net::error_code &ec)
|
2017-12-24 08:34:11 +01:00
|
|
|
noexcept
|
|
|
|
{
|
|
|
|
// Right here this handler is executing on the main stack (not in any
|
|
|
|
// ircd::context).
|
|
|
|
if(!handle_ec(*client, ec))
|
|
|
|
return;
|
|
|
|
|
|
|
|
// This call returns immediately because we can never block the main stack outside
|
|
|
|
// of the ircd::context system. The context the closure ends up getting is the next
|
|
|
|
// available from the request pool, which may not be available immediately so this
|
|
|
|
// handler might be queued for some time after this call returns.
|
|
|
|
request([ec, client(std::move(client)), timeout]
|
|
|
|
{
|
|
|
|
// Right here this handler is executing on an ircd::context with its own
|
|
|
|
// stack dedicated to the lifetime of this request. If client::main()
|
|
|
|
// returns true, we bring the client back into async mode to wait for
|
|
|
|
// the next request.
|
|
|
|
if(client->main())
|
|
|
|
async_recv_next(std::move(client), timeout);
|
|
|
|
else
|
|
|
|
disconnect(*client, net::dc::SSL_NOTIFY_YIELD);
|
|
|
|
});
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2017-10-12 02:44:00 +02:00
|
|
|
//
|
|
|
|
// client
|
|
|
|
//
|
|
|
|
|
2017-03-11 02:46:25 +01:00
|
|
|
ircd::client::client()
|
|
|
|
:client{std::shared_ptr<socket>{}}
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2017-09-30 08:04:41 +02:00
|
|
|
ircd::client::client(const hostport &host_port,
|
2017-03-11 02:46:25 +01:00
|
|
|
const seconds &timeout)
|
|
|
|
:client
|
|
|
|
{
|
2017-10-27 00:36:31 +02:00
|
|
|
net::connect(host_port, timeout)
|
2017-03-11 02:46:25 +01:00
|
|
|
}
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
ircd::client::client(std::shared_ptr<socket> sock)
|
2017-08-23 22:47:15 +02:00
|
|
|
:clit{clients, clients.emplace(end(clients), this)}
|
2017-03-11 02:46:25 +01:00
|
|
|
,sock{std::move(sock)}
|
2017-09-24 04:51:06 +02:00
|
|
|
,request_timer{ircd::timer::nostart}
|
2017-03-11 02:46:25 +01:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
ircd::client::~client()
|
2017-10-25 18:49:16 +02:00
|
|
|
noexcept try
|
|
|
|
{
|
2017-11-01 23:51:24 +01:00
|
|
|
//assert(!sock || !connected(*sock));
|
2017-10-25 18:49:16 +02:00
|
|
|
}
|
|
|
|
catch(const std::exception &e)
|
2017-03-11 02:46:25 +01:00
|
|
|
{
|
2017-11-01 23:51:24 +01:00
|
|
|
log::critical("~client(%p): %s", this, e.what());
|
2017-10-25 18:49:16 +02:00
|
|
|
return;
|
2017-03-11 02:46:25 +01:00
|
|
|
}
|
|
|
|
|
2017-12-22 00:12:36 +01:00
|
|
|
/// Main client loop.
|
|
|
|
///
|
|
|
|
/// This function parses requests off the socket in a loop until there are no
|
|
|
|
/// more requests or there is a fatal error. The ctx will "block" to wait for
|
|
|
|
/// more data off the socket during the middle of a request until the request
|
|
|
|
/// timeout is reached. main() will not "block" to wait for more data after a
|
|
|
|
/// request; it will simply `return true` which puts this client back into
|
|
|
|
/// async mode and relinquishes this stack. returning false will disconnect
|
|
|
|
/// the client rather than putting it back into async mode. Exceptions do not
|
|
|
|
/// pass below main() therefor anything unhandled is an internal server error
|
|
|
|
/// and the client is disconnected as well.
|
|
|
|
///
|
|
|
|
/// Before main(), the client had been sitting in async mode waiting for
|
|
|
|
/// socket activity. Once activity with data was detected indicating a request,
|
|
|
|
/// the client was dispatched to the request pool where it is paired to an
|
|
|
|
/// ircd::ctx with a stack. main() is then invoked on that ircd::ctx stack.
|
|
|
|
/// Nothing from the socket has been read into userspace before main().
|
|
|
|
///
|
2017-03-11 02:46:25 +01:00
|
|
|
bool
|
|
|
|
ircd::client::main()
|
|
|
|
noexcept try
|
|
|
|
{
|
2017-11-30 20:44:23 +01:00
|
|
|
const auto header_max{8_KiB};
|
|
|
|
//const auto content_max{64_KiB};
|
|
|
|
const auto content_max{8_MiB};
|
2017-10-27 00:36:31 +02:00
|
|
|
const unique_buffer<mutable_buffer> buffer
|
2017-10-12 03:16:10 +02:00
|
|
|
{
|
|
|
|
header_max + content_max
|
|
|
|
};
|
|
|
|
|
|
|
|
parse::buffer pb{buffer};
|
2017-09-12 19:04:40 +02:00
|
|
|
parse::capstan pc{pb, read_closure(*this)}; do
|
|
|
|
{
|
2017-12-24 08:34:11 +01:00
|
|
|
request_timer = ircd::timer{};
|
|
|
|
const socket::scope_timeout timeout
|
|
|
|
{
|
|
|
|
*sock, request_timeout, [client(shared_from(*this))]
|
|
|
|
(const net::error_code &ec)
|
|
|
|
{
|
|
|
|
if(!ec)
|
|
|
|
disconnect(*client, net::dc::SSL_NOTIFY_YIELD);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2017-09-12 19:04:40 +02:00
|
|
|
if(!handle_request(*this, pc))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
pb.remove();
|
|
|
|
}
|
|
|
|
while(pc.unparsed());
|
|
|
|
|
|
|
|
return true;
|
2017-03-11 02:46:25 +01:00
|
|
|
}
|
2016-11-29 16:23:38 +01:00
|
|
|
catch(const boost::system::system_error &e)
|
2016-09-12 23:07:46 +02:00
|
|
|
{
|
2017-08-23 23:13:57 +02:00
|
|
|
using namespace boost::system::errc;
|
2017-12-29 23:53:39 +01:00
|
|
|
using boost::system::system_category;
|
2017-10-27 00:36:31 +02:00
|
|
|
using boost::asio::error::get_ssl_category;
|
|
|
|
using boost::asio::error::get_misc_category;
|
|
|
|
|
2017-11-17 07:02:57 +01:00
|
|
|
const error_code &ec{e.code()};
|
|
|
|
const int &value{ec.value()};
|
2017-12-29 23:53:39 +01:00
|
|
|
if(ec.category() == system_category()) switch(value)
|
2017-08-23 23:13:57 +02:00
|
|
|
{
|
|
|
|
case success:
|
2017-11-01 23:51:24 +01:00
|
|
|
assert(0);
|
2017-08-23 23:13:57 +02:00
|
|
|
return true;
|
|
|
|
|
2017-08-23 22:47:15 +02:00
|
|
|
case broken_pipe:
|
|
|
|
case connection_reset:
|
2017-08-23 23:13:57 +02:00
|
|
|
case not_connected:
|
2017-11-01 23:51:24 +01:00
|
|
|
disconnect(*this, net::dc::RST);
|
|
|
|
return false;
|
|
|
|
|
2017-08-23 23:50:37 +02:00
|
|
|
case operation_canceled:
|
2017-11-01 23:51:24 +01:00
|
|
|
disconnect(*this, net::dc::SSL_NOTIFY);
|
|
|
|
return false;
|
|
|
|
|
|
|
|
case bad_file_descriptor:
|
2017-08-23 23:13:57 +02:00
|
|
|
return false;
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2017-11-17 07:02:57 +01:00
|
|
|
else if(ec.category() == get_ssl_category()) switch(uint8_t(value))
|
2017-10-27 00:36:31 +02:00
|
|
|
{
|
2017-11-17 07:02:57 +01:00
|
|
|
case SSL_R_SHORT_READ:
|
2017-11-25 22:20:46 +01:00
|
|
|
case SSL_R_PROTOCOL_IS_SHUTDOWN:
|
2017-11-01 23:51:24 +01:00
|
|
|
disconnect(*this, net::dc::RST);
|
2017-10-27 00:36:31 +02:00
|
|
|
return false;
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2017-11-17 07:02:57 +01:00
|
|
|
else if(ec.category() == get_misc_category()) switch(value)
|
2017-10-27 00:36:31 +02:00
|
|
|
{
|
2017-11-17 07:02:57 +01:00
|
|
|
case boost::asio::error::eof:
|
2017-11-01 23:51:24 +01:00
|
|
|
disconnect(*this, net::dc::RST);
|
2017-10-27 00:36:31 +02:00
|
|
|
return false;
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2017-11-01 23:51:24 +01:00
|
|
|
log::error("client(%p): (unexpected) %s: (%d) %s",
|
|
|
|
(const void *)this,
|
|
|
|
ec.category().name(),
|
2017-11-17 07:02:57 +01:00
|
|
|
value,
|
2017-11-01 23:51:24 +01:00
|
|
|
ec.message());
|
2017-08-23 23:13:57 +02:00
|
|
|
|
2017-11-01 23:51:24 +01:00
|
|
|
disconnect(*this, net::dc::RST);
|
2016-09-12 23:07:46 +02:00
|
|
|
return false;
|
2016-09-11 08:05:38 +02:00
|
|
|
}
|
2016-11-29 16:23:38 +01:00
|
|
|
catch(const std::exception &e)
|
2017-03-14 00:11:30 +01:00
|
|
|
{
|
|
|
|
log::error("client[%s] [500 Internal Error]: %s",
|
2017-09-30 08:04:41 +02:00
|
|
|
string(remote(*this)),
|
2017-03-14 00:11:30 +01:00
|
|
|
e.what());
|
|
|
|
|
2017-11-01 23:51:24 +01:00
|
|
|
#ifdef RB_DEBUG
|
2017-10-25 18:49:16 +02:00
|
|
|
throw;
|
2017-11-01 23:51:24 +01:00
|
|
|
#else
|
|
|
|
return false;
|
|
|
|
#endif
|
2017-03-14 00:11:30 +01:00
|
|
|
}
|
|
|
|
|
2016-11-29 16:23:38 +01:00
|
|
|
std::shared_ptr<ircd::client>
|
|
|
|
ircd::add_client(std::shared_ptr<socket> s)
|
2016-09-12 23:07:46 +02:00
|
|
|
{
|
2017-12-22 00:13:26 +01:00
|
|
|
//ip::tcp::socket &sd(*s);
|
|
|
|
//sd.non_blocking(false);
|
|
|
|
|
|
|
|
//static const asio::socket_base::keep_alive keep_alive(true);
|
|
|
|
//sd.set_option(keep_alive);
|
|
|
|
|
|
|
|
//static const asio::socket_base::linger linger{true, 10};
|
|
|
|
//sd.set_option(linger);
|
|
|
|
|
2017-08-23 22:47:15 +02:00
|
|
|
const auto client
|
|
|
|
{
|
|
|
|
make_client(std::move(s))
|
|
|
|
};
|
|
|
|
|
2017-08-23 23:13:57 +02:00
|
|
|
log::debug("client[%s] CONNECTED local[%s]",
|
2017-09-30 08:04:41 +02:00
|
|
|
string(remote(*client)),
|
|
|
|
string(local(*client)));
|
2016-11-29 16:23:38 +01:00
|
|
|
|
2017-03-14 02:39:54 +01:00
|
|
|
async_recv_next(client, async_timeout);
|
2016-11-29 16:23:38 +01:00
|
|
|
return client;
|
2016-09-12 23:07:46 +02:00
|
|
|
}
|
2016-11-29 16:23:38 +01:00
|
|
|
|
|
|
|
template<class... args>
|
|
|
|
std::shared_ptr<ircd::client>
|
|
|
|
ircd::make_client(args&&... a)
|
2016-09-12 23:07:46 +02:00
|
|
|
{
|
2016-11-29 16:23:38 +01:00
|
|
|
return std::make_shared<client>(std::forward<args>(a)...);
|
2016-09-11 08:05:38 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2016-11-29 16:23:38 +01:00
|
|
|
ircd::disconnect_all()
|
2016-09-13 02:10:04 +02:00
|
|
|
{
|
2017-11-01 23:51:24 +01:00
|
|
|
auto it(begin(client::clients));
|
|
|
|
while(it != end(client::clients))
|
2016-11-29 16:23:38 +01:00
|
|
|
{
|
2017-11-01 23:51:24 +01:00
|
|
|
auto *const client(*it);
|
|
|
|
++it; try
|
|
|
|
{
|
|
|
|
disconnect(*client, net::dc::SSL_NOTIFY);
|
|
|
|
}
|
|
|
|
catch(const std::exception &e)
|
|
|
|
{
|
|
|
|
log::warning("Error disconnecting client @%p: %s", client, e.what());
|
|
|
|
}
|
2016-11-29 16:23:38 +01:00
|
|
|
}
|
2016-09-13 02:10:04 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2016-11-29 16:23:38 +01:00
|
|
|
ircd::disconnect(client &client,
|
2017-10-27 00:36:31 +02:00
|
|
|
const net::dc &type)
|
2015-12-13 00:22:21 +01:00
|
|
|
{
|
2017-10-27 00:36:31 +02:00
|
|
|
if(likely(client.sock))
|
|
|
|
disconnect(*client.sock, type);
|
2015-12-13 00:22:21 +01:00
|
|
|
}
|
|
|
|
|
2017-10-27 00:36:31 +02:00
|
|
|
namespace ircd
|
|
|
|
{
|
|
|
|
static bool handle_ec_success(client &);
|
|
|
|
static bool handle_ec_timeout(client &);
|
|
|
|
static bool handle_ec_eof(client &);
|
|
|
|
static bool handle_ec_short_read(client &);
|
|
|
|
static bool handle_ec_default(client &, const net::error_code &);
|
|
|
|
}
|
|
|
|
|
2016-09-11 08:05:38 +02:00
|
|
|
bool
|
2016-09-13 02:10:04 +02:00
|
|
|
ircd::handle_ec(client &client,
|
2017-09-30 08:04:41 +02:00
|
|
|
const net::error_code &ec)
|
2016-09-11 08:05:38 +02:00
|
|
|
{
|
|
|
|
using namespace boost::system::errc;
|
2017-12-29 23:53:39 +01:00
|
|
|
using boost::system::system_category;
|
2017-10-27 00:36:31 +02:00
|
|
|
using boost::asio::error::get_ssl_category;
|
|
|
|
using boost::asio::error::get_misc_category;
|
2016-09-11 08:05:38 +02:00
|
|
|
|
2017-12-29 23:53:39 +01:00
|
|
|
if(ec.category() == system_category()) switch(ec.value())
|
2016-09-11 08:05:38 +02:00
|
|
|
{
|
2016-09-13 02:10:04 +02:00
|
|
|
case success: return handle_ec_success(client);
|
2016-11-29 16:23:38 +01:00
|
|
|
case operation_canceled: return handle_ec_timeout(client);
|
2017-10-27 00:36:31 +02:00
|
|
|
default: return handle_ec_default(client, ec);
|
2016-09-13 02:10:04 +02:00
|
|
|
}
|
2017-10-27 00:36:31 +02:00
|
|
|
else if(ec.category() == get_misc_category()) switch(ec.value())
|
|
|
|
{
|
|
|
|
case asio::error::eof: return handle_ec_eof(client);
|
|
|
|
default: return handle_ec_default(client, ec);
|
|
|
|
}
|
|
|
|
else if(ec.category() == get_ssl_category()) switch(ec.value())
|
|
|
|
{
|
|
|
|
case SSL_R_SHORT_READ: return handle_ec_short_read(client);
|
|
|
|
default: return handle_ec_default(client, ec);
|
|
|
|
}
|
|
|
|
else return handle_ec_default(client, ec);
|
2016-09-13 02:10:04 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
2017-10-27 00:36:31 +02:00
|
|
|
ircd::handle_ec_default(client &client,
|
|
|
|
const net::error_code &ec)
|
2016-09-13 02:10:04 +02:00
|
|
|
{
|
2017-10-27 00:36:31 +02:00
|
|
|
log::debug("client(%p): %s: %s",
|
|
|
|
&client,
|
|
|
|
ec.category().name(),
|
|
|
|
ec.message());
|
|
|
|
|
|
|
|
disconnect(client, net::dc::SSL_NOTIFY);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
ircd::handle_ec_short_read(client &client)
|
|
|
|
try
|
|
|
|
{
|
2017-11-01 23:51:24 +01:00
|
|
|
log::warning("client[%s]: short_read",
|
|
|
|
string(remote(client)));
|
2017-10-27 00:36:31 +02:00
|
|
|
|
|
|
|
disconnect(client, net::dc::RST);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
catch(const std::exception &e)
|
|
|
|
{
|
2017-11-01 23:51:24 +01:00
|
|
|
log::error("client(%p): short_read: %s",
|
|
|
|
&client,
|
|
|
|
e.what());
|
2017-10-27 00:36:31 +02:00
|
|
|
|
|
|
|
return false;
|
2016-09-13 00:10:56 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
ircd::handle_ec_eof(client &client)
|
2017-08-23 22:47:15 +02:00
|
|
|
try
|
2016-09-13 00:10:56 +02:00
|
|
|
{
|
2017-10-25 18:49:16 +02:00
|
|
|
log::debug("client[%s]: EOF",
|
|
|
|
string(remote(client)));
|
2017-08-23 22:47:15 +02:00
|
|
|
|
2017-10-27 00:36:31 +02:00
|
|
|
disconnect(client, net::dc::RST);
|
2016-09-13 00:10:56 +02:00
|
|
|
return false;
|
|
|
|
}
|
2017-08-23 22:47:15 +02:00
|
|
|
catch(const std::exception &e)
|
|
|
|
{
|
2017-11-01 23:51:24 +01:00
|
|
|
log::error("client(%p): EOF: %s",
|
|
|
|
&client,
|
|
|
|
e.what());
|
2017-08-23 22:47:15 +02:00
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
2016-09-13 00:10:56 +02:00
|
|
|
|
2016-11-29 16:23:38 +01:00
|
|
|
bool
|
|
|
|
ircd::handle_ec_timeout(client &client)
|
2017-08-23 22:47:15 +02:00
|
|
|
try
|
2016-09-23 08:59:24 +02:00
|
|
|
{
|
2017-10-19 10:04:52 +02:00
|
|
|
assert(bool(client.sock));
|
2017-11-01 23:51:24 +01:00
|
|
|
log::warning("client[%s]: disconnecting after inactivity timeout",
|
|
|
|
string(remote(client)));
|
2017-08-23 22:47:15 +02:00
|
|
|
|
2017-10-27 00:36:31 +02:00
|
|
|
disconnect(client, net::dc::SSL_NOTIFY);
|
2016-11-29 16:23:38 +01:00
|
|
|
return false;
|
2016-09-11 08:05:38 +02:00
|
|
|
}
|
2017-08-23 22:47:15 +02:00
|
|
|
catch(const std::exception &e)
|
|
|
|
{
|
2017-11-01 23:51:24 +01:00
|
|
|
log::error("client(%p): timeout: %s",
|
|
|
|
&client,
|
|
|
|
e.what());
|
2017-08-23 22:47:15 +02:00
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
2017-10-27 00:36:31 +02:00
|
|
|
|
|
|
|
bool
|
|
|
|
ircd::handle_ec_success(client &client)
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|