mirror of
https://github.com/matrix-construct/construct
synced 2024-08-23 18:14:46 +02:00
330 lines
7.6 KiB
C++
330 lines
7.6 KiB
C++
/*
|
|
* Copyright (C) 2016 Charybdis Development Team
|
|
* Copyright (C) 2016 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.
|
|
*/
|
|
|
|
#pragma once
|
|
#define HAVE_IRCD_CLIENT_SOCK_H
|
|
|
|
#include <boost/asio.hpp>
|
|
#include <boost/asio/ssl.hpp>
|
|
#include <boost/asio/steady_timer.hpp>
|
|
#include "ctx/continuation.h"
|
|
|
|
namespace ircd {
|
|
|
|
namespace asio = boost::asio;
|
|
namespace ip = asio::ip;
|
|
|
|
using boost::system::error_code;
|
|
using asio::steady_timer;
|
|
|
|
IRCD_EXCEPTION(error, nxdomain)
|
|
|
|
extern asio::ssl::context sslv23_client;
|
|
|
|
} // namespace ircd
|
|
|
|
namespace ircd {
|
|
|
|
struct socket
|
|
:std::enable_shared_from_this<socket>
|
|
{
|
|
struct init;
|
|
struct stat;
|
|
struct io;
|
|
|
|
enum dc
|
|
{
|
|
RST, // hardest disconnect
|
|
FIN, // graceful shutdown both directions
|
|
FIN_SEND, // graceful shutdown send side
|
|
FIN_RECV, // graceful shutdown recv side
|
|
};
|
|
|
|
struct stat
|
|
{
|
|
size_t bytes {0};
|
|
size_t calls {0};
|
|
};
|
|
|
|
using message_flags = boost::asio::socket_base::message_flags;
|
|
using handshake_type = asio::ssl::stream<ip::tcp::socket>::handshake_type;
|
|
using handler = std::function<void (const error_code &) noexcept>;
|
|
|
|
asio::ssl::stream<ip::tcp::socket> ssl;
|
|
ip::tcp::socket &sd;
|
|
steady_timer timer;
|
|
stat in, out;
|
|
bool timedout;
|
|
|
|
void handle_timeout(const std::weak_ptr<socket> wp, const error_code &ec) noexcept;
|
|
bool handle_ready(const error_code &ec) noexcept;
|
|
|
|
public:
|
|
operator const ip::tcp::socket &() const { return sd; }
|
|
operator ip::tcp::socket &() { return sd; }
|
|
|
|
ip::tcp::endpoint remote() const { return sd.remote_endpoint(); }
|
|
ip::tcp::endpoint local() const { return sd.local_endpoint(); }
|
|
|
|
bool connected() const noexcept;
|
|
auto available() const { return sd.available(); }
|
|
|
|
template<class duration> void set_timeout(const duration &);
|
|
|
|
template<class iov> auto read_some(const iov &, error_code &);
|
|
template<class iov> auto read_some(const iov &);
|
|
template<class iov> auto read(const iov &, error_code &);
|
|
template<class iov> auto read(const iov &);
|
|
|
|
template<class iov> auto write_some(const iov &, error_code &);
|
|
template<class iov> auto write_some(const iov &);
|
|
template<class iov> auto write(const iov &, error_code &);
|
|
template<class iov> auto write(const iov &);
|
|
|
|
// Asynchronous 'ready' closure
|
|
void operator()(const milliseconds &timeout, handler);
|
|
void operator()(handler);
|
|
void cancel();
|
|
|
|
void disconnect(const dc &type = dc::FIN);
|
|
void connect(const ip::tcp::endpoint &ep);
|
|
|
|
socket(const std::string &host,
|
|
const uint16_t &port,
|
|
asio::ssl::context &ssl = sslv23_client,
|
|
boost::asio::io_service *const &ios = ircd::ios);
|
|
|
|
socket(const ip::tcp::endpoint &remote,
|
|
asio::ssl::context &ssl = sslv23_client,
|
|
boost::asio::io_service *const &ios = ircd::ios);
|
|
|
|
socket(asio::ssl::context &ssl = sslv23_client,
|
|
boost::asio::io_service *const &ios = ircd::ios);
|
|
|
|
~socket() noexcept;
|
|
};
|
|
|
|
char *read(socket &, char *&start, char *const &stop);
|
|
string_view readline(socket &, char *&start, char *const &stop);
|
|
|
|
size_t write(socket &, const char *const &buf, const size_t &max);
|
|
size_t write(socket &, const string_view &);
|
|
|
|
ip::address remote_address(const socket &);
|
|
std::string remote_ip(const socket &);
|
|
uint16_t remote_port(const socket &);
|
|
ip::address local_address(const socket &);
|
|
std::string local_ip(const socket &);
|
|
uint16_t local_port(const socket &);
|
|
|
|
class socket::io
|
|
{
|
|
struct socket &sock;
|
|
struct stat &stat;
|
|
size_t bytes;
|
|
|
|
public:
|
|
operator size_t() const;
|
|
|
|
io(struct socket &, struct stat &, const std::function<size_t ()> &closure);
|
|
};
|
|
|
|
struct socket::init
|
|
{
|
|
init();
|
|
~init() noexcept;
|
|
};
|
|
|
|
|
|
inline
|
|
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++;
|
|
}
|
|
|
|
inline
|
|
socket::io::operator size_t()
|
|
const
|
|
{
|
|
return bytes;
|
|
}
|
|
|
|
template<class iov>
|
|
auto
|
|
socket::write(const iov &bufs)
|
|
{
|
|
const auto ret(async_write(ssl, bufs, yield(continuation())));
|
|
return ret;
|
|
}
|
|
|
|
template<class iov>
|
|
auto
|
|
socket::write(const iov &bufs,
|
|
error_code &ec)
|
|
{
|
|
const auto ret(async_write(ssl, bufs, yield(continuation())[ec]));
|
|
return ret;
|
|
}
|
|
|
|
template<class iov>
|
|
auto
|
|
socket::write_some(const iov &bufs)
|
|
{
|
|
const auto ret(ssl.async_write_some(bufs, yield(continuation())));
|
|
return ret;
|
|
}
|
|
|
|
template<class iov>
|
|
auto
|
|
socket::write_some(const iov &bufs,
|
|
error_code &ec)
|
|
{
|
|
const auto ret(ssl.async_write_some(bufs, yield(continuation())[ec]));
|
|
return ret;
|
|
}
|
|
|
|
template<class iov>
|
|
auto
|
|
socket::read(const iov &bufs)
|
|
{
|
|
return io(*this, in, [&]
|
|
{
|
|
const auto ret(async_read(ssl, bufs, yield(continuation())));
|
|
|
|
if(unlikely(!ret))
|
|
throw boost::system::system_error(boost::asio::error::eof);
|
|
|
|
return ret;
|
|
});
|
|
}
|
|
|
|
template<class iov>
|
|
auto
|
|
socket::read(const iov &bufs,
|
|
error_code &ec)
|
|
{
|
|
return io(*this, in, [&]
|
|
{
|
|
return async_read(ssl, bufs, yield(continuation())[ec]);
|
|
});
|
|
}
|
|
|
|
template<class iov>
|
|
auto
|
|
socket::read_some(const iov &bufs)
|
|
{
|
|
return io(*this, in, [&]
|
|
{
|
|
const auto ret(ssl.async_read_some(bufs, yield(continuation())));
|
|
|
|
if(unlikely(!ret))
|
|
throw boost::system::system_error(boost::asio::error::eof);
|
|
|
|
return ret;
|
|
});
|
|
}
|
|
|
|
template<class iov>
|
|
auto
|
|
socket::read_some(const iov &bufs,
|
|
error_code &ec)
|
|
{
|
|
return io(*this, in, [&]
|
|
{
|
|
return ssl.async_read_some(bufs, yield(continuation())[ec]);
|
|
});
|
|
}
|
|
|
|
template<class duration>
|
|
void
|
|
socket::set_timeout(const duration &t)
|
|
{
|
|
if(t < duration(0))
|
|
return;
|
|
|
|
timer.expires_from_now(t);
|
|
timer.async_wait(std::bind(&socket::handle_timeout, this, shared_from_this(), ph::_1));
|
|
}
|
|
|
|
inline uint16_t
|
|
local_port(const socket &socket)
|
|
{
|
|
return socket.local().port();
|
|
}
|
|
|
|
inline std::string
|
|
local_ip(const socket &socket)
|
|
{
|
|
return local_address(socket).to_string();
|
|
}
|
|
|
|
inline ip::address
|
|
local_address(const socket &socket)
|
|
{
|
|
return socket.local().address();
|
|
}
|
|
|
|
inline uint16_t
|
|
remote_port(const socket &socket)
|
|
{
|
|
return socket.remote().port();
|
|
}
|
|
|
|
inline std::string
|
|
remote_ip(const socket &socket)
|
|
{
|
|
return remote_address(socket).to_string();
|
|
}
|
|
|
|
inline ip::address
|
|
remote_address(const socket &socket)
|
|
{
|
|
return socket.remote().address();
|
|
}
|
|
|
|
} // namespace ircd
|
|
|
|
inline
|
|
ircd::buffer::mutable_buffer::operator boost::asio::mutable_buffer()
|
|
const
|
|
{
|
|
return boost::asio::mutable_buffer
|
|
{
|
|
data(*this), size(*this)
|
|
};
|
|
}
|
|
|
|
inline
|
|
ircd::buffer::const_buffer::operator boost::asio::const_buffer()
|
|
const
|
|
{
|
|
return boost::asio::const_buffer
|
|
{
|
|
data(*this), size(*this)
|
|
};
|
|
}
|