PurpleI2P
/
i2pd
mirror of https://github.com/PurpleI2P/i2pd.git
1
0
Fork 0
Code Issues Releases Activity
Browse Source

Reduce the parsing to a single state machine, automatic removal of objects and destruction of sockets/streams

pull/136/head
Francisco Blas (klondike) Izquierdo Riera 10 years ago
parent
610fd2ac67
commit
882b559d3a
2 changed files with 199 additions and 261 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 390
      SOCKS.cpp
  2. 70
      SOCKS.h

390
SOCKS.cpp
Unescape View File

@ -23,28 +23,33 @@ namespace proxy @@ -23,28 +23,33 @@ namespace proxy
}
}
void SOCKSHandler::Terminate() {
CloseStream();
CloseSock();
delete this; // HACK: ew
void SOCKSHandler::Done() {
if (m_parent) m_parent->RemoveHandler (shared_from_this ());
}
boost::asio::const_buffers_1 SOCKSHandler::GenerateSOCKS5SelectAuth(SOCKSHandler::authMethods method)
{
response[0] = '\x05'; //Version
response[1] = method; //Response code
return boost::asio::const_buffers_1(response,2);
void SOCKSHandler::Terminate() {
if (dead.exchange(true)) return;
if (m_sock) {
LogPrint(eLogDebug,"--- SOCKS close sock");
m_sock->close();
delete m_sock;
m_sock = nullptr;
}
if (m_stream) {
LogPrint(eLogDebug,"--- SOCKS close stream");
m_stream.reset ();
}
Done();
}
boost::asio::const_buffers_1 SOCKSHandler::GenerateSOCKS4Response(SOCKSHandler::errTypes error, uint32_t ip, uint16_t port)
{
assert(error >= SOCKS4_OK);
assert(type == ADDR_IPV4);
response[0] = '\x00'; //Version
response[1] = error; //Response code
htobe16buf(response+2,port); //Port
htobe32buf(response+4,ip); //IP
return boost::asio::const_buffers_1(response,8);
m_response[0] = '\x00'; //Version
m_response[1] = error; //Response code
htobe16buf(m_response+2,port); //Port
htobe32buf(m_response+4,ip); //IP
return boost::asio::const_buffers_1(m_response,8);
}
boost::asio::const_buffers_1 SOCKSHandler::GenerateSOCKS5Response(SOCKSHandler::errTypes error, SOCKSHandler::addrTypes type,
@ -52,42 +57,43 @@ namespace proxy @@ -52,42 +57,43 @@ namespace proxy
{
size_t size;
assert(error <= SOCKS5_ADDR_UNSUP);
response[0] = '\x05'; //Version
response[1] = error; //Response code
response[2] = '\x00'; //RSV
response[3] = type; //Address type
m_response[0] = '\x05'; //Version
m_response[1] = error; //Response code
m_response[2] = '\x00'; //RSV
m_response[3] = type; //Address type
switch (type) {
case ADDR_IPV4:
size = 10;
htobe32buf(response+4,addr.ip);
htobe32buf(m_response+4,addr.ip);
break;
case ADDR_IPV6:
size = 22;
memcpy(response+4,addr.ipv6, 16);
memcpy(m_response+4,addr.ipv6, 16);
break;
case ADDR_DNS:
size = 7+addr.dns.size;
response[4] = addr.dns.size;
memcpy(response+5,addr.dns.value, addr.dns.size);
m_response[4] = addr.dns.size;
memcpy(m_response+5,addr.dns.value, addr.dns.size);
break;
}
htobe16buf(response+size-2,port); //Port
return boost::asio::const_buffers_1(response,size);
htobe16buf(m_response+size-2,port); //Port
return boost::asio::const_buffers_1(m_response,size);
}
/* Ah ah ah, you didn't say the magic word */
void SOCKSHandler::Socks5AuthNegoFailed()
bool SOCKSHandler::Socks5ChooseAuth()
{
LogPrint(eLogWarning,"--- SOCKS5 authentication negotiation failed");
boost::asio::async_write(*m_sock, GenerateSOCKS5SelectAuth(AUTH_UNACCEPTABLE),
std::bind(&SOCKSHandler::SentSocksFailed, this, std::placeholders::_1));
}
void SOCKSHandler::Socks5ChooseAuth()
{
LogPrint(eLogDebug,"--- SOCKS5 choosing authentication method: ", m_authchosen);
boost::asio::async_write(*m_sock, GenerateSOCKS5SelectAuth(m_authchosen),
std::bind(&SOCKSHandler::SentSocksResponse, this, std::placeholders::_1));
m_response[0] = '\x05'; //Version
m_response[1] = m_authchosen; //Response code
boost::asio::const_buffers_1 response(m_response,2);
if (m_authchosen == AUTH_UNACCEPTABLE) {
LogPrint(eLogWarning,"--- SOCKS5 authentication negotiation failed");
boost::asio::async_write(*m_sock, response, std::bind(&SOCKSHandler::SentSocksFailed, this, std::placeholders::_1));
return false;
} else {
LogPrint(eLogDebug,"--- SOCKS5 choosing authentication method: ", m_authchosen);
boost::asio::async_write(*m_sock, response, std::bind(&SOCKSHandler::SentSocksResponse, this, std::placeholders::_1));
return true;
}
}
/* All hope is lost beyond this point */
@ -123,114 +129,32 @@ namespace proxy @@ -123,114 +129,32 @@ namespace proxy
auto s = i2p::client::context.GetAddressBook().ToAddress(m_parent->GetLocalDestination()->GetIdentHash());
address ad; ad.dns.FromString(s);
//HACK only 16 bits passed in port as SOCKS5 doesn't allow for more
response = GenerateSOCKS5Response(SOCKS5_OK, ADDR_DNS, ad, m_stream->GetSendStreamID());
break;
}
boost::asio::async_write(*m_sock, response, std::bind(&SOCKSHandler::SentSocksResponse, this, std::placeholders::_1));
}
void SOCKSHandler::CloseSock()
{
if (m_sock) {
LogPrint(eLogDebug,"--- SOCKS close sock");
m_sock->close();
delete m_sock;
m_sock = nullptr;
}
}
void SOCKSHandler::CloseStream()
{
if (m_stream) {
LogPrint(eLogDebug,"--- SOCKS close stream");
m_stream.reset ();
}
}
std::size_t SOCKSHandler::HandleData(uint8_t *sock_buff, std::size_t len)
{
assert(len); // This should always be called with a least a byte left to parse
switch (m_state) {
case GET_VERSION:
return HandleVersion(sock_buff);
case SOCKS5_AUTHNEGO:
return HandleSOCKS5AuthNego(sock_buff,len);
case SOCKS_REQUEST:
return HandleSOCKSRequest(sock_buff,len);
default:
LogPrint(eLogError,"--- SOCKS state?? ", m_state);
Terminate();
return 0;
}
}
std::size_t SOCKSHandler::HandleVersion(uint8_t *sock_buff)
{
switch (*sock_buff) {
case SOCKS4:
m_state = SOCKS_REQUEST; // Switch to the 4 handler
m_pstate = GET_COMMAND; //Initialize the parser at the right position
response = GenerateSOCKS5Response(SOCKS5_OK, ADDR_DNS, ad, m_stream->GetRecvStreamID());
break;
case SOCKS5:
m_state = SOCKS5_AUTHNEGO; // Switch to the 5 handler
m_pstate = GET5_AUTHNUM; //Initialize the parser at the right position
break;
default:
LogPrint(eLogError,"--- SOCKS rejected invalid version: ", ((int)*sock_buff));
Terminate();
return 0;
}
m_socksv = (SOCKSHandler::socksVersions) *sock_buff;
return 1;
boost::asio::async_write(*m_sock, response, std::bind(&SOCKSHandler::SentSocksDone, this, std::placeholders::_1));
}
std::size_t SOCKSHandler::HandleSOCKS5AuthNego(uint8_t *sock_buff, std::size_t len)
{
std::size_t rv = 0;
while (len > 0) {
rv++;
switch (m_pstate)
{
case GET5_AUTHNUM:
m_parseleft = *sock_buff;
m_pstate = GET5_AUTH;
break;
case GET5_AUTH:
m_parseleft --;
if (*sock_buff == AUTH_NONE)
m_authchosen = AUTH_NONE;
if ( m_parseleft == 0 ) {
if (m_authchosen == AUTH_UNACCEPTABLE) {
//TODO: we maybe want support for other methods!
LogPrint(eLogError,"--- SOCKS5 couldn't negotiate authentication");
Socks5AuthNegoFailed();
return 0;
}
m_pstate = GET5_REQUESTV;
m_state = SOCKS_REQUEST;
m_need_more = false;
Socks5ChooseAuth();
return rv;
}
break;
default:
LogPrint(eLogError,"--- SOCKS5 parse state?? ", m_pstate);
Terminate();
return 0;
}
sock_buff++;
len--;
void SOCKSHandler::EnterState(SOCKSHandler::state nstate, uint8_t parseleft) {
switch (nstate) {
case GET_PORT: parseleft = 2; break;
case GET_IPV4: m_addrtype = ADDR_IPV4; m_address.ip = 0; parseleft = 4; break;
case GET4_IDENT: m_4aip = m_address.ip; break;
case GET4A_HOST:
case GET5_HOST: m_addrtype = ADDR_DNS; m_address.dns.size = 0; break;
case GET5_IPV6: m_addrtype = ADDR_IPV6; parseleft = 16; break;
default:;
}
return rv;
m_parseleft = parseleft;
m_state = nstate;
}
bool SOCKSHandler::ValidateSOCKSRequest() {
void SOCKSHandler::ValidateSOCKSRequest() {
if ( m_cmd != CMD_CONNECT ) {
//TODO: we need to support binds and other shit!
LogPrint(eLogError,"--- SOCKS unsupported command: ", m_cmd);
SocksRequestFailed(SOCKS5_CMD_UNSUP);
return false;
return;
}
//TODO: we may want to support other address types!
if ( m_addrtype != ADDR_DNS ) {
@ -243,24 +167,48 @@ namespace proxy @@ -243,24 +167,48 @@ namespace proxy
break;
}
SocksRequestFailed(SOCKS5_ADDR_UNSUP);
return false;
return;
}
//TODO: we may want to support other domains
if(m_addrtype == ADDR_DNS && m_address.dns.ToString().find(".i2p") == std::string::npos) {
LogPrint(eLogError,"--- SOCKS invalid hostname: ", m_address.dns.ToString());
SocksRequestFailed(SOCKS5_ADDR_UNSUP);
return false;
return;
}
return true;
}
std::size_t SOCKSHandler::HandleSOCKSRequest(uint8_t *sock_buff, std::size_t len)
bool SOCKSHandler::HandleData(uint8_t *sock_buff, std::size_t len)
{
std::size_t rv = 0;
assert(len); // This should always be called with a least a byte left to parse
while (len > 0) {
rv++;
switch (m_pstate)
{
switch (m_state) {
case GET_SOCKSV:
m_socksv = (SOCKSHandler::socksVersions) *sock_buff;
switch (*sock_buff) {
case SOCKS4:
EnterState(GET_COMMAND); //Initialize the parser at the right position
break;
case SOCKS5:
EnterState(GET5_AUTHNUM); //Initialize the parser at the right position
break;
default:
LogPrint(eLogError,"--- SOCKS rejected invalid version: ", ((int)*sock_buff));
Terminate();
return false;
}
break;
case GET5_AUTHNUM:
EnterState(GET5_AUTH, *sock_buff);
break;
case GET5_AUTH:
m_parseleft --;
if (*sock_buff == AUTH_NONE)
m_authchosen = AUTH_NONE;
if ( m_parseleft == 0 ) {
if (!Socks5ChooseAuth()) return false;
EnterState(GET5_REQUESTV);
}
break;
case GET_COMMAND:
switch (*sock_buff) {
case CMD_CONNECT:
@ -271,12 +219,12 @@ namespace proxy @@ -271,12 +219,12 @@ namespace proxy
default:
LogPrint(eLogError,"--- SOCKS invalid command: ", ((int)*sock_buff));
SocksRequestFailed(SOCKS5_GEN_FAIL);
return 0;
return false;
}
m_cmd = (SOCKSHandler::cmdTypes)*sock_buff;
switch (m_socksv) {
case SOCKS5: m_pstate = GET5_GETRSV; break;
case SOCKS4: m_pstate = GET_PORT; m_parseleft = 2; break;
case SOCKS5: EnterState(GET5_GETRSV); break;
case SOCKS4: EnterState(GET_PORT); break;
}
break;
case GET_PORT:
@ -284,8 +232,8 @@ namespace proxy @@ -284,8 +232,8 @@ namespace proxy
m_parseleft--;
if (m_parseleft == 0) {
switch (m_socksv) {
case SOCKS5: m_pstate = DONE; break;
case SOCKS4: m_pstate = GET_IPV4; m_address.ip = 0; m_parseleft = 4; break;
case SOCKS5: EnterState(DONE); break;
case SOCKS4: EnterState(GET_IPV4); break;
}
}
break;
@ -294,32 +242,29 @@ namespace proxy @@ -294,32 +242,29 @@ namespace proxy
m_parseleft--;
if (m_parseleft == 0) {
switch (m_socksv) {
case SOCKS5: m_pstate = GET_PORT; m_parseleft = 2; break;
case SOCKS4: m_pstate = GET4_IDENT; m_4aip = m_address.ip; break;
case SOCKS5: EnterState(GET_PORT); break;
case SOCKS4: EnterState(GET4_IDENT); m_4aip = m_address.ip; break;
}
}
break;
case GET4_IDENT:
if (!*sock_buff) {
if( m_4aip == 0 || m_4aip > 255 ) {
m_addrtype = ADDR_IPV4;
m_pstate = DONE;
EnterState(DONE);
} else {
m_addrtype = ADDR_DNS;
m_pstate = GET4A_HOST;
m_address.dns.size = 0;
EnterState(GET4A_HOST);
}
}
break;
case GET4A_HOST:
if (!*sock_buff) {
m_pstate = DONE;
EnterState(DONE);
break;
}
if (m_address.dns.size >= max_socks_hostname_size) {
LogPrint(eLogError,"--- SOCKS4a destination is too large");
SocksRequestFailed(SOCKS4_FAIL);
return 0;
return false;
}
m_address.dns.push_back(*sock_buff);
break;
@ -327,65 +272,56 @@ namespace proxy @@ -327,65 +272,56 @@ namespace proxy
if (*sock_buff != SOCKS5) {
LogPrint(eLogError,"--- SOCKS5 rejected unknown request version: ", ((int)*sock_buff));
SocksRequestFailed(SOCKS5_GEN_FAIL);
return 0;
return false;
}
m_pstate = GET_COMMAND;
EnterState(GET_COMMAND);
break;
case GET5_GETRSV:
if ( *sock_buff != 0 ) {
LogPrint(eLogError,"--- SOCKS5 unknown reserved field: ", ((int)*sock_buff));
SocksRequestFailed(SOCKS5_GEN_FAIL);
return 0;
return false;
}
m_pstate = GET5_GETADDRTYPE;
EnterState(GET5_GETADDRTYPE);
break;
case GET5_GETADDRTYPE:
switch (*sock_buff) {
case ADDR_IPV4: m_pstate = GET_IPV4; m_address.ip = 0; m_parseleft = 4; break;
case ADDR_IPV6: m_pstate = GET5_IPV6; m_parseleft = 16; break;
case ADDR_DNS : m_pstate = GET5_HOST_SIZE; break;
case ADDR_IPV4: EnterState(GET_IPV4); break;
case ADDR_IPV6: EnterState(GET5_IPV6); break;
case ADDR_DNS : EnterState(GET5_HOST_SIZE); break;
default:
LogPrint(eLogError,"--- SOCKS5 unknown address type: ", ((int)*sock_buff));
SocksRequestFailed(SOCKS5_GEN_FAIL);
return 0;
return false;
}
m_addrtype = (SOCKSHandler::addrTypes)*sock_buff;
break;
case GET5_IPV6:
m_address.ipv6[16-m_parseleft] = *sock_buff;
m_parseleft--;
if (m_parseleft == 0) {
m_pstate = GET_PORT;
m_parseleft = 2;
}
if (m_parseleft == 0) EnterState(GET_PORT);
break;
case GET5_HOST_SIZE:
m_parseleft = *sock_buff;
m_address.dns.size = 0;
m_pstate = GET5_HOST;
EnterState(GET5_HOST, *sock_buff);
break;
case GET5_HOST:
m_address.dns.push_back(*sock_buff);
m_parseleft--;
if (m_parseleft == 0) {
m_pstate = GET_PORT;
m_parseleft = 2;
}
if (m_parseleft == 0) EnterState(GET_PORT);
break;
default:
LogPrint(eLogError,"--- SOCKS parse state?? ", m_pstate);
LogPrint(eLogError,"--- SOCKS parse state?? ", m_state);
Terminate();
return 0;
}
if (m_pstate == DONE) {
m_state = READY;
m_need_more = false;
return (ValidateSOCKSRequest() ? rv : 0);
return false;
}
sock_buff++;
len--;
if (len && m_state == DONE) {
LogPrint(eLogError,"--- SOCKS rejected because we can't handle extra data");
SocksRequestFailed(SOCKS5_GEN_FAIL);
return false;
}
}
return rv;
return true;
}
void SOCKSHandler::HandleSockRecv(const boost::system::error_code & ecode, std::size_t len)
@ -397,32 +333,17 @@ namespace proxy @@ -397,32 +333,17 @@ namespace proxy
return;
}
std::size_t pos = 0;
m_need_more = true;
while (pos != len && m_state != READY && m_need_more) {
assert(pos < len); //We are overflowing the buffer otherwise
std::size_t rv = HandleData(m_sock_buff + pos, len - pos);
if (!rv) return; //Something went wrong die misserably
pos += rv;
}
assert(!(m_state == READY && m_need_more));
if (m_state == READY) {
LogPrint(eLogInfo,"--- SOCKS requested ", m_address.dns.ToString(), ":" , m_port);
if (pos != len) {
LogPrint(eLogError,"--- SOCKS rejected because we can't handle extra data");
SocksRequestFailed(SOCKS5_GEN_FAIL);
return ;
if (HandleData(m_sock_buff, len)) {
if (m_state == DONE) {
LogPrint(eLogInfo,"--- SOCKS requested ", m_address.dns.ToString(), ":" , m_port);
m_parent->GetLocalDestination ()->CreateStream (
std::bind (&SOCKSHandler::HandleStreamRequestComplete,
this, std::placeholders::_1), m_address.dns.ToString(), m_port);
} else {
AsyncSockRead();
}
m_parent->GetLocalDestination ()->CreateStream (
std::bind (&SOCKSHandler::HandleStreamRequestComplete,
this, std::placeholders::_1), m_address.dns.ToString(), m_port);
} else if (m_need_more) {
LogPrint (eLogDebug,"--- SOCKS Need more data");
AsyncSockRead();
}
}
void SOCKSHandler::SentSocksFailed(const boost::system::error_code & ecode)
@ -434,31 +355,35 @@ namespace proxy @@ -434,31 +355,35 @@ namespace proxy
Terminate();
}
}
void SOCKSHandler::SentSocksResponse(const boost::system::error_code & ecode)
void SOCKSHandler::SentSocksDone(const boost::system::error_code & ecode)
{
if (!ecode) {
if(m_state == READY) {
LogPrint (eLogInfo,"--- SOCKS New I2PTunnel connection");
auto connection = std::make_shared<i2p::client::I2PTunnelConnection>((i2p::client::I2PTunnel *)m_parent, m_sock, m_stream);
m_parent->AddConnection (connection);
connection->I2PConnect ();
} else {
LogPrint (eLogDebug,"--- SOCKS Go to next state");
AsyncSockRead();
}
if (dead.exchange(true)) return;
LogPrint (eLogInfo,"--- SOCKS New I2PTunnel connection");
auto connection = std::make_shared<i2p::client::I2PTunnelConnection>((i2p::client::I2PTunnel *)m_parent, m_sock, m_stream);
m_parent->AddConnection (connection);
connection->I2PConnect ();
Done();
}
else
{
LogPrint (eLogError,"--- SOCKS Closing socket after completion reply because: ", ecode.message ());
Terminate();
}
}
void SOCKSHandler::SentSocksResponse(const boost::system::error_code & ecode)
{
if (ecode) {
LogPrint (eLogError,"--- SOCKS Closing socket after sending reply because: ", ecode.message ());
Terminate();
}
}
void SOCKSHandler::HandleStreamRequestComplete (std::shared_ptr<i2p::stream::Stream> stream)
{
if (stream) {
//TODO: test the stream is open if it isn't fail with connrefused
m_stream = stream;
SocksRequestSuccess();
} else {
@ -467,7 +392,6 @@ namespace proxy @@ -467,7 +392,6 @@ namespace proxy
}
}
void SOCKSServer::Start ()
{
m_Acceptor.listen ();
@ -479,6 +403,7 @@ namespace proxy @@ -479,6 +403,7 @@ namespace proxy
m_Acceptor.close();
m_Timer.cancel ();
ClearConnections ();
ClearHandlers();
}
void SOCKSServer::Accept ()
@ -486,14 +411,31 @@ namespace proxy @@ -486,14 +411,31 @@ namespace proxy
auto newSocket = new boost::asio::ip::tcp::socket (GetService ());
m_Acceptor.async_accept (*newSocket, std::bind (&SOCKSServer::HandleAccept, this,
std::placeholders::_1, newSocket));
}
}
void SOCKSServer::AddHandler (std::shared_ptr<SOCKSHandler> handler) {
std::unique_lock<std::mutex> l(m_HandlersMutex);
m_Handlers.insert (handler);
}
void SOCKSServer::RemoveHandler (std::shared_ptr<SOCKSHandler> handler)
{
std::unique_lock<std::mutex> l(m_HandlersMutex);
m_Handlers.erase (handler);
}
void SOCKSServer::ClearHandlers ()
{
std::unique_lock<std::mutex> l(m_HandlersMutex);
m_Handlers.clear ();
}
void SOCKSServer::HandleAccept (const boost::system::error_code& ecode, boost::asio::ip::tcp::socket * socket)
{
if (!ecode)
{
LogPrint(eLogDebug,"--- SOCKS accepted");
new SOCKSHandler(this, socket);
AddHandler(std::make_shared<SOCKSHandler> (this, socket));
Accept();
}
else

70
SOCKS.h
Unescape View File

@ -3,7 +3,10 @@ @@ -3,7 +3,10 @@
#include <memory>
#include <string>
#include <set>
#include <boost/asio.hpp>
#include <mutex>
#include <atomic>
#include "Identity.h"
#include "Streaming.h"
#include "I2PTunnel.h"
@ -29,16 +32,10 @@ namespace proxy @@ -29,16 +32,10 @@ namespace proxy
};
class SOCKSServer;
class SOCKSHandler {
class SOCKSHandler: public std::enable_shared_from_this<SOCKSHandler> {
private:
enum state {
GET_VERSION, // Get SOCKS version
SOCKS5_AUTHNEGO, //Authentication negotiation
SOCKS5_AUTH, //Authentication
SOCKS_REQUEST, //Request
READY // Ready to connect
};
enum parseState {
GET_SOCKSV,
GET_COMMAND,
GET_PORT,
GET_IPV4,
@ -95,25 +92,21 @@ namespace proxy @@ -95,25 +92,21 @@ namespace proxy
uint8_t ipv6[16];
};
std::size_t HandleData(uint8_t *sock_buff, std::size_t len);
std::size_t HandleVersion(uint8_t *sock_buff);
std::size_t HandleSOCKS5AuthNego(uint8_t *sock_buff, std::size_t len);
std::size_t HandleSOCKSRequest(uint8_t *sock_buff, std::size_t len);
bool ValidateSOCKSRequest();
void EnterState(state nstate, uint8_t parseleft = 1);
bool HandleData(uint8_t *sock_buff, std::size_t len);
void ValidateSOCKSRequest();
void HandleSockRecv(const boost::system::error_code & ecode, std::size_t bytes_transfered);
void Done();
void Terminate();
void CloseSock();
void CloseStream();
void AsyncSockRead();
boost::asio::const_buffers_1 GenerateSOCKS5SelectAuth(authMethods method);
boost::asio::const_buffers_1 GenerateSOCKS4Response(errTypes error, uint32_t ip, uint16_t port);
boost::asio::const_buffers_1 GenerateSOCKS5Response(errTypes error, addrTypes type, const address &addr, uint16_t port);
void Socks5AuthNegoFailed();
void Socks5ChooseAuth();
bool Socks5ChooseAuth();
void SocksRequestFailed(errTypes error);
void SocksRequestSuccess();
//HACK: we need to pass the shared_ptr to ensure the buffer will live enough
void SentSocksFailed(const boost::system::error_code & ecode);
void SentSocksDone(const boost::system::error_code & ecode);
void SentSocksResponse(const boost::system::error_code & ecode);
void HandleStreamRequestComplete (std::shared_ptr<i2p::stream::Stream> stream);
@ -121,9 +114,7 @@ namespace proxy @@ -121,9 +114,7 @@ namespace proxy
SOCKSServer * m_parent;
boost::asio::ip::tcp::socket * m_sock;
std::shared_ptr<i2p::stream::Stream> m_stream;
state m_state;
parseState m_pstate;
uint8_t response[7+max_socks_hostname_size];
uint8_t m_response[7+max_socks_hostname_size];
address m_address; //Address
uint32_t m_4aip; //Used in 4a requests
uint16_t m_port;
@ -133,18 +124,30 @@ namespace proxy @@ -133,18 +124,30 @@ namespace proxy
addrTypes m_addrtype; //Address type chosen
socksVersions m_socksv; //Socks version
cmdTypes m_cmd; // Command requested
bool m_need_more; //The parser still needs to receive more data
state m_state;
std::atomic<bool> dead; //To avoid cleaning up multiple times
public:
SOCKSHandler(SOCKSServer * parent, boost::asio::ip::tcp::socket * sock) :
m_parent(parent), m_sock(sock), m_stream(nullptr), m_state(GET_VERSION),
m_authchosen(AUTH_UNACCEPTABLE), m_addrtype(ADDR_IPV4)
{ m_address.ip = 0; AsyncSockRead(); }
~SOCKSHandler() { CloseSock(); CloseStream(); }
m_parent(parent), m_sock(sock), m_stream(nullptr),
m_authchosen(AUTH_UNACCEPTABLE), m_addrtype(ADDR_IPV4), dead(false)
{ m_address.ip = 0; AsyncSockRead(); EnterState(GET_SOCKSV); }
~SOCKSHandler() { Terminate(); }
};
class SOCKSServer: public i2p::client::I2PTunnel
{
private:
std::set<std::shared_ptr<SOCKSHandler> > m_Handlers;
boost::asio::ip::tcp::acceptor m_Acceptor;
boost::asio::deadline_timer m_Timer;
std::mutex m_HandlersMutex;
private:
void Accept();
void HandleAccept(const boost::system::error_code& ecode, boost::asio::ip::tcp::socket * socket);
public:
SOCKSServer(int port) : I2PTunnel(nullptr),
m_Acceptor (GetService (), boost::asio::ip::tcp::endpoint (boost::asio::ip::tcp::v4(), port)),
@ -153,17 +156,10 @@ namespace proxy @@ -153,17 +156,10 @@ namespace proxy
void Start ();
void Stop ();
private:
void Accept();
void HandleAccept(const boost::system::error_code& ecode, boost::asio::ip::tcp::socket * socket);
private:
boost::asio::ip::tcp::acceptor m_Acceptor;
boost::asio::deadline_timer m_Timer;
};
void AddHandler (std::shared_ptr<SOCKSHandler> handler);
void RemoveHandler (std::shared_ptr<SOCKSHandler> handler);
void ClearHandlers ();
};
typedef SOCKSServer SOCKSProxy;
}

Write Preview
Loading…
Cancel
Save