Git-Mirrors/RetroShare
1
0
Fork 0
mirror of https://github.com/RetroShare/RetroShare.git synced 2024-10-01 02:35:48 -04:00
Code Issues Actions Packages Projects Releases Wiki Activity

reimplemented the tunnel handshake

Browse Source 
git-svn-id: http://svn.code.sf.net/p/retroshare/code/trunk@2428 b45a01b8-16f6-495d-af2f-9b41ad6348cc
This commit is contained in:
joss17 2010-02-25 22:44:04 +00:00
parent 47b5f62aeb
commit 3d33f5d729
7 changed files with 373 additions and 192 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
libretroshare/src/pqi/pqiperson.cc
View File

@ -436,6 +436,10 @@ pqiconnect *pqiperson::getKid(uint32_t type)
{
std::map<uint32_t, pqiconnect *>::iterator it;
if (kids.empty()) {
return NULL;
}
it = kids.find(type);
if (it == kids.end())
{

99
libretroshare/src/pqi/pqissltunnel.cc
View File

@ -45,8 +45,8 @@ const int pqisslzone = 37714;
#define TUNNEL_WAITING_NOT 0
#define TUNNEL_WAITING_DELAY 1
#define TUNNEL_WAITING_SPAM_PING 2
#define TUNNEL_WAITING_PING_RETURN 3
#define TUNNEL_WAITING_SPAM_HANDSHAKE 2
#define TUNNEL_WAITING_RETURN_HANDSHAKE 3
#define TUNNEL_PASSIVE 0x00
@ -301,7 +301,7 @@ int pqissltunnel::tick()
if (waiting > 0)
{
#ifdef DEBUG_PQISSL_TUNNEL
std::cerr << "pqissltunnel::tick() Continuing Connection Attempt!" << std::endl;
//std::cerr << "pqissltunnel::tick() Continuing Connection Attempt!" << std::endl;
#endif
ConnectAttempt();
return 1;
@ -314,42 +314,41 @@ int pqissltunnel::tick()
/********** Internals of Tunnel Connection ****************************/
int pqissltunnel::ConnectAttempt()
{
#ifdef DEBUG_PQISSL_TUNNEL
std::cerr << "pqissltunnel::ConnectAttempt() called." << std::endl;
#endif
#ifdef DEBUG_PQISSL_TUNNEL
//std::cerr << "pqissltunnel::ConnectAttempt() called." << std::endl;
#endif
switch(waiting)
{
case TUNNEL_WAITING_NOT:
active = true; /* we're starting this one */
#ifdef DEBUG_PQISSL_TUNNEL
std::cerr << "pqissltunnel::ConnectAttempt() STATE = Not Waiting." << std::endl;
#endif
case TUNNEL_WAITING_DELAY:
std::cerr << "pqissltunnel::ConnectAttempt() STATE = Waiting Delay, starting connection" << std::endl;
if ((time(NULL) - mConnectTS) > TUNNEL_START_CONNECTION_DELAY) {
waiting = TUNNEL_WAITING_SPAM_PING;
waiting = TUNNEL_WAITING_SPAM_HANDSHAKE;
}
break;
case TUNNEL_WAITING_SPAM_PING:
case TUNNEL_WAITING_SPAM_HANDSHAKE:
#ifdef DEBUG_PQISSL_TUNNEL
std::cerr << "pqissltunnel::ConnectAttempt() STATE = Waiting for spamming handshake." << std::endl;
#endif
std::cerr << "pqissltunnel::ConnectAttempt() STATE = Waiting for spamming ping." << std::endl;
Spam_Ping();
waiting = TUNNEL_WAITING_PING_RETURN;
spam_handshake();
waiting = TUNNEL_WAITING_RETURN_HANDSHAKE;
break;
case TUNNEL_WAITING_PING_RETURN:
case TUNNEL_WAITING_RETURN_HANDSHAKE:
if ((time(NULL) - mConnectTS) < TUNNEL_PING_TIMEOUT) {
#ifdef DEBUG_PQISSL_TUNNEL
std::cerr << "pqissltunnel::ConnectAttempt() STATE = Waiting for ping reply." << std::endl;
//std::cerr << "pqissltunnel::ConnectAttempt() STATE = Waiting for handshake reply." << std::endl;
#endif
} else {
#ifdef DEBUG_PQISSL_TUNNEL
std::cerr << "pqissltunnel::ConnectAttempt() no ping reply during imparing time. Connection failed." << std::endl;
std::cerr << "pqissltunnel::ConnectAttempt() no handshake reply during imparing time. Connection failed." << std::endl;
#endif
waiting = TUNNEL_WAITING_NOT;
active = false;
@ -373,29 +372,27 @@ int pqissltunnel::ConnectAttempt()
return -1;
}
void pqissltunnel::Spam_Ping()
void pqissltunnel::spam_handshake()
{
#ifdef DEBUG_PQISSL_TUNNEL
std::cerr << "pqissltunnel::Spam_Ping() starting to spam ping tunnel packet." << std::endl;
std::cerr << "pqissltunnel::spam_handshake() starting to spam handshake tunnel packet." << std::endl;
#endif
std::list<std::string> peers;
mConnMgr->getOnlineList(peers);
std::list<std::string>::iterator it = peers.begin();
while (it != peers.end()) {
//send a ping to the destination through the relay
//send a handshake to the destination through the relay
if (*it != parent()->PeerId()) {
std::cerr << "sending ping with relay id : " << *it << std::endl;
mP3tunnel->pingTunnelConnection(*it, parent()->PeerId());
mP3tunnel->initiateHandshake(*it, parent()->PeerId());
}
++it;
}
}
void pqissltunnel::addIncomingPacket(void* encoded_data, int encoded_data_length) {
#ifdef DEBUG_PQISSL_TUNNEL
#ifdef DEBUG_PQISSL_TUNNEL
std::cerr << "pqissltunnel::addIncomingPacket() called." << std::endl;
std::cerr << "pqissltunnel::addIncomingPacket() getRsItemSize(encoded_data) : " << getRsItemSize(encoded_data) << std::endl;
#endif
#endif
last_packet_time = time(NULL);
data_with_length data_w_l;
@ -403,25 +400,30 @@ void pqissltunnel::addIncomingPacket(void* encoded_data, int encoded_data_length
memcpy(data_w_l.data, encoded_data, encoded_data_length);
data_w_l.length = encoded_data_length;
data_packet_queue.push_front(data_w_l);
#ifdef DEBUG_PQISSL_TUNNEL
std::cerr << "pqissltunnel::addIncomingPacket() getRsItemSize(data_w_l.data) : " << getRsItemSize(data_w_l.data) << std::endl;
#endif
}
void pqissltunnel::IncommingPingPacket(std::string incRelayPeerId) {
#ifdef DEBUG_PQISSL_TUNNEL
std::cerr << "pqissltunnel::IncommingPingPacket() called with incRelayPeerId : " << incRelayPeerId << std::endl;
#endif
void pqissltunnel::IncommingPingPacket() {
#ifdef DEBUG_PQISSL_TUNNEL
std::cerr << "pqissltunnel::IncommingPingPacket() called" << std::endl;
#endif
last_packet_time = time(NULL);
}
void pqissltunnel::IncommingHanshakePacket(std::string incRelayPeerId) {
#ifdef DEBUG_PQISSL_TUNNEL
std::cerr << "pqissltunnel::IncommingHanshakePacket() called with incRelayPeerId : " << incRelayPeerId << std::endl;
#endif
if ((time(NULL) - resetTime) <= TUNNEL_TIMEOUT_AFTER_RESET) {
#ifdef DEBUG_PQISSL_TUNNEL
std::cerr << "pqissltunnel::IncommingPingPacket() a reset occured, don't activate the connection." << std::endl;
std::cerr << "pqissltunnel::IncommingHanshakePacket() a reset occured, don't activate the connection." << std::endl;
#endif
return;
}
last_packet_time = time(NULL);
std::string message = "pqissltunnel::IncommingPingPacket() mConnMgr->isOnline(parent()->PeerId() : ";
std::string message = "pqissltunnel::IncommingHanshakePacket() mConnMgr->isOnline(parent()->PeerId() : ";
if (mConnMgr->isOnline(parent()->PeerId())) {
message += "true";
} else {
@ -442,14 +444,13 @@ void pqissltunnel::IncommingPingPacket(std::string incRelayPeerId) {
if (parent())
{
#ifdef DEBUG_PQISSL_TUNNEL
std::cerr << "pqissltunnel::IncommingPingPacket() Notify the pqiperson.... (Both Connect/Receive)" << parent()->PeerId() <<std::endl;
#endif
rslog(RSL_DEBUG_BASIC, pqisslzone, "pqissltunnel::IncommingPingPacket() Notify the pqiperson.... (Both Connect/Receive)");
#ifdef DEBUG_PQISSL_TUNNEL
std::cerr << "pqissltunnel::IncommingHanshakePacket() Notify the pqiperson.... (Both Connect/Receive)" << parent()->PeerId() <<std::endl;
#endif
rslog(RSL_DEBUG_BASIC, pqisslzone, "pqissltunnel::IncommingHanshakePacket() Notify the pqiperson.... (Both Connect/Receive)");
parent() -> notifyEvent(this, NET_CONNECT_SUCCESS);
}
}
/********** Implementation of BinInterface **************************
* All the rest of the BinInterface.
*
@ -470,24 +471,14 @@ int pqissltunnel::senddata(void *data, int len)
int outlen = 0;
void * out;
if (!AuthSSL::getAuthSSL()->encrypt(out, outlen, data, len, parent()->PeerId())) {
std::cerr << "pqissltunnel::readdata() problem while crypting packet, ignoring it." << std::endl;
std::cerr << "pqissltunnel::senddata() problem while crypting packet, ignoring it." << std::endl;
return -1;
}
std::cerr << "pqissltunnel::readdata() outlen : " << outlen << std::endl;
//create RsTunnelDataItem
RsTunnelDataItem *item = new RsTunnelDataItem();
item->destPeerId = parent()->PeerId();
item->relayPeerId = relayPeerId;
item->sourcePeerId = mConnMgr->getOwnId();
item->PeerId(relayPeerId);
item->connection_accepted = 1;
item->encoded_data_len = outlen;
item->encoded_data = out;
#ifdef DEBUG_PQISSL_TUNNEL
std::cerr << "pqissltunnel::senddata() sending item (Putting it into queue)" << std::endl ;
std::cerr << "pqissltunnel::senddata() sending item via p3tunnel" << std::endl ;
#endif
mP3tunnel->sendItem(item);
mP3tunnel->sendTunnelData(parent()->PeerId(), relayPeerId, out, outlen);
return len;
}

5
libretroshare/src/pqi/pqissltunnel.h
View File

@ -106,7 +106,8 @@ virtual bool bandwidthLimited() { return true ; } // replace by !sameLAN to avoi
//called by the p3tunnel service to add incoming packets that will be read by the read data function.
void addIncomingPacket(void* encoded_data, int data_length);
void IncommingPingPacket(std::string incRelayPeerId);
void IncommingPingPacket();
void IncommingHanshakePacket(std::string incRelayPeerId);
private:
//if no packet (last_time_packet_time) is received since PING_RECEIVE_TIME_OUT, let's assume the connection is broken
@ -119,7 +120,7 @@ private:
int last_ping_send_time;
int ConnectAttempt();
void Spam_Ping();
void spam_handshake();
int waiting;
bool active;
time_t resetTime;

118
libretroshare/src/serialiser/rstunnelitems.cc
View File

@ -24,7 +24,6 @@ uint32_t RsTunnelDataItem::serial_size()
s += GetTlvStringSize(sourcePeerId) ;
s += GetTlvStringSize(relayPeerId) ;
s += GetTlvStringSize(destPeerId) ;
s += 4 ; //connection_accept
s += 4 ; //encoded_data_len
s += encoded_data_len;
@ -32,13 +31,31 @@ uint32_t RsTunnelDataItem::serial_size()
return s ;
}
uint32_t RsTunnelHandshakeItem::serial_size()
{
#ifdef P3TUNNEL_DEBUG
std::cerr << "RsTunnelHandshakeItem::serial_size() called." << std::endl ;
#endif
uint32_t s = 0 ;
s += 8 ; // header
s += GetTlvStringSize(sourcePeerId) ;
s += GetTlvStringSize(relayPeerId) ;
s += GetTlvStringSize(destPeerId) ;
s += GetTlvStringSize(sslCertPEM) ;
s += 4 ; //connection_accept
return s ;
}
//
// ---------------------------------- Serialization ----------------------------------//
//
RsItem *RsTunnelSerialiser::deserialise(void *data, uint32_t *size)
{
#ifdef P3TUNNEL_DEBUG
std::cerr << "RsTunnelDataItem::deserialise() called." << std::endl ;
std::cerr << "RsTunnelSerialiser::deserialise() called." << std::endl ;
#endif
// look what we have...
@ -62,6 +79,7 @@ RsItem *RsTunnelSerialiser::deserialise(void *data, uint32_t *size)
switch(getRsItemSubType(rstype))
{
case RS_TUNNEL_SUBTYPE_DATA : return new RsTunnelDataItem(data,*size) ;
case RS_TUNNEL_SUBTYPE_HANDSHAKE : return new RsTunnelHandshakeItem(data,*size) ;
default:
std::cerr << "Unknown packet type in Rstunnel!" << std::endl ;
@ -106,7 +124,6 @@ bool RsTunnelDataItem::serialize(void *data,uint32_t& pktsize)
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_VALUE, sourcePeerId);
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_VALUE, relayPeerId);
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_VALUE, destPeerId);
ok &= setRawUInt32(data, tlvsize, &offset, connection_accepted);
ok &= setRawUInt32(data, tlvsize, &offset, encoded_data_len) ;
memcpy((void*)((unsigned char*)data+offset),encoded_data,encoded_data_len) ;
@ -119,9 +136,9 @@ bool RsTunnelDataItem::serialize(void *data,uint32_t& pktsize)
if ((offset + encoded_data_len) != tlvsize )
{
ok = false;
#ifdef RSSERIAL_DEBUG
#ifdef P3TUNNEL_DEBUG
std::cerr << "RsTunnelDataItem::serialiseTransfer() Size Error! " << std::endl;
#endif
#endif
}
#ifdef P3TUNNEL_DEBUG
@ -131,9 +148,50 @@ bool RsTunnelDataItem::serialize(void *data,uint32_t& pktsize)
return ok;
}
bool RsTunnelHandshakeItem::serialize(void *data,uint32_t& pktsize)
{
#ifdef P3TUNNEL_DEBUG
std::cerr << "RsTunnelHandshakeItem::serialize() called." << std::endl ;
#endif
uint32_t tlvsize = serial_size();
uint32_t offset = 0;
if (pktsize < tlvsize)
return false; /* not enough space */
pktsize = tlvsize;
bool ok = true;
#ifdef P3TUNNEL_DEBUG
std::cerr << "RsTunnelHandshakeItem::serialize() tlvsize : " << tlvsize << std::endl ;
#endif
ok &= setRsItemHeader(data,tlvsize,PacketId(), tlvsize);
/* skip the header */
offset += 8;
/* add mandatory parts first */
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_VALUE, sourcePeerId);
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_VALUE, relayPeerId);
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_VALUE, destPeerId);
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_CERT_SSL, sslCertPEM);
ok &= setRawUInt32(data, tlvsize, &offset, connection_accepted);
if (offset != tlvsize )
{
ok = false;
#ifdef P3TUNNEL_DEBUG
std::cerr << "RsTunnelHandshakeItem::serialiseTransfer() Size Error! " << std::endl;
#endif
}
return ok;
}
//deserialize in constructor
RsTunnelDataItem::RsTunnelDataItem(void *data,uint32_t pktsize)
: RsTunnelItem(RS_TUNNEL_SUBTYPE_DATA)
RsTunnelDataItem::RsTunnelDataItem(void *data,uint32_t pktsize) : RsTunnelItem(RS_TUNNEL_SUBTYPE_DATA)
{
#ifdef P3TUNNEL_DEBUG
std::cerr << "RsTunnelDataItem constructor called : deserializing packet." << std::endl ;
@ -149,7 +207,6 @@ RsTunnelDataItem::RsTunnelDataItem(void *data,uint32_t pktsize)
ok &= GetTlvString(data, pktsize, &offset, TLV_TYPE_STR_VALUE, sourcePeerId);
ok &= GetTlvString(data, pktsize, &offset, TLV_TYPE_STR_VALUE, relayPeerId);
ok &= GetTlvString(data, pktsize, &offset, TLV_TYPE_STR_VALUE, destPeerId);
ok &= getRawUInt32(data, pktsize, &offset, &connection_accepted);
ok &= getRawUInt32(data, pktsize, &offset, &encoded_data_len) ;
encoded_data = (void*)malloc(encoded_data_len) ;
@ -164,16 +221,53 @@ RsTunnelDataItem::RsTunnelDataItem(void *data,uint32_t pktsize)
#endif
}
//deserialize in constructor
RsTunnelHandshakeItem::RsTunnelHandshakeItem(void *data,uint32_t pktsize) : RsTunnelItem(RS_TUNNEL_SUBTYPE_HANDSHAKE)
{
#ifdef P3TUNNEL_DEBUG
std::cerr << "RsTunnelHandshakeItem constructor called : deserializing packet." << std::endl ;
#endif
uint32_t offset = 8; // skip the header
uint32_t rssize = getRsItemSize(data);
bool ok = true ;
#ifdef P3TUNNEL_DEBUG
std::cerr << "RsTunnelHandshakeItem constructor rssize : " << rssize << std::endl ;
#endif
ok &= GetTlvString(data, pktsize, &offset, TLV_TYPE_STR_VALUE, sourcePeerId);
ok &= GetTlvString(data, pktsize, &offset, TLV_TYPE_STR_VALUE, relayPeerId);
ok &= GetTlvString(data, pktsize, &offset, TLV_TYPE_STR_VALUE, destPeerId);
ok &= GetTlvString(data, pktsize, &offset, TLV_TYPE_STR_CERT_SSL, sslCertPEM);
ok &= getRawUInt32(data, pktsize, &offset, &connection_accepted);
#ifdef WINDOWS_SYS // No Exceptions in Windows compile. (drbobs).
#else
if (offset != rssize)
throw std::runtime_error("Size error while deserializing.") ;
if (!ok)
throw std::runtime_error("Unknown error while deserializing.") ;
#endif
}
std::ostream& RsTunnelDataItem::print(std::ostream& o, uint16_t)
{
o << "RsTunnelDataItem :" << std::endl ;
o << " sourcePeerId : " << sourcePeerId << std::endl ;
o << " relayPeerId : " << relayPeerId << std::endl ;
o << " destPeerId : " << destPeerId << std::endl ;
o << " connection_accepted : " << connection_accepted << std::endl ;
o << " encoded_data_len : " << encoded_data_len << std::endl ;
if (encoded_data_len != 0 ) {
o << "getRsItemSize(encoded_data)" << getRsItemSize(encoded_data) << std::endl ;
}
return o ;
}
std::ostream& RsTunnelHandshakeItem::print(std::ostream& o, uint16_t)
{
o << "RsTunnelDataItem :" << std::endl ;
o << " sourcePeerId : " << sourcePeerId << std::endl ;
o << " relayPeerId : " << relayPeerId << std::endl ;
o << " destPeerId : " << destPeerId << std::endl ;
o << " sslCertPEM : " << sslCertPEM << std::endl ;
o << " connection_accepted : " << connection_accepted << std::endl ;
return o ;
}

18
libretroshare/src/serialiser/rstunnelitems.h
View File

@ -36,6 +36,7 @@
#include "serialiser/rstlvkeys.h"
const uint8_t RS_TUNNEL_SUBTYPE_DATA = 0x01 ;
const uint8_t RS_TUNNEL_SUBTYPE_HANDSHAKE = 0x02 ;
/***********************************************************************************/
/* Basic Tunnel Item Class */
@ -64,6 +65,23 @@ class RsTunnelDataItem: public RsTunnelItem
std::string sourcePeerId ;
std::string relayPeerId ;
std::string destPeerId ;
std::ostream& print(std::ostream& o, uint16_t) ;
bool serialize(void *data,uint32_t& size) ;
uint32_t serial_size() ;
};
class RsTunnelHandshakeItem: public RsTunnelItem
{
public:
RsTunnelHandshakeItem() : RsTunnelItem(RS_TUNNEL_SUBTYPE_HANDSHAKE) {}
RsTunnelHandshakeItem(void *data,uint32_t size) ; // deserialization
std::string sourcePeerId ;
std::string relayPeerId ;
std::string destPeerId ;
std::string sslCertPEM ;
uint32_t connection_accepted;
std::ostream& print(std::ostream& o, uint16_t) ;

266
libretroshare/src/services/p3tunnel.cc
View File

@ -40,6 +40,10 @@
#include "util/rsprint.h"
#include "util/rsversion.h"
#define TUNNEL_HANDSHAKE_INIT 1
#define TUNNEL_HANDSHAKE_ACK 2
#define TUNNEL_HANDSHAKE_REFUSE 0
p3tunnel::p3tunnel(p3ConnectMgr *cm, pqipersongrp *perGrp)
:p3Service(RS_SERVICE_TYPE_TUNNEL), mConnMgr(cm), mPqiPersonGrp(perGrp)
{
@ -57,21 +61,11 @@ void p3tunnel::statusChange(const std::list<pqipeer> &plist) {
int p3tunnel::tick()
{
if (!mConnMgr->getTunnelConnection()) {
//no tunnel allowed, just drop the packet
return -1;
}
return handleIncoming();
}
int p3tunnel::handleIncoming()
{
if (!mConnMgr->getTunnelConnection()) {
//no tunnel allowed, just drop the packet
return -1;
}
RsItem *item = NULL;
#ifdef P3TUNNEL_DEBUG
@ -82,25 +76,30 @@ int p3tunnel::handleIncoming()
// While messages read
while(NULL != (item = recvItem()))
{
if (!mConnMgr->getTunnelConnection()) {
//no tunnel allowed, just drop the packet
continue;
}
RsTunnelDataItem *tdi = NULL;
RsTunnelHandshakeItem *thi = NULL;
{
#ifdef P3TUNNEL_DEBUG
#ifdef P3TUNNEL_DEBUG
std::ostringstream out;
out << "p3tunnel::handleIncoming()";
out << " Received Message!" << std::endl;
item -> print(out);
out << std::endl;
std::cerr << out.str();
#endif
#endif
}
if (NULL != (tdi = dynamic_cast<RsTunnelDataItem *> (item))) {
#ifdef P3TUNNEL_DEBUG
std::cerr << "p3tunnel::handleIncoming() tdi->encoded_data_len : " << tdi->encoded_data_len << std::endl;
#endif
recvTunnelData(tdi);
nhandled++;
} else if (NULL != (thi = dynamic_cast<RsTunnelHandshakeItem *> (item))) {
recvTunnelHandshake(thi);
nhandled++;
}
delete item;
}
@ -110,13 +109,12 @@ int p3tunnel::handleIncoming()
/*************************************************************************************/
/* Output Network Msgs */
/*************************************************************************************/
void p3tunnel::sendTunnelData(std::string destPeerId, std::string relayPeerId, void *data, int data_length)
{
sendTunnelDataPrivate(1, relayPeerId, ownId,relayPeerId, destPeerId, data, data_length);
void p3tunnel::sendTunnelData(std::string destPeerId, std::string relayPeerId, void *data, int data_length) {
sendTunnelDataPrivate(relayPeerId, ownId,relayPeerId, destPeerId, data, data_length);
}
void p3tunnel::sendTunnelDataPrivate(int accept, std::string to, std::string sourcePeerId, std::string relayPeerId, std::string destPeerId, void *data, int data_length)
{
void p3tunnel::sendTunnelDataPrivate(std::string to, std::string sourcePeerId, std::string relayPeerId, std::string destPeerId, void *data, int data_length) {
if (!mConnMgr->getTunnelConnection()) {
//no tunnel allowed, just drop the request
return;
@ -126,12 +124,12 @@ void p3tunnel::sendTunnelDataPrivate(int accept, std::string to, std::string sou
// Then send message.
{
#ifdef P3TUNNEL_DEBUG
#ifdef P3TUNNEL_DEBUG
std::ostringstream out;
out << "p3tunnel::sendTunnelDataPrivate() Constructing a RsTunnelItem Message!" << std::endl;
out << "Sending to: " << to;
std::cerr << out.str() << std::endl;
#endif
#endif
}
// Construct a message
@ -139,18 +137,16 @@ void p3tunnel::sendTunnelDataPrivate(int accept, std::string to, std::string sou
rdi->destPeerId = destPeerId;
rdi->sourcePeerId = sourcePeerId;
rdi->relayPeerId = relayPeerId;
rdi->connection_accepted = accept;
rdi->encoded_data_len = data_length;
rdi->encoded_data = (void*)malloc(data_length);
memcpy(rdi->encoded_data, data, data_length);
#ifdef P3TUNNEL_DEBUG
std::cerr << "p3tunnel::sendTunnelDataPrivate() data_length : "<< data_length << std::endl;
#endif
rdi->PeerId(to);
#ifdef P3TUNNEL_DEBUG
std::cerr << "p3tunnel::sendTunnelDataPrivate() data_length : "<< data_length << std::endl;
#endif
/* send msg */
sendItem(rdi);
}
@ -161,114 +157,190 @@ void p3tunnel::pingTunnelConnection(std::string relayPeerId, std::string destPee
std::cerr << "ownId : " << ownId << std::endl;
std::cerr << "destPeerId : " << destPeerId << std::endl;
#endif
this->sendTunnelDataPrivate(1, relayPeerId, ownId, relayPeerId, destPeerId, NULL, 0);
this->sendTunnelDataPrivate(relayPeerId, ownId, relayPeerId, destPeerId, NULL, 0);
}
void p3tunnel::initiateHandshake(std::string relayPeerId, std::string destPeerId) {
#ifdef P3TUNNEL_DEBUG
std::cerr << "p3tunnel::initiateHandshake() initiating handshake with relay id : " << relayPeerId << std::endl;
std::cerr << "ownId : " << ownId << std::endl;
std::cerr << "destPeerId : " << destPeerId << std::endl;
#endif
// Construct a message
RsTunnelHandshakeItem *rhi = new RsTunnelHandshakeItem();
rhi->destPeerId = destPeerId;
rhi->sourcePeerId = ownId;
rhi->relayPeerId = relayPeerId;
rhi->connection_accepted = TUNNEL_HANDSHAKE_INIT;
rhi->sslCertPEM = AuthSSL::getAuthSSL()->SaveOwnCertificateToString();
rhi->PeerId(relayPeerId);
/* send msg */
sendItem(rhi);
}
/*************************************************************************************/
/* Input Network Msgs */
/*************************************************************************************/
void p3tunnel::recvTunnelHandshake(RsTunnelHandshakeItem *item)
{
#ifdef P3TUNNEL_DEBUG
std::cerr << "p3tunnel::recvTunnelHandshake() From: " << item->PeerId() << std::endl;
#endif
RsPeerDetails pd;
if (!AuthSSL::getAuthSSL()->LoadDetailsFromStringCert(item->sslCertPEM, pd)) {
#ifdef P3TUNNEL_DEBUG
std::cerr << "p3tunnel::recvTunnelHandshake() cert is not valid. This might be a intrusion attempt." << std::endl;
#endif
return;
}
if (item->sourcePeerId != pd.id) {
#ifdef P3TUNNEL_DEBUG
std::cerr << "p3tunnel::recvTunnelHandshake() cert is not issued from the source id of the tunnel. This might be a intrusion attempt." << std::endl;
#endif
return;
}
//compare the peer id from the item sender to the ids in the item.
if (item->PeerId() == item->sourcePeerId && ownId == item->relayPeerId) {
if (mConnMgr->isOnline(item->destPeerId)) {
#ifdef P3TUNNEL_DEBUG
std::cerr << "p3tunnel::recvTunnelHandshake() relaying packet." << std::endl;
#endif
//relaying the handshake
RsTunnelHandshakeItem* forwardItem = new RsTunnelHandshakeItem();
forwardItem->sourcePeerId = item->sourcePeerId;
forwardItem->relayPeerId = item->relayPeerId;
forwardItem->destPeerId = item->destPeerId;
forwardItem->connection_accepted = item->connection_accepted;
forwardItem->sslCertPEM = item->sslCertPEM;
forwardItem->PeerId(item->destPeerId);
sendItem(forwardItem);
} else {
//sending back refuse
//not implemented
#ifdef P3TUNNEL_DEBUG
std::cerr << "p3tunnel::recvTunnelHandshake() not relaying packet because destination is offline." << std::endl;
#endif
}
} else if (item->PeerId() == item->relayPeerId && ownId == item->destPeerId) {
if (item->connection_accepted == TUNNEL_HANDSHAKE_INIT || item->connection_accepted == TUNNEL_HANDSHAKE_ACK) {
//check if we accept connection
if (!mConnMgr->isFriend(pd.id)) {
//send back a refuse
// not implemented
} else {
if (item->connection_accepted == TUNNEL_HANDSHAKE_INIT) {
#ifdef P3TUNNEL_DEBUG
std::cerr << "p3tunnel::recvTunnelHandshake() sending back acknowledgement to " << item->sourcePeerId << std::endl;
#endif
//send back acknowledgement
RsTunnelHandshakeItem* ack = new RsTunnelHandshakeItem();
ack->sourcePeerId = ownId;
ack->relayPeerId = item->relayPeerId;
ack->destPeerId = item->sourcePeerId;
ack->connection_accepted = TUNNEL_HANDSHAKE_ACK;
ack->sslCertPEM = AuthSSL::getAuthSSL()->SaveOwnCertificateToString();
ack->PeerId(item->relayPeerId);
sendItem(ack);
}
//open the local tunnel connection
#ifdef P3TUNNEL_DEBUG
std::cerr << "p3tunnel::recvTunnelHandshake() opening localy the tunnel connection emulation." << std::endl;
#endif
pqiperson *pers = mPqiPersonGrp->getPeer(item->sourcePeerId);
pqissltunnel *pqicon = (pqissltunnel *)(((pqiconnect *) pers->getKid(PQI_CONNECT_TUNNEL))->ni);
pqicon->IncommingHanshakePacket(item->relayPeerId);
}
}
}
}
void p3tunnel::recvTunnelData(RsTunnelDataItem *item)
{
#ifdef P3TUNNEL_DEBUG
#ifdef P3TUNNEL_DEBUG
std::cerr << "p3tunnel::recvPeerConnectRequest() From: " << item->PeerId() << std::endl;
#endif
#endif
//compare the peer id from the item sender to the ids in the item.
if (item->PeerId() == item->sourcePeerId && ownId == item->relayPeerId) {
privateRecvTunnelDataRelaying(item);
} else if (item->PeerId() == item->relayPeerId && ownId == item->destPeerId) {
privateRecvTunnelDataDestination(item);
} else if (item->PeerId() == item->destPeerId && ownId == item->relayPeerId) {
//it's a ping reply from a destination, I'm relaying. Just forward the packet to the source
if (item->connection_accepted && mConnMgr->isOnline(item->sourcePeerId)) {
sendTunnelDataPrivate(1, item->sourcePeerId, item->sourcePeerId, ownId, item->destPeerId, NULL, 0);
return;
}
} else if (item->PeerId() == item->relayPeerId && ownId == item->sourcePeerId) {
#ifdef P3TUNNEL_DEBUG
std::cerr << "p3tunnel::privateRecvTunnelDataRelaying() it's a ping reply. Let's see if the tunnel is accepted." << std::endl;
#endif
if (item->connection_accepted) {
#ifdef P3TUNNEL_DEBUG
std::cerr << "p3tunnel::privateRecvTunnelDataRelaying() tunnel is accepted. activate the pqissltunnel connection." << std::endl;
#endif
pqiperson *pers = mPqiPersonGrp->getPeer(item->destPeerId);
pqissltunnel *pqicon = (pqissltunnel *)(((pqiconnect *) pers->getKid(PQI_CONNECT_TUNNEL))->ni);
pqicon->IncommingPingPacket(item->relayPeerId);
} else {
#ifdef P3TUNNEL_DEBUG
std::cerr << "p3tunnel::privateRecvTunnelDataRelaying() tunnel is not accepted." << std::endl;
#endif
return;
}
}
}
void p3tunnel::privateRecvTunnelDataRelaying(RsTunnelDataItem *item) {
#ifdef P3TUNNEL_DEBUG
#ifdef P3TUNNEL_DEBUG
std::cerr << "p3tunnel::privateRecvTunnelDataRelaying() I am relaying, let's see if it's possible to send the packet to destination." << std::endl;
#endif
if (mConnMgr->isOnline(item->destPeerId)) {
#ifdef P3TUNNEL_DEBUG
std::cerr << "p3tunnel::privateRecvTunnelDataRelaying() I am relaying, relay the packet to destination." << std::endl;
#endif
sendTunnelDataPrivate(1, item->destPeerId, item->sourcePeerId, ownId, item->destPeerId, item->encoded_data, item->encoded_data_len);
#endif
if (!mConnMgr->isFriend(item->sourcePeerId) || !mConnMgr->isFriend(item->destPeerId)) {
#ifdef P3TUNNEL_DEBUG
std::cerr << "p3tunnel::privateRecvTunnelDataDestination() not trusting relay or dest peer. Aborting." << std::endl;
#endif
return;
} else {
#ifdef P3TUNNEL_DEBUG
std::cerr << "p3tunnel::privateRecvTunnelDataRelaying() destination peer is not online, send back the request with a deny" << std::endl;
#endif
sendTunnelDataPrivate(0, item->sourcePeerId, item->sourcePeerId, ownId, item->destPeerId, NULL, 0);
}
if (mConnMgr->isOnline(item->destPeerId)) {
#ifdef P3TUNNEL_DEBUG
std::cerr << "p3tunnel::privateRecvTunnelDataRelaying() I am relaying, relay the packet to destination." << std::endl;
#endif
sendTunnelDataPrivate(item->destPeerId, item->sourcePeerId, ownId, item->destPeerId, item->encoded_data, item->encoded_data_len);
return;
}
}
void p3tunnel::privateRecvTunnelDataDestination(RsTunnelDataItem *item) {
#ifdef P3TUNNEL_DEBUG
#ifdef P3TUNNEL_DEBUG
std::cerr << "p3tunnel::privateRecvTunnelDataDestination() I am the destination Id, let's make some checks and read the packet." << std::endl;
#endif
#endif
if (!mConnMgr->isFriend(item->sourcePeerId) || !mConnMgr->isFriend(item->relayPeerId)) {
#ifdef P3TUNNEL_DEBUG
std::cerr << "p3tunnel::privateRecvTunnelDataDestination() not trusting rely or source peer. Aborting." << std::endl;
#endif
#ifdef P3TUNNEL_DEBUG
std::cerr << "p3tunnel::privateRecvTunnelDataDestination() not trusting relay or source peer. Aborting." << std::endl;
#endif
return;
}
//peer is online when connected through a tunnel so we should not drop the packet
// if (mConnMgr->isOnline(item->sourcePeerId)) {
//#ifdef P3TUNNEL_DEBUG
// std::cerr << "p3tunnel::privateRecvTunnelDataDestination() no need to make tunnel connection, source peer is online. Aborting." << std::endl;
//#endif
// return;
// }
if (!mConnMgr->isOnline(item->relayPeerId)) {
#ifdef P3TUNNEL_DEBUG
#ifdef P3TUNNEL_DEBUG
std::cerr << "p3tunnel::privateRecvTunnelDataDestination() relay peer is not connected, connection impossible. Aborting." << std::endl;
#endif
return;
}
pqiperson *pers = mPqiPersonGrp->getPeer(item->sourcePeerId);
if (pers == NULL) {
#ifdef P3TUNNEL_DEBUG
std::cerr << "p3tunnel::privateRecvTunnelDataDestination() internal source pqiperson peer not found. Aborting." << std::endl;
#endif
#endif
return;
}
pqiperson *pers = mPqiPersonGrp->getPeer(item->sourcePeerId);
if (pers == NULL) {
#ifdef P3TUNNEL_DEBUG
std::cerr << "p3tunnel::privateRecvTunnelDataDestination() tunnel connection not found. Aborting." << std::endl;
#endif
return;
}
//if data is empty, then it's a ping, send the packet to the net emulation layer
if (item->encoded_data_len == 0) {
#ifdef P3TUNNEL_DEBUG
std::cerr << "p3tunnel::privateRecvTunnelDataDestination() receiving a ping packet, activating connection and sending back acknowlegment." << std::endl;
#endif
pqissltunnel *pqicon = (pqissltunnel *)(((pqiconnect *) pers->getKid(PQI_CONNECT_TUNNEL))->ni);
pqicon->IncommingPingPacket(item->relayPeerId);
//sendTunnelDataPrivate(1, item->relayPeerId, item->sourcePeerId, item->relayPeerId, ownId, NULL, 0);
if (pqicon == NULL || !pqicon->isactive()) {
#ifdef P3TUNNEL_DEBUG
std::cerr << "p3tunnel::privateRecvTunnelDataDestination() tunnel connection not found. Aborting." << std::endl;
#endif
return;
}
//send the packet to the net emulation layer
if (item->encoded_data_len == 0) {
#ifdef P3TUNNEL_DEBUG
std::cerr << "p3tunnel::privateRecvTunnelDataDestination() receiving a ping packet, activating connection and sending back acknowlegment." << std::endl;
#endif
pqissltunnel *pqicon = (pqissltunnel *)(((pqiconnect *) pers->getKid(PQI_CONNECT_TUNNEL))->ni);
pqicon->IncommingPingPacket();
} else {
#ifdef P3TUNNEL_DEBUG
#ifdef P3TUNNEL_DEBUG
std::cerr << "p3tunnel::privateRecvTunnelDataDestination() receiving a data packet, transfer it to the pqissltunnel connection." << std::endl;
std::cerr << "p3tunnel::privateRecvTunnelDataDestination() getRsItemSize(item->encoded_data) : " << getRsItemSize(item->encoded_data) << std::endl;
#endif
#endif
pqissltunnel *pqicon = (pqissltunnel *)(((pqiconnect *) pers->getKid(PQI_CONNECT_TUNNEL))->ni);
pqicon->addIncomingPacket(item->encoded_data, item->encoded_data_len);
}

5
libretroshare/src/services/p3tunnel.h
View File

@ -52,12 +52,12 @@ int tick();
void sendTunnelData(std::string destPeerId, std::string relayPeerId, void *data, int data_length);
//to establish a connection, send a ping (just a empty data packet)
void pingTunnelConnection(std::string relayPeerId, std::string destPeerId);
void initiateHandshake(std::string relayPeerId, std::string destPeerId);
private:
void sendTunnelDataPrivate(int connection_accept, std::string to, std::string sourcePeerId, std::string relayPeerId, std::string destPeerId, void *data, int data_length);
void sendTunnelDataPrivate(std::string to, std::string sourcePeerId, std::string relayPeerId, std::string destPeerId, void *data, int data_length);
void privateRecvTunnelDataRelaying(RsTunnelDataItem *item); //invoked when I am relaying
void privateRecvTunnelDataDestination(RsTunnelDataItem *item); //invoked when I am the destination of the tunnel
@ -65,6 +65,7 @@ void privateRecvTunnelDataDestination(RsTunnelDataItem *item); //invoked when I
/* Network Input */
int handleIncoming();
void recvTunnelData(RsTunnelDataItem *item);
void recvTunnelHandshake(RsTunnelHandshakeItem *item);
private: