int SrsRtmp::handshake()
{
int ret = ERROR_SUCCESS;
SrsSocket skt(stfd);
SrsComplexHandshake complex_hs;
SrsSimpleHandshake simple_hs;
if ((ret = simple_hs.handshake_with_client(skt, complex_hs)) != ERROR_SUCCESS) {
return ret;
}
return ret;
}
static void echo_client(stackful_actor self)
{
log::logger_t& lg = self.get_context().get_logger();
try
{
size_t ecount = 10;
errcode_t ec;
boost::shared_ptr<tcp_resolver_t::iterator> eitr;
boost::shared_ptr<boost::asio::ssl::context> ssl_ctx;
self->match("init").recv(eitr, ssl_ctx);
ssl::stream<> skt(self, *ssl_ctx);
skt->set_verify_mode(boost::asio::ssl::verify_peer);
skt->set_verify_callback(boost::bind(&ssl_ut::verify_certificate, _arg1, _arg2, lg));
skt.async_connect(*eitr);
self->match(tcp::as_conn).recv(ec);
GCE_VERIFY(!ec).except(ec);
skt.async_handshake(boost::asio::ssl::stream_base::client);
self->match(ssl::as_handshake).recv(ec);
GCE_VERIFY(!ec).except(ec);
echo_header hdr;
size_t hdr_len = amsg::size_of(hdr);
amsg::zero_copy_buffer zbuf;
char buff[256];
std::string str("hello world!");
hdr.size_ = amsg::size_of(str);
zbuf.set_write(buff, 256);
amsg::write(zbuf, hdr);
amsg::write(zbuf, str);
for (size_t i=0; i<ecount; ++i)
{
skt.async_write(boost::asio::buffer(buff, hdr_len + hdr.size_));
self->match(tcp::as_send).recv(ec);
GCE_VERIFY(!ec).except(ec);
skt.async_read(hdr_len + hdr.size_);
message::chunk ch(hdr_len + hdr.size_);
self->match(tcp::as_recv).recv(ec, ch);
zbuf.set_read(ch.data(), hdr_len + hdr.size_);
std::string echo_str;
amsg::read(zbuf, hdr);
amsg::read(zbuf, echo_str);
GCE_VERIFY(!zbuf.bad()).except<std::runtime_error>();
GCE_VERIFY(str == echo_str);
}
str.assign("bye");
hdr.size_ = amsg::size_of(str);
zbuf.set_write(buff, 256);
amsg::write(zbuf, hdr);
amsg::write(zbuf, str);
skt.async_write(boost::asio::buffer(buff, hdr_len + hdr.size_));
self->match(tcp::as_send).recv(ec);
GCE_VERIFY(!ec).except(ec);
skt.async_shutdown();
self->match(ssl::as_shutdown).recv();
}
catch (std::exception& ex)
{
GCE_ERROR(lg) << ex.what();
}
}
static void echo_session(stackful_actor self)
{
log::logger_t& lg = self.get_context().get_logger();
try
{
boost::shared_ptr<ssl_socket_t> ssl_skt;
self->match("init").recv(ssl_skt);
ssl::stream<> skt(self, ssl_skt);
errcode_t ec;
skt.async_handshake(boost::asio::ssl::stream_base::server);
self->match(ssl::as_handshake).recv(ec);
GCE_VERIFY(!ec).except(ec);
amsg::zero_copy_buffer zbuf;
byte_t read_buff[256];
std::deque<bytes_t> write_queue;
echo_header hdr;
size_t const hdr_len = amsg::size_of(hdr);
match_t const recv_header = atom("header");
match_t const recv_body = atom("body");
skt.async_read(boost::asio::buffer(read_buff, hdr_len), message(recv_header));
while (true)
{
match_t type;
errcode_t ec;
self->match(recv_header, recv_body, tcp::as_send, type).recv(ec);
GCE_VERIFY(!ec).except(ec);
if (type == recv_header)
{
zbuf.set_read(read_buff, hdr_len);
amsg::read(zbuf, hdr);
GCE_VERIFY(!zbuf.bad()).except<std::runtime_error>();
skt.async_read(boost::asio::buffer(read_buff + hdr_len, hdr.size_), message(recv_body));
}
else if (type == recv_body)
{
zbuf.set_read(read_buff + hdr_len, hdr.size_);
std::string str;
amsg::read(zbuf, str);
GCE_VERIFY(!zbuf.bad()).except<std::runtime_error>();
//GCE_INFO(lg) << "server recved echo: " << str;
if (str == "bye")
{
break;
}
bool write_in_progress = !write_queue.empty();
write_queue.push_back(bytes_t(read_buff, hdr_len + hdr.size_));
if (!write_in_progress)
{
bytes_t const& echo = write_queue.front();
skt.async_write(boost::asio::buffer(echo.data(), echo.size()));
}
skt.async_read(boost::asio::buffer(read_buff, hdr_len), message(recv_header));
}
else
{
write_queue.pop_front();
if (!write_queue.empty())
{
bytes_t const& echo = write_queue.front();
skt.async_write(boost::asio::buffer(echo.data(), echo.size()));
}
}
}
skt.async_shutdown();
self->match(ssl::as_shutdown).recv();
}
catch (std::exception& ex)
{
GCE_ERROR(lg) << ex.what();
}
}
///----------------------------------------------------------------------------
gce::detail::socket_ptr acceptor::accept(yield_t yield)
{
gce::tcp::socket_ptr skt(new socket(snd_.get_io_service()));
acpr_.async_accept(skt->get_socket(), yield);
return skt;
}
