mirror of
https://github.com/RetroShare/RetroShare.git
synced 2025-08-09 23:02:29 -04:00
fixed up encryption/decryption of messages. Message passing through grouter works./RetroShare
git-svn-id: http://svn.code.sf.net/p/retroshare/code/branches/v0.6-IdCleaning@7204 b45a01b8-16f6-495d-af2f-9b41ad6348cc
This commit is contained in:
csoler
parent
e5a6dde5b9
commit
d2ab6cc6ab
8 changed files with 157 additions and 106 deletions
|
|
@ -170,7 +170,7 @@ RsItem *RsGRouterSerialiser::deserialise(void *data, uint32_t *pktsize)
|
|||
return NULL;
|
||||
}
|
||||
|
||||
RsGRouterItem *RsGRouterSerialiser::deserialise_RsGRouterPublishKeyItem(void *data, uint32_t pktsize) const
|
||||
RsGRouterPublishKeyItem *RsGRouterSerialiser::deserialise_RsGRouterPublishKeyItem(void *data, uint32_t pktsize) const
|
||||
{
|
||||
uint32_t offset = 8; // skip the header
|
||||
uint32_t rssize = getRsItemSize(data);
|
||||
|
|
@ -197,7 +197,7 @@ RsGRouterItem *RsGRouterSerialiser::deserialise_RsGRouterPublishKeyItem(void *da
|
|||
return item;
|
||||
}
|
||||
|
||||
RsGRouterItem *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 rssize = getRsItemSize(data);
|
||||
|
|
@ -205,9 +205,10 @@ RsGRouterItem *RsGRouterSerialiser::deserialise_RsGRouterGenericDataItem(void *d
|
|||
|
||||
RsGRouterGenericDataItem *item = new RsGRouterGenericDataItem() ;
|
||||
|
||||
ok &= getRawUInt32(data, pktsize, &offset, &item->routing_id); // file hash
|
||||
ok &= item->destination_key.deserialise(data, pktsize, offset) ;
|
||||
ok &= getRawUInt32(data, pktsize, &offset, &item->data_size); // file hash
|
||||
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)))
|
||||
{
|
||||
|
|
@ -227,7 +228,7 @@ RsGRouterItem *RsGRouterSerialiser::deserialise_RsGRouterGenericDataItem(void *d
|
|||
return item;
|
||||
}
|
||||
|
||||
RsGRouterItem *RsGRouterSerialiser::deserialise_RsGRouterACKItem(void *data, uint32_t pktsize) const
|
||||
RsGRouterACKItem *RsGRouterSerialiser::deserialise_RsGRouterACKItem(void *data, uint32_t pktsize) const
|
||||
{
|
||||
uint32_t offset = 8; // skip the header
|
||||
uint32_t rssize = getRsItemSize(data);
|
||||
|
|
@ -235,7 +236,7 @@ RsGRouterItem *RsGRouterSerialiser::deserialise_RsGRouterACKItem(void *data, uin
|
|||
|
||||
RsGRouterACKItem *item = new RsGRouterACKItem() ;
|
||||
|
||||
ok &= getRawUInt32(data, pktsize, &offset, &item->mid); // file hash
|
||||
ok &= getRawUInt64(data, pktsize, &offset, &item->mid); // file hash
|
||||
ok &= getRawUInt32(data, pktsize, &offset, &item->state); // file hash
|
||||
|
||||
if (offset != rssize || !ok)
|
||||
|
|
@ -247,7 +248,7 @@ RsGRouterItem *RsGRouterSerialiser::deserialise_RsGRouterACKItem(void *data, uin
|
|||
return item;
|
||||
}
|
||||
|
||||
RsGRouterItem *RsGRouterSerialiser::deserialise_RsGRouterRoutingInfoItem(void *data, uint32_t pktsize) const
|
||||
RsGRouterRoutingInfoItem *RsGRouterSerialiser::deserialise_RsGRouterRoutingInfoItem(void *data, uint32_t pktsize) const
|
||||
{
|
||||
uint32_t offset = 8; // skip the header
|
||||
uint32_t rssize = getRsItemSize(data);
|
||||
|
|
@ -256,7 +257,7 @@ RsGRouterItem *RsGRouterSerialiser::deserialise_RsGRouterRoutingInfoItem(void *d
|
|||
RsGRouterRoutingInfoItem *item = new RsGRouterRoutingInfoItem() ;
|
||||
|
||||
ok &= getRawUInt32(data, pktsize, &offset, &item->status_flags);
|
||||
ok &= item->origin.deserialise(data, pktsize, offset) ;
|
||||
ok &= item->origin.deserialise(data, pktsize, offset) ;
|
||||
ok &= getRawTimeT(data, pktsize, &offset, item->received_time);
|
||||
|
||||
uint32_t s = 0 ;
|
||||
|
|
@ -266,21 +267,15 @@ RsGRouterItem *RsGRouterSerialiser::deserialise_RsGRouterRoutingInfoItem(void *d
|
|||
{
|
||||
FriendTrialRecord ftr ;
|
||||
|
||||
ok &= ftr.friend_id.deserialise(data, pktsize, offset) ;
|
||||
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 = new RsGRouterGenericDataItem ;
|
||||
|
||||
ok &= getRawUInt32(data, pktsize, &offset, &item->data_item->routing_id);
|
||||
ok &= item->data_item->destination_key.deserialise(data, pktsize, offset) ;
|
||||
ok &= getRawUInt32(data, pktsize, &offset, &item->data_item->data_size) ;
|
||||
|
||||
item->data_item->data_bytes = (uint8_t*)malloc(item->data_item->data_size) ;
|
||||
memcpy(item->data_item->data_bytes,&((uint8_t*)data)[offset],item->data_item->data_size) ;
|
||||
offset += item->data_item->data_size ;
|
||||
item->data_item = deserialise_RsGRouterGenericDataItem(&((uint8_t*)data)[offset],pktsize - offset) ;
|
||||
|
||||
if (offset != rssize || !ok)
|
||||
{
|
||||
|
|
@ -290,7 +285,7 @@ RsGRouterItem *RsGRouterSerialiser::deserialise_RsGRouterRoutingInfoItem(void *d
|
|||
|
||||
return item;
|
||||
}
|
||||
RsGRouterItem *RsGRouterSerialiser::deserialise_RsGRouterMatrixFriendListItem(void *data, uint32_t pktsize) const
|
||||
RsGRouterMatrixFriendListItem *RsGRouterSerialiser::deserialise_RsGRouterMatrixFriendListItem(void *data, uint32_t pktsize) const
|
||||
{
|
||||
uint32_t offset = 8; // skip the header
|
||||
uint32_t rssize = getRsItemSize(data);
|
||||
|
|
@ -314,7 +309,7 @@ RsGRouterItem *RsGRouterSerialiser::deserialise_RsGRouterMatrixFriendListItem(vo
|
|||
|
||||
return item;
|
||||
}
|
||||
RsGRouterItem *RsGRouterSerialiser::deserialise_RsGRouterMatrixCluesItem(void *data, uint32_t pktsize) const
|
||||
RsGRouterMatrixCluesItem *RsGRouterSerialiser::deserialise_RsGRouterMatrixCluesItem(void *data, uint32_t pktsize) const
|
||||
{
|
||||
uint32_t offset = 8; // skip the header
|
||||
uint32_t rssize = getRsItemSize(data);
|
||||
|
|
@ -357,6 +352,7 @@ 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
|
||||
|
||||
|
|
@ -368,11 +364,12 @@ RsGRouterGenericDataItem *RsGRouterGenericDataItem::duplicate() const
|
|||
|
||||
uint32_t RsGRouterGenericDataItem::serial_size() const
|
||||
{
|
||||
uint32_t s = 8 ; // header
|
||||
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_size
|
||||
s += destination_key.serial_size() ; // destination_key
|
||||
s += 4 ; // randomized distance
|
||||
s += 4 ; // data_size
|
||||
s += data_size ; // data
|
||||
|
||||
return s ;
|
||||
}
|
||||
|
|
@ -393,8 +390,9 @@ bool RsGRouterGenericDataItem::serialise(void *data,uint32_t& size) const
|
|||
return false ;
|
||||
|
||||
/* add mandatory parts first */
|
||||
ok &= setRawUInt32(data, tlvsize, &offset, routing_id);
|
||||
ok &= destination_key.serialise(data, tlvsize, offset) ;
|
||||
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);
|
||||
|
||||
memcpy(&((uint8_t*)data)[offset],data_bytes,data_size) ;
|
||||
|
|
@ -417,7 +415,7 @@ bool RsGRouterACKItem::serialise(void *data,uint32_t& size) const
|
|||
return false ;
|
||||
|
||||
/* add mandatory parts first */
|
||||
ok &= setRawUInt32(data, tlvsize, &offset, mid);
|
||||
ok &= setRawUInt64(data, tlvsize, &offset, mid);
|
||||
ok &= setRawUInt32(data, tlvsize, &offset, state);
|
||||
|
||||
if (offset != tlvsize)
|
||||
|
|
@ -450,18 +448,13 @@ uint32_t RsGRouterMatrixFriendListItem::serial_size() const
|
|||
}
|
||||
uint32_t RsGRouterRoutingInfoItem::serial_size() const
|
||||
{
|
||||
uint32_t s = 8 ; // header
|
||||
uint32_t s = 8 ; // header
|
||||
s += 4 ; // status_flags
|
||||
s += origin.serial_size() ; // origin
|
||||
s += origin.serial_size() ; // origin
|
||||
s += 8 ; // received_time
|
||||
s += 4 ; // tried_friends.size() ;
|
||||
|
||||
s += tried_friends.size() * ( RsPeerId::SIZE_IN_BYTES + 8 ) ; // FriendTrialRecord
|
||||
|
||||
s += 4; // data_item->routing_id
|
||||
s += data_item->destination_key.serial_size(); // data_item->destination_key
|
||||
s += 4; // data_item->data_size
|
||||
s += data_item->data_size; // data_item->data_bytes
|
||||
s += tried_friends.size() * ( RsPeerId::SIZE_IN_BYTES + 8 + 4 + 4 ) ; // FriendTrialRecord
|
||||
s += data_item->serial_size(); // data_item
|
||||
|
||||
return s ;
|
||||
}
|
||||
|
|
@ -515,6 +508,25 @@ bool RsGRouterMatrixCluesItem::serialise(void *data,uint32_t& size) const
|
|||
|
||||
return ok;
|
||||
}
|
||||
|
||||
bool FriendTrialRecord::deserialise(void *data,uint32_t& offset,uint32_t size)
|
||||
{
|
||||
bool ok = true ;
|
||||
ok &= friend_id.deserialise(data, size, offset) ;
|
||||
ok &= getRawTimeT(data, size, &offset, time_stamp) ;
|
||||
ok &= getRawUFloat32(data, size, &offset, probability) ;
|
||||
ok &= getRawUInt32(data, size, &offset, &nb_friends) ;
|
||||
return ok ;
|
||||
}
|
||||
bool FriendTrialRecord::serialise(void *data,uint32_t& offset,uint32_t size) const
|
||||
{
|
||||
bool ok = true ;
|
||||
ok &= friend_id.serialise(data, size, offset) ;
|
||||
ok &= setRawTimeT(data, size, &offset, time_stamp) ;
|
||||
ok &= setRawUFloat32(data, size, &offset, probability) ;
|
||||
ok &= setRawUInt32(data, size, &offset, nb_friends) ;
|
||||
return ok ;
|
||||
}
|
||||
bool RsGRouterRoutingInfoItem::serialise(void *data,uint32_t& size) const
|
||||
{
|
||||
uint32_t tlvsize,offset=0;
|
||||
|
|
@ -529,17 +541,11 @@ bool RsGRouterRoutingInfoItem::serialise(void *data,uint32_t& size) const
|
|||
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).friend_id.serialise(data, tlvsize, offset ) ;
|
||||
ok &= setRawTimeT(data, tlvsize, &offset, (*it).time_stamp) ;
|
||||
}
|
||||
ok &= (*it).serialise(data,offset,size - offset) ;
|
||||
|
||||
ok &= setRawUInt32(data, tlvsize, &offset, data_item->routing_id) ;
|
||||
ok &= data_item->destination_key.serialise(data, tlvsize, offset) ;
|
||||
ok &= setRawUInt32(data, tlvsize, &offset, data_item->data_size) ;
|
||||
|
||||
memcpy(&((uint8_t*)data)[offset],data_item->data_bytes,data_item->data_size) ;
|
||||
offset += data_item->data_size ;
|
||||
uint32_t ns = size - offset ;
|
||||
ok &= data_item->serialise( &((uint8_t*)data)[offset], ns) ;
|
||||
offset += ns ;
|
||||
|
||||
if (offset != tlvsize)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -34,12 +34,12 @@
|
|||
static const uint8_t RS_SERVICE_TYPE_GROUTER = 0x0016 ;
|
||||
|
||||
const uint8_t RS_PKT_SUBTYPE_GROUTER_PUBLISH_KEY = 0x01 ; // used to publish a key
|
||||
const uint8_t RS_PKT_SUBTYPE_GROUTER_DATA = 0x02 ; // used to send data to a destination
|
||||
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_MATRIX_CLUES = 0x80 ; // item to save matrix clues
|
||||
const uint8_t RS_PKT_SUBTYPE_GROUTER_ROUTING_INFO = 0x81 ; // item to save routing info
|
||||
const uint8_t RS_PKT_SUBTYPE_GROUTER_FRIENDS_LIST = 0x82 ; // item to save friend lists
|
||||
const uint8_t RS_PKT_SUBTYPE_GROUTER_ROUTING_INFO = 0x85 ; // 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 ;
|
||||
|
|
@ -253,12 +253,12 @@ class RsGRouterSerialiser: public RsSerialType
|
|||
virtual RsItem *deserialise (void *data, uint32_t *size) ;
|
||||
|
||||
private:
|
||||
RsGRouterItem *deserialise_RsGRouterPublishKeyItem(void *data,uint32_t size) const ;
|
||||
RsGRouterItem *deserialise_RsGRouterGenericDataItem(void *data,uint32_t size) const ;
|
||||
RsGRouterItem *deserialise_RsGRouterACKItem(void *data,uint32_t size) const ;
|
||||
RsGRouterItem *deserialise_RsGRouterMatrixCluesItem(void *data,uint32_t size) const ;
|
||||
RsGRouterItem *deserialise_RsGRouterMatrixFriendListItem(void *data,uint32_t size) const ;
|
||||
RsGRouterItem *deserialise_RsGRouterRoutingInfoItem(void *data,uint32_t size) const ;
|
||||
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 ;
|
||||
RsGRouterMatrixFriendListItem *deserialise_RsGRouterMatrixFriendListItem(void *data,uint32_t size) const ;
|
||||
RsGRouterRoutingInfoItem *deserialise_RsGRouterRoutingInfoItem(void *data,uint32_t size) const ;
|
||||
};
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -150,7 +150,14 @@ bool GRouterMatrix::computeRoutingProbabilities(const GRouterKeyId& key_id, cons
|
|||
|
||||
if(it2 == _time_combined_hits.end())
|
||||
{
|
||||
std::cerr << "GRouterMatrix::computeRoutingProbabilities(): key id " << key_id.toStdString() << " does not exist!" << std::endl;
|
||||
// The key is not known. In this case, we return equal probabilities for all peers.
|
||||
//
|
||||
float p = 1.0f / friends.size() ;
|
||||
|
||||
for(std::list<RsPeerId>::const_iterator it(friends.begin());it!=friends.end();++it)
|
||||
probas[*it] = p ;
|
||||
|
||||
std::cerr << "GRouterMatrix::computeRoutingProbabilities(): key id " << key_id.toStdString() << " does not exist! Returning uniform probabilities." << std::endl;
|
||||
return false ;
|
||||
}
|
||||
const std::vector<float>& w(it2->second) ;
|
||||
|
|
|
|||
|
|
@ -34,7 +34,7 @@ class RsGRouterGenericDataItem ;
|
|||
|
||||
typedef uint32_t GRouterServiceId ;
|
||||
typedef uint32_t GRouterKeyPropagationId ;
|
||||
typedef uint32_t GRouterMsgPropagationId ;
|
||||
typedef uint64_t GRouterMsgPropagationId ;
|
||||
|
||||
static const uint32_t GROUTER_CLIENT_ID_MESSAGES = 0x1001 ;
|
||||
|
||||
|
|
@ -50,8 +50,8 @@ static const time_t RS_GROUTER_PUBLISH_CAMPAIGN_PERIOD = 1 *60 ; // Check
|
|||
static const time_t RS_GROUTER_PUBLISH_KEY_TIME_INTERVAL = 2 *60 ; // Advertise each key once a day at most.
|
||||
static const time_t RS_GROUTER_ROUTING_WAITING_TIME = 3600 ; // time between two trial of sending a given message
|
||||
static const time_t RS_GROUTER_KEY_DIFFUSION_MAX_KEEP = 7200 ; // time to keep key diffusion items in cache, to avoid multiple diffusion.
|
||||
static const uint32_t GROUTER_ITEM_DISTANCE_UNIT = 100 ; // One unit of distance between two peers
|
||||
static const uint32_t GROUTER_ITEM_MAX_TRAVEL_DISTANCE = 10*100 ; // 10 distance units. That is a lot.
|
||||
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 = 16*256 ; // 16 distance units. That is a lot.
|
||||
|
||||
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.
|
||||
|
|
@ -68,23 +68,27 @@ class GRouterPublishedKeyInfo
|
|||
time_t validity_time ;
|
||||
};
|
||||
|
||||
struct FriendTrialRecord
|
||||
class FriendTrialRecord
|
||||
{
|
||||
RsPeerId friend_id ; // id of the friend
|
||||
time_t time_stamp ; // time of the last tried
|
||||
float probability ; // probability at which the item was selected
|
||||
int nb_friends ; // number of friends at the time of sending the item
|
||||
public:
|
||||
RsPeerId friend_id ; // id of the friend
|
||||
time_t time_stamp ; // time of the last tried
|
||||
float probability ; // probability at which the item was selected
|
||||
uint32_t nb_friends ; // number of friends at the time of sending the item
|
||||
|
||||
bool serialise(void *data,uint32_t& offset,uint32_t size) const ;
|
||||
bool deserialise(void *data,uint32_t& offset,uint32_t size) ;
|
||||
};
|
||||
|
||||
class GRouterRoutingInfo
|
||||
{
|
||||
public:
|
||||
RsGRouterGenericDataItem *data_item ;
|
||||
|
||||
uint32_t status_flags ; // pending, waiting, etc.
|
||||
std::list<FriendTrialRecord> tried_friends ; // list of friends to which the item was sent ordered with time.
|
||||
RsPeerId origin ; // which friend sent us that item
|
||||
time_t received_time ; // time at which the item was received
|
||||
uint32_t randomized_distance ; // distance of travel, randomized at each hop.
|
||||
|
||||
std::list<FriendTrialRecord> tried_friends ; // list of friends to which the item was sent ordered with time.
|
||||
|
||||
RsGRouterGenericDataItem *data_item ;
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -307,13 +307,14 @@ void p3GRouter::routePendingObjects()
|
|||
RsPeerId own_id( mLinkMgr->getOwnId() );
|
||||
|
||||
for(std::map<GRouterMsgPropagationId, GRouterRoutingInfo>::iterator it(_pending_messages.begin());it!=_pending_messages.end();)
|
||||
if((it->second.status_flags & RS_GROUTER_ROUTING_STATE_PEND) || (it->second.status_flags == RS_GROUTER_ROUTING_STATE_SENT && it->second.tried_friends.front().time_stamp+RS_GROUTER_ROUTING_WAITING_TIME < now))
|
||||
if((it->second.status_flags == RS_GROUTER_ROUTING_STATE_PEND) || (it->second.status_flags == RS_GROUTER_ROUTING_STATE_SENT && it->second.tried_friends.front().time_stamp+RS_GROUTER_ROUTING_WAITING_TIME < now))
|
||||
{
|
||||
std::cerr << " Msg id: " << std::hex << it->first << std::dec << std::endl;
|
||||
std::cerr << " Origin: " << it->second.origin.toStdString() << std::endl;
|
||||
std::cerr << " Last : " << it->second.tried_friends.front().friend_id.toStdString() << std::endl;
|
||||
std::cerr << " Time : " << it->second.tried_friends.front().time_stamp << std::endl;
|
||||
std::cerr << " Flags : " << it->second.status_flags << std::endl;
|
||||
std::cerr << " Dist : " << it->second.data_item->randomized_distance<< std::endl;
|
||||
std::cerr << " Probabilities: " << std::endl;
|
||||
|
||||
std::map<RsPeerId,float> probas ; // friends probabilities for online friend list.
|
||||
|
|
@ -326,7 +327,7 @@ void p3GRouter::routePendingObjects()
|
|||
|
||||
// Compute the branching factor.
|
||||
|
||||
int N = computeBranchingFactor(probas,it->second.randomized_distance) ;
|
||||
int N = computeBranchingFactor(probas,it->second.data_item->randomized_distance) ;
|
||||
|
||||
// Now use this to select N random peers according to the given probabilities
|
||||
|
||||
|
|
@ -358,6 +359,8 @@ void p3GRouter::routePendingObjects()
|
|||
|
||||
// send
|
||||
new_item->PeerId(*its) ;
|
||||
new_item->randomized_distance += computeRandomDistanceIncrement(*its,new_item->destination_key) ;
|
||||
|
||||
sendItem(new_item) ;
|
||||
}
|
||||
|
||||
|
|
@ -384,6 +387,25 @@ void p3GRouter::routePendingObjects()
|
|||
}
|
||||
}
|
||||
|
||||
uint32_t p3GRouter::computeRandomDistanceIncrement(const RsPeerId& pid,const GRouterKeyId& destination_key)
|
||||
{
|
||||
// This computes a consistent random bias between 0 and 255, which only depends on the
|
||||
// destination key and the friend the item is going to be routed through.
|
||||
// Makes it much harder for attakcers to figure out what is going on with
|
||||
// distances in the network, and makes statistics about multiple sending
|
||||
// attempts impossible.
|
||||
//
|
||||
static uint64_t random_salt = RSRandom::random_u64() ;
|
||||
static const int total_size = RsPeerId::SIZE_IN_BYTES + GRouterKeyId::SIZE_IN_BYTES + sizeof(random_salt) ;
|
||||
|
||||
unsigned char tmpmem[total_size] ;
|
||||
*(uint64_t*)&tmpmem[0] = random_salt ;
|
||||
memcpy(&tmpmem[sizeof(random_salt)],pid.toByteArray(),RsPeerId::SIZE_IN_BYTES) ;
|
||||
memcpy(&tmpmem[sizeof(random_salt) + RsPeerId::SIZE_IN_BYTES],destination_key.toByteArray(),GRouterKeyId::SIZE_IN_BYTES) ;
|
||||
|
||||
return RsDirUtil::sha1sum(tmpmem,total_size).toByteArray()[5] ;
|
||||
}
|
||||
|
||||
uint32_t p3GRouter::computeBranchingFactor(const std::map<RsPeerId,float>& probas,uint32_t dist)
|
||||
{
|
||||
// This should be made a bit more adaptive ;-)
|
||||
|
|
@ -474,10 +496,15 @@ bool p3GRouter::registerKey(const GRouterKeyId& key,const GRouterServiceId& clie
|
|||
{
|
||||
RsStackMutex mtx(grMtx) ;
|
||||
|
||||
if(_registered_services.find(client_id) == _registered_services.end())
|
||||
{
|
||||
std::cerr << __PRETTY_FUNCTION__ << ": unable to register key " << key << " for client id " << client_id << ": client id is not known." << std::endl;
|
||||
return false ;
|
||||
}
|
||||
|
||||
GRouterPublishedKeyInfo info ;
|
||||
info.service_id = client_id ;
|
||||
info.description_string = description.substr(0,20);
|
||||
info.validity_time = 0 ; // not used yet.
|
||||
info.last_published_time = 0 ; // means never published, se it will be re-published soon.
|
||||
|
||||
_owned_key_ids[key] = info ;
|
||||
|
|
@ -615,9 +642,11 @@ void p3GRouter::handleRecvACKItem(RsGRouterACKItem *item)
|
|||
_routing_matrix.addRoutingClue(it->second.data_item->destination_key,item->PeerId(),weight) ;
|
||||
}
|
||||
|
||||
std::cerr << " forwarding ACK to origin: " << it->second.origin.toStdString() << std::endl;
|
||||
|
||||
sendACK(it->second.origin,item->mid,item->state) ;
|
||||
if(it->second.origin != mLinkMgr->getOwnId())
|
||||
{
|
||||
std::cerr << " forwarding ACK to origin: " << it->second.origin.toStdString() << std::endl;
|
||||
sendACK(it->second.origin,item->mid,item->state) ;
|
||||
}
|
||||
break ;
|
||||
|
||||
case RS_GROUTER_ACK_STATE_GIVEN_UP: // route is bad. We forward back and update the routing matrix.
|
||||
|
|
@ -696,31 +725,25 @@ void p3GRouter::handleRecvDataItem(RsGRouterGenericDataItem *item)
|
|||
// Is the item for us? If so, find the client service and send the item back.
|
||||
//
|
||||
if(it != _owned_key_ids.end())
|
||||
if(time(NULL) < it->second.validity_time)
|
||||
{
|
||||
if(itr->second.status_flags == RS_GROUTER_ROUTING_STATE_ARVD)
|
||||
sendACK(item->PeerId(), item->routing_id, RS_GROUTER_ACK_STATE_RECEIVED_INDIRECTLY) ;
|
||||
else
|
||||
{
|
||||
sendACK(item->PeerId(), item->routing_id, RS_GROUTER_ACK_STATE_RECEIVED) ;
|
||||
itr->second.status_flags = RS_GROUTER_ROUTING_STATE_ARVD ;
|
||||
|
||||
std::map<GRouterServiceId,GRouterClientService*>::const_iterator its = _registered_services.find(it->second.service_id) ;
|
||||
|
||||
if(its != _registered_services.end())
|
||||
{
|
||||
std::cerr << " Key is owned by us. Notifying service for this item." << std::endl;
|
||||
its->second->receiveGRouterData(it->first,item_copy) ;
|
||||
}
|
||||
else
|
||||
std::cerr << " (EE) weird situation. No service registered for a key that we own. Key id = " << item->destination_key.toStdString() << ", service id = " << it->second.service_id << std::endl;
|
||||
}
|
||||
}
|
||||
{
|
||||
if(itr->second.status_flags == RS_GROUTER_ROUTING_STATE_ARVD)
|
||||
sendACK(item->PeerId(), item->routing_id, RS_GROUTER_ACK_STATE_RECEIVED_INDIRECTLY) ;
|
||||
else
|
||||
{
|
||||
std::cerr << " key is outdated. The item will be dropped." << std::endl;
|
||||
return ;
|
||||
sendACK(item->PeerId(), item->routing_id, RS_GROUTER_ACK_STATE_RECEIVED) ;
|
||||
itr->second.status_flags = RS_GROUTER_ROUTING_STATE_ARVD ;
|
||||
|
||||
std::map<GRouterServiceId,GRouterClientService*>::const_iterator its = _registered_services.find(it->second.service_id) ;
|
||||
|
||||
if(its != _registered_services.end())
|
||||
{
|
||||
std::cerr << " Key is owned by us. Notifying service for this item." << std::endl;
|
||||
its->second->receiveGRouterData(it->first,item_copy) ;
|
||||
}
|
||||
else
|
||||
std::cerr << " (EE) weird situation. No service registered for a key that we own. Key id = " << item->destination_key.toStdString() << ", service id = " << it->second.service_id << std::endl;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
std::cerr << " item is not for us. Storing in pending mode." << std::endl;
|
||||
|
|
@ -747,7 +770,7 @@ void p3GRouter::sendData(const GRouterKeyId& destination, RsGRouterGenericDataIt
|
|||
info.data_item = item ;
|
||||
info.status_flags = RS_GROUTER_ROUTING_STATE_PEND ;
|
||||
info.origin = RsPeerId(mLinkMgr->getOwnId()) ;
|
||||
info.received_time = time(NULL) ;
|
||||
info.data_item->randomized_distance = 0 ;
|
||||
|
||||
// Make sure we have a unique id (at least locally).
|
||||
//
|
||||
|
|
@ -762,6 +785,7 @@ void p3GRouter::sendData(const GRouterKeyId& destination, RsGRouterGenericDataIt
|
|||
std::cerr << " data_item.byte = " << info.data_item->data_bytes << std::endl;
|
||||
std::cerr << " destination = " << info.data_item->destination_key << std::endl;
|
||||
std::cerr << " status = " << info.status_flags << std::endl;
|
||||
std::cerr << " distance = " << info.data_item->randomized_distance << std::endl;
|
||||
std::cerr << " origin = " << info.origin.toStdString() << std::endl;
|
||||
std::cerr << " Recv time = " << info.received_time << std::endl;
|
||||
|
||||
|
|
@ -878,7 +902,8 @@ void p3GRouter::debugDump()
|
|||
|
||||
for(std::map<GRouterMsgPropagationId, GRouterRoutingInfo>::iterator it(_pending_messages.begin());it!=_pending_messages.end();++it)
|
||||
std::cerr << " Msg id: " << std::hex << it->first << std::dec
|
||||
<< " Origin: " << it->second.origin.toStdString()
|
||||
<< " Local Origin: " << it->second.origin.toStdString()
|
||||
<< " Destination: " << it->second.data_item->destination_key
|
||||
<< " Time : " << now - it->second.tried_friends.front().time_stamp << " secs ago."
|
||||
<< " Status: " << statusString[it->second.status_flags] << std::endl;
|
||||
|
||||
|
|
|
|||
|
|
@ -133,8 +133,11 @@ class p3GRouter: public RsGRouter, public p3Service, public p3Config
|
|||
void debugDump() ;
|
||||
void locked_forwardKey(const RsGRouterPublishKeyItem&) ;
|
||||
|
||||
// utility functions
|
||||
//
|
||||
static uint32_t computeBranchingFactor(const std::map<RsPeerId,float>& probas,uint32_t dist) ;
|
||||
static std::set<RsPeerId> computeRoutingFriends(const std::map<RsPeerId,float>& probas,uint32_t N) ;
|
||||
static uint32_t computeRandomDistanceIncrement(const RsPeerId& pid,const GRouterKeyId& destination_id) ;
|
||||
|
||||
//===================================================//
|
||||
// p3Config methods //
|
||||
|
|
|
|||
|
|
@ -312,7 +312,7 @@ bool GxsSecurity::decrypt(void *& out, int & outlen, const void *in, int inlen,
|
|||
#ifdef DISTRIB_DEBUG
|
||||
std::cerr << "GxsSecurity::decrypt() " << std::endl;
|
||||
#endif
|
||||
RSA *rsa_publish = RSAPublicKey_dup(extractPrivateKey(key)) ;
|
||||
RSA *rsa_publish = RSAPrivateKey_dup(extractPrivateKey(key)) ;
|
||||
EVP_PKEY *privateKey = NULL;
|
||||
|
||||
//RSA* rsa_publish = EVP_PKEY_get1_RSA(privateKey);
|
||||
|
|
|
|||
|
|
@ -1855,6 +1855,8 @@ bool p3MsgService::decryptMessage(const std::string& mId)
|
|||
if(!GxsSecurity::decrypt(decrypted_data,decrypted_size,(void*)encrypted_data,encrypted_size,encryption_key))
|
||||
throw std::runtime_error("Decryption failed!") ;
|
||||
|
||||
std::cerr << " First bytes of decrypted data: " << RsUtil::BinToHex((const char *)decrypted_data,std::min(decrypted_size,50)) << "..."<< std::endl;
|
||||
|
||||
uint8_t *decr_data = (uint8_t*)decrypted_data ;
|
||||
#ifdef DEBUG_DISTANT_MSG
|
||||
std::cerr << " Message has succesfully decrypted. Decrypted size = " << decrypted_size << std::endl;
|
||||
|
|
@ -1873,14 +1875,15 @@ bool p3MsgService::decryptMessage(const std::string& mId)
|
|||
#ifdef DEBUG_DISTANT_MSG
|
||||
std::cerr << " Reading identity section " << std::endl;
|
||||
#endif
|
||||
uint8_t ptag = decr_data[offset] ;
|
||||
uint8_t ptag = decr_data[offset++] ;
|
||||
|
||||
if(ptag != DISTANT_MSG_TAG_IDENTITY)
|
||||
throw std::runtime_error("Bad ptag in encrypted msg packet "+printNumber(ptag,true)+" => packet is dropped.") ;
|
||||
|
||||
unsigned char *tmp_data = &decr_data[offset] ;
|
||||
unsigned char *old_data = tmp_data ;
|
||||
uint32_t identity_size = PGPKeyParser::read_125Size(tmp_data) ;
|
||||
offset += tmp_data - decr_data ;
|
||||
offset += tmp_data - old_data ;
|
||||
|
||||
if(identity_size != RsGxsId::SIZE_IN_BYTES)
|
||||
throw std::runtime_error("Bad size in Identity section " + printNumber(identity_size,false) + " => packet is dropped.") ;
|
||||
|
|
@ -1893,19 +1896,21 @@ bool p3MsgService::decryptMessage(const std::string& mId)
|
|||
#endif
|
||||
// 2 - deserialize the item
|
||||
|
||||
ptag = decr_data[offset] ;
|
||||
ptag = decr_data[offset++] ;
|
||||
|
||||
if(ptag != DISTANT_MSG_TAG_CLEAR_MSG)
|
||||
throw std::runtime_error("Bad ptag in encrypted msg packet " + printNumber(ptag,true) + " => packet is dropped.") ;
|
||||
|
||||
tmp_data = &decr_data[offset] ;
|
||||
old_data = tmp_data ;
|
||||
uint32_t item_size = PGPKeyParser::read_125Size(tmp_data) ;
|
||||
offset += tmp_data - decr_data ;
|
||||
offset += tmp_data - old_data ;
|
||||
|
||||
#ifdef DEBUG_DISTANT_MSG
|
||||
std::cerr << " Deserializing..." << std::endl;
|
||||
#endif
|
||||
RsMsgItem *item = dynamic_cast<RsMsgItem*>(_serialiser->deserialise(&decr_data[offset],&item_size)) ;
|
||||
offset += item_size ;
|
||||
|
||||
if(item == NULL)
|
||||
throw std::runtime_error("Decrypted message could not be deserialized.") ;
|
||||
|
|
@ -1923,9 +1928,10 @@ bool p3MsgService::decryptMessage(const std::string& mId)
|
|||
if(ptag != DISTANT_MSG_TAG_SIGNATURE)
|
||||
throw std::runtime_error("Bad ptag in signature packet " + printNumber(ptag,true) + " => packet is dropped.") ;
|
||||
|
||||
unsigned char *tmp_data = &decr_data[offset] ;
|
||||
tmp_data = &decr_data[offset] ;
|
||||
old_data = tmp_data ;
|
||||
uint32_t signature_size = PGPKeyParser::read_125Size(tmp_data) ;
|
||||
offset += tmp_data - decr_data ;
|
||||
offset += tmp_data - old_data ;
|
||||
|
||||
RsTlvKeySignature signature ;
|
||||
signature.keyId = senders_id.toStdString() ;
|
||||
|
|
@ -2024,7 +2030,7 @@ bool p3MsgService::decryptMessage(const std::string& mId)
|
|||
void p3MsgService::connectToGlobalRouter(p3GRouter *gr)
|
||||
{
|
||||
mGRouter = gr ;
|
||||
gr->registerClientService(RS_SERVICE_TYPE_MSG,this) ;
|
||||
gr->registerClientService(GROUTER_CLIENT_ID_MESSAGES,this) ;
|
||||
}
|
||||
|
||||
void p3MsgService::enableDistantMessaging(bool b)
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue