i2pd/BOB.h

238 lines
7.3 KiB
C
Raw Normal View History

2014-12-02 15:34:02 +00:00
#ifndef BOB_H__
#define BOB_H__
2014-12-02 20:47:44 +00:00
#include <inttypes.h>
2014-12-02 16:42:35 +00:00
#include <thread>
#include <memory>
2014-12-02 20:47:44 +00:00
#include <map>
#include <string>
2014-12-02 16:42:35 +00:00
#include <boost/asio.hpp>
2014-12-02 20:47:44 +00:00
#include "I2PTunnel.h"
#include "I2PService.h"
2014-12-03 02:45:01 +00:00
#include "Identity.h"
2014-12-03 19:48:41 +00:00
#include "LeaseSet.h"
2014-12-02 16:42:35 +00:00
2014-12-02 15:34:02 +00:00
namespace i2p
{
namespace client
{
2014-12-02 20:47:44 +00:00
const size_t BOB_COMMAND_BUFFER_SIZE = 1024;
const char BOB_COMMAND_ZAP[] = "zap";
2014-12-03 02:45:01 +00:00
const char BOB_COMMAND_QUIT[] = "quit";
const char BOB_COMMAND_START[] = "start";
2014-12-03 20:24:30 +00:00
const char BOB_COMMAND_STOP[] = "stop";
const char BOB_COMMAND_SETNICK[] = "setnick";
const char BOB_COMMAND_GETNICK[] = "getnick";
2014-12-04 02:01:40 +00:00
const char BOB_COMMAND_NEWKEYS[] = "newkeys";
const char BOB_COMMAND_GETKEYS[] = "getkeys";
const char BOB_COMMAND_SETKEYS[] = "setkeys";
const char BOB_COMMAND_GETDEST[] = "getdest";
2014-12-03 02:45:01 +00:00
const char BOB_COMMAND_OUTHOST[] = "outhost";
const char BOB_COMMAND_OUTPORT[] = "outport";
2014-12-03 20:02:19 +00:00
const char BOB_COMMAND_INHOST[] = "inhost";
const char BOB_COMMAND_INPORT[] = "inport";
2014-12-05 21:03:43 +00:00
const char BOB_COMMAND_QUIET[] = "quiet";
2014-12-06 00:16:54 +00:00
const char BOB_COMMAND_LOOKUP[] = "lookup";
2014-12-06 03:25:31 +00:00
const char BOB_COMMAND_CLEAR[] = "clear";
const char BOB_COMMAND_LIST[] = "list";
const char BOB_COMMAND_OPTION[] = "option";
2014-12-05 21:03:43 +00:00
const char BOB_VERSION[] = "BOB 00.00.10\nOK\n";
2014-12-02 21:45:51 +00:00
const char BOB_REPLY_OK[] = "OK %s\n";
const char BOB_REPLY_ERROR[] = "ERROR %s\n";
2014-12-06 03:25:31 +00:00
const char BOB_DATA[] = "NICKNAME %s\n";
class BOBI2PTunnel: public I2PService
2014-12-06 03:25:31 +00:00
{
public:
2015-02-24 20:40:50 +00:00
BOBI2PTunnel (std::shared_ptr<ClientDestination> localDestination):
I2PService (localDestination) {};
2014-12-02 20:47:44 +00:00
2014-12-06 03:25:31 +00:00
virtual void Start () {};
virtual void Stop () {};
};
class BOBI2PInboundTunnel: public BOBI2PTunnel
2014-12-03 19:48:41 +00:00
{
2014-12-07 14:48:03 +00:00
struct AddressReceiver
{
std::shared_ptr<boost::asio::ip::tcp::socket> socket;
2014-12-07 14:48:03 +00:00
char buffer[BOB_COMMAND_BUFFER_SIZE + 1]; // for destination base64 address
2015-04-06 19:02:37 +00:00
uint8_t * data; // pointer to buffer
2014-12-07 14:48:03 +00:00
size_t dataLen, bufferOffset;
AddressReceiver (): data (nullptr), dataLen (0), bufferOffset (0) {};
};
2014-12-03 19:48:41 +00:00
public:
2015-02-24 20:40:50 +00:00
BOBI2PInboundTunnel (int port, std::shared_ptr<ClientDestination> localDestination);
2014-12-03 19:48:41 +00:00
~BOBI2PInboundTunnel ();
void Start ();
void Stop ();
private:
void Accept ();
2015-04-06 19:02:37 +00:00
void HandleAccept (const boost::system::error_code& ecode, std::shared_ptr<AddressReceiver> receiver);
2014-12-03 19:48:41 +00:00
2015-04-06 19:02:37 +00:00
void ReceiveAddress (std::shared_ptr<AddressReceiver> receiver);
2014-12-03 19:48:41 +00:00
void HandleReceivedAddress (const boost::system::error_code& ecode, std::size_t bytes_transferred,
2015-04-06 19:02:37 +00:00
std::shared_ptr<AddressReceiver> receiver);
2014-12-03 19:48:41 +00:00
void HandleDestinationRequestComplete (std::shared_ptr<i2p::data::LeaseSet> leaseSet, std::shared_ptr<AddressReceiver> receiver);
2014-12-03 19:48:41 +00:00
2015-04-06 19:02:37 +00:00
void CreateConnection (std::shared_ptr<AddressReceiver> receiver, std::shared_ptr<const i2p::data::LeaseSet> leaseSet);
2014-12-03 19:48:41 +00:00
private:
boost::asio::ip::tcp::acceptor m_Acceptor;
};
2014-12-06 03:25:31 +00:00
class BOBI2POutboundTunnel: public BOBI2PTunnel
2014-12-05 19:13:16 +00:00
{
public:
2015-02-24 20:40:50 +00:00
BOBI2POutboundTunnel (const std::string& address, int port, std::shared_ptr<ClientDestination> localDestination, bool quiet);
2014-12-05 19:13:16 +00:00
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:
2015-02-24 20:40:50 +00:00
BOBDestination (std::shared_ptr<ClientDestination> localDestination);
~BOBDestination ();
void Start ();
void Stop ();
2014-12-08 02:04:02 +00:00
void StopTunnels ();
void CreateInboundTunnel (int port);
void CreateOutboundTunnel (const std::string& address, int port, bool quiet);
2015-02-24 20:40:50 +00:00
const i2p::data::PrivateKeys& GetKeys () const { return m_LocalDestination->GetPrivateKeys (); };
std::shared_ptr<ClientDestination> GetLocalDestination () const { return m_LocalDestination; };
private:
2015-02-24 20:40:50 +00:00
std::shared_ptr<ClientDestination> m_LocalDestination;
BOBI2POutboundTunnel * m_OutboundTunnel;
BOBI2PInboundTunnel * m_InboundTunnel;
};
2014-12-02 20:47:44 +00:00
class BOBCommandChannel;
class BOBCommandSession: public std::enable_shared_from_this<BOBCommandSession>
2014-12-02 16:42:35 +00:00
{
public:
2014-12-02 20:47:44 +00:00
BOBCommandSession (BOBCommandChannel& owner);
~BOBCommandSession ();
2014-12-02 21:45:51 +00:00
void Terminate ();
2014-12-02 20:47:44 +00:00
boost::asio::ip::tcp::socket& GetSocket () { return m_Socket; };
2014-12-05 21:03:43 +00:00
void SendVersion ();
2014-12-02 20:47:44 +00:00
// command handlers
void ZapCommandHandler (const char * operand, size_t len);
2014-12-02 21:45:51 +00:00
void QuitCommandHandler (const char * operand, size_t len);
2014-12-03 02:45:01 +00:00
void StartCommandHandler (const char * operand, size_t len);
2014-12-03 20:24:30 +00:00
void StopCommandHandler (const char * operand, size_t len);
2014-12-03 02:45:01 +00:00
void SetNickCommandHandler (const char * operand, size_t len);
2014-12-03 20:24:30 +00:00
void GetNickCommandHandler (const char * operand, size_t len);
2014-12-03 02:45:01 +00:00
void NewkeysCommandHandler (const char * operand, size_t len);
2014-12-04 02:01:40 +00:00
void SetkeysCommandHandler (const char * operand, size_t len);
void GetkeysCommandHandler (const char * operand, size_t len);
void GetdestCommandHandler (const char * operand, size_t len);
2014-12-03 02:45:01 +00:00
void OuthostCommandHandler (const char * operand, size_t len);
void OutportCommandHandler (const char * operand, size_t len);
2014-12-03 20:02:19 +00:00
void InhostCommandHandler (const char * operand, size_t len);
void InportCommandHandler (const char * operand, size_t len);
2014-12-05 19:13:16 +00:00
void QuietCommandHandler (const char * operand, size_t len);
2014-12-05 21:03:43 +00:00
void LookupCommandHandler (const char * operand, size_t len);
2014-12-06 00:16:54 +00:00
void ClearCommandHandler (const char * operand, size_t len);
2014-12-06 03:25:31 +00:00
void ListCommandHandler (const char * operand, size_t len);
void OptionCommandHandler (const char * operand, size_t len);
2014-12-06 00:16:54 +00:00
2014-12-02 21:45:51 +00:00
private:
2014-12-05 21:03:43 +00:00
void Receive ();
2014-12-02 21:45:51 +00:00
void HandleReceived (const boost::system::error_code& ecode, std::size_t bytes_transferred);
void Send (size_t len);
void HandleSent (const boost::system::error_code& ecode, std::size_t bytes_transferred);
void SendReplyOK (const char * msg);
void SendReplyError (const char * msg);
2014-12-06 03:25:31 +00:00
void SendData (const char * nickname);
2014-12-05 21:03:43 +00:00
2014-12-02 16:42:35 +00:00
private:
2014-12-02 20:47:44 +00:00
BOBCommandChannel& m_Owner;
boost::asio::ip::tcp::socket m_Socket;
2014-12-02 21:45:51 +00:00
char m_ReceiveBuffer[BOB_COMMAND_BUFFER_SIZE + 1], m_SendBuffer[BOB_COMMAND_BUFFER_SIZE + 1];
2014-12-02 20:47:44 +00:00
size_t m_ReceiveBufferOffset;
bool m_IsOpen, m_IsQuiet;
2014-12-03 02:45:01 +00:00
std::string m_Nickname, m_Address;
int m_InPort, m_OutPort;
2014-12-03 02:45:01 +00:00
i2p::data::PrivateKeys m_Keys;
2014-12-06 20:31:39 +00:00
std::map<std::string, std::string> m_Options;
2014-12-08 02:04:02 +00:00
BOBDestination * m_CurrentDestination;
2014-12-02 20:47:44 +00:00
};
typedef void (BOBCommandSession::*BOBCommandHandler)(const char * operand, size_t len);
2014-12-02 15:34:02 +00:00
class BOBCommandChannel
{
public:
BOBCommandChannel (int port);
~BOBCommandChannel ();
2014-12-02 16:42:35 +00:00
void Start ();
void Stop ();
2014-12-02 20:47:44 +00:00
boost::asio::io_service& GetService () { return m_Service; };
void AddDestination (const std::string& name, BOBDestination * dest);
2014-12-08 02:04:02 +00:00
void DeleteDestination (const std::string& name);
BOBDestination * FindDestination (const std::string& name);
2014-12-03 02:45:01 +00:00
2014-12-02 16:42:35 +00:00
private:
void Run ();
void Accept ();
2014-12-02 20:47:44 +00:00
void HandleAccept(const boost::system::error_code& ecode, std::shared_ptr<BOBCommandSession> session);
2014-12-02 16:42:35 +00:00
private:
bool m_IsRunning;
std::thread * m_Thread;
boost::asio::io_service m_Service;
boost::asio::ip::tcp::acceptor m_Acceptor;
std::map<std::string, BOBDestination *> m_Destinations;
2014-12-02 20:47:44 +00:00
std::map<std::string, BOBCommandHandler> m_CommandHandlers;
2014-12-06 03:25:31 +00:00
public:
const decltype(m_CommandHandlers)& GetCommandHandlers () const { return m_CommandHandlers; };
const decltype(m_Destinations)& GetDestinations () const { return m_Destinations; };
2014-12-02 15:34:02 +00:00
};
}
}
#endif