Git-Mirrors/RetroShare
1
0
Fork 0
mirror of https://github.com/RetroShare/RetroShare.git synced 2025-07-23 06:31:20 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

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.

Browse source 
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
Download patch file Download diff file Expand all files Collapse all files

2
libretroshare/src/grouter/grouterclientservice.h
View file

@ -49,7 +49,7 @@ class GRouterClientService
// //
// GRouter stays owner of the item, so the client should not delete it! // 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 << "!!!!!! 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; std::cerr << " destination key_id = " << destination_key.toStdString() << std::endl;

286
libretroshare/src/grouter/grouteritems.cc
View file

@ -29,118 +29,6 @@ bool RsGRouterItem::serialise_header(void *data,uint32_t& pktsize,uint32_t& tlvs
return true ; 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 */ /* SERIALISER STUFF */
/**********************************************************************************************/ /**********************************************************************************************/
@ -159,7 +47,7 @@ RsItem *RsGRouterSerialiser::deserialise(void *data, uint32_t *pktsize)
{ {
//case RS_PKT_SUBTYPE_GROUTER_PUBLISH_KEY: return deserialise_RsGRouterPublishKeyItem(data, *pktsize); //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_DATA: return deserialise_RsGRouterGenericDataItem(data, *pktsize);
case RS_PKT_SUBTYPE_GROUTER_ACK: return deserialise_RsGRouterACKItem(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_MATRIX_CLUES: return deserialise_RsGRouterMatrixCluesItem(data, *pktsize);
case RS_PKT_SUBTYPE_GROUTER_FRIENDS_LIST: return deserialise_RsGRouterMatrixFriendListItem(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); case RS_PKT_SUBTYPE_GROUTER_ROUTING_INFO: return deserialise_RsGRouterRoutingInfoItem(data, *pktsize);
@ -170,33 +58,6 @@ RsItem *RsGRouterSerialiser::deserialise(void *data, uint32_t *pktsize)
return NULL; 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 RsGRouterGenericDataItem *RsGRouterSerialiser::deserialise_RsGRouterGenericDataItem(void *data, uint32_t pktsize) const
{ {
uint32_t offset = 8; // skip the header uint32_t offset = 8; // skip the header
@ -207,7 +68,6 @@ RsGRouterGenericDataItem *RsGRouterSerialiser::deserialise_RsGRouterGenericDataI
ok &= getRawUInt64(data, pktsize, &offset, &item->routing_id); ok &= getRawUInt64(data, pktsize, &offset, &item->routing_id);
ok &= item->destination_key.deserialise(data, pktsize, offset) ; ok &= item->destination_key.deserialise(data, pktsize, offset) ;
ok &= getRawUInt32(data, pktsize, &offset, &item->randomized_distance);
ok &= getRawUInt32(data, pktsize, &offset, &item->data_size); 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)))
@ -219,6 +79,11 @@ RsGRouterGenericDataItem *RsGRouterSerialiser::deserialise_RsGRouterGenericDataI
memcpy(item->data_bytes,&((uint8_t*)data)[offset],item->data_size) ; memcpy(item->data_bytes,&((uint8_t*)data)[offset],item->data_size) ;
offset += item->data_size ; offset += item->data_size ;
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) if (offset != rssize || !ok)
{ {
std::cerr << __PRETTY_FUNCTION__ << ": error while deserialising! Item will be dropped." << std::endl; std::cerr << __PRETTY_FUNCTION__ << ": error while deserialising! Item will be dropped." << std::endl;
@ -228,16 +93,18 @@ RsGRouterGenericDataItem *RsGRouterSerialiser::deserialise_RsGRouterGenericDataI
return item; 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 offset = 8; // skip the header
uint32_t rssize = getRsItemSize(data); uint32_t rssize = getRsItemSize(data);
bool ok = true ; bool ok = true ;
RsGRouterACKItem *item = new RsGRouterACKItem() ; RsGRouterReceiptItem *item = new RsGRouterReceiptItem() ;
ok &= getRawUInt64(data, pktsize, &offset, &item->mid); // file hash ok &= getRawUInt64(data, pktsize, &offset, &item->mid);
ok &= getRawUInt32(data, pktsize, &offset, &item->state); // file hash 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) if (offset != rssize || !ok)
{ {
@ -256,27 +123,11 @@ RsGRouterRoutingInfoItem *RsGRouterSerialiser::deserialise_RsGRouterRoutingInfoI
RsGRouterRoutingInfoItem *item = new RsGRouterRoutingInfoItem() ; RsGRouterRoutingInfoItem *item = new RsGRouterRoutingInfoItem() ;
ok &= getRawUInt32(data, pktsize, &offset, &item->status_flags); ok &= getRawUInt32(data, pktsize, &offset, &item->data_status);
ok &= item->origin.deserialise(data, pktsize, offset) ; ok &= getRawTimeT(data, pktsize, &offset, item->received_time_TS);
ok &= getRawTimeT(data, pktsize, &offset, item->received_time); ok &= getRawTimeT(data, pktsize, &offset, item->last_sent_TS);
ok &= getRawTimeT(data, pktsize, &offset, item->last_sent);
ok &= getRawUInt32(data, pktsize, &offset, &item->client_id); 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) ;
}
item->data_item = deserialise_RsGRouterGenericDataItem(&((uint8_t*)data)[offset],pktsize - offset) ; item->data_item = deserialise_RsGRouterGenericDataItem(&((uint8_t*)data)[offset],pktsize - offset) ;
if(item->data_item != NULL) if(item->data_item != NULL)
offset += item->data_item->serial_size() ; offset += item->data_item->serial_size() ;
@ -360,32 +211,49 @@ RsGRouterGenericDataItem *RsGRouterGenericDataItem::duplicate() const
item->routing_id = routing_id ; item->routing_id = routing_id ;
item->destination_key = destination_key ; item->destination_key = destination_key ;
item->data_size = data_size ; item->data_size = data_size ;
item->randomized_distance = randomized_distance ;
// then duplicate the memory chunk // then duplicate the memory chunk
item->data_bytes = (uint8_t*)malloc(data_size) ; item->data_bytes = (uint8_t*)malloc(data_size) ;
memcpy(item->data_bytes,data_bytes,data_size) ; memcpy(item->data_bytes,data_bytes,data_size) ;
item->signature = signature ;
item->randomized_distance = randomized_distance ;
item->flags = flags ;
return item ; return item ;
} }
uint32_t RsGRouterGenericDataItem::serial_size() const uint32_t RsGRouterGenericDataItem::serial_size() const
{ {
uint32_t s = 8 ; // header uint32_t s = 8 ; // header
s += sizeof(GRouterMsgPropagationId) ; // routing id s += sizeof(GRouterMsgPropagationId) ; // routing id
s += destination_key.serial_size() ; // destination_key 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 ; // randomized distance
s += 4 ; // flags
return s ;
}
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 += 4 ; // data_size
s += data_size ; // data s += data_size ; // data
return s ; return s ;
} }
uint32_t RsGRouterACKItem::serial_size() const uint32_t RsGRouterReceiptItem::serial_size() const
{ {
uint32_t s = 8 ; // header uint32_t s = 8 ; // header
s += sizeof(GRouterMsgPropagationId) ; // routing id s += sizeof(GRouterMsgPropagationId) ; // routing id
s += destination_key.serial_size() ; // destination_key
s += 4 ; // state s += 4 ; // state
s += signature.TlvSize() ; // signature
return s ; return s ;
} }
@ -400,7 +268,34 @@ bool RsGRouterGenericDataItem::serialise(void *data,uint32_t& size) const
/* add mandatory parts first */ /* add mandatory parts first */
ok &= setRawUInt64(data, tlvsize, &offset, routing_id); ok &= setRawUInt64(data, tlvsize, &offset, routing_id);
ok &= destination_key.serialise(data, tlvsize, offset) ; 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 ;
ok &= signature.SetTlv(data, tlvsize, &offset) ;
ok &= setRawUInt32(data, tlvsize, &offset, randomized_distance) ; 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;
}
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); ok &= setRawUInt32(data, tlvsize, &offset, data_size);
memcpy(&((uint8_t*)data)[offset],data_bytes,data_size) ; memcpy(&((uint8_t*)data)[offset],data_bytes,data_size) ;
@ -414,7 +309,7 @@ bool RsGRouterGenericDataItem::serialise(void *data,uint32_t& size) const
return ok; return ok;
} }
bool RsGRouterACKItem::serialise(void *data,uint32_t& size) const bool RsGRouterReceiptItem::serialise(void *data,uint32_t& size) const
{ {
uint32_t tlvsize,offset=0; uint32_t tlvsize,offset=0;
bool ok = true; bool ok = true;
@ -425,11 +320,13 @@ bool RsGRouterACKItem::serialise(void *data,uint32_t& size) const
/* add mandatory parts first */ /* add mandatory parts first */
ok &= setRawUInt64(data, tlvsize, &offset, mid); ok &= setRawUInt64(data, tlvsize, &offset, mid);
ok &= setRawUInt32(data, tlvsize, &offset, state); ok &= setRawUInt32(data, tlvsize, &offset, state);
ok &= destination_key.serialise(data,tlvsize,offset) ;
ok &= signature.SetTlv(data,tlvsize,&offset) ;
if (offset != tlvsize) if (offset != tlvsize)
{ {
ok = false; ok = false;
std::cerr << "RsGRouterACKItem::serialisedata() size error! " << std::endl; std::cerr << "RsGRouterReceiptItem::serialisedata() size error! " << std::endl;
} }
return ok; return ok;
@ -458,12 +355,10 @@ uint32_t RsGRouterRoutingInfoItem::serial_size() const
{ {
uint32_t s = 8 ; // header uint32_t s = 8 ; // header
s += 4 ; // status_flags s += 4 ; // status_flags
s += origin.serial_size() ; // origin
s += 8 ; // received_time s += 8 ; // received_time
s += 8 ; // last_sent s += 8 ; // last_sent
s += 4 ; // tried_friends.size() ; s += 4 ; // tried_friends.size() ;
s += sizeof(GRouterServiceId) ; // service_id s += sizeof(GRouterServiceId) ; // service_id
s += tried_friends.size() * ( RsPeerId::SIZE_IN_BYTES + 8 + 4 + 4 ) ; // FriendTrialRecord
s += data_item->serial_size(); // data_item s += data_item->serial_size(); // data_item
return s ; return s ;
@ -545,15 +440,10 @@ bool RsGRouterRoutingInfoItem::serialise(void *data,uint32_t& size) const
if(!serialise_header(data,size,tlvsize,offset)) if(!serialise_header(data,size,tlvsize,offset))
return false ; return false ;
ok &= setRawUInt32(data, tlvsize, &offset, status_flags) ; ok &= setRawUInt32(data, tlvsize, &offset, data_status) ;
ok &= origin.serialise(data, tlvsize, offset) ; ok &= setRawTimeT(data, tlvsize, &offset, received_time_TS) ;
ok &= setRawTimeT(data, tlvsize, &offset, received_time) ; ok &= setRawTimeT(data, tlvsize, &offset, last_sent_TS) ;
ok &= setRawTimeT(data, tlvsize, &offset, last_sent) ;
ok &= setRawUInt32(data, tlvsize, &offset, client_id) ; 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 ; uint32_t ns = size - offset ;
ok &= data_item->serialise( &((uint8_t*)data)[offset], ns) ; ok &= data_item->serialise( &((uint8_t*)data)[offset], ns) ;
@ -572,35 +462,28 @@ bool RsGRouterRoutingInfoItem::serialise(void *data,uint32_t& size) const
// ------------------------------------- IO --------------------------------------- // // ------------------------------------- IO --------------------------------------- //
// -----------------------------------------------------------------------------------// // -----------------------------------------------------------------------------------//
// //
//std::ostream& RsGRouterPublishKeyItem::print(std::ostream& o, uint16_t) std::ostream& RsGRouterReceiptItem::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)
{ {
o << "RsGRouterACKItem:" << std::endl ; o << "RsGRouterReceiptItem:" << std::endl ;
o << " direct origin: \""<< PeerId() << "\"" << std::endl ; o << " direct origin: \""<< PeerId() << "\"" << std::endl ;
o << " Mid: " << mid << std::endl ; o << " Mid: " << mid << std::endl ;
o << " State: " << state << 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) std::ostream& RsGRouterGenericDataItem::print(std::ostream& o, uint16_t)
{ {
o << "RsGRouterGenericDataItem:" << std::endl ; o << "RsGRouterGenericDataItem:" << std::endl ;
o << " direct origin: \""<< PeerId() << "\"" << 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 << " Key: " << destination_key.toStdString() << std::endl ;
o << " Data size: " << data_size << 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 ;
} }
@ -609,14 +492,13 @@ std::ostream& RsGRouterRoutingInfoItem::print(std::ostream& o, uint16_t)
{ {
o << "RsGRouterRoutingInfoItem:" << std::endl ; o << "RsGRouterRoutingInfoItem:" << std::endl ;
o << " direct origin: \""<< PeerId() << "\"" << std::endl ; o << " direct origin: \""<< PeerId() << "\"" << std::endl ;
o << " origin: "<< origin.toStdString() << std::endl ; o << " recv time: "<< received_time_TS << std::endl ;
o << " recv time: "<< received_time << std::endl ; o << " Last sent: "<< last_sent_TS << std::endl ;
o << " Last sent: "<< last_sent << std::endl ; o << " flags: "<< std::hex << data_status << std::dec << std::endl ;
o << " flags: "<< std::hex << status_flags << std::dec << std::endl ; o << " Key 1: "<< destination_key << std::endl ;
o << " Key: "<< data_item->destination_key.toStdString() << std::endl ; o << " Key 2: "<< data_item->destination_key << std::endl ;
o << " Data size: "<< data_item->data_size << std::endl ; o << " Data size: "<< data_item->data_size << std::endl ;
o << " Client id: "<< client_id << std::endl ; o << " Client id: "<< client_id << std::endl ;
o << " Tried friends: "<< tried_friends.size() << std::endl;
return o ; return o ;
} }

80
libretroshare/src/grouter/grouteritems.h
View file

@ -26,6 +26,7 @@
#pragma once #pragma once
#include "serialiser/rsserial.h" #include "serialiser/rsserial.h"
#include "serialiser/rstlvkeys.h"
#include "serialiser/rsserviceids.h" #include "serialiser/rsserviceids.h"
#include "retroshare/rstypes.h" #include "retroshare/rstypes.h"
@ -33,16 +34,17 @@
#include "p3grouter.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_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_ACK_deprecated = 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_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_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_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_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 = 3 ; // irrelevant since all items travel through tunnels
const uint8_t QOS_PRIORITY_RS_GROUTER_ACK = 3 ;
const uint8_t QOS_PRIORITY_RS_GROUTER_DATA = 3 ;
/***********************************************************************************/ /***********************************************************************************/
@ -77,56 +79,14 @@ class RsGRouterNonCopyableObject
RsGRouterNonCopyableObject operator=(const RsGRouterNonCopyableObject&) { return *this ;} 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 */ /* 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 class RsGRouterGenericDataItem: public RsGRouterItem, public RsGRouterNonCopyableObject
{ {
public: public:
RsGRouterGenericDataItem() : RsGRouterItem(RS_PKT_SUBTYPE_GROUTER_DATA) { setPriorityLevel(QOS_PRIORITY_RS_GROUTER_DATA) ; } RsGRouterGenericDataItem() : RsGRouterItem(RS_PKT_SUBTYPE_GROUTER_DATA) { setPriorityLevel(QOS_PRIORITY_RS_GROUTER) ; }
virtual ~RsGRouterGenericDataItem() { clear() ; } virtual ~RsGRouterGenericDataItem() { clear() ; }
virtual bool serialise(void *data,uint32_t& size) const ; virtual bool serialise(void *data,uint32_t& size) const ;
@ -145,16 +105,23 @@ class RsGRouterGenericDataItem: public RsGRouterItem, public RsGRouterNonCopyabl
// //
GRouterMsgPropagationId routing_id ; GRouterMsgPropagationId routing_id ;
GRouterKeyId destination_key ; GRouterKeyId destination_key ;
uint32_t randomized_distance ;
uint32_t data_size ; uint32_t data_size ;
uint8_t *data_bytes; 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: public:
RsGRouterACKItem() : RsGRouterItem(RS_PKT_SUBTYPE_GROUTER_ACK) { setPriorityLevel(QOS_PRIORITY_RS_GROUTER_ACK) ; } RsGRouterReceiptItem() : RsGRouterItem(RS_PKT_SUBTYPE_GROUTER_RECEIPT) { setPriorityLevel(QOS_PRIORITY_RS_GROUTER) ; }
virtual bool serialise(void *data,uint32_t& size) const ; virtual bool serialise(void *data,uint32_t& size) const ;
virtual uint32_t serial_size() const ; virtual uint32_t serial_size() const ;
@ -165,7 +132,10 @@ class RsGRouterACKItem: public RsGRouterItem
// packet data // packet data
// //
GRouterMsgPropagationId mid ; // message id to which this ack is a response 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 uint32_t state ; // packet was delivered, not delivered, bounced, etc
RsTlvKeySignature signature ; // signs mid+destination_key+state
}; };
// Items for saving the routing matrix information. // Items for saving the routing matrix information.
@ -221,7 +191,6 @@ class RsGRouterRoutingInfoItem: public RsGRouterItem, public GRouterRoutingInfo,
if(data_item != NULL) if(data_item != NULL)
delete data_item ; delete data_item ;
data_item = NULL ; data_item = NULL ;
tried_friends.clear() ;
} }
virtual std::ostream& print(std::ostream &out, uint16_t indent = 0) ; virtual std::ostream& print(std::ostream &out, uint16_t indent = 0) ;
}; };
@ -246,9 +215,8 @@ class RsGRouterSerialiser: public RsSerialType
virtual RsItem *deserialise (void *data, uint32_t *size) ; virtual RsItem *deserialise (void *data, uint32_t *size) ;
private: private:
//RsGRouterPublishKeyItem *deserialise_RsGRouterPublishKeyItem(void *data,uint32_t size) const ;
RsGRouterGenericDataItem *deserialise_RsGRouterGenericDataItem(void *data,uint32_t size) const ; RsGRouterGenericDataItem *deserialise_RsGRouterGenericDataItem(void *data,uint32_t size) const ;
RsGRouterACKItem *deserialise_RsGRouterACKItem(void *data,uint32_t size) const ; RsGRouterReceiptItem *deserialise_RsGRouterReceiptItem(void *data,uint32_t size) const ;
RsGRouterMatrixCluesItem *deserialise_RsGRouterMatrixCluesItem(void *data,uint32_t size) const ; RsGRouterMatrixCluesItem *deserialise_RsGRouterMatrixCluesItem(void *data,uint32_t size) const ;
RsGRouterMatrixFriendListItem *deserialise_RsGRouterMatrixFriendListItem(void *data,uint32_t size) const ; RsGRouterMatrixFriendListItem *deserialise_RsGRouterMatrixFriendListItem(void *data,uint32_t size) const ;
RsGRouterRoutingInfoItem *deserialise_RsGRouterRoutingInfoItem(void *data,uint32_t size) const ; RsGRouterRoutingInfoItem *deserialise_RsGRouterRoutingInfoItem(void *data,uint32_t size) const ;

38
libretroshare/src/grouter/groutertypes.h
View file

@ -29,11 +29,12 @@
#include <time.h> #include <time.h>
#include <list> #include <list>
#include "pgp/rscertificate.h" #include "pgp/rscertificate.h"
#include "turtle/p3turtle.h"
#include "retroshare/rsgrouter.h" #include "retroshare/rsgrouter.h"
class RsGRouterGenericDataItem ; 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_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. 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_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_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 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_DATA_STATUS_UNKNOWN = 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_DATA_STATUS_PENDING = 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_DATA_STATUS_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_DATA_STATUS_ACKOWLG = 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_ACK_STATE_UNKN = 0x0000 ; // unknown destination key static const uint32_t RS_GROUTER_TUNNEL_STATUS_UNMANAGED = 0x0000 ;// unknown destination key
static const uint32_t RS_GROUTER_ACK_STATE_RCVD = 0x0001 ; // data was received, directly static const uint32_t RS_GROUTER_TUNNEL_STATUS_PENDING = 0x0001 ;// unknown destination key
static const uint32_t RS_GROUTER_ACK_STATE_IRCV = 0x0002 ; // data was received indirectly static const uint32_t RS_GROUTER_TUNNEL_STATUS_READY = 0x0002 ;// unknown destination key
static const uint32_t RS_GROUTER_ACK_STATE_GVNP = 0x0003 ; // data was given up. No route. static const uint32_t RS_GROUTER_TUNNEL_STATUS_CAN_SEND = 0x0003 ;// unknown destination key
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)
class FriendTrialRecord class FriendTrialRecord
{ {
@ -82,14 +80,16 @@ class FriendTrialRecord
class GRouterRoutingInfo class GRouterRoutingInfo
{ {
public: public:
uint32_t status_flags ; // pending, waiting, etc. uint32_t data_status ; // pending, waiting, etc.
RsPeerId origin ; // which friend sent us that item uint32_t tunnel_status ; // status of tunnel handling.
time_t received_time ; // time at which the item was originally received time_t received_time_TS ; // time at which the item was originally received
time_t last_sent ; // last time the item was sent to friends 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. RsGxsId destination_key ; // ultimate destination for this key
GRouterKeyId destination_key ; // ultimate destination for this key
GRouterServiceId client_id ; // service ID of the client. Only valid when origin==OwnId 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 ;
}; };

1105
libretroshare/src/grouter/p3grouter.cc
View file

File diff suppressed because it is too large Load diff

130
libretroshare/src/grouter/p3grouter.h
View file

@ -31,27 +31,54 @@
#include "retroshare/rsgrouter.h" #include "retroshare/rsgrouter.h"
#include "retroshare/rstypes.h" #include "retroshare/rstypes.h"
#include "retroshare/rstypes.h"
#include "turtle/turtleclientservice.h"
#include "services/p3service.h" #include "services/p3service.h"
#include "pqi/p3cfgmgr.h" #include "pqi/p3cfgmgr.h"
#include "groutertypes.h" #include "groutertypes.h"
#include "groutermatrix.h" #include "groutermatrix.h"
#include "grouteritems.h" #include "grouteritems.h"
//#include "groutercache.h"
// To be put in pqi/p3cfgmgr.h // To be put in pqi/p3cfgmgr.h
// //
static const uint32_t CONFIG_TYPE_GROUTER = 0x0016 ; static const uint32_t CONFIG_TYPE_GROUTER = 0x0016 ;
class p3LinkMgr ; static const uint32_t RS_GROUTER_DATA_FLAGS_ENCRYPTED = 0x0001 ;
class RsGRouterPublishKeyItem ;
class RsGRouterACKItem ;
class p3GRouter: public RsGRouter, public p3Service, public p3Config class p3LinkMgr ;
class p3turtle ;
class p3IdService ;
class RsGRouterItem ;
class RsGRouterGenericDataItem ;
class RsGRouterReceiptItem ;
class GRouterTunnelInfo
{ {
public: public:
p3GRouter(p3ServiceControl *sc,p3LinkMgr *lm) ; GRouterTunnelInfo() :first_tunnel_ok_TS(0), last_tunnel_ok_TS(0) {}
void addVirtualPeer(const TurtleVirtualPeerId& vpid)
{
assert(virtual_peers.find(vpid) == virtual_peers.end()) ;
time_t now = time(NULL) ;
virtual_peers.insert(vpid) ;
if(first_tunnel_ok_TS == 0) first_tunnel_ok_TS = now ;
if(last_tunnel_ok_TS < now) last_tunnel_ok_TS = now ;
}
std::set<TurtleVirtualPeerId> virtual_peers ;
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) ;
//===================================================// //===================================================//
// Router clients business // // Router clients business //
@ -68,17 +95,17 @@ class p3GRouter: public RsGRouter, public p3Service, public p3Config
// forward in the network, so that is can be a possible destination for // forward in the network, so that is can be a possible destination for
// global messages. // global messages.
// //
// key : The key that is published // auth_id : The GXS key that will be used to sign the data Receipts.
// fingerp : Fingerprint of the key to encrypt the data. // contact_key : The key that is used to open tunnels
// desc_str : Any fixed length string (< 20 characters) to descript the address in words. // 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. // 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. // 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 // Unregistering a key might not have an instantaneous effect, so the client is responsible for
// discarding traffic that might later come for this key. // 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 registerKey(const RsGxsId& authentication_id, const GRouterServiceId& client_id,const std::string& description_string) ;
virtual bool unregisterKey(const GRouterKeyId& key) ; virtual bool unregisterKey(const RsGxsId &key_id, const GRouterServiceId &sid) ;
//===================================================// //===================================================//
// Routing clue collection methods // // Routing clue collection methods //
@ -95,12 +122,12 @@ class p3GRouter: public RsGRouter, public p3Service, public p3Config
// remembered by the client, so that he knows when the data has been received. // 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. // 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) ; virtual bool sendData( const RsGxsId& destination,
const GRouterServiceId& client_id,
// Sends an ACK to the origin of the msg. This is used to notify for uint8_t *data,
// unfound route, or message correctly received, depending on the particular situation. uint32_t data_size,
// const RsGxsId& signing_id,
virtual void sendACK(const RsPeerId& peer,GRouterMsgPropagationId mid, uint32_t flags) ; GRouterMsgPropagationId& id) ;
//===================================================// //===================================================//
// Interface with RsGRouter // // Interface with RsGRouter //
@ -138,7 +165,10 @@ class p3GRouter: public RsGRouter, public p3Service, public p3Config
} }
virtual void setDebugEnabled(bool b) { _debug_enabled = b ; } virtual void setDebugEnabled(bool b) { _debug_enabled = b ; }
protected:
virtual void connectToTurtleRouter(p3turtle *pt) ;
protected:
//===================================================// //===================================================//
// Routing method handling // // Routing method handling //
//===================================================// //===================================================//
@ -156,7 +186,16 @@ class p3GRouter: public RsGRouter, public p3Service, public p3Config
static const uint16_t SERVICE_INFO_MIN_MAJOR_VERSION = 1; static const uint16_t SERVICE_INFO_MIN_MAJOR_VERSION = 1;
static const uint16_t SERVICE_INFO_MIN_MINOR_VERSION = 0; static const uint16_t SERVICE_INFO_MIN_MINOR_VERSION = 0;
private: //===================================================//
// Interaction with turtle router //
//===================================================//
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) ;
private:
class nullstream: public std::ostream {}; class nullstream: public std::ostream {};
std::ostream& grouter_debug() const std::ostream& grouter_debug() const
@ -169,12 +208,12 @@ class p3GRouter: public RsGRouter, public p3Service, public p3Config
void autoWash() ; void autoWash() ;
void routePendingObjects() ; void routePendingObjects() ;
void handleIncoming() ; void handleIncoming() ;
void handleTunnels() ;
void debugDump() ; void debugDump() ;
// utility functions // 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 float computeMatrixContribution(float base,uint32_t time_shift,float probability) ;
static time_t computeNextTimeDelay(time_t duration) ; static time_t computeNextTimeDelay(time_t duration) ;
@ -182,6 +221,14 @@ class p3GRouter: public RsGRouter, public p3Service, public p3Config
uint32_t computeRandomDistanceIncrement(const RsPeerId& pid,const GRouterKeyId& destination_id) ; uint32_t computeRandomDistanceIncrement(const RsPeerId& pid,const GRouterKeyId& destination_id) ;
// 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);
//===================================================// //===================================================//
// p3Config methods // // p3Config methods //
//===================================================// //===================================================//
@ -201,6 +248,10 @@ class p3GRouter: public RsGRouter, public p3Service, public p3Config
// //
void debug_dump() ; void debug_dump() ;
//===================================================//
// Internal queues/variables //
//===================================================//
// Stores the routing info // Stores the routing info
// - list of known key ids // - list of known key ids
// - list of clues/time_stamp for each key. // - list of clues/time_stamp for each key.
@ -208,6 +259,20 @@ class p3GRouter: public RsGRouter, public p3Service, public p3Config
// //
GRouterMatrix _routing_matrix ; 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. // Stores the routing events.
// - ongoing requests, waiting for return ACK // - ongoing requests, waiting for return ACK
// - pending items // - pending items
@ -215,28 +280,21 @@ class p3GRouter: public RsGRouter, public p3Service, public p3Config
// //
std::map<GRouterMsgPropagationId, GRouterRoutingInfo> _pending_messages;// pending messages std::map<GRouterMsgPropagationId, GRouterRoutingInfo> _pending_messages;// pending messages
// Stores the keys which identify the router's node. For each key, a structure holds: std::map<TurtleFileHash,GRouterTunnelInfo> _virtual_peers ;
// - the client service
// - flags
// - usage time stamps
//
std::map<GRouterKeyId, GRouterPublishedKeyInfo> _owned_key_ids ;
// Registered services. These are known to the different peers with a common id, // Queue of incoming items. Might be receipts or data. Should always be empty (not a storage place)
// so it's important to keep consistency here. This map is volatile, and re-created at each startup of std::list<RsGRouterItem*> _incoming_items ;
// the software, when newly created services register themselves.
std::map<GRouterServiceId,GRouterClientService *> _registered_services ; // Data handling methods
// Data handling ethods
// //
void handleRecvDataItem(RsGRouterGenericDataItem *item); void handleRecvDataItem(RsGRouterGenericDataItem *item);
void handleRecvACKItem(RsGRouterACKItem *item); void handleRecvReceiptItem(RsGRouterReceiptItem *item);
// Pointers to other RS objects // Pointers to other RS objects
// //
p3ServiceControl *mServiceControl ; p3ServiceControl *mServiceControl ;
p3LinkMgr *mLinkMgr ; p3turtle *mTurtle ;
p3IdService *mIdService ;
// Multi-thread protection mutex. // Multi-thread protection mutex.
// //

3
libretroshare/src/libretroshare.pro
View file

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

14
libretroshare/src/retroshare/rsgrouter.h
View file

@ -27,8 +27,9 @@
#include "util/rsdir.h" #include "util/rsdir.h"
#include "retroshare/rsids.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 uint32_t GRouterServiceId ;
typedef uint64_t GRouterMsgPropagationId ; typedef uint64_t GRouterMsgPropagationId ;
@ -53,6 +54,7 @@ class RsGRouter
struct GRouterPublishedKeyInfo struct GRouterPublishedKeyInfo
{ {
std::string description_string ; std::string description_string ;
RsGxsId authentication_key ;
uint32_t service_id ; uint32_t service_id ;
}; };
@ -85,8 +87,14 @@ class RsGRouter
// Communication to other services. // // Communication to other services. //
//===================================================// //===================================================//
virtual void sendData(const GRouterKeyId& destination, const GRouterServiceId& client_id, RsGRouterGenericDataItem *item,GRouterMsgPropagationId& id) =0; virtual bool sendData( const RsGxsId& destination,
virtual bool registerKey(const GRouterKeyId& key,const GRouterServiceId& client_id,const std::string& description_string) =0; 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 // // Routage feedback from other services //

2
libretroshare/src/retroshare/rsids.h
View file

@ -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 ; 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_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< 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< 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 ; typedef t_RsGenericIdType< PGP_KEY_FINGERPRINT_SIZE, true, RS_GENERIC_ID_PGP_FINGERPRINT_TYPE> PGPFingerprintType ;

11
libretroshare/src/retroshare/rsmsgs.h
View file

@ -95,7 +95,7 @@ typedef uint64_t ChatLobbyMsgId ;
typedef std::string ChatLobbyNickName ; typedef std::string ChatLobbyNickName ;
typedef RsPeerId DistantChatPeerId ; typedef RsPeerId DistantChatPeerId ;
typedef GRouterKeyIdType DistantMsgPeerId ; //typedef GRouterKeyId DistantMsgPeerId ;
typedef uint64_t MessageId ; typedef uint64_t MessageId ;
@ -368,14 +368,6 @@ std::ostream &operator<<(std::ostream &out, const MessageInfo &info);
class RsMsgs; class RsMsgs;
extern RsMsgs *rsMsgs; extern RsMsgs *rsMsgs;
struct DistantOfflineMessengingInvite
{
RsPgpId issuer_pgp_id ;
DistantMsgPeerId peer_id ;
time_t time_of_validity ;
};
class RsMsgs class RsMsgs
{ {
public: public:
@ -390,7 +382,6 @@ virtual ~RsMsgs() { return; }
virtual bool getMessageSummaries(std::list<MsgInfoSummary> &msgList) = 0; virtual bool getMessageSummaries(std::list<MsgInfoSummary> &msgList) = 0;
virtual bool getMessage(const std::string &mId, MessageInfo &msg) = 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 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 MessageSend(MessageInfo &info) = 0;
virtual bool SystemMessage(const std::string &title, const std::string &message, uint32_t systemFlag) = 0; virtual bool SystemMessage(const std::string &title, const std::string &message, uint32_t systemFlag) = 0;

4
libretroshare/src/rsserver/p3msgs.cc
View file

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

1
libretroshare/src/rsserver/p3msgs.h
View file

@ -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 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 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 SystemMessage(const std::string &title, const std::string &message, uint32_t systemFlag);
virtual bool MessageToDraft(MessageInfo &info, const std::string &msgParentId); virtual bool MessageToDraft(MessageInfo &info, const std::string &msgParentId);
virtual bool MessageToTrash(const std::string &mid, bool bTrash); virtual bool MessageToTrash(const std::string &mid, bool bTrash);

3
libretroshare/src/rsserver/rsinit.cc
View file

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

157
libretroshare/src/services/p3msgservice.cc
View file

@ -315,19 +315,12 @@ void p3MsgService::checkSizeAndSendMessage(RsMsgItem *msg)
// Indicate that the message is to be continued. // Indicate that the message is to be continued.
// //
item->msgFlags |= RS_MSG_FLAGS_PARTIAL ; item->msgFlags |= RS_MSG_FLAGS_PARTIAL ;
if(msg->msgFlags & RS_MSG_FLAGS_DISTANT)
sendPrivateMsgItem(item) ;
else
sendItem(item) ; sendItem(item) ;
} }
#ifdef DEBUG_DISTANT_MSG #ifdef DEBUG_DISTANT_MSG
std::cerr << " Chopped off msg of size " << msg->message.size() << std::endl; std::cerr << " Chopped off msg of size " << msg->message.size() << std::endl;
#endif #endif
if(msg->msgFlags & RS_MSG_FLAGS_DISTANT)
sendPrivateMsgItem(msg) ;
else
sendItem(msg) ; sendItem(msg) ;
} }
@ -414,6 +407,9 @@ int p3MsgService::checkOutgoingMessages()
} }
for(std::list<RsMsgItem*>::const_iterator it(output_queue.begin());it!=output_queue.end();++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) ; checkSizeAndSendMessage(*it) ;
if(changed) if(changed)
@ -996,7 +992,7 @@ bool p3MsgService::setMsgParentId(uint32_t msgId, uint32_t msgParentId)
/****************************************/ /****************************************/
/****************************************/ /****************************************/
/* Message Items */ /* Message Items */
int p3MsgService::sendMessage(RsMsgItem *item) uint32_t p3MsgService::sendMessage(RsMsgItem *item)
{ {
if(!item) if(!item)
return 0 ; return 0 ;
@ -1021,15 +1017,23 @@ int p3MsgService::sendMessage(RsMsgItem *item)
msi->srcId = item->PeerId(); msi->srcId = item->PeerId();
mSrcIds.insert(std::pair<uint32_t, RsMsgSrcId*>(msi->msgId, msi)); mSrcIds.insert(std::pair<uint32_t, RsMsgSrcId*>(msi->msgId, msi));
} }
} }
IndicateConfigChanged(); /**** INDICATE MSG CONFIG CHANGED! *****/ IndicateConfigChanged(); /**** INDICATE MSG CONFIG CHANGED! *****/
RsServer::notify()->notifyListChange(NOTIFY_LIST_MESSAGELIST, NOTIFY_TYPE_ADD); 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) 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_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<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_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) sendMessage(initMIRsMsg(info, *pit)); 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) sendMessage(initMIRsMsg(info, *pit)); 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 */ /* send to ourselves as well */
RsMsgItem *msg = initMIRsMsg(info, mServiceCtrl->getOwnId()); RsMsgItem *msg = initMIRsMsg(info, mServiceCtrl->getOwnId());
@ -1643,21 +1647,21 @@ RsMsgItem *p3MsgService::initMIRsMsg(const MessageInfo& info, const RsGxsId& to)
initMIRsMsg(msg,info) ; initMIRsMsg(msg,info) ;
msg->PeerId(RsPeerId()); msg->PeerId(RsPeerId(to));
msg->msgFlags |= RS_MSG_FLAGS_DISTANT; msg->msgFlags |= RS_MSG_FLAGS_DISTANT;
if (info.msgflags & RS_MSG_SIGNED) if (info.msgflags & RS_MSG_SIGNED)
msg->msgFlags |= RS_MSG_FLAGS_SIGNED; msg->msgFlags |= RS_MSG_FLAGS_SIGNED;
// We replace the msg text by the whole message serialized possibly signed, // // We replace the msg text by the whole message serialized possibly signed,
// and binary encrypted, so as to obfuscate all its content. // // and binary encrypted, so as to obfuscate all its content.
// // //
if(!createDistantMessage(to,info.rsgxsid_srcId,msg)) // if(!createDistantMessage(to,info.rsgxsid_srcId,msg))
{ // {
std::cerr << "Cannot encrypt distant message. Something went wrong." << std::endl; // std::cerr << "Cannot encrypt distant message. Something went wrong." << std::endl;
delete msg ; // delete msg ;
return NULL ; // return NULL ;
} // }
return msg ; return msg ;
} }
@ -1676,6 +1680,7 @@ RsMsgItem *p3MsgService::initMIRsMsg(const MessageInfo &info, const RsPeerId& to
return msg; return msg;
} }
#ifdef TO_BE_REMOVED
bool p3MsgService::createDistantMessage(const RsGxsId& destination_gxs_id,const RsGxsId& source_gxs_id,RsMsgItem *item) bool p3MsgService::createDistantMessage(const RsGxsId& destination_gxs_id,const RsGxsId& source_gxs_id,RsMsgItem *item)
{ {
#ifdef DEBUG_DISTANT_MSG #ifdef DEBUG_DISTANT_MSG
@ -2094,6 +2099,7 @@ bool p3MsgService::decryptMessage(const std::string& mId)
return false ; return false ;
} }
} }
#endif
void p3MsgService::connectToGlobalRouter(p3GRouter *gr) void p3MsgService::connectToGlobalRouter(p3GRouter *gr)
{ {
@ -2123,10 +2129,12 @@ void p3MsgService::enableDistantMessaging(bool b)
#endif #endif
for(std::list<RsGxsId>::const_iterator it(own_id_list.begin());it!=own_id_list.end();++it) for(std::list<RsGxsId>::const_iterator it(own_id_list.begin());it!=own_id_list.end();++it)
{
if(b) if(b)
mGRouter->registerKey(GRouterKeyId(*it),GROUTER_CLIENT_ID_MESSAGES,"Messaging contact") ; mGRouter->registerKey(*it,GROUTER_CLIENT_ID_MESSAGES,"Messaging contact") ;
else else
mGRouter->unregisterKey(GRouterKeyId(*it)) ; mGRouter->unregisterKey(*it,GROUTER_CLIENT_ID_MESSAGES) ;
}
if(cchanged) if(cchanged)
IndicateConfigChanged() ; IndicateConfigChanged() ;
@ -2147,36 +2155,6 @@ void p3MsgService::manageDistantPeers()
enableDistantMessaging(mDistantMessagingEnabled) ; 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) void p3MsgService::acknowledgeDataReceived(const GRouterMsgPropagationId& id)
{ {
RsStackMutex stack(mMsgMtx); /********** STACK LOCKED MTX ******/ 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); RsServer::notify()->notifyListChange(NOTIFY_LIST_MESSAGELIST,NOTIFY_TYPE_ADD);
IndicateConfigChanged() ; 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(data,&data_size) ;
RsItem *item = _serialiser->deserialise(gitem->data_bytes,&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; 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. msg_item->PeerId(RsPeerId(signing_key)) ; // hack to pass on GXS id.
handleIncomingItem(encrypted_msg_item) ; handleIncomingItem(msg_item) ;
} }
else else
std::cerr << " Item could not be deserialised. Format error??" << std::endl; 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 RsGxsId destination_key_id(msgitem->PeerId()) ;
std::cerr << "p3MsgService::sendDistanteMsgItem(): sending distant msg item to peer " << msgitem->PeerId() << std::endl; RsGxsId signing_key_id ;
#endif
GRouterKeyId key_id(msgitem->PeerId()) ;
{
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 #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 #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 ;
}
} }

12
libretroshare/src/services/p3msgservice.h
View file

@ -127,7 +127,7 @@ class p3MsgService: public p3Service, public p3Config, public pqiServiceMonitor,
bool distantMessagingEnabled() ; bool distantMessagingEnabled() ;
private: private:
void sendPrivateMsgItem(RsMsgItem *msgitem) ; void sendDistantMsgItem(RsMsgItem *msgitem) ;
// This contains the ongoing tunnel handling contacts. // This contains the ongoing tunnel handling contacts.
// The map is indexed by the hash // The map is indexed by the hash
@ -136,21 +136,22 @@ class p3MsgService: public p3Service, public p3Config, public pqiServiceMonitor,
// Overloaded from GRouterClientService // 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) ; virtual void acknowledgeDataReceived(const GRouterMsgPropagationId& msg_id) ;
// Utility functions // Utility functions
bool createDistantMessage(const RsGxsId& destination_gxs_id,const RsGxsId& source_gxs_id,RsMsgItem *msg) ; bool createDistantMessage(const RsGxsId& destination_gxs_id,const RsGxsId& source_gxs_id,RsMsgItem *msg) ;
bool locked_findHashForVirtualPeerId(const RsPeerId& pid,Sha1CheckSum& hash) ; 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 manageDistantPeers() ;
void handleIncomingItem(RsMsgItem *) ; void handleIncomingItem(RsMsgItem *) ;
uint32_t getNewUniqueMsgId(); uint32_t getNewUniqueMsgId();
int sendMessage(RsMsgItem *item); uint32_t sendMessage(RsMsgItem *item);
uint32_t sendDistantMessage(RsMsgItem *item,const RsGxsId& signing_gxs_id);
void checkSizeAndSendMessage(RsMsgItem *msg); void checkSizeAndSendMessage(RsMsgItem *msg);
int incomingMsgs(); int incomingMsgs();
@ -192,6 +193,9 @@ class p3MsgService: public p3Service, public p3Config, public pqiServiceMonitor,
// used delete msgSrcIds after config save // 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 // save the parent of the messages in draft for replied and forwarded
std::map<uint32_t, RsMsgParentId*> mParentId; std::map<uint32_t, RsMsgParentId*> mParentId;

13
retroshare-gui/src/gui/MessagesDialog.cpp
View file

@ -1521,19 +1521,6 @@ void MessagesDialog::insertMsgTxtAndFiles(QTreeWidgetItem *item, bool bSetToRead
updateInterface(); 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) bool MessagesDialog::getCurrentMsg(std::string &cid, std::string &mid)
{ {
QTreeWidgetItem *item = ui.messageTreeWidget->currentItem(); QTreeWidgetItem *item = ui.messageTreeWidget->currentItem();

1
retroshare-gui/src/gui/MessagesDialog.h
View file

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

1
retroshare-gui/src/gui/RetroShareLink.cpp
View file

@ -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; std::cerr << " RetroShareLink::process MessageRequest : id : " << link.hash().toStdString() << ", subject : " << link.name().toStdString() << std::endl;
#endif #endif
RsPeerDetails detail; RsPeerDetails detail;
DistantMsgPeerId dm_pid ;
// This is awful, but apparently the hash can be multiple different types. Let's check! // This is awful, but apparently the hash can be multiple different types. Let's check!

1
retroshare-gui/src/gui/common/PeerDefs.cpp
View file

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

50
retroshare-gui/src/gui/msgs/MessageWidget.cpp
View file

@ -133,14 +133,12 @@ MessageWidget::MessageWidget(bool controlled, QWidget *parent, Qt::WindowFlags f
connect(ui.expandFilesButton, SIGNAL(clicked()), this, SLOT(togglefileview())); connect(ui.expandFilesButton, SIGNAL(clicked()), this, SLOT(togglefileview()));
connect(ui.downloadButton, SIGNAL(clicked()), this, SLOT(getallrecommended())); connect(ui.downloadButton, SIGNAL(clicked()), this, SLOT(getallrecommended()));
connect(ui.msgText, SIGNAL(anchorClicked(QUrl)), this, SLOT(anchorClicked(QUrl))); 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(messagesTagsChanged()), this, SLOT(messagesTagsChanged()));
connect(NotifyQt::getInstance(), SIGNAL(messagesChanged()), this, SLOT(messagesChanged())); connect(NotifyQt::getInstance(), SIGNAL(messagesChanged()), this, SLOT(messagesChanged()));
ui.imageBlockWidget->addButtonAction(tr("Load images always for this message"), this, SLOT(loadImagesAlways()), true); ui.imageBlockWidget->addButtonAction(tr("Load images always for this message"), this, SLOT(loadImagesAlways()), true);
ui.msgText->setImageBlockWidget(ui.imageBlockWidget); ui.msgText->setImageBlockWidget(ui.imageBlockWidget);
ui.decryptFrame->hide();
/* hide the Tree +/- */ /* hide the Tree +/- */
ui.msgList->setRootIsDecorated( false ); ui.msgList->setRootIsDecorated( false );
@ -445,8 +443,6 @@ void MessageWidget::fill(const std::string &msgId)
// return; // return;
// } // }
ui.decryptFrame->hide();
currMsgId = msgId; currMsgId = msgId;
if (currMsgId.empty()) { if (currMsgId.empty()) {
@ -573,12 +569,7 @@ void MessageWidget::fill(const std::string &msgId)
ui.fromText->setToolTip(tooltip_string) ; 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())); 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); 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)); 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.filesText->setText(QString("%1").arg(msgInfo.count));
ui.filesSize->setText(QString(misc::friendlyUnit(msgInfo.size))); ui.filesSize->setText(QString(misc::friendlyUnit(msgInfo.size)));
if (msgInfo.msgflags & RS_MSG_ENCRYPTED) {
ui.decryptFrame->show();
}
showTagLabels(); showTagLabels();
currMsgFlags = msgInfo.msgflags; currMsgFlags = msgInfo.msgflags;
@ -748,40 +735,3 @@ void MessageWidget::loadImagesAlways()
rsMsgs->MessageLoadEmbeddedImages(currMsgId, true); 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;
}

2
retroshare-gui/src/gui/msgs/MessageWidget.h
View file

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

121
retroshare-gui/src/gui/msgs/MessageWidget.ui
View file

@ -23,7 +23,7 @@
<property name="bottomMargin"> <property name="bottomMargin">
<number>0</number> <number>0</number>
</property> </property>
<item row="1" column="0"> <item row="0" column="0">
<widget class="QSplitter" name="msgSplitter"> <widget class="QSplitter" name="msgSplitter">
<property name="orientation"> <property name="orientation">
<enum>Qt::Vertical</enum> <enum>Qt::Vertical</enum>
@ -414,125 +414,6 @@
</widget> </widget>
</widget> </widget>
</item> </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> </layout>
<action name="actionPrint"> <action name="actionPrint">
<property name="text"> <property name="text">