i2pd/BOB.cpp

656 lines
18 KiB
C++
Raw Normal View History

2014-12-02 20:47:44 +00:00
#include <string.h>
2014-12-03 02:45:01 +00:00
#include <boost/lexical_cast.hpp>
2014-12-02 16:42:35 +00:00
#include "Log.h"
2014-12-03 02:45:01 +00:00
#include "ClientContext.h"
2014-12-02 15:34:02 +00:00
#include "BOB.h"
namespace i2p
{
namespace client
{
BOBI2PInboundTunnel::BOBI2PInboundTunnel (int port, ClientDestination * localDestination):
BOBI2PTunnel (localDestination),
m_Acceptor (localDestination->GetService (), boost::asio::ip::tcp::endpoint (boost::asio::ip::tcp::v4(), port)), m_Timer (localDestination->GetService ())
2014-12-03 19:48:41 +00:00
{
}
BOBI2PInboundTunnel::~BOBI2PInboundTunnel ()
{
2014-12-05 00:29:20 +00:00
Stop ();
2014-12-03 19:48:41 +00:00
}
void BOBI2PInboundTunnel::Start ()
{
m_Acceptor.listen ();
Accept ();
}
void BOBI2PInboundTunnel::Stop ()
{
m_Acceptor.close();
ClearHandlers ();
2014-12-03 19:48:41 +00:00
}
void BOBI2PInboundTunnel::Accept ()
{
2014-12-07 14:48:03 +00:00
auto receiver = new AddressReceiver ();
receiver->socket = new boost::asio::ip::tcp::socket (GetService ());
m_Acceptor.async_accept (*receiver->socket, std::bind (&BOBI2PInboundTunnel::HandleAccept, this,
std::placeholders::_1, receiver));
2014-12-03 19:48:41 +00:00
}
2014-12-07 14:48:03 +00:00
void BOBI2PInboundTunnel::HandleAccept (const boost::system::error_code& ecode, AddressReceiver * receiver)
2014-12-03 19:48:41 +00:00
{
if (!ecode)
{
Accept ();
2014-12-07 14:48:03 +00:00
ReceiveAddress (receiver);
2014-12-03 19:48:41 +00:00
}
else
2014-12-07 14:48:03 +00:00
{
delete receiver->socket;
delete receiver;
}
2014-12-03 19:48:41 +00:00
}
2014-12-07 14:48:03 +00:00
void BOBI2PInboundTunnel::ReceiveAddress (AddressReceiver * receiver)
2014-12-03 19:48:41 +00:00
{
2014-12-07 14:48:03 +00:00
receiver->socket->async_read_some (boost::asio::buffer(
receiver->buffer + receiver->bufferOffset,
BOB_COMMAND_BUFFER_SIZE - receiver->bufferOffset),
2014-12-03 19:48:41 +00:00
std::bind(&BOBI2PInboundTunnel::HandleReceivedAddress, this,
2014-12-07 14:48:03 +00:00
std::placeholders::_1, std::placeholders::_2, receiver));
2014-12-03 19:48:41 +00:00
}
void BOBI2PInboundTunnel::HandleReceivedAddress (const boost::system::error_code& ecode, std::size_t bytes_transferred,
2014-12-07 14:48:03 +00:00
AddressReceiver * receiver)
2014-12-03 19:48:41 +00:00
{
if (ecode)
{
LogPrint ("BOB inbound tunnel read error: ", ecode.message ());
2014-12-07 14:48:03 +00:00
delete receiver->socket;
delete receiver;
2014-12-03 19:48:41 +00:00
}
else
{
2014-12-07 14:48:03 +00:00
receiver->bufferOffset += bytes_transferred;
receiver->buffer[receiver->bufferOffset] = 0;
char * eol = strchr (receiver->buffer, '\n');
2014-12-03 19:48:41 +00:00
if (eol)
{
*eol = 0;
2014-12-07 14:48:03 +00:00
receiver->data = (uint8_t *)eol + 1;
receiver->dataLen = receiver->bufferOffset - (eol - receiver->buffer + 1);
2014-12-03 19:48:41 +00:00
i2p::data::IdentHash ident;
2014-12-07 14:48:03 +00:00
if (!context.GetAddressBook ().GetIdentHash (receiver->buffer, ident))
{
2014-12-07 14:48:03 +00:00
LogPrint (eLogError, "BOB address ", receiver->buffer, " not found");
delete receiver->socket;
delete receiver;
return;
}
2014-12-03 19:48:41 +00:00
auto leaseSet = GetLocalDestination ()->FindLeaseSet (ident);
if (leaseSet)
2014-12-07 14:48:03 +00:00
CreateConnection (receiver, leaseSet);
2014-12-03 19:48:41 +00:00
else
{
GetLocalDestination ()->RequestDestination (ident);
2014-12-03 19:48:41 +00:00
m_Timer.expires_from_now (boost::posix_time::seconds (I2P_TUNNEL_DESTINATION_REQUEST_TIMEOUT));
m_Timer.async_wait (std::bind (&BOBI2PInboundTunnel::HandleDestinationRequestTimer,
2014-12-07 14:48:03 +00:00
this, std::placeholders::_1, receiver, ident));
2014-12-03 19:48:41 +00:00
}
}
else
{
2014-12-07 14:48:03 +00:00
if (receiver->bufferOffset < BOB_COMMAND_BUFFER_SIZE)
ReceiveAddress (receiver);
2014-12-06 20:31:39 +00:00
else
{
2014-12-07 14:48:03 +00:00
LogPrint ("BOB missing inbound address ");
delete receiver->socket;
delete receiver;
2014-12-06 20:31:39 +00:00
}
2014-12-03 19:48:41 +00:00
}
}
}
2014-12-07 14:48:03 +00:00
void BOBI2PInboundTunnel::HandleDestinationRequestTimer (const boost::system::error_code& ecode, AddressReceiver * receiver, i2p::data::IdentHash ident)
2014-12-03 19:48:41 +00:00
{
if (ecode != boost::asio::error::operation_aborted)
{
auto leaseSet = GetLocalDestination ()->FindLeaseSet (ident);
if (leaseSet)
{
2014-12-07 14:48:03 +00:00
CreateConnection (receiver, leaseSet);
2014-12-03 19:48:41 +00:00
return;
}
else
LogPrint ("LeaseSet for BOB inbound destination not found");
}
2014-12-07 14:48:03 +00:00
delete receiver->socket;
delete receiver;
2014-12-03 19:48:41 +00:00
}
2014-12-07 14:48:03 +00:00
void BOBI2PInboundTunnel::CreateConnection (AddressReceiver * receiver, const i2p::data::LeaseSet * leaseSet)
2014-12-03 19:48:41 +00:00
{
LogPrint ("New BOB inbound connection");
2014-12-07 14:48:03 +00:00
auto connection = std::make_shared<I2PTunnelConnection>(this, receiver->socket, leaseSet);
AddHandler (connection);
2014-12-07 14:48:03 +00:00
connection->I2PConnect (receiver->data, receiver->dataLen);
delete receiver;
2014-12-03 19:48:41 +00:00
}
BOBI2POutboundTunnel::BOBI2POutboundTunnel (const std::string& address, int port,
ClientDestination * localDestination, bool quiet): BOBI2PTunnel (localDestination),
2014-12-05 19:13:16 +00:00
m_Endpoint (boost::asio::ip::address::from_string (address), port), m_IsQuiet (quiet)
{
}
void BOBI2POutboundTunnel::Start ()
{
Accept ();
}
void BOBI2POutboundTunnel::Stop ()
{
ClearHandlers ();
2014-12-05 19:13:16 +00:00
}
void BOBI2POutboundTunnel::Accept ()
{
auto localDestination = GetLocalDestination ();
if (localDestination)
localDestination->AcceptStreams (std::bind (&BOBI2POutboundTunnel::HandleAccept, this, std::placeholders::_1));
else
LogPrint ("Local destination not set for server tunnel");
}
void BOBI2POutboundTunnel::HandleAccept (std::shared_ptr<i2p::stream::Stream> stream)
{
if (stream)
{
auto conn = std::make_shared<I2PTunnelConnection> (this, stream, new boost::asio::ip::tcp::socket (GetService ()), m_Endpoint, m_IsQuiet);
AddHandler (conn);
2014-12-05 19:13:16 +00:00
conn->Connect ();
}
}
BOBDestination::BOBDestination (ClientDestination& localDestination):
m_LocalDestination (localDestination),
m_OutboundTunnel (nullptr), m_InboundTunnel (nullptr)
{
}
BOBDestination::~BOBDestination ()
{
delete m_OutboundTunnel;
delete m_InboundTunnel;
2015-01-01 14:54:15 +00:00
i2p::client::context.DeleteLocalDestination (&m_LocalDestination);
}
void BOBDestination::Start ()
{
if (m_OutboundTunnel) m_OutboundTunnel->Start ();
if (m_InboundTunnel) m_InboundTunnel->Start ();
}
void BOBDestination::Stop ()
{
2014-12-08 02:04:02 +00:00
StopTunnels ();
m_LocalDestination.Stop ();
}
2014-12-05 19:13:16 +00:00
2014-12-08 02:04:02 +00:00
void BOBDestination::StopTunnels ()
{
if (m_OutboundTunnel)
{
m_OutboundTunnel->Stop ();
delete m_OutboundTunnel;
m_OutboundTunnel = nullptr;
}
if (m_InboundTunnel)
{
m_InboundTunnel->Stop ();
delete m_InboundTunnel;
m_InboundTunnel = nullptr;
}
}
void BOBDestination::CreateInboundTunnel (int port)
{
2014-12-08 02:04:02 +00:00
if (!m_InboundTunnel)
m_InboundTunnel = new BOBI2PInboundTunnel (port, &m_LocalDestination);
}
void BOBDestination::CreateOutboundTunnel (const std::string& address, int port, bool quiet)
{
2014-12-08 02:04:02 +00:00
if (!m_OutboundTunnel)
m_OutboundTunnel = new BOBI2POutboundTunnel (address, port, &m_LocalDestination, quiet);
}
2014-12-02 20:47:44 +00:00
BOBCommandSession::BOBCommandSession (BOBCommandChannel& owner):
m_Owner (owner), m_Socket (m_Owner.GetService ()), m_ReceiveBufferOffset (0),
2014-12-08 02:04:02 +00:00
m_IsOpen (true), m_IsQuiet (false), m_InPort (0), m_OutPort (0),
m_CurrentDestination (nullptr)
2014-12-02 16:42:35 +00:00
{
}
2014-12-02 20:47:44 +00:00
BOBCommandSession::~BOBCommandSession ()
{
}
2014-12-02 21:45:51 +00:00
void BOBCommandSession::Terminate ()
{
m_Socket.close ();
m_IsOpen = false;
}
2014-12-02 20:47:44 +00:00
void BOBCommandSession::Receive ()
{
m_Socket.async_read_some (boost::asio::buffer(m_ReceiveBuffer + m_ReceiveBufferOffset, BOB_COMMAND_BUFFER_SIZE - m_ReceiveBufferOffset),
std::bind(&BOBCommandSession::HandleReceived, shared_from_this (),
std::placeholders::_1, std::placeholders::_2));
}
void BOBCommandSession::HandleReceived (const boost::system::error_code& ecode, std::size_t bytes_transferred)
{
if (ecode)
2014-12-02 21:45:51 +00:00
{
2014-12-02 20:47:44 +00:00
LogPrint ("BOB command channel read error: ", ecode.message ());
2014-12-05 00:29:20 +00:00
if (ecode != boost::asio::error::operation_aborted)
Terminate ();
2014-12-02 21:45:51 +00:00
}
2014-12-02 20:47:44 +00:00
else
{
size_t size = m_ReceiveBufferOffset + bytes_transferred;
m_ReceiveBuffer[size] = 0;
char * eol = strchr (m_ReceiveBuffer, '\n');
if (eol)
{
*eol = 0;
char * operand = strchr (m_ReceiveBuffer, ' ');
2014-12-03 02:45:01 +00:00
if (operand)
{
*operand = 0;
operand++;
}
else
operand = eol;
2014-12-02 20:47:44 +00:00
// process command
2014-12-03 02:45:01 +00:00
auto& handlers = m_Owner.GetCommandHandlers ();
2014-12-02 20:47:44 +00:00
auto it = handlers.find (m_ReceiveBuffer);
if (it != handlers.end ())
2014-12-03 02:45:01 +00:00
(this->*(it->second))(operand, eol - operand);
else
2014-12-05 15:59:37 +00:00
{
2014-12-03 02:45:01 +00:00
LogPrint (eLogError, "BOB unknown command ", m_ReceiveBuffer);
2014-12-05 15:59:37 +00:00
SendReplyError ("unknown command");
}
2014-12-02 20:47:44 +00:00
m_ReceiveBufferOffset = size - (eol - m_ReceiveBuffer) - 1;
memmove (m_ReceiveBuffer, eol + 1, m_ReceiveBufferOffset);
}
else
{
if (size < BOB_COMMAND_BUFFER_SIZE)
m_ReceiveBufferOffset = size;
else
{
LogPrint (eLogError, "Malformed input of the BOB command channel");
2014-12-02 21:45:51 +00:00
Terminate ();
2014-12-02 20:47:44 +00:00
}
}
2014-12-02 21:45:51 +00:00
}
}
void BOBCommandSession::Send (size_t len)
{
boost::asio::async_write (m_Socket, boost::asio::buffer (m_SendBuffer, len),
boost::asio::transfer_all (),
std::bind(&BOBCommandSession::HandleSent, shared_from_this (),
std::placeholders::_1, std::placeholders::_2));
}
void BOBCommandSession::HandleSent (const boost::system::error_code& ecode, std::size_t bytes_transferred)
{
if (ecode)
{
LogPrint ("BOB command channel send error: ", ecode.message ());
2014-12-05 00:29:20 +00:00
if (ecode != boost::asio::error::operation_aborted)
Terminate ();
2014-12-02 21:45:51 +00:00
}
else
{
2014-12-02 20:47:44 +00:00
if (m_IsOpen)
Receive ();
2014-12-02 21:45:51 +00:00
else
Terminate ();
2014-12-02 20:47:44 +00:00
}
}
2014-12-02 21:45:51 +00:00
void BOBCommandSession::SendReplyOK (const char * msg)
{
#ifdef _MSC_VER
size_t len = sprintf_s (m_SendBuffer, BOB_COMMAND_BUFFER_SIZE, BOB_REPLY_OK, msg);
#else
size_t len = snprintf (m_SendBuffer, BOB_COMMAND_BUFFER_SIZE, BOB_REPLY_OK, msg);
#endif
Send (len);
}
void BOBCommandSession::SendReplyError (const char * msg)
{
#ifdef _MSC_VER
size_t len = sprintf_s (m_SendBuffer, BOB_COMMAND_BUFFER_SIZE, BOB_REPLY_ERROR, msg);
#else
size_t len = snprintf (m_SendBuffer, BOB_COMMAND_BUFFER_SIZE, BOB_REPLY_ERROR, msg);
#endif
Send (len);
}
2014-12-06 03:25:31 +00:00
2014-12-05 21:03:43 +00:00
void BOBCommandSession::SendVersion ()
{
size_t len = strlen (BOB_VERSION);
memcpy (m_SendBuffer, BOB_VERSION, len);
Send (len);
}
2014-12-06 03:25:31 +00:00
void BOBCommandSession::SendData (const char * nickname)
{
#ifdef _MSC_VER
size_t len = sprintf_s (m_SendBuffer, BOB_COMMAND_BUFFER_SIZE, BOB_DATA, nickname);
#else
size_t len = snprintf (m_SendBuffer, BOB_COMMAND_BUFFER_SIZE, BOB_DATA, nickname);
#endif
Send (len);
}
2014-12-02 20:47:44 +00:00
void BOBCommandSession::ZapCommandHandler (const char * operand, size_t len)
{
LogPrint (eLogDebug, "BOB: zap");
2014-12-02 21:45:51 +00:00
Terminate ();
}
void BOBCommandSession::QuitCommandHandler (const char * operand, size_t len)
{
LogPrint (eLogDebug, "BOB: quit");
2014-12-02 20:47:44 +00:00
m_IsOpen = false;
2014-12-02 21:45:51 +00:00
SendReplyOK ("Bye!");
2014-12-02 20:47:44 +00:00
}
2014-12-03 02:45:01 +00:00
void BOBCommandSession::StartCommandHandler (const char * operand, size_t len)
{
LogPrint (eLogDebug, "BOB: start ", m_Nickname);
2014-12-08 02:04:02 +00:00
if (!m_CurrentDestination)
{
m_CurrentDestination = new BOBDestination (*i2p::client::context.CreateNewLocalDestination (m_Keys, true, &m_Options));
2014-12-08 02:04:02 +00:00
m_Owner.AddDestination (m_Nickname, m_CurrentDestination);
}
if (m_InPort)
2014-12-08 02:04:02 +00:00
m_CurrentDestination->CreateInboundTunnel (m_InPort);
if (m_OutPort && !m_Address.empty ())
2014-12-08 02:04:02 +00:00
m_CurrentDestination->CreateOutboundTunnel (m_Address, m_OutPort, m_IsQuiet);
m_CurrentDestination->Start ();
SendReplyOK ("tunnel starting");
2014-12-03 02:45:01 +00:00
}
2014-12-03 20:24:30 +00:00
void BOBCommandSession::StopCommandHandler (const char * operand, size_t len)
{
auto dest = m_Owner.FindDestination (m_Nickname);
if (dest)
2014-12-03 20:24:30 +00:00
{
2014-12-08 02:04:02 +00:00
dest->StopTunnels ();
2014-12-03 20:24:30 +00:00
SendReplyOK ("tunnel stopping");
}
else
SendReplyError ("tunnel not found");
}
2014-12-03 02:45:01 +00:00
void BOBCommandSession::SetNickCommandHandler (const char * operand, size_t len)
{
LogPrint (eLogDebug, "BOB: setnick ", operand);
2014-12-03 02:45:01 +00:00
m_Nickname = operand;
2014-12-05 00:29:20 +00:00
std::string msg ("Nickname set to ");
2014-12-03 02:45:01 +00:00
msg += operand;
SendReplyOK (msg.c_str ());
}
2014-12-03 20:24:30 +00:00
void BOBCommandSession::GetNickCommandHandler (const char * operand, size_t len)
{
LogPrint (eLogDebug, "BOB: getnick ", operand);
2014-12-08 02:04:02 +00:00
m_CurrentDestination = m_Owner.FindDestination (operand);
if (m_CurrentDestination)
2014-12-03 20:24:30 +00:00
{
2014-12-08 02:04:02 +00:00
m_Keys = m_CurrentDestination->GetKeys ();
2014-12-03 20:24:30 +00:00
m_Nickname = operand;
2014-12-05 00:29:20 +00:00
std::string msg ("Nickname set to ");
2014-12-03 20:24:30 +00:00
msg += operand;
SendReplyOK (msg.c_str ());
}
else
SendReplyError ("tunnel not found");
}
2014-12-03 02:45:01 +00:00
void BOBCommandSession::NewkeysCommandHandler (const char * operand, size_t len)
{
LogPrint (eLogDebug, "BOB: newkeys");
m_Keys = i2p::data::PrivateKeys::CreateRandomKeys ();
2014-12-03 02:55:30 +00:00
SendReplyOK (m_Keys.GetPublic ().ToBase64 ().c_str ());
2014-12-03 02:45:01 +00:00
}
2014-12-04 02:01:40 +00:00
void BOBCommandSession::SetkeysCommandHandler (const char * operand, size_t len)
{
LogPrint (eLogDebug, "BOB: setkeys ", operand);
2014-12-04 02:01:40 +00:00
m_Keys.FromBase64 (operand);
2014-12-07 22:19:56 +00:00
SendReplyOK (m_Keys.GetPublic ().ToBase64 ().c_str ());
2014-12-04 02:01:40 +00:00
}
void BOBCommandSession::GetkeysCommandHandler (const char * operand, size_t len)
{
LogPrint (eLogDebug, "BOB: getkeys");
SendReplyOK (m_Keys.ToBase64 ().c_str ());
}
void BOBCommandSession::GetdestCommandHandler (const char * operand, size_t len)
{
LogPrint (eLogDebug, "BOB: getdest");
SendReplyOK (m_Keys.GetPublic ().ToBase64 ().c_str ());
}
2014-12-03 02:45:01 +00:00
void BOBCommandSession::OuthostCommandHandler (const char * operand, size_t len)
{
LogPrint (eLogDebug, "BOB: outhost ", operand);
2014-12-03 02:45:01 +00:00
m_Address = operand;
SendReplyOK ("outhost set");
}
void BOBCommandSession::OutportCommandHandler (const char * operand, size_t len)
{
LogPrint (eLogDebug, "BOB: outport ", operand);
m_OutPort = boost::lexical_cast<int>(operand);
2014-12-03 02:45:01 +00:00
SendReplyOK ("outbound port set");
}
2014-12-03 20:02:19 +00:00
void BOBCommandSession::InhostCommandHandler (const char * operand, size_t len)
{
LogPrint (eLogDebug, "BOB: inhost ", operand);
2014-12-03 20:02:19 +00:00
m_Address = operand;
SendReplyOK ("inhost set");
}
void BOBCommandSession::InportCommandHandler (const char * operand, size_t len)
{
LogPrint (eLogDebug, "BOB: inport ", operand);
m_InPort = boost::lexical_cast<int>(operand);
2014-12-03 20:02:19 +00:00
SendReplyOK ("inbound port set");
}
2014-12-05 19:13:16 +00:00
void BOBCommandSession::QuietCommandHandler (const char * operand, size_t len)
{
LogPrint (eLogDebug, "BOB: quiet");
m_IsQuiet = true;
SendReplyOK ("quiet");
}
2014-12-05 21:03:43 +00:00
void BOBCommandSession::LookupCommandHandler (const char * operand, size_t len)
{
LogPrint (eLogDebug, "BOB: lookup ", operand);
2014-12-05 21:03:43 +00:00
i2p::data::IdentityEx addr;
if (!context.GetAddressBook ().GetAddress (operand, addr))
{
SendReplyError ("Address Not found");
return;
}
SendReplyOK (addr.ToBase64 ().c_str ());
}
2014-12-06 00:16:54 +00:00
void BOBCommandSession::ClearCommandHandler (const char * operand, size_t len)
{
LogPrint (eLogDebug, "BOB: clear");
2014-12-08 02:04:02 +00:00
m_Owner.DeleteDestination (m_Nickname);
2014-12-06 00:16:54 +00:00
SendReplyOK ("cleared");
}
2014-12-05 21:03:43 +00:00
2014-12-06 03:25:31 +00:00
void BOBCommandSession::ListCommandHandler (const char * operand, size_t len)
{
LogPrint (eLogDebug, "BOB: list");
auto& destinations = m_Owner.GetDestinations ();
for (auto it: destinations)
2014-12-06 03:25:31 +00:00
SendData (it.first.c_str ());
SendReplyOK ("Listing done");
}
void BOBCommandSession::OptionCommandHandler (const char * operand, size_t len)
{
LogPrint (eLogDebug, "BOB: option ", operand);
2014-12-06 20:31:39 +00:00
const char * value = strchr (operand, '=');
if (value)
{
*(const_cast<char *>(value)) = 0;
m_Options[operand] = value + 1;
*(const_cast<char *>(value)) = '=';
SendReplyOK ("option");
}
else
SendReplyError ("malformed");
2014-12-06 03:25:31 +00:00
}
2014-12-02 16:42:35 +00:00
BOBCommandChannel::BOBCommandChannel (int port):
m_IsRunning (false), m_Thread (nullptr),
m_Acceptor (m_Service, boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), port))
2014-12-02 15:34:02 +00:00
{
2014-12-03 02:45:01 +00:00
// command -> handler
2014-12-02 20:47:44 +00:00
m_CommandHandlers[BOB_COMMAND_ZAP] = &BOBCommandSession::ZapCommandHandler;
2014-12-02 21:45:51 +00:00
m_CommandHandlers[BOB_COMMAND_QUIT] = &BOBCommandSession::QuitCommandHandler;
2014-12-03 02:45:01 +00:00
m_CommandHandlers[BOB_COMMAND_START] = &BOBCommandSession::StartCommandHandler;
2014-12-03 20:24:30 +00:00
m_CommandHandlers[BOB_COMMAND_STOP] = &BOBCommandSession::StopCommandHandler;
2014-12-03 02:45:01 +00:00
m_CommandHandlers[BOB_COMMAND_SETNICK] = &BOBCommandSession::SetNickCommandHandler;
2014-12-03 20:24:30 +00:00
m_CommandHandlers[BOB_COMMAND_GETNICK] = &BOBCommandSession::GetNickCommandHandler;
2014-12-03 02:45:01 +00:00
m_CommandHandlers[BOB_COMMAND_NEWKEYS] = &BOBCommandSession::NewkeysCommandHandler;
2014-12-04 02:01:40 +00:00
m_CommandHandlers[BOB_COMMAND_GETKEYS] = &BOBCommandSession::GetkeysCommandHandler;
m_CommandHandlers[BOB_COMMAND_SETKEYS] = &BOBCommandSession::SetkeysCommandHandler;
m_CommandHandlers[BOB_COMMAND_GETDEST] = &BOBCommandSession::GetdestCommandHandler;
2014-12-03 02:45:01 +00:00
m_CommandHandlers[BOB_COMMAND_OUTHOST] = &BOBCommandSession::OuthostCommandHandler;
m_CommandHandlers[BOB_COMMAND_OUTPORT] = &BOBCommandSession::OutportCommandHandler;
2014-12-03 20:02:19 +00:00
m_CommandHandlers[BOB_COMMAND_INHOST] = &BOBCommandSession::InhostCommandHandler;
m_CommandHandlers[BOB_COMMAND_INPORT] = &BOBCommandSession::InportCommandHandler;
2014-12-05 19:13:16 +00:00
m_CommandHandlers[BOB_COMMAND_QUIET] = &BOBCommandSession::QuietCommandHandler;
2014-12-05 21:03:43 +00:00
m_CommandHandlers[BOB_COMMAND_LOOKUP] = &BOBCommandSession::LookupCommandHandler;
2014-12-06 00:16:54 +00:00
m_CommandHandlers[BOB_COMMAND_CLEAR] = &BOBCommandSession::ClearCommandHandler;
2014-12-06 03:25:31 +00:00
m_CommandHandlers[BOB_COMMAND_LIST] = &BOBCommandSession::ListCommandHandler;
m_CommandHandlers[BOB_COMMAND_OPTION] = &BOBCommandSession::OptionCommandHandler;
2014-12-02 15:34:02 +00:00
}
BOBCommandChannel::~BOBCommandChannel ()
{
2014-12-02 16:42:35 +00:00
Stop ();
for (auto it: m_Destinations)
2014-12-03 20:24:30 +00:00
delete it.second;
2014-12-02 16:42:35 +00:00
}
void BOBCommandChannel::Start ()
{
Accept ();
m_IsRunning = true;
m_Thread = new std::thread (std::bind (&BOBCommandChannel::Run, this));
}
void BOBCommandChannel::Stop ()
{
m_IsRunning = false;
for (auto it: m_Destinations)
2014-12-03 20:24:30 +00:00
it.second->Stop ();
m_Acceptor.cancel ();
2014-12-02 16:42:35 +00:00
m_Service.stop ();
if (m_Thread)
{
m_Thread->join ();
delete m_Thread;
m_Thread = nullptr;
}
}
2014-12-08 02:04:02 +00:00
2014-12-02 16:42:35 +00:00
void BOBCommandChannel::Run ()
{
while (m_IsRunning)
{
try
{
m_Service.run ();
}
catch (std::exception& ex)
{
LogPrint (eLogError, "BOB: ", ex.what ());
}
}
}
void BOBCommandChannel::AddDestination (const std::string& name, BOBDestination * dest)
2014-12-03 02:45:01 +00:00
{
m_Destinations[name] = dest;
2014-12-03 02:45:01 +00:00
}
2014-12-03 20:24:30 +00:00
2014-12-08 02:04:02 +00:00
void BOBCommandChannel::DeleteDestination (const std::string& name)
{
auto it = m_Destinations.find (name);
if (it != m_Destinations.end ())
{
it->second->Stop ();
delete it->second;
m_Destinations.erase (it);
}
}
BOBDestination * BOBCommandChannel::FindDestination (const std::string& name)
2014-12-03 20:24:30 +00:00
{
auto it = m_Destinations.find (name);
if (it != m_Destinations.end ())
2014-12-03 20:24:30 +00:00
return it->second;
return nullptr;
}
2014-12-03 02:45:01 +00:00
2014-12-02 16:42:35 +00:00
void BOBCommandChannel::Accept ()
{
2014-12-02 20:47:44 +00:00
auto newSession = std::make_shared<BOBCommandSession> (*this);
m_Acceptor.async_accept (newSession->GetSocket (), std::bind (&BOBCommandChannel::HandleAccept, this,
std::placeholders::_1, newSession));
2014-12-02 16:42:35 +00:00
}
2014-12-02 20:47:44 +00:00
void BOBCommandChannel::HandleAccept(const boost::system::error_code& ecode, std::shared_ptr<BOBCommandSession> session)
2014-12-02 16:42:35 +00:00
{
if (ecode != boost::asio::error::operation_aborted)
Accept ();
if (!ecode)
{
2014-12-02 20:47:44 +00:00
LogPrint (eLogInfo, "New BOB command connection from ", session->GetSocket ().remote_endpoint ());
2014-12-05 21:03:43 +00:00
session->SendVersion ();
2014-12-02 16:42:35 +00:00
}
else
LogPrint (eLogError, "BOB accept error: ", ecode.message ());
2014-12-02 15:34:02 +00:00
}
}
}