started implementation of new Global Router model. Switched msg service to use it (much simpler now!), and updated GUI. Implemented half the tunnel management logic.

git-svn-id: http://svn.code.sf.net/p/retroshare/code/branches/v0.6-NewGRouterModel@7838 b45a01b8-16f6-495d-af2f-9b41ad6348cc
This commit is contained in:
csoler 2015-01-11 22:18:28 +00:00
parent 41a5c48243
commit e8f5f44318
22 changed files with 1091 additions and 1488 deletions

@ -49,7 +49,7 @@ class GRouterClientService
//
// GRouter stays owner of the item, so the client should not delete it!
//
virtual void receiveGRouterData(const GRouterKeyId& destination_key, const RsGRouterGenericDataItem * /*item*/)
virtual void receiveGRouterData(const RsGxsId& destination_key,const RsGxsId& signing_key, GRouterServiceId &client_id, uint8_t *data, uint32_t data_size)
{
std::cerr << "!!!!!! Received Data from global router, but the client service is not handling it !!!!!!!!!!" << std::endl ;
std::cerr << " destination key_id = " << destination_key.toStdString() << std::endl;

@ -29,118 +29,6 @@ bool RsGRouterItem::serialise_header(void *data,uint32_t& pktsize,uint32_t& tlvs
return true ;
}
/* serialise the data to the buffer */
// uint32_t RsGRouterPublishKeyItem::serial_size() const
// {
// uint32_t s = 8 ; // header
// s += POW_PAYLOAD_SIZE ; // proof of work bytes
// s += 4 ; // diffusion_id
// s += published_key.serial_size() ; // sha1 for published_key
// s += 4 ; // service id
// s += 4 ; // randomized distance
// s += GetTlvStringSize(description_string) ; // description
// s += fingerprint.serial_size() ; // fingerprint
//
// return s ;
// }
//bool RsGRouterPublishKeyItem::serialise(void *data, uint32_t& pktsize) const
//{
// uint32_t tlvsize,offset=0;
// bool ok = true;
//
// if(!serialise_header(data,pktsize,tlvsize,offset))
// return false ;
//
// memcpy(&((uint8_t*)data)[offset],pow_bytes,POW_PAYLOAD_SIZE) ;
// offset += 8 ;
//
// /* add mandatory parts first */
// ok &= setRawUInt32(data, tlvsize, &offset, diffusion_id);
// ok &= published_key.serialise(data, tlvsize, offset) ;
// ok &= setRawUInt32(data, tlvsize, &offset, service_id);
// ok &= setRawUFloat32(data, tlvsize, &offset, randomized_distance);
// ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_VALUE, description_string);
// ok &= fingerprint.serialise(data, tlvsize, offset) ;
//
// if (offset != tlvsize)
// {
// ok = false;
// std::cerr << "RsFileItemSerialiser::serialiseData() Size Error! " << std::endl;
// }
//
// return ok;
//}
/**********************************************************************************************/
/* PROOF OF WORK STUFF */
/**********************************************************************************************/
bool RsGRouterProofOfWorkObject::checkProofOfWork()
{
uint32_t size = serial_size() ;
unsigned char *mem = (unsigned char *)malloc(size) ;
if(mem == NULL)
{
std::cerr << "RsGRouterProofOfWorkObject: cannot allocate memory for " << size << " bytes." << std::endl;
return false ;
}
serialise(mem,size) ;
bool res = checkProofOfWork(mem,size) ;
free(mem) ;
return res ;
}
bool RsGRouterProofOfWorkObject::updateProofOfWork()
{
uint32_t size = serial_size() ;
unsigned char *mem = (unsigned char *)malloc(size) ;
if(mem == NULL)
{
std::cerr << "RsGRouterProofOfWorkObject: cannot allocate memory for " << size << " bytes." << std::endl;
return false ;
}
serialise(mem,size) ;
memset(mem,0,POW_PAYLOAD_SIZE) ; // init the payload
while(true)
{
if(checkProofOfWork(mem,size))
break ;
int k ;
for(k=0;k<POW_PAYLOAD_SIZE;++k)
{
++mem[k] ;
if(mem[k]!=0)
break ;
}
if(k == POW_PAYLOAD_SIZE)
return false ;
}
memcpy(pow_bytes,mem,POW_PAYLOAD_SIZE) ; // copy the good bytes.
free(mem) ;
return true ;
}
bool RsGRouterProofOfWorkObject::checkProofOfWork(unsigned char *mem,uint32_t size)
{
Sha1CheckSum sum = RsDirUtil::sha1sum(mem,size) ;
for(int i=0;i<PROOF_OF_WORK_REQUESTED_BYTES;++i)
if(sum.toByteArray()[i] != 0)
return false ;
return true ;
}
/**********************************************************************************************/
/* SERIALISER STUFF */
/**********************************************************************************************/
@ -158,9 +46,9 @@ RsItem *RsGRouterSerialiser::deserialise(void *data, uint32_t *pktsize)
switch(getRsItemSubType(rstype))
{
//case RS_PKT_SUBTYPE_GROUTER_PUBLISH_KEY: return deserialise_RsGRouterPublishKeyItem(data, *pktsize);
case RS_PKT_SUBTYPE_GROUTER_DATA: return deserialise_RsGRouterGenericDataItem(data, *pktsize);
case RS_PKT_SUBTYPE_GROUTER_ACK: return deserialise_RsGRouterACKItem(data, *pktsize);
case RS_PKT_SUBTYPE_GROUTER_MATRIX_CLUES: return deserialise_RsGRouterMatrixCluesItem(data, *pktsize);
case RS_PKT_SUBTYPE_GROUTER_DATA: return deserialise_RsGRouterGenericDataItem(data, *pktsize);
case RS_PKT_SUBTYPE_GROUTER_RECEIPT: return deserialise_RsGRouterReceiptItem(data, *pktsize);
case RS_PKT_SUBTYPE_GROUTER_MATRIX_CLUES: return deserialise_RsGRouterMatrixCluesItem(data, *pktsize);
case RS_PKT_SUBTYPE_GROUTER_FRIENDS_LIST: return deserialise_RsGRouterMatrixFriendListItem(data, *pktsize);
case RS_PKT_SUBTYPE_GROUTER_ROUTING_INFO: return deserialise_RsGRouterRoutingInfoItem(data, *pktsize);
default:
@ -170,33 +58,6 @@ RsItem *RsGRouterSerialiser::deserialise(void *data, uint32_t *pktsize)
return NULL;
}
//RsGRouterPublishKeyItem *RsGRouterSerialiser::deserialise_RsGRouterPublishKeyItem(void *data, uint32_t pktsize) const
//{
// uint32_t offset = 8; // skip the header
// uint32_t rssize = getRsItemSize(data);
// bool ok = true ;
//
// RsGRouterPublishKeyItem *item = new RsGRouterPublishKeyItem() ;
//
// memcpy(&((uint8_t*)data)[offset],item->pow_bytes,RsGRouterProofOfWorkObject::POW_PAYLOAD_SIZE) ;
// offset += 8 ;
//
// ok &= getRawUInt32(data, pktsize, &offset, &item->diffusion_id); // file hash
// ok &= item->published_key.deserialise(data, pktsize, offset) ;
// ok &= getRawUInt32(data, pktsize, &offset, &item->service_id); // file hash
// ok &= getRawUFloat32(data, pktsize, &offset, item->randomized_distance); // file hash
// ok &= GetTlvString(data, pktsize, &offset, TLV_TYPE_STR_VALUE,item->description_string);
// ok &= item->fingerprint.deserialise(data,pktsize,offset) ;
//
// if (offset != rssize || !ok)
// {
// std::cerr << __PRETTY_FUNCTION__ << ": error while deserialising! Item will be dropped." << std::endl;
// return NULL ;
// }
//
// return item;
//}
RsGRouterGenericDataItem *RsGRouterSerialiser::deserialise_RsGRouterGenericDataItem(void *data, uint32_t pktsize) const
{
uint32_t offset = 8; // skip the header
@ -207,10 +68,9 @@ RsGRouterGenericDataItem *RsGRouterSerialiser::deserialise_RsGRouterGenericDataI
ok &= getRawUInt64(data, pktsize, &offset, &item->routing_id);
ok &= item->destination_key.deserialise(data, pktsize, offset) ;
ok &= getRawUInt32(data, pktsize, &offset, &item->randomized_distance);
ok &= getRawUInt32(data, pktsize, &offset, &item->data_size);
if( NULL == (item->data_bytes = (uint8_t*)malloc(item->data_size)))
if( NULL == (item->data_bytes = (uint8_t*)malloc(item->data_size)))
{
std::cerr << __PRETTY_FUNCTION__ << ": Cannot allocate memory for chunk " << item->data_size << std::endl;
return NULL ;
@ -219,7 +79,12 @@ RsGRouterGenericDataItem *RsGRouterSerialiser::deserialise_RsGRouterGenericDataI
memcpy(item->data_bytes,&((uint8_t*)data)[offset],item->data_size) ;
offset += item->data_size ;
if (offset != rssize || !ok)
ok &= item->signature.GetTlv(data, pktsize, &offset) ;
ok &= getRawUInt32(data, pktsize, &offset, &item->randomized_distance);
ok &= getRawUInt32(data, pktsize, &offset, &item->flags);
if (offset != rssize || !ok)
{
std::cerr << __PRETTY_FUNCTION__ << ": error while deserialising! Item will be dropped." << std::endl;
return NULL ;
@ -228,16 +93,18 @@ RsGRouterGenericDataItem *RsGRouterSerialiser::deserialise_RsGRouterGenericDataI
return item;
}
RsGRouterACKItem *RsGRouterSerialiser::deserialise_RsGRouterACKItem(void *data, uint32_t pktsize) const
RsGRouterReceiptItem *RsGRouterSerialiser::deserialise_RsGRouterReceiptItem(void *data, uint32_t pktsize) const
{
uint32_t offset = 8; // skip the header
uint32_t rssize = getRsItemSize(data);
bool ok = true ;
RsGRouterACKItem *item = new RsGRouterACKItem() ;
RsGRouterReceiptItem *item = new RsGRouterReceiptItem() ;
ok &= getRawUInt64(data, pktsize, &offset, &item->mid); // file hash
ok &= getRawUInt32(data, pktsize, &offset, &item->state); // file hash
ok &= getRawUInt64(data, pktsize, &offset, &item->mid);
ok &= getRawUInt32(data, pktsize, &offset, &item->state);
ok &= item->destination_key.deserialise(data, pktsize, offset);
ok &= item->signature.GetTlv(data, pktsize, &offset); // signature
if (offset != rssize || !ok)
{
@ -256,26 +123,10 @@ RsGRouterRoutingInfoItem *RsGRouterSerialiser::deserialise_RsGRouterRoutingInfoI
RsGRouterRoutingInfoItem *item = new RsGRouterRoutingInfoItem() ;
ok &= getRawUInt32(data, pktsize, &offset, &item->status_flags);
ok &= item->origin.deserialise(data, pktsize, offset) ;
ok &= getRawTimeT(data, pktsize, &offset, item->received_time);
ok &= getRawTimeT(data, pktsize, &offset, item->last_sent);
ok &= getRawUInt32(data, pktsize, &offset, &item->client_id);
uint32_t s = 0 ;
ok &= getRawUInt32(data, pktsize, &offset, &s) ;
for(uint32_t i=0;i<s;++i)
{
FriendTrialRecord ftr ;
ok &= ftr.friend_id.deserialise(data, pktsize, offset) ;
ok &= getRawTimeT(data, pktsize, &offset, ftr.time_stamp) ;
ok &= getRawUFloat32(data, pktsize, &offset, ftr.probability) ;
ok &= getRawUInt32(data, pktsize, &offset, &ftr.nb_friends) ;
item->tried_friends.push_back(ftr) ;
}
ok &= getRawUInt32(data, pktsize, &offset, &item->data_status);
ok &= getRawTimeT(data, pktsize, &offset, item->received_time_TS);
ok &= getRawTimeT(data, pktsize, &offset, item->last_sent_TS);
ok &= getRawUInt32(data, pktsize, &offset, &item->client_id);
item->data_item = deserialise_RsGRouterGenericDataItem(&((uint8_t*)data)[offset],pktsize - offset) ;
if(item->data_item != NULL)
@ -360,61 +211,105 @@ RsGRouterGenericDataItem *RsGRouterGenericDataItem::duplicate() const
item->routing_id = routing_id ;
item->destination_key = destination_key ;
item->data_size = data_size ;
item->randomized_distance = randomized_distance ;
// then duplicate the memory chunk
item->data_bytes = (uint8_t*)malloc(data_size) ;
memcpy(item->data_bytes,data_bytes,data_size) ;
return item ;
}
item->signature = signature ;
item->randomized_distance = randomized_distance ;
item->flags = flags ;
return item ;
}
uint32_t RsGRouterGenericDataItem::serial_size() const
{
uint32_t s = 8 ; // header
s += sizeof(GRouterMsgPropagationId) ; // routing id
s += destination_key.serial_size() ; // destination_key
s += 4 ; // randomized distance
s += 4 ; // data_size
s += data_size ; // data
uint32_t s = 8 ; // header
s += sizeof(GRouterMsgPropagationId) ; // routing id
s += destination_key.serial_size() ; // destination_key
s += 4 ; // data_size
s += data_size ; // data
s += signature.TlvSize() ; // signature
s += 4 ; // randomized distance
s += 4 ; // flags
return s ;
return s ;
}
uint32_t RsGRouterACKItem::serial_size() const
uint32_t RsGRouterGenericDataItem::signed_data_size() const
{
uint32_t s = 0 ; // no header
s += sizeof(GRouterMsgPropagationId) ; // routing id
s += destination_key.serial_size() ; // destination_key
s += 4 ; // data_size
s += data_size ; // data
return s ;
}
uint32_t RsGRouterReceiptItem::serial_size() const
{
uint32_t s = 8 ; // header
s += sizeof(GRouterMsgPropagationId) ; // routing id
s += 4 ; // state
s += destination_key.serial_size() ; // destination_key
s += 4 ; // state
s += signature.TlvSize() ; // signature
return s ;
}
bool RsGRouterGenericDataItem::serialise(void *data,uint32_t& size) const
{
uint32_t tlvsize,offset=0;
bool ok = true;
if(!serialise_header(data,size,tlvsize,offset))
return false ;
uint32_t tlvsize,offset=0;
bool ok = true;
/* add mandatory parts first */
ok &= setRawUInt64(data, tlvsize, &offset, routing_id);
ok &= destination_key.serialise(data, tlvsize, offset) ;
ok &= setRawUInt32(data, tlvsize, &offset, randomized_distance) ;
ok &= setRawUInt32(data, tlvsize, &offset, data_size);
if(!serialise_header(data,size,tlvsize,offset))
return false ;
memcpy(&((uint8_t*)data)[offset],data_bytes,data_size) ;
offset += data_size ;
/* add mandatory parts first */
ok &= setRawUInt64(data, tlvsize, &offset, routing_id);
ok &= destination_key.serialise(data, tlvsize, offset) ;
ok &= setRawUInt32(data, tlvsize, &offset, data_size);
if (offset != tlvsize)
{
ok = false;
memcpy(&((uint8_t*)data)[offset],data_bytes,data_size) ;
offset += data_size ;
ok &= signature.SetTlv(data, tlvsize, &offset) ;
ok &= setRawUInt32(data, tlvsize, &offset, randomized_distance) ;
ok &= setRawUInt32(data, tlvsize, &offset, flags) ;
if (offset != tlvsize)
{
ok = false;
std::cerr << "RsGRouterGenericDataItem::serialisedata() size error! " << std::endl;
}
}
return ok;
return ok;
}
bool RsGRouterACKItem::serialise(void *data,uint32_t& size) const
bool RsGRouterGenericDataItem::serialise_signed_data(void *data,uint32_t& size) const
{
bool ok = true;
uint32_t offset = 0;
uint32_t tlvsize = signed_data_size() ;
/* add mandatory parts first */
ok &= setRawUInt64(data, tlvsize, &offset, routing_id);
ok &= destination_key.serialise(data, tlvsize, offset) ;
ok &= setRawUInt32(data, tlvsize, &offset, data_size);
memcpy(&((uint8_t*)data)[offset],data_bytes,data_size) ;
offset += data_size ;
if (offset != tlvsize)
{
ok = false;
std::cerr << "RsGRouterGenericDataItem::serialisedata() size error! " << std::endl;
}
return ok;
}
bool RsGRouterReceiptItem::serialise(void *data,uint32_t& size) const
{
uint32_t tlvsize,offset=0;
bool ok = true;
@ -423,13 +318,15 @@ bool RsGRouterACKItem::serialise(void *data,uint32_t& size) const
return false ;
/* add mandatory parts first */
ok &= setRawUInt64(data, tlvsize, &offset, mid);
ok &= setRawUInt64(data, tlvsize, &offset, mid);
ok &= setRawUInt32(data, tlvsize, &offset, state);
ok &= destination_key.serialise(data,tlvsize,offset) ;
ok &= signature.SetTlv(data,tlvsize,&offset) ;
if (offset != tlvsize)
{
ok = false;
std::cerr << "RsGRouterACKItem::serialisedata() size error! " << std::endl;
std::cerr << "RsGRouterReceiptItem::serialisedata() size error! " << std::endl;
}
return ok;
@ -458,12 +355,10 @@ uint32_t RsGRouterRoutingInfoItem::serial_size() const
{
uint32_t s = 8 ; // header
s += 4 ; // status_flags
s += origin.serial_size() ; // origin
s += 8 ; // received_time
s += 8 ; // last_sent
s += 4 ; // tried_friends.size() ;
s += sizeof(GRouterServiceId) ; // service_id
s += tried_friends.size() * ( RsPeerId::SIZE_IN_BYTES + 8 + 4 + 4 ) ; // FriendTrialRecord
s += data_item->serial_size(); // data_item
return s ;
@ -545,19 +440,14 @@ bool RsGRouterRoutingInfoItem::serialise(void *data,uint32_t& size) const
if(!serialise_header(data,size,tlvsize,offset))
return false ;
ok &= setRawUInt32(data, tlvsize, &offset, status_flags) ;
ok &= origin.serialise(data, tlvsize, offset) ;
ok &= setRawTimeT(data, tlvsize, &offset, received_time) ;
ok &= setRawTimeT(data, tlvsize, &offset, last_sent) ;
ok &= setRawUInt32(data, tlvsize, &offset, data_status) ;
ok &= setRawTimeT(data, tlvsize, &offset, received_time_TS) ;
ok &= setRawTimeT(data, tlvsize, &offset, last_sent_TS) ;
ok &= setRawUInt32(data, tlvsize, &offset, client_id) ;
ok &= setRawUInt32(data, tlvsize, &offset, tried_friends.size()) ;
for(std::list<FriendTrialRecord>::const_iterator it(tried_friends.begin());it!=tried_friends.end();++it)
ok &= (*it).serialise(data,offset,size) ;
uint32_t ns = size - offset ;
ok &= data_item->serialise( &((uint8_t*)data)[offset], ns) ;
offset += ns ;
uint32_t ns = size - offset ;
ok &= data_item->serialise( &((uint8_t*)data)[offset], ns) ;
offset += ns ;
if (offset != tlvsize)
{
@ -572,51 +462,43 @@ bool RsGRouterRoutingInfoItem::serialise(void *data,uint32_t& size) const
// ------------------------------------- IO --------------------------------------- //
// -----------------------------------------------------------------------------------//
//
//std::ostream& RsGRouterPublishKeyItem::print(std::ostream& o, uint16_t)
//{
// o << "GRouterPublishKeyItem:" << std::endl ;
// o << " POW bytes : \""<< RsPgpId(pow_bytes).toStdString() << "\"" << std::endl ;
// o << " direct origin: \""<< PeerId() << "\"" << std::endl ;
// o << " Key: " << published_key.toStdString() << std::endl ;
// o << " Req. Id: " << std::hex << diffusion_id << std::dec << std::endl ;
// o << " Srv. Id: " << std::hex << service_id << std::dec << std::endl ;
// o << " Distance: " << randomized_distance << std::endl ;
// o << " Description: " << description_string << std::endl ;
// o << " Fingerprint: " << fingerprint.toStdString() << std::endl ;
//
// return o ;
//}
std::ostream& RsGRouterACKItem::print(std::ostream& o, uint16_t)
std::ostream& RsGRouterReceiptItem::print(std::ostream& o, uint16_t)
{
o << "RsGRouterACKItem:" << std::endl ;
o << " direct origin: \""<< PeerId() << "\"" << std::endl ;
o << " Mid: " << mid << std::endl ;
o << " State: " << state << std::endl ;
o << "RsGRouterReceiptItem:" << std::endl ;
o << " direct origin: \""<< PeerId() << "\"" << std::endl ;
o << " Mid: " << mid << std::endl ;
o << " State: " << state << std::endl ;
o << " Dest: " << destination_key << std::endl ;
o << " Sign: " << signature.keyId << std::endl ;
return o ;
return o ;
}
std::ostream& RsGRouterGenericDataItem::print(std::ostream& o, uint16_t)
{
o << "RsGRouterGenericDataItem:" << std::endl ;
o << " direct origin: \""<< PeerId() << "\"" << std::endl ;
o << " Key: " << destination_key.toStdString() << std::endl ;
o << " Data size: " << data_size << std::endl ;
o << "RsGRouterGenericDataItem:" << std::endl ;
o << " Direct origin: \""<< PeerId() << "\"" << std::endl ;
o << " Routing ID: " << std::hex << routing_id << std::dec << "\"" << std::endl ;
o << " Key: " << destination_key.toStdString() << std::endl ;
o << " Data size: " << data_size << std::endl ;
o << " Data hash: " << RsDirUtil::sha1sum(data_bytes,data_size) << std::endl ;
o << " signature key: " << signature.keyId << std::endl;
o << " randomized dist:" << randomized_distance << std::endl;
o << " flags: " << flags << std::endl;
return o ;
return o ;
}
std::ostream& RsGRouterRoutingInfoItem::print(std::ostream& o, uint16_t)
{
o << "RsGRouterRoutingInfoItem:" << std::endl ;
o << " direct origin: \""<< PeerId() << "\"" << std::endl ;
o << " origin: "<< origin.toStdString() << std::endl ;
o << " recv time: "<< received_time << std::endl ;
o << " Last sent: "<< last_sent << std::endl ;
o << " flags: "<< std::hex << status_flags << std::dec << std::endl ;
o << " Key: "<< data_item->destination_key.toStdString() << std::endl ;
o << " Data size: "<< data_item->data_size << std::endl ;
o << " recv time: "<< received_time_TS << std::endl ;
o << " Last sent: "<< last_sent_TS << std::endl ;
o << " flags: "<< std::hex << data_status << std::dec << std::endl ;
o << " Key 1: "<< destination_key << std::endl ;
o << " Key 2: "<< data_item->destination_key << std::endl ;
o << " Data size: "<< data_item->data_size << std::endl ;
o << " Client id: "<< client_id << std::endl ;
o << " Tried friends: "<< tried_friends.size() << std::endl;
return o ;
}

@ -26,23 +26,25 @@
#pragma once
#include "serialiser/rsserial.h"
#include "serialiser/rstlvkeys.h"
#include "serialiser/rsserviceids.h"
#include "retroshare/rstypes.h"
#include "retroshare/rsgrouter.h"
#include "p3grouter.h"
const uint8_t RS_PKT_SUBTYPE_GROUTER_PUBLISH_KEY = 0x01 ; // used to publish a key
const uint8_t RS_PKT_SUBTYPE_GROUTER_ACK = 0x03 ; // acknowledgement of data received
const uint8_t RS_PKT_SUBTYPE_GROUTER_DATA = 0x05 ; // used to send data to a destination
const uint8_t RS_PKT_SUBTYPE_GROUTER_PUBLISH_KEY = 0x01 ; // used to publish a key
const uint8_t RS_PKT_SUBTYPE_GROUTER_ACK_deprecated = 0x03 ; // acknowledgement of data received
const uint8_t RS_PKT_SUBTYPE_GROUTER_RECEIPT = 0x04 ; // acknowledgement of data received
const uint8_t RS_PKT_SUBTYPE_GROUTER_DATA_deprecated = 0x05 ; // used to send data to a destination
const uint8_t RS_PKT_SUBTYPE_GROUTER_DATA = 0x06 ; // used to send data to a destination (Signed by source)
const uint8_t RS_PKT_SUBTYPE_GROUTER_MATRIX_CLUES = 0x80 ; // item to save matrix clues
const uint8_t RS_PKT_SUBTYPE_GROUTER_FRIENDS_LIST = 0x82 ; // item to save friend lists
const uint8_t RS_PKT_SUBTYPE_GROUTER_ROUTING_INFO = 0x87 ; // item to save routing info
const uint8_t RS_PKT_SUBTYPE_GROUTER_MATRIX_CLUES = 0x80 ; // item to save matrix clues
const uint8_t RS_PKT_SUBTYPE_GROUTER_FRIENDS_LIST = 0x82 ; // item to save friend lists
const uint8_t RS_PKT_SUBTYPE_GROUTER_ROUTING_INFO_deprecated = 0x87 ; // deprecated. Don't use.
const uint8_t RS_PKT_SUBTYPE_GROUTER_ROUTING_INFO = 0x89 ; // item to save routing info
const uint8_t QOS_PRIORITY_RS_GROUTER_PUBLISH_KEY = 3 ; // slow items. No need to congest the network with this.
const uint8_t QOS_PRIORITY_RS_GROUTER_ACK = 3 ;
const uint8_t QOS_PRIORITY_RS_GROUTER_DATA = 3 ;
const uint8_t QOS_PRIORITY_RS_GROUTER = 3 ; // irrelevant since all items travel through tunnels
/***********************************************************************************/
@ -77,95 +79,63 @@ class RsGRouterNonCopyableObject
RsGRouterNonCopyableObject operator=(const RsGRouterNonCopyableObject&) { return *this ;}
};
class RsGRouterProofOfWorkObject
{
public:
RsGRouterProofOfWorkObject() {}
virtual bool serialise(void *data,uint32_t& size) const =0;
virtual uint32_t serial_size() const =0;
virtual bool checkProofOfWork() ; // checks that the serialized object hashes down to a hash beginning with LEADING_BYTES_SIZE zeroes
virtual bool updateProofOfWork() ; // computes the pow_bytes so that the hash starts with LEADING_BYTES_SIZE zeroes.
static bool checkProofOfWork(unsigned char *mem,uint32_t size) ;
static const int POW_PAYLOAD_SIZE = 8 ;
static const int PROOF_OF_WORK_REQUESTED_BYTES = 4 ;
unsigned char pow_bytes[POW_PAYLOAD_SIZE] ; // 8 bytes to put at the beginning of the serialized packet, so that
// the hash starts with a fixed number of zeroes.
};
/***********************************************************************************/
/* Specific packets */
/***********************************************************************************/
//class RsGRouterPublishKeyItem: public RsGRouterItem, public RsGRouterProofOfWorkObject
//{
// public:
// RsGRouterPublishKeyItem() : RsGRouterItem(RS_PKT_SUBTYPE_GROUTER_PUBLISH_KEY) { setPriorityLevel(QOS_PRIORITY_RS_GROUTER_PUBLISH_KEY) ; }
//
// virtual bool serialise(void *data,uint32_t& size) const ;
// virtual uint32_t serial_size() const ;
//
// virtual void clear() {}
// virtual std::ostream& print(std::ostream &out, uint16_t indent = 0) ;
//
// // packet data
// //
// GRouterKeyPropagationId diffusion_id ;
// GRouterKeyId published_key ;
// uint32_t service_id ;
// float randomized_distance ;
// std::string description_string ;
// PGPFingerprintType fingerprint ;
//
//};
class RsGRouterGenericDataItem: public RsGRouterItem, public RsGRouterNonCopyableObject
{
public:
RsGRouterGenericDataItem() : RsGRouterItem(RS_PKT_SUBTYPE_GROUTER_DATA) { setPriorityLevel(QOS_PRIORITY_RS_GROUTER_DATA) ; }
virtual ~RsGRouterGenericDataItem() { clear() ; }
public:
RsGRouterGenericDataItem() : RsGRouterItem(RS_PKT_SUBTYPE_GROUTER_DATA) { setPriorityLevel(QOS_PRIORITY_RS_GROUTER) ; }
virtual ~RsGRouterGenericDataItem() { clear() ; }
virtual bool serialise(void *data,uint32_t& size) const ;
virtual uint32_t serial_size() const ;
virtual bool serialise(void *data,uint32_t& size) const ;
virtual uint32_t serial_size() const ;
virtual void clear()
{
free(data_bytes);
data_bytes=NULL;
}
virtual std::ostream& print(std::ostream &out, uint16_t indent = 0) ;
virtual void clear()
{
free(data_bytes);
data_bytes=NULL;
}
virtual std::ostream& print(std::ostream &out, uint16_t indent = 0) ;
RsGRouterGenericDataItem *duplicate() const ;
RsGRouterGenericDataItem *duplicate() const ;
// packet data
//
GRouterMsgPropagationId routing_id ;
GRouterKeyId destination_key ;
uint32_t randomized_distance ;
// packet data
//
GRouterMsgPropagationId routing_id ;
GRouterKeyId destination_key ;
uint32_t data_size ;
uint8_t *data_bytes;
uint32_t data_size ;
uint8_t *data_bytes;
RsTlvKeySignature signature ; // signature by sender's key
uint32_t randomized_distance ; // number of hops (tunnel wise. Does not preclude of the real distance)
uint32_t flags ;
// utility methods for signing data
uint32_t signed_data_size() const ;
bool serialise_signed_data(void *data,uint32_t& size) const ;
};
class RsGRouterACKItem: public RsGRouterItem
class RsGRouterReceiptItem: public RsGRouterItem
{
public:
RsGRouterACKItem() : RsGRouterItem(RS_PKT_SUBTYPE_GROUTER_ACK) { setPriorityLevel(QOS_PRIORITY_RS_GROUTER_ACK) ; }
public:
RsGRouterReceiptItem() : RsGRouterItem(RS_PKT_SUBTYPE_GROUTER_RECEIPT) { setPriorityLevel(QOS_PRIORITY_RS_GROUTER) ; }
virtual bool serialise(void *data,uint32_t& size) const ;
virtual uint32_t serial_size() const ;
virtual bool serialise(void *data,uint32_t& size) const ;
virtual uint32_t serial_size() const ;
virtual void clear() {}
virtual std::ostream& print(std::ostream &out, uint16_t indent = 0) ;
virtual void clear() {}
virtual std::ostream& print(std::ostream &out, uint16_t indent = 0) ;
// packet data
//
GRouterMsgPropagationId mid ; // message id to which this ack is a response
uint32_t state ; // packet was delivered, not delivered, bounced, etc
// packet data
//
GRouterMsgPropagationId mid ; // message id to which this ack is a response
GRouterKeyId destination_key ; // This is the key to the peer we're reponding to.
uint32_t state ; // packet was delivered, not delivered, bounced, etc
RsTlvKeySignature signature ; // signs mid+destination_key+state
};
// Items for saving the routing matrix information.
@ -192,7 +162,7 @@ class RsGRouterMatrixFriendListItem: public RsGRouterItem
{
public:
RsGRouterMatrixFriendListItem() : RsGRouterItem(RS_PKT_SUBTYPE_GROUTER_FRIENDS_LIST)
{ setPriorityLevel(0) ; } // this item is never sent through the network
{ setPriorityLevel(0) ; } // this item is never sent through the network
virtual bool serialise(void *data,uint32_t& size) const ;
virtual uint32_t serial_size() const ;
@ -221,7 +191,6 @@ class RsGRouterRoutingInfoItem: public RsGRouterItem, public GRouterRoutingInfo,
if(data_item != NULL)
delete data_item ;
data_item = NULL ;
tried_friends.clear() ;
}
virtual std::ostream& print(std::ostream &out, uint16_t indent = 0) ;
};
@ -246,10 +215,9 @@ class RsGRouterSerialiser: public RsSerialType
virtual RsItem *deserialise (void *data, uint32_t *size) ;
private:
//RsGRouterPublishKeyItem *deserialise_RsGRouterPublishKeyItem(void *data,uint32_t size) const ;
RsGRouterGenericDataItem *deserialise_RsGRouterGenericDataItem(void *data,uint32_t size) const ;
RsGRouterACKItem *deserialise_RsGRouterACKItem(void *data,uint32_t size) const ;
RsGRouterMatrixCluesItem *deserialise_RsGRouterMatrixCluesItem(void *data,uint32_t size) const ;
RsGRouterGenericDataItem *deserialise_RsGRouterGenericDataItem(void *data,uint32_t size) const ;
RsGRouterReceiptItem *deserialise_RsGRouterReceiptItem(void *data,uint32_t size) const ;
RsGRouterMatrixCluesItem *deserialise_RsGRouterMatrixCluesItem(void *data,uint32_t size) const ;
RsGRouterMatrixFriendListItem *deserialise_RsGRouterMatrixFriendListItem(void *data,uint32_t size) const ;
RsGRouterRoutingInfoItem *deserialise_RsGRouterRoutingInfoItem(void *data,uint32_t size) const ;
};

@ -29,11 +29,12 @@
#include <time.h>
#include <list>
#include "pgp/rscertificate.h"
#include "turtle/p3turtle.h"
#include "retroshare/rsgrouter.h"
class RsGRouterGenericDataItem ;
static const uint32_t GROUTER_CLIENT_ID_MESSAGES = 0x1001 ;
static const uint16_t GROUTER_CLIENT_ID_MESSAGES = 0x1001 ;
static const uint32_t RS_GROUTER_MATRIX_MAX_HIT_ENTRIES = 10; // max number of clues to store
static const uint32_t RS_GROUTER_MATRIX_MIN_TIME_BETWEEN_HITS = 60; // can be set to up to half the publish time interval. Prevents flooding routes.
@ -51,21 +52,18 @@ static const time_t RS_GROUTER_MEAN_EXPECTED_RTT = 30 ; // refer
static const uint32_t GROUTER_ITEM_DISTANCE_UNIT = 256 ; // One unit of distance between two peers
static const uint32_t GROUTER_ITEM_MAX_TRAVEL_DISTANCE = 6*256 ; // 6 distance units. That is a lot.
static const uint32_t GROUTER_ITEM_MAX_CACHE_KEEP_TIME = 30*86400 ; // ACKN Items are kept in cache for 1 month, to allow sending acknowledgements to peers while not online.
static const uint32_t GROUTER_ITEM_MAX_CACHE_KEEP_TIME = 86400 ; // Cached items are kept for 24 hours at most.
static const uint32_t GROUTER_ITEM_MAX_CACHE_KEEP_TIME_DEAD= 3600 ; // DEAD Items are kept in cache for only 1 hour to favor re-exploring dead routes.
static const uint32_t RS_GROUTER_ROUTING_STATE_UNKN = 0x0000 ; // unknown. Unused.
static const uint32_t RS_GROUTER_ROUTING_STATE_PEND = 0x0001 ; // item is pending. Should be sent asap.
static const uint32_t RS_GROUTER_ROUTING_STATE_SENT = 0x0002 ; // item is sent. Waiting for answer
static const uint32_t RS_GROUTER_ROUTING_STATE_ARVD = 0x0003 ; // item is at destination. The cache only holds it to avoid duplication.
static const uint32_t RS_GROUTER_ROUTING_STATE_DEAD = 0x0004 ; // item is at a dead end.
static const uint32_t RS_GROUTER_DATA_STATUS_UNKNOWN = 0x0000 ; // unknown. Unused.
static const uint32_t RS_GROUTER_DATA_STATUS_PENDING = 0x0001 ; // item is pending. Should be sent asap.
static const uint32_t RS_GROUTER_DATA_STATUS_SENT = 0x0002 ; // item is sent. Waiting for answer
static const uint32_t RS_GROUTER_DATA_STATUS_ACKOWLG = 0x0003 ; // item is at destination. The cache only holds it to avoid duplication.
static const uint32_t RS_GROUTER_ACK_STATE_UNKN = 0x0000 ; // unknown destination key
static const uint32_t RS_GROUTER_ACK_STATE_RCVD = 0x0001 ; // data was received, directly
static const uint32_t RS_GROUTER_ACK_STATE_IRCV = 0x0002 ; // data was received indirectly
static const uint32_t RS_GROUTER_ACK_STATE_GVNP = 0x0003 ; // data was given up. No route.
static const uint32_t RS_GROUTER_ACK_STATE_NORO = 0x0004 ; // data was given up. No route.
static const uint32_t RS_GROUTER_ACK_STATE_TOOF = 0x0005 ; // dropped because of distance (too far)
static const uint32_t RS_GROUTER_TUNNEL_STATUS_UNMANAGED = 0x0000 ;// unknown destination key
static const uint32_t RS_GROUTER_TUNNEL_STATUS_PENDING = 0x0001 ;// unknown destination key
static const uint32_t RS_GROUTER_TUNNEL_STATUS_READY = 0x0002 ;// unknown destination key
static const uint32_t RS_GROUTER_TUNNEL_STATUS_CAN_SEND = 0x0003 ;// unknown destination key
class FriendTrialRecord
{
@ -82,15 +80,17 @@ class FriendTrialRecord
class GRouterRoutingInfo
{
public:
uint32_t status_flags ; // pending, waiting, etc.
RsPeerId origin ; // which friend sent us that item
time_t received_time ; // time at which the item was originally received
time_t last_sent ; // last time the item was sent to friends
uint32_t data_status ; // pending, waiting, etc.
uint32_t tunnel_status ; // status of tunnel handling.
time_t received_time_TS ; // time at which the item was originally received
time_t last_sent_TS ; // last time the item was sent to friends
time_t last_tunnel_request_TS ; // last time tunnels have been asked for this item.
uint32_t sending_attempts ; // number of times tunnels have been asked for this peer without success
std::list<FriendTrialRecord> tried_friends ; // list of friends to which the item was sent ordered with time.
GRouterKeyId destination_key ; // ultimate destination for this key
GRouterServiceId client_id ; // service ID of the client. Only valid when origin==OwnId
RsGxsId destination_key ; // ultimate destination for this key
GRouterServiceId client_id ; // service ID of the client. Only valid when origin==OwnId
TurtleFileHash tunnel_hash ; // tunnel hash to be used for this item
RsGRouterGenericDataItem *data_item ;
RsGRouterGenericDataItem *data_item ;
};

File diff suppressed because it is too large Load Diff

@ -31,227 +31,285 @@
#include "retroshare/rsgrouter.h"
#include "retroshare/rstypes.h"
#include "retroshare/rstypes.h"
#include "turtle/turtleclientservice.h"
#include "services/p3service.h"
#include "pqi/p3cfgmgr.h"
#include "groutertypes.h"
#include "groutermatrix.h"
#include "grouteritems.h"
//#include "groutercache.h"
// To be put in pqi/p3cfgmgr.h
//
static const uint32_t CONFIG_TYPE_GROUTER = 0x0016 ;
static const uint32_t RS_GROUTER_DATA_FLAGS_ENCRYPTED = 0x0001 ;
class p3LinkMgr ;
class RsGRouterPublishKeyItem ;
class RsGRouterACKItem ;
class p3turtle ;
class p3IdService ;
class RsGRouterItem ;
class RsGRouterGenericDataItem ;
class RsGRouterReceiptItem ;
class p3GRouter: public RsGRouter, public p3Service, public p3Config
class GRouterTunnelInfo
{
public:
p3GRouter(p3ServiceControl *sc,p3LinkMgr *lm) ;
public:
GRouterTunnelInfo() :first_tunnel_ok_TS(0), last_tunnel_ok_TS(0) {}
//===================================================//
// Router clients business //
//===================================================//
void addVirtualPeer(const TurtleVirtualPeerId& vpid)
{
assert(virtual_peers.find(vpid) == virtual_peers.end()) ;
time_t now = time(NULL) ;
// This method allows to associate client ids (that are saved to disk) to client objects deriving
// from GRouterClientService. The various services are responsible for regstering themselves to the
// global router, with consistent ids. The services are stored in a map, and arriving objects are
// passed on the correct service depending on the client id of the key they are reaching.
//
virtual bool registerClientService(const GRouterServiceId& id,GRouterClientService *service) ;
virtual_peers.insert(vpid) ;
// Use this method to register/unregister a key that the global router will
// forward in the network, so that is can be a possible destination for
// global messages.
//
// key : The key that is published
// fingerp : Fingerprint of the key to encrypt the data.
// desc_str : Any fixed length string (< 20 characters) to descript the address in words.
// client_id: id of the client service to send the traffic to.
// To obtain a client id, the service must register using the previous method.
//
// Unregistering a key might not have an instantaneous effect, so the client is responsible for
// discarding traffic that might later come for this key.
//
virtual bool registerKey(const GRouterKeyId& key, const GRouterServiceId& client_id,const std::string& description_string) ;
virtual bool unregisterKey(const GRouterKeyId& key) ;
if(first_tunnel_ok_TS == 0) first_tunnel_ok_TS = now ;
if(last_tunnel_ok_TS < now) last_tunnel_ok_TS = now ;
}
//===================================================//
// Routing clue collection methods //
//===================================================//
std::set<TurtleVirtualPeerId> virtual_peers ;
virtual void addRoutingClue(const GRouterKeyId& id,const RsPeerId& peer_id) ;
time_t first_tunnel_ok_TS ; // timestamp when 1st tunnel was received.
time_t last_tunnel_ok_TS ; // timestamp when last tunnel was received.
};
class p3GRouter: public RsGRouter, public RsTurtleClientService, public p3Service, public p3Config
{
public:
p3GRouter(p3ServiceControl *sc,p3IdService *is) ;
//===================================================//
// Client/server request services //
//===================================================//
//===================================================//
// Router clients business //
//===================================================//
// Sends an item to the given destination. The router takes ownership of
// the memory. That means item_data will be erase on return. The returned id should be
// remembered by the client, so that he knows when the data has been received.
// The client id is supplied so that the client can be notified when the data has been received.
//
virtual void sendData(const GRouterKeyId& destination,const GRouterServiceId& client_id, RsGRouterGenericDataItem *item,GRouterMsgPropagationId& id) ;
// This method allows to associate client ids (that are saved to disk) to client objects deriving
// from GRouterClientService. The various services are responsible for regstering themselves to the
// global router, with consistent ids. The services are stored in a map, and arriving objects are
// passed on the correct service depending on the client id of the key they are reaching.
//
virtual bool registerClientService(const GRouterServiceId& id,GRouterClientService *service) ;
// Sends an ACK to the origin of the msg. This is used to notify for
// unfound route, or message correctly received, depending on the particular situation.
//
virtual void sendACK(const RsPeerId& peer,GRouterMsgPropagationId mid, uint32_t flags) ;
// Use this method to register/unregister a key that the global router will
// forward in the network, so that is can be a possible destination for
// global messages.
//
// auth_id : The GXS key that will be used to sign the data Receipts.
// contact_key : The key that is used to open tunnels
// desc_str : Any fixed length string (< 20 characters) to descript the address in words.
// client_id : Id of the client service to send the traffic to.
// The client ID should match the ID that has been registered using the previous method.
//
// Unregistering a key might not have an instantaneous effect, so the client is responsible for
// discarding traffic that might later come for this key.
//
virtual bool registerKey(const RsGxsId& authentication_id, const GRouterServiceId& client_id,const std::string& description_string) ;
virtual bool unregisterKey(const RsGxsId &key_id, const GRouterServiceId &sid) ;
//===================================================//
// Interface with RsGRouter //
//===================================================//
//===================================================//
// Routing clue collection methods //
//===================================================//
// debug info from routing matrix
// - list of known key ids
// - list of clues/time_stamp for each key.
// - real time routing probabilities
//
virtual bool getRoutingMatrixInfo(GRouterRoutingMatrixInfo& info) ;
virtual void addRoutingClue(const GRouterKeyId& id,const RsPeerId& peer_id) ;
// debug info from routing cache
// - Cache Items
// * which message ids
// * directions
// * timestamp
// * message type
// - Cache state (memory size, etc)
//
virtual bool getRoutingCacheInfo(std::vector<GRouterRoutingCacheInfo>& info) ;
//===================================================//
// Client/server request services //
//===================================================//
//===================================================//
// Derived from p3Service //
//===================================================//
// Sends an item to the given destination. The router takes ownership of
// the memory. That means item_data will be erase on return. The returned id should be
// remembered by the client, so that he knows when the data has been received.
// The client id is supplied so that the client can be notified when the data has been received.
//
virtual bool sendData( const RsGxsId& destination,
const GRouterServiceId& client_id,
uint8_t *data,
uint32_t data_size,
const RsGxsId& signing_id,
GRouterMsgPropagationId& id) ;
virtual RsServiceInfo getServiceInfo()
{
return RsServiceInfo(RS_SERVICE_TYPE_GROUTER,
SERVICE_INFO_APP_NAME,
SERVICE_INFO_APP_MAJOR_VERSION,
SERVICE_INFO_APP_MINOR_VERSION,
SERVICE_INFO_MIN_MAJOR_VERSION,
SERVICE_INFO_MIN_MINOR_VERSION) ;
}
//===================================================//
// Interface with RsGRouter //
//===================================================//
virtual void setDebugEnabled(bool b) { _debug_enabled = b ; }
protected:
//===================================================//
// Routing method handling //
//===================================================//
// debug info from routing matrix
// - list of known key ids
// - list of clues/time_stamp for each key.
// - real time routing probabilities
//
virtual bool getRoutingMatrixInfo(GRouterRoutingMatrixInfo& info) ;
// Calls
// - autoWash()
// - packet handling methods
// - matrix updates
//
virtual int tick() ;
// debug info from routing cache
// - Cache Items
// * which message ids
// * directions
// * timestamp
// * message type
// - Cache state (memory size, etc)
//
virtual bool getRoutingCacheInfo(std::vector<GRouterRoutingCacheInfo>& info) ;
static const std::string SERVICE_INFO_APP_NAME ;
static const uint16_t SERVICE_INFO_APP_MAJOR_VERSION = 1;
static const uint16_t SERVICE_INFO_APP_MINOR_VERSION = 0;
static const uint16_t SERVICE_INFO_MIN_MAJOR_VERSION = 1;
static const uint16_t SERVICE_INFO_MIN_MINOR_VERSION = 0;
//===================================================//
// Derived from p3Service //
//===================================================//
private:
class nullstream: public std::ostream {};
virtual RsServiceInfo getServiceInfo()
{
return RsServiceInfo(RS_SERVICE_TYPE_GROUTER,
SERVICE_INFO_APP_NAME,
SERVICE_INFO_APP_MAJOR_VERSION,
SERVICE_INFO_APP_MINOR_VERSION,
SERVICE_INFO_MIN_MAJOR_VERSION,
SERVICE_INFO_MIN_MINOR_VERSION) ;
}
std::ostream& grouter_debug() const
{
static nullstream null ;
virtual void setDebugEnabled(bool b) { _debug_enabled = b ; }
return _debug_enabled?(std::cerr):null;
}
virtual void connectToTurtleRouter(p3turtle *pt) ;
void autoWash() ;
void routePendingObjects() ;
void handleIncoming() ;
void debugDump() ;
protected:
//===================================================//
// Routing method handling //
//===================================================//
// utility functions
//
static uint32_t computeBranchingFactor(const std::vector<RsPeerId>& friends,uint32_t dist) ;
std::set<uint32_t> computeRoutingFriends(const std::vector<RsPeerId>& friends,const std::vector<float>& probas,uint32_t N) ;
static float computeMatrixContribution(float base,uint32_t time_shift,float probability) ;
static time_t computeNextTimeDelay(time_t duration) ;
// Calls
// - autoWash()
// - packet handling methods
// - matrix updates
//
virtual int tick() ;
void locked_notifyClientAcknowledged(const GRouterMsgPropagationId& msg_id,const GRouterServiceId& service_id) const ;
static const std::string SERVICE_INFO_APP_NAME ;
static const uint16_t SERVICE_INFO_APP_MAJOR_VERSION = 1;
static const uint16_t SERVICE_INFO_APP_MINOR_VERSION = 0;
static const uint16_t SERVICE_INFO_MIN_MAJOR_VERSION = 1;
static const uint16_t SERVICE_INFO_MIN_MINOR_VERSION = 0;
uint32_t computeRandomDistanceIncrement(const RsPeerId& pid,const GRouterKeyId& destination_id) ;
//===================================================//
// Interaction with turtle router //
//===================================================//
//===================================================//
// p3Config methods //
//===================================================//
virtual bool handleTunnelRequest(const RsFileHash& /*hash*/,const RsPeerId& /*peer_id*/) ;
virtual void receiveTurtleData(RsTurtleGenericTunnelItem */*item*/,const RsFileHash& /*hash*/,const RsPeerId& /*virtual_peer_id*/,RsTurtleGenericTunnelItem::Direction /*direction*/);
virtual void addVirtualPeer(const TurtleFileHash& hash,const TurtleVirtualPeerId& virtual_peer_id,RsTurtleGenericTunnelItem::Direction dir) ;
virtual void removeVirtualPeer(const TurtleFileHash& hash,const TurtleVirtualPeerId& virtual_peer_id) ;
// Load/save the routing info, the pending items in transit, and the config variables.
//
virtual bool loadList(std::list<RsItem*>& items) ;
virtual bool saveList(bool& cleanup,std::list<RsItem*>& items) ;
private:
class nullstream: public std::ostream {};
virtual RsSerialiser *setupSerialiser() ;
std::ostream& grouter_debug() const
{
static nullstream null ;
//===================================================//
// Debug methods //
//===================================================//
return _debug_enabled?(std::cerr):null;
}
// Prints the internal state of the router, for debug purpose.
//
void debug_dump() ;
void autoWash() ;
void routePendingObjects() ;
void handleIncoming() ;
void handleTunnels() ;
// Stores the routing info
// - list of known key ids
// - list of clues/time_stamp for each key.
// - real time routing probabilities
//
GRouterMatrix _routing_matrix ;
void debugDump() ;
// Stores the routing events.
// - ongoing requests, waiting for return ACK
// - pending items
// Both a stored in 2 different lists, to allow a more efficient handling.
//
std::map<GRouterMsgPropagationId, GRouterRoutingInfo> _pending_messages;// pending messages
// utility functions
//
static float computeMatrixContribution(float base,uint32_t time_shift,float probability) ;
static time_t computeNextTimeDelay(time_t duration) ;
// Stores the keys which identify the router's node. For each key, a structure holds:
// - the client service
// - flags
// - usage time stamps
//
std::map<GRouterKeyId, GRouterPublishedKeyInfo> _owned_key_ids ;
void locked_notifyClientAcknowledged(const GRouterMsgPropagationId& msg_id,const GRouterServiceId& service_id) const ;
// Registered services. These are known to the different peers with a common id,
// so it's important to keep consistency here. This map is volatile, and re-created at each startup of
// the software, when newly created services register themselves.
uint32_t computeRandomDistanceIncrement(const RsPeerId& pid,const GRouterKeyId& destination_id) ;
std::map<GRouterServiceId,GRouterClientService *> _registered_services ;
// signs an item with the given key.
bool signDataItem(RsGRouterGenericDataItem *item,const RsGxsId& id) ;
bool verifySignedDataItem(RsGRouterGenericDataItem *item) ;
bool encryptDataItem(RsGRouterGenericDataItem *item,const RsGxsId& destination_key) ;
bool decryptDataItem(RsGRouterGenericDataItem *item) ;
Sha1CheckSum makeTunnelHash(const RsGxsId& destination,const GRouterServiceId& client);
void sendDataInTunnel(const TurtleVirtualPeerId& vpid,RsGRouterGenericDataItem *item);
// Data handling ethods
//
void handleRecvDataItem(RsGRouterGenericDataItem *item);
void handleRecvACKItem(RsGRouterACKItem *item);
//===================================================//
// p3Config methods //
//===================================================//
// Pointers to other RS objects
//
p3ServiceControl *mServiceControl ;
p3LinkMgr *mLinkMgr ;
// Load/save the routing info, the pending items in transit, and the config variables.
//
virtual bool loadList(std::list<RsItem*>& items) ;
virtual bool saveList(bool& cleanup,std::list<RsItem*>& items) ;
// Multi-thread protection mutex.
//
RsMutex grMtx ;
virtual RsSerialiser *setupSerialiser() ;
// config update/save variables
bool _changed ;
bool _debug_enabled ;
//===================================================//
// Debug methods //
//===================================================//
time_t _last_autowash_time ;
time_t _last_matrix_update_time ;
time_t _last_debug_output_time ;
time_t _last_config_changed ;
// Prints the internal state of the router, for debug purpose.
//
void debug_dump() ;
uint64_t _random_salt ;
//===================================================//
// Internal queues/variables //
//===================================================//
// Stores the routing info
// - list of known key ids
// - list of clues/time_stamp for each key.
// - real time routing probabilities
//
GRouterMatrix _routing_matrix ;
// Stores the keys which identify the router's node. For each key, a structure holds:
// - the client service
// - flags
// - usage time stamps
//
std::map<Sha1CheckSum, GRouterPublishedKeyInfo> _owned_key_ids ;
// Registered services. These are known to the different peers with a common id,
// so it's important to keep consistency here. This map is volatile, and re-created at each startup of
// the software, when newly created services register themselves.
std::map<GRouterServiceId,GRouterClientService *> _registered_services ;
// Stores the routing events.
// - ongoing requests, waiting for return ACK
// - pending items
// Both a stored in 2 different lists, to allow a more efficient handling.
//
std::map<GRouterMsgPropagationId, GRouterRoutingInfo> _pending_messages;// pending messages
std::map<TurtleFileHash,GRouterTunnelInfo> _virtual_peers ;
// Queue of incoming items. Might be receipts or data. Should always be empty (not a storage place)
std::list<RsGRouterItem*> _incoming_items ;
// Data handling methods
//
void handleRecvDataItem(RsGRouterGenericDataItem *item);
void handleRecvReceiptItem(RsGRouterReceiptItem *item);
// Pointers to other RS objects
//
p3ServiceControl *mServiceControl ;
p3turtle *mTurtle ;
p3IdService *mIdService ;
// Multi-thread protection mutex.
//
RsMutex grMtx ;
// config update/save variables
bool _changed ;
bool _debug_enabled ;
time_t _last_autowash_time ;
time_t _last_matrix_update_time ;
time_t _last_debug_output_time ;
time_t _last_config_changed ;
uint64_t _random_salt ;
};
template<typename T> p3GRouter::nullstream& operator<<(p3GRouter::nullstream& ns,const T&) { return ns ; }

@ -433,7 +433,8 @@ HEADERS += services/p3msgservice.h \
HEADERS += turtle/p3turtle.h \
turtle/rsturtleitem.h \
turtle/turtletypes.h
turtle/turtletypes.h \
turtle/turtleclientservice.h
HEADERS += util/folderiterator.h \
util/rsdebug.h \

@ -27,8 +27,9 @@
#include "util/rsdir.h"
#include "retroshare/rsids.h"
#include "retroshare/rsgxsifacetypes.h"
typedef GRouterKeyIdType GRouterKeyId ; // we use SSLIds, so that it's easier in the GUI to mix up peer ids with grouter ids.
typedef RsGxsId GRouterKeyId ; // we use SSLIds, so that it's easier in the GUI to mix up peer ids with grouter ids.
typedef uint32_t GRouterServiceId ;
typedef uint64_t GRouterMsgPropagationId ;
@ -52,8 +53,9 @@ class RsGRouter
struct GRouterPublishedKeyInfo
{
std::string description_string ;
uint32_t service_id ;
std::string description_string ;
RsGxsId authentication_key ;
uint32_t service_id ;
};
struct GRouterRoutingMatrixInfo
@ -85,8 +87,14 @@ class RsGRouter
// Communication to other services. //
//===================================================//
virtual void sendData(const GRouterKeyId& destination, const GRouterServiceId& client_id, RsGRouterGenericDataItem *item,GRouterMsgPropagationId& id) =0;
virtual bool registerKey(const GRouterKeyId& key,const GRouterServiceId& client_id,const std::string& description_string) =0;
virtual bool sendData( const RsGxsId& destination,
const GRouterServiceId& client_id,
uint8_t *data,
uint32_t data_size,
const RsGxsId& signing_id,
GRouterMsgPropagationId& id) =0;
virtual bool registerKey(const RsGxsId& authentication_id, const GRouterServiceId& client_id,const std::string& description_string)=0 ;
//===================================================//
// Routage feedback from other services //

@ -219,7 +219,7 @@ static const uint32_t RS_GENERIC_ID_GXS_CIRCLE_ID_TYPE = 0x0008 ;
static const uint32_t RS_GENERIC_ID_GROUTER_ID_TYPE = 0x0009 ;
typedef t_RsGenericIdType< SSL_ID_SIZE , false, RS_GENERIC_ID_SSL_ID_TYPE> SSLIdType ;
typedef t_RsGenericIdType< SSL_ID_SIZE , false, RS_GENERIC_ID_GROUTER_ID_TYPE> GRouterKeyIdType ;
//typedef t_RsGenericIdType< SSL_ID_SIZE , false, RS_GENERIC_ID_GROUTER_ID_TYPE> GRouterKeyIdType ;
typedef t_RsGenericIdType< PGP_KEY_ID_SIZE , true, RS_GENERIC_ID_PGP_ID_TYPE> PGPIdType ;
typedef t_RsGenericIdType< SHA1_SIZE , false, RS_GENERIC_ID_SHA1_ID_TYPE> Sha1CheckSum ;
typedef t_RsGenericIdType< PGP_KEY_FINGERPRINT_SIZE, true, RS_GENERIC_ID_PGP_FINGERPRINT_TYPE> PGPFingerprintType ;

@ -90,12 +90,12 @@
const ChatLobbyFlags RS_CHAT_LOBBY_FLAGS_AUTO_SUBSCRIBE( 0x00000001 ) ;
typedef uint64_t ChatLobbyId ;
typedef uint64_t ChatLobbyMsgId ;
typedef uint64_t ChatLobbyId ;
typedef uint64_t ChatLobbyMsgId ;
typedef std::string ChatLobbyNickName ;
typedef RsPeerId DistantChatPeerId ;
typedef GRouterKeyIdType DistantMsgPeerId ;
typedef RsPeerId DistantChatPeerId ;
//typedef GRouterKeyId DistantMsgPeerId ;
typedef uint64_t MessageId ;
@ -368,14 +368,6 @@ std::ostream &operator<<(std::ostream &out, const MessageInfo &info);
class RsMsgs;
extern RsMsgs *rsMsgs;
struct DistantOfflineMessengingInvite
{
RsPgpId issuer_pgp_id ;
DistantMsgPeerId peer_id ;
time_t time_of_validity ;
};
class RsMsgs
{
public:
@ -390,7 +382,6 @@ virtual ~RsMsgs() { return; }
virtual bool getMessageSummaries(std::list<MsgInfoSummary> &msgList) = 0;
virtual bool getMessage(const std::string &mId, MessageInfo &msg) = 0;
virtual void getMessageCount(unsigned int *pnInbox, unsigned int *pnInboxNew, unsigned int *pnOutbox, unsigned int *pnDraftbox, unsigned int *pnSentbox, unsigned int *pnTrashbox) = 0;
virtual bool decryptMessage(const std::string& mId) = 0 ;
virtual bool MessageSend(MessageInfo &info) = 0;
virtual bool SystemMessage(const std::string &title, const std::string &message, uint32_t systemFlag) = 0;

@ -293,10 +293,6 @@ bool p3Msgs::MessageSend(MessageInfo &info)
return mMsgSrv->MessageSend(info);
}
bool p3Msgs::decryptMessage(const std::string& mId)
{
return mMsgSrv->decryptMessage(mId);
}
void p3Msgs::enableDistantMessaging(bool b)
{
mMsgSrv->enableDistantMessaging(b);

@ -59,7 +59,6 @@ class p3Msgs: public RsMsgs
virtual void getMessageCount(unsigned int *pnInbox, unsigned int *pnInboxNew, unsigned int *pnOutbox, unsigned int *pnDraftbox, unsigned int *pnSentbox, unsigned int *pnTrashbox);
virtual bool MessageSend(MessageInfo &info);
virtual bool decryptMessage(const std::string& mid);
virtual bool SystemMessage(const std::string &title, const std::string &message, uint32_t systemFlag);
virtual bool MessageToDraft(MessageInfo &info, const std::string &msgParentId);
virtual bool MessageToTrash(const std::string &mid, bool bTrash);

@ -1449,7 +1449,7 @@ int RsServer::StartupRetroShare()
mStatusSrv = new p3StatusService(serviceCtrl);
#ifdef ENABLE_GROUTER
p3GRouter *gr = new p3GRouter(serviceCtrl,mLinkMgr) ;
p3GRouter *gr = new p3GRouter(serviceCtrl,mGxsIdService) ;
rsGRouter = gr ;
pqih->addService(gr,true) ;
#endif
@ -1466,6 +1466,7 @@ int RsServer::StartupRetroShare()
ftserver->connectToTurtleRouter(tr) ;
chatSrv->connectToTurtleRouter(tr) ;
gr->connectToTurtleRouter(tr) ;
#ifdef ENABLE_GROUTER
msgSrv->connectToGlobalRouter(gr) ;
#endif

@ -297,7 +297,7 @@ void p3MsgService::checkSizeAndSendMessage(RsMsgItem *msg)
static const uint32_t MAX_STRING_SIZE = 15000 ;
std::cerr << "Msg is size " << msg->message.size() << std::endl;
std::cerr << "Msg is size " << msg->message.size() << std::endl;
while(msg->message.size() > MAX_STRING_SIZE)
{
@ -315,20 +315,13 @@ void p3MsgService::checkSizeAndSendMessage(RsMsgItem *msg)
// Indicate that the message is to be continued.
//
item->msgFlags |= RS_MSG_FLAGS_PARTIAL ;
if(msg->msgFlags & RS_MSG_FLAGS_DISTANT)
sendPrivateMsgItem(item) ;
else
sendItem(item) ;
sendItem(item) ;
}
#ifdef DEBUG_DISTANT_MSG
std::cerr << " Chopped off msg of size " << msg->message.size() << std::endl;
#endif
if(msg->msgFlags & RS_MSG_FLAGS_DISTANT)
sendPrivateMsgItem(msg) ;
else
sendItem(msg) ;
sendItem(msg) ;
}
int p3MsgService::checkOutgoingMessages()
@ -346,20 +339,20 @@ int p3MsgService::checkOutgoingMessages()
std::list<uint32_t>::iterator it;
std::list<uint32_t> toErase;
RsStackMutex stack(mMsgMtx); /********** STACK LOCKED MTX ******/
RsStackMutex stack(mMsgMtx); /********** STACK LOCKED MTX ******/
std::map<uint32_t, RsMsgItem *>::iterator mit;
for(mit = msgOutgoing.begin(); mit != msgOutgoing.end(); ++mit)
{
if (mit->second->msgFlags & RS_MSG_FLAGS_TRASH)
if (mit->second->msgFlags & RS_MSG_FLAGS_TRASH)
continue;
/* find the certificate */
RsPeerId pid = mit->second->PeerId();
if( pid == ownId
|| ( (mit->second->msgFlags & RS_MSG_FLAGS_DISTANT) && (!(mit->second->msgFlags & RS_MSG_FLAGS_ROUTED)))
|| mServiceCtrl->isPeerConnected(getServiceInfo().mServiceType, pid) ) /* FEEDBACK Msg to Ourselves */
|| ( (mit->second->msgFlags & RS_MSG_FLAGS_DISTANT) && (!(mit->second->msgFlags & RS_MSG_FLAGS_ROUTED)))
|| mServiceCtrl->isPeerConnected(getServiceInfo().mServiceType, pid) ) /* FEEDBACK Msg to Ourselves */
{
/* send msg */
pqioutput(PQL_DEBUG_BASIC, msgservicezone,
@ -413,8 +406,11 @@ int p3MsgService::checkOutgoingMessages()
}
}
for(std::list<RsMsgItem*>::const_iterator it(output_queue.begin());it!=output_queue.end();++it)
checkSizeAndSendMessage(*it) ;
for(std::list<RsMsgItem*>::const_iterator it(output_queue.begin());it!=output_queue.end();++it)
if((*it)->msgFlags & RS_MSG_FLAGS_DISTANT) // don't split distant messages. The global router takes care of it.
sendDistantMsgItem(*it) ;
else
checkSizeAndSendMessage(*it) ;
if(changed)
RsServer::notify()->notifyListChange(NOTIFY_LIST_MESSAGELIST,NOTIFY_TYPE_MOD);
@ -996,7 +992,7 @@ bool p3MsgService::setMsgParentId(uint32_t msgId, uint32_t msgParentId)
/****************************************/
/****************************************/
/* Message Items */
int p3MsgService::sendMessage(RsMsgItem *item)
uint32_t p3MsgService::sendMessage(RsMsgItem *item)
{
if(!item)
return 0 ;
@ -1020,16 +1016,24 @@ int p3MsgService::sendMessage(RsMsgItem *item)
msi->msgId = item->msgId;
msi->srcId = item->PeerId();
mSrcIds.insert(std::pair<uint32_t, RsMsgSrcId*>(msi->msgId, msi));
}
}
}
IndicateConfigChanged(); /**** INDICATE MSG CONFIG CHANGED! *****/
RsServer::notify()->notifyListChange(NOTIFY_LIST_MESSAGELIST, NOTIFY_TYPE_ADD);
checkOutgoingMessages();
return item->msgId;
}
uint32_t p3MsgService::sendDistantMessage(RsMsgItem *item,const RsGxsId& from)
{
uint32_t msg_id = sendMessage(item) ;
return 1;
RS_STACK_MUTEX(mMsgMtx) ;
mDistantOutgoingMsgSigners[msg_id] = from ;
return msg_id ;
}
bool p3MsgService::MessageSend(MessageInfo &info)
@ -1038,9 +1042,9 @@ bool p3MsgService::MessageSend(MessageInfo &info)
for(std::list<RsPeerId>::const_iterator pit = info.rspeerid_msgcc.begin(); pit != info.rspeerid_msgcc.end(); ++pit) sendMessage(initMIRsMsg(info, *pit));
for(std::list<RsPeerId>::const_iterator pit = info.rspeerid_msgbcc.begin(); pit != info.rspeerid_msgbcc.end(); ++pit) sendMessage(initMIRsMsg(info, *pit));
for(std::list<RsGxsId>::const_iterator pit = info.rsgxsid_msgto.begin(); pit != info.rsgxsid_msgto.end(); ++pit) sendMessage(initMIRsMsg(info, *pit));
for(std::list<RsGxsId>::const_iterator pit = info.rsgxsid_msgcc.begin(); pit != info.rsgxsid_msgcc.end(); ++pit) sendMessage(initMIRsMsg(info, *pit));
for(std::list<RsGxsId>::const_iterator pit = info.rsgxsid_msgbcc.begin(); pit != info.rsgxsid_msgbcc.end(); ++pit) sendMessage(initMIRsMsg(info, *pit));
for(std::list<RsGxsId>::const_iterator pit = info.rsgxsid_msgto.begin(); pit != info.rsgxsid_msgto.end(); ++pit) sendDistantMessage(initMIRsMsg(info, *pit),info.rsgxsid_srcId);
for(std::list<RsGxsId>::const_iterator pit = info.rsgxsid_msgcc.begin(); pit != info.rsgxsid_msgcc.end(); ++pit) sendDistantMessage(initMIRsMsg(info, *pit),info.rsgxsid_srcId);
for(std::list<RsGxsId>::const_iterator pit = info.rsgxsid_msgbcc.begin(); pit != info.rsgxsid_msgbcc.end(); ++pit) sendDistantMessage(initMIRsMsg(info, *pit),info.rsgxsid_srcId);
/* send to ourselves as well */
RsMsgItem *msg = initMIRsMsg(info, mServiceCtrl->getOwnId());
@ -1632,39 +1636,39 @@ void p3MsgService::initMIRsMsg(RsMsgItem *msg,const MessageInfo& info)
}
/* translate flags from outside */
if (info.msgflags & RS_MSG_USER_REQUEST)
msg->msgFlags |= RS_MSG_FLAGS_USER_REQUEST;
msg->msgFlags |= RS_MSG_FLAGS_USER_REQUEST;
if (info.msgflags & RS_MSG_FRIEND_RECOMMENDATION)
msg->msgFlags |= RS_MSG_FLAGS_FRIEND_RECOMMENDATION;
}
RsMsgItem *p3MsgService::initMIRsMsg(const MessageInfo& info, const RsGxsId& to)
{
RsMsgItem *msg = new RsMsgItem();
RsMsgItem *msg = new RsMsgItem();
initMIRsMsg(msg,info) ;
initMIRsMsg(msg,info) ;
msg->PeerId(RsPeerId());
msg->msgFlags |= RS_MSG_FLAGS_DISTANT;
msg->PeerId(RsPeerId(to));
msg->msgFlags |= RS_MSG_FLAGS_DISTANT;
if (info.msgflags & RS_MSG_SIGNED)
msg->msgFlags |= RS_MSG_FLAGS_SIGNED;
if (info.msgflags & RS_MSG_SIGNED)
msg->msgFlags |= RS_MSG_FLAGS_SIGNED;
// We replace the msg text by the whole message serialized possibly signed,
// and binary encrypted, so as to obfuscate all its content.
//
if(!createDistantMessage(to,info.rsgxsid_srcId,msg))
{
std::cerr << "Cannot encrypt distant message. Something went wrong." << std::endl;
delete msg ;
return NULL ;
}
// // We replace the msg text by the whole message serialized possibly signed,
// // and binary encrypted, so as to obfuscate all its content.
// //
// if(!createDistantMessage(to,info.rsgxsid_srcId,msg))
// {
// std::cerr << "Cannot encrypt distant message. Something went wrong." << std::endl;
// delete msg ;
// return NULL ;
// }
return msg ;
}
RsMsgItem *p3MsgService::initMIRsMsg(const MessageInfo &info, const RsPeerId& to)
{
RsMsgItem *msg = new RsMsgItem();
RsMsgItem *msg = new RsMsgItem();
initMIRsMsg(msg,info) ;
@ -1676,6 +1680,7 @@ RsMsgItem *p3MsgService::initMIRsMsg(const MessageInfo &info, const RsPeerId& to
return msg;
}
#ifdef TO_BE_REMOVED
bool p3MsgService::createDistantMessage(const RsGxsId& destination_gxs_id,const RsGxsId& source_gxs_id,RsMsgItem *item)
{
#ifdef DEBUG_DISTANT_MSG
@ -2094,6 +2099,7 @@ bool p3MsgService::decryptMessage(const std::string& mId)
return false ;
}
}
#endif
void p3MsgService::connectToGlobalRouter(p3GRouter *gr)
{
@ -2122,11 +2128,13 @@ void p3MsgService::enableDistantMessaging(bool b)
std::cerr << (b?"Enabling":"Disabling") << " distant messaging, with peer id = " << *it << std::endl;
#endif
for(std::list<RsGxsId>::const_iterator it(own_id_list.begin());it!=own_id_list.end();++it)
if(b)
mGRouter->registerKey(GRouterKeyId(*it),GROUTER_CLIENT_ID_MESSAGES,"Messaging contact") ;
else
mGRouter->unregisterKey(GRouterKeyId(*it)) ;
for(std::list<RsGxsId>::const_iterator it(own_id_list.begin());it!=own_id_list.end();++it)
{
if(b)
mGRouter->registerKey(*it,GROUTER_CLIENT_ID_MESSAGES,"Messaging contact") ;
else
mGRouter->unregisterKey(*it,GROUTER_CLIENT_ID_MESSAGES) ;
}
if(cchanged)
IndicateConfigChanged() ;
@ -2147,36 +2155,6 @@ void p3MsgService::manageDistantPeers()
enableDistantMessaging(mDistantMessagingEnabled) ;
}
void p3MsgService::sendGRouterData(const GRouterKeyId& key_id,RsMsgItem *msgitem)
{
// The item is serialized and turned into a generic turtle item.
uint32_t msg_serialized_rssize = _serialiser->size(msgitem) ;
unsigned char *msg_serialized_data = new unsigned char[msg_serialized_rssize] ;
if(!_serialiser->serialise(msgitem,msg_serialized_data,&msg_serialized_rssize))
{
std::cerr << "(EE) p3MsgService::sendTurtleData(): Serialization error." << std::endl;
delete[] msg_serialized_data ;
return ;
}
RsGRouterGenericDataItem *item = new RsGRouterGenericDataItem ;
item->data_bytes = (uint8_t*)malloc(msg_serialized_rssize) ;
item->data_size = msg_serialized_rssize ;
memcpy(item->data_bytes,msg_serialized_data,msg_serialized_rssize) ;
delete[] msg_serialized_data ;
GRouterMsgPropagationId grouter_message_id ;
mGRouter->sendData(key_id,GROUTER_CLIENT_ID_MESSAGES,item,grouter_message_id) ;
// now store the grouter id along with the message id, so that we can keep track of received messages
_ongoing_messages[grouter_message_id] = msgitem->msgId ;
}
void p3MsgService::acknowledgeDataReceived(const GRouterMsgPropagationId& id)
{
RsStackMutex stack(mMsgMtx); /********** STACK LOCKED MTX ******/
@ -2209,38 +2187,77 @@ void p3MsgService::acknowledgeDataReceived(const GRouterMsgPropagationId& id)
RsServer::notify()->notifyListChange(NOTIFY_LIST_MESSAGELIST,NOTIFY_TYPE_ADD);
IndicateConfigChanged() ;
}
void p3MsgService::receiveGRouterData(const GRouterKeyId& key, const RsGRouterGenericDataItem *gitem)
void p3MsgService::receiveGRouterData(const RsGxsId& destination_key, const RsGxsId& signing_key,GRouterServiceId& client_id,uint8_t *data,uint32_t data_size)
{
std::cerr << "p3MsgService::receiveGRouterData(): received message item of size " << gitem->data_size << ", for key " << key << std::endl;
std::cerr << "p3MsgService::receiveGRouterData(): received message item of size " << data_size << ", for key " << destination_key << std::endl;
uint32_t size = gitem->data_size ;
RsItem *item = _serialiser->deserialise(gitem->data_bytes,&size) ;
RsItem *item = _serialiser->deserialise(data,&data_size) ;
RsMsgItem *encrypted_msg_item = dynamic_cast<RsMsgItem*>(item) ;
free(data) ;
if(encrypted_msg_item != NULL)
RsMsgItem *msg_item = dynamic_cast<RsMsgItem*>(item) ;
if(msg_item != NULL)
{
std::cerr << " Encrypted item correctly deserialised. Passing on to incoming list." << std::endl;
encrypted_msg_item->PeerId(RsPeerId(key)) ; // hack to pass on GXS id.
handleIncomingItem(encrypted_msg_item) ;
msg_item->PeerId(RsPeerId(signing_key)) ; // hack to pass on GXS id.
handleIncomingItem(msg_item) ;
}
else
std::cerr << " Item could not be deserialised. Format error??" << std::endl;
}
void p3MsgService::sendPrivateMsgItem(RsMsgItem *msgitem)
void p3MsgService::sendDistantMsgItem(RsMsgItem *msgitem)
{
#ifdef DEBUG_DISTANT_MSG
std::cerr << "p3MsgService::sendDistanteMsgItem(): sending distant msg item to peer " << msgitem->PeerId() << std::endl;
#endif
GRouterKeyId key_id(msgitem->PeerId()) ;
RsGxsId destination_key_id(msgitem->PeerId()) ;
RsGxsId signing_key_id ;
{
RS_STACK_MUTEX(mMsgMtx) ;
signing_key_id = mDistantOutgoingMsgSigners[msgitem->msgId] ;
if(signing_key_id.isNull())
{
std::cerr << "ERROR: cannot find signing key id for msg id " << msgitem->msgId << std::endl;
std::cerr << " available keys are:" << std::endl;
for(std::map<uint32_t,RsGxsId>::const_iterator it(mDistantOutgoingMsgSigners.begin());it!=mDistantOutgoingMsgSigners.end();++it)
std::cerr << " " << it->first << " " << it->second << std::endl;
return ;
}
}
#ifdef DEBUG_DISTANT_MSG
std::cerr << " Flushing msg " << msgitem->msgId << " for peer id " << msgitem->PeerId() << std::endl;
std::cerr << "p3MsgService::sendDistanteMsgItem(): sending distant msg item" << std::endl;
std::cerr << " msg ID : " << msgitem->msgId << std::endl;
std::cerr << " to peer : " << destination_key_id << std::endl;
std::cerr << " signing : " << signing_key_id << std::endl;
#endif
sendGRouterData(key_id,msgitem) ;
// The item is serialized and turned into a generic turtle item.
uint32_t msg_serialized_rssize = _serialiser->size(msgitem) ;
unsigned char *msg_serialized_data = new unsigned char[msg_serialized_rssize] ;
if(!_serialiser->serialise(msgitem,msg_serialized_data,&msg_serialized_rssize))
{
std::cerr << "(EE) p3MsgService::sendTurtleData(): Serialization error." << std::endl;
delete[] msg_serialized_data ;
return ;
}
#ifdef DEBUG_DISTANT_MSG
std::cerr << " serialised size : " << msg_serialized_rssize << std::endl;
#endif
GRouterMsgPropagationId grouter_message_id ;
mGRouter->sendData(destination_key_id,GROUTER_CLIENT_ID_MESSAGES,msg_serialized_data,msg_serialized_rssize,signing_key_id,grouter_message_id) ;
// now store the grouter id along with the message id, so that we can keep track of received messages
{
RS_STACK_MUTEX(mMsgMtx) ;
_ongoing_messages[grouter_message_id] = msgitem->msgId ;
}
}

