void OnReceived(_UInt32 nbytes, StreamBuffer::Node* node, const error_code& error)
{
m_PendingRecvRequestCount--;
node->m_Len = nbytes;
m_Wrapper->m_IStream.PushNode(node);
if (error.value() != 0)
{
if (m_PendingRecvRequestCount == 0 && m_RequestSendRequestCount == 0)
{
if (!(error.value() == 104 || error.value() == 54))
{
m_Wrapper->Close();
}
if (!m_Wrapper->m_OnConnectBroken.Empty())
{
m_Wrapper->m_OnConnectBroken(m_Wrapper, m_Wrapper->m_IStream, m_Wrapper->m_OStream);
}
}
}
else
{
AsyncReceive();
m_Wrapper->m_OnReceived(m_Wrapper, m_Wrapper->m_IStream, m_Wrapper->m_OStream);
}
}
void OnSent(StreamBuffer::Node* node, const error_code& error)
{
m_RequestSendRequestCount--;
if (error.value() != 0)
{
m_Wrapper->m_OStream.DeallocNode(node);
if (m_PendingRecvRequestCount == 0 && m_RequestSendRequestCount == 0)
{
if (!(error.value() == 104 || error.value() == 54))
{
m_Wrapper->Close();
}
if (!m_Wrapper->m_OnConnectBroken.Empty())
{
m_Wrapper->m_OnConnectBroken(m_Wrapper, m_Wrapper->m_IStream, m_Wrapper->m_OStream);
}
}
}
else
{
if (!m_Wrapper->m_OnSent.Empty())
{
m_Wrapper->m_OnSent(m_Wrapper, (const void *)((char *)node + sizeof(StreamBuffer::Node)), node->m_Len);
}
m_Wrapper->m_OStream.DeallocNode(node);
AsyncSend();
}
}
void WSThread_tls::runTimer(const error_code & ec, websocketpp::connection_hdl hdl, int timerInd)
{
// Все данные в m_connections[hdl]
if (hdl.expired())
return;
if (m_connections[hdl].timing == nullptr)
return;
if (!m_connections[hdl].timing->isTimerOn)
return;
if (ec.value() !=0 ) {
ERROR_STREAM_F << " Error code: " << ec.value() << " Mess: " << ec.message();
}
try {
if (forRunTimer(hdl, timerInd))
return;
m_connections[hdl].timing->m_timer = m_server.set_timer(m_connections[hdl].timing->msec, bind(&WSThread_tls::runTimer
, this, placeholders::_1, hdl, timerInd));
}
catch (...) {
// This exception is not thrown out in normal operation
ERROR_STREAM_F << "RUN EXCEPTION!!!!!!!";
}
}
bool connection::check_error(const error_code& err)
{
if (!err)
{
return true;
}
switch (err.value())
{
case asio::error::operation_aborted:
break;
case custom_error::no_such_file_or_directory:
closed(shared_from_this());
break;
case custom_error::ssl_short_read:
closed(shared_from_this());
break;
default:
error(shared_from_this(), err.value(), err.message());
break;
}
return false;
}
void client::connected_handler(client_session *session, std::shared_ptr<connection> conn, const error_code& err)
{
if (err)
{
switch (err.value())
{
case asio::error::connection_refused:
refused();
break;
default:
error(err.value(), err.message());
break;
}
return;
}
_connection = conn;
_session = std::shared_ptr<client_session>(session);
auto closed_slot = [this](std::shared_ptr<connection> conn)
{
(void)conn;
disconnected();
};
auto error_slot = [this](std::shared_ptr<connection> conn, int code, const std::string& message)
{
(void)conn;
error(code, message);
};
auto received_slot = [this](std::shared_ptr<connection> conn, std::unique_ptr<istream> stream)
{
(void)conn;
received(std::move(stream));
};
_connection->closed.connect(closed_slot);
_connection->error.connect(error_slot);
_connection->received.connect(received_slot);
connected();
}
lsd::lsd(io_service& ios, address const& listen_interface
, peer_callback_t const& cb)
: m_callback(cb)
, m_socket(udp::endpoint(address_v4::from_string("239.192.152.143", ec), 6771)
, boost::bind(&lsd::on_announce, self(), _1, _2, _3))
, m_broadcast_timer(ios)
, m_retry_count(1)
, m_cookie(random())
, m_disabled(false)
{
#if defined(TORRENT_LOGGING) || defined(TORRENT_VERBOSE_LOGGING)
m_log = fopen("lsd.log", "w+");
if (m_log == NULL)
{
fprintf(stderr, "failed to open 'lsd.log': (%d) %s"
, errno, strerror(errno));
}
#endif
error_code ec;
m_socket.open(ios, ec);
#if defined(TORRENT_LOGGING) || defined(TORRENT_VERBOSE_LOGGING)
if (ec)
{
if (m_log) fprintf(m_log, "FAILED TO OPEN SOCKET: (%d) %s\n"
, ec.value(), ec.message().c_str());
}
#endif
}
bool
equivalent (error_code const& code, int condition
) const noexcept override
{
return *this == code.category() &&
code.value() == condition;
}
void socks_connection::on_handshake1(error_code const& ec, size_t bytes_transferred)
{
if (ec || bytes_transferred != 2)
{
printf("socks_connection::on_handshake1: (%d) %s\n"
, ec.value(), ec.message().c_str());
close_connection();
return;
}
if (m_out_buffer[0] != 4 && m_out_buffer[0] != 5)
{
printf("socks_connection::on_handshake1: unexpected socks protocol version: %d"
, int(m_out_buffer[0]));
close_connection();
return;
}
int num_methods = unsigned(m_out_buffer[1]);
// read list of auth-methods
asio::async_read(m_client_connection, asio::mutable_buffers_1(&m_out_buffer[0],
num_methods)
, std::bind(&socks_connection::on_handshake2, shared_from_this()
, _1, _2));
}
void socks_connection::on_request_domain_name(error_code const& ec, size_t bytes_transferred)
{
if (ec)
{
printf("socks_connection::on_request_domain_name(%s): (%d) %s\n"
, command(), ec.value(), ec.message().c_str());
close_connection();
return;
}
const int buffer_size = 10 + bytes_transferred;
boost::uint16_t port = m_out_buffer[buffer_size - 2] & 0xff;
port <<= 8;
port |= m_out_buffer[buffer_size - 1] & 0xff;
std::string hostname(&m_out_buffer[5], boost::uint8_t(m_out_buffer[4]));
printf("socks_connection::on_request_domain_name(%s): hostname: %s port: %d\n"
, command(), hostname.c_str(), port);
char port_str[10];
snprintf(port_str, sizeof(port_str), "%d", port);
asio::ip::tcp::resolver::query q(hostname, port_str);
m_resolver.async_resolve(q
, std::bind(&socks_connection::on_request_domain_lookup
, shared_from_this(), _1, _2));
}
void
Endpoint::raw_recv_callback(const error_code& e, size_t b)
{
recv_guard.unlock();
if (!e && b > 0) {
size_t n = inbound.producer().commit_buffer(b),
u = protocol->buffer2message(inbound.consumer().data(), n);
n = inbound.consumer().consume_buffer(u);
protocol->handle_messages(dispatcher);
/*
* Re-register any further reads and update running statistics
*/
protocol->receive_data();
recv_rate.update(b);
} else {
if (e == boost::asio::error::operation_aborted)
return;
stop();
if (e != boost::asio::error::eof)
throw ReadError("Endpoint::raw_recv_callback",
e.value(),
e.message().c_str());
}
}
void
Endpoint::raw_send_callback(const error_code& e, size_t b)
{
send_guard.unlock();
if (!e && b > 0) {
size_t n = 0;
n = outbound.consumer().consume_buffer(b);
protocol->bytes_transferred(b);
/*
* Re-register any further writes and update running statistics
*/
protocol->transfer_data(n);
send_rate.update(b);
} else {
if (e == boost::asio::error::operation_aborted)
return;
stop();
if (e != boost::asio::error::eof)
throw WriteError("Endpoint::raw_send_callback",
e.value(),
e.message().c_str());
}
}
void on_error(error_code const& code)
{
if (code)
{
if // usually, by on_receive
((code.category() == error::misc_category && code.value () == error::eof) ||
// and these - by on_send
(code.category() == error::system_category && code.value () == error::connection_reset) ||
(code.category() == error::system_category && code.value () == error::broken_pipe ))
{
on_discon_(code);
}
else
on_error_(code);
}
}
void Session::_AsyncError(const string& message, const error_code& ec)
{
//komunikat o bledzie operacji asynchronicznej
string s = message
+ to_string(ec.value()) + ". "
+ ec.message() + ". ";
//wyswietlenie i zamkniecie sesji
_WasError(s);
}
void NetClient::OnConnectionFailed(NetConnection* sender, const error_code& error)
{
LSL_LOG("NetClient conection failed " + error.message());
if (!_net->OnConnectionFailed(sender, error.value()))
return;
Disconnect();
}
QString StaticHelpers::translateError(error_code const& ec, char* msgs[], int msgs_len)
{
int code = ec.value();
if (code < 0 || code >= msgs_len)
{
return QString::fromStdString(ec.message());
}
return qApp->translate("ErrorMsg", msgs[code]);
}
void http_server::on_read(error_code const& ec, size_t bytes_transferred) try
{
if (ec)
{
std::printf("http_server::on_read: (%d) %s\n"
, ec.value(), ec.message().c_str());
close_connection();
return;
}
m_bytes_used += int(bytes_transferred);
int const req_len = find_request_len(m_recv_buffer.data(), m_bytes_used);
if (req_len < 0)
{
read();
return;
}
http_request req = parse_request(m_recv_buffer.data(), req_len);
m_recv_buffer.erase(m_recv_buffer.begin(), m_recv_buffer.begin() + req_len);
m_bytes_used -= req_len;
auto it = m_handlers.find(req.path);
if (it == m_handlers.end())
{
if (m_stall_handlers.find(req.path) != m_stall_handlers.end())
{
return;
}
// no handler found, 404
m_send_buffer = send_response(404, "Not Found");
}
else
{
m_send_buffer = it->second(req.method, req.req, req.headers);
}
bool close = lower_case(req.headers["connection"]) == "close";
async_write(m_connection, asio::const_buffers_1(m_send_buffer.data()
, m_send_buffer.size()), std::bind(&http_server::on_write
, this, _1, _2, close));
}
catch (std::exception& e)
{
std::printf("http_server::on_read() failed: %s\n"
, e.what());
close_connection();
}
void socks_connection::on_handshake3(error_code const& ec, size_t bytes_transferred)
{
if (ec || bytes_transferred != 2)
{
printf("socks_connection::on_handshake3: (%d) %s\n"
, ec.value(), ec.message().c_str());
close_connection();
return;
}
asio::async_read(m_client_connection, asio::mutable_buffers_1(&m_out_buffer[0], 10)
, std::bind(&socks_connection::on_request1, shared_from_this()
, _1, _2));
}
__dir_stream(const path& root, directory_options opts, error_code& ec)
: __stream_(nullptr),
__root_(root)
{
if ((__stream_ = ::opendir(root.c_str())) == nullptr) {
ec = detail::capture_errno();
const bool allow_eacess =
bool(opts & directory_options::skip_permission_denied);
if (allow_eacess && ec.value() == EACCES)
ec.clear();
return;
}
advance(ec);
}
void UDPSocket::OnReceive( const error_code& error, std::size_t bytes, UDPReceiveSessionPtr session )
{
if (!error || error == boost::asio::error::message_size)
{
assert( bytes > 0 );
// ³É¹¦
InetSocketAddress addr = from_endpoint( session->remote_endpoint );
this->GetListener()->OnSocketReceive(this, addr, session->buffer.data(), bytes );
}
else
{
// ʧ°Ü
this->GetListener()->OnSocketReceiveFailed( this, error.value() );
}
}
int error_decoder(error_code const& ec )
{
const native_to_socket_err_t* cur = native_to_socket_err;
do
{
if ( ec.value() == cur->native )
{
return cur->socket_err;
}
++cur;
} while ( cur != native_to_socket_err + sizeof( native_to_socket_err ) / sizeof( native_to_socket_err_t ) );
return -1;
}
void http_proxy::on_server_forward(error_code const& ec
, size_t /* bytes_transferred */)
{
if (ec)
{
std::printf("http_proxy: error writing to client: (%d) %s\n"
, ec.value(), ec.message().c_str());
close_connection();
return;
}
m_server_connection.async_read_some(
sim::asio::mutable_buffers_1(m_in_buffer, sizeof(m_in_buffer))
, std::bind(&http_proxy::on_server_receive, this, _1, _2));
}
void http_server::on_accept(error_code const& ec)
{
if (ec)
{
std::printf("http_server::on_accept: (%d) %s\n"
, ec.value(), ec.message().c_str());
close_connection();
return;
}
std::printf("http_server accepted connection from: %s : %d\n",
m_ep.address().to_string().c_str(), m_ep.port());
read();
}
void TCPClientSocket::OnConnect( const error_code& error )
{
m_ConnectTimer.Stop();
//if ( this->IsClosed() )
//{
// return;
//}
if ( !error )
{
this->GetListener()->OnSocketConnect( this );
}
else
{
this->GetListener()->OnSocketConnectFailed( this, error.value() );
}
}
void lsd::announce(sha1_hash const& ih, int listen_port, bool broadcast)
{
if (m_disabled) return;
char ih_hex[41];
to_hex((char const*)&ih[0], 20, ih_hex);
char msg[200];
int msg_len = snprintf(msg, sizeof(msg),
"BT-SEARCH * HTTP/1.1\r\n"
"Host: 239.192.152.143:6771\r\n"
"Port: %d\r\n"
"Infohash: %s\r\n"
"cookie: %x\r\n"
"\r\n\r\n", listen_port, ih_hex, m_cookie);
#if defined(TORRENT_LOGGING) || defined(TORRENT_VERBOSE_LOGGING)
{
if (m_log) fprintf(m_log, "%s ==> announce: ih: %s port: %u\n"
, time_now_string(), ih_hex, listen_port);
}
#endif
m_retry_count = 1;
error_code ec;
m_socket.send(msg, msg_len, ec, broadcast ? broadcast_socket::broadcast : 0);
if (ec)
{
m_disabled = true;
#if defined(TORRENT_LOGGING) || defined(TORRENT_VERBOSE_LOGGING)
{
if (m_log) fprintf(m_log, "%s failed to send message: (%d) %s"
, time_now_string(), ec.value(), ec.message().c_str());
}
#endif
return;
}
#if defined TORRENT_ASIO_DEBUGGING
add_outstanding_async("lsd::resend_announce");
#endif
m_broadcast_timer.expires_from_now(seconds(2 * m_retry_count), ec);
m_broadcast_timer.async_wait(boost::bind(&lsd::resend_announce, self(), _1
, std::string(msg)));
}
void http_proxy::on_server_write(error_code const& ec, size_t bytes_transferred)
{
m_writing_to_server = false;
if (ec)
{
std::printf("http_proxy::on_server_write: (%d) %s\n"
, ec.value(), ec.message().c_str());
close_connection();
return;
}
memmove(&m_server_out_buffer[0], m_server_out_buffer + bytes_transferred
, m_num_server_out_bytes - bytes_transferred);
m_num_server_out_bytes -= int(bytes_transferred);
if (m_num_server_out_bytes > 0)
write_server_send_buffer();
}
QString StaticHelpers::translateUpnpError(error_code const& ec)
{
int ev = ec.value();
int num_errors = sizeof(error_codes) / sizeof(error_codes[0]);
error_code_t* end = error_codes + num_errors;
error_code_t tmp = { ev, 0 };
error_code_t* e = std::lower_bound(error_codes, end, tmp
, boost::bind(&error_code_t::code, _1) < boost::bind(&error_code_t::code, _2));
if (e != end && e->code == ev)
{
return e->msg;
}
char msg[500];
snprintf(msg, sizeof(msg), "unknown UPnP error (%d)", ev);
return msg;
}
void http_proxy::on_read_request(error_code const& ec, size_t bytes_transferred) try
{
if (ec)
{
std::printf("http_proxy::on_read_request: (%d) %s\n"
, ec.value(), ec.message().c_str());
close_connection();
return;
}
m_num_client_in_bytes += int(bytes_transferred);
// scan for end of HTTP request
int req_len = find_request_len(m_client_in_buffer, m_num_client_in_bytes);
while (req_len >= 0)
{
// parse request from [0, eor), connect to target server and forward
// the request.
http_request const req = parse_request(m_client_in_buffer, req_len);
forward_request(req);
// pop this request from the receive buffer
memmove(m_client_in_buffer + req_len, m_client_in_buffer
, m_num_client_in_bytes - req_len);
m_num_client_in_bytes -= req_len;
// is there another request in the buffer?
req_len = find_request_len(m_client_in_buffer, m_num_client_in_bytes);
}
// read more from the client
m_client_connection.async_read_some(asio::mutable_buffers_1(
&m_client_in_buffer[m_num_client_in_bytes]
, sizeof(m_client_in_buffer) - m_num_client_in_bytes)
, std::bind(&http_proxy::on_read_request, this, _1, _2));
}
catch (std::runtime_error& e)
{
std::printf("http_proxy::on_read_request() failed: %s\n"
, e.what());
close_connection();
}
void OnConnected(const std::string& remote, _UInt16 port, const error_code& error)
{
if (error.value() == 0)
{
m_Wrapper->m_IStream.Clear(); // Hack by hailong for re-connection
m_Wrapper->m_OStream.Clear();
CloseLinger();
AsyncReceive();
m_Wrapper->m_OnConnected(m_Wrapper, m_Wrapper->m_IStream, m_Wrapper->m_OStream);
}
else
{
m_Wrapper->m_Errno = IGAME_ERROR_CONNECT;
m_Socket.close();
if (!m_Wrapper->m_OnConnectFailed.Empty())
{
m_Wrapper->m_OnConnectFailed(m_Wrapper, m_Wrapper->m_IStream, m_Wrapper->m_OStream);
}
}
}
void http_proxy::on_accept(error_code const& ec)
{
if (ec == asio::error::operation_aborted)
return;
if (ec)
{
std::printf("http_proxy::on_accept: (%d) %s\n"
, ec.value(), ec.message().c_str());
close_connection();
return;
}
std::printf("http_proxy accepted connection from: %s : %d\n",
m_ep.address().to_string().c_str(), m_ep.port());
// read http request
m_client_connection.async_read_some(asio::mutable_buffers_1(
&m_client_in_buffer[0], sizeof(m_client_in_buffer))
, std::bind(&http_proxy::on_read_request, this, _1, _2));
}
void http_server::on_write(error_code const& ec
, size_t /* bytes_transferred */
, bool close)
{
if (ec)
{
std::printf("http_server::on_write: (%d) %s\n"
, ec.value(), ec.message().c_str());
close_connection();
return;
}
if (!close && (m_flags & keep_alive))
{
// try to read another request out of the buffer
m_ios.post(std::bind(&http_server::on_read, this, error_code(), 0));
}
else
{
close_connection();
}
}
