void Client::Send(const void* data, size_t bytes, SndCb const& cb)
{
if (!impl_) {
if (cb)
cb(MakeNetworkErrorCode(eNetworkErrorCode::ec_shutdown));
return ;
}
impl_->GetSession()->Send(data, bytes, cb);
}
void Client::Send(Buffer && buf, SndCb const& cb)
{
if (!impl_) {
if (cb)
cb(MakeNetworkErrorCode(eNetworkErrorCode::ec_shutdown));
return ;
}
impl_->GetSession()->Send(std::move(buf), cb);
}
void _udp_sess_id_t::Send(const void * data, size_t bytes, const SndCb & cb)
{
if (!udp_point) {
if (cb)
cb(MakeNetworkErrorCode(eNetworkErrorCode::ec_shutdown));
return ;
}
boost_ec ec = udp_point->Send(remote_addr, data, bytes);
if (cb) cb(ec);
}
void _udp_sess_id_t::Send(Buffer && buf, const SndCb & cb)
{
if (!udp_point) {
if (cb)
cb(MakeNetworkErrorCode(eNetworkErrorCode::ec_shutdown));
return ;
}
boost_ec ec = udp_point->Send(remote_addr, buf.data(), buf.size());
if (cb) cb(ec);
}
boost_ec UdpPointImpl::Send(const void* data, size_t bytes)
{
boost_ec ec;
if (!init_) {
ec = goStart(local_addr_);
if (ec) return ec;
}
std::size_t n = socket_->send(buffer(data, bytes), 0, ec);
if (ec) return ec;
if (n < bytes) return MakeNetworkErrorCode(eNetworkErrorCode::ec_half);
return boost_ec();
}
void UdpPointImpl::Shutdown()
{
if (!init_) return ;
if (shutdown_) return ;
shutdown_ = true;
boost_ec ignore_ec;
socket_->shutdown(socket_base::shutdown_both, ignore_ec);
socket_->close(ignore_ec);
DebugPrint(dbg_session_alive, "udp::Shutdown");
recv_shutdown_channel_ >> nullptr;
if (opt_.disconnect_cb_)
opt_.disconnect_cb_(GetSession(), MakeNetworkErrorCode(eNetworkErrorCode::ec_shutdown));
}
boost_ec Client::Connect(std::string const& url)
{
std::unique_lock<co_mutex> lock(*connect_mtx_, std::defer_lock);
if (!lock.try_lock()) return MakeNetworkErrorCode(eNetworkErrorCode::ec_connecting);
if (impl_ && impl_->GetSession()->IsEstab()) return MakeNetworkErrorCode(eNetworkErrorCode::ec_estab);
boost_ec ec;
*local_addr_ = endpoint::from_string(url, ec);
if (ec) return ec;
if (local_addr_->proto() == proto_type::tcp || local_addr_->proto() == proto_type::ssl) {
protocol_ = tcp::instance();
} else if (local_addr_->proto() == proto_type::udp) {
protocol_ = udp::instance();
} else {
return MakeNetworkErrorCode(eNetworkErrorCode::ec_unsupport_protocol);
}
impl_ = protocol_->CreateClient();
this->Link(*impl_->GetOptions());
return impl_->Connect(*local_addr_);
}
endpoint Protocol::endpoint::from_string(std::string const& url, boost_ec & ec)
{
if (url.empty()) {
ec = MakeNetworkErrorCode(eNetworkErrorCode::ec_url_parse_error);
return endpoint();
}
static ::boost::regex re("((.*)://)?([^:/]+)(:(\\d+))?(/.*)?");
boost::smatch result;
bool ok = boost::regex_match(url, result, re);
if (!ok) {
ec = MakeNetworkErrorCode(eNetworkErrorCode::ec_url_parse_error);
return endpoint();
}
endpoint ep(::boost::asio::ip::address::from_string(result[3].str(), ec), atoi(result[5].str().c_str()));
if (ec) return endpoint();
ep.proto_ = str2proto(result[2].str());
ep.path_ = result[6].str();
return ep;
}
boost_ec UdpPointImpl::goStart(endpoint local_endpoint)
{
if (init_) return MakeNetworkErrorCode(eNetworkErrorCode::ec_estab);
try {
socket_.reset(new udp::socket(GetUdpIoService(), udp::endpoint(local_endpoint)));
} catch (boost::system::system_error& e) {
return e.code();
}
boost_ec ignore_ec;
local_addr_ = endpoint(socket_->local_endpoint(ignore_ec), local_endpoint.ext());
init_ = true;
auto this_ptr = this->shared_from_this();
go_dispatch(egod_robin) [this_ptr] {
this_ptr->DoRecv();
};
return boost_ec();
}
boost_ec Server::goStart(std::string const& url)
{
boost_ec ec;
*local_addr_ = endpoint::from_string(url, ec);
if (ec) return ec;
if (local_addr_->proto() == proto_type::tcp || local_addr_->proto() == proto_type::ssl) {
protocol_ = tcp::instance();
} else if (local_addr_->proto() == proto_type::udp) {
protocol_ = udp::instance();
} else {
return MakeNetworkErrorCode(eNetworkErrorCode::ec_unsupport_protocol);
}
impl_ = protocol_->CreateServer();
this->Link(*impl_->GetOptions());
ec = impl_->goStart(*local_addr_);
*local_addr_ = impl_->LocalAddr();
return ec;
}
void FakeSession::SendNoDelay(const void *, size_t, const SndCb & cb)
{
if (cb) cb(MakeNetworkErrorCode(eNetworkErrorCode::ec_shutdown));
}
void FakeSession::SendNoDelay(Buffer &&, const SndCb & cb)
{
if (cb) cb(MakeNetworkErrorCode(eNetworkErrorCode::ec_shutdown));
}