@ -127,7 +127,7 @@ class p3MsgService: public p3Service, public p3Config, public pqiServiceMonitor,
bool distantMessagingEnabled() ;
private:
void sendPrivateMsgItem(RsMsgItem *msgitem) ;
void sendDistantMsgItem(RsMsgItem *msgitem) ;
// This contains the ongoing tunnel handling contacts.
// The map is indexed by the hash
@ -136,22 +136,23 @@ class p3MsgService: public p3Service, public p3Config, public pqiServiceMonitor,
// Overloaded from GRouterClientService
virtual void receiveGRouterData(const GRouterKeyId& key,const RsGRouterGenericDataItem *item) ;
virtual void receiveGRouterData(const RsGxsId& destination_key,const RsGxsId& signing_key, GRouterServiceId &client_id, uint8_t *data, uint32_t data_size) ;
virtual void acknowledgeDataReceived(const GRouterMsgPropagationId& msg_id) ;
// Utility functions
bool createDistantMessage(const RsGxsId& destination_gxs_id,const RsGxsId& source_gxs_id,RsMsgItem *msg) ;
bool locked_findHashForVirtualPeerId(const RsPeerId& pid,Sha1CheckSum& hash) ;
void sendGRouterData(const GRouterKeyId &key_id,RsMsgItem *) ;
void sendGRouterData(const RsGxsId &key_id,RsMsgItem *) ;
void manageDistantPeers() ;
void handleIncomingItem(RsMsgItem *) ;
uint32_t getNewUniqueMsgId();
int sendMessage(RsMsgItem *item);
void checkSizeAndSendMessage(RsMsgItem *msg);
uint32_t sendMessage(RsMsgItem *item);
uint32_t sendDistantMessage(RsMsgItem *item,const RsGxsId& signing_gxs_id);
void checkSizeAndSendMessage(RsMsgItem *msg);
int incomingMsgs();
void processMsg(RsMsgItem *mi, bool incoming);
@ -190,7 +191,10 @@ class p3MsgService: public p3Service, public p3Config, public pqiServiceMonitor,
uint32_t mMsgUniqueId;
// used delete msgSrcIds after config save
std::map<uint32_t, RsMsgSrcId*> mSrcIds;
std::map<uint32_t, RsMsgSrcId*> mSrcIds;
// temporary storage. Will not be needed when messages have a proper "from" field. Not saved!
std::map<uint32_t, RsGxsId> mDistantOutgoingMsgSigners;
// save the parent of the messages in draft for replied and forwarded
std::map<uint32_t, RsMsgParentId*> mParentId;

