mirror of
https://github.com/PurpleI2P/i2pd.git
synced 2025-07-01 10:14:36 +02:00
809 lines
36 KiB
C++
809 lines
36 KiB
C++
/*
|
|
* Copyright (c) 2013-2022, The PurpleI2P Project
|
|
*
|
|
* This file is part of Purple i2pd project and licensed under BSD3
|
|
*
|
|
* See full license text in LICENSE file at top of project tree
|
|
*/
|
|
|
|
#include <string.h>
|
|
#include "Log.h"
|
|
#include "ClientContext.h"
|
|
#include "util.h"
|
|
#include "BOB.h"
|
|
|
|
namespace i2p {
|
|
namespace client {
|
|
BOBI2PInboundTunnel::BOBI2PInboundTunnel(const boost::asio::ip::tcp::endpoint &ep,
|
|
std::shared_ptr <ClientDestination> localDestination) :
|
|
BOBI2PTunnel(localDestination), m_Acceptor(localDestination->GetService(), ep) {
|
|
}
|
|
|
|
BOBI2PInboundTunnel::~BOBI2PInboundTunnel() {
|
|
Stop();
|
|
}
|
|
|
|
void BOBI2PInboundTunnel::Start() {
|
|
m_Acceptor.listen();
|
|
Accept();
|
|
}
|
|
|
|
void BOBI2PInboundTunnel::Stop() {
|
|
m_Acceptor.close();
|
|
ClearHandlers();
|
|
}
|
|
|
|
void BOBI2PInboundTunnel::Accept() {
|
|
auto receiver = std::make_shared<AddressReceiver>();
|
|
receiver->socket = std::make_shared<boost::asio::ip::tcp::socket>(GetService());
|
|
m_Acceptor.async_accept(*receiver->socket, std::bind(&BOBI2PInboundTunnel::HandleAccept, this,
|
|
std::placeholders::_1, receiver));
|
|
}
|
|
|
|
void BOBI2PInboundTunnel::HandleAccept(const boost::system::error_code &ecode,
|
|
std::shared_ptr <AddressReceiver> receiver) {
|
|
if (!ecode) {
|
|
Accept();
|
|
ReceiveAddress(receiver);
|
|
}
|
|
}
|
|
|
|
void BOBI2PInboundTunnel::ReceiveAddress(std::shared_ptr <AddressReceiver> receiver) {
|
|
receiver->socket->async_read_some(boost::asio::buffer(
|
|
receiver->buffer + receiver->bufferOffset,
|
|
BOB_COMMAND_BUFFER_SIZE - receiver->bufferOffset),
|
|
std::bind(&BOBI2PInboundTunnel::HandleReceivedAddress, this,
|
|
std::placeholders::_1, std::placeholders::_2, receiver));
|
|
}
|
|
|
|
void BOBI2PInboundTunnel::HandleReceivedAddress(const boost::system::error_code &ecode,
|
|
std::size_t bytes_transferred,
|
|
std::shared_ptr <AddressReceiver> receiver) {
|
|
if (ecode)
|
|
LogPrint(eLogError, "BOB: Inbound tunnel read error: ", ecode.message());
|
|
else {
|
|
receiver->bufferOffset += bytes_transferred;
|
|
receiver->buffer[receiver->bufferOffset] = 0;
|
|
char *eol = strchr(receiver->buffer, '\n');
|
|
if (eol) {
|
|
*eol = 0;
|
|
if (eol != receiver->buffer && eol[-1] == '\r')
|
|
eol[-1] = 0; // workaround for Transmission, it sends '\r\n' terminated address
|
|
receiver->data = (uint8_t *) eol + 1;
|
|
receiver->dataLen = receiver->bufferOffset - (eol - receiver->buffer + 1);
|
|
auto addr = context.GetAddressBook().GetAddress(receiver->buffer);
|
|
if (!addr) {
|
|
LogPrint(eLogError, "BOB: Address ", receiver->buffer, " not found");
|
|
return;
|
|
}
|
|
if (addr->IsIdentHash()) {
|
|
auto leaseSet = GetLocalDestination()->FindLeaseSet(addr->identHash);
|
|
if (leaseSet)
|
|
CreateConnection(receiver, leaseSet);
|
|
else
|
|
GetLocalDestination()->RequestDestination(addr->identHash,
|
|
std::bind(
|
|
&BOBI2PInboundTunnel::HandleDestinationRequestComplete,
|
|
this, std::placeholders::_1, receiver));
|
|
} else
|
|
GetLocalDestination()->RequestDestinationWithEncryptedLeaseSet(addr->blindedPublicKey,
|
|
std::bind(
|
|
&BOBI2PInboundTunnel::HandleDestinationRequestComplete,
|
|
this,
|
|
std::placeholders::_1,
|
|
receiver));
|
|
} else {
|
|
if (receiver->bufferOffset < BOB_COMMAND_BUFFER_SIZE)
|
|
ReceiveAddress(receiver);
|
|
else
|
|
LogPrint(eLogError, "BOB: Missing inbound address");
|
|
}
|
|
}
|
|
}
|
|
|
|
void BOBI2PInboundTunnel::HandleDestinationRequestComplete(std::shared_ptr <i2p::data::LeaseSet> leaseSet,
|
|
std::shared_ptr <AddressReceiver> receiver) {
|
|
if (leaseSet)
|
|
CreateConnection(receiver, leaseSet);
|
|
else
|
|
LogPrint(eLogError, "BOB: LeaseSet for inbound destination not found");
|
|
}
|
|
|
|
void BOBI2PInboundTunnel::CreateConnection(std::shared_ptr <AddressReceiver> receiver,
|
|
std::shared_ptr<const i2p::data::LeaseSet> leaseSet) {
|
|
LogPrint(eLogDebug, "BOB: New inbound connection");
|
|
auto connection = std::make_shared<I2PTunnelConnection>(this, receiver->socket, leaseSet);
|
|
AddHandler(connection);
|
|
connection->I2PConnect(receiver->data, receiver->dataLen);
|
|
}
|
|
|
|
BOBI2POutboundTunnel::BOBI2POutboundTunnel(const std::string &outhost, int port,
|
|
std::shared_ptr <ClientDestination> localDestination, bool quiet)
|
|
: BOBI2PTunnel(localDestination),
|
|
m_Endpoint(boost::asio::ip::address::from_string(outhost), port), m_IsQuiet(quiet) {
|
|
}
|
|
|
|
void BOBI2POutboundTunnel::Start() {
|
|
Accept();
|
|
}
|
|
|
|
void BOBI2POutboundTunnel::Stop() {
|
|
ClearHandlers();
|
|
}
|
|
|
|
void BOBI2POutboundTunnel::Accept() {
|
|
auto localDestination = GetLocalDestination();
|
|
if (localDestination)
|
|
localDestination->AcceptStreams(
|
|
std::bind(&BOBI2POutboundTunnel::HandleAccept, this, std::placeholders::_1));
|
|
else
|
|
LogPrint(eLogError, "BOB: 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,
|
|
std::make_shared<boost::asio::ip::tcp::socket>(
|
|
GetService()), m_Endpoint, m_IsQuiet);
|
|
AddHandler(conn);
|
|
conn->Connect();
|
|
}
|
|
}
|
|
|
|
BOBDestination::BOBDestination(std::shared_ptr <ClientDestination> localDestination,
|
|
const std::string &nickname, const std::string &inhost,
|
|
const std::string &outhost,
|
|
const int inport, const int outport, const bool quiet) :
|
|
m_LocalDestination(localDestination),
|
|
m_OutboundTunnel(nullptr), m_InboundTunnel(nullptr),
|
|
m_Nickname(nickname), m_InHost(inhost), m_OutHost(outhost),
|
|
m_InPort(inport), m_OutPort(outport), m_Quiet(quiet), m_IsRunning(false) {
|
|
}
|
|
|
|
BOBDestination::~BOBDestination() {
|
|
delete m_OutboundTunnel;
|
|
delete m_InboundTunnel;
|
|
i2p::client::context.DeleteLocalDestination(m_LocalDestination);
|
|
}
|
|
|
|
void BOBDestination::Start() {
|
|
if (m_OutboundTunnel) m_OutboundTunnel->Start();
|
|
if (m_InboundTunnel) m_InboundTunnel->Start();
|
|
m_IsRunning = true;
|
|
}
|
|
|
|
void BOBDestination::Stop() {
|
|
StopTunnels();
|
|
m_LocalDestination->Stop();
|
|
}
|
|
|
|
void BOBDestination::StopTunnels() {
|
|
m_IsRunning = false;
|
|
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, const std::string &inhost) {
|
|
if (!m_InboundTunnel) {
|
|
// update inport and inhost (user can stop tunnel and change)
|
|
m_InPort = port;
|
|
m_InHost = inhost;
|
|
boost::asio::ip::tcp::endpoint ep(boost::asio::ip::tcp::v4(), port);
|
|
if (!inhost.empty()) {
|
|
boost::system::error_code ec;
|
|
auto addr = boost::asio::ip::address::from_string(inhost, ec);
|
|
if (!ec)
|
|
ep.address(addr);
|
|
else
|
|
LogPrint(eLogError, "BOB: ", ec.message());
|
|
}
|
|
m_InboundTunnel = new BOBI2PInboundTunnel(ep, m_LocalDestination);
|
|
}
|
|
}
|
|
|
|
void BOBDestination::CreateOutboundTunnel(const std::string &outhost, int port, bool quiet) {
|
|
if (!m_OutboundTunnel) {
|
|
// update outport and outhost (user can stop tunnel and change)
|
|
m_OutPort = port;
|
|
m_OutHost = outhost;
|
|
m_OutboundTunnel = new BOBI2POutboundTunnel(outhost, port, m_LocalDestination, quiet);
|
|
}
|
|
}
|
|
|
|
BOBCommandSession::BOBCommandSession(BOBCommandChannel &owner) :
|
|
m_Owner(owner), m_Socket(m_Owner.GetService()),
|
|
m_ReceiveBuffer(BOB_COMMAND_BUFFER_SIZE + 1), m_SendBuffer(BOB_COMMAND_BUFFER_SIZE + 1),
|
|
m_IsOpen(true), m_IsQuiet(false), m_IsActive(false),
|
|
m_InPort(0), m_OutPort(0), m_CurrentDestination(nullptr) {
|
|
}
|
|
|
|
BOBCommandSession::~BOBCommandSession() {
|
|
}
|
|
|
|
void BOBCommandSession::Terminate() {
|
|
m_Socket.close();
|
|
m_IsOpen = false;
|
|
}
|
|
|
|
void BOBCommandSession::Receive() {
|
|
boost::asio::async_read_until(m_Socket, m_ReceiveBuffer, '\n',
|
|
std::bind(&BOBCommandSession::HandleReceivedLine, shared_from_this(),
|
|
std::placeholders::_1, std::placeholders::_2));
|
|
}
|
|
|
|
void
|
|
BOBCommandSession::HandleReceivedLine(const boost::system::error_code &ecode, std::size_t bytes_transferred) {
|
|
if (ecode) {
|
|
LogPrint(eLogError, "BOB: Command channel read error: ", ecode.message());
|
|
if (ecode != boost::asio::error::operation_aborted)
|
|
Terminate();
|
|
} else {
|
|
std::string line;
|
|
|
|
std::istream is(&m_ReceiveBuffer);
|
|
std::getline(is, line);
|
|
|
|
std::string command, operand;
|
|
std::istringstream iss(line);
|
|
iss >> command >> operand;
|
|
|
|
// process command
|
|
auto &handlers = m_Owner.GetCommandHandlers();
|
|
auto it = handlers.find(command);
|
|
if (it != handlers.end()) {
|
|
(this->*(it->second))(operand.c_str(), operand.length());
|
|
} else {
|
|
LogPrint(eLogError, "BOB: Unknown command ", command.c_str());
|
|
SendReplyError("unknown command");
|
|
}
|
|
}
|
|
}
|
|
|
|
void BOBCommandSession::Send() {
|
|
boost::asio::async_write(m_Socket, m_SendBuffer,
|
|
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(eLogError, "BOB: Command channel send error: ", ecode.message());
|
|
if (ecode != boost::asio::error::operation_aborted)
|
|
Terminate();
|
|
} else {
|
|
if (m_IsOpen)
|
|
Receive();
|
|
else
|
|
Terminate();
|
|
}
|
|
}
|
|
|
|
void BOBCommandSession::SendReplyOK(const char *msg) {
|
|
std::ostream os(&m_SendBuffer);
|
|
os << "OK";
|
|
if (msg) {
|
|
os << " " << msg;
|
|
}
|
|
os << std::endl;
|
|
Send();
|
|
}
|
|
|
|
void BOBCommandSession::SendReplyError(const char *msg) {
|
|
std::ostream os(&m_SendBuffer);
|
|
os << "ERROR " << msg << std::endl;
|
|
Send();
|
|
}
|
|
|
|
void BOBCommandSession::SendVersion() {
|
|
std::ostream os(&m_SendBuffer);
|
|
os << "BOB 00.00.10" << std::endl;
|
|
SendReplyOK();
|
|
}
|
|
|
|
void BOBCommandSession::SendRaw(const char *data) {
|
|
std::ostream os(&m_SendBuffer);
|
|
os << data << std::endl;
|
|
}
|
|
|
|
void BOBCommandSession::BuildStatusLine(bool currentTunnel, BOBDestination *dest, std::string &out) {
|
|
// helper lambdas
|
|
const auto issetStr = [](const std::string &str) {
|
|
return str.empty() ? "not_set" : str;
|
|
}; // for inhost, outhost
|
|
const auto issetNum = [&issetStr](const int p) {
|
|
return issetStr(p == 0 ? "" : std::to_string(p));
|
|
}; // for inport, outport
|
|
const auto destExists = [](const BOBDestination *const dest) { return dest != nullptr; };
|
|
const auto destReady = [](const BOBDestination *const dest) { return dest->IsRunning(); };
|
|
const auto bool_str = [](const bool v) { return v ? "true" : "false"; }; // bool -> str
|
|
|
|
// tunnel info
|
|
const std::string nickname = currentTunnel ? m_Nickname : dest->GetNickname();
|
|
const bool quiet = currentTunnel ? m_IsQuiet : dest->GetQuiet();
|
|
const std::string inhost = issetStr(currentTunnel ? m_InHost : dest->GetInHost());
|
|
const std::string outhost = issetStr(currentTunnel ? m_OutHost : dest->GetOutHost());
|
|
const std::string inport = issetNum(currentTunnel ? m_InPort : dest->GetInPort());
|
|
const std::string outport = issetNum(currentTunnel ? m_OutPort : dest->GetOutPort());
|
|
const bool keys = destExists(dest); // key must exist when destination is created
|
|
const bool starting = destExists(dest) && !destReady(dest);
|
|
const bool running = destExists(dest) && destReady(dest);
|
|
const bool stopping = false;
|
|
|
|
// build line
|
|
std::stringstream ss;
|
|
ss << "DATA "
|
|
<< "NICKNAME: " << nickname << " " << "STARTING: " << bool_str(starting) << " "
|
|
<< "RUNNING: " << bool_str(running) << " " << "STOPPING: " << bool_str(stopping) << " "
|
|
<< "KEYS: " << bool_str(keys) << " " << "QUIET: " << bool_str(quiet) << " "
|
|
<< "INPORT: " << inport << " " << "INHOST: " << inhost << " "
|
|
<< "OUTPORT: " << outport << " " << "OUTHOST: " << outhost;
|
|
out = ss.str();
|
|
}
|
|
|
|
void BOBCommandSession::ZapCommandHandler(const char *operand, size_t len) {
|
|
LogPrint(eLogDebug, "BOB: zap");
|
|
Terminate();
|
|
}
|
|
|
|
void BOBCommandSession::QuitCommandHandler(const char *operand, size_t len) {
|
|
LogPrint(eLogDebug, "BOB: quit");
|
|
m_IsOpen = false;
|
|
SendReplyOK("Bye!");
|
|
}
|
|
|
|
void BOBCommandSession::StartCommandHandler(const char *operand, size_t len) {
|
|
LogPrint(eLogDebug, "BOB: start ", m_Nickname);
|
|
if (m_IsActive) {
|
|
SendReplyError("tunnel is active");
|
|
return;
|
|
}
|
|
if (!m_Keys.GetPublic()) // keys are set ?
|
|
{
|
|
SendReplyError("Keys must be set.");
|
|
return;
|
|
}
|
|
if (m_InPort == 0
|
|
&& m_OutHost.empty() && m_OutPort == 0) {
|
|
SendReplyError("(inhost):inport or outhost:outport must be set.");
|
|
return;
|
|
}
|
|
if (!m_InHost.empty()) {
|
|
// TODO: FIXME: temporary validation, until hostname support is added
|
|
boost::system::error_code ec;
|
|
boost::asio::ip::address::from_string(m_InHost, ec);
|
|
if (ec) {
|
|
SendReplyError("inhost must be a valid IPv4 address.");
|
|
return;
|
|
}
|
|
}
|
|
if (!m_OutHost.empty()) {
|
|
// TODO: FIXME: temporary validation, until hostname support is added
|
|
boost::system::error_code ec;
|
|
boost::asio::ip::address::from_string(m_OutHost, ec);
|
|
if (ec) {
|
|
SendReplyError("outhost must be a IPv4 address.");
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (!m_CurrentDestination) {
|
|
m_CurrentDestination = new BOBDestination(i2p::client::context.CreateNewLocalDestination(m_Keys, true,
|
|
&m_Options), // deleted in clear command
|
|
m_Nickname, m_InHost, m_OutHost, m_InPort, m_OutPort,
|
|
m_IsQuiet);
|
|
m_Owner.AddDestination(m_Nickname, m_CurrentDestination);
|
|
}
|
|
if (m_InPort)
|
|
m_CurrentDestination->CreateInboundTunnel(m_InPort, m_InHost);
|
|
if (m_OutPort && !m_OutHost.empty())
|
|
m_CurrentDestination->CreateOutboundTunnel(m_OutHost, m_OutPort, m_IsQuiet);
|
|
m_CurrentDestination->Start();
|
|
SendReplyOK("Tunnel starting");
|
|
m_IsActive = true;
|
|
}
|
|
|
|
void BOBCommandSession::StopCommandHandler(const char *operand, size_t len) {
|
|
LogPrint(eLogDebug, "BOB: stop ", m_Nickname);
|
|
if (!m_IsActive) {
|
|
SendReplyError("tunnel is inactive");
|
|
return;
|
|
}
|
|
auto dest = m_Owner.FindDestination(m_Nickname);
|
|
if (dest) {
|
|
dest->StopTunnels();
|
|
SendReplyOK("Tunnel stopping");
|
|
} else
|
|
SendReplyError("tunnel not found");
|
|
m_IsActive = false;
|
|
}
|
|
|
|
void BOBCommandSession::SetNickCommandHandler(const char *operand, size_t len) {
|
|
LogPrint(eLogDebug, "BOB: setnick ", operand);
|
|
if (*operand) {
|
|
auto dest = m_Owner.FindDestination(operand);
|
|
if (!dest) {
|
|
m_Nickname = operand;
|
|
std::string msg("Nickname set to ");
|
|
msg += m_Nickname;
|
|
SendReplyOK(msg.c_str());
|
|
} else
|
|
SendReplyError("tunnel is active");
|
|
} else
|
|
SendReplyError("no nickname has been set");
|
|
}
|
|
|
|
void BOBCommandSession::GetNickCommandHandler(const char *operand, size_t len) {
|
|
LogPrint(eLogDebug, "BOB: getnick ", operand);
|
|
if (*operand) {
|
|
m_CurrentDestination = m_Owner.FindDestination(operand);
|
|
if (m_CurrentDestination) {
|
|
m_Keys = m_CurrentDestination->GetKeys();
|
|
m_IsActive = m_CurrentDestination->IsRunning();
|
|
m_Nickname = operand;
|
|
}
|
|
if (m_Nickname == operand) {
|
|
std::string msg("Nickname set to ");
|
|
msg += m_Nickname;
|
|
SendReplyOK(msg.c_str());
|
|
} else
|
|
SendReplyError("no nickname has been set");
|
|
} else
|
|
SendReplyError("no nickname has been set");
|
|
}
|
|
|
|
void BOBCommandSession::NewkeysCommandHandler(const char *operand, size_t len) {
|
|
LogPrint(eLogDebug, "BOB: newkeys");
|
|
i2p::data::SigningKeyType signatureType = i2p::data::SIGNING_KEY_TYPE_DSA_SHA1;
|
|
i2p::data::CryptoKeyType cryptoType = i2p::data::CRYPTO_KEY_TYPE_ELGAMAL;
|
|
if (*operand) {
|
|
try {
|
|
char *operand1 = (char *) strchr(operand, ' ');
|
|
if (operand1) {
|
|
*operand1 = 0;
|
|
operand1++;
|
|
cryptoType = std::stoi(operand1);
|
|
}
|
|
signatureType = std::stoi(operand);
|
|
}
|
|
catch (std::invalid_argument &ex) {
|
|
LogPrint(eLogWarning, "BOB: Error on newkeys: ", ex.what());
|
|
}
|
|
}
|
|
|
|
|
|
m_Keys = i2p::data::PrivateKeys::CreateRandomKeys(signatureType, cryptoType);
|
|
SendReplyOK(m_Keys.GetPublic()->ToBase64().c_str());
|
|
}
|
|
|
|
void BOBCommandSession::SetkeysCommandHandler(const char *operand, size_t len) {
|
|
LogPrint(eLogDebug, "BOB: setkeys ", operand);
|
|
if (*operand && m_Keys.FromBase64(operand))
|
|
SendReplyOK(m_Keys.GetPublic()->ToBase64().c_str());
|
|
else
|
|
SendReplyError("invalid keys");
|
|
}
|
|
|
|
void BOBCommandSession::GetkeysCommandHandler(const char *operand, size_t len) {
|
|
LogPrint(eLogDebug, "BOB: getkeys");
|
|
if (m_Keys.GetPublic()) // keys are set ?
|
|
SendReplyOK(m_Keys.ToBase64().c_str());
|
|
else
|
|
SendReplyError("keys are not set");
|
|
}
|
|
|
|
void BOBCommandSession::GetdestCommandHandler(const char *operand, size_t len) {
|
|
LogPrint(eLogDebug, "BOB: getdest");
|
|
if (m_Keys.GetPublic()) // keys are set ?
|
|
SendReplyOK(m_Keys.GetPublic()->ToBase64().c_str());
|
|
else
|
|
SendReplyError("keys are not set");
|
|
}
|
|
|
|
void BOBCommandSession::OuthostCommandHandler(const char *operand, size_t len) {
|
|
LogPrint(eLogDebug, "BOB: outhost ", operand);
|
|
if (*operand) {
|
|
m_OutHost = operand;
|
|
SendReplyOK("outhost set");
|
|
} else
|
|
SendReplyError("empty outhost");
|
|
}
|
|
|
|
void BOBCommandSession::OutportCommandHandler(const char *operand, size_t len) {
|
|
LogPrint(eLogDebug, "BOB: outport ", operand);
|
|
if (*operand) {
|
|
m_OutPort = std::stoi(operand);
|
|
if (m_OutPort >= 0)
|
|
SendReplyOK("outbound port set");
|
|
else
|
|
SendReplyError("port out of range");
|
|
} else
|
|
SendReplyError("empty outport");
|
|
}
|
|
|
|
void BOBCommandSession::InhostCommandHandler(const char *operand, size_t len) {
|
|
LogPrint(eLogDebug, "BOB: inhost ", operand);
|
|
if (*operand) {
|
|
m_InHost = operand;
|
|
SendReplyOK("inhost set");
|
|
} else
|
|
SendReplyError("empty inhost");
|
|
}
|
|
|
|
void BOBCommandSession::InportCommandHandler(const char *operand, size_t len) {
|
|
LogPrint(eLogDebug, "BOB: inport ", operand);
|
|
if (*operand) {
|
|
m_InPort = std::stoi(operand);
|
|
if (m_InPort >= 0)
|
|
SendReplyOK("inbound port set");
|
|
else
|
|
SendReplyError("port out of range");
|
|
} else
|
|
SendReplyError("empty inport");
|
|
}
|
|
|
|
void BOBCommandSession::QuietCommandHandler(const char *operand, size_t len) {
|
|
LogPrint(eLogDebug, "BOB: quiet");
|
|
if (m_Nickname.length() > 0) {
|
|
if (!m_IsActive) {
|
|
m_IsQuiet = true;
|
|
SendReplyOK("Quiet set");
|
|
} else
|
|
SendReplyError("tunnel is active");
|
|
} else
|
|
SendReplyError("no nickname has been set");
|
|
}
|
|
|
|
void BOBCommandSession::LookupCommandHandler(const char *operand, size_t len) {
|
|
LogPrint(eLogDebug, "BOB: lookup ", operand);
|
|
if (*operand) {
|
|
auto addr = context.GetAddressBook().GetAddress(operand);
|
|
if (!addr) {
|
|
SendReplyError("Address Not found");
|
|
return;
|
|
}
|
|
auto localDestination = m_CurrentDestination ? m_CurrentDestination->GetLocalDestination()
|
|
: i2p::client::context.GetSharedLocalDestination();
|
|
if (addr->IsIdentHash()) {
|
|
// we might have leaseset already
|
|
auto leaseSet = localDestination->FindLeaseSet(addr->identHash);
|
|
if (leaseSet) {
|
|
SendReplyOK(leaseSet->GetIdentity()->ToBase64().c_str());
|
|
return;
|
|
}
|
|
}
|
|
// trying to request
|
|
auto s = shared_from_this();
|
|
auto requstCallback = [s](std::shared_ptr <i2p::data::LeaseSet> ls) {
|
|
if (ls)
|
|
s->SendReplyOK(ls->GetIdentity()->ToBase64().c_str());
|
|
else
|
|
s->SendReplyError("LeaseSet Not found");
|
|
};
|
|
if (addr->IsIdentHash())
|
|
localDestination->RequestDestination(addr->identHash, requstCallback);
|
|
else
|
|
localDestination->RequestDestinationWithEncryptedLeaseSet(addr->blindedPublicKey, requstCallback);
|
|
} else
|
|
SendReplyError("empty lookup address");
|
|
}
|
|
|
|
void BOBCommandSession::LookupLocalCommandHandler(const char *operand, size_t len) {
|
|
LogPrint(eLogDebug, "BOB: lookup local ", operand);
|
|
if (*operand) {
|
|
auto addr = context.GetAddressBook().GetAddress(operand);
|
|
if (!addr) {
|
|
SendReplyError("Address Not found");
|
|
return;
|
|
}
|
|
auto ls = i2p::data::netdb.FindLeaseSet(addr->identHash);
|
|
if (ls)
|
|
SendReplyOK(ls->GetIdentity()->ToBase64().c_str());
|
|
else
|
|
SendReplyError("Local LeaseSet Not found");
|
|
} else
|
|
SendReplyError("empty lookup address");
|
|
}
|
|
|
|
void BOBCommandSession::ClearCommandHandler(const char *operand, size_t len) {
|
|
LogPrint(eLogDebug, "BOB: clear");
|
|
m_Owner.DeleteDestination(m_Nickname);
|
|
m_Nickname = "";
|
|
SendReplyOK("cleared");
|
|
}
|
|
|
|
void BOBCommandSession::ListCommandHandler(const char *operand, size_t len) {
|
|
LogPrint(eLogDebug, "BOB: list");
|
|
std::string statusLine;
|
|
bool sentCurrent = false;
|
|
const auto &destinations = m_Owner.GetDestinations();
|
|
for (const auto &it: destinations) {
|
|
BuildStatusLine(false, it.second, statusLine);
|
|
SendRaw(statusLine.c_str());
|
|
if (m_Nickname.compare(it.second->GetNickname()) == 0)
|
|
sentCurrent = true;
|
|
}
|
|
if (!sentCurrent && !m_Nickname.empty()) {
|
|
// add the current tunnel to the list.
|
|
// this is for the incomplete tunnel which has not been started yet.
|
|
BuildStatusLine(true, m_CurrentDestination, statusLine);
|
|
SendRaw(statusLine.c_str());
|
|
}
|
|
SendReplyOK("Listing done");
|
|
}
|
|
|
|
void BOBCommandSession::OptionCommandHandler(const char *operand, size_t len) {
|
|
LogPrint(eLogDebug, "BOB: option ", operand);
|
|
const char *value = strchr(operand, '=');
|
|
if (value) {
|
|
std::string msg("option ");
|
|
*(const_cast<char *>(value)) = 0;
|
|
m_Options[operand] = value + 1;
|
|
msg += operand;
|
|
*(const_cast<char *>(value)) = '=';
|
|
msg += " set to ";
|
|
msg += value + 1;
|
|
SendReplyOK(msg.c_str());
|
|
} else
|
|
SendReplyError("malformed");
|
|
}
|
|
|
|
void BOBCommandSession::StatusCommandHandler(const char *operand, size_t len) {
|
|
LogPrint(eLogDebug, "BOB: status ", operand);
|
|
const std::string name = operand;
|
|
std::string statusLine;
|
|
|
|
// always prefer destination
|
|
auto dest = m_Owner.FindDestination(name);
|
|
if (dest) {
|
|
// tunnel destination exists
|
|
BuildStatusLine(false, dest, statusLine);
|
|
SendReplyOK(statusLine.c_str());
|
|
} else {
|
|
if (m_Nickname == name && !name.empty()) {
|
|
// tunnel is incomplete / has not been started yet
|
|
BuildStatusLine(true, nullptr, statusLine);
|
|
SendReplyOK(statusLine.c_str());
|
|
} else {
|
|
SendReplyError("no nickname has been set");
|
|
}
|
|
}
|
|
}
|
|
|
|
void BOBCommandSession::HelpCommandHandler(const char *operand, size_t len) {
|
|
auto helpStrings = m_Owner.GetHelpStrings();
|
|
if (!*operand) {
|
|
std::stringstream ss;
|
|
ss << "COMMANDS:";
|
|
for (auto const &x: helpStrings) {
|
|
ss << " " << x.first;
|
|
}
|
|
const std::string &str = ss.str();
|
|
SendReplyOK(str.c_str());
|
|
} else {
|
|
auto it = helpStrings.find(operand);
|
|
if (it != helpStrings.end()) {
|
|
SendReplyOK(it->second.c_str());
|
|
return;
|
|
}
|
|
SendReplyError("No such command");
|
|
}
|
|
}
|
|
|
|
BOBCommandChannel::BOBCommandChannel(const std::string &address, int port) :
|
|
RunnableService("BOB"),
|
|
m_Acceptor(GetIOService(),
|
|
boost::asio::ip::tcp::endpoint(boost::asio::ip::address::from_string(address), port)) {
|
|
// command -> handler
|
|
m_CommandHandlers[BOB_COMMAND_ZAP] = &BOBCommandSession::ZapCommandHandler;
|
|
m_CommandHandlers[BOB_COMMAND_QUIT] = &BOBCommandSession::QuitCommandHandler;
|
|
m_CommandHandlers[BOB_COMMAND_START] = &BOBCommandSession::StartCommandHandler;
|
|
m_CommandHandlers[BOB_COMMAND_STOP] = &BOBCommandSession::StopCommandHandler;
|
|
m_CommandHandlers[BOB_COMMAND_SETNICK] = &BOBCommandSession::SetNickCommandHandler;
|
|
m_CommandHandlers[BOB_COMMAND_GETNICK] = &BOBCommandSession::GetNickCommandHandler;
|
|
m_CommandHandlers[BOB_COMMAND_NEWKEYS] = &BOBCommandSession::NewkeysCommandHandler;
|
|
m_CommandHandlers[BOB_COMMAND_GETKEYS] = &BOBCommandSession::GetkeysCommandHandler;
|
|
m_CommandHandlers[BOB_COMMAND_SETKEYS] = &BOBCommandSession::SetkeysCommandHandler;
|
|
m_CommandHandlers[BOB_COMMAND_GETDEST] = &BOBCommandSession::GetdestCommandHandler;
|
|
m_CommandHandlers[BOB_COMMAND_OUTHOST] = &BOBCommandSession::OuthostCommandHandler;
|
|
m_CommandHandlers[BOB_COMMAND_OUTPORT] = &BOBCommandSession::OutportCommandHandler;
|
|
m_CommandHandlers[BOB_COMMAND_INHOST] = &BOBCommandSession::InhostCommandHandler;
|
|
m_CommandHandlers[BOB_COMMAND_INPORT] = &BOBCommandSession::InportCommandHandler;
|
|
m_CommandHandlers[BOB_COMMAND_QUIET] = &BOBCommandSession::QuietCommandHandler;
|
|
m_CommandHandlers[BOB_COMMAND_LOOKUP] = &BOBCommandSession::LookupCommandHandler;
|
|
m_CommandHandlers[BOB_COMMAND_LOOKUP_LOCAL] = &BOBCommandSession::LookupLocalCommandHandler;
|
|
m_CommandHandlers[BOB_COMMAND_CLEAR] = &BOBCommandSession::ClearCommandHandler;
|
|
m_CommandHandlers[BOB_COMMAND_LIST] = &BOBCommandSession::ListCommandHandler;
|
|
m_CommandHandlers[BOB_COMMAND_OPTION] = &BOBCommandSession::OptionCommandHandler;
|
|
m_CommandHandlers[BOB_COMMAND_STATUS] = &BOBCommandSession::StatusCommandHandler;
|
|
m_CommandHandlers[BOB_COMMAND_HELP] = &BOBCommandSession::HelpCommandHandler;
|
|
// command -> help string
|
|
m_HelpStrings[BOB_COMMAND_ZAP] = BOB_HELP_ZAP;
|
|
m_HelpStrings[BOB_COMMAND_QUIT] = BOB_HELP_QUIT;
|
|
m_HelpStrings[BOB_COMMAND_START] = BOB_HELP_START;
|
|
m_HelpStrings[BOB_COMMAND_STOP] = BOB_HELP_STOP;
|
|
m_HelpStrings[BOB_COMMAND_SETNICK] = BOB_HELP_SETNICK;
|
|
m_HelpStrings[BOB_COMMAND_GETNICK] = BOB_HELP_GETNICK;
|
|
m_HelpStrings[BOB_COMMAND_NEWKEYS] = BOB_HELP_NEWKEYS;
|
|
m_HelpStrings[BOB_COMMAND_GETKEYS] = BOB_HELP_GETKEYS;
|
|
m_HelpStrings[BOB_COMMAND_SETKEYS] = BOB_HELP_SETKEYS;
|
|
m_HelpStrings[BOB_COMMAND_GETDEST] = BOB_HELP_GETDEST;
|
|
m_HelpStrings[BOB_COMMAND_OUTHOST] = BOB_HELP_OUTHOST;
|
|
m_HelpStrings[BOB_COMMAND_OUTPORT] = BOB_HELP_OUTPORT;
|
|
m_HelpStrings[BOB_COMMAND_INHOST] = BOB_HELP_INHOST;
|
|
m_HelpStrings[BOB_COMMAND_INPORT] = BOB_HELP_INPORT;
|
|
m_HelpStrings[BOB_COMMAND_QUIET] = BOB_HELP_QUIET;
|
|
m_HelpStrings[BOB_COMMAND_LOOKUP] = BOB_HELP_LOOKUP;
|
|
m_HelpStrings[BOB_COMMAND_CLEAR] = BOB_HELP_CLEAR;
|
|
m_HelpStrings[BOB_COMMAND_LIST] = BOB_HELP_LIST;
|
|
m_HelpStrings[BOB_COMMAND_OPTION] = BOB_HELP_OPTION;
|
|
m_HelpStrings[BOB_COMMAND_STATUS] = BOB_HELP_STATUS;
|
|
m_HelpStrings[BOB_COMMAND_HELP] = BOB_HELP_HELP;
|
|
}
|
|
|
|
BOBCommandChannel::~BOBCommandChannel() {
|
|
if (IsRunning())
|
|
Stop();
|
|
for (const auto &it: m_Destinations)
|
|
delete it.second;
|
|
}
|
|
|
|
void BOBCommandChannel::Start() {
|
|
Accept();
|
|
StartIOService();
|
|
}
|
|
|
|
void BOBCommandChannel::Stop() {
|
|
for (auto &it: m_Destinations)
|
|
it.second->Stop();
|
|
m_Acceptor.cancel();
|
|
StopIOService();
|
|
}
|
|
|
|
void BOBCommandChannel::AddDestination(const std::string &name, BOBDestination *dest) {
|
|
m_Destinations[name] = dest;
|
|
}
|
|
|
|
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) {
|
|
auto it = m_Destinations.find(name);
|
|
if (it != m_Destinations.end())
|
|
return it->second;
|
|
return nullptr;
|
|
}
|
|
|
|
void BOBCommandChannel::Accept() {
|
|
auto newSession = std::make_shared<BOBCommandSession>(*this);
|
|
m_Acceptor.async_accept(newSession->GetSocket(), std::bind(&BOBCommandChannel::HandleAccept, this,
|
|
std::placeholders::_1, newSession));
|
|
}
|
|
|
|
void BOBCommandChannel::HandleAccept(const boost::system::error_code &ecode,
|
|
std::shared_ptr <BOBCommandSession> session) {
|
|
if (ecode != boost::asio::error::operation_aborted)
|
|
Accept();
|
|
|
|
if (!ecode) {
|
|
LogPrint(eLogInfo, "BOB: New command connection from ", session->GetSocket().remote_endpoint());
|
|
session->SendVersion();
|
|
} else
|
|
LogPrint(eLogError, "BOB: Accept error: ", ecode.message());
|
|
}
|
|
}
|
|
}
|