Reformat code

This commit is contained in:
Anatolii Cherednichenko 2022-08-30 02:11:28 +03:00
parent 3ddb370718
commit 55534ea002
140 changed files with 46068 additions and 48277 deletions

View file

@ -21,263 +21,326 @@
#include "Identity.h"
#include "LeaseSet.h"
namespace i2p
{
namespace client
{
const size_t BOB_COMMAND_BUFFER_SIZE = 1024;
const char BOB_COMMAND_ZAP[] = "zap";
const char BOB_COMMAND_QUIT[] = "quit";
const char BOB_COMMAND_START[] = "start";
const char BOB_COMMAND_STOP[] = "stop";
const char BOB_COMMAND_SETNICK[] = "setnick";
const char BOB_COMMAND_GETNICK[] = "getnick";
const char BOB_COMMAND_NEWKEYS[] = "newkeys";
const char BOB_COMMAND_GETKEYS[] = "getkeys";
const char BOB_COMMAND_SETKEYS[] = "setkeys";
const char BOB_COMMAND_GETDEST[] = "getdest";
const char BOB_COMMAND_OUTHOST[] = "outhost";
const char BOB_COMMAND_OUTPORT[] = "outport";
const char BOB_COMMAND_INHOST[] = "inhost";
const char BOB_COMMAND_INPORT[] = "inport";
const char BOB_COMMAND_QUIET[] = "quiet";
const char BOB_COMMAND_LOOKUP[] = "lookup";
const char BOB_COMMAND_LOOKUP_LOCAL[] = "lookuplocal";
const char BOB_COMMAND_CLEAR[] = "clear";
const char BOB_COMMAND_LIST[] = "list";
const char BOB_COMMAND_OPTION[] = "option";
const char BOB_COMMAND_STATUS[] = "status";
const char BOB_COMMAND_HELP[] = "help";
namespace i2p {
namespace client {
const size_t BOB_COMMAND_BUFFER_SIZE = 1024;
const char BOB_COMMAND_ZAP[] = "zap";
const char BOB_COMMAND_QUIT[] = "quit";
const char BOB_COMMAND_START[] = "start";
const char BOB_COMMAND_STOP[] = "stop";
const char BOB_COMMAND_SETNICK[] = "setnick";
const char BOB_COMMAND_GETNICK[] = "getnick";
const char BOB_COMMAND_NEWKEYS[] = "newkeys";
const char BOB_COMMAND_GETKEYS[] = "getkeys";
const char BOB_COMMAND_SETKEYS[] = "setkeys";
const char BOB_COMMAND_GETDEST[] = "getdest";
const char BOB_COMMAND_OUTHOST[] = "outhost";
const char BOB_COMMAND_OUTPORT[] = "outport";
const char BOB_COMMAND_INHOST[] = "inhost";
const char BOB_COMMAND_INPORT[] = "inport";
const char BOB_COMMAND_QUIET[] = "quiet";
const char BOB_COMMAND_LOOKUP[] = "lookup";
const char BOB_COMMAND_LOOKUP_LOCAL[] = "lookuplocal";
const char BOB_COMMAND_CLEAR[] = "clear";
const char BOB_COMMAND_LIST[] = "list";
const char BOB_COMMAND_OPTION[] = "option";
const char BOB_COMMAND_STATUS[] = "status";
const char BOB_COMMAND_HELP[] = "help";
const char BOB_HELP_ZAP[] = "zap - Shuts down BOB.";
const char BOB_HELP_QUIT[] = "quit - Quits this session with BOB.";
const char BOB_HELP_START[] = "start - Starts the current nicknamed tunnel.";
const char BOB_HELP_STOP[] = "stop - Stops the current nicknamed tunnel.";
const char BOB_HELP_SETNICK[] = "setnick <NICKNAME> - Creates a new nickname.";
const char BOB_HELP_GETNICK[] = "getnick <TUNNELNAME> - Sets the nickname from the database.";
const char BOB_HELP_NEWKEYS[] = "newkeys - Generate a new keypair for the current nickname.";
const char BOB_HELP_GETKEYS[] = "getkeys - Return the keypair for the current nickname.";
const char BOB_HELP_SETKEYS[] = "setkeys <BASE64_KEYPAIR> - Sets the keypair for the current nickname.";
const char BOB_HELP_GETDEST[] = "getdest - Return the destination for the current nickname.";
const char BOB_HELP_OUTHOST[] = "outhost <HOSTNAME|IP> - Set the outhound hostname or IP.";
const char BOB_HELP_OUTPORT[] = "outport <PORT_NUMBER> - Set the outbound port that nickname contacts.";
const char BOB_HELP_INHOST[] = "inhost <HOSTNAME|IP> - Set the inbound hostname or IP.";
const char BOB_HELP_INPORT[] = "inport <PORT_NUMBER> - Set the inbound port number nickname listens on.";
const char BOB_HELP_QUIET[] = "quiet <True|False> - Whether to send the incoming destination.";
const char BOB_HELP_LOOKUP[] = "lookup <I2P_HOSTNAME> - Look up an I2P hostname.";
const char BOB_HELP_CLEAR[] = "clear - Clear the current nickname out of the list.";
const char BOB_HELP_LIST[] = "list - List all tunnels.";
const char BOB_HELP_OPTION[] = "option <KEY>=<VALUE> - Set an option. NOTE: Don't use any spaces.";
const char BOB_HELP_STATUS[] = "status <NICKNAME> - Display status of a nicknamed tunnel.";
const char BOB_HELP_HELP [] = "help <COMMAND> - Get help on a command.";
const char BOB_HELP_ZAP[] = "zap - Shuts down BOB.";
const char BOB_HELP_QUIT[] = "quit - Quits this session with BOB.";
const char BOB_HELP_START[] = "start - Starts the current nicknamed tunnel.";
const char BOB_HELP_STOP[] = "stop - Stops the current nicknamed tunnel.";
const char BOB_HELP_SETNICK[] = "setnick <NICKNAME> - Creates a new nickname.";
const char BOB_HELP_GETNICK[] = "getnick <TUNNELNAME> - Sets the nickname from the database.";
const char BOB_HELP_NEWKEYS[] = "newkeys - Generate a new keypair for the current nickname.";
const char BOB_HELP_GETKEYS[] = "getkeys - Return the keypair for the current nickname.";
const char BOB_HELP_SETKEYS[] = "setkeys <BASE64_KEYPAIR> - Sets the keypair for the current nickname.";
const char BOB_HELP_GETDEST[] = "getdest - Return the destination for the current nickname.";
const char BOB_HELP_OUTHOST[] = "outhost <HOSTNAME|IP> - Set the outhound hostname or IP.";
const char BOB_HELP_OUTPORT[] = "outport <PORT_NUMBER> - Set the outbound port that nickname contacts.";
const char BOB_HELP_INHOST[] = "inhost <HOSTNAME|IP> - Set the inbound hostname or IP.";
const char BOB_HELP_INPORT[] = "inport <PORT_NUMBER> - Set the inbound port number nickname listens on.";
const char BOB_HELP_QUIET[] = "quiet <True|False> - Whether to send the incoming destination.";
const char BOB_HELP_LOOKUP[] = "lookup <I2P_HOSTNAME> - Look up an I2P hostname.";
const char BOB_HELP_CLEAR[] = "clear - Clear the current nickname out of the list.";
const char BOB_HELP_LIST[] = "list - List all tunnels.";
const char BOB_HELP_OPTION[] = "option <KEY>=<VALUE> - Set an option. NOTE: Don't use any spaces.";
const char BOB_HELP_STATUS[] = "status <NICKNAME> - Display status of a nicknamed tunnel.";
const char BOB_HELP_HELP[] = "help <COMMAND> - Get help on a command.";
class BOBI2PTunnel: public I2PService
{
public:
class BOBI2PTunnel : public I2PService {
public:
BOBI2PTunnel (std::shared_ptr<ClientDestination> localDestination):
I2PService (localDestination) {};
BOBI2PTunnel(std::shared_ptr <ClientDestination> localDestination) :
I2PService(localDestination) {};
virtual void Start () {};
virtual void Stop () {};
};
virtual void Start() {};
class BOBI2PInboundTunnel: public BOBI2PTunnel
{
struct AddressReceiver
{
std::shared_ptr<boost::asio::ip::tcp::socket> socket;
char buffer[BOB_COMMAND_BUFFER_SIZE + 1]; // for destination base64 address
uint8_t * data; // pointer to buffer
size_t dataLen, bufferOffset;
virtual void Stop() {};
};
AddressReceiver (): data (nullptr), dataLen (0), bufferOffset (0) {};
};
class BOBI2PInboundTunnel : public BOBI2PTunnel {
struct AddressReceiver {
std::shared_ptr <boost::asio::ip::tcp::socket> socket;
char buffer[BOB_COMMAND_BUFFER_SIZE + 1]; // for destination base64 address
uint8_t *data; // pointer to buffer
size_t dataLen, bufferOffset;
public:
AddressReceiver() : data(nullptr), dataLen(0), bufferOffset(0) {};
};
BOBI2PInboundTunnel (const boost::asio::ip::tcp::endpoint& ep, std::shared_ptr<ClientDestination> localDestination);
~BOBI2PInboundTunnel ();
public:
void Start ();
void Stop ();
BOBI2PInboundTunnel(const boost::asio::ip::tcp::endpoint &ep,
std::shared_ptr <ClientDestination> localDestination);
private:
~BOBI2PInboundTunnel();
void Accept ();
void HandleAccept (const boost::system::error_code& ecode, std::shared_ptr<AddressReceiver> receiver);
void Start();
void ReceiveAddress (std::shared_ptr<AddressReceiver> receiver);
void HandleReceivedAddress (const boost::system::error_code& ecode, std::size_t bytes_transferred,
std::shared_ptr<AddressReceiver> receiver);
void Stop();
void HandleDestinationRequestComplete (std::shared_ptr<i2p::data::LeaseSet> leaseSet, std::shared_ptr<AddressReceiver> receiver);
private:
void CreateConnection (std::shared_ptr<AddressReceiver> receiver, std::shared_ptr<const i2p::data::LeaseSet> leaseSet);
void Accept();
private:
void HandleAccept(const boost::system::error_code &ecode, std::shared_ptr <AddressReceiver> receiver);
boost::asio::ip::tcp::acceptor m_Acceptor;
};
void ReceiveAddress(std::shared_ptr <AddressReceiver> receiver);
class BOBI2POutboundTunnel: public BOBI2PTunnel
{
public:
void HandleReceivedAddress(const boost::system::error_code &ecode, std::size_t bytes_transferred,
std::shared_ptr <AddressReceiver> receiver);
BOBI2POutboundTunnel (const std::string& outhost, int port, std::shared_ptr<ClientDestination> localDestination, bool quiet);
void HandleDestinationRequestComplete(std::shared_ptr <i2p::data::LeaseSet> leaseSet,
std::shared_ptr <AddressReceiver> receiver);
void Start ();
void Stop ();
void CreateConnection(std::shared_ptr <AddressReceiver> receiver,
std::shared_ptr<const i2p::data::LeaseSet> leaseSet);
void SetQuiet () { m_IsQuiet = true; };
private:
private:
boost::asio::ip::tcp::acceptor m_Acceptor;
};
void Accept ();
void HandleAccept (std::shared_ptr<i2p::stream::Stream> stream);
class BOBI2POutboundTunnel : public BOBI2PTunnel {
public:
private:
BOBI2POutboundTunnel(const std::string &outhost, int port,
std::shared_ptr <ClientDestination> localDestination, bool quiet);
boost::asio::ip::tcp::endpoint m_Endpoint;
bool m_IsQuiet;
};
void Start();
void Stop();
void SetQuiet() { m_IsQuiet = true; };
private:
void Accept();
void HandleAccept(std::shared_ptr <i2p::stream::Stream> stream);
private:
boost::asio::ip::tcp::endpoint m_Endpoint;
bool m_IsQuiet;
};
class BOBDestination
{
public:
class BOBDestination {
public:
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);
~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);
void Start ();
void Stop ();
void StopTunnels ();
void CreateInboundTunnel (int port, const std::string& inhost);
void CreateOutboundTunnel (const std::string& outhost, int port, bool quiet);
const std::string& GetNickname() const { return m_Nickname; }
const std::string& GetInHost() const { return m_InHost; }
const std::string& GetOutHost() const { return m_OutHost; }
int GetInPort() const { return m_InPort; }
int GetOutPort() const { return m_OutPort; }
bool GetQuiet() const { return m_Quiet; }
bool IsRunning() const { return m_IsRunning; }
const i2p::data::PrivateKeys& GetKeys () const { return m_LocalDestination->GetPrivateKeys (); };
std::shared_ptr<ClientDestination> GetLocalDestination () const { return m_LocalDestination; };
~BOBDestination();
private:
void Start();
std::shared_ptr<ClientDestination> m_LocalDestination;
BOBI2POutboundTunnel * m_OutboundTunnel;
BOBI2PInboundTunnel * m_InboundTunnel;
void Stop();
std::string m_Nickname;
std::string m_InHost, m_OutHost;
int m_InPort, m_OutPort;
bool m_Quiet;
bool m_IsRunning;
};
void StopTunnels();
class BOBCommandChannel;
class BOBCommandSession: public std::enable_shared_from_this<BOBCommandSession>
{
public:
void CreateInboundTunnel(int port, const std::string &inhost);
BOBCommandSession (BOBCommandChannel& owner);
~BOBCommandSession ();
void Terminate ();
void CreateOutboundTunnel(const std::string &outhost, int port, bool quiet);
boost::asio::ip::tcp::socket& GetSocket () { return m_Socket; };
void SendVersion ();
const std::string &GetNickname() const { return m_Nickname; }
// command handlers
void ZapCommandHandler (const char * operand, size_t len);
void QuitCommandHandler (const char * operand, size_t len);
void StartCommandHandler (const char * operand, size_t len);
void StopCommandHandler (const char * operand, size_t len);
void SetNickCommandHandler (const char * operand, size_t len);
void GetNickCommandHandler (const char * operand, size_t len);
void NewkeysCommandHandler (const char * operand, size_t len);
void SetkeysCommandHandler (const char * operand, size_t len);
void GetkeysCommandHandler (const char * operand, size_t len);
void GetdestCommandHandler (const char * operand, size_t len);
void OuthostCommandHandler (const char * operand, size_t len);
void OutportCommandHandler (const char * operand, size_t len);
void InhostCommandHandler (const char * operand, size_t len);
void InportCommandHandler (const char * operand, size_t len);
void QuietCommandHandler (const char * operand, size_t len);
void LookupCommandHandler (const char * operand, size_t len);
void LookupLocalCommandHandler (const char * operand, size_t len);
void ClearCommandHandler (const char * operand, size_t len);
void ListCommandHandler (const char * operand, size_t len);
void OptionCommandHandler (const char * operand, size_t len);
void StatusCommandHandler (const char * operand, size_t len);
void HelpCommandHandler (const char * operand, size_t len);
const std::string &GetInHost() const { return m_InHost; }
private:
const std::string &GetOutHost() const { return m_OutHost; }
void Receive ();
void HandleReceivedLine(const boost::system::error_code& ecode, std::size_t bytes_transferred);
void HandleReceived (const boost::system::error_code& ecode, std::size_t bytes_transferred);
int GetInPort() const { return m_InPort; }
void Send ();
void HandleSent (const boost::system::error_code& ecode, std::size_t bytes_transferred);
void SendReplyOK (const char * msg = nullptr);
void SendReplyError (const char * msg);
void SendRaw (const char * data);
int GetOutPort() const { return m_OutPort; }
void BuildStatusLine(bool currentTunnel, BOBDestination *destination, std::string &out);
bool GetQuiet() const { return m_Quiet; }
private:
bool IsRunning() const { return m_IsRunning; }
BOBCommandChannel& m_Owner;
boost::asio::ip::tcp::socket m_Socket;
boost::asio::streambuf m_ReceiveBuffer, m_SendBuffer;
bool m_IsOpen, m_IsQuiet, m_IsActive;
std::string m_Nickname, m_InHost, m_OutHost;
int m_InPort, m_OutPort;
i2p::data::PrivateKeys m_Keys;
std::map<std::string, std::string> m_Options;
BOBDestination * m_CurrentDestination;
};
typedef void (BOBCommandSession::*BOBCommandHandler)(const char * operand, size_t len);
const i2p::data::PrivateKeys &GetKeys() const { return m_LocalDestination->GetPrivateKeys(); };
class BOBCommandChannel: private i2p::util::RunnableService
{
public:
std::shared_ptr <ClientDestination> GetLocalDestination() const { return m_LocalDestination; };
BOBCommandChannel (const std::string& address, int port);
~BOBCommandChannel ();
private:
void Start ();
void Stop ();
std::shared_ptr <ClientDestination> m_LocalDestination;
BOBI2POutboundTunnel *m_OutboundTunnel;
BOBI2PInboundTunnel *m_InboundTunnel;
boost::asio::io_service& GetService () { return GetIOService (); };
void AddDestination (const std::string& name, BOBDestination * dest);
void DeleteDestination (const std::string& name);
BOBDestination * FindDestination (const std::string& name);
std::string m_Nickname;
std::string m_InHost, m_OutHost;
int m_InPort, m_OutPort;
bool m_Quiet;
bool m_IsRunning;
};
private:
class BOBCommandChannel;
void Accept ();
void HandleAccept(const boost::system::error_code& ecode, std::shared_ptr<BOBCommandSession> session);
class BOBCommandSession : public std::enable_shared_from_this<BOBCommandSession> {
public:
private:
BOBCommandSession(BOBCommandChannel &owner);
boost::asio::ip::tcp::acceptor m_Acceptor;
std::map<std::string, BOBDestination *> m_Destinations;
std::map<std::string, BOBCommandHandler> m_CommandHandlers;
std::map<std::string, std::string> m_HelpStrings;
~BOBCommandSession();
public:
void Terminate();
const decltype(m_CommandHandlers)& GetCommandHandlers () const { return m_CommandHandlers; };
const decltype(m_HelpStrings)& GetHelpStrings () const { return m_HelpStrings; };
const decltype(m_Destinations)& GetDestinations () const { return m_Destinations; };
};
}
boost::asio::ip::tcp::socket &GetSocket() { return m_Socket; };
void SendVersion();
// command handlers
void ZapCommandHandler(const char *operand, size_t len);
void QuitCommandHandler(const char *operand, size_t len);
void StartCommandHandler(const char *operand, size_t len);
void StopCommandHandler(const char *operand, size_t len);
void SetNickCommandHandler(const char *operand, size_t len);
void GetNickCommandHandler(const char *operand, size_t len);
void NewkeysCommandHandler(const char *operand, size_t len);
void SetkeysCommandHandler(const char *operand, size_t len);
void GetkeysCommandHandler(const char *operand, size_t len);
void GetdestCommandHandler(const char *operand, size_t len);
void OuthostCommandHandler(const char *operand, size_t len);
void OutportCommandHandler(const char *operand, size_t len);
void InhostCommandHandler(const char *operand, size_t len);
void InportCommandHandler(const char *operand, size_t len);
void QuietCommandHandler(const char *operand, size_t len);
void LookupCommandHandler(const char *operand, size_t len);
void LookupLocalCommandHandler(const char *operand, size_t len);
void ClearCommandHandler(const char *operand, size_t len);
void ListCommandHandler(const char *operand, size_t len);
void OptionCommandHandler(const char *operand, size_t len);
void StatusCommandHandler(const char *operand, size_t len);
void HelpCommandHandler(const char *operand, size_t len);
private:
void Receive();
void HandleReceivedLine(const boost::system::error_code &ecode, std::size_t bytes_transferred);
void HandleReceived(const boost::system::error_code &ecode, std::size_t bytes_transferred);
void Send();
void HandleSent(const boost::system::error_code &ecode, std::size_t bytes_transferred);
void SendReplyOK(const char *msg = nullptr);
void SendReplyError(const char *msg);
void SendRaw(const char *data);
void BuildStatusLine(bool currentTunnel, BOBDestination *destination, std::string &out);
private:
BOBCommandChannel &m_Owner;
boost::asio::ip::tcp::socket m_Socket;
boost::asio::streambuf m_ReceiveBuffer, m_SendBuffer;
bool m_IsOpen, m_IsQuiet, m_IsActive;
std::string m_Nickname, m_InHost, m_OutHost;
int m_InPort, m_OutPort;
i2p::data::PrivateKeys m_Keys;
std::map <std::string, std::string> m_Options;
BOBDestination *m_CurrentDestination;
};
typedef void (BOBCommandSession::*BOBCommandHandler)(const char *operand, size_t len);
class BOBCommandChannel : private i2p::util::RunnableService {
public:
BOBCommandChannel(const std::string &address, int port);
~BOBCommandChannel();
void Start();
void Stop();
boost::asio::io_service &GetService() { return GetIOService(); };
void AddDestination(const std::string &name, BOBDestination *dest);
void DeleteDestination(const std::string &name);
BOBDestination *FindDestination(const std::string &name);
private:
void Accept();
void HandleAccept(const boost::system::error_code &ecode, std::shared_ptr <BOBCommandSession> session);
private:
boost::asio::ip::tcp::acceptor m_Acceptor;
std::map<std::string, BOBDestination *> m_Destinations;
std::map <std::string, BOBCommandHandler> m_CommandHandlers;
std::map <std::string, std::string> m_HelpStrings;
public:
const decltype(m_CommandHandlers)
&
GetCommandHandlers() const { return m_CommandHandlers; };
const decltype(m_HelpStrings)
&
GetHelpStrings() const { return m_HelpStrings; };
const decltype(m_Destinations)
&
GetDestinations() const { return m_Destinations; };
};
}
}
#endif