@ -1521,19 +1521,6 @@ void MessagesDialog::insertMsgTxtAndFiles(QTreeWidgetItem *item, bool bSetToRead
updateInterface();
}
void MessagesDialog::decryptSelectedMsg()
{
if (!MessageWidget::decryptMsg(mCurrMsgId)) {
return;
}
// Force refill
mCurrMsgId.clear();
msgWidget->fill("");
insertMsgTxtAndFiles(ui.messageTreeWidget->currentItem());
}
bool MessagesDialog::getCurrentMsg(std::string &cid, std::string &mid)
{
QTreeWidgetItem *item = ui.messageTreeWidget->currentItem();

@ -69,7 +69,6 @@ private slots:
/** Create the context popup menu and it's submenus */
void messageTreeWidgetCustomPopupMenu(QPoint point);
void folderlistWidgetCustomPopupMenu(QPoint);
void decryptSelectedMsg() ;
void changeBox(int newrow);
void changeQuickView(int newrow);

@ -1279,7 +1279,6 @@ static void processList(const QStringList &list, const QString &textSingular, co
std::cerr << " RetroShareLink::process MessageRequest : id : " << link.hash().toStdString() << ", subject : " << link.name().toStdString() << std::endl;
#endif
RsPeerDetails detail;
DistantMsgPeerId dm_pid ;
// This is awful, but apparently the hash can be multiple different types. Let's check!

@ -119,7 +119,6 @@ const QString PeerDefs::rsidFromId(const RsPeerId &id, QString *name /* = NULL*/
QString rsid;
std::string peerName = rsPeers->getPeerName(id);
DistantMsgPeerId pid ;
if(!peerName.empty())
{

@ -133,14 +133,12 @@ MessageWidget::MessageWidget(bool controlled, QWidget *parent, Qt::WindowFlags f
connect(ui.expandFilesButton, SIGNAL(clicked()), this, SLOT(togglefileview()));
connect(ui.downloadButton, SIGNAL(clicked()), this, SLOT(getallrecommended()));
connect(ui.msgText, SIGNAL(anchorClicked(QUrl)), this, SLOT(anchorClicked(QUrl)));
connect(ui.decryptButton, SIGNAL(clicked()), this, SLOT(decrypt()));
connect(NotifyQt::getInstance(), SIGNAL(messagesTagsChanged()), this, SLOT(messagesTagsChanged()));
connect(NotifyQt::getInstance(), SIGNAL(messagesChanged()), this, SLOT(messagesChanged()));
ui.imageBlockWidget->addButtonAction(tr("Load images always for this message"), this, SLOT(loadImagesAlways()), true);
ui.msgText->setImageBlockWidget(ui.imageBlockWidget);
ui.decryptFrame->hide();
/* hide the Tree +/- */
ui.msgList->setRootIsDecorated( false );
@ -445,8 +443,6 @@ void MessageWidget::fill(const std::string &msgId)
// return;
// }
ui.decryptFrame->hide();
currMsgId = msgId;
if (currMsgId.empty()) {
@ -573,12 +569,7 @@ void MessageWidget::fill(const std::string &msgId)
ui.fromText->setToolTip(tooltip_string) ;
}
if (msgInfo.msgflags & RS_MSG_ENCRYPTED) {
ui.subjectText->setText(tr("Encrypted message"));
ui.fromText->setText(tr("Unknown (needs decryption)")) ;
} else {
ui.subjectText->setText(QString::fromUtf8(msgInfo.title.c_str()));
}
text = RsHtmlMsg(msgInfo.msgflags).formatText(ui.msgText->document(), QString::fromUtf8(msgInfo.msg.c_str()), RSHTML_FORMATTEXT_EMBED_SMILEYS | RSHTML_FORMATTEXT_EMBED_LINKS | RSHTML_FORMATTEXT_REPLACE_LINKS);
ui.msgText->resetImagesStatus(Settings->getMsgLoadEmbeddedImages() || (msgInfo.msgflags & RS_MSG_LOAD_EMBEDDED_IMAGES));
@ -587,10 +578,6 @@ void MessageWidget::fill(const std::string &msgId)
ui.filesText->setText(QString("%1").arg(msgInfo.count));
ui.filesSize->setText(QString(misc::friendlyUnit(msgInfo.size)));
if (msgInfo.msgflags & RS_MSG_ENCRYPTED) {
ui.decryptFrame->show();
}
showTagLabels();
currMsgFlags = msgInfo.msgflags;
@ -748,40 +735,3 @@ void MessageWidget::loadImagesAlways()
rsMsgs->MessageLoadEmbeddedImages(currMsgId, true);
}
void MessageWidget::decrypt()
{
if (!decryptMsg(currMsgId)) {
return;
}
// Force refill
std::string msgId = currMsgId;
currMsgId.clear();
fill(msgId);
}
bool MessageWidget::decryptMsg(const std::string &msgId)
{
if (msgId.empty()) {
return false;
}
MessageInfo msgInfo;
if (!rsMsgs->getMessage(msgId, msgInfo)) {
return false;
}
if (!(msgInfo.msgflags & RS_MSG_ENCRYPTED)) {
QMessageBox::warning(NULL, tr("Decryption failed!"), tr("This message is not encrypted. Cannot decrypt!"));
return false;
}
if (!rsMsgs->decryptMessage(msgId)) {
QMessageBox::warning(NULL, tr("Decryption failed!"), tr("This message could not be decrypted."));
return false;
}
return true;
}

@ -59,7 +59,6 @@ public:
QString subject(bool noEmpty);
static bool decryptMsg(const std::string &msgId);
private slots:
void reply();
@ -82,7 +81,6 @@ private slots:
void anchorClicked(const QUrl &url);
void loadImagesAlways();
void decrypt();
private:
void clearTagLabels();

@ -23,7 +23,7 @@
<property name="bottomMargin">
<number>0</number>
</property>
<item row="1" column="0">
<item row="0" column="0">
<widget class="QSplitter" name="msgSplitter">
<property name="orientation">
<enum>Qt::Vertical</enum>
@ -414,125 +414,6 @@
</widget>
</widget>
</item>
<item row="0" column="0">
<widget class="QFrame" name="decryptFrame">
<property name="palette">
<palette>
<active>
<colorrole role="Base">
<brush brushstyle="SolidPattern">
<color alpha="255">
<red>255</red>
<green>255</green>
<blue>255</blue>
</color>
</brush>
</colorrole>
<colorrole role="Window">
<brush brushstyle="SolidPattern">
<color alpha="255">
<red>204</red>
<green>255</green>
<blue>204</blue>
</color>
</brush>
</colorrole>
</active>
<inactive>
<colorrole role="Base">
<brush brushstyle="SolidPattern">
<color alpha="255">
<red>255</red>
<green>255</green>
<blue>255</blue>
</color>
</brush>
</colorrole>
<colorrole role="Window">
<brush brushstyle="SolidPattern">
<color alpha="255">
<red>204</red>
<green>255</green>
<blue>204</blue>
</color>
</brush>
</colorrole>
</inactive>
<disabled>
<colorrole role="Base">
<brush brushstyle="SolidPattern">
<color alpha="255">
<red>204</red>
<green>255</green>
<blue>204</blue>
</color>
</brush>
</colorrole>
<colorrole role="Window">
<brush brushstyle="SolidPattern">
<color alpha="255">
<red>204</red>
<green>255</green>
<blue>204</blue>
</color>
</brush>
</colorrole>
</disabled>
</palette>
</property>
<property name="autoFillBackground">
<bool>true</bool>
</property>
<property name="frameShape">
<enum>QFrame::Box</enum>
</property>
<layout class="QHBoxLayout" name="horizontalLayout">
<property name="spacing">
<number>6</number>
</property>
<property name="margin">
<number>6</number>
</property>
<item>
<widget class="QLabel" name="decryptImage">
<property name="text">
<string/>
</property>
<property name="pixmap">
<pixmap resource="../images.qrc">:/images/mail-encrypted-full.png</pixmap>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="decryptLabel">
<property name="text">
<string>This messages is encrypted. Click the right button to decrypt it.</string>
</property>
</widget>
</item>
<item>
<spacer name="horizontalSpacer">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>280</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
<item>
<widget class="QToolButton" name="decryptButton">
<property name="text">
<string>Decrypt</string>
</property>
</widget>
</item>
</layout>
</widget>
</item>
</layout>
<action name="actionPrint">
<property name="text">