Git-Mirrors/RetroShare
1
0
Fork 0
mirror of https://github.com/RetroShare/RetroShare.git synced 2025-02-25 01:10:19 -05:00
Code Issues Actions Packages Projects Releases Wiki Activity

merged remaining of v0.6-IdCleaning branch (7180->7213) to incorporate global router stuff in trunk

Browse Source 
git-svn-id: http://svn.code.sf.net/p/retroshare/code/trunk@7214 b45a01b8-16f6-495d-af2f-9b41ad6348cc
This commit is contained in:
csoler 2014-03-29 14:18:05 +00:00
parent 0e6302ac6a
commit 1042744685
53 changed files with 2387 additions and 1904 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
libretroshare/src/dbase/cachestrapper.cc
View File

@ -1006,7 +1006,8 @@ bool CacheStrapper::loadList(std::list<RsItem *>& load)
std::cerr << std::endl;
#endif
bool fileExists = RsDirUtil::checkFile(filename);
uint64_t tmp_size ;
bool fileExists = RsDirUtil::checkFile(filename,tmp_size);
if (fileExists)
{
#ifdef CS_DEBUG

111
libretroshare/src/dbase/fimonitor.cc
View File

@ -29,6 +29,7 @@
#include "rsserver/p3face.h"
#include "dbase/fimonitor.h"
#include "util/rsdir.h"
#include "pqi/authssl.h"
#include "serialiser/rsserviceids.h"
#include "retroshare/rsiface.h"
#include "pqi/p3notify.h"
@ -47,16 +48,17 @@
#include <unistd.h>
#include <stdio.h>
#include <fstream>
#include <sstream>
#include <time.h>
//***********
//#define FIM_DEBUG 1
// ***********
// #define FIM_DEBUG 1
// ***********/
FileIndexMonitor::FileIndexMonitor(CacheStrapper *cs, std::string cachedir, const RsPeerId& pid,const std::string& config_dir)
:CacheSource(RS_SERVICE_TYPE_FILE_INDEX, false, cs, cachedir), fiMutex("FileIndexMonitor"), fi(pid),
pendingDirs(false), pendingForceCacheWrite(false),
mForceCheck(false), mInCheck(false), hashCache(config_dir+"/" + "file_cache.lst"),useHashCache(true)
mForceCheck(false), mInCheck(false), hashCache(config_dir+"/" + "file_cache"),useHashCache(true)
{
updatePeriod = 15 * 60; // 15 minutes
@ -114,7 +116,63 @@ HashCache::HashCache(const std::string& path)
_max_cache_duration_days = 10 ; // 10 days is the default value.
_files.clear() ;
_changed = false ;
std::ifstream f(_path.c_str()) ;
// check for unencrypted
std::istream *f = NULL ;
uint64_t file_size ;
if(RsDirUtil::checkFile( _path+".bin",file_size,false ) )
{
std::cerr << "Encrypted hash cache file present. Reading it." << std::endl;
// read the binary stream into memory.
//
void *buffer = malloc(file_size) ;
if(buffer == NULL)
{
std::cerr << "Cannot allocate memory for reading encrypted file cache, bytes=" << file_size << std::endl;
return ;
}
FILE *F = fopen( (_path+".bin").c_str(),"rb") ;
if(fread(buffer,1,file_size,F) != file_size)
{
std::cerr << "Cannot read from file " + _path+".bin" << ": something's wrong." << std::endl;
free(buffer) ;
return ;
}
fclose(F) ;
void *decrypted_data ;
int decrypted_data_size ;
if(!AuthSSL::getAuthSSL()->decrypt(decrypted_data, decrypted_data_size, buffer, file_size))
{
std::cerr << "Cannot decrypt encrypted file cache. Something's wrong." << std::endl;
free(buffer) ;
return ;
}
free(buffer) ;
std::string s((char *)decrypted_data,decrypted_data_size) ;
f = new std::istringstream(s) ;
free(decrypted_data) ;
}
else
{
std::cerr << "Encrypted file cache not present. Trying unencrypted..." << std::endl;
f = new std::ifstream( (_path+".lst").c_str()) ;
if(!f->good())
{
std::cerr << "Unencrypted file cache not present either." << std::endl;
return ;
}
}
std::streamsize max_line_size = 2000 ; // should be enough. Anyway, if we
// miss one entry, we just lose some
@ -127,21 +185,21 @@ HashCache::HashCache(const std::string& path)
int n=0 ;
#endif
while(!f.eof())
while(!f->eof())
{
HashCacheInfo info ;
f.getline(buff,max_line_size,'\n') ;
f->getline(buff,max_line_size,'\n') ;
std::string name(buff) ;
f.getline(buff,max_line_size,'\n') ; //if(sscanf(buff,"%llu",&info.size) != 1) break ;
f->getline(buff,max_line_size,'\n') ; //if(sscanf(buff,"%llu",&info.size) != 1) break ;
info.size = 0 ;
sscanf(buff, RsDirUtil::scanf_string_for_uint(sizeof(info.size)), &info.size);
f.getline(buff,max_line_size,'\n') ; if(sscanf(buff,RsDirUtil::scanf_string_for_uint(sizeof(info.time_stamp)),&info.time_stamp) != 1) { std::cerr << "Could not read one entry! Giving up." << std::endl; break ; }
f.getline(buff,max_line_size,'\n') ; if(sscanf(buff,RsDirUtil::scanf_string_for_uint(sizeof(info.modf_stamp)),&info.modf_stamp) != 1) { std::cerr << "Could not read one entry! Giving up." << std::endl; break ; }
f.getline(buff,max_line_size,'\n') ; info.hash = std::string(buff) ;
f->getline(buff,max_line_size,'\n') ; if(sscanf(buff,RsDirUtil::scanf_string_for_uint(sizeof(info.time_stamp)),&info.time_stamp) != 1) { std::cerr << "Could not read one entry! Giving up." << std::endl; break ; }
f->getline(buff,max_line_size,'\n') ; if(sscanf(buff,RsDirUtil::scanf_string_for_uint(sizeof(info.modf_stamp)),&info.modf_stamp) != 1) { std::cerr << "Could not read one entry! Giving up." << std::endl; break ; }
f->getline(buff,max_line_size,'\n') ; info.hash = std::string(buff) ;
#ifdef FIM_DEBUG
std::cerr << " (" << name << ", " << info.size << ", " << info.time_stamp << ", " << info.modf_stamp << ", " << info.hash << std::endl ;
@ -149,9 +207,9 @@ HashCache::HashCache(const std::string& path)
#endif
_files[name] = info ;
}
f.close() ;
delete[] buff ;
delete f ;
#ifdef FIM_DEBUG
std::cerr << n << " entries loaded." << std::endl ;
#endif
@ -164,7 +222,7 @@ void HashCache::save()
#ifdef FIM_DEBUG
std::cerr << "Saving Hash Cache to file " << _path << "..." << std::endl ;
#endif
std::ofstream f( (_path+".tmp").c_str() ) ;
std::ostringstream f ;
for(std::map<std::string,HashCacheInfo>::const_iterator it(_files.begin());it!=_files.end();++it)
{
@ -174,9 +232,34 @@ void HashCache::save()
f << it->second.modf_stamp << std::endl;
f << it->second.hash << std::endl;
}
f.close() ;
RsDirUtil::renameFile(_path+".tmp",_path) ;
void *encryptedData = NULL ;
int encDataLen = 0 ;
if(!AuthSSL::getAuthSSL()->encrypt(encryptedData, encDataLen, f.str().c_str(), f.str().length(), AuthSSL::getAuthSSL()->OwnId()))
{
std::cerr << "Cannot encrypt hash cache. Something's wrong." << std::endl;
return;
}
FILE *F = fopen( (_path+".bin.tmp").c_str(),"wb" ) ;
if(F == NULL)
{
std::cerr << "Cannot open encrypted file cache for writing: " << _path+".bin.tmp" << std::endl;
free(encryptedData) ;
return ;
}
if(fwrite(encryptedData,1,encDataLen,F) != encDataLen)
{
std::cerr << "Could not write entire encrypted hash cache file. Out of disc space??" << std::endl;
free(encryptedData) ;
return ;
}
fclose(F) ;
free(encryptedData) ;
RsDirUtil::renameFile(_path+".bin.tmp",_path+".bin") ;
#ifdef FIM_DEBUG
std::cerr << "done." << std::endl ;
#endif

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!
//
virtual void receiveGRouterData(RsGRouterGenericDataItem * /*item*/,const GRouterKeyId& destination_key)
virtual void receiveGRouterData(const GRouterKeyId& destination_key, const RsGRouterGenericDataItem * /*item*/)
{
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;

106
libretroshare/src/grouter/grouteritems.cc
View File

@ -35,11 +35,11 @@ uint32_t RsGRouterPublishKeyItem::serial_size() const
uint32_t s = 8 ; // header
s += POW_PAYLOAD_SIZE ; // proof of work bytes
s += 4 ; // diffusion_id
s += 20 ; // sha1 for published_key
s += published_key.serial_size() ; // sha1 for published_key
s += 4 ; // service id
s += 4 ; // randomized distance
s += GetTlvStringSize(description_string) ; // description
s += PGP_KEY_FINGERPRINT_SIZE ; // fingerprint
s += fingerprint.serial_size() ; // fingerprint
return s ;
}
@ -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 += 20 ; // sha1 for published_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)
@ -434,7 +432,7 @@ uint32_t RsGRouterMatrixCluesItem::serial_size() const
{
uint32_t s = 8 ; // header
s += 20 ; // Key size
s += destination_key.serial_size() ; // Key size
s += 4 ; // list<RoutingMatrixHitEntry>::size()
s += (4+4+8) * clues.size() ;
@ -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.SIZE_IN_BYTES ; // 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.SIZE_IN_BYTES; // 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)
{

25
libretroshare/src/grouter/grouteritems.h
View File

@ -26,20 +26,19 @@
#pragma once
#include "serialiser/rsserial.h"
#include "serialiser/rsserviceids.h"
#include "retroshare/rstypes.h"
#include "rsgrouter.h"
#include "retroshare/rsgrouter.h"
#include "p3grouter.h"
// To be put in serialiser/rsserviceids.h
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 ;
@ -50,6 +49,7 @@ const uint32_t RS_GROUTER_ACK_STATE_RECEIVED_INDIRECTLY = 0x0002 ; // data was
const uint32_t RS_GROUTER_ACK_STATE_GIVEN_UP = 0x0003 ; // data was given up. No route.
const uint32_t RS_GROUTER_ACK_STATE_NO_ROUTE = 0x0004 ; // data was given up. No route.
const uint32_t RS_GROUTER_ACK_STATE_UNKNOWN = 0x0005 ; // unknown destination key
const uint32_t RS_GROUTER_ACK_STATE_TOO_FAR = 0x0006 ; // dropped because of distance
/***********************************************************************************/
/* Basic GRouter Item Class */
@ -151,6 +151,7 @@ class RsGRouterGenericDataItem: public RsGRouterItem, public RsGRouterNonCopyabl
//
GRouterMsgPropagationId routing_id ;
GRouterKeyId destination_key ;
uint32_t randomized_distance ;
uint32_t data_size ;
uint8_t *data_bytes;
@ -251,12 +252,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 ;
};

38
libretroshare/src/grouter/groutermatrix.cc
View File

@ -32,8 +32,7 @@ GRouterMatrix::GRouterMatrix()
_proba_need_updating = true ;
}
bool GRouterMatrix::addRoutingClue( const GRouterKeyId& key_id,const GRouterServiceId& sid,float distance,
const std::string& desc_string,const RsPeerId& source_friend)
bool GRouterMatrix::addRoutingClue(const GRouterKeyId& key_id,const RsPeerId& source_friend,float weight)
{
// 1 - get the friend index.
//
@ -44,7 +43,7 @@ bool GRouterMatrix::addRoutingClue( const GRouterKeyId& key_id,const GRouterServ
time_t now = time(NULL) ;
RoutingMatrixHitEntry rc ;
rc.weight = 1.0f / (1.0f + distance) ;
rc.weight = weight ;
rc.time_stamp = now ;
rc.friend_id = fid ;
@ -103,6 +102,14 @@ uint32_t GRouterMatrix::getFriendId(const RsPeerId& source_friend)
return it->second ;
}
void GRouterMatrix::getListOfKnownKeys(std::vector<GRouterKeyId>& key_ids) const
{
key_ids.clear() ;
for(std::map<GRouterKeyId,std::vector<float> >::const_iterator it(_time_combined_hits.begin());it!=_time_combined_hits.end();++it)
key_ids.push_back(it->first) ;
}
void GRouterMatrix::debugDump() const
{
std::cerr << " Proba needs up: " << _proba_need_updating << std::endl;
@ -130,7 +137,7 @@ void GRouterMatrix::debugDump() const
}
}
bool GRouterMatrix::computeRoutingProbabilities(const GRouterKeyId& key_id, const std::list<RsPeerId>& friends, std::map<RsPeerId,float>& probas) const
bool GRouterMatrix::computeRoutingProbabilities(const GRouterKeyId& key_id, const std::vector<RsPeerId>& friends, std::vector<float>& probas) const
{
// Routing probabilities are computed according to routing clues
//
@ -144,34 +151,41 @@ bool GRouterMatrix::computeRoutingProbabilities(const GRouterKeyId& key_id, cons
if(_proba_need_updating)
std::cerr << "GRouterMatrix::computeRoutingProbabilities(): matrix is not up to date. Not a real problem, but still..." << std::endl;
probas.clear() ;
probas.resize(friends.size(),0.0f) ;
float total = 0.0f ;
std::map<GRouterKeyId,std::vector<float> >::const_iterator it2 = _time_combined_hits.find(key_id) ;
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() ;
probas.clear() ;
probas.resize(friends.size(),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) ;
for(std::list<RsPeerId>::const_iterator it(friends.begin());it!=friends.end();++it)
for(uint32_t i=0;i<friends.size();++i)
{
uint32_t findex = getFriendId_const(*it) ;
uint32_t findex = getFriendId_const(friends[i]) ;
if(findex >= w.size())
probas[*it] = 0.0f ;
probas[i] = 0.0f ;
else
{
probas[*it] = w[findex] ;
probas[i] = w[findex] ;
total += w[findex] ;
}
}
if(total > 0.0f)
for(std::map<RsPeerId,float>::iterator it(probas.begin());it!=probas.end();++it)
it->second /= total ;
for(int i=0;i<friends.size();++i)
probas[i] /= total ;
return true ;
}

13
libretroshare/src/grouter/groutermatrix.h
View File

@ -28,8 +28,8 @@
#include <list>
#include "pgp/rscertificate.h"
#include "retroshare/rsgrouter.h"
#include "groutertypes.h"
#include "rsgrouter.h"
class RsItem ;
@ -51,7 +51,7 @@ class GRouterMatrix
// the computation accounts for the time at which the info was received and the
// weight of each routing hit record.
//
bool computeRoutingProbabilities(const GRouterKeyId& id, const std::list<RsPeerId>& friends, std::map<RsPeerId,float>& probas) const ;
bool computeRoutingProbabilities(const GRouterKeyId& id, const std::vector<RsPeerId>& friends, std::vector<float>& probas) const ;
// Update routing probabilities for each key, accounting for all received events, but without
// activity information
@ -60,14 +60,15 @@ class GRouterMatrix
// Record one routing clue. The events can possibly be merged in time buckets.
//
bool addRoutingClue(const GRouterKeyId& id,const GRouterServiceId& sid,float distance,const std::string& desc_string,const RsPeerId& source_friend) ;
bool addRoutingClue(const GRouterKeyId& id,const RsPeerId& source_friend,float weight) ;
bool saveList(std::list<RsItem*>& items) ;
bool loadList(std::list<RsItem*>& items) ;
// Dump info in terminal.
//
void debugDump() const ;
bool saveList(std::list<RsItem*>& items) ;
bool loadList(std::list<RsItem*>& items) ;
void getListOfKnownKeys(std::vector<GRouterKeyId>& key_ids) const ;
private:
// returns the friend id, possibly creating a new id.

31
libretroshare/src/grouter/groutertypes.h
View File

@ -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,36 +50,35 @@ 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 = 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.
static const uint32_t RS_GROUTER_ROUTING_STATE_SENT = 0x0002 ; // item is sent. Waiting for answer
static const uint32_t RS_GROUTER_ROUTING_STATE_ARVD = 0x0003 ; // item is at destination. The cache only holds it to avoid duplication.
class GRouterPublishedKeyInfo
class FriendTrialRecord
{
public:
GRouterServiceId service_id ;
std::string description_string ;
PGPFingerprintType fpr ;
time_t last_published_time ;
time_t validity_time ;
};
struct FriendTrialRecord
{
RsPeerId friend_id ; // id of the friend
time_t time_stamp ; // time of the last tried
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
std::list<FriendTrialRecord> tried_friends ; // list of friends to which the item was sent ordered with time.
RsGRouterGenericDataItem *data_item ;
};

373
libretroshare/src/grouter/p3grouter.cc
View File

@ -68,6 +68,17 @@
// * keep the local routing info in a cache that is saved (Which peer issued the msg)
// - which probability was used to chose this friend (will be useful
// to compute the routing contribution if the msg is ACK-ed)
//
// Two probabilities are computed:
// - routing probabilities among connected friends
// * this is computed by the routing matrix
// - branching factor N
// * depends on the depth of the items
// * depends on the distribution of probabilities (min and max)
//
// Once computed,
// - the item is forwarded randomly to N peers drawn from the list of connected peers with the given probabilities.
// - the depth of the item is incremented randomly
//
// - downward: look into routing cache. If info not present, drop the item.
// Forward item into stored direction.
@ -137,6 +148,7 @@
// - packet service ID (Can be messenging, channels, etc).
// - packet data (void* + size_t)
// - flags (such as ACK or response required, and packet direction)
// - routed directions and probabilities
// * ACK packet.
// - packet unique ID (the id of the corresponding data)
// - flags (reason for ACK. Could be data delivered, or error, too far, etc)
@ -179,8 +191,10 @@
#include "groutertypes.h"
#include "grouterclientservice.h"
const std::string p3GRouter::SERVICE_INFO_APP_NAME = "Global Router" ;
p3GRouter::p3GRouter(p3LinkMgr *lm)
: p3Service(RS_SERVICE_TYPE_GROUTER), p3Config(CONFIG_TYPE_GROUTER), mLinkMgr(lm), grMtx("GRouter")
: p3Service(), p3Config(), mLinkMgr(lm), grMtx("GRouter")
{
addSerialType(new RsGRouterSerialiser()) ;
@ -215,7 +229,8 @@ int p3GRouter::tick()
{
last_publish_campaign_time = now ;
publishKeys() ;
//publishKeys() ; // we don't publish keys anymore.
//
_routing_matrix.updateRoutingProbabilities() ;
}
@ -284,135 +299,77 @@ void p3GRouter::routePendingObjects()
{
RsStackMutex mtx(grMtx) ;
// Go through list of published keys
// broadcast a publishKeyItem for each of them.
//
// The routing rules are the following:
//
// Go through list of cached routing objects. For each object:
// if(Last try is old)
// put the object in pending list
//
// (This loop is costly (could handle lots of items), so it should be done less often.)
//
// Add peer to the list of tried routes with time stamp
// Keep the list of tried friends
//
// Go through list of pendign objects. For each object:
// Select one route direction
// - according to current probabilities from the routing matrix
// - according to list of previous attempts
//
// if(route found)
// forward item, update state and time stamp
// else
// if(I am not the sender)
// send back ACK(given up) // if I am the sender, I will keep trying.
//
// Item has received an ACK
//
// ACK: given up => change route
// ACK: received => Remove item from routed items
//
// The list in _pending_messages is necessarily short and most of the time empty. Once
// treated, objects are stored in _routing_cache, where they wait for an answer.
time_t now = time(NULL) ;
std::cerr << "p3GRouter::routeObjects() triage phase:" << std::endl;
std::cerr << "Cached Items : " << _pending_messages.size() << std::endl;
std::list<RsPeerId> lst ;
mLinkMgr->getOnlineList(lst) ;
mLinkMgr->getOnlineList(lst) ;
RsPeerId own_id( mLinkMgr->getOwnId() );
std::vector<RsPeerId> pids ;
for(std::list<RsPeerId>::const_iterator it(lst.begin());it!=lst.end();++it)
pids.push_back(*it) ;
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.
RsPeerId routed_friend ; // friend chosen for the next hop
float best_proba = 0.0f; // temp variable used to select the best proba
bool should_remove = false ; // should we remove this from the map?
std::vector<float> probas ; // friends probabilities for online friend list.
RsPeerId routed_friend ; // friend chosen for the next hop
bool should_remove = false ; // should we remove this from the map?
// retrieve probabilities for this key.
// Retrieve probabilities for this key. This call always succeeds. If no route is known, all probabilities become equal.
//
if(! _routing_matrix.computeRoutingProbabilities(it->second.data_item->destination_key, lst, probas))
_routing_matrix.computeRoutingProbabilities(it->second.data_item->destination_key, pids, probas) ;
// Compute the branching factor.
int N = computeBranchingFactor(pids,probas,it->second.data_item->randomized_distance) ;
// Now use this to select N random peers according to the given probabilities
std::set<uint32_t> routing_friend_indices = computeRoutingFriends(pids,probas,N) ;
std::cerr << " Routing statistics: " << std::endl;
// Actually send the item.
for(std::set<uint32_t>::const_iterator its(routing_friend_indices.begin());its!=routing_friend_indices.end();++its)
{
// key does not exist in routing matrix => send back an ACK(unknown)
std::cerr << " Friend : " << (*its) << std::endl;
std::cerr << " [Cannot compute. Unknown destination key!!] " << std::endl;
if(it->second.origin != own_id)
{
std::cerr << " removing item and notifying the sender (" << it->second.origin.toStdString() << ")" << std::endl;
sendACK(it->second.origin,it->first,RS_GROUTER_ACK_STATE_UNKNOWN) ;
// remove item from cache
//
should_remove = true ;
}
std::cerr << " item is ours. Keeping it until a route is known." << std::endl;
// else, select a routing friend at random, or just wait? Wait is probably better.
}
bool friend_found = false ;
for(std::map<RsPeerId,float>::const_iterator it2(probas.begin());it2!=probas.end();++it2)
{
std::cerr << " " << it2->first.toStdString() << " : " << it2->second << std::endl;
// select the peer with highest probability that hasn't yet been tried.
if(it2->second > best_proba && !(it2->first == it->second.tried_friends.front().friend_id))
{
routed_friend = it2->first ;
best_proba = it2->second ;
friend_found = true ;
}
}
std::cerr << " Best route: " << routed_friend.toStdString() << ", with probability " << best_proba << std::endl;
// now, send the item.
if(friend_found)
{
// make a deep copy of the item
RsGRouterGenericDataItem *new_item = it->second.data_item->duplicate() ;
// update cache entry
FriendTrialRecord ftr ;
ftr.time_stamp = now ;
ftr.friend_id = routed_friend ;
ftr.friend_id = pids[*its];
ftr.probability = probas[*its] ;
ftr.nb_friends = probas.size() ;
it->second.tried_friends.push_front(ftr) ;
it->second.status_flags = RS_GROUTER_ROUTING_STATE_SENT ;
std::cerr << " Sending..." << std::endl;
std::cerr << " Routing probability: " << ftr.probability << std::endl;
std::cerr << " Sending..." << std::endl;
// send
new_item->PeerId(routed_friend) ;
new_item->PeerId(pids[*its]) ;
new_item->randomized_distance += computeRandomDistanceIncrement(pids[*its],new_item->destination_key) ;
sendItem(new_item) ;
}
else if(it->second.origin != mLinkMgr->getOwnId() || std::find(lst.begin(),lst.end(),it->second.origin) != lst.end())
{
// There's no correct friend to send this item to. We keep it for a while. If it's too old,
// we discard it. For now, the procedure is to send back an ACK.
std::cerr << " Item has no route candidate. It's too old. " << std::endl;
std::cerr << " sending ACK(no route) to peer " << it->second.origin.toStdString() << std::endl;
sendACK(it->second.origin,it->first,RS_GROUTER_ACK_STATE_NO_ROUTE) ;
should_remove = true ;
}
if(should_remove)
{
@ -430,11 +387,56 @@ void p3GRouter::routePendingObjects()
++it ;
}
else
{
std::cerr << "Skipping " << std::hex << it->first << std::dec << ", dest=" << it->second.data_item->destination_key.toStdString() << ", state = " << it->second.status_flags << ", stamp=" << it->second.tried_friends.front().time_stamp << " - " << it->second.tried_friends.front().friend_id.toStdString() << std::endl;
++it ;
}
}
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::vector<RsPeerId>& friends,const std::vector<float>& probas,uint32_t dist)
{
// This should be made a bit more adaptive ;-)
//
return 1 ;
}
std::set<uint32_t> p3GRouter::computeRoutingFriends(const std::vector<RsPeerId>& pids,const std::vector<float>& probas,uint32_t N)
{
// We draw N friends according to the routing probabilitites that are passed as parameter.
//
std::set<uint32_t> res ;
if(probas.empty())
return res ;
res.insert(0) ;
return res ;
}
void p3GRouter::publishKeys()
{
#ifdef SUSPENDED
RsStackMutex mtx(grMtx) ;
// Go through list of published keys
@ -454,14 +456,13 @@ void p3GRouter::publishKeys()
std::cerr << " Key id : " << it->first.toStdString() << std::endl;
std::cerr << " Service id : " << std::hex << info.service_id << std::dec << std::endl;
std::cerr << " Description : " << info.description_string << std::endl;
std::cerr << " Fingerprint : " << info.fpr.toStdString() << std::endl;
RsGRouterPublishKeyItem item ;
item.diffusion_id = RSRandom::random_u32() ;
item.published_key = it->first ;
item.service_id = info.service_id ;
item.randomized_distance = drand48() ;
item.fingerprint = info.fpr;
item.fingerprint.clear() ; // not set
item.description_string = info.description_string ;
item.PeerId(RsPeerId()) ; // no peer id => key is forwarded to all friends.
@ -471,6 +472,7 @@ void p3GRouter::publishKeys()
info.last_published_time = now ;
}
}
#endif
}
void p3GRouter::locked_forwardKey(const RsGRouterPublishKeyItem& item)
@ -497,16 +499,20 @@ void p3GRouter::locked_forwardKey(const RsGRouterPublishKeyItem& item)
else
std::cerr << " Not forwarding to source id " << item.PeerId() << std::endl;
}
bool p3GRouter::registerKey(const GRouterKeyId& key,const PGPFingerprintType& fps,const GRouterServiceId& client_id,const std::string& description)
bool p3GRouter::registerKey(const GRouterKeyId& key,const GRouterServiceId& client_id,const std::string& description)
{
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.fpr = fps ;
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.
//info.last_published_time = 0 ; // means never published, se it will be re-published soon.
_owned_key_ids[key] = info ;
@ -575,7 +581,7 @@ void p3GRouter::handleRecvPublishKeyItem(RsGRouterPublishKeyItem *item)
// update the route matrix
_routing_matrix.addRoutingClue(item->published_key,item->service_id,item->randomized_distance,item->description_string,RsPeerId(item->PeerId())) ;
_routing_matrix.addRoutingClue(item->published_key,RsPeerId(item->PeerId()),1) ;
// forward the key to other peers according to key forwarding cache
@ -602,7 +608,7 @@ void p3GRouter::handleRecvPublishKeyItem(RsGRouterPublishKeyItem *item)
void p3GRouter::handleRecvACKItem(RsGRouterACKItem *item)
{
RsStackMutex mtx(grMtx) ;
std::cerr << "Received ACK item, mid=" << std::hex << item->mid << std::dec << std::endl;
std::cerr << "Received ACK item, mid=" << std::hex << item->mid << std::dec << ", ACK type = "<< item->state << std::endl;
// find the item in the pendign list,
// - if not found, drop.
@ -624,44 +630,81 @@ void p3GRouter::handleRecvACKItem(RsGRouterACKItem *item)
switch(item->state)
{
case RS_GROUTER_ACK_STATE_RECEIVED_INDIRECTLY:
// Do nothing. It was indirectly received: fine. We don't need to notify the origin
// otherwise lots of ACKs will flow to the origin.
break ;
case RS_GROUTER_ACK_STATE_RECEIVED:
// Notify the origin. This is the main route and it was successful.
std::cerr << " forwarding ACK to origin: " << it->second.origin.toStdString() << std::endl;
std::cerr << " updating routing matrix." << std::endl;
sendACK(it->second.origin,item->mid,RS_GROUTER_ACK_STATE_RECEIVED) ;
it->second.status_flags = RS_GROUTER_ROUTING_STATE_ARVD ;
{
#warning UNFINISHED code.
// Now compute the weight for that particular item. See with what probabilities it was chosen.
//
float weight = (item->state == RS_GROUTER_ACK_STATE_RECEIVED)?1.0f : 0.5;
std::cerr << " weight = " << weight << std::endl;
_routing_matrix.addRoutingClue(it->second.data_item->destination_key,item->PeerId(),weight) ;
}
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.
break ;
}
if(it->second.origin == mLinkMgr->getOwnId())
if(it->second.origin == mLinkMgr->getOwnId())
{
// find the client service and notify it.
std::cerr << " We're owner: should notify client id" << std::endl;
}
// Always remove the item.
// Just decrement the list of tried friends
//
delete it->second.data_item ;
_pending_messages.erase(it) ;
for(std::list<FriendTrialRecord>::iterator it2(it->second.tried_friends.begin());it2!=it->second.tried_friends.end();++it2)
if( (*it2).friend_id == item->PeerId())
{
std::cerr << " Removing friend try for peer " << item->PeerId() << ". " << it->second.tried_friends.size() << " tries left." << std::endl;
it->second.tried_friends.erase(it2) ;
break ;
}
if(it->second.tried_friends.empty())
{
delete it->second.data_item ;
_pending_messages.erase(it) ;
std::cerr << " No tries left. Removing item from pending list." << std::endl;
}
}
void p3GRouter::handleRecvDataItem(RsGRouterGenericDataItem *item)
{
RsStackMutex mtx(grMtx) ;
std::cerr << "Received data item for key " << item->destination_key << std::endl;
std::cerr << "Received data item for key " << item->destination_key << ", distance = " << item->randomized_distance << std::endl;
// check the item depth. If too large, send a ACK back.
if(item->randomized_distance > GROUTER_ITEM_MAX_TRAVEL_DISTANCE)
{
std::cerr << " Distance is too large: " << item->randomized_distance << " units. Item is dropped." << std::endl;
sendACK(item->PeerId(),item->routing_id,RS_GROUTER_ACK_STATE_TOO_FAR) ;
return ;
}
// Do we have this item in the cache already?
// - if not, add in the pending items
// - if yet. Ignore, or send ACK for shorter route.
std::map<GRouterKeyId,GRouterPublishedKeyInfo>::const_iterator it = _owned_key_ids.find(item->destination_key) ;
std::map<GRouterMsgPropagationId,GRouterRoutingInfo>::const_iterator itr = _pending_messages.find(item->routing_id) ;
std::map<GRouterMsgPropagationId,GRouterRoutingInfo>::iterator itr = _pending_messages.find(item->routing_id) ;
RsGRouterGenericDataItem *item_copy = NULL;
if(itr != _pending_messages.end())
@ -670,7 +713,7 @@ void p3GRouter::handleRecvDataItem(RsGRouterGenericDataItem *item)
item_copy = itr->second.data_item ;
}
else // item is now known. Store it into pending msgs. We make a copy, since the item will be deleted otherwise.
else // item is not known. Store it into pending msgs. We make a copy, since the item will be deleted otherwise.
{
std::cerr << " Item is new. Storing in cache as pending messages." << std::endl;
@ -679,38 +722,40 @@ void p3GRouter::handleRecvDataItem(RsGRouterGenericDataItem *item)
info.data_item = item->duplicate() ;
item_copy = info.data_item ;
if(it != _owned_key_ids.end())
info.status_flags = RS_GROUTER_ROUTING_STATE_ARVD ;
else
info.status_flags = RS_GROUTER_ROUTING_STATE_PEND ;
info.origin = RsPeerId(item->PeerId()) ;
info.received_time = time(NULL) ;
_pending_messages[item->routing_id] = info ;
itr = _pending_messages.find(item->routing_id) ;
}
// 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
{
// test validity time. If too old, we don't forward.
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(item_copy,it->first) ;
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 << " (WW) key is outdated. Dropping this item." << std::endl;
}
else
std::cerr << " Item is not for us. Leaving in pending msgs to be routed later." << std::endl;
{
std::cerr << " item is not for us. Storing in pending mode." << std::endl;
itr->second.status_flags = RS_GROUTER_ROUTING_STATE_PEND ;
}
_changed = true ;
}
@ -732,17 +777,22 @@ 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).
//
GRouterMsgPropagationId propagation_id ;
do { propagation_id = RSRandom::random_u32(); } while(_pending_messages.find(propagation_id) != _pending_messages.end()) ;
item->destination_key = destination ;
item->routing_id = propagation_id ;
std::cerr << "p3GRouter::sendGRouterData(): pushing the followign item in the msg pending list:" << std::endl;
std::cerr << " data_item.size = " << info.data_item->data_size << std::endl;
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;
@ -821,6 +871,54 @@ bool p3GRouter::saveList(bool& cleanup,std::list<RsItem*>& items)
return true ;
}
bool p3GRouter::getRoutingMatrixInfo(RsGRouter::GRouterRoutingMatrixInfo& info)
{
info.per_friend_probabilities.clear() ;
info.friend_ids.clear() ;
info.published_keys.clear() ;
std::list<RsPeerId> ids ;
mLinkMgr->getOnlineList(ids) ;
RsStackMutex mtx(grMtx) ;
info.published_keys = _owned_key_ids ;
for(std::list<RsPeerId>::const_iterator it(ids.begin());it!=ids.end();++it)
info.friend_ids.push_back(*it) ;
std::vector<GRouterKeyId> known_keys ;
std::vector<float> probas ;
_routing_matrix.getListOfKnownKeys(known_keys) ;
for(uint32_t i=0;i<known_keys.size();++i)
{
_routing_matrix.computeRoutingProbabilities(known_keys[i],info.friend_ids,probas) ;
info.per_friend_probabilities[known_keys[i]] = probas ;
}
return true ;
}
bool p3GRouter::getRoutingCacheInfo(std::vector<GRouterRoutingCacheInfo>& infos)
{
RsStackMutex mtx(grMtx) ;
infos.clear() ;
for(std::map<GRouterMsgPropagationId,GRouterRoutingInfo>::const_iterator it(_pending_messages.begin());it!=_pending_messages.end();++it)
{
infos.push_back(GRouterRoutingCacheInfo()) ;
GRouterRoutingCacheInfo& cinfo(infos.back()) ;
cinfo.mid = it->first ;
cinfo.local_origin = it->second.origin ;
cinfo.destination = it->second.data_item->destination_key ;
cinfo.time_stamp = it->second.received_time ;
cinfo.status = it->second.status_flags ;
cinfo.data_size = it->second.data_item->data_size ;
}
return true ;
}
// Dump everything
//
void p3GRouter::debugDump()
@ -837,7 +935,7 @@ void p3GRouter::debugDump()
std::cerr << " Key id : " << it->first.toStdString() << std::endl;
std::cerr << " Service id : " << std::hex << it->second.service_id << std::dec << std::endl;
std::cerr << " Description : " << it->second.description_string << std::endl;
std::cerr << " Last published: " << now - it->second.last_published_time << " secs ago" << std::endl;
//std::cerr << " Last published: " << now - it->second.last_published_time << " secs ago" << std::endl;
}
std::cerr << " Registered services: " << std::endl;
@ -854,7 +952,18 @@ void p3GRouter::debugDump()
std::cerr << " [Not shown yet] " << std::endl;
std::cerr << " Data items: " << std::endl;
std::cerr << " [Not shown yet] " << std::endl;
static std::string statusString[4] = { "Unkn","Pend","Sent","Ackn" };
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
<< " 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;
// << " Last : " << it->second.tried_friends.front().friend_id.toStdString() << std::endl;
// << " Probabilities: " << std::endl;
std::cerr << " Routing matrix: " << std::endl;

40
libretroshare/src/grouter/p3grouter.h
View File

@ -28,15 +28,16 @@
#include <map>
#include <queue>
#include "rsgrouter.h"
#include "retroshare/rsgrouter.h"
#include "retroshare/rstypes.h"
#include "services/p3service.h"
#include "pqi/p3cfgmgr.h"
#include "retroshare/rstypes.h"
#include "groutertypes.h"
#include "groutermatrix.h"
#include "groutercache.h"
#include "grouteritems.h"
//#include "groutercache.h"
// To be put in pqi/p3cfgmgr.h
//
@ -75,9 +76,7 @@ class p3GRouter: public RsGRouter, public p3Service, public p3Config
// Unregistering a key might not have an instantaneous effect, so the client is responsible for
// discarding traffic that might later come for this key.
//
bool registerKey(const GRouterKeyId& key,const PGPFingerprintType& pgp_fingerprint,
const GRouterServiceId& client_id,const std::string& description_string) ;
bool registerKey(const GRouterKeyId& key, const GRouterServiceId& client_id,const std::string& description_string) ;
bool unregisterKey(const GRouterKeyId& key) ;
//===================================================//
@ -103,7 +102,7 @@ class p3GRouter: public RsGRouter, public p3Service, public p3Config
// - list of clues/time_stamp for each key.
// - real time routing probabilities
//
virtual bool getRoutingMatrixInfo(RoutingMatrixInfo& info) { return false ;}
virtual bool getRoutingMatrixInfo(GRouterRoutingMatrixInfo& info) ;
// debug info from routing cache
// - Cache Items
@ -113,8 +112,21 @@ class p3GRouter: public RsGRouter, public p3Service, public p3Config
// * message type
// - Cache state (memory size, etc)
//
virtual bool getRoutingCacheInfo(RoutingCacheInfo& info) { return false ;}
virtual bool getRoutingCacheInfo(std::vector<GRouterRoutingCacheInfo>& info) ;
//===================================================//
// Derived from p3Service //
//===================================================//
virtual RsServiceInfo getServiceInfo()
{
return RsServiceInfo(RS_SERVICE_TYPE_GROUTER,
SERVICE_INFO_APP_NAME,
SERVICE_INFO_APP_MAJOR_VERSION,
SERVICE_INFO_APP_MINOR_VERSION,
SERVICE_INFO_MIN_MAJOR_VERSION,
SERVICE_INFO_MIN_MINOR_VERSION) ;
}
protected:
//===================================================//
// Routing method handling //
@ -127,6 +139,12 @@ class p3GRouter: public RsGRouter, public p3Service, public p3Config
//
virtual int tick() ;
static const std::string SERVICE_INFO_APP_NAME ;
static const uint16_t SERVICE_INFO_APP_MAJOR_VERSION = 1;
static const uint16_t SERVICE_INFO_APP_MINOR_VERSION = 0;
static const uint16_t SERVICE_INFO_MIN_MAJOR_VERSION = 1;
static const uint16_t SERVICE_INFO_MIN_MINOR_VERSION = 0;
private:
void autoWash() ;
void routePendingObjects() ;
@ -135,6 +153,12 @@ class p3GRouter: public RsGRouter, public p3Service, public p3Config
void debugDump() ;
void locked_forwardKey(const RsGRouterPublishKeyItem&) ;
// utility functions
//
static uint32_t computeBranchingFactor(const std::vector<RsPeerId>& friends,const std::vector<float>& probas,uint32_t dist) ;
static std::set<uint32_t> computeRoutingFriends(const std::vector<RsPeerId>& friends,const std::vector<float>& probas,uint32_t N) ;
static uint32_t computeRandomDistanceIncrement(const RsPeerId& pid,const GRouterKeyId& destination_id) ;
//===================================================//
// p3Config methods //
//===================================================//

167
libretroshare/src/gxs/gxssecurity.cc
View File

@ -49,9 +49,9 @@ RSA *GxsSecurity::extractPublicKey(const RsTlvSecurityKey& key)
return rsakey;
}
bool GxsSecurity::getSignature(char* data, uint32_t data_len, RsTlvSecurityKey* privKey, RsTlvKeySignature& sign)
bool GxsSecurity::getSignature(const char *data, uint32_t data_len, const RsTlvSecurityKey& privKey, RsTlvKeySignature& sign)
{
RSA* rsa_pub = extractPrivateKey(*privKey);
RSA* rsa_pub = extractPrivateKey(privKey);
EVP_PKEY *key_pub = EVP_PKEY_new();
EVP_PKEY_assign_RSA(key_pub, rsa_pub);
@ -69,11 +69,33 @@ bool GxsSecurity::getSignature(char* data, uint32_t data_len, RsTlvSecurityKey*
EVP_PKEY_free(key_pub);
sign.signData.setBinData(sigbuf, siglen);
sign.keyId = privKey->keyId;
sign.keyId = privKey.keyId;
return ok;
}
bool GxsSecurity::validateSignature(const char *data, uint32_t data_len, const RsTlvSecurityKey& key, const RsTlvKeySignature& signature)
{
RSA *rsakey = RSAPublicKey_dup(extractPublicKey(key)) ;
EVP_PKEY *signKey = EVP_PKEY_new();
EVP_PKEY_assign_RSA(signKey, rsakey);
/* calc and check signature */
EVP_MD_CTX *mdctx = EVP_MD_CTX_create();
EVP_VerifyInit(mdctx, EVP_sha1());
EVP_VerifyUpdate(mdctx, data, data_len);
int signOk = EVP_VerifyFinal(mdctx, (unsigned char*)signature.signData.bin_data, signature.signData.bin_len, signKey);
/* clean up */
EVP_PKEY_free(signKey);
EVP_MD_CTX_destroy(mdctx);
return signOk;
}
bool GxsSecurity::validateNxsMsg(RsNxsMsg& msg, RsTlvKeySignature& sign, RsTlvSecurityKey& key)
{
#ifdef GXS_SECURITY_DEBUG
@ -204,101 +226,112 @@ std::string GxsSecurity::getBinDataSign(void *data, int len)
bool GxsSecurity::encrypt(void *& out, int & outlen, const void *in, int inlen, EVP_PKEY *privateKey)
bool GxsSecurity::encrypt(void *& out, int & outlen, const void *in, int inlen, const RsTlvSecurityKey& key)
{
#ifdef DISTRIB_DEBUG
std::cerr << "GxsSecurity::encrypt() " << std::endl;
std::cerr << "GxsSecurity::encrypt() " << std::endl;
#endif
RSA *rsa_publish_pub = NULL;
EVP_PKEY *public_key = NULL;
RSA *rsa_publish_pub = RSAPublicKey_dup(extractPublicKey(key)) ;
EVP_PKEY *public_key = NULL;
RSA* rsa_publish = EVP_PKEY_get1_RSA(privateKey);
rsa_publish_pub = RSAPublicKey_dup(rsa_publish);
//RSA* rsa_publish = EVP_PKEY_get1_RSA(privateKey);
//rsa_publish_pub = RSAPublicKey_dup(rsa_publish);
if(rsa_publish_pub != NULL){
public_key = EVP_PKEY_new();
EVP_PKEY_assign_RSA(public_key, rsa_publish_pub);
}else{
if(rsa_publish_pub != NULL)
{
public_key = EVP_PKEY_new();
EVP_PKEY_assign_RSA(public_key, rsa_publish_pub);
}else{
#ifdef DISTRIB_DEBUG
std::cerr << "GxsSecurity(): Could not generate publish key " << grpId
<< std::endl;
std::cerr << "GxsSecurity(): Could not generate publish key " << grpId
<< std::endl;
#endif
return false;
}
return false;
}
EVP_CIPHER_CTX ctx;
int eklen, net_ekl;
unsigned char *ek;
unsigned char iv[EVP_MAX_IV_LENGTH];
EVP_CIPHER_CTX_init(&ctx);
int out_currOffset = 0;
int out_offset = 0;
EVP_CIPHER_CTX ctx;
int eklen, net_ekl;
unsigned char *ek;
unsigned char iv[EVP_MAX_IV_LENGTH];
EVP_CIPHER_CTX_init(&ctx);
int out_currOffset = 0;
int out_offset = 0;
int max_evp_key_size = EVP_PKEY_size(public_key);
ek = (unsigned char*)malloc(max_evp_key_size);
const EVP_CIPHER *cipher = EVP_aes_128_cbc();
int cipher_block_size = EVP_CIPHER_block_size(cipher);
int size_net_ekl = sizeof(net_ekl);
int max_evp_key_size = EVP_PKEY_size(public_key);
ek = (unsigned char*)malloc(max_evp_key_size);
const EVP_CIPHER *cipher = EVP_aes_128_cbc();
int cipher_block_size = EVP_CIPHER_block_size(cipher);
int size_net_ekl = sizeof(net_ekl);
int max_outlen = inlen + cipher_block_size + EVP_MAX_IV_LENGTH + max_evp_key_size + size_net_ekl;
int max_outlen = inlen + cipher_block_size + EVP_MAX_IV_LENGTH + max_evp_key_size + size_net_ekl;
// intialize context and send store encrypted cipher in ek
if(!EVP_SealInit(&ctx, EVP_aes_128_cbc(), &ek, &eklen, iv, &public_key, 1)) return false;
// intialize context and send store encrypted cipher in ek
if(!EVP_SealInit(&ctx, EVP_aes_128_cbc(), &ek, &eklen, iv, &public_key, 1)) return false;
// now assign memory to out accounting for data, and cipher block size, key length, and key length val
out = new unsigned char[inlen + cipher_block_size + size_net_ekl + eklen + EVP_MAX_IV_LENGTH];
// now assign memory to out accounting for data, and cipher block size, key length, and key length val
out = new unsigned char[inlen + cipher_block_size + size_net_ekl + eklen + EVP_MAX_IV_LENGTH];
net_ekl = htonl(eklen);
memcpy((unsigned char*)out + out_offset, &net_ekl, size_net_ekl);
out_offset += size_net_ekl;
net_ekl = htonl(eklen);
memcpy((unsigned char*)out + out_offset, &net_ekl, size_net_ekl);
out_offset += size_net_ekl;
memcpy((unsigned char*)out + out_offset, ek, eklen);
out_offset += eklen;
memcpy((unsigned char*)out + out_offset, ek, eklen);
out_offset += eklen;
memcpy((unsigned char*)out + out_offset, iv, EVP_MAX_IV_LENGTH);
out_offset += EVP_MAX_IV_LENGTH;
memcpy((unsigned char*)out + out_offset, iv, EVP_MAX_IV_LENGTH);
out_offset += EVP_MAX_IV_LENGTH;
// now encrypt actual data
if(!EVP_SealUpdate(&ctx, (unsigned char*) out + out_offset, &out_currOffset, (unsigned char*) in, inlen)) return false;
// now encrypt actual data
if(!EVP_SealUpdate(&ctx, (unsigned char*) out + out_offset, &out_currOffset, (unsigned char*) in, inlen)) return false;
// move along to partial block space
out_offset += out_currOffset;
// move along to partial block space
out_offset += out_currOffset;
// add padding
if(!EVP_SealFinal(&ctx, (unsigned char*) out + out_offset, &out_currOffset)) return false;
// add padding
if(!EVP_SealFinal(&ctx, (unsigned char*) out + out_offset, &out_currOffset)) return false;
// move to end
out_offset += out_currOffset;
// move to end
out_offset += out_currOffset;
// make sure offset has not gone passed valid memory bounds
if(out_offset > max_outlen) return false;
// make sure offset has not gone passed valid memory bounds
if(out_offset > max_outlen) return false;
// free encrypted key data
free(ek);
// free encrypted key data
free(ek);
outlen = out_offset;
return true;
delete[] ek;
#ifdef DISTRIB_DEBUG
std::cerr << "GxsSecurity::encrypt() finished with outlen : " << outlen << std::endl;
#endif
return true;
outlen = out_offset;
return true;
}
bool GxsSecurity::decrypt(void *& out, int & outlen, const void *in, int inlen, EVP_PKEY *privateKey)
bool GxsSecurity::decrypt(void *& out, int & outlen, const void *in, int inlen, const RsTlvSecurityKey& key)
{
#ifdef DISTRIB_DEBUG
std::cerr << "GxsSecurity::decrypt() " << std::endl;
std::cerr << "GxsSecurity::decrypt() " << std::endl;
#endif
RSA *rsa_publish = RSAPrivateKey_dup(extractPrivateKey(key)) ;
EVP_PKEY *privateKey = NULL;
//RSA* rsa_publish = EVP_PKEY_get1_RSA(privateKey);
//rsa_publish_pub = RSAPublicKey_dup(rsa_publish);
if(rsa_publish != NULL)
{
privateKey = EVP_PKEY_new();
EVP_PKEY_assign_RSA(privateKey, rsa_publish);
}
else
{
#ifdef DISTRIB_DEBUG
std::cerr << "GxsSecurity(): Could not generate publish key " << grpId
<< std::endl;
#endif
return false;
}
EVP_CIPHER_CTX ctx;
int eklen = 0, net_ekl = 0;

15
libretroshare/src/gxs/gxssecurity.h
View File

@ -98,7 +98,7 @@ public:
*@param in
*@param inlen
*/
static bool encrypt(void *&out, int &outlen, const void *in, int inlen, EVP_PKEY *privateKey);
static bool encrypt(void *&out, int &outlen, const void *in, int inlen, const RsTlvSecurityKey& key) ;
/**
@ -110,7 +110,7 @@ public:
* @param inlen
* @return false if encryption failed
*/
static bool decrypt(void *&out, int &outlen, const void *in, int inlen, EVP_PKEY *privateKey);
static bool decrypt(void *&out, int &outlen, const void *in, int inlen, const RsTlvSecurityKey& key) ;
/*!
* uses grp signature to check if group has been
@ -139,7 +139,16 @@ public:
* @param sign the signature is stored here
* @return false if signature creation failed, true is signature created
*/
static bool getSignature(char* data, uint32_t data_len, RsTlvSecurityKey* privKey, RsTlvKeySignature& sign);
static bool getSignature(const char *data, uint32_t data_len, const RsTlvSecurityKey& privKey, RsTlvKeySignature& sign);
/*!
* @param data data that has been signed
* @param data_len length of signed data
* @param privKey public key to used to check signature
* @param sign Signature for the data
* @return true if signature checks
*/
static bool validateSignature(const char *data, uint32_t data_len, const RsTlvSecurityKey& pubKey, const RsTlvKeySignature& sign);
};
#endif // GXSSECURITY_H

8
libretroshare/src/gxs/rsgenexchange.cc
View File

@ -392,7 +392,7 @@ uint8_t RsGenExchange::createGroup(RsNxsGrp *grp, RsTlvSecurityKeySet& privateKe
memcpy(allGrpData+(grp->grp.bin_len), metaData, metaDataLen);
RsTlvKeySignature adminSign;
bool ok = GxsSecurity::getSignature(allGrpData, allGrpDataLen, &privAdminKey, adminSign);
bool ok = GxsSecurity::getSignature(allGrpData, allGrpDataLen, privAdminKey, adminSign);
// add admin sign to grpMeta
meta->signSet.keySignSet[GXS_SERV::FLAG_AUTHEN_ADMIN] = adminSign;
@ -458,7 +458,7 @@ int RsGenExchange::createGroupSignatures(RsTlvKeySignatureSet& signSet, RsTlvBin
RsTlvKeySignature sign;
if(GxsSecurity::getSignature((char*)grpData.bin_data, grpData.bin_len,
&authorKey, sign))
authorKey, sign))
{
id_ret = SIGN_SUCCESS;
}
@ -584,7 +584,7 @@ int RsGenExchange::createMsgSignatures(RsTlvKeySignatureSet& signSet, RsTlvBinar
RsTlvKeySignature pubSign = signSet.keySignSet[GXS_SERV::FLAG_AUTHEN_PUBLISH];
publishSignSuccess = GxsSecurity::getSignature((char*)msgData.bin_data, msgData.bin_len, pubKey, pubSign);
publishSignSuccess = GxsSecurity::getSignature((char*)msgData.bin_data, msgData.bin_len, *pubKey, pubSign);
//place signature in msg meta
signSet.keySignSet[GXS_SERV::FLAG_AUTHEN_PUBLISH] = pubSign;
@ -617,7 +617,7 @@ int RsGenExchange::createMsgSignatures(RsTlvKeySignatureSet& signSet, RsTlvBinar
RsTlvKeySignature sign;
if(GxsSecurity::getSignature((char*)msgData.bin_data, msgData.bin_len,
&authorKey, sign))
authorKey, sign))
{
id_ret = SIGN_SUCCESS;
}

30
libretroshare/src/libretroshare.pro
View File

@ -7,7 +7,7 @@ TARGET = retroshare
#GXS Stuff.
# This should be disabled for releases until further notice.
CONFIG += gxs debug
#CONFIG += grouter
#CONFIG += dsdv
profiling {
@ -34,23 +34,6 @@ debug {
QMAKE_CXXFLAGS *= -g -fno-omit-frame-pointer
}
grouter {
DEFINES *= GROUTER
HEADERS += grouter/groutercache.h \
grouter/rsgrouter.h \
grouter/grouteritems.h \
grouter/p3grouter.h \
grouter/rsgroutermatrix.h \
grouter/rsgrouterclient.h
SOURCES += grouter/p3grouter.cc \
grouter/grouteritems.cc \
grouter/groutermatrix.cc
# grouter/groutercache.cc \
# grouter/rsgrouterclient.cc
}
dsdv {
DEFINES *= SERVICES_DSDV
HEADERS += services/p3dsdv.h \
@ -397,6 +380,13 @@ HEADERS += rsserver/p3face.h \
rsserver/rsaccounts.h \
rsserver/p3serverconfig.h
HEADERS += grouter/groutercache.h \
grouter/rsgrouter.h \
grouter/grouteritems.h \
grouter/p3grouter.h \
grouter/rsgroutermatrix.h \
grouter/rsgrouterclient.h
HEADERS += serialiser/rsbaseserial.h \
serialiser/rsfiletransferitems.h \
serialiser/rsserviceserialiser.h \
@ -533,6 +523,10 @@ SOURCES += rsserver/p3face-config.cc \
rsserver/rstypes.cc \
rsserver/p3serverconfig.cc
SOURCES += grouter/p3grouter.cc \
grouter/grouteritems.cc \
grouter/groutermatrix.cc
SOURCES += plugins/pluginmanager.cc \
plugins/dlfcn_win32.cc \
serialiser/rspluginitems.cc

68
libretroshare/src/grouter/rsgrouter.h → libretroshare/src/retroshare/rsgrouter.h
View File

@ -27,43 +27,56 @@
#include "util/rsdir.h"
#include "grouter/groutertypes.h"
#include "retroshare/rsids.h"
typedef GRouterKeyIdType GRouterKeyId ; // we use SSLIds, so that it's easier in the GUI to mix up peer ids with grouter ids.
typedef Sha1CheckSum GRouterKeyId ; // we use sha1. Gives sufficient entropy.
class GRouterClientService ;
class RsGRouterGenericDataItem ;
// This is the interface file for the global router service.
//
struct RoutingCacheInfo
{
// what do we want to show here?
// - recently routed items
// - ongoing routing info
// - pending items, waiting for an answer
// -
};
struct RoutingMatrixInfo
{
// Probabilities of reaching a given key for each friend.
// This concerns all known keys.
//
std::map<GRouterKeyId, std::vector<float> > per_friend_probabilities ;
// List of own published keys, with associated service ID
//
std::map<GRouterKeyId, GRouterClientService *> published_keys ;
};
class RsGRouter
{
public:
// This is the interface file for the global router service.
//
struct GRouterRoutingCacheInfo
{
GRouterMsgPropagationId mid ;
RsPeerId local_origin;
GRouterKeyId destination ;
time_t time_stamp ;
uint32_t status ;
uint32_t data_size ;
};
struct GRouterPublishedKeyInfo
{
std::string description_string ;
uint32_t service_id ;
};
struct GRouterRoutingMatrixInfo
{
// Probabilities of reaching a given key for each friend.
// This concerns all known keys.
//
std::map<GRouterKeyId, std::vector<float> > per_friend_probabilities ;
// List of friend ids in the same order. Should roughly correspond to the friends that are currently online.
//
std::vector<RsPeerId> friend_ids ;
// List of own published keys, with associated service ID
//
std::map<GRouterKeyId,GRouterPublishedKeyInfo> published_keys ;
};
//===================================================//
// Debugging info //
//===================================================//
virtual bool getRoutingCacheInfo(RoutingCacheInfo& info) =0;
virtual bool getRoutingMatrixInfo(RoutingMatrixInfo& info) =0;
virtual bool getRoutingCacheInfo(std::vector<GRouterRoutingCacheInfo>& infos) =0;
virtual bool getRoutingMatrixInfo(GRouterRoutingMatrixInfo& info) =0;
// retrieve the routing probabilities
@ -72,8 +85,7 @@ class RsGRouter
//===================================================//
virtual void sendData(const GRouterKeyId& destination, RsGRouterGenericDataItem *item) =0;
virtual bool registerKey(const GRouterKeyId& key,const PGPFingerprintType& fps,const GRouterServiceId& client_id,const std::string& description_string) =0;
virtual bool registerKey(const GRouterKeyId& key,const GRouterServiceId& client_id,const std::string& description_string) =0;
};
// To access the GRouter from anywhere

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

@ -218,8 +218,10 @@ static const uint32_t RS_GENERIC_ID_GXS_GROUP_ID_TYPE = 0x0005 ;
static const uint32_t RS_GENERIC_ID_GXS_ID_TYPE = 0x0006 ;
static const uint32_t RS_GENERIC_ID_GXS_MSG_ID_TYPE = 0x0007 ;
static const uint32_t RS_GENERIC_ID_GXS_CIRCLE_ID_TYPE = 0x0008 ;
static const uint32_t RS_GENERIC_ID_GROUTER_ID_TYPE = 0x0009 ;
typedef t_RsGenericIdType< SSL_ID_SIZE , false, RS_GENERIC_ID_SSL_ID_TYPE> SSLIdType ;
typedef t_RsGenericIdType< SSL_ID_SIZE , false, RS_GENERIC_ID_GROUTER_ID_TYPE> GRouterKeyIdType ;
typedef t_RsGenericIdType< PGP_KEY_ID_SIZE , true, RS_GENERIC_ID_PGP_ID_TYPE> PGPIdType ;
typedef t_RsGenericIdType< SHA1_SIZE , false, RS_GENERIC_ID_SHA1_ID_TYPE> Sha1CheckSum ;
typedef t_RsGenericIdType< PGP_KEY_FINGERPRINT_SIZE, true, RS_GENERIC_ID_PGP_FINGERPRINT_TYPE> PGPFingerprintType ;

52
libretroshare/src/retroshare/rsmsgs.h
View File

@ -33,6 +33,7 @@
#include <set>
#include "rstypes.h"
#include "rsgxsifacetypes.h"
/********************** For Messages and Channels *****************/
@ -88,32 +89,42 @@ typedef uint64_t ChatLobbyMsgId ;
typedef std::string ChatLobbyNickName ;
typedef RsPeerId DistantChatPeerId ;
typedef RsPeerId DistantMsgPeerId ;
typedef GRouterKeyIdType DistantMsgPeerId ;
class MessageInfo
{
public:
MessageInfo() {}
std::string msgId;
RsPeerId srcId;
public:
MessageInfo() {}
std::string msgId;
unsigned int msgflags;
RsPeerId rspeerid_srcId;
RsGxsId rsgxsid_srcId;
std::list<RsPeerId> msgto;
std::list<RsPeerId> msgcc;
std::list<RsPeerId> msgbcc;
unsigned int msgflags;
std::string title;
std::string msg;
// friend destinations
//
std::list<RsPeerId> rspeerid_msgto; // RsPeerId is used here for various purposes:
std::list<RsPeerId> rspeerid_msgcc; // - real peer ids which are actual friend locations
std::list<RsPeerId> rspeerid_msgbcc; // -
std::string attach_title;
std::string attach_comment;
std::list<FileInfo> files;
std::map<std::string,std::string> encryption_keys ; // for concerned ids only the public pgp key id to encrypt the message with.
int size; /* total of files */
int count; /* file count */
// distant peers
//
std::list<RsGxsId> rsgxsid_msgto; // RsPeerId is used here for various purposes:
std::list<RsGxsId> rsgxsid_msgcc; // - real peer ids which are actual friend locations
std::list<RsGxsId> rsgxsid_msgbcc; // -
int ts;
std::string title;
std::string msg;
std::string attach_title;
std::string attach_comment;
std::list<FileInfo> files;
int size; /* total of files */
int count; /* file count */
int ts;
};
class MsgInfoSummary
@ -241,7 +252,7 @@ extern RsMsgs *rsMsgs;
struct DistantOfflineMessengingInvite
{
RsPgpId issuer_pgp_id ;
Sha1CheckSum hash ;
DistantMsgPeerId peer_id ;
time_t time_of_validity ;
};
@ -291,11 +302,8 @@ virtual bool resetMessageStandardTagTypes(MsgTagType& tags) = 0;
/* Private distant messages */
/****************************************/
virtual bool createDistantOfflineMessengingInvite(time_t validity_time_stamp, DistantMsgPeerId& hash)=0 ;
virtual bool getDistantOfflineMessengingInvites(std::vector<DistantOfflineMessengingInvite>& invites) = 0 ;
virtual void enableDistantMessaging(bool b) = 0;
virtual bool distantMessagingEnabled() = 0;
virtual bool getDistantMessagePeerId(const RsPgpId& pgp_id, DistantMsgPeerId& peerId) = 0;
/****************************************/
/* Chat */

12
libretroshare/src/rsserver/p3msgs.cc
View File

@ -100,14 +100,6 @@ bool p3Msgs::decryptMessage(const std::string& mId)
{
return mMsgSrv->decryptMessage(mId);
}
bool p3Msgs::createDistantOfflineMessengingInvite(time_t ts, DistantMsgPeerId &hash)
{
return mMsgSrv->createDistantOfflineMessengingInvite(ts,hash) ;
}
bool p3Msgs::getDistantOfflineMessengingInvites(std::vector<DistantOfflineMessengingInvite>& invites)
{
return mMsgSrv->getDistantOfflineMessengingInvites(invites);
}
void p3Msgs::enableDistantMessaging(bool b)
{
mMsgSrv->enableDistantMessaging(b);
@ -116,10 +108,6 @@ bool p3Msgs::distantMessagingEnabled()
{
return mMsgSrv->distantMessagingEnabled();
}
bool p3Msgs::getDistantMessagePeerId(const RsPgpId& pgp_id,DistantMsgPeerId &pid)
{
return mMsgSrv->getDistantMessagePeerId(pgp_id,pid);
}
bool p3Msgs::SystemMessage(const std::string &title, const std::string &message, uint32_t systemFlag)
{

5
libretroshare/src/rsserver/p3msgs.h
View File

@ -27,6 +27,7 @@
*/
#include "retroshare/rsmsgs.h"
#include "retroshare/rsgxsifacetypes.h"
class p3MsgService;
class p3ChatService;
@ -80,12 +81,8 @@ class p3Msgs: public RsMsgs
virtual bool resetMessageStandardTagTypes(MsgTagType& tags);
virtual bool createDistantOfflineMessengingInvite(time_t, DistantMsgPeerId&) ;
virtual bool getDistantOfflineMessengingInvites(std::vector<DistantOfflineMessengingInvite>&);
virtual void enableDistantMessaging(bool b) ;
virtual bool distantMessagingEnabled() ;
virtual bool getDistantMessagePeerId(const RsPgpId& pgp_id,DistantMsgPeerId& pid) ;
/*!
* gets avatar from peer, image data in jpeg format

135
libretroshare/src/rsserver/rsinit.cc
View File

@ -56,6 +56,8 @@
#include <openssl/rand.h>
#include <fcntl.h>
#define ENABLE_GROUTER
#if (defined(__unix__) || defined(unix)) && !defined(USG)
#include <sys/param.h>
#endif
@ -69,7 +71,7 @@
#include "pqi/sslfns.h"
#include "pqi/authgpg.h"
#ifdef GROUTER
#ifdef ENABLE_GROUTER
#include "grouter/p3grouter.h"
#endif
@ -839,7 +841,7 @@ bool RsInit::SetHiddenLocation(const std::string& hiddenaddress, uint16_t port)
RsFiles *rsFiles = NULL;
RsTurtle *rsTurtle = NULL ;
#ifdef GROUTER
#ifdef ENABLE_GROUTER
RsGRouter *rsGRouter = NULL ;
#endif
@ -1111,7 +1113,8 @@ int RsServer::StartupRetroShare()
* if not... copy from dataDirectory
*/
if (!RsDirUtil::checkFile(bootstrapfile,true))
uint64_t tmp_size ;
if (!RsDirUtil::checkFile(bootstrapfile,tmp_size,true))
{
std::cerr << "DHT bootstrap file not in ConfigDir: " << bootstrapfile << std::endl;
std::string installfile = rsAccounts.PathDataDirectory();
@ -1119,7 +1122,7 @@ int RsServer::StartupRetroShare()
installfile += BITDHT_BOOTSTRAP_FILENAME;
std::cerr << "Checking for Installation DHT bootstrap file " << installfile << std::endl;
if ((installfile != "") && (RsDirUtil::checkFile(installfile)))
if ((installfile != "") && (RsDirUtil::checkFile(installfile,tmp_size)))
{
std::cerr << "Copying Installation DHT bootstrap file..." << std::endl;
if (RsDirUtil::copyFile(installfile, bootstrapfile))
@ -1295,67 +1298,6 @@ int RsServer::StartupRetroShare()
//
mPluginsManager->loadPlugins(programatically_inserted_plugins) ;
/* create Services */
p3ServiceInfo *serviceInfo = new p3ServiceInfo(serviceCtrl);
mDisc = new p3discovery2(mPeerMgr, mLinkMgr, mNetMgr, serviceCtrl);
mHeart = new p3heartbeat(serviceCtrl, pqih);
msgSrv = new p3MsgService(serviceCtrl);
chatSrv = new p3ChatService(serviceCtrl, mLinkMgr, mHistoryMgr);
mStatusSrv = new p3StatusService(serviceCtrl);
#ifdef GROUTER
p3GRouter *gr = new p3GRouter(mLinkMgr) ;
rsGRouter = gr ;
pqih->addService(gr, true) ;
#endif
p3turtle *tr = new p3turtle(mLinkMgr) ;
rsTurtle = tr ;
pqih -> addService(tr, true);
pqih -> addService(ftserver, true);
rsDisc = mDisc;
rsMsgs = new p3Msgs(msgSrv, chatSrv);
// connect components to turtle router.
ftserver->connectToTurtleRouter(tr) ;
chatSrv->connectToTurtleRouter(tr) ;
#ifdef GROUTER
msgSrv->connectToGlobalRouter(gr) ;
#endif
msgSrv->connectToTurtleRouter(tr) ;
pqih -> addService(serviceInfo, true);
pqih -> addService(mHeart, true);
pqih -> addService(mDisc, true);
pqih -> addService(msgSrv, true);
pqih -> addService(chatSrv, true);
pqih ->addService(mStatusSrv, true);
// set interfaces for plugins
//
RsPlugInInterfaces interfaces;
interfaces.mFiles = rsFiles;
interfaces.mPeers = rsPeers;
interfaces.mMsgs = rsMsgs;
interfaces.mTurtle = rsTurtle;
interfaces.mDisc = rsDisc;
interfaces.mDht = rsDht;
// don't exist no more.
//interfaces.mForums = mForums;
interfaces.mNotify = mNotify;
mPluginsManager->setInterfaces(interfaces);
// now add plugin objects inside the loop:
// - client services provided by plugins.
// - cache services provided by plugins.
//
mPluginsManager->registerClientServices(pqih) ;
mPluginsManager->registerCacheServices() ;
#ifdef RS_ENABLE_GXS
// The idea is that if priorGxsDir is non
@ -1553,6 +1495,67 @@ int RsServer::StartupRetroShare()
#endif // RS_ENABLE_GXS.
/* create Services */
p3ServiceInfo *serviceInfo = new p3ServiceInfo(serviceCtrl);
mDisc = new p3discovery2(mPeerMgr, mLinkMgr, mNetMgr, serviceCtrl);
mHeart = new p3heartbeat(serviceCtrl, pqih);
msgSrv = new p3MsgService(serviceCtrl,mGxsIdService);
chatSrv = new p3ChatService(serviceCtrl, mLinkMgr, mHistoryMgr);
mStatusSrv = new p3StatusService(serviceCtrl);
#ifdef ENABLE_GROUTER
p3GRouter *gr = new p3GRouter(mLinkMgr) ;
rsGRouter = gr ;
pqih->addService(gr,true) ;
#endif
p3turtle *tr = new p3turtle(mLinkMgr) ;
rsTurtle = tr ;
pqih -> addService(tr,true);
pqih -> addService(ftserver,true);
rsDisc = mDisc;
rsMsgs = new p3Msgs(msgSrv, chatSrv);
// connect components to turtle router.
ftserver->connectToTurtleRouter(tr) ;
chatSrv->connectToTurtleRouter(tr) ;
#ifdef ENABLE_GROUTER
msgSrv->connectToGlobalRouter(gr) ;
#endif
pqih -> addService(serviceInfo,true);
pqih -> addService(mHeart,true);
pqih -> addService(mDisc,true);
pqih -> addService(msgSrv,true);
pqih -> addService(chatSrv,true);
pqih ->addService(mStatusSrv,true);
// set interfaces for plugins
//
RsPlugInInterfaces interfaces;
interfaces.mFiles = rsFiles;
interfaces.mPeers = rsPeers;
interfaces.mMsgs = rsMsgs;
interfaces.mTurtle = rsTurtle;
interfaces.mDisc = rsDisc;
interfaces.mDht = rsDht;
// don't exist no more.
//interfaces.mForums = mForums;
interfaces.mNotify = mNotify;
mPluginsManager->setInterfaces(interfaces);
// now add plugin objects inside the loop:
// - client services provided by plugins.
// - cache services provided by plugins.
//
mPluginsManager->registerClientServices(pqih) ;
mPluginsManager->registerCacheServices() ;
#ifdef RS_RTT
p3rtt *mRtt = new p3rtt(serviceCtrl);
@ -1635,7 +1638,7 @@ int RsServer::StartupRetroShare()
mConfigMgr->addConfiguration("p3History.cfg", mHistoryMgr);
mConfigMgr->addConfiguration("p3Status.cfg", mStatusSrv);
mConfigMgr->addConfiguration("turtle.cfg", tr);
#ifdef GROUTER
#ifdef ENABLE_GROUTER
mConfigMgr->addConfiguration("grouter.cfg", gr);
#endif

51
libretroshare/src/serialiser/rsmsgitems.cc
View File

@ -1380,9 +1380,13 @@ void RsMsgItem::clear()
subject.clear();
message.clear();
msgto.TlvClear();
msgcc.TlvClear();
msgbcc.TlvClear();
rspeerid_msgto.TlvClear();
rspeerid_msgcc.TlvClear();
rspeerid_msgbcc.TlvClear();
rsgxsid_msgto.TlvClear();
rsgxsid_msgcc.TlvClear();
rsgxsid_msgbcc.TlvClear();
attachment.TlvClear();
}
@ -1403,15 +1407,18 @@ std::ostream &RsMsgItem::print(std::ostream &out, uint16_t indent)
printIndent(out, int_Indent);
out << "Message To: " << std::endl;
msgto.print(out, int_Indent);
rspeerid_msgto.print(out, int_Indent);
rsgxsid_msgto.print(out, int_Indent);
printIndent(out, int_Indent);
out << "Message CC: " << std::endl;
msgcc.print(out, int_Indent);
rspeerid_msgcc.print(out, int_Indent);
rsgxsid_msgcc.print(out, int_Indent);
printIndent(out, int_Indent);
out << "Message BCC: " << std::endl;
msgbcc.print(out, int_Indent);
rspeerid_msgbcc.print(out, int_Indent);
rsgxsid_msgbcc.print(out, int_Indent);
printIndent(out, int_Indent);
std::string cnv_subject(subject.begin(), subject.end());
@ -1514,9 +1521,14 @@ uint32_t RsMsgItem::serial_size(bool m_bConfiguration)
s += GetTlvStringSize(subject);
s += GetTlvStringSize(message);
s += msgto.TlvSize();
s += msgcc.TlvSize();
s += msgbcc.TlvSize();
s += rspeerid_msgto.TlvSize();
s += rspeerid_msgcc.TlvSize();
s += rspeerid_msgbcc.TlvSize();
s += rsgxsid_msgto.TlvSize();
s += rsgxsid_msgcc.TlvSize();
s += rsgxsid_msgbcc.TlvSize();
s += attachment.TlvSize();
if (m_bConfiguration) {
@ -1558,9 +1570,13 @@ bool RsMsgItem::serialise(void *data, uint32_t& pktsize,bool config)
ok &= SetTlvString(data,tlvsize,&offset,TLV_TYPE_STR_SUBJECT,subject);
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_MSG, message);
ok &= msgto.SetTlv(data, tlvsize, &offset);
ok &= msgcc.SetTlv(data, tlvsize, &offset);
ok &= msgbcc.SetTlv(data, tlvsize, &offset);
ok &= rspeerid_msgto.SetTlv(data, tlvsize, &offset);
ok &= rspeerid_msgcc.SetTlv(data, tlvsize, &offset);
ok &= rspeerid_msgbcc.SetTlv(data, tlvsize, &offset);
ok &= rsgxsid_msgto.SetTlv(data, tlvsize, &offset);
ok &= rsgxsid_msgcc.SetTlv(data, tlvsize, &offset);
ok &= rsgxsid_msgbcc.SetTlv(data, tlvsize, &offset);
ok &= attachment.SetTlv(data, tlvsize, &offset);
@ -1614,9 +1630,14 @@ RsMsgItem *RsMsgSerialiser::deserialiseMsgItem(void *data, uint32_t *pktsize)
ok &= GetTlvString(data,rssize,&offset,TLV_TYPE_STR_SUBJECT,item->subject);
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_MSG, item->message);
ok &= item->msgto.GetTlv(data, rssize, &offset);
ok &= item->msgcc.GetTlv(data, rssize, &offset);
ok &= item->msgbcc.GetTlv(data, rssize, &offset);
ok &= item->rspeerid_msgto.GetTlv(data, rssize, &offset);
ok &= item->rspeerid_msgcc.GetTlv(data, rssize, &offset);
ok &= item->rspeerid_msgbcc.GetTlv(data, rssize, &offset);
ok &= item->rsgxsid_msgto.GetTlv(data, rssize, &offset);
ok &= item->rsgxsid_msgcc.GetTlv(data, rssize, &offset);
ok &= item->rsgxsid_msgbcc.GetTlv(data, rssize, &offset);
ok &= item->attachment.GetTlv(data, rssize, &offset);
if (m_bConfiguration) {

15
libretroshare/src/serialiser/rsmsgitems.h
View File

@ -458,11 +458,6 @@ class RsMsgItem: public RsMessageItem
public:
RsMsgItem() :RsMessageItem(RS_PKT_SUBTYPE_DEFAULT) {}
// RsMsgItem(uint16_t type)
// :RsItem(RS_PKT_VERSION_SERVICE, type,
// RS_PKT_SUBTYPE_DEFAULT)
// { setPriorityLevel(QOS_PRIORITY_RS_MSG_ITEM) ; }
virtual ~RsMsgItem() {}
virtual void clear();
@ -482,9 +477,13 @@ class RsMsgItem: public RsMessageItem
std::string subject;
std::string message;
RsTlvPeerIdSet msgto;
RsTlvPeerIdSet msgcc;
RsTlvPeerIdSet msgbcc;
RsTlvPeerIdSet rspeerid_msgto;
RsTlvPeerIdSet rspeerid_msgcc;
RsTlvPeerIdSet rspeerid_msgbcc;
RsTlvGxsIdSet rsgxsid_msgto;
RsTlvGxsIdSet rsgxsid_msgcc;
RsTlvGxsIdSet rsgxsid_msgbcc;
RsTlvFileSet attachment;
};

1
libretroshare/src/serialiser/rsserviceids.h
View File

@ -48,6 +48,7 @@ const uint16_t RS_SERVICE_TYPE_TURTLE = 0x0014;
const uint16_t RS_SERVICE_TYPE_TUNNEL = 0x0015;
const uint16_t RS_SERVICE_TYPE_HEARTBEAT = 0x0016;
const uint16_t RS_SERVICE_TYPE_FILE_TRANSFER = 0x0017;
const uint16_t RS_SERVICE_TYPE_GROUTER = 0x0018;
/* BanList Still Testing at the moment - Service Only */
const uint16_t RS_SERVICE_TYPE_BANLIST = 0x0101;

1
libretroshare/src/serialiser/rstlvbase.h
View File

@ -230,6 +230,7 @@ const uint16_t TLV_TYPE_HASHSET = 0x1022;
const uint16_t TLV_TYPE_PGPIDSET = 0x1023;
const uint16_t TLV_TYPE_RECOGNSET = 0x1024;
const uint16_t TLV_TYPE_GXSIDSET = 0x1025;
const uint16_t TLV_TYPE_SERVICESET = 0x1030;

7
libretroshare/src/serialiser/rstlvtypes.h
View File

@ -41,7 +41,7 @@
#include <serialiser/rstlvtypes.h>
#include <serialiser/rstlvbase.h>
#include <serialiser/rsbaseserial.h>
#include <retroshare/rsgxsifacetypes.h>
//! A base class for all tlv items
/*! This class is provided to allow the serialisation and deserialization of compund
@ -190,9 +190,10 @@ template<class ID_CLASS,uint32_t TLV_TYPE> class t_RsTlvIdSet: public RsTlvItem
std::list<ID_CLASS> ids ;
};
typedef t_RsTlvIdSet<RsPeerId,TLV_TYPE_PEERSET> RsTlvPeerIdSet ;
typedef t_RsTlvIdSet<RsPgpId,TLV_TYPE_PGPIDSET> RsTlvPgpIdSet ;
typedef t_RsTlvIdSet<RsPeerId,TLV_TYPE_PEERSET> RsTlvPeerIdSet ;
typedef t_RsTlvIdSet<RsPgpId,TLV_TYPE_PGPIDSET> RsTlvPgpIdSet ;
typedef t_RsTlvIdSet<Sha1CheckSum,TLV_TYPE_HASHSET> RsTlvHashSet ;
typedef t_RsTlvIdSet<RsGxsId,TLV_TYPE_GXSIDSET> RsTlvGxsIdSet ;
class RsTlvServiceIdSet: public RsTlvItem
{

1344
libretroshare/src/services/p3msgservice.cc
View File

File diff suppressed because it is too large Load Diff

195
libretroshare/src/services/p3msgservice.h
View File

@ -43,79 +43,74 @@
#include "serialiser/rsmsgitems.h"
#include "util/rsthreads.h"
#ifdef GROUTER
#include "retroshare/rsgxsifacetypes.h"
#include "grouter/p3grouter.h"
#include "grouter/grouterclientservice.h"
#endif
#include "turtle/p3turtle.h"
#include "turtle/turtleclientservice.h"
class p3LinkMgr;
class p3IdService;
// Temp tweak to test grouter
class p3MsgService: public p3Service, public p3Config, public pqiServiceMonitor, public RsTurtleClientService
#ifdef GROUTER
, public GRouterClientService
#endif
class p3MsgService: public p3Service, public p3Config, public pqiServiceMonitor, public GRouterClientService
{
public:
p3MsgService(p3ServiceControl *sc);
virtual RsServiceInfo getServiceInfo();
p3MsgService(p3ServiceControl *sc, p3IdService *id_service);
virtual RsServiceInfo getServiceInfo();
/* External Interface */
bool getMessageSummaries(std::list<MsgInfoSummary> &msgList);
bool getMessage(const std::string &mid, MessageInfo &msg);
void getMessageCount(unsigned int *pnInbox, unsigned int *pnInboxNew, unsigned int *pnOutbox, unsigned int *pnDraftbox, unsigned int *pnSentbox, unsigned int *pnTrashbox);
/* External Interface */
bool getMessageSummaries(std::list<MsgInfoSummary> &msgList);
bool getMessage(const std::string &mid, MessageInfo &msg);
void getMessageCount(unsigned int *pnInbox, unsigned int *pnInboxNew, unsigned int *pnOutbox, unsigned int *pnDraftbox, unsigned int *pnSentbox, unsigned int *pnTrashbox);
bool decryptMessage(const std::string& mid) ;
bool removeMsgId(const std::string &mid);
bool markMsgIdRead(const std::string &mid, bool bUnreadByUser);
bool setMsgFlag(const std::string &mid, uint32_t flag, uint32_t mask);
bool getMsgParentId(const std::string &msgId, std::string &msgParentId);
// msgParentId == 0 --> remove
bool setMsgParentId(uint32_t msgId, uint32_t msgParentId);
bool decryptMessage(const std::string& mid) ;
bool removeMsgId(const std::string &mid);
bool markMsgIdRead(const std::string &mid, bool bUnreadByUser);
bool setMsgFlag(const std::string &mid, uint32_t flag, uint32_t mask);
bool getMsgParentId(const std::string &msgId, std::string &msgParentId);
// msgParentId == 0 --> remove
bool setMsgParentId(uint32_t msgId, uint32_t msgParentId);
bool MessageSend(MessageInfo &info);
bool SystemMessage(const std::string &title, const std::string &message, uint32_t systemFlag);
bool MessageToDraft(MessageInfo &info, const std::string &msgParentId);
bool MessageToTrash(const std::string &mid, bool bTrash);
bool MessageSend(MessageInfo &info);
bool SystemMessage(const std::string &title, const std::string &message, uint32_t systemFlag);
bool MessageToDraft(MessageInfo &info, const std::string &msgParentId);
bool MessageToTrash(const std::string &mid, bool bTrash);
bool getMessageTagTypes(MsgTagType& tags);
bool setMessageTagType(uint32_t tagId, std::string& text, uint32_t rgb_color);
bool removeMessageTagType(uint32_t tagId);
bool getMessageTagTypes(MsgTagType& tags);
bool setMessageTagType(uint32_t tagId, std::string& text, uint32_t rgb_color);
bool removeMessageTagType(uint32_t tagId);
bool getMessageTag(const std::string &msgId, MsgTagInfo& info);
/* set == false && tagId == 0 --> remove all */
bool setMessageTag(const std::string &msgId, uint32_t tagId, bool set);
bool getMessageTag(const std::string &msgId, MsgTagInfo& info);
/* set == false && tagId == 0 --> remove all */
bool setMessageTag(const std::string &msgId, uint32_t tagId, bool set);
bool resetMessageStandardTagTypes(MsgTagType& tags);
bool resetMessageStandardTagTypes(MsgTagType& tags);
void loadWelcomeMsg(); /* startup message */
void loadWelcomeMsg(); /* startup message */
//std::list<RsMsgItem *> &getMsgList();
//std::list<RsMsgItem *> &getMsgOutList();
//std::list<RsMsgItem *> &getMsgList();
//std::list<RsMsgItem *> &getMsgOutList();
int tick();
int status();
int tick();
int status();
/*** Overloaded from p3Config ****/
virtual RsSerialiser *setupSerialiser();
virtual bool saveList(bool& cleanup, std::list<RsItem*>&);
virtual bool loadList(std::list<RsItem*>& load);
virtual void saveDone();
/*** Overloaded from p3Config ****/
/*** Overloaded from p3Config ****/
virtual RsSerialiser *setupSerialiser();
virtual bool saveList(bool& cleanup, std::list<RsItem*>&);
virtual bool loadList(std::list<RsItem*>& load);
virtual void saveDone();
/*** Overloaded from p3Config ****/
/*** Overloaded from pqiMonitor ***/
virtual void statusChange(const std::list<pqiServicePeer> &plist);
int checkOutgoingMessages();
/*** Overloaded from pqiMonitor ***/
/*** Overloaded from pqiMonitor ***/
virtual void statusChange(const std::list<pqiServicePeer> &plist);
int checkOutgoingMessages();
/*** Overloaded from pqiMonitor ***/
/*** overloaded from p3turtle ***/
/*** overloaded from p3turtle ***/
#ifdef GROUTER
virtual void connectToGlobalRouter(p3GRouter *) ;
#endif
virtual void connectToTurtleRouter(p3turtle *) ;
struct DistantMessengingInvite
{
@ -128,96 +123,80 @@ int checkOutgoingMessages();
uint32_t status ;
bool pending_messages ;
};
bool createDistantOfflineMessengingInvite(time_t time_of_validity,DistantMsgPeerId &peer_id) ;
bool getDistantOfflineMessengingInvites(std::vector<DistantOfflineMessengingInvite>& invites) ;
void enableDistantMessaging(bool b) ;
bool distantMessagingEnabled() ;
bool getDistantMessagePeerId(const RsPgpId& pgp_id,DistantMsgPeerId &peer_id) ;
private:
bool getDistantMessageHash(const RsPgpId& pgp_id,Sha1CheckSum &hash) ;
void sendPrivateMsgItem(const Sha1CheckSum& hash,RsMsgItem *) ;
// This maps contains the current invitations to respond to.
// The map is indexed by the hash
std::map<Sha1CheckSum,DistantMessengingInvite> _messenging_invites ;
void sendPrivateMsgItem(RsMsgItem *msgitem) ;
// This contains the ongoing tunnel handling contacts.
// The map is indexed by the hash
std::map<Sha1CheckSum,DistantMessengingContact> _messenging_contacts ;
//
std::map<GRouterKeyId,DistantMessengingContact> _messenging_contacts ;
// Overloaded from RsTurtleClientService
// Overloaded from GRouterClientService
#ifdef GROUTER
virtual void receiveGRouterData(RsGRouterGenericDataItem *item, const GRouterKeyId& key) ;
#endif
virtual bool handleTunnelRequest(const Sha1CheckSum& hash,const RsPeerId& peer_id) ;
// virtual void receiveTurtleData(RsTurtleGenericTunnelItem *item,const Sha1CheckSum& hash,const RsPeerId& virtual_peer_id,RsTurtleGenericTunnelItem::Direction direction) ;
void addVirtualPeer(const TurtleFileHash&, const TurtleVirtualPeerId&,RsTurtleGenericTunnelItem::Direction /* dir */) {}
void removeVirtualPeer(const TurtleFileHash&, const TurtleVirtualPeerId&) {}
virtual void receiveGRouterData(const GRouterKeyId& key,const RsGRouterGenericDataItem *item) ;
// Utility functions
bool encryptMessage(const RsPgpId& pgp_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) ;
void sendGRouterData(const GRouterKeyId &key_id,RsMsgItem *) ;
void manageDistantPeers() ;
void sendTurtleData(const Sha1CheckSum& hash,RsMsgItem *) ;
#ifdef GROUTER
void sendGRouterData(const Sha1CheckSum& hash,RsMsgItem *) ;
#endif
void handleIncomingItem(RsMsgItem *) ;
#ifdef GROUTER
uint32_t getNewUniqueMsgId();
int sendMessage(RsMsgItem *item);
void checkSizeAndSendMessage(RsMsgItem *msg);
int incomingMsgs();
void processMsg(RsMsgItem *mi, bool incoming);
bool checkAndRebuildPartialMessage(RsMsgItem*) ;
void initRsMI(RsMsgItem *msg, MessageInfo &mi);
void initRsMIS(RsMsgItem *msg, MsgInfoSummary &mis);
RsMsgItem *initMIRsMsg(const MessageInfo &info, const RsPeerId& to);
RsMsgItem *initMIRsMsg(const MessageInfo &info, const RsGxsId& to);
void initMIRsMsg(RsMsgItem *item,const MessageInfo &info) ;
void initStandardTagTypes();
p3ServiceControl *mServiceCtrl;
p3IdService *mIdService ;
p3GRouter *mGRouter ;
#endif
p3turtle *mTurtle ;
uint32_t getNewUniqueMsgId();
int sendMessage(RsMsgItem *item);
void checkSizeAndSendMessage(RsMsgItem *msg);
/* Mutex Required for stuff below */
int incomingMsgs();
void processMsg(RsMsgItem *mi, bool incoming);
bool checkAndRebuildPartialMessage(RsMsgItem*) ;
void initRsMI(RsMsgItem *msg, MessageInfo &mi);
void initRsMIS(RsMsgItem *msg, MsgInfoSummary &mis);
RsMsgItem *initMIRsMsg(MessageInfo &info, const RsPeerId &to);
void initStandardTagTypes();
p3ServiceControl *mServiceCtrl;
/* Mutex Required for stuff below */
RsMutex mMsgMtx;
RsMsgSerialiser *_serialiser ;
RsMutex mMsgMtx;
RsMsgSerialiser *_serialiser ;
/* stored list of messages */
std::map<uint32_t, RsMsgItem *> imsg;
std::map<uint32_t, RsMsgItem *> imsg;
/* ones that haven't made it out yet! */
std::map<uint32_t, RsMsgItem *> msgOutgoing;
std::map<uint32_t, RsMsgItem *> msgOutgoing;
std::map<RsPeerId, RsMsgItem *> _pendingPartialMessages ;
std::map<RsPeerId, RsMsgItem *> _pendingPartialMessages ;
/* maps for tags types and msg tags */
/* maps for tags types and msg tags */
std::map<uint32_t, RsMsgTagType*> mTags;
std::map<uint32_t, RsMsgTags*> mMsgTags;
std::map<uint32_t, RsMsgTagType*> mTags;
std::map<uint32_t, RsMsgTags*> mMsgTags;
uint32_t mMsgUniqueId;
uint32_t mMsgUniqueId;
// used delete msgSrcIds after config save
std::map<uint32_t, RsMsgSrcId*> mSrcIds;
// used delete msgSrcIds after config save
std::map<uint32_t, RsMsgSrcId*> mSrcIds;
// save the parent of the messages in draft for replied and forwarded
std::map<uint32_t, RsMsgParentId*> mParentId;
// save the parent of the messages in draft for replied and forwarded
std::map<uint32_t, RsMsgParentId*> mParentId;
std::string config_dir;
std::string config_dir;
bool mDistantMessagingEnabled ;
bool mDistantMessagingEnabled ;
};
#endif // MESSAGE_SERVICE_HEADER

4
libretroshare/src/util/rsdir.cc
View File

@ -294,7 +294,7 @@ bool RsDirUtil::copyFile(const std::string& source,const std::string& dest)
}
bool RsDirUtil::checkFile(const std::string& filename,bool disallow_empty_file)
bool RsDirUtil::checkFile(const std::string& filename,uint64_t& file_size,bool disallow_empty_file)
{
int val;
mode_t st_mode;
@ -327,6 +327,8 @@ bool RsDirUtil::checkFile(const std::string& filename,bool disallow_empty_file)
return false;
}
file_size = buf.st_size ;
if(disallow_empty_file && buf.st_size == 0)
return false ;

2
libretroshare/src/util/rsdir.h
View File

@ -85,7 +85,7 @@ int breakupDirList(const std::string& path, std::list<std::string> &subdirs
bool copyFile(const std::string& source,const std::string& dest);
bool fileExists(const std::string& file);
bool checkFile(const std::string& filename,bool disallow_empty_file = false);
bool checkFile(const std::string& filename,uint64_t& file_size,bool disallow_empty_file = false);
bool checkDirectory(const std::string& dir);
bool checkCreateDirectory(const std::string& dir);

23
retroshare-gui/src/gui/MessagesDialog.cpp
View File

@ -1114,19 +1114,28 @@ void MessagesDialog::insertMessages()
text.clear();
std::list<RsPeerId>::const_iterator pit;
for (pit = msgInfo.msgto.begin(); pit != msgInfo.msgto.end(); pit++)
for(std::list<RsPeerId>::const_iterator pit = msgInfo.rspeerid_msgto.begin(); pit != msgInfo.rspeerid_msgto.end(); pit++)
{
if (text.isEmpty() == false) {
if (!text.isEmpty())
text += ", ";
}
std::string peerName = rsPeers->getPeerName(*pit);
if (peerName.empty()) {
if (peerName.empty())
text += PeerDefs::rsid("", *pit);
} else {
else
text += QString::fromUtf8(peerName.c_str());
}
for(std::list<RsGxsId>::const_iterator pit = msgInfo.rsgxsid_msgto.begin(); pit != msgInfo.rsgxsid_msgto.end(); pit++)
{
if (!text.isEmpty())
text += ", ";
// We should improve this by showing the real names of each GXS id.
std::string peerName = "GXS_id("+(*pit).toStdString() + ")" ;
if (peerName.empty())
text += PeerDefs::rsid("", *pit);
else
text += QString::fromUtf8(peerName.c_str());
}
}
} else {
std::cerr << "MessagesDialog::insertMsgTxtAndFiles() Couldn't find Msg" << std::endl;

50
retroshare-gui/src/gui/NetworkDialog.cpp
View File

@ -221,7 +221,7 @@ void NetworkDialog::connectTreeWidgetCostumPopupMenu( QPoint /*point*/ )
contextMnu->addAction(QIcon(IMAGE_EXPORT), tr("Export my certificate..."), this, SLOT(on_actionExportKey_activated()));
contextMnu->addAction(QIcon(IMAGE_PEERDETAILS), tr("Peer details..."), this, SLOT(peerdetails()));
contextMnu->addAction(QIcon(IMAGE_MESSAGE), tr("Send Message"), this, SLOT(sendDistantMessage()));
//contextMnu->addAction(QIcon(IMAGE_MESSAGE), tr("Send Message"), this, SLOT(sendDistantMessage()));
contextMnu->addAction(QIcon(IMAGE_COPYLINK), tr("Copy RetroShare Link"), this, SLOT(copyLink()));
contextMnu->addSeparator() ;
contextMnu->addAction(QIcon(IMAGE_CLEAN_UNUSED), tr("Remove unused keys..."), this, SLOT(removeUnusedKeys()));
@ -352,30 +352,30 @@ void NetworkDialog::copyLink()
RSLinkClipboard::copyLinks(urls);
}
void NetworkDialog::sendDistantMessage()
{
QTreeWidgetItem *wi = getCurrentNeighbour();
if (wi == NULL) {
return;
}
MessageComposer *nMsgDialog = MessageComposer::newMsg();
if (nMsgDialog == NULL) {
return;
}
DistantMsgPeerId pid ;
RsPgpId mGpgId(wi->text(COLUMN_PEERID).toStdString()) ;
if(rsMsgs->getDistantMessagePeerId(mGpgId,pid))
{
nMsgDialog->addRecipient(MessageComposer::TO, pid, mGpgId);
nMsgDialog->show();
nMsgDialog->activateWindow();
}
/* window will destroy itself! */
}
//void NetworkDialog::sendDistantMessage()
//{
// QTreeWidgetItem *wi = getCurrentNeighbour();
// if (wi == NULL) {
// return;
// }
//
// MessageComposer *nMsgDialog = MessageComposer::newMsg();
// if (nMsgDialog == NULL) {
// return;
// }
//
// DistantMsgPeerId pid ;
// RsPgpId mGpgId(wi->text(COLUMN_PEERID).toStdString()) ;
//
// if(rsMsgs->getDistantMessagePeerId(mGpgId,pid))
// {
// nMsgDialog->addRecipient(MessageComposer::TO, pid, mGpgId);
// nMsgDialog->show();
// nMsgDialog->activateWindow();
// }
//
// /* window will destroy itself! */
//}
void NetworkDialog::updateDisplay()
{

2
retroshare-gui/src/gui/NetworkDialog.h
View File

@ -72,7 +72,7 @@ private slots:
// void deleteCert() ;
void peerdetails();
void copyLink();
void sendDistantMessage();
// void sendDistantMessage();
/** Create the context popup menu and it's submenus */
void connectTreeWidgetCostumPopupMenu( QPoint point );
//void unvalidGPGKeyWidgetCostumPopupMenu( QPoint point );

26
retroshare-gui/src/gui/RetroShareLink.cpp
View File

@ -565,7 +565,23 @@ bool RetroShareLink::createMessage(const RsPeerId& peerId, const QString& subjec
return valid();
}
bool RetroShareLink::createMessage(const RsGxsId& peerId, const QString& subject)
{
clear();
_hash = QString::fromStdString(peerId.toStdString());
//PeerDefs::rsidFromId(peerId, &_name);
_name = QString::fromStdString("GXS_id("+peerId.toStdString()+")") ;
// do something better here!!
_subject = subject;
_type = TYPE_MESSAGE;
check();
return valid();
}
void RetroShareLink::clear()
{
_valid = false;
@ -1507,14 +1523,15 @@ static void processList(const QStringList &list, const QString &textSingular, co
{
if (detail.accept_connection || RsPeerId(detail.id) == rsPeers->getOwnId() || RsPgpId(detail.gpg_id) == rsPeers->getGPGOwnId()) {
MessageComposer *msg = MessageComposer::newMsg();
msg->addRecipient(MessageComposer::TO, detail.id, false);
msg->addRecipient(MessageComposer::TO, detail.id);
if (link.subject().isEmpty() == false) {
msg->setTitleText(link.subject());
}
msg->show();
messageStarted.append(PeerDefs::nameWithLocation(detail));
}
else if(rsMsgs->getDistantMessagePeerId(detail.gpg_id,dm_pid))
}
#ifdef SUSPENDED
else if(rsMsgs->getDistantMessagePeerId(detail.gpg_id,dm_pid))
{
MessageComposer *msg = MessageComposer::newMsg();
msg->addRecipient(MessageComposer::TO, dm_pid,detail.gpg_id) ;
@ -1525,7 +1542,8 @@ static void processList(const QStringList &list, const QString &textSingular, co
msg->show();
messageStarted.append(PeerDefs::nameWithLocation(detail));
}
}
#endif
else
{
messageReceipientNotAccepted.append(PeerDefs::nameWithLocation(detail));

4
retroshare-gui/src/gui/RetroShareLink.h
View File

@ -35,6 +35,7 @@
#include <stdint.h>
#include <retroshare/rstypes.h>
#include <retroshare/rsgxsifacetypes.h>
#include <QString>
#include <QVector>
@ -79,7 +80,8 @@ class RetroShareLink
bool createForum(const std::string& id, const std::string& msgId);
bool createChannel(const std::string& id, const std::string& msgId);
bool createSearch(const QString& keywords);
bool createMessage(const RsPeerId& peerId, const QString& subject);
bool createMessage(const RsPeerId &peerId, const QString& subject);
bool createMessage(const RsGxsId &peerId, const QString& subject);
bool createCertificate(const RsPeerId &ssl_id) ;
bool createPrivateChatInvite(time_t time_stamp,const QString& gpg_id,const QString& encrypted_chat_info) ;
bool createPublicMsgInvite(time_t time_stamp,const QString& pgp_id,const QString& hash) ;

2
retroshare-gui/src/gui/common/FriendList.cpp
View File

@ -1312,7 +1312,7 @@ void FriendList::msgfriend()
std::string id = getRsId(peer);
MessageComposer::msgFriend(RsPeerId(id), (peer->type() == TYPE_GROUP));
MessageComposer::msgFriend(RsPeerId(id)) ;
}
void FriendList::recommendfriend()

21
retroshare-gui/src/gui/common/FriendSelectionDialog.cpp
View File

@ -46,6 +46,27 @@ std::list<RsPeerId> FriendSelectionDialog::selectFriends_SSL(QWidget *parent,con
return sids ;
}
std::list<RsGxsId> FriendSelectionDialog::selectFriends_GXS(QWidget *parent,const QString& caption,const QString& header_text,
FriendSelectionWidget::Modus modus,
FriendSelectionWidget::ShowTypes show_type,
const std::list<RsGxsId>& pre_selected_ids)
{
std::list<std::string> psids ;
for(std::list<RsGxsId>::const_iterator it(pre_selected_ids.begin());it!=pre_selected_ids.end();++it)
psids.push_back( (*it).toStdString() ) ;
FriendSelectionDialog dialog(parent,header_text,modus,show_type,FriendSelectionWidget::IDTYPE_SSL,psids) ;
dialog.setWindowTitle(caption) ;
if(QDialog::Rejected == dialog.exec())
return std::list<RsGxsId>() ;
std::list<RsGxsId> sids ;
dialog.friends_widget->selectedIds<RsGxsId,FriendSelectionWidget::IDTYPE_GXS>(sids,false) ;
return sids ;
}
FriendSelectionDialog::FriendSelectionDialog(QWidget *parent,const QString& header_text,
FriendSelectionWidget::Modus modus,
FriendSelectionWidget::ShowTypes show_type,

9
retroshare-gui/src/gui/common/FriendSelectionDialog.h
View File

@ -2,6 +2,7 @@
#include <QDialog>
#include <retroshare/rstypes.h>
#include <retroshare/rsidentity.h>
#include <gui/common/FriendSelectionWidget.h>
class FriendSelectionDialog : public QDialog
@ -9,13 +10,19 @@ class FriendSelectionDialog : public QDialog
public:
static std::list<RsPgpId> selectFriends_PGP(QWidget *parent,const QString& caption,const QString& header_string,
FriendSelectionWidget::Modus modus = FriendSelectionWidget::MODUS_MULTI,
FriendSelectionWidget::ShowTypes = FriendSelectionWidget::SHOW_GROUP | FriendSelectionWidget::SHOW_SSL,
FriendSelectionWidget::ShowTypes = FriendSelectionWidget::SHOW_GROUP,
const std::list<RsPgpId>& pre_selected_ids = std::list<RsPgpId>()) ;
static std::list<RsPeerId> selectFriends_SSL(QWidget *parent,const QString& caption,const QString& header_string,
FriendSelectionWidget::Modus modus = FriendSelectionWidget::MODUS_MULTI,
FriendSelectionWidget::ShowTypes = FriendSelectionWidget::SHOW_GROUP | FriendSelectionWidget::SHOW_SSL,
const std::list<RsPeerId>& pre_selected_ids = std::list<RsPeerId>()) ;
static std::list<RsGxsId> selectFriends_GXS(QWidget *parent,const QString& caption,const QString& header_string,
FriendSelectionWidget::Modus modus = FriendSelectionWidget::MODUS_MULTI,
FriendSelectionWidget::ShowTypes = FriendSelectionWidget::SHOW_GROUP | FriendSelectionWidget::SHOW_GXS,
const std::list<RsGxsId>& pre_selected_ids = std::list<RsGxsId>()) ;
private:
virtual ~FriendSelectionDialog() ;
FriendSelectionDialog(QWidget *parent,const QString& header_string,FriendSelectionWidget::Modus modus,FriendSelectionWidget::ShowTypes show_type,

128
retroshare-gui/src/gui/common/FriendSelectionWidget.cpp
View File

@ -41,6 +41,8 @@
#define COLUMN_DATA 0
#define COLUMN_COUNT 1
#define IDDIALOG_IDLIST 1
#define ROLE_ID Qt::UserRole
#define ROLE_SORT Qt::UserRole + 1
@ -73,9 +75,8 @@ static void setSelected(FriendSelectionWidget::Modus modus, QTreeWidgetItem *ite
}
}
FriendSelectionWidget::FriendSelectionWidget(QWidget *parent) :
QWidget(parent),
ui(new Ui::FriendSelectionWidget)
FriendSelectionWidget::FriendSelectionWidget(QWidget *parent)
: RsGxsUpdateBroadcastPage(rsIdentity,parent), ui(new Ui::FriendSelectionWidget)
{
ui->setupUi(this);
@ -87,6 +88,8 @@ FriendSelectionWidget::FriendSelectionWidget(QWidget *parent) :
mInSslItemChanged = false;
mInFillList = false;
mIdQueue = new TokenQueue(rsIdentity->getTokenService(), this);
connect(ui->friendList, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(contextMenuRequested(QPoint)));
connect(ui->friendList, SIGNAL(itemDoubleClicked(QTreeWidgetItem*,int)), this, SLOT(itemDoubleClicked(QTreeWidgetItem*,int)));
connect(ui->friendList, SIGNAL(itemChanged(QTreeWidgetItem*,int)), this, SLOT(itemChanged(QTreeWidgetItem*,int)));
@ -228,6 +231,34 @@ void FriendSelectionWidget::fillList()
secured_fillList() ;
}
void FriendSelectionWidget::loadRequest(const TokenQueue */*queue*/, const TokenRequest &req)
{
// store all IDs locally, and call fillList() ;
uint32_t token = req.mToken ;
RsGxsIdGroup data;
std::vector<RsGxsIdGroup> datavector;
std::vector<RsGxsIdGroup>::iterator vit;
if (!rsIdentity->getGroupData(token, datavector))
{
std::cerr << "FriendSelectionWidget::loadRequest() ERROR. Cannot load data from rsIdentity." << std::endl;
return ;
}
gxsIds.clear() ;
for(uint32_t i=0;i<datavector.size();++i)
{
gxsIds.push_back(datavector[i].mMeta.mGroupId) ;
std::cerr << " got ID = " << datavector[i].mMeta.mGroupId << std::endl;
}
std::cerr << "Got all " << datavector.size() << " ids from rsIdentity. Calling update of list." << std::endl;
fillList() ;
}
void FriendSelectionWidget::secured_fillList()
{
mInFillList = true;
@ -248,6 +279,10 @@ void FriendSelectionWidget::secured_fillList()
selectedIds<RsPgpId,IDTYPE_GPG>(gpgIdsSelected,true);
}
std::list<RsGxsId> gxsIdsSelected;
if (mShowTypes & SHOW_GXS)
selectedIds<RsGxsId,IDTYPE_GXS>(gxsIdsSelected,true);
// remove old items
ui->friendList->clear();
@ -282,9 +317,11 @@ void FriendSelectionWidget::secured_fillList()
while (true) {
QTreeWidgetItem *groupItem = NULL;
QTreeWidgetItem *gpgItem = NULL;
RsGroupInfo *groupInfo = NULL;
QTreeWidgetItem *gxsItem = NULL;
RsGroupInfo *groupInfo = NULL;
if ((mShowTypes & SHOW_GROUP) && groupIt != groupInfoList.end()) {
if ((mShowTypes & SHOW_GROUP) && groupIt != groupInfoList.end())
{
groupInfo = &(*groupIt);
if (groupInfo->peerIds.size() == 0) {
@ -323,7 +360,8 @@ void FriendSelectionWidget::secured_fillList()
}
}
if (mShowTypes & (SHOW_GPG | SHOW_NON_FRIEND_GPG)) {
if (mShowTypes & (SHOW_GPG | SHOW_NON_FRIEND_GPG))
{
// iterate through gpg ids
for (gpgIt = gpgIds.begin(); gpgIt != gpgIds.end(); gpgIt++) {
if (groupInfo) {
@ -422,7 +460,9 @@ void FriendSelectionWidget::secured_fillList()
setSelected(mListModus, gpgItem, true);
}
}
} else {
}
else
{
// iterate through ssl ids
for (sslIt = sslIds.begin(); sslIt != sslIds.end(); sslIt++) {
RsPeerDetails detail;
@ -470,6 +510,47 @@ void FriendSelectionWidget::secured_fillList()
}
}
if(mShowTypes & SHOW_GXS)
{
// iterate through gpg ids
for (std::vector<RsGxsGroupId>::const_iterator gxsIt = gxsIds.begin(); gxsIt != gxsIds.end(); gxsIt++)
{
// we fill the not assigned gpg ids
if (std::find(filledIds.begin(), filledIds.end(), (*gxsIt).toStdString()) != filledIds.end())
continue;
// add equal too, its no problem
filledIds.push_back((*gxsIt).toStdString());
RsIdentityDetails detail;
if (!rsIdentity->getIdDetails(RsGxsId(*gxsIt), detail))
continue; /* BAD */
// make a widget per friend
gxsItem = new RSTreeWidgetItem(mCompareRole, IDTYPE_GXS);
QString name = QString::fromUtf8(detail.mNickname.c_str());
gxsItem->setText(COLUMN_NAME, name + " ("+QString::fromStdString( (*gxsIt).toStdString() )+")");
gxsItem->setTextColor(COLUMN_NAME, textColorOnline());
gxsItem->setFlags(Qt::ItemIsUserCheckable | gxsItem->flags());
gxsItem->setIcon(COLUMN_NAME, QIcon(StatusDefs::imageUser(RS_STATUS_ONLINE)));
gxsItem->setData(COLUMN_DATA, ROLE_ID, QString::fromStdString(detail.mId.toStdString()));
gxsItem->setData(COLUMN_DATA, ROLE_SORT, "2 " + name);
if (mListModus == MODUS_CHECK)
gxsItem->setCheckState(0, Qt::Unchecked);
ui->friendList->addTopLevelItem(gxsItem);
gxsItem->setExpanded(true);
emit itemAdded(IDTYPE_GXS, QString::fromStdString(detail.mId.toStdString()), gxsItem);
if (std::find(gxsIdsSelected.begin(), gxsIdsSelected.end(), detail.mId) != gxsIdsSelected.end())
setSelected(mListModus, gxsItem, true);
}
}
if (groupIt != groupInfoList.end()) {
groupIt++;
} else {
@ -488,6 +569,29 @@ void FriendSelectionWidget::secured_fillList()
emit contentChanged();
}
void FriendSelectionWidget::updateDisplay(bool)
{
requestGXSIdList() ;
}
void FriendSelectionWidget::requestGXSIdList()
{
if (!mIdQueue)
return;
//mStateHelper->setLoading(IDDIALOG_IDLIST, true);
//mStateHelper->setLoading(IDDIALOG_IDDETAILS, true);
//mStateHelper->setLoading(IDDIALOG_REPLIST, true);
mIdQueue->cancelActiveRequestTokens(IDDIALOG_IDLIST);
RsTokReqOptions opts;
opts.mReqType = GXS_REQUEST_TYPE_GROUP_DATA;
uint32_t token;
mIdQueue->requestGroupInfo(token, RS_TOKREQ_ANSTYPE_DATA, opts, IDDIALOG_IDLIST);
}
void FriendSelectionWidget::groupsChanged(int /*type*/)
{
@ -657,7 +761,8 @@ void FriendSelectionWidget::itemChanged(QTreeWidgetItem *item, int column)
}
break;
case IDTYPE_GPG:
{
case IDTYPE_GXS:
{
if (mInGpgItemChanged) {
break;
}
@ -790,7 +895,9 @@ void FriendSelectionWidget::selectedIds(IdType idType, std::list<std::string> &i
}
break;
case IDTYPE_GPG:
if (idType == IDTYPE_GPG) {
case IDTYPE_GXS:
if (idType == IDTYPE_GPG || idType == IDTYPE_GXS)
{
if (isSelected(mListModus, item)) {
id = idFromItem(item);
} else {
@ -858,7 +965,8 @@ void FriendSelectionWidget::setSelectedIds(IdType idType, const std::list<std::s
case IDTYPE_GROUP:
case IDTYPE_GPG:
case IDTYPE_SSL:
if (idType == itemType) {
case IDTYPE_GXS:
if (idType == itemType) {
if (std::find(ids.begin(), ids.end(), id) != ids.end()) {
setSelected(mListModus, item, true);
break;

17
retroshare-gui/src/gui/common/FriendSelectionWidget.h
View File

@ -26,6 +26,9 @@
#include <QWidget>
#include <QDialog>
#include <gui/gxs/RsGxsUpdateBroadcastPage.h>
#include "util/TokenQueue.h"
namespace Ui {
class FriendSelectionWidget;
}
@ -33,7 +36,7 @@ class FriendSelectionWidget;
class QTreeWidgetItem;
class RSTreeWidgetItemCompareRole;
class FriendSelectionWidget : public QWidget
class FriendSelectionWidget : public RsGxsUpdateBroadcastPage, public TokenResponse
{
Q_OBJECT
@ -45,7 +48,8 @@ public:
IDTYPE_NONE,
IDTYPE_GROUP,
IDTYPE_SSL,
IDTYPE_GPG
IDTYPE_GPG,
IDTYPE_GXS
};
enum Modus
@ -61,6 +65,7 @@ public:
SHOW_GPG = 2,
SHOW_SSL = 4,
SHOW_NON_FRIEND_GPG = 8,
SHOW_GXS =16
};
Q_DECLARE_FLAGS(ShowTypes, ShowType)
@ -107,6 +112,9 @@ public:
protected:
void changeEvent(QEvent *e);
virtual void loadRequest(const TokenQueue *queue,const TokenRequest& req);
virtual void updateDisplay(bool complete);
signals:
void itemAdded(int idType, const QString &id, QTreeWidgetItem *item);
void contentChanged();
@ -132,6 +140,8 @@ private:
void selectedIds(IdType idType, std::list<std::string> &ids, bool onlyDirectSelected);
void setSelectedIds(IdType idType, const std::list<std::string> &ids, bool add);
void requestGXSIdList() ;
bool mStarted;
RSTreeWidgetItemCompareRole *mCompareRole;
Modus mListModus;
@ -147,6 +157,9 @@ private:
Ui::FriendSelectionWidget *ui;
friend class FriendSelectionDialog ;
std::vector<RsGxsGroupId> gxsIds ;
TokenQueue *mIdQueue ;
};
Q_DECLARE_OPERATORS_FOR_FLAGS(FriendSelectionWidget::ShowTypes)

61
retroshare-gui/src/gui/common/PeerDefs.cpp
View File

@ -22,6 +22,7 @@
#include <QCoreApplication>
#include <retroshare/rspeers.h>
#include <retroshare/rsmsgs.h>
#include <retroshare/rsidentity.h>
#include "PeerDefs.h"
@ -42,6 +43,14 @@ const QString PeerDefs::rsid(const std::string &name, const RsPgpId &id)
return QString::fromUtf8(name.c_str()) + "@" + QString::fromStdString(id.toStdString());
}
const QString PeerDefs::rsid(const std::string &name, const RsGxsId &id)
{
if (name.empty()) {
return qApp->translate("PeerDefs", "Unknown") + "@" + QString::fromStdString(id.toStdString());
}
return QString::fromUtf8(name.c_str()) + "@" + QString::fromStdString(id.toStdString());
}
const QString PeerDefs::rsid(const std::string &name, const RsPeerId &id)
{
if (name.empty()) {
@ -60,32 +69,42 @@ const QString PeerDefs::rsidFromId(const RsPeerId &id, QString *name /* = NULL*/
QString rsid;
std::string peerName = rsPeers->getPeerName(id);
DistantMsgPeerId pid ;
DistantMsgPeerId pid ;
if(!peerName.empty())
{
if(!peerName.empty())
{
rsid = PeerDefs::rsid(peerName, id);
if (name) {
if (name)
*name = QString::fromUtf8(peerName.c_str());
}
}
else if(rsMsgs->getDistantMessagePeerId(rsPeers->getGPGOwnId(),pid) && pid == id)
{
// not a real peer. Try from hash for distant messages
peerName = rsPeers->getGPGName(rsPeers->getGPGOwnId()) ;
rsid = PeerDefs::rsid(peerName, rsPeers->getGPGOwnId());
if(name)
*name = QString::fromUtf8(peerName.c_str());
}
else
{
rsid = PeerDefs::rsid("", id);
if (name)
*name = qApp->translate("PeerDefs", "Unknown");
}
return rsid ;
}
std::list<RsGxsId> gxs_ids ;
rsIdentity->getOwnIds(gxs_ids) ;
for(std::list<RsGxsId>::const_iterator it(gxs_ids.begin());it!=gxs_ids.end();++it)
if(RsPeerId(*it) == id)
{
// not a real peer. Try from hash for distant messages
RsIdentityDetails details ;
if(!rsIdentity->getIdDetails(*it,details))
continue ;
peerName = details.mNickname ;
rsid = PeerDefs::rsid(peerName, *it);
if(name)
*name = QString::fromUtf8(peerName.c_str());
}
rsid = PeerDefs::rsid("", id);
if (name)
*name = qApp->translate("PeerDefs", "Unknown");
return rsid;
}

2
retroshare-gui/src/gui/common/PeerDefs.h
View File

@ -24,6 +24,7 @@
#define _PEERDEFS_H
#include <QString>
#include <retroshare/rsidentity.h>
class RsPeerDetails;
@ -35,6 +36,7 @@ public:
static const QString rsid(const RsPeerDetails &details);
static const QString rsid(const std::string &name, const RsPeerId &id);
static const QString rsid(const std::string &name, const RsPgpId &id);
static const QString rsid(const std::string &name, const RsGxsId &id);
static const QString rsidFromId(const RsPgpId &id, QString *name = NULL);
static const QString rsidFromId(const RsPeerId &id, QString *name = NULL);
static RsPeerId idFromRsid(const QString &rsid, bool check);

4
retroshare-gui/src/gui/feeds/ChatMsgItem.cpp
View File

@ -197,7 +197,7 @@ void ChatMsgItem::sendMsg()
return;
}
nMsgDialog->addRecipient(MessageComposer::TO, mPeerId, false);
nMsgDialog->addRecipient(MessageComposer::TO, mPeerId);
nMsgDialog->show();
nMsgDialog->activateWindow();
@ -245,7 +245,7 @@ void ChatMsgItem::sendMessage()
mi.title = tr("Quick Message").toUtf8().constData();
mi.msg = quickmsgText->toHtml().toUtf8().constData();
mi.msgto.push_back(mPeerId);
mi.rspeerid_msgto.push_back(mPeerId);
rsMsgs->MessageSend(mi);

8
retroshare-gui/src/gui/feeds/MsgItem.cpp
View File

@ -81,16 +81,16 @@ void MsgItem::updateItemStatic()
return;
/* get peer Id */
mPeerId = mi.srcId;
mPeerId = mi.rspeerid_srcId;
avatar->setId(mPeerId);
QString title;
QString srcName;
if ((mi.msgflags & RS_MSG_SYSTEM) && mi.srcId == rsPeers->getOwnId()) {
if ((mi.msgflags & RS_MSG_SYSTEM) && mi.rspeerid_srcId == rsPeers->getOwnId()) {
srcName = "RetroShare";
} else {
srcName = QString::fromUtf8(rsPeers->getPeerName(mi.srcId).c_str());
srcName = QString::fromUtf8(rsPeers->getPeerName(mi.rspeerid_srcId).c_str());
}
timestampLabel->setText(DateTime::formatLongDateTime(mi.ts));
@ -138,7 +138,7 @@ void MsgItem::updateItemStatic()
for(it = mi.files.begin(); it != mi.files.end(); it++)
{
/* add file */
SubFileItem *fi = new SubFileItem(it->hash, it->fname, it->path, it->size, SFI_STATE_REMOTE, mi.srcId);
SubFileItem *fi = new SubFileItem(it->hash, it->fname, it->path, it->size, SFI_STATE_REMOTE, mi.rspeerid_srcId);
mFileItems.push_back(fi);
QLayout *layout = expandFrame->layout();

4
retroshare-gui/src/gui/feeds/PeerItem.cpp
View File

@ -275,7 +275,7 @@ void PeerItem::sendMsg()
return;
}
nMsgDialog->addRecipient(MessageComposer::TO, mPeerId, false);
nMsgDialog->addRecipient(MessageComposer::TO, mPeerId);
nMsgDialog->show();
nMsgDialog->activateWindow();
@ -314,7 +314,7 @@ void PeerItem::sendMessage()
mi.title = tr("Quick Message").toUtf8().constData();
mi.msg = quickmsgText->toHtml().toUtf8().constData();
mi.msgto.push_back(mPeerId);
mi.rspeerid_msgto.push_back(mPeerId);
rsMsgs->MessageSend(mi);

5
retroshare-gui/src/gui/feeds/SecurityItem.cpp
View File

@ -375,6 +375,8 @@ void SecurityItem::sendMsg()
std::cerr << std::endl;
#endif
std::cerr << __PRETTY_FUNCTION__ << ": suspended for now." << std::endl;
#ifdef SUSPENDED
MessageComposer *nMsgDialog = MessageComposer::newMsg();
if (nMsgDialog == NULL) {
return;
@ -389,7 +391,8 @@ void SecurityItem::sendMsg()
nMsgDialog->activateWindow();
}
/* window will destroy itself! */
/* window will destroy itself! */
#endif
}
void SecurityItem::openChat()

614
retroshare-gui/src/gui/msgs/MessageComposer.cpp
View File

@ -44,6 +44,7 @@
#include <retroshare/rsmsgs.h>
#include <retroshare/rsstatus.h>
#include <retroshare/rsfiles.h>
#include <retroshare/rsidentity.h>
#include "gui/notifyqt.h"
#include "gui/common/RSTreeWidgetItem.h"
@ -73,9 +74,6 @@
#define COLOR_CONNECT Qt::blue
#define TYPE_GROUP 0
#define TYPE_SSL 1
#define COLUMN_RECIPIENT_TYPE 0
#define COLUMN_RECIPIENT_ICON 1
#define COLUMN_RECIPIENT_NAME 2
@ -83,7 +81,7 @@
#define COLUMN_RECIPIENT_DATA COLUMN_RECIPIENT_ICON // the column with a QTableWidgetItem
#define ROLE_RECIPIENT_ID Qt::UserRole
#define ROLE_RECIPIENT_GROUP Qt::UserRole + 1
#define ROLE_RECIPIENT_TYPE Qt::UserRole + 1
#define COLUMN_FILE_CHECKED 0
#define COLUMN_FILE_NAME 0
@ -215,7 +213,8 @@ MessageComposer::MessageComposer(QWidget *parent, Qt::WindowFlags flags)
ui.friendSelectionWidget->setModus(FriendSelectionWidget::MODUS_MULTI);
ui.friendSelectionWidget->setShowType(FriendSelectionWidget::SHOW_GROUP
| FriendSelectionWidget::SHOW_SSL
| (ui.onlyTrustedKeys->isChecked()? FriendSelectionWidget::SHOW_NONE : FriendSelectionWidget::SHOW_NON_FRIEND_GPG));
| FriendSelectionWidget::SHOW_GXS);
//| (ui.onlyTrustedKeys->isChecked()? FriendSelectionWidget::SHOW_NONE : FriendSelectionWidget::SHOW_NON_FRIEND_GPG));
//ui.friendSelectionWidget->setShowType(FriendSelectionWidget::SHOW_GROUP | FriendSelectionWidget::SHOW_SSL );
ui.friendSelectionWidget->start();
@ -359,29 +358,27 @@ void MessageComposer::processSettings(bool bLoad)
Settings->endGroup();
}
/*static*/ void MessageComposer::msgDistantPeer(const RsPgpId& pgp_id)
/*static*/ void MessageComposer::msgGxsIdentity(const RsGxsId &id)
{
// std::cerr << "MessageComposer::msgfriend()" << std::endl;
/* create a message */
DistantMsgPeerId pid ;
rsMsgs->getDistantMessagePeerId(pgp_id,pid) ;
MessageComposer *pMsgDialog = MessageComposer::newMsg();
if (pMsgDialog == NULL)
if (pMsgDialog == NULL)
return;
pMsgDialog->addRecipient(TO,pid,pgp_id) ;
pMsgDialog->addRecipient(TO, id);
pMsgDialog->show();
/* window will destroy itself! */
}
/*static*/ void MessageComposer::msgFriend(const RsPeerId &id, bool group)
/*static*/ void MessageComposer::msgFriend(const RsPeerId &id)
{
// std::cerr << "MessageComposer::msgfriend()" << std::endl;
// std::cerr << "MessageComposer::msgfriend()" << std::endl;
/* create a message */
@ -390,25 +387,10 @@ void MessageComposer::processSettings(bool bLoad)
return;
}
if (group) {
pMsgDialog->addRecipient(TO, id, true);
} else {
RsPeerDetails detail;
if (rsPeers->getPeerDetails(id, detail) && detail.accept_connection)
RsPeerDetails detail;
if (rsPeers->getPeerDetails(id, detail) && detail.accept_connection)
{
// if (detail.isOnlyGPGdetail) {
// //put all sslChilds in message list
// std::list<RsPeerId> sslIds;
// rsPeers->getAssociatedSSLIds(id, sslIds);
//
// std::list<RsPeerId>::const_iterator it;
// for (it = sslIds.begin(); it != sslIds.end(); it++) {
// pMsgDialog->addRecipient(TO, *it, false);
// }
// } else {
pMsgDialog->addRecipient(TO, detail.id, false);
// }
}
pMsgDialog->addRecipient(TO, id);
}
pMsgDialog->show();
@ -460,7 +442,7 @@ void MessageComposer::recommendFriend(const std::list <RsPeerId> &sslIds, const
composer->msgFlags |= RS_MSG_FRIEND_RECOMMENDATION;
if (!to.isNull()) {
composer->addRecipient(TO, to, false);
composer->addRecipient(TO, to);
}
RsPgpId ownPgpId = rsPeers->getGPGOwnId();
RetroShareLink link;
@ -479,7 +461,7 @@ void MessageComposer::recommendFriend(const std::list <RsPeerId> &sslIds, const
if (*peerIt == to) {
continue;
}
composer->addRecipient(CC, *peerIt, false);
composer->addRecipient(CC, *peerIt);
}
if (autoSend) {
@ -683,15 +665,16 @@ void MessageComposer::peerStatusChanged(const QString& peer_id, int status)
for (row = 0; row < rowCount; row++) {
enumType type;
destinationType dtype ;
std::string id;
bool group;
if (getRecipientFromRow(row, type, id, group) && !id.empty() ) {
if (group == false && QString::fromStdString(id) == peer_id) {
if (getRecipientFromRow(row, type,dtype, id) && !id.empty() ) {
if (dtype == PEER_TYPE_SSL && QString::fromStdString(id) == peer_id)
{
QTableWidgetItem *item = ui.recipientWidget->item(row, COLUMN_RECIPIENT_ICON);
if (item) {
if (item)
item->setIcon(QIcon(StatusDefs::imageUser(status)));
}
}
}
}
@ -892,38 +875,34 @@ MessageComposer *MessageComposer::newMsg(const std::string &msgId /* = ""*/)
std::list<std::string> groupIds;
std::list<std::string>::iterator groupIt;
std::list<RsPeerId>::iterator it;
// calculateGroupsOfSslIds(groupInfoList, msgInfo.msgto, groupIds);
// for (groupIt = groupIds.begin(); groupIt != groupIds.end(); groupIt++ ) {
// msgComposer->addRecipient(MessageComposer::TO, *groupIt, true) ;
// }
for (it = msgInfo.msgto.begin(); it != msgInfo.msgto.end(); it++ ) {
msgComposer->addRecipient(MessageComposer::TO, *it, false) ;
}
// calculateGroupsOfSslIds(groupInfoList, msgInfo.msgto, groupIds);
// for (groupIt = groupIds.begin(); groupIt != groupIds.end(); groupIt++ ) {
// msgComposer->addRecipient(MessageComposer::TO, *groupIt, true) ;
// }
// calculateGroupsOfSslIds(groupInfoList, msgInfo.msgcc, groupIds);
// for (groupIt = groupIds.begin(); groupIt != groupIds.end(); groupIt++ ) {
// msgComposer->addRecipient(MessageComposer::CC, *groupIt, true) ;
// }
for (it = msgInfo.msgcc.begin(); it != msgInfo.msgcc.end(); it++ ) {
msgComposer->addRecipient(MessageComposer::CC, *it, false) ;
}
// calculateGroupsOfSslIds(groupInfoList, msgInfo.msgcc, groupIds);
// for (groupIt = groupIds.begin(); groupIt != groupIds.end(); groupIt++ ) {
// msgComposer->addRecipient(MessageComposer::CC, *groupIt, true) ;
// }
// calculateGroupsOfSslIds(groupInfoList, msgInfo.msgbcc, groupIds);
// for (groupIt = groupIds.begin(); groupIt != groupIds.end(); groupIt++ ) {
// msgComposer->addRecipient(MessageComposer::BCC, *groupIt, true) ;
// }
for (it = msgInfo.msgbcc.begin(); it != msgInfo.msgbcc.end(); it++ ) {
msgComposer->addRecipient(MessageComposer::BCC, *it, false) ;
}
// calculateGroupsOfSslIds(groupInfoList, msgInfo.msgbcc, groupIds);
// for (groupIt = groupIds.begin(); groupIt != groupIds.end(); groupIt++ ) {
// msgComposer->addRecipient(MessageComposer::BCC, *groupIt, true) ;
// }
for (std::list<RsPeerId>::const_iterator it = msgInfo.rspeerid_msgto.begin(); it != msgInfo.rspeerid_msgto.end(); it++ ) msgComposer->addRecipient(MessageComposer::TO, *it) ;
for (std::list<RsPeerId>::const_iterator it = msgInfo.rspeerid_msgcc.begin(); it != msgInfo.rspeerid_msgcc.end(); it++ ) msgComposer->addRecipient(MessageComposer::CC, *it) ;
for (std::list<RsPeerId>::const_iterator it = msgInfo.rspeerid_msgbcc.begin(); it != msgInfo.rspeerid_msgbcc.end(); it++ ) msgComposer->addRecipient(MessageComposer::BCC, *it) ;
for (std::list<RsGxsId>::const_iterator it = msgInfo.rsgxsid_msgto.begin(); it != msgInfo.rsgxsid_msgto.end(); it++ ) msgComposer->addRecipient(MessageComposer::TO, *it) ;
for (std::list<RsGxsId>::const_iterator it = msgInfo.rsgxsid_msgcc.begin(); it != msgInfo.rsgxsid_msgcc.end(); it++ ) msgComposer->addRecipient(MessageComposer::CC, *it) ;
for (std::list<RsGxsId>::const_iterator it = msgInfo.rsgxsid_msgbcc.begin(); it != msgInfo.rsgxsid_msgbcc.end(); it++ ) msgComposer->addRecipient(MessageComposer::BCC, *it) ;
MsgTagInfo tagInfo;
rsMsgs->getMessageTag(msgId, tagInfo);
msgComposer->m_tagIds = tagInfo.tagIds;
msgComposer->showTagLabels();
msgComposer->ui.msgText->document()->setModified(false);
}
@ -935,29 +914,44 @@ MessageComposer *MessageComposer::newMsg(const std::string &msgId /* = ""*/)
QString MessageComposer::buildReplyHeader(const MessageInfo &msgInfo)
{
RetroShareLink link;
link.createMessage(msgInfo.srcId, "");
link.createMessage(msgInfo.rspeerid_srcId, "");
QString from = link.toHtml();
QString to;
std::list<RsPeerId>::const_iterator it;
for (it = msgInfo.msgto.begin(); it != msgInfo.msgto.end(); it++) {
if (link.createMessage(*it, "")) {
if (!to.isEmpty()) {
for ( std::list<RsPeerId>::const_iterator it = msgInfo.rspeerid_msgto.begin(); it != msgInfo.rspeerid_msgto.end(); it++)
if (link.createMessage(*it, ""))
{
if (!to.isEmpty())
to += ", ";
}
to += link.toHtml();
}
}
for ( std::list<RsGxsId>::const_iterator it = msgInfo.rsgxsid_msgto.begin(); it != msgInfo.rsgxsid_msgto.end(); it++)
if (link.createMessage(*it, ""))
{
if (!to.isEmpty())
to += ", ";
to += link.toHtml();
}
QString cc;
for (it = msgInfo.msgcc.begin(); it != msgInfo.msgcc.end(); it++) {
for (std::list<RsPeerId>::const_iterator it = msgInfo.rspeerid_msgcc.begin(); it != msgInfo.rspeerid_msgcc.end(); it++)
if (link.createMessage(*it, "")) {
if (!cc.isEmpty()) {
cc += ", ";
}
cc += link.toHtml();
}
}
for (std::list<RsGxsId>::const_iterator it = msgInfo.rsgxsid_msgcc.begin(); it != msgInfo.rsgxsid_msgcc.end(); it++)
if (link.createMessage(*it, "")) {
if (!cc.isEmpty()) {
cc += ", ";
}
cc += link.toHtml();
}
QString header = QString("<span>-----%1-----").arg(tr("Original Message"));
header += QString("<br><font size='3'><strong>%1: </strong>%2</font><br>").arg(tr("From"), from);
@ -1030,22 +1024,28 @@ MessageComposer *MessageComposer::replyMsg(const std::string &msgId, bool all)
msgComposer->setTitleText(QString::fromUtf8(msgInfo.title.c_str()), REPLY);
msgComposer->setQuotedMsg(QString::fromUtf8(msgInfo.msg.c_str()), buildReplyHeader(msgInfo));
msgComposer->addRecipient(MessageComposer::TO, msgInfo.srcId, false);
if(!msgInfo.rspeerid_srcId.isNull()) msgComposer->addRecipient(MessageComposer::TO, msgInfo.rspeerid_srcId);
if(!msgInfo.rsgxsid_srcId.isNull()) msgComposer->addRecipient(MessageComposer::TO, msgInfo.rsgxsid_srcId);
if (all) {
if (all)
{
RsPeerId ownId = rsPeers->getOwnId();
for (std::list<RsPeerId>::iterator tli = msgInfo.msgto.begin(); tli != msgInfo.msgto.end(); tli++) {
if (ownId != *tli) {
msgComposer->addRecipient(MessageComposer::TO, *tli, false) ;
}
}
for (std::list<RsPeerId>::iterator tli = msgInfo.rspeerid_msgto.begin(); tli != msgInfo.rspeerid_msgto.end(); tli++)
if (ownId != *tli)
msgComposer->addRecipient(MessageComposer::TO, *tli) ;
for (std::list<RsPeerId>::iterator tli = msgInfo.msgcc.begin(); tli != msgInfo.msgcc.end(); tli++) {
if (ownId != *tli) {
msgComposer->addRecipient(MessageComposer::TO, *tli, false) ;
}
}
for (std::list<RsPeerId>::iterator tli = msgInfo.rspeerid_msgcc.begin(); tli != msgInfo.rspeerid_msgcc.end(); tli++)
if (ownId != *tli)
msgComposer->addRecipient(MessageComposer::TO, *tli) ;
for (std::list<RsGxsId>::iterator tli = msgInfo.rsgxsid_msgto.begin(); tli != msgInfo.rsgxsid_msgto.end(); tli++)
//if (ownId != *tli)
msgComposer->addRecipient(MessageComposer::TO, *tli) ;
for (std::list<RsGxsId>::iterator tli = msgInfo.rsgxsid_msgcc.begin(); tli != msgInfo.rsgxsid_msgcc.end(); tli++)
//if (ownId != *tli)
msgComposer->addRecipient(MessageComposer::TO, *tli) ;
}
// needed to send system flags with reply
@ -1139,9 +1139,10 @@ void MessageComposer::sendMessage()
}
}
template<class T> void addUnique(std::list<T>& lst,const T& t) { if(std::find(lst.begin(),lst.end(),t) == lst.end()) lst.push_back(t) ; }
bool MessageComposer::sendMessage_internal(bool bDraftbox)
{
#ifdef SUSPENDED
/* construct a message */
MessageInfo mi;
@ -1165,7 +1166,7 @@ bool MessageComposer::sendMessage_internal(bool bDraftbox)
for (int i = 0; i < filesCount; i++) {
QTreeWidgetItem *item = ui.msgFileList->topLevelItem(i);
if (item->checkState(COLUMN_FILE_CHECKED)) {
std::string hash = item->text(COLUMN_FILE_HASH).toStdString();
RsFileHash hash ( item->text(COLUMN_FILE_HASH).toStdString() );
for(std::list<FileInfo>::iterator it = _recList.begin(); it != _recList.end(); it++) {
if (it->hash == hash) {
mi.files.push_back(*it);
@ -1185,79 +1186,89 @@ bool MessageComposer::sendMessage_internal(bool bDraftbox)
int rowCount = ui.recipientWidget->rowCount();
int row;
for (row = 0; row < rowCount; row++) {
for (row = 0; row < rowCount; row++)
{
enumType type;
destinationType dtype ;
std::string id;
bool group;
if (getRecipientFromRow(row, type, id, group) && !id.empty())
{
if (group) {
RsGroupInfo groupInfo;
if (rsPeers->getGroupInfo(id, groupInfo) == false) {
// group not found
continue;
}
if (!getRecipientFromRow(row, type,dtype, id) || id.empty())
continue ;
std::list<std::string>::const_iterator groupIt;
for (groupIt = groupInfo.peerIds.begin(); groupIt != groupInfo.peerIds.end(); groupIt++) {
std::list<RsPeerId> sslIds;
rsPeers->getAssociatedSSLIds(*groupIt, sslIds);
switch(dtype)
{
case PEER_TYPE_GROUP: {
RsGroupInfo groupInfo;
if (rsPeers->getGroupInfo(id, groupInfo) == false) {
// group not found
continue;
}
std::list<RsPeerId>::const_iterator sslIt;
for (sslIt = sslIds.begin(); sslIt != sslIds.end(); sslIt++) {
if (std::find(peers.begin(), peers.end(), *sslIt) == peers.end()) {
// no friend
continue;
}
std::list<RsPgpId>::const_iterator groupIt;
for (groupIt = groupInfo.peerIds.begin(); groupIt != groupInfo.peerIds.end(); groupIt++) {
std::list<RsPeerId> sslIds;
rsPeers->getAssociatedSSLIds(*groupIt, sslIds);
switch (type) {
case TO:
if (std::find(mi.msgto.begin(), mi.msgto.end(), *sslIt) == mi.msgto.end()) {
mi.msgto.push_back(*sslIt);
}
break;
case CC:
if (std::find(mi.msgcc.begin(), mi.msgcc.end(), *sslIt) == mi.msgcc.end()) {
mi.msgcc.push_back(*sslIt);
}
break;
case BCC:
if (std::find(mi.msgbcc.begin(), mi.msgbcc.end(), *sslIt) == mi.msgbcc.end()) {
mi.msgbcc.push_back(*sslIt);
}
break;
}
std::list<RsPeerId>::const_iterator sslIt;
for (sslIt = sslIds.begin(); sslIt != sslIds.end(); sslIt++) {
if (std::find(peers.begin(), peers.end(), *sslIt) == peers.end()) {
// no friend
continue;
}
}
} else {
if (_distant_peers.find(id)==_distant_peers.end() && std::find(peers.begin(), peers.end(), id) == peers.end()) {
// no friend
continue;
}
switch (type) {
case TO:
if (std::find(mi.msgto.begin(), mi.msgto.end(), id) == mi.msgto.end()) {
mi.msgto.push_back(id);
}
switch (type)
{
case TO: addUnique(mi.rspeerid_msgto,*sslIt);
break;
case CC:
if (std::find(mi.msgcc.begin(), mi.msgcc.end(), id) == mi.msgcc.end()) {
mi.msgcc.push_back(id);
}
case CC: addUnique(mi.rspeerid_msgcc,*sslIt);
break;
case BCC:
if (std::find(mi.msgbcc.begin(), mi.msgbcc.end(), id) == mi.msgbcc.end()) {
mi.msgbcc.push_back(id);
}
case BCC:addUnique(mi.rspeerid_msgbcc,*sslIt);
break;
}
}
}
}
break ;
case PEER_TYPE_SSL:
{
RsPeerId pid(id) ;
switch (type)
{
case TO: addUnique(mi.rspeerid_msgto,pid);
break ;
case CC: addUnique(mi.rspeerid_msgcc,pid);
break ;
case BCC:addUnique(mi.rspeerid_msgbcc,pid);
break ;
}
}
break ;
case PEER_TYPE_GXS:
{
RsGxsId gid(id) ;
switch (type)
{
case TO: addUnique(mi.rsgxsid_msgto,gid) ;
break ;
case CC: addUnique(mi.rsgxsid_msgcc,gid) ;
break ;
case BCC:addUnique(mi.rsgxsid_msgbcc,gid) ;
break ;
}
}
break ;
default:
std::cerr << __PRETTY_FUNCTION__ << ": Unhandled desitnation type " << dtype << std::endl;
break ;
}
}
if (bDraftbox) {
if (bDraftbox)
{
mi.msgId = m_sDraftMsgId;
rsMsgs->MessageToDraft(mi, m_msgParentId);
@ -1275,16 +1286,18 @@ bool MessageComposer::sendMessage_internal(bool bDraftbox)
rsMsgs->MessageForwarded(m_sDraftMsgId, true);
break;
}
} else {
}
else
{
/* check for the recipient */
if (mi.msgto.empty()) {
if (mi.rspeerid_msgto.empty() && mi.rspeerid_msgcc.empty() && mi.rspeerid_msgbcc.empty()
&& mi.rsgxsid_msgto.empty() && mi.rsgxsid_msgcc.empty() && mi.rsgxsid_msgbcc.empty())
{
QMessageBox::warning(this, tr("RetroShare"), tr("Please insert at least one recipient."), QMessageBox::Ok);
return false; // Don't send with no recipient
}
mi.encryption_keys = _distant_peers ;
if(ui.signMessage_CB->isChecked())
mi.msgflags |= RS_MSG_SIGNED ;
if(ui.signMessage_CB->isChecked())
mi.msgflags |= RS_MSG_SIGNED ;
if (rsMsgs->MessageSend(mi) == false) {
return false;
@ -1324,7 +1337,7 @@ bool MessageComposer::sendMessage_internal(bool bDraftbox)
}
}
ui.msgText->document()->setModified(false);
#endif
return true;
}
@ -1350,10 +1363,10 @@ void MessageComposer::addEmptyRecipient()
}
}
setRecipientToRow(lastRow, TO,"", false);
setRecipientToRow(lastRow, TO,PEER_TYPE_SSL,"");
}
bool MessageComposer::getRecipientFromRow(int row, enumType &type, std::string &id, bool &group)
bool MessageComposer::getRecipientFromRow(int row, enumType &type, destinationType& dest_type,std::string &id)
{
if (row >= ui.recipientWidget->rowCount()) {
return false;
@ -1366,12 +1379,12 @@ bool MessageComposer::getRecipientFromRow(int row, enumType &type, std::string &
type = (enumType) cb->itemData(cb->currentIndex(), Qt::UserRole).toInt();
id = ui.recipientWidget->item(row, COLUMN_RECIPIENT_DATA)->data(ROLE_RECIPIENT_ID).toString().toStdString();
group = ui.recipientWidget->item(row, COLUMN_RECIPIENT_DATA)->data(ROLE_RECIPIENT_GROUP).toBool();
dest_type = (destinationType)ui.recipientWidget->item(row, COLUMN_RECIPIENT_DATA)->data(ROLE_RECIPIENT_TYPE).toInt();
return true;
}
void MessageComposer::setRecipientToRow(int row, enumType type, const std::string& id, bool group)
void MessageComposer::setRecipientToRow(int row, enumType type, destinationType dest_type, const std::string &id)
{
if (row + 1 > ui.recipientWidget->rowCount()) {
ui.recipientWidget->setRowCount(row + 1);
@ -1407,9 +1420,10 @@ void MessageComposer::setRecipientToRow(int row, enumType type, const std::strin
QIcon icon;
QString name;
if (!id.empty())
{
if (group)
{
{
switch(dest_type)
{
case PEER_TYPE_GROUP: {
icon = QIcon(IMAGE_GROUP16);
RsGroupInfo groupInfo;
@ -1418,54 +1432,61 @@ void MessageComposer::setRecipientToRow(int row, enumType type, const std::strin
} else {
name = tr("Unknown");
}
}
else
{
RsPeerDetails details;
}
break ;
if(_distant_peers.find(RsPeerId(id)) != _distant_peers.end())
{
if(!rsPeers->getGPGDetails(_distant_peers[RsPeerId(id)], details))
{
std::cerr << "Can't get peer details from " << _distant_peers[RsPeerId(id)] << std::endl;
return ;
}
case PEER_TYPE_GXS: {
name = tr("Distant peer (name: %2, PGP key: %1)").arg(QString::fromStdString(_distant_peers[RsPeerId(id)].toStdString())).arg(QString::fromStdString(details.name)) ;
icon = QIcon(StatusDefs::imageUser(RS_STATUS_ONLINE));
}
else if(rsPeers->getPeerDetails(RsPeerId(id), details) && (!details.isOnlyGPGdetail))
{
name = PeerDefs::nameWithLocation(details);
RsIdentityDetails detail;
RsGxsId gid(id) ;
StatusInfo peerStatusInfo;
// No check of return value. Non existing status info is handled as offline.
rsStatus->getStatus(RsPeerId(id), peerStatusInfo);
if(!rsIdentity->getIdDetails(gid, detail))
{
std::cerr << "Can't get peer details from " << gid << std::endl;
return ;
}
icon = QIcon(StatusDefs::imageUser(peerStatusInfo.status));
}
else
{
icon = QIcon(StatusDefs::imageUser(RS_STATUS_OFFLINE));
name = tr("Unknown friend");
}
}
name = tr("Distant peer (name: %2, PGP key: %1)").arg(QString::fromStdString(gid.toStdString())).arg(QString::fromStdString(detail.mNickname)) ;
icon = QIcon(StatusDefs::imageUser(RS_STATUS_ONLINE));
}
break ;
case PEER_TYPE_SSL: {
RsPeerDetails details ;
if(!rsPeers->getPeerDetails(RsPeerId(id), details))
{
std::cerr << "Can't get peer details from " << id << std::endl;
return ;
}
name = PeerDefs::nameWithLocation(details);
StatusInfo peerStatusInfo;
// No check of return value. Non existing status info is handled as offline.
rsStatus->getStatus(RsPeerId(id), peerStatusInfo);
icon = QIcon(StatusDefs::imageUser(peerStatusInfo.status));
}
break ;
default:
std::cerr << __PRETTY_FUNCTION__ << ": Unhandled type " << dest_type << std::endl;
return ;
}
}
comboBox->setCurrentIndex(comboBox->findData(type, Qt::UserRole));
lineEdit->setText(name);
if (id.empty()) {
if (id.empty())
lineEdit->setStyleSheet(QString(STYLE_FAIL).arg(lineEdit->objectName()));
} else {
else
lineEdit->setStyleSheet(QString(STYLE_NORMAL).arg(lineEdit->objectName()));
}
QTableWidgetItem *item = new QTableWidgetItem(icon, "", 0);
item->setFlags(Qt::NoItemFlags);
ui.recipientWidget->setItem(row, COLUMN_RECIPIENT_ICON, item);
ui.recipientWidget->item(row, COLUMN_RECIPIENT_DATA)->setData(ROLE_RECIPIENT_ID, QString::fromStdString(id));
ui.recipientWidget->item(row, COLUMN_RECIPIENT_DATA)->setData(ROLE_RECIPIENT_GROUP, group);
ui.recipientWidget->item(row, COLUMN_RECIPIENT_DATA)->setData(ROLE_RECIPIENT_TYPE, dest_type);
addEmptyRecipient();
}
@ -1532,13 +1553,14 @@ void MessageComposer::editingRecipientFinished()
enumType type;
std::string id; // dummy
bool group; // dummy
getRecipientFromRow(row, type, id, group);
destinationType dtype ;
getRecipientFromRow(row, type, dtype, id);
QString text = lineEdit->text();
if (text.isEmpty()) {
setRecipientToRow(row, type, "", false);
setRecipientToRow(row, type,PEER_TYPE_SSL, "");
return;
}
@ -1556,7 +1578,7 @@ void MessageComposer::editingRecipientFinished()
QString name = PeerDefs::nameWithLocation(details);
if (text.compare(name, Qt::CaseSensitive) == 0) {
// found it
setRecipientToRow(row, type, details.id.toStdString(), false);
setRecipientToRow(row, type, PEER_TYPE_SSL, details.id.toStdString());
return;
}
}
@ -1570,100 +1592,94 @@ void MessageComposer::editingRecipientFinished()
QString groupName = GroupDefs::name(*groupIt);
if (text.compare(groupName, Qt::CaseSensitive) == 0) {
// found it
setRecipientToRow(row, type, groupIt->id, true);
setRecipientToRow(row, type, PEER_TYPE_GROUP, groupIt->id);
return;
}
}
setRecipientToRow(row, type, "", false);
setRecipientToRow(row, type, PEER_TYPE_SSL, "");
lineEdit->setStyleSheet(QString(STYLE_FAIL).arg(lineEdit->objectName()));
lineEdit->setText(text);
}
void MessageComposer::addRecipient(enumType type, const DistantMsgPeerId& pid,const RsPgpId& pgp_id)
void MessageComposer::addRecipient(enumType type, const RsPeerId& pid)
{
_distant_peers[pid] = pgp_id ;
int rowCount = ui.recipientWidget->rowCount();
int row;
for (row = 0; row < rowCount; row++)
{
enumType rowType;
std::string rowId;
destinationType dtype ;
int rowCount = ui.recipientWidget->rowCount();
int row;
for (row = 0; row < rowCount; row++)
{
enumType rowType;
std::string rowId;
bool rowGroup;
if (getRecipientFromRow(row, rowType, dtype, rowId))
{
if (rowId.empty()) // use row
break;
if (getRecipientFromRow(row, rowType, rowId, rowGroup) == true)
{
if (rowId.empty()) // use row
break;
if (rowId == pid.toStdString() && rowType == type) // existing row
break;
}
else // use row
break;
}
setRecipientToRow(row, type, pid.toStdString(), false);
}
void MessageComposer::addRecipient(enumType type, const RsPeerId &id, bool group)
{
std::list<RsPeerId> sslIds;
if (group) {
sslIds.push_back(id);
} else {
// check for gpg id or ssl id
RsPeerDetails detail;
if (!rsPeers->getPeerDetails(id, detail)) {
return;
if (RsPeerId(rowId) == pid && rowType == type) // existing row
break;
}
// if (detail.isOnlyGPGdetail)
// {
// if( (!rsPeers->getAssociatedSSLIds(id, sslIds)) || sslIds.empty())
// {
// std::string hash ;
// if(rsMsgs->getDistantMessageHash(id,hash))
// addRecipient(type, hash, id);
// else
// {
// QMessageBox::warning(this,tr("PGP key unknown"),tr("You dont have the PGP key of the message sender. So you cannot respond!"),QMessageBox::Ok) ;
// return;
// }
// }
// }
// else {
sslIds.push_back(id);
// }
else // use row
break;
}
std::list<RsPeerId>::const_iterator sslIt;
for (sslIt = sslIds.begin(); sslIt != sslIds.end(); sslIt++) {
// search existing or empty row
int rowCount = ui.recipientWidget->rowCount();
int row;
for (row = 0; row < rowCount; row++) {
enumType rowType;
std::string rowId;
bool rowGroup;
if (getRecipientFromRow(row, rowType, rowId, rowGroup) == true) {
if (rowId.empty()) {
// use row
break;
}
setRecipientToRow(row, type, PEER_TYPE_SSL,pid.toStdString());
}
void MessageComposer::addRecipient(enumType type, const RsGxsId& gxs_id)
{
_distant_peers.insert(gxs_id) ;
if (rowId == (*sslIt).toStdString() && rowType == type && group == rowGroup) {
// existing row
break;
}
} else {
int rowCount = ui.recipientWidget->rowCount();
int row;
for (row = 0; row < rowCount; row++)
{
enumType rowType;
std::string rowId;
destinationType dtype ;
if (getRecipientFromRow(row, rowType, dtype, rowId))
{
if (rowId.empty()) // use row
break;
if (RsGxsId(rowId) == gxs_id && rowType == type) // existing row
break;
}
else // use row
break;
}
setRecipientToRow(row, type, PEER_TYPE_GXS,gxs_id.toStdString());
}
void MessageComposer::addRecipient(enumType type, const std::string& id)
{
// search existing or empty row
int rowCount = ui.recipientWidget->rowCount();
int row;
for (row = 0; row < rowCount; row++) {
enumType rowType;
std::string rowId;
destinationType dtype ;
bool rowGroup;
if (getRecipientFromRow(row, rowType, dtype,rowId))
{
if (rowId.empty()) {
// use row
break;
}
}
setRecipientToRow(row, type, (*sslIt).toStdString(), group);
if (rowId == id && rowType == type && dtype == PEER_TYPE_GROUP) {
// existing row
break;
}
} else {
// use row
break;
}
}
setRecipientToRow(row, type, PEER_TYPE_GROUP, id);
}
void MessageComposer::setupFileActions()
@ -2299,36 +2315,32 @@ void MessageComposer::fileHashingFinished(QList<HashedFile> hashedFiles)
void MessageComposer::addContact(enumType type)
{
// std::list<std::string> ids;
// ui.friendSelectionWidget->selectedIds<std::string,FriendSelectionWidget::IDTYPE_GROUP>(ids,false);
//
// std::list<std::string>::iterator idIt;
// for (idIt = ids.begin(); idIt != ids.end(); idIt++) {
// addRecipient(type, *idIt, true);
// }
// std::list<std::string> ids;
// ui.friendSelectionWidget->selectedIds<std::string,FriendSelectionWidget::IDTYPE_GROUP>(ids,false);
//
// std::list<std::string>::iterator idIt;
// for (idIt = ids.begin(); idIt != ids.end(); idIt++) {
// addRecipient(type, *idIt, true);
// }
std::list<RsPeerId> ids ;
ui.friendSelectionWidget->selectedIds<RsPeerId,FriendSelectionWidget::IDTYPE_SSL>(ids, true);
for (std::list<RsPeerId>::const_iterator idIt = ids.begin(); idIt != ids.end(); idIt++) {
addRecipient(type, *idIt, false);
}
std::list<RsPeerId> ids ;
ui.friendSelectionWidget->selectedIds<RsPeerId,FriendSelectionWidget::IDTYPE_SSL>(ids, true);
for (std::list<RsPeerId>::const_iterator idIt = ids.begin(); idIt != ids.end(); idIt++) {
addRecipient(type, *idIt);
}
std::list<RsPgpId> id2 ;
ui.friendSelectionWidget->selectedIds<RsPgpId,FriendSelectionWidget::IDTYPE_GPG>(id2, true);
for (std::list<RsPgpId>::const_iterator idIt = id2.begin(); idIt != id2.end(); idIt++)
{
DistantMsgPeerId pid ;
if(rsMsgs->getDistantMessagePeerId(*idIt,pid))
addRecipient(type, pid, *idIt);
}
std::list<RsGxsId> id2 ;
ui.friendSelectionWidget->selectedIds<RsGxsId,FriendSelectionWidget::IDTYPE_GXS>(id2, true);
for (std::list<RsGxsId>::const_iterator idIt = id2.begin(); idIt != id2.end(); idIt++)
addRecipient(type, *idIt);
}
void MessageComposer::toggleShowNonFriend(bool bValue)
{
ui.friendSelectionWidget->setShowType(FriendSelectionWidget::SHOW_GROUP
| FriendSelectionWidget::SHOW_SSL
| (bValue?FriendSelectionWidget::SHOW_NONE : FriendSelectionWidget::SHOW_NON_FRIEND_GPG));
| (bValue?FriendSelectionWidget::SHOW_NONE : FriendSelectionWidget::SHOW_GXS));
Settings->setValueToGroup("MessageComposer", "ShowOnlyTrustedKeys", bValue);
}
@ -2349,21 +2361,23 @@ void MessageComposer::addBcc()
void MessageComposer::addRecommend()
{
std::list<RsPeerId> sslIds;
ui.friendSelectionWidget->selectedIds<RsPeerId,FriendSelectionWidget::IDTYPE_SSL>(sslIds, false);
std::list<RsPeerId> sslIds;
ui.friendSelectionWidget->selectedIds<RsPeerId,FriendSelectionWidget::IDTYPE_SSL>(sslIds, false);
if (sslIds.empty()) {
return;
}
std::list<RsGxsId> gxsIds ;
ui.friendSelectionWidget->selectedIds<RsGxsId,FriendSelectionWidget::IDTYPE_GXS>(gxsIds, true);
std::list <RsPeerId>::iterator it;
for (it = sslIds.begin(); it != sslIds.end(); it++) {
addRecipient(CC, *it, false);
}
if (sslIds.empty() && gxsIds.empty())
return;
QString text = buildRecommendHtml(sslIds);
ui.msgText->textCursor().insertHtml(text);
ui.msgText->setFocus(Qt::OtherFocusReason);
for(std::list <RsPeerId>::iterator it = sslIds.begin(); it != sslIds.end(); it++)
addRecipient(CC, *it);
for (std::list<RsGxsId>::const_iterator it = gxsIds.begin(); it != gxsIds.end(); it++)
addRecipient(TO, *it);
QString text = buildRecommendHtml(sslIds);
ui.msgText->textCursor().insertHtml(text);
ui.msgText->setFocus(Qt::OtherFocusReason);
}
void MessageComposer::friendDetails()

18
retroshare-gui/src/gui/msgs/MessageComposer.h
View File

@ -42,6 +42,7 @@ class MessageComposer : public QMainWindow
public:
enum enumType { TO, CC, BCC };
enum enumMessageType { NORMAL, REPLY, FORWARD };
enum destinationType { PEER_TYPE_SSL, PEER_TYPE_GROUP, PEER_TYPE_GXS };
public:
/** Default Constructor */
@ -49,9 +50,9 @@ public:
MessageComposer(QWidget *parent = 0, Qt::WindowFlags flags = 0);
~MessageComposer();
static void msgFriend(const RsPeerId &id, bool group);
//static void msgDistantPeer(const std::string& hash,const std::string& pgp_id) ;
static void msgDistantPeer(const RsPgpId& pgp_id) ;
static void msgFriend(const RsPeerId &id);
static void msgGxsIdentity(const RsGxsId& gxs_id) ;
static void msgGroup(const std::string& group_id) ;
static QString recommendMessage();
static void recommendFriend(const std::list <RsPeerId> &sslIds, const RsPeerId &to = RsPeerId(), const QString &msg = "", bool autoSend = false);
@ -68,8 +69,9 @@ public:
void setTitleText(const QString &title, enumMessageType type = NORMAL);
void setQuotedMsg(const QString &msg, const QString &header);
void setMsgText(const QString &msg, bool asHtml = false);
void addRecipient(enumType type, const RsPeerId &id, bool group);
void addRecipient(enumType type, const DistantMsgPeerId &pid, const RsPgpId &pgp_id) ;
void addRecipient(enumType type, const RsPeerId &id);
void addRecipient(enumType type, const RsGxsId &gxs_id) ;
void addRecipient(enumType type, const std::string& group_id) ;
public slots:
/* actions to take.... */
@ -174,8 +176,8 @@ private:
void calculateTitle();
void addEmptyRecipient();
bool getRecipientFromRow(int row, enumType &type, std::string &id, bool &group);
void setRecipientToRow(int row, enumType type, const std::string &id, bool group);
bool getRecipientFromRow(int row, enumType &type, destinationType& dest_type, std::string &id);
void setRecipientToRow(int row, enumType type, destinationType dest_type,const std::string &id);
void clearTagLabels();
void showTagLabels();
@ -221,7 +223,7 @@ private:
Ui::MessageComposer ui;
std::list<FileInfo> _recList ;
std::map<DistantMsgPeerId,RsPgpId> _distant_peers ; // pairs (hash,pgp_id)
std::set<RsGxsId> _distant_peers ; // we keep a list of them, in order to know which peer is a GXS id.
};
#endif

46
retroshare-gui/src/gui/msgs/MessageWidget.cpp
View File

@ -304,7 +304,7 @@ void MessageWidget::getcurrentrecommended()
}
std::list<RsPeerId> srcIds;
srcIds.push_back(msgInfo.srcId);
srcIds.push_back(msgInfo.rspeerid_srcId);
QModelIndexList list = ui.msgList->selectionModel()->selectedIndexes();
@ -353,7 +353,7 @@ void MessageWidget::getallrecommended()
for(it = recList.begin(); it != recList.end(); it++) {
std::cerr << "MessageWidget::getallrecommended() Calling File Request" << std::endl;
std::list<RsPeerId> srcIds;
srcIds.push_back(msgInfo.srcId);
srcIds.push_back(msgInfo.rspeerid_srcId);
rsFiles->FileRequest(it->fname, it->hash, it->size, "", RS_FILE_REQ_ANONYMOUS_ROUTING, srcIds);
}
}
@ -497,28 +497,23 @@ void MessageWidget::fill(const std::string &msgId)
ui.msgList->insertTopLevelItems(0, items);
/* iterate through the sources */
std::list<RsPeerId>::const_iterator pit;
RetroShareLink link;
QString text;
for(pit = msgInfo.msgto.begin(); pit != msgInfo.msgto.end(); pit++) {
if (link.createMessage(*pit, "")) {
text += link.toHtml() + " ";
}
}
for(std::list<RsPeerId>::const_iterator pit = msgInfo.rspeerid_msgto.begin(); pit != msgInfo.rspeerid_msgto.end(); pit++) if (link.createMessage(*pit, "")) text += link.toHtml() + " ";
for(std::list<RsGxsId >::const_iterator pit = msgInfo.rsgxsid_msgto.begin(); pit != msgInfo.rsgxsid_msgto.end(); pit++) if (link.createMessage(*pit, "")) text += link.toHtml() + " ";
ui.toText->setText(text);
if (msgInfo.msgcc.size() > 0) {
if (!msgInfo.rspeerid_msgcc.empty() || !msgInfo.rsgxsid_msgcc.empty())
{
ui.cclabel->setVisible(true);
ui.ccText->setVisible(true);
text.clear();
for(pit = msgInfo.msgcc.begin(); pit != msgInfo.msgcc.end(); pit++) {
if (link.createMessage(*pit, "")) {
text += link.toHtml() + " ";
}
}
for(std::list<RsPeerId>::const_iterator pit = msgInfo.rspeerid_msgcc.begin(); pit != msgInfo.rspeerid_msgcc.end(); pit++) if (link.createMessage(*pit, "")) text += link.toHtml() + " ";
for(std::list<RsGxsId>::const_iterator pit = msgInfo.rsgxsid_msgcc.begin(); pit != msgInfo.rsgxsid_msgcc.end(); pit++) if (link.createMessage(*pit, "")) text += link.toHtml() + " ";
ui.ccText->setText(text);
} else {
ui.cclabel->setVisible(false);
@ -526,16 +521,15 @@ void MessageWidget::fill(const std::string &msgId)
ui.ccText->clear();
}
if (msgInfo.msgbcc.size() > 0) {
ui.bcclabel->setVisible(true);
ui.bccText->setVisible(true);
if (!msgInfo.rspeerid_msgbcc.empty() || !msgInfo.rsgxsid_msgbcc.empty())
{
ui.bcclabel->setVisible(true);
ui.bccText->setVisible(true);
text.clear();
for(std::list<RsPeerId>::const_iterator pit = msgInfo.rspeerid_msgbcc.begin(); pit != msgInfo.rspeerid_msgbcc.end(); pit++) if (link.createMessage(*pit, "")) text += link.toHtml() + " ";
for(std::list<RsGxsId>::const_iterator pit = msgInfo.rsgxsid_msgbcc.begin(); pit != msgInfo.rsgxsid_msgbcc.end(); pit++) if (link.createMessage(*pit, "")) text += link.toHtml() + " ";
text.clear();
for(pit = msgInfo.msgbcc.begin(); pit != msgInfo.msgbcc.end(); pit++) {
if (link.createMessage(*pit, "")) {
text += link.toHtml() + " ";
}
}
ui.bccText->setText(text);
} else {
ui.bcclabel->setVisible(false);
@ -552,11 +546,11 @@ void MessageWidget::fill(const std::string &msgId)
// outgoing message are from me
srcId = ownId;
} else {
srcId = msgInfo.srcId;
srcId = msgInfo.rspeerid_srcId;
}
link.createMessage(srcId, "");
if ((msgInfo.msgflags & RS_MSG_SYSTEM) && msgInfo.srcId == ownId) {
if ((msgInfo.msgflags & RS_MSG_SYSTEM) && msgInfo.rspeerid_srcId == ownId) {
ui.fromText->setText("RetroShare");
} else {
ui.fromText->setText(link.toHtml());

250
retroshare-gui/src/gui/settings/GlobalRouterStatistics.cpp Normal file
View File

@ -0,0 +1,250 @@
/****************************************************************
* RetroShare is distributed under the following license:
*
* Copyright (C) 20011, RetroShare Team
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
****************************************************************/
#include <iostream>
#include <QTimer>
#include <QObject>
#include <QPainter>
#include <QStylePainter>
#include <QLayout>
#include <retroshare/rsgrouter.h>
#include <retroshare/rspeers.h>
#include "GlobalRouterStatistics.h"
#include "gui/settings/rsharesettings.h"
static const int MAX_TUNNEL_REQUESTS_DISPLAY = 10 ;
static QColor colorScale(float f)
{
if(f == 0)
return QColor::fromHsv(0,0,192) ;
else
return QColor::fromHsv((int)((1.0-f)*280),200,255) ;
}
GlobalRouterStatistics::GlobalRouterStatistics(QWidget *parent)
: RsAutoUpdatePage(2000,parent)
{
setupUi(this) ;
m_bProcessSettings = false;
_router_F->setWidget( _tst_CW = new GlobalRouterStatisticsWidget() ) ;
// load settings
processSettings(true);
}
GlobalRouterStatistics::~GlobalRouterStatistics()
{
// save settings
processSettings(false);
}
void GlobalRouterStatistics::processSettings(bool bLoad)
{
m_bProcessSettings = true;
Settings->beginGroup(QString("GlobalRouterStatistics"));
if (bLoad) {
// load settings
// state of splitter
//splitter->restoreState(Settings->value("Splitter").toByteArray());
} else {
// save settings
// state of splitter
//Settings->setValue("Splitter", splitter->saveState());
}
Settings->endGroup();
m_bProcessSettings = false;
}
void GlobalRouterStatistics::updateDisplay()
{
_tst_CW->updateContent() ;
}
QString GlobalRouterStatistics::getPeerName(const RsPeerId &peer_id)
{
static std::map<RsPeerId, QString> names ;
std::map<RsPeerId,QString>::const_iterator it = names.find(peer_id) ;
if( it != names.end())
return it->second ;
else
{
RsPeerDetails detail ;
if(!rsPeers->getPeerDetails(peer_id,detail))
return tr("Unknown Peer");
return (names[peer_id] = QString::fromUtf8(detail.name.c_str())) ;
}
}
GlobalRouterStatisticsWidget::GlobalRouterStatisticsWidget(QWidget *parent)
: QWidget(parent)
{
maxWidth = 400 ;
maxHeight = 0 ;
}
void GlobalRouterStatisticsWidget::updateContent()
{
std::vector<RsGRouter::GRouterRoutingCacheInfo> cache_infos ;
RsGRouter::GRouterRoutingMatrixInfo matrix_info ;
rsGRouter->getRoutingCacheInfo(cache_infos) ;
rsGRouter->getRoutingMatrixInfo(matrix_info) ;
// What do we need to draw?
//
// Routing matrix
// Key [][][][][][][][][][]
//
// -> each [] shows a square (one per friend location) that is the routing probabilities for all connected friends
// computed using the "computeRoutingProbabilitites()" method.
//
// Own key ids
// key service id description
//
// Data items
// Msg id Local origin Destination Time Status
//
static const int cellx = 6 ;
static const int celly = 10+4 ;
QPixmap tmppixmap(maxWidth, maxHeight);
tmppixmap.fill(this, 0, 0);
setFixedHeight(maxHeight);
QPainter painter(&tmppixmap);
painter.initFrom(this);
painter.setPen(QColor::fromRgb(0,0,0)) ;
maxHeight = 500 ;
// std::cerr << "Drawing into pixmap of size " << maxWidth << "x" << maxHeight << std::endl;
// draw...
int ox=5,oy=5 ;
painter.drawText(ox,oy+celly,tr("Pending packets")+":" + QString::number(cache_infos.size())) ; oy += celly*2 ;
for(uint32_t i=0;i<cache_infos.size();++i)
{
QString packet_string ;
packet_string += QString::number(cache_infos[i].mid,16) ;
packet_string += tr(" by ")+QString::fromStdString(cache_infos[i].local_origin.toStdString()) ;
packet_string += tr(" to ")+QString::fromStdString(cache_infos[i].destination.toStdString()) ;
packet_string += tr(" Status ")+QString::number(cache_infos[i].status) ;
painter.drawText(ox+2*cellx,oy+celly,packet_string ) ; oy += celly ;
}
oy += celly ;
painter.drawText(ox,oy+celly,tr("Managed keys")+":" + QString::number(matrix_info.published_keys.size())) ; oy += celly*2 ;
for(std::map<GRouterKeyId,RsGRouter::GRouterPublishedKeyInfo>::const_iterator it(matrix_info.published_keys.begin());it!=matrix_info.published_keys.end();++it)
{
QString packet_string ;
packet_string += QString::fromStdString(it->first.toStdString()) ;
packet_string += tr(" : Service ID = ")+QString::number(it->second.service_id,16) ;
packet_string += " \""+QString::fromUtf8(it->second.description_string.c_str()) + "\"" ;
painter.drawText(ox+2*cellx,oy+celly,packet_string ) ; oy += celly ;
}
oy += celly ;
QString prob_string ;
painter.drawText(ox+0*cellx,oy+celly,tr("Routing matrix (")) ;
// draw scale
for(int i=0;i<100;++i)
{
painter.setPen(colorScale(i/100.0)) ;
painter.drawLine(ox+120+i,oy+celly+2,ox+120+i,oy+2) ;
}
painter.setPen(QColor::fromRgb(0,0,0)) ;
painter.drawText(ox+230,oy+celly,")") ;
oy += celly ;
oy += celly ;
static const int MaxKeySize = 20 ;
for(std::map<GRouterKeyId,std::vector<float> >::const_iterator it(matrix_info.per_friend_probabilities.begin());it!=matrix_info.per_friend_probabilities.end();++it)
{
painter.drawText(ox+2*cellx,oy+celly,QString::fromStdString(it->first.toStdString())+" : ") ;
for(uint32_t i=0;i<matrix_info.friend_ids.size();++i)
painter.fillRect(ox+(MaxKeySize + i)*cellx+200,oy,cellx,celly,colorScale(it->second[i])) ;
oy += celly ;
}
oy += celly ;
oy += celly ;
// update the pixmap
//
pixmap = tmppixmap;
maxHeight = oy ;
}
QString GlobalRouterStatisticsWidget::speedString(float f)
{
if(f < 1.0f)
return QString("0 B/s") ;
if(f < 1024.0f)
return QString::number((int)f)+" B/s" ;
return QString::number(f/1024.0,'f',2) + " KB/s";
}
void GlobalRouterStatisticsWidget::paintEvent(QPaintEvent */*event*/)
{
QStylePainter(this).drawPixmap(0, 0, pixmap);
}
void GlobalRouterStatisticsWidget::resizeEvent(QResizeEvent *event)
{
QRect TaskGraphRect = geometry();
maxWidth = TaskGraphRect.width();
maxHeight = TaskGraphRect.height() ;
QWidget::resizeEvent(event);
updateContent();
}

71
retroshare-gui/src/gui/settings/GlobalRouterStatistics.h Normal file
View File

@ -0,0 +1,71 @@
/****************************************************************
* RetroShare is distributed under the following license:
*
* Copyright (C) 20011, RetroShare Team
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
****************************************************************/
#pragma once
#include <QPoint>
#include <retroshare/rsgrouter.h>
#include <retroshare/rstypes.h>
#include "RsAutoUpdatePage.h"
#include "ui_GlobalRouterStatistics.h"
class GlobalRouterStatisticsWidget ;
class GlobalRouterStatistics: public RsAutoUpdatePage, public Ui::GlobalRouterStatistics
{
Q_OBJECT
public:
GlobalRouterStatistics(QWidget *parent = NULL) ;
~GlobalRouterStatistics();
// Cache for peer names.
static QString getPeerName(const RsPeerId& peer_id) ;
private:
void processSettings(bool bLoad);
bool m_bProcessSettings;
virtual void updateDisplay() ;
GlobalRouterStatisticsWidget *_tst_CW ;
} ;
class GlobalRouterStatisticsWidget: public QWidget
{
Q_OBJECT
public:
GlobalRouterStatisticsWidget(QWidget *parent = NULL) ;
virtual void paintEvent(QPaintEvent *event) ;
virtual void resizeEvent(QResizeEvent *event);
void updateContent() ;
private:
static QString speedString(float f) ;
QPixmap pixmap ;
int maxWidth,maxHeight ;
};

55
retroshare-gui/src/gui/settings/GlobalRouterStatistics.ui Normal file
View File

@ -0,0 +1,55 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>GlobalRouterStatistics</class>
<widget class="QWidget" name="GlobalRouterStatistics">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>611</width>
<height>408</height>
</rect>
</property>
<property name="windowTitle">
<string>Router Statistics</string>
</property>
<property name="windowIcon">
<iconset resource="images.qrc">
<normaloff>:/images/rstray3.png</normaloff>:/images/rstray3.png</iconset>
</property>
<layout class="QGridLayout" name="gridLayout">
<item row="0" column="0">
<widget class="QSplitter" name="splitter">
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
<widget class="QScrollArea" name="_router_F">
<property name="frameShape">
<enum>QFrame::NoFrame</enum>
</property>
<property name="horizontalScrollBarPolicy">
<enum>Qt::ScrollBarAlwaysOff</enum>
</property>
<property name="widgetResizable">
<bool>true</bool>
</property>
<widget class="QWidget" name="scrollAreaWidgetContents">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>593</width>
<height>390</height>
</rect>
</property>
</widget>
</widget>
</widget>
</item>
</layout>
</widget>
<resources>
<include location="images.qrc"/>
</resources>
<connections/>
</ui>

10
retroshare-gui/src/gui/settings/ServerPage.cpp
View File

@ -22,6 +22,7 @@
#include "ServerPage.h"
#include <gui/FileTransfer/TurtleRouterDialog.h>
#include <gui/FileTransfer/TurtleRouterStatistics.h>
#include <gui/settings/GlobalRouterStatistics.h>
#include "rshare.h"
#include "rsharesettings.h"
@ -78,12 +79,13 @@ ServerPage::ServerPage(QWidget * parent, Qt::WindowFlags flags)
trs->setSizePolicy(QSizePolicy(QSizePolicy::MinimumExpanding,QSizePolicy::MinimumExpanding)) ;
ui.tabWidget->widget(2)->layout()->addWidget(trs) ;
ui.tabWidget->widget(2)->layout()->setContentsMargins(0,5,0,0) ;
QSpacerItem *verticalSpacer = new QSpacerItem(0,0,QSizePolicy::Expanding, QSizePolicy::Minimum);
ui.tabWidget->widget(2)->layout()->addItem(verticalSpacer) ;
ui.tabWidget->widget(2)->layout()->addItem( new QSpacerItem(0,0,QSizePolicy::Expanding, QSizePolicy::Minimum)) ;
ui.tabWidget->widget(2)->layout()->update() ;
GlobalRouterStatistics *grs = new GlobalRouterStatistics ;
grs->setSizePolicy(QSizePolicy(QSizePolicy::MinimumExpanding,QSizePolicy::MinimumExpanding)) ;
ui.tabWidget->addTab(grs,tr("Global routing")) ;
ui.torpage_incoming->setVisible(false);
/* Hide platform specific features */

5
retroshare-gui/src/retroshare-gui.pro
View File

@ -25,7 +25,7 @@ gxs {
CONFIG += gxsgui
# thewire is incomplete - dont enable
#CONFIG += thewire
#CONFIG += photoshare
CONFIG += photoshare
DEFINES += RS_ENABLE_GXS
}
@ -388,6 +388,7 @@ HEADERS += rshare.h \
gui/msgs/MessageUserNotify.h \
gui/images/retroshare_win.rc.h \
gui/settings/rsharesettings.h \
gui/settings/GlobalRouterStatistics.h \
gui/settings/RsharePeerSettings.h \
gui/settings/rsettings.h \
gui/settings/rsettingswin.h \
@ -567,6 +568,7 @@ FORMS += gui/StartDialog.ui \
gui/settings/ChatPage.ui \
gui/settings/RelayPage.ui \
gui/settings/ServicePermissionsPage.ui \
gui/settings/GlobalRouterStatistics.ui \
gui/settings/PluginItem.ui \
gui/toaster/MessageToaster.ui \
gui/toaster/OnlineToaster.ui \
@ -746,6 +748,7 @@ SOURCES += main.cpp \
gui/style/StyleDialog.cpp \
gui/settings/rsharesettings.cpp \
gui/settings/RsharePeerSettings.cpp \
gui/settings/GlobalRouterStatistics.cpp \
gui/settings/rsettings.cpp \
gui/settings/rsettingswin.cpp \
gui/settings/GeneralPage.cpp \