updated to upstream/master
@ -19,7 +19,7 @@ Compilation on Linux
|
||||
sudo zypper install gcc-c++ libqt4-devel libgnome-keyring-devel \
|
||||
glib2-devel speex-devel libssh-devel protobuf-devel libcurl-devel \
|
||||
libxml2-devel libxslt-devel sqlcipher-devel libmicrohttpd-devel \
|
||||
opencv-devel speexdsp-devel libupnp-devel
|
||||
opencv-devel speexdsp-devel libupnp-devel libavcodec-devel
|
||||
```
|
||||
* Arch Linux
|
||||
```bash
|
||||
|
24
TODO.txt
@ -6,31 +6,34 @@ Legend:
|
||||
[ ] pending
|
||||
[/] half-done, someone's on it
|
||||
[-] cancelled
|
||||
[?] needs discussion. Not sure we need this.
|
||||
[X] done
|
||||
|
||||
PS: no tabs in this file,thx ;-)
|
||||
|
||||
---------------------------------------- TODO for RC ---------------------------------------------
|
||||
|
||||
E [ ] Implement creation of a default (signed) gxs id in startup wizard. Needs to show to the user a proper separation between nodes (network layer) and GXS ids (service layer).
|
||||
E [ ] add tooltips in in permission matrix when hovering over the top most button/service name explain what the service does and the dependencies
|
||||
E [ ] finish pass of GXS network service
|
||||
|
||||
----------------------------------------- TODO list ----------------------------------------------
|
||||
|
||||
GUI
|
||||
E [X] add a "Contact" list to help selecting peers in People/FriendChooser/messages/etc.
|
||||
E [ ] Implement creation of a default (signed) gxs id in startup wizard. Needs to show to the
|
||||
user a proper separation between nodes (network layer) and GXS ids (service layer).
|
||||
E [ ] fix posted GUI. Needs to be more handy and more appealing.
|
||||
E [ ] add RS links for GXS identities, so that they can be transferred easily between nodes in forums, etc
|
||||
E [ ] enable people dialog
|
||||
M [ ] Personal Page (Profile Page for GXS ID Users,view latest Posts, public forum/channels,posted posts, comments in all areas, Reputation Infos, Popularity and more)
|
||||
E [ ] fix RSButtonOnText::eventFilter, and fix all places where RSButtonOnText gets deleted
|
||||
E [ ] find all places where the deprecated(in Qt5) Q_WS_WIN and other Q_WS* macros are
|
||||
used, and replace with something else
|
||||
E [ ] add tooltips in in permission matrix when hovering over the top most button/service name
|
||||
explain what the service does and the dependencies
|
||||
E [ ] find all places where the deprecated(in Qt5) Q_WS_WIN and other Q_WS* macros are used, and replace with something else
|
||||
E [ ] Make RS fully compatible with High DPI screens.
|
||||
M [ ] improve comments in channels. Comments should be more available, more visible, and easier to handle.
|
||||
E [ ] make GRouter statistics less CPU greedy
|
||||
M [ ] Merge the various help systems. there's 3 of them now. Lots of duplicate code, etc.
|
||||
M [ ] New and consistent icon set (Purplehaze420 said he would provide a consistent set of icons. Is that still alive?)
|
||||
M [ ] add in options->Network a way to select which network interface is used to talk (choice between "auto" or selected from a list)
|
||||
M [ ] add a RS link for encrypted messages (encrypt for multiple GXS ids at once). Messages will appear as a link when encrypted and
|
||||
M [?] add a RS link for encrypted messages (encrypt for multiple GXS ids at once). Messages will appear as a link when encrypted and
|
||||
be automatically decrypted when a suitable GXS id is available for it. Could be a way to securely post something in a public place.
|
||||
|
||||
File transfer (all 3 tasks are related)
|
||||
@ -38,9 +41,10 @@ File transfer (all 3 tasks are related)
|
||||
H [ ] implement a new file list management, with new info such as access time,total upload, popularity, etc
|
||||
H [ ] implement a new file list sharing service based on auto-sync system
|
||||
M [ ] get rid of the old cache system (remove CacheStrapper, CacheSource,etc)
|
||||
M [ ] implement end-to-end encryption using chacha20 and H(F), requesting file on H(H(F)). Make this optional and backward compatible.
|
||||
|
||||
DHT
|
||||
H [ ] improve DHT lookups to find masquerading peers using fake peers. First experiments (by cyril) do not prove very efficient.
|
||||
H [-] improve DHT lookups to find masquerading peers using fake peers. First experiments (by cyril) do not prove very efficient.
|
||||
|
||||
GXS
|
||||
M [X] create a tunnel service from distant chat code to make it (1) more generic (2) resistant to packet loss.
|
||||
@ -61,10 +65,8 @@ VOIP
|
||||
H [ ] Audio Conference
|
||||
H [ ] Video Conference
|
||||
|
||||
|
||||
Messages
|
||||
H [ ] make the mail system re-send failed emails notified by the global router. This is hard because it needs a proper
|
||||
management of duplicate messages
|
||||
H [X] make the mail system re-send failed emails notified by the global router. This is hard because it needs a proper management of duplicate messages
|
||||
E [X] add flags to allow distant messaging from contact list only / everyone / noone / only signed ids.
|
||||
|
||||
Chat
|
||||
|
@ -1,5 +1,23 @@
|
||||
retroshare06 (0.6.0-1.XXXXXX~YYYYYY) YYYYYY; urgency=low
|
||||
|
||||
4953324 electron128 Sat, 2 Jan 2016 14:53:24 +0100 Merge pull request #235 from PhenomRetroShare/Fix_MakeMACOS_PluginWorking
|
||||
c5e6f62 Phenom Sat, 2 Jan 2016 14:19:53 +0100 Make Plugin working in Mac OSX.
|
||||
b6b5f9c csoler Fri, 1 Jan 2016 22:36:07 -0500 fixed some of the issues reported by coverity scan (mainly uninitialised class members)
|
||||
ab3939c csoler Fri, 1 Jan 2016 11:11:40 -0500 added missing update of mClientMsgUpdateMap, causing both a memory leak and an inconsistency in TS
|
||||
22c00fc electron128 Fri, 1 Jan 2016 14:07:15 +0100 fixed free() in UdpLayer::recv_loop
|
||||
58672e8 electron128 Fri, 1 Jan 2016 13:44:38 +0100 fix the logic to prevent using invalid iterators. First make a valid iterator, then dereference
|
||||
3b2eae4 electron128 Fri, 1 Jan 2016 12:17:08 +0100 fixed memory leak by using stack memory instead of heap memory
|
||||
9cb81f5 electron128 Fri, 1 Jan 2016 12:01:49 +0100 don't create wiki dataservice if wiki is not enabled for compile
|
||||
72812be electron128 Fri, 1 Jan 2016 11:54:59 +0100 added missing initialisation of integers in GxsForumThreadWidget
|
||||
55ea8a5 electron128 Fri, 1 Jan 2016 11:49:03 +0100 init pointer in RsServer
|
||||
7efb763 electron128 Fri, 1 Jan 2016 11:38:29 +0100 restore stream state of std::cerr after printing hex number
|
||||
640d71b electron128 Fri, 1 Jan 2016 11:09:49 +0100 removed delete of RsTemporaryMemory
|
||||
d24ff5a csoler Thu, 31 Dec 2015 19:42:50 -0500 Merge pull request #232 from G10h4ck/master
|
||||
7895932 Gio Fri, 1 Jan 2016 00:45:01 +0100 print_stacktrace is OS specific
|
||||
e872727 csoler Thu, 31 Dec 2015 17:37:05 -0500 updated dos->unix convertion script
|
||||
b6b04dc csoler Thu, 31 Dec 2015 17:28:42 -0500 added script to convert files to unix format
|
||||
6392d65 csoler Thu, 31 Dec 2015 16:50:52 -0500 fixed [dos] LF in IdDialog.h
|
||||
|
||||
a6ee7cc csoler Thu, 31 Dec 2015 14:15:14 -0500 Merge pull request #230 from G10h4ck/ss_port_invalid_family
|
||||
fac1524 csoler Thu, 31 Dec 2015 13:58:13 -0500 updated todo list
|
||||
c5feafa Gio Thu, 31 Dec 2015 19:56:50 +0100 Add missing stacktrace.h
|
||||
|
@ -2399,6 +2399,13 @@ bdNodeNetMsg::bdNodeNetMsg(char *msg, int len, struct sockaddr_in *in_addr)
|
||||
:data(NULL), mSize(len), addr(*in_addr)
|
||||
{
|
||||
data = (char *) malloc(len);
|
||||
|
||||
if(data == NULL)
|
||||
{
|
||||
std::cerr << "(EE) " << __PRETTY_FUNCTION__ << ": ERROR. cannot allocate memory for " << len << " bytes." << std::endl;
|
||||
return ;
|
||||
}
|
||||
|
||||
memcpy(data, msg, len);
|
||||
//print(std::cerr);
|
||||
}
|
||||
|
@ -20,6 +20,7 @@
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <iostream>
|
||||
#include <stdlib.h> /* malloc() realloc() free() strtoll() */
|
||||
#include <string.h> /* memset() */
|
||||
#include "util/bdstring.h"
|
||||
@ -111,6 +112,13 @@ static char *_be_decode_str(const char **data, long long *data_len)
|
||||
|
||||
if (**data == ':') {
|
||||
char *_ret = (char *) malloc(sizeof(sllen) + len + 1);
|
||||
|
||||
if(_ret == NULL)
|
||||
{
|
||||
std::cerr << "(EE) " << __PRETTY_FUNCTION__ << ": ERROR. cannot allocate memory for " << len+1+sizeof(sllen) << " bytes." << std::endl;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
memcpy(_ret, &sllen, sizeof(sllen));
|
||||
ret = _ret + sizeof(sllen);
|
||||
memcpy(ret, *data + 1, len);
|
||||
@ -500,6 +508,12 @@ be_node *be_create_str(const char *str)
|
||||
int len = strlen(str);
|
||||
long long int sllen = len;
|
||||
char *_ret = (char *) malloc(sizeof(sllen) + len + 1);
|
||||
|
||||
if(_ret == NULL)
|
||||
{
|
||||
std::cerr << "(EE) " << __PRETTY_FUNCTION__ << ": ERROR. cannot allocate memory for " << len+1+sizeof(sllen) << " bytes." << std::endl;
|
||||
return NULL;
|
||||
}
|
||||
char *ret = NULL;
|
||||
|
||||
memcpy(_ret, &sllen, sizeof(sllen));
|
||||
@ -519,6 +533,12 @@ be_node *be_create_str_wlen(const char *str, int len) /* not including \0 */
|
||||
be_node *n = be_alloc(BE_STR);
|
||||
long long int sllen = len;
|
||||
char *_ret = (char *) malloc(sizeof(sllen) + len + 1);
|
||||
|
||||
if(_ret == NULL)
|
||||
{
|
||||
std::cerr << "(EE) " << __PRETTY_FUNCTION__ << ": ERROR. cannot allocate memory for " << len+1+sizeof(sllen) << " bytes." << std::endl;
|
||||
return NULL;
|
||||
}
|
||||
char *ret = NULL;
|
||||
|
||||
memcpy(_ret, &sllen, sizeof(sllen));
|
||||
@ -561,6 +581,12 @@ int be_add_keypair(be_node *dict, const char *str, be_node *node)
|
||||
int len = strlen(str);
|
||||
long long int sllen = len;
|
||||
char *_ret = (char *) malloc(sizeof(sllen) + len + 1);
|
||||
|
||||
if(_ret == NULL)
|
||||
{
|
||||
std::cerr << "(EE) " << __PRETTY_FUNCTION__ << ": ERROR. cannot allocate memory for " << len+1+sizeof(sllen) << " bytes." << std::endl;
|
||||
return 0;
|
||||
}
|
||||
char *ret = NULL;
|
||||
|
||||
//fprintf(stderr, "be_add_keypair() key len = %d\n",len);
|
||||
|
@ -66,7 +66,11 @@ class udpPacket
|
||||
:raddr(*addr), len(dlen)
|
||||
{
|
||||
data = malloc(len);
|
||||
|
||||
if(data != NULL)
|
||||
memcpy(data, dta, len);
|
||||
else
|
||||
std::cerr << "(EE) error in memory allocation in " << __PRETTY_FUNCTION__ << std::endl;
|
||||
}
|
||||
|
||||
~udpPacket()
|
||||
@ -242,6 +246,12 @@ void UdpLayer::recv_loop()
|
||||
int maxsize = 16000;
|
||||
void *inbuf = malloc(maxsize);
|
||||
|
||||
if(inbuf == NULL)
|
||||
{
|
||||
std::cerr << "(EE) Error in memory allocation of size " << maxsize << " in " << __PRETTY_FUNCTION__ << std::endl;
|
||||
return ;
|
||||
}
|
||||
|
||||
int status;
|
||||
struct timeval timeout;
|
||||
|
||||
|
@ -100,6 +100,13 @@ int bloomFilter::setFilterBits(const std::string &hex)
|
||||
|
||||
// convert to binary array.
|
||||
uint8_t *tmparray = (uint8_t *) malloc(bytes);
|
||||
|
||||
if(tmparray == NULL)
|
||||
{
|
||||
std::cerr << "(EE) Error. Cannot allocate memory for " << bytes << " bytes in " << __PRETTY_FUNCTION__ << std::endl;
|
||||
return 0;
|
||||
}
|
||||
|
||||
uint32_t i = 0;
|
||||
|
||||
for(i = 0; i < bytes; i++)
|
||||
@ -139,6 +146,13 @@ std::string bloomFilter::getFilter()
|
||||
|
||||
// convert to binary array.
|
||||
uint8_t *tmparray = (uint8_t *) malloc(bytes);
|
||||
|
||||
if(tmparray == NULL)
|
||||
{
|
||||
std::cerr << "(EE) Error. Cannot allocate memory for " << bytes << " bytes in " << __PRETTY_FUNCTION__ << std::endl;
|
||||
return std::string();
|
||||
}
|
||||
|
||||
int i,j;
|
||||
|
||||
for(i = 0; i < bytes; i++)
|
||||
|
@ -202,7 +202,7 @@ bool DistributedChatService::handleRecvChatLobbyMsgItem(RsChatMsgItem *ci)
|
||||
//name = cli->nick;
|
||||
//popupChatFlag = RS_POPUP_CHATLOBBY;
|
||||
|
||||
RsServer::notify()->AddPopupMessage(RS_POPUP_CHATLOBBY, virtual_peer_id.toStdString(), cli->signature.keyId.toStdString(), cli->message); /* notify private chat message */
|
||||
RsServer::notify()->AddPopupMessage(RS_POPUP_CHATLOBBY, ChatId(cli->lobby_id).toStdString(), cli->signature.keyId.toStdString(), cli->message); /* notify private chat message */
|
||||
|
||||
return true ;
|
||||
}
|
||||
@ -319,11 +319,6 @@ void DistributedChatService::locked_printDebugInfo() const
|
||||
|
||||
}
|
||||
|
||||
std::cerr << "Recorded lobby names: " << std::endl;
|
||||
|
||||
for( std::map<RsPeerId,ChatLobbyId>::const_iterator it(_lobby_ids.begin()) ;it!=_lobby_ids.end();++it)
|
||||
std::cerr << " \"" << it->first << "\" id = " << std::hex << it->second << std::dec << std::endl;
|
||||
|
||||
std::cerr << "Visible public lobbies: " << std::endl;
|
||||
|
||||
for( std::map<ChatLobbyId,VisibleChatLobbyRecord>::const_iterator it(_visible_lobbies.begin()) ;it!=_visible_lobbies.end();++it)
|
||||
@ -339,21 +334,6 @@ void DistributedChatService::locked_printDebugInfo() const
|
||||
std::cerr << " \"" << std::hex << it->first << "\" flags = " << it->second << std::dec << std::endl;
|
||||
}
|
||||
|
||||
bool DistributedChatService::isLobbyId(const RsPeerId& virtual_peer_id,ChatLobbyId& lobby_id)
|
||||
{
|
||||
RsStackMutex stack(mDistributedChatMtx); /********** STACK LOCKED MTX ******/
|
||||
|
||||
std::map<ChatLobbyVirtualPeerId,ChatLobbyId>::const_iterator it(_lobby_ids.find(virtual_peer_id)) ;
|
||||
|
||||
if(it != _lobby_ids.end())
|
||||
{
|
||||
lobby_id = it->second ;
|
||||
return true ;
|
||||
}
|
||||
|
||||
lobby_id = 0;
|
||||
return false ;
|
||||
}
|
||||
bool DistributedChatService::locked_bouncingObjectCheck(RsChatLobbyBouncingObject *obj,const RsPeerId& peer_id,uint32_t lobby_count)
|
||||
{
|
||||
static std::map<std::string, std::list<time_t> > message_counts ;
|
||||
@ -1368,7 +1348,6 @@ bool DistributedChatService::acceptLobbyInvite(const ChatLobbyId& lobby_id,const
|
||||
entry.last_connexion_challenge_time = now ;
|
||||
entry.last_keep_alive_packet_time = now ;
|
||||
|
||||
_lobby_ids[entry.virtual_peer_id] = lobby_id ;
|
||||
_chat_lobbys[lobby_id] = entry ;
|
||||
|
||||
_lobby_invites_queue.erase(it) ; // remove the invite from cache.
|
||||
@ -1487,8 +1466,6 @@ bool DistributedChatService::joinVisibleChatLobby(const ChatLobbyId& lobby_id,co
|
||||
entry.last_connexion_challenge_time = now ;
|
||||
entry.last_keep_alive_packet_time = now ;
|
||||
|
||||
_lobby_ids[entry.virtual_peer_id] = lobby_id ;
|
||||
|
||||
for(std::set<RsPeerId>::const_iterator it2(it->second.participating_friends.begin());it2!=it->second.participating_friends.end();++it2)
|
||||
{
|
||||
invited_friends.push_back(*it2) ;
|
||||
@ -1537,7 +1514,6 @@ ChatLobbyId DistributedChatService::createChatLobby(const std::string& lobby_nam
|
||||
entry.last_connexion_challenge_time = now ;
|
||||
entry.last_keep_alive_packet_time = now ;
|
||||
|
||||
_lobby_ids[entry.virtual_peer_id] = lobby_id ;
|
||||
_chat_lobbys[lobby_id] = entry ;
|
||||
}
|
||||
|
||||
@ -1619,13 +1595,6 @@ void DistributedChatService::unsubscribeChatLobby(const ChatLobbyId& id)
|
||||
// remove lobby information
|
||||
|
||||
_chat_lobbys.erase(it) ;
|
||||
|
||||
for(std::map<ChatLobbyVirtualPeerId,ChatLobbyId>::iterator it2(_lobby_ids.begin());it2!=_lobby_ids.end();++it2)
|
||||
if(it2->second == id)
|
||||
{
|
||||
_lobby_ids.erase(it2) ;
|
||||
break ;
|
||||
}
|
||||
}
|
||||
|
||||
RsServer::notify()->notifyListChange(NOTIFY_LIST_CHAT_LOBBY_LIST, NOTIFY_TYPE_DEL) ;
|
||||
|
@ -60,7 +60,6 @@ class DistributedChatService
|
||||
// Interface part to communicate with
|
||||
//
|
||||
bool getVirtualPeerId(const ChatLobbyId& lobby_id, RsPeerId& virtual_peer_id) ;
|
||||
bool isLobbyId(const RsPeerId& virtual_peer_id, ChatLobbyId& lobby_id) ;
|
||||
void getChatLobbyList(std::list<ChatLobbyId>& clids) ;
|
||||
bool getChatLobbyInfo(const ChatLobbyId& id,ChatLobbyInfo& clinfo) ;
|
||||
bool acceptLobbyInvite(const ChatLobbyId& id,const RsGxsId& identity) ;
|
||||
@ -149,7 +148,6 @@ class DistributedChatService
|
||||
std::map<ChatLobbyId,ChatLobbyEntry> _chat_lobbys ;
|
||||
std::map<ChatLobbyId,ChatLobbyInvite> _lobby_invites_queue ;
|
||||
std::map<ChatLobbyId,VisibleChatLobbyRecord> _visible_lobbies ;
|
||||
std::map<ChatLobbyVirtualPeerId,ChatLobbyId> _lobby_ids ;
|
||||
std::map<ChatLobbyId,ChatLobbyFlags> _known_lobbies_flags ; // flags for all lobbies, including the ones that are not known. So we can't
|
||||
std::map<ChatLobbyId,std::vector<RsChatLobbyMsgItem*> > _pendingPartialLobbyMessages ; // store them in _chat_lobbies (subscribed lobbies) nor _visible_lobbies.
|
||||
// Known flags:
|
||||
|
@ -29,6 +29,7 @@
|
||||
#include "rsserver/p3face.h"
|
||||
#include "dbase/fimonitor.h"
|
||||
#include "util/rsdir.h"
|
||||
#include "util/rsmemory.h"
|
||||
#include "pqi/authssl.h"
|
||||
#include "serialiser/rsserviceids.h"
|
||||
#include "retroshare/rsiface.h"
|
||||
@ -128,13 +129,11 @@ HashCache::HashCache(const std::string& path)
|
||||
|
||||
// read the binary stream into memory.
|
||||
//
|
||||
void *buffer = malloc(file_size) ;
|
||||
void *buffer = rs_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 (!F)
|
||||
{
|
||||
|
@ -39,6 +39,7 @@
|
||||
#include "util/rsstring.h"
|
||||
#endif
|
||||
#include "util/rsdiscspace.h"
|
||||
#include "util/rsmemory.h"
|
||||
|
||||
#include "ft/ftcontroller.h"
|
||||
|
||||
@ -747,8 +748,14 @@ bool ftController::copyFile(const std::string& source,const std::string& dest)
|
||||
size_t T=0;
|
||||
|
||||
static const int BUFF_SIZE = 10485760 ; // 10 MB buffer to speed things up.
|
||||
void *buffer = malloc(BUFF_SIZE) ;
|
||||
void *buffer = rs_malloc(BUFF_SIZE) ;
|
||||
|
||||
if(buffer == NULL)
|
||||
{
|
||||
fclose (in);
|
||||
fclose (out);
|
||||
return false ;
|
||||
}
|
||||
bool bRet = true;
|
||||
|
||||
while( (s = fread(buffer,1,BUFF_SIZE,in)) > 0)
|
||||
|
@ -35,6 +35,7 @@
|
||||
#include "ft/ftfileprovider.h"
|
||||
#include "ft/ftsearch.h"
|
||||
#include "util/rsdir.h"
|
||||
#include "util/rsmemory.h"
|
||||
#include <retroshare/rsturtle.h>
|
||||
#include <time.h>
|
||||
|
||||
@ -878,13 +879,11 @@ bool ftDataMultiplex::locked_handleServerRequest(ftFileProvider *provider, const
|
||||
std::cerr << "Warning: peer " << peerId << " is asking a large chunk (s=" << chunksize << ") for hash " << hash << ", filesize=" << size << ". This is unexpected." << std::endl ;
|
||||
return false ;
|
||||
}
|
||||
void *data = malloc(chunksize);
|
||||
void *data = rs_malloc(chunksize);
|
||||
|
||||
if(data == NULL)
|
||||
{
|
||||
std::cerr << "WARNING: Could not allocate data for a chunksize of " << chunksize << std::endl ;
|
||||
return false ;
|
||||
}
|
||||
|
||||
#ifdef MPLEX_DEBUG
|
||||
std::cerr << "ftDataMultiplex::locked_handleServerRequest()";
|
||||
std::cerr << "\t peer: " << peerId << " hash: " << hash;
|
||||
|
@ -465,6 +465,8 @@ RsTurtleGenericTunnelItem *ftServer::deserialiseItem(void *data,uint32_t size) c
|
||||
return NULL; /* wrong type */
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
switch(getRsItemSubType(rstype))
|
||||
{
|
||||
case RS_TURTLE_SUBTYPE_FILE_REQUEST : return new RsTurtleFileRequestItem(data,size) ;
|
||||
@ -478,6 +480,13 @@ RsTurtleGenericTunnelItem *ftServer::deserialiseItem(void *data,uint32_t size) c
|
||||
return NULL ;
|
||||
}
|
||||
}
|
||||
catch(std::exception& e)
|
||||
{
|
||||
std::cerr << "(EE) deserialisation error in " << __PRETTY_FUNCTION__ << ": " << e.what() << std::endl;
|
||||
|
||||
return NULL ;
|
||||
}
|
||||
}
|
||||
|
||||
void ftServer::addVirtualPeer(const TurtleFileHash& hash,const TurtleVirtualPeerId& virtual_peer_id,RsTurtleGenericTunnelItem::Direction dir)
|
||||
{
|
||||
@ -1093,11 +1102,10 @@ bool ftServer::sendData(const RsPeerId& peerId, const RsFileHash& hash, uint64_t
|
||||
|
||||
item->chunk_offset = offset+baseoffset ;
|
||||
item->chunk_size = chunk;
|
||||
item->chunk_data = malloc(chunk) ;
|
||||
item->chunk_data = rs_malloc(chunk) ;
|
||||
|
||||
if(item->chunk_data == NULL)
|
||||
{
|
||||
std::cerr << "p3turtle: Warning: failed malloc of " << chunk << " bytes for sending data packet." << std::endl ;
|
||||
delete item;
|
||||
return false;
|
||||
}
|
||||
|
@ -26,6 +26,7 @@
|
||||
#include <iostream>
|
||||
#include <stdexcept>
|
||||
|
||||
#include <util/rsmemory.h>
|
||||
#include <serialiser/itempriorities.h>
|
||||
#include <ft/ftturtlefiletransferitem.h>
|
||||
|
||||
@ -422,14 +423,24 @@ RsTurtleFileDataItem::RsTurtleFileDataItem(void *data,uint32_t pktsize)
|
||||
uint32_t offset = 8; // skip the header
|
||||
uint32_t rssize = getRsItemSize(data);
|
||||
|
||||
/* add mandatory parts first */
|
||||
|
||||
bool ok = true ;
|
||||
|
||||
if(rssize > pktsize)
|
||||
ok = false ;
|
||||
|
||||
/* add mandatory parts first */
|
||||
ok &= getRawUInt32(data, pktsize, &offset, &tunnel_id) ;
|
||||
ok &= getRawUInt64(data, pktsize, &offset, &chunk_offset);
|
||||
ok &= getRawUInt32(data, pktsize, &offset, &chunk_size);
|
||||
|
||||
chunk_data = (void*)malloc(chunk_size) ;
|
||||
if(chunk_size > rssize || rssize - chunk_size < offset)
|
||||
throw std::runtime_error("RsTurtleFileDataItem::() error while deserializing.") ;
|
||||
|
||||
chunk_data = (void*)rs_malloc(chunk_size) ;
|
||||
|
||||
if(chunk_data == NULL)
|
||||
throw std::runtime_error("RsTurtleFileDataItem::() cannot allocate memory.") ;
|
||||
|
||||
memcpy(chunk_data,(void*)((unsigned char*)data+offset),chunk_size) ;
|
||||
|
||||
offset += chunk_size ;
|
||||
|
@ -66,6 +66,12 @@ RsGRouterTransactionChunkItem *RsGRouterSerialiser::deserialise_RsGRouterTransac
|
||||
uint32_t rssize = getRsItemSize(data);
|
||||
bool ok = true ;
|
||||
|
||||
if(tlvsize < rssize)
|
||||
{
|
||||
std::cerr << __PRETTY_FUNCTION__ << ": wrong encoding of item size. Serialisation error!" << std::endl;
|
||||
return NULL ;
|
||||
}
|
||||
|
||||
RsGRouterTransactionChunkItem *item = new RsGRouterTransactionChunkItem() ;
|
||||
|
||||
/* add mandatory parts first */
|
||||
@ -74,15 +80,14 @@ RsGRouterTransactionChunkItem *RsGRouterSerialiser::deserialise_RsGRouterTransac
|
||||
ok &= getRawUInt32(data, tlvsize, &offset, &item->chunk_size);
|
||||
ok &= getRawUInt32(data, tlvsize, &offset, &item->total_size);
|
||||
|
||||
if( NULL == (item->chunk_data = (uint8_t*)malloc(item->chunk_size)))
|
||||
if(item->chunk_size > rssize || offset > rssize - item->chunk_size) // better than if(item->chunk_size + offset > rssize)
|
||||
{
|
||||
std::cerr << __PRETTY_FUNCTION__ << ": Cannot allocate memory for chunk " << item->chunk_size << std::endl;
|
||||
std::cerr << __PRETTY_FUNCTION__ << ": Cannot read beyond item size. Serialisation error!" << std::endl;
|
||||
delete item;
|
||||
return NULL ;
|
||||
}
|
||||
if(item->chunk_size + offset > rssize)
|
||||
if( NULL == (item->chunk_data = (uint8_t*)rs_malloc(item->chunk_size)))
|
||||
{
|
||||
std::cerr << __PRETTY_FUNCTION__ << ": Cannot read beyond item size. Serialisation error!" << std::endl;
|
||||
delete item;
|
||||
return NULL ;
|
||||
}
|
||||
@ -125,6 +130,11 @@ RsGRouterGenericDataItem *RsGRouterSerialiser::deserialise_RsGRouterGenericDataI
|
||||
uint32_t rssize = getRsItemSize(data);
|
||||
bool ok = true ;
|
||||
|
||||
if(pktsize < rssize)
|
||||
{
|
||||
std::cerr << __PRETTY_FUNCTION__ << ": wrong encoding of item size. Serialisation error!" << std::endl;
|
||||
return NULL ;
|
||||
}
|
||||
RsGRouterGenericDataItem *item = new RsGRouterGenericDataItem() ;
|
||||
|
||||
ok &= getRawUInt64(data, pktsize, &offset, &item->routing_id);
|
||||
@ -132,16 +142,15 @@ RsGRouterGenericDataItem *RsGRouterSerialiser::deserialise_RsGRouterGenericDataI
|
||||
ok &= getRawUInt32(data, pktsize, &offset, &item->service_id);
|
||||
ok &= getRawUInt32(data, pktsize, &offset, &item->data_size);
|
||||
|
||||
if( NULL == (item->data_bytes = (uint8_t*)malloc(item->data_size)))
|
||||
if(item->data_size > rssize || offset > rssize - item->data_size) // better than if(item->data_size + offset > rssize)
|
||||
{
|
||||
std::cerr << __PRETTY_FUNCTION__ << ": Cannot allocate memory for chunk " << item->data_size << std::endl;
|
||||
std::cerr << __PRETTY_FUNCTION__ << ": Cannot read beyond item size. Serialisation error!" << std::endl;
|
||||
delete item;
|
||||
return NULL ;
|
||||
}
|
||||
|
||||
if(item->data_size + offset > rssize)
|
||||
if( NULL == (item->data_bytes = (uint8_t*)rs_malloc(item->data_size)))
|
||||
{
|
||||
std::cerr << __PRETTY_FUNCTION__ << ": Cannot read beyond item size. Serialisation error!" << std::endl;
|
||||
delete item;
|
||||
return NULL ;
|
||||
}
|
||||
@ -337,8 +346,19 @@ RsGRouterGenericDataItem *RsGRouterGenericDataItem::duplicate() const
|
||||
|
||||
// then duplicate the memory chunk
|
||||
|
||||
item->data_bytes = (uint8_t*)malloc(data_size) ;
|
||||
if(data_size > 0)
|
||||
{
|
||||
item->data_bytes = (uint8_t*)rs_malloc(data_size) ;
|
||||
|
||||
if(item->data_bytes == NULL)
|
||||
{
|
||||
delete item ;
|
||||
return NULL ;
|
||||
}
|
||||
memcpy(item->data_bytes,data_bytes,data_size) ;
|
||||
}
|
||||
else
|
||||
item->data_bytes = NULL ;
|
||||
|
||||
return item ;
|
||||
}
|
||||
|
@ -25,6 +25,8 @@
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "util/rsmemory.h"
|
||||
|
||||
#include "serialiser/rsserial.h"
|
||||
#include "serialiser/rstlvkeys.h"
|
||||
#include "serialiser/rsserviceids.h"
|
||||
@ -194,7 +196,11 @@ class RsGRouterTransactionChunkItem: public RsGRouterTransactionItem, public RsG
|
||||
{
|
||||
RsGRouterTransactionChunkItem *item = new RsGRouterTransactionChunkItem ;
|
||||
*item = *this ; // copy all fields
|
||||
item->chunk_data = (uint8_t*)malloc(chunk_size) ; // deep copy memory chunk
|
||||
item->chunk_data = (uint8_t*)rs_malloc(chunk_size) ; // deep copy memory chunk
|
||||
|
||||
if(item->chunk_data == NULL)
|
||||
return NULL ;
|
||||
|
||||
memcpy(item->chunk_data,chunk_data,chunk_size) ;
|
||||
return item ;
|
||||
}
|
||||
|
@ -1121,13 +1121,11 @@ bool p3GRouter::locked_sendTransactionData(const RsPeerId& pid,const RsGRouterTr
|
||||
std::cerr << " sending to tunnel vpid " << pid << std::endl;
|
||||
#endif
|
||||
uint32_t turtle_data_size = trans_item.serial_size() ;
|
||||
uint8_t *turtle_data = (uint8_t*)malloc(turtle_data_size) ;
|
||||
uint8_t *turtle_data = (uint8_t*)rs_malloc(turtle_data_size) ;
|
||||
|
||||
if(turtle_data == NULL)
|
||||
{
|
||||
std::cerr << " ERROR: Cannot allocate turtle data memory for size " << turtle_data_size << std::endl;
|
||||
return false ;
|
||||
}
|
||||
|
||||
if(!trans_item.serialise(turtle_data,turtle_data_size))
|
||||
{
|
||||
std::cerr << " ERROR: cannot serialise RsGRouterTransactionChunkItem." << std::endl;
|
||||
@ -1184,15 +1182,17 @@ void p3GRouter::autoWash()
|
||||
#ifdef GROUTER_DEBUG
|
||||
grouter_debug() << " Removing cached item " << std::hex << it->first << std::dec << std::endl;
|
||||
#endif
|
||||
GRouterClientService *client = NULL ;
|
||||
GRouterServiceId service_id = 0;
|
||||
//GRouterClientService *client = NULL ;
|
||||
//GRouterServiceId service_id = 0;
|
||||
|
||||
if( it->second.data_status != RS_GROUTER_DATA_STATUS_DONE )
|
||||
{
|
||||
if(!locked_getClientAndServiceId(it->second.tunnel_hash,it->second.data_item->destination_key,client,service_id))
|
||||
std::cerr << " ERROR: cannot find client for cancelled message " << it->first << std::endl;
|
||||
else
|
||||
GRouterClientService *client = NULL;
|
||||
|
||||
if(locked_getLocallyRegisteredClientFromServiceId(it->second.client_id,client))
|
||||
failed_msgs[it->first] = client ;
|
||||
else
|
||||
std::cerr << " ERROR: client id " << it->second.client_id << " not registered. Consistency error." << std::endl;
|
||||
}
|
||||
|
||||
delete it->second.data_item ;
|
||||
@ -1302,14 +1302,13 @@ bool p3GRouter::sliceDataItem(RsGRouterAbstractMsgItem *item,std::list<RsGRouter
|
||||
chunk_item->total_size = size;
|
||||
chunk_item->chunk_start= offset;
|
||||
chunk_item->chunk_size = chunk_size ;
|
||||
chunk_item->chunk_data = (uint8_t*)malloc(chunk_size) ;
|
||||
chunk_item->chunk_data = (uint8_t*)rs_malloc(chunk_size) ;
|
||||
#ifdef GROUTER_DEBUG
|
||||
std::cerr << " preparing to send a chunk [" << offset << " -> " << offset + chunk_size << " / " << size << "]" << std::endl;
|
||||
#endif
|
||||
|
||||
if(chunk_item->chunk_data == NULL)
|
||||
{
|
||||
std::cerr << " ERROR: Cannot allocate memory for size " << chunk_size << std::endl;
|
||||
delete chunk_item;
|
||||
throw ;
|
||||
}
|
||||
@ -1411,7 +1410,7 @@ void p3GRouter::handleIncomingReceiptItem(RsGRouterSignedReceiptItem *receipt_it
|
||||
#endif
|
||||
it->second.data_status = RS_GROUTER_DATA_STATUS_DONE;
|
||||
|
||||
if(locked_getClientAndServiceId(it->second.tunnel_hash,it->second.data_item->destination_key,client_service,service_id))
|
||||
if(locked_getLocallyRegisteredClientFromServiceId(it->second.client_id,client_service))
|
||||
mid = it->first ;
|
||||
else
|
||||
{
|
||||
@ -1604,6 +1603,7 @@ void p3GRouter::handleIncomingDataItem(RsGRouterGenericDataItem *data_item)
|
||||
info.receipt_item = receipt_item ; // inited before, or NULL.
|
||||
info.tunnel_status = RS_GROUTER_TUNNEL_STATUS_UNMANAGED ;
|
||||
info.last_sent_TS = 0 ;
|
||||
info.client_id = data_item->service_id ;
|
||||
info.item_hash = item_hash ;
|
||||
info.last_tunnel_request_TS = 0 ;
|
||||
info.sending_attempts = 0 ;
|
||||
@ -1680,25 +1680,9 @@ void p3GRouter::handleIncomingDataItem(RsGRouterGenericDataItem *data_item)
|
||||
IndicateConfigChanged() ;
|
||||
}
|
||||
|
||||
bool p3GRouter::locked_getClientAndServiceId(const TurtleFileHash& hash, const RsGxsId& destination_key, GRouterClientService *& client, GRouterServiceId& service_id)
|
||||
bool p3GRouter::locked_getLocallyRegisteredClientFromServiceId(const GRouterServiceId& service_id,GRouterClientService *& client)
|
||||
{
|
||||
client = NULL ;
|
||||
service_id = 0;
|
||||
RsGxsId gxs_id ;
|
||||
|
||||
if(!locked_getGxsIdAndClientId(hash,gxs_id,service_id))
|
||||
{
|
||||
std::cerr << " p3GRouter::ERROR: locked_getGxsIdAndClientId(): no key registered for hash " << hash << std::endl;
|
||||
return false ;
|
||||
}
|
||||
|
||||
if(gxs_id != destination_key)
|
||||
{
|
||||
std::cerr << " ERROR: verification (destination) GXS key " << destination_key << " does not match key from hash " << gxs_id << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
// now find the client given its id.
|
||||
|
||||
std::map<GRouterServiceId,GRouterClientService*>::const_iterator its = _registered_services.find(service_id) ;
|
||||
|
||||
@ -1934,7 +1918,11 @@ bool p3GRouter::sendData(const RsGxsId& destination,const GRouterServiceId& clie
|
||||
|
||||
RsGRouterGenericDataItem *data_item = new RsGRouterGenericDataItem ;
|
||||
|
||||
data_item->data_bytes = (uint8_t*)malloc(data_size) ;
|
||||
data_item->data_bytes = (uint8_t*)rs_malloc(data_size) ;
|
||||
|
||||
if(data_item->data_bytes == NULL)
|
||||
return false ;
|
||||
|
||||
memcpy(data_item->data_bytes,data,data_size) ;
|
||||
|
||||
data_item->data_size = data_size ;
|
||||
@ -1981,6 +1969,7 @@ bool p3GRouter::sendData(const RsGxsId& destination,const GRouterServiceId& clie
|
||||
info.data_status = RS_GROUTER_DATA_STATUS_PENDING ;
|
||||
info.tunnel_status = RS_GROUTER_TUNNEL_STATUS_UNMANAGED ;
|
||||
info.last_sent_TS = 0 ;
|
||||
info.client_id = client_id ;
|
||||
info.last_tunnel_request_TS = 0 ;
|
||||
info.item_hash = computeDataItemHash(data_item) ;
|
||||
info.sending_attempts = 0 ;
|
||||
@ -2029,7 +2018,8 @@ Sha1CheckSum p3GRouter::makeTunnelHash(const RsGxsId& destination,const GRouterS
|
||||
|
||||
return RsDirUtil::sha1sum(bytes,20) ;
|
||||
}
|
||||
bool p3GRouter::locked_getGxsIdAndClientId(const TurtleFileHash& sum,RsGxsId& gxs_id,GRouterServiceId& client_id)
|
||||
#ifdef TO_REMOVE
|
||||
bool p3GRouter::locked_getGxsOwnIdAndClientIdFromHash(const TurtleFileHash& sum,RsGxsId& gxs_id,GRouterServiceId& client_id)
|
||||
{
|
||||
assert( gxs_id.SIZE_IN_BYTES == 16) ;
|
||||
assert(Sha1CheckSum::SIZE_IN_BYTES == 20) ;
|
||||
@ -2047,6 +2037,7 @@ bool p3GRouter::locked_getGxsIdAndClientId(const TurtleFileHash& sum,RsGxsId& gx
|
||||
|
||||
return true ;
|
||||
}
|
||||
#endif
|
||||
bool p3GRouter::loadList(std::list<RsItem*>& items)
|
||||
{
|
||||
{
|
||||
@ -2211,6 +2202,7 @@ void p3GRouter::debugDump()
|
||||
for(std::map<Sha1CheckSum, GRouterPublishedKeyInfo>::const_iterator it(_owned_key_ids.begin());it!=_owned_key_ids.end();++it)
|
||||
{
|
||||
grouter_debug() << " Hash : " << it->first << std::endl;
|
||||
grouter_debug() << " Key : " << it->second.authentication_key << std::endl;
|
||||
grouter_debug() << " Service id : " << std::hex << it->second.service_id << std::dec << std::endl;
|
||||
grouter_debug() << " Description : " << it->second.description_string << std::endl;
|
||||
}
|
||||
@ -2228,6 +2220,8 @@ void p3GRouter::debugDump()
|
||||
{
|
||||
grouter_debug() << " Msg id: " << std::hex << it->first << std::dec ;
|
||||
grouter_debug() << " data hash: " << it->second.item_hash ;
|
||||
grouter_debug() << " client id: " << std::hex << it->second.client_id << std::dec;
|
||||
grouter_debug() << " Flags: " << std::hex << it->second.routing_flags << std::dec;
|
||||
grouter_debug() << " Destination: " << it->second.data_item->destination_key ;
|
||||
grouter_debug() << " Received: " << now - it->second.received_time_TS << " secs ago.";
|
||||
grouter_debug() << " Last sent: " << now - it->second.last_sent_TS << " secs ago.";
|
||||
|
@ -252,8 +252,7 @@ private:
|
||||
void handleIncomingReceiptItem(RsGRouterSignedReceiptItem *receipt_item) ;
|
||||
void handleIncomingDataItem(RsGRouterGenericDataItem *data_item) ;
|
||||
|
||||
bool locked_getClientAndServiceId(const TurtleFileHash& hash, const RsGxsId& destination_key, GRouterClientService *& client, GRouterServiceId& service_id);
|
||||
|
||||
bool locked_getLocallyRegisteredClientFromServiceId(const GRouterServiceId& service_id,GRouterClientService *& client);
|
||||
|
||||
// utility functions
|
||||
//
|
||||
@ -270,7 +269,7 @@ private:
|
||||
|
||||
static Sha1CheckSum makeTunnelHash(const RsGxsId& destination,const GRouterServiceId& client);
|
||||
|
||||
bool locked_getGxsIdAndClientId(const TurtleFileHash &sum,RsGxsId& gxs_id,GRouterServiceId& client_id);
|
||||
//bool locked_getGxsIdAndClientId(const TurtleFileHash &sum,RsGxsId& gxs_id,GRouterServiceId& client_id);
|
||||
bool locked_sendTransactionData(const RsPeerId& pid,const RsGRouterTransactionItem& item);
|
||||
|
||||
void locked_collectAvailableFriends(const GRouterKeyId &gxs_id,std::list<RsPeerId>& friend_peers, const std::set<RsPeerId>& incoming_routes,bool is_origin);
|
||||
|
@ -563,7 +563,11 @@ bool GxsSecurity::encrypt(uint8_t *& out, uint32_t &outlen, const uint8_t *in, u
|
||||
int out_offset = 0;
|
||||
|
||||
int max_evp_key_size = EVP_PKEY_size(public_key);
|
||||
ek = (unsigned char*)malloc(max_evp_key_size);
|
||||
ek = (unsigned char*)rs_malloc(max_evp_key_size);
|
||||
|
||||
if(ek == NULL)
|
||||
return false ;
|
||||
|
||||
const EVP_CIPHER *cipher = EVP_aes_128_cbc();
|
||||
int cipher_block_size = EVP_CIPHER_block_size(cipher);
|
||||
int size_net_ekl = sizeof(net_ekl);
|
||||
@ -574,13 +578,10 @@ bool GxsSecurity::encrypt(uint8_t *& out, uint32_t &outlen, const uint8_t *in, u
|
||||
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 = (uint8_t*)malloc(inlen + cipher_block_size + size_net_ekl + eklen + EVP_MAX_IV_LENGTH);
|
||||
out = (uint8_t*)rs_malloc(inlen + cipher_block_size + size_net_ekl + eklen + EVP_MAX_IV_LENGTH);
|
||||
|
||||
if(out == NULL)
|
||||
{
|
||||
std::cerr << "gxssecurity::encrypt(): cnnot allocate memory of size " << inlen + cipher_block_size + size_net_ekl + eklen + EVP_MAX_IV_LENGTH << " to encrypt data." << std::endl;
|
||||
return false ;
|
||||
}
|
||||
|
||||
net_ekl = htonl(eklen);
|
||||
memcpy((unsigned char*)out + out_offset, &net_ekl, size_net_ekl);
|
||||
@ -750,7 +751,11 @@ bool GxsSecurity::decrypt(uint8_t *& out, uint32_t & outlen, const uint8_t *in,
|
||||
|
||||
EVP_CIPHER_CTX ctx;
|
||||
int eklen = 0, net_ekl = 0;
|
||||
unsigned char *ek = (unsigned char*)malloc(EVP_PKEY_size(privateKey));
|
||||
unsigned char *ek = (unsigned char*)rs_malloc(EVP_PKEY_size(privateKey));
|
||||
|
||||
if(ek == NULL)
|
||||
return false ;
|
||||
|
||||
unsigned char iv[EVP_MAX_IV_LENGTH];
|
||||
EVP_CIPHER_CTX_init(&ctx);
|
||||
|
||||
@ -788,13 +793,10 @@ bool GxsSecurity::decrypt(uint8_t *& out, uint32_t & outlen, const uint8_t *in,
|
||||
std::cerr << "Severe error in " << __PRETTY_FUNCTION__ << ": cannot encrypt. " << std::endl;
|
||||
return false ;
|
||||
}
|
||||
out = (uint8_t*)malloc(inlen - in_offset);
|
||||
out = (uint8_t*)rs_malloc(inlen - in_offset);
|
||||
|
||||
if(out == NULL)
|
||||
{
|
||||
std::cerr << "gxssecurity::decrypt(): cannot allocate memory of size " << inlen - in_offset << " to decrypt data." << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
if(!EVP_OpenUpdate(&ctx, (unsigned char*) out, &out_currOffset, (unsigned char*)in + in_offset, inlen - in_offset))
|
||||
{
|
||||
|
@ -856,7 +856,7 @@ void p3GxsTunnelService::handleRecvDHPublicKey(RsGxsTunnelDHPublicKeyItem *item)
|
||||
#endif
|
||||
|
||||
uint32_t pubkey_size = BN_num_bytes(item->public_key) ;
|
||||
unsigned char *data = (unsigned char *)malloc(pubkey_size) ;
|
||||
RsTemporaryMemory data(pubkey_size) ;
|
||||
BN_bn2bin(item->public_key, data) ;
|
||||
|
||||
RsTlvSecurityKey signature_key ;
|
||||
@ -901,7 +901,7 @@ void p3GxsTunnelService::handleRecvDHPublicKey(RsGxsTunnelDHPublicKeyItem *item)
|
||||
signature_key = item->gxs_key ;
|
||||
}
|
||||
|
||||
if(!GxsSecurity::validateSignature((char*)data,pubkey_size,signature_key,item->signature))
|
||||
if(!GxsSecurity::validateSignature((char*)(unsigned char*)data,pubkey_size,signature_key,item->signature))
|
||||
{
|
||||
std::cerr << "(SS) Signature was verified and it doesn't check! This is a security issue!" << std::endl;
|
||||
return ;
|
||||
@ -939,7 +939,7 @@ void p3GxsTunnelService::handleRecvDHPublicKey(RsGxsTunnelDHPublicKeyItem *item)
|
||||
// Looks for the DH params. If not there yet, create them.
|
||||
//
|
||||
int size = DH_size(it->second.dh) ;
|
||||
unsigned char *key_buff = new unsigned char[size] ;
|
||||
RsTemporaryMemory key_buff(size) ;
|
||||
|
||||
if(size != DH_compute_key(key_buff,item->public_key,it->second.dh))
|
||||
{
|
||||
@ -959,7 +959,6 @@ void p3GxsTunnelService::handleRecvDHPublicKey(RsGxsTunnelDHPublicKeyItem *item)
|
||||
|
||||
assert(GXS_TUNNEL_AES_KEY_SIZE <= Sha1CheckSum::SIZE_IN_BYTES) ;
|
||||
memcpy(pinfo.aes_key, RsDirUtil::sha1sum(key_buff,size).toByteArray(),GXS_TUNNEL_AES_KEY_SIZE) ;
|
||||
delete[] key_buff ;
|
||||
|
||||
pinfo.last_contact = time(NULL) ;
|
||||
pinfo.last_keep_alive_sent = time(NULL) ;
|
||||
@ -1036,7 +1035,15 @@ bool p3GxsTunnelService::locked_sendDHPublicKey(const DH *dh,const RsGxsId& own_
|
||||
uint32_t error_status ;
|
||||
|
||||
uint32_t size = BN_num_bytes(dhitem->public_key) ;
|
||||
unsigned char *data = (unsigned char *)malloc(size) ;
|
||||
|
||||
RsTemporaryMemory data(size) ;
|
||||
|
||||
if(data == NULL)
|
||||
{
|
||||
delete(dhitem);
|
||||
return false ;
|
||||
}
|
||||
|
||||
BN_bn2bin(dhitem->public_key, data) ;
|
||||
|
||||
if(!mGixs->signData((unsigned char*)data,size,own_gxs_id,signature,error_status))
|
||||
@ -1048,11 +1055,9 @@ bool p3GxsTunnelService::locked_sendDHPublicKey(const DH *dh,const RsGxsId& own_
|
||||
default: std::cerr << "(EE) Unknown error when signing" << std::endl;
|
||||
break ;
|
||||
}
|
||||
free(data) ;
|
||||
delete(dhitem);
|
||||
return false;
|
||||
}
|
||||
free(data) ;
|
||||
|
||||
if(!mGixs->getKey(own_gxs_id,signature_key_public))
|
||||
{
|
||||
@ -1136,8 +1141,13 @@ bool p3GxsTunnelService::locked_sendClearTunnelData(RsGxsTunnelDHPublicKeyItem *
|
||||
uint32_t rssize = item->serial_size() ;
|
||||
|
||||
gitem->data_size = rssize + 8 ;
|
||||
gitem->data_bytes = malloc(rssize+8) ;
|
||||
gitem->data_bytes = rs_malloc(rssize+8) ;
|
||||
|
||||
if(gitem->data_bytes == NULL)
|
||||
{
|
||||
delete gitem ;
|
||||
return NULL ;
|
||||
}
|
||||
// by convention, we use a IV of 0 for unencrypted data.
|
||||
memset(gitem->data_bytes,0,8) ;
|
||||
|
||||
@ -1221,7 +1231,10 @@ bool p3GxsTunnelService::locked_sendEncryptedTunnelData(RsGxsTunnelItem *item)
|
||||
RsTurtleGenericDataItem *gitem = new RsTurtleGenericDataItem ;
|
||||
|
||||
gitem->data_size = encrypted_size + GXS_TUNNEL_ENCRYPTION_IV_SIZE + GXS_TUNNEL_ENCRYPTION_HMAC_SIZE ;
|
||||
gitem->data_bytes = malloc(gitem->data_size) ;
|
||||
gitem->data_bytes = rs_malloc(gitem->data_size) ;
|
||||
|
||||
if(gitem->data_bytes == NULL)
|
||||
return false ;
|
||||
|
||||
memcpy(& ((uint8_t*)gitem->data_bytes)[0] ,&IV,8) ;
|
||||
|
||||
@ -1316,7 +1329,11 @@ bool p3GxsTunnelService::sendData(const RsGxsTunnelId &tunnel_id, uint32_t servi
|
||||
item->flags = 0; // not used yet.
|
||||
item->service_id = service_id;
|
||||
item->data_size = size; // encrypted data size
|
||||
item->data = (uint8_t*)malloc(size); // encrypted data
|
||||
item->data = (uint8_t*)rs_malloc(size); // encrypted data
|
||||
|
||||
if(item->data == NULL)
|
||||
delete item ;
|
||||
|
||||
item->PeerId(RsPeerId(tunnel_id)) ;
|
||||
memcpy(item->data,data,size) ;
|
||||
|
||||
@ -1465,6 +1482,8 @@ bool p3GxsTunnelService::closeExistingTunnel(const RsGxsTunnelId& tunnel_id, uin
|
||||
|
||||
if(it2 != _gxs_tunnel_virtual_peer_ids.end())
|
||||
hash = it2->second.hash ;
|
||||
else
|
||||
hash = it->second.hash ;
|
||||
|
||||
// check how many clients are used. If empty, close the tunnel
|
||||
|
||||
|
@ -29,6 +29,7 @@
|
||||
#include "serialiser/rsbaseserial.h"
|
||||
#include "serialiser/rstlvbase.h"
|
||||
#include "util/rsprint.h"
|
||||
#include "util/rsmemory.h"
|
||||
|
||||
#include "gxstunnel/rsgxstunnelitems.h"
|
||||
|
||||
@ -343,6 +344,13 @@ RsGxsTunnelDHPublicKeyItem *RsGxsTunnelSerialiser::deserialise_RsGxsTunnelDHPubl
|
||||
/* get mandatory parts first */
|
||||
ok &= getRawUInt32(data, rssize, &offset, &s);
|
||||
|
||||
if(s > rssize || rssize - s < offset)
|
||||
{
|
||||
std::cerr << "RsGxsTunnelDHPublicKeyItem::() Size error while deserializing." << std::endl ;
|
||||
delete item ;
|
||||
return NULL ;
|
||||
}
|
||||
|
||||
item->public_key = BN_bin2bn(&((unsigned char *)data)[offset],s,NULL) ;
|
||||
offset += s ;
|
||||
|
||||
@ -380,11 +388,15 @@ RsGxsTunnelDataItem *RsGxsTunnelSerialiser::deserialise_RsGxsTunnelDataItem(void
|
||||
ok &= getRawUInt32(dat, rssize, &offset, &item->service_id);
|
||||
ok &= getRawUInt32(dat, rssize, &offset, &item->data_size);
|
||||
|
||||
if(offset + item->data_size <= size)
|
||||
if(item->data_size > rssize || rssize - item->data_size < offset)
|
||||
{
|
||||
item->data = (unsigned char*)malloc(item->data_size) ;
|
||||
std::cerr << "RsGxsTunnelDHPublicKeyItem::() Size error while deserializing." << std::endl ;
|
||||
delete item ;
|
||||
return NULL ;
|
||||
}
|
||||
item->data = (unsigned char*)rs_malloc(item->data_size) ;
|
||||
|
||||
if(dat == NULL)
|
||||
if(item->data == NULL)
|
||||
{
|
||||
delete item ;
|
||||
return NULL ;
|
||||
@ -392,9 +404,6 @@ RsGxsTunnelDataItem *RsGxsTunnelSerialiser::deserialise_RsGxsTunnelDataItem(void
|
||||
|
||||
memcpy(item->data,&((uint8_t*)dat)[offset],item->data_size) ;
|
||||
offset += item->data_size ;
|
||||
}
|
||||
else
|
||||
ok = false ;
|
||||
|
||||
|
||||
if (offset != rssize)
|
||||
|
@ -73,7 +73,7 @@ class RsGxsTunnelItem: public RsItem
|
||||
class RsGxsTunnelDataItem: public RsGxsTunnelItem
|
||||
{
|
||||
public:
|
||||
RsGxsTunnelDataItem() :RsGxsTunnelItem(RS_PKT_SUBTYPE_GXS_TUNNEL_DATA) { data=NULL ;data_size=0; }
|
||||
RsGxsTunnelDataItem() :RsGxsTunnelItem(RS_PKT_SUBTYPE_GXS_TUNNEL_DATA) { data=NULL ;data_size=0;service_id=0;unique_item_counter=0; }
|
||||
RsGxsTunnelDataItem(uint8_t subtype) :RsGxsTunnelItem(subtype) { data=NULL ;data_size=0; }
|
||||
|
||||
virtual ~RsGxsTunnelDataItem() {}
|
||||
@ -96,7 +96,7 @@ public:
|
||||
class RsGxsTunnelStatusItem: public RsGxsTunnelItem
|
||||
{
|
||||
public:
|
||||
RsGxsTunnelStatusItem() :RsGxsTunnelItem(RS_PKT_SUBTYPE_GXS_TUNNEL_STATUS) {}
|
||||
RsGxsTunnelStatusItem() :RsGxsTunnelItem(RS_PKT_SUBTYPE_GXS_TUNNEL_STATUS) , status(0) {}
|
||||
RsGxsTunnelStatusItem(void *data,uint32_t size) ; // deserialization
|
||||
|
||||
virtual ~RsGxsTunnelStatusItem() {}
|
||||
|
@ -361,7 +361,6 @@ HEADERS += chat/distantchat.h \
|
||||
|
||||
HEADERS += pqi/authssl.h \
|
||||
pqi/authgpg.h \
|
||||
pqi/rsmemory.h \
|
||||
pgp/pgphandler.h \
|
||||
pgp/pgpkeyutil.h \
|
||||
pgp/rsaes.h \
|
||||
@ -475,6 +474,7 @@ HEADERS += turtle/p3turtle.h \
|
||||
|
||||
HEADERS += util/folderiterator.h \
|
||||
util/rsdebug.h \
|
||||
util/rsmemory.h \
|
||||
util/rscompress.h \
|
||||
util/smallobject.h \
|
||||
util/rsdir.h \
|
||||
@ -631,6 +631,7 @@ SOURCES += util/folderiterator.cc \
|
||||
util/rscompress.cc \
|
||||
util/smallobject.cc \
|
||||
util/rsdir.cc \
|
||||
util/rsmemory.cc \
|
||||
util/rsdiscspace.cc \
|
||||
util/rsnet.cc \
|
||||
util/rsnet_ss.cc \
|
||||
|
@ -26,6 +26,7 @@ extern "C" {
|
||||
#include "retroshare/rspeers.h" // For rsicontrol.
|
||||
#include "util/rsdir.h"
|
||||
#include "util/rsdiscspace.h"
|
||||
#include "util/rsmemory.h"
|
||||
#include "pgp/pgpkeyutil.h"
|
||||
|
||||
static const uint32_t PGP_CERTIFICATE_LIMIT_MAX_NAME_SIZE = 64 ;
|
||||
@ -39,7 +40,11 @@ PassphraseCallback PGPHandler::_passphrase_callback = NULL ;
|
||||
|
||||
ops_keyring_t *PGPHandler::allocateOPSKeyring()
|
||||
{
|
||||
ops_keyring_t *kr = (ops_keyring_t*)malloc(sizeof(ops_keyring_t)) ;
|
||||
ops_keyring_t *kr = (ops_keyring_t*)rs_malloc(sizeof(ops_keyring_t)) ;
|
||||
|
||||
if(kr == NULL)
|
||||
return NULL ;
|
||||
|
||||
kr->nkeys = 0 ;
|
||||
kr->nkeys_allocated = 0 ;
|
||||
kr->keys = 0 ;
|
||||
|
@ -82,6 +82,8 @@ bool RsPluginManager::acceptablePluginName(const std::string& name)
|
||||
//
|
||||
#ifdef WINDOWS_SYS
|
||||
return name.size() > 4 && name.substr(name.size() - 4) == ".dll";
|
||||
#elif defined(__MACH__)
|
||||
return name.size() > 6 && !strcmp(name.c_str()+name.size()-6,".dylib") ;
|
||||
#else
|
||||
return name.size() > 3 && !strcmp(name.c_str()+name.size()-3,".so") ;
|
||||
#endif
|
||||
|
@ -117,10 +117,10 @@ static struct CRYPTO_dynlock_value *dyn_create_function(const char */*file*/, in
|
||||
{
|
||||
struct CRYPTO_dynlock_value *value;
|
||||
|
||||
value = (struct CRYPTO_dynlock_value*) malloc(sizeof(struct CRYPTO_dynlock_value));
|
||||
if (!value) {
|
||||
value = (struct CRYPTO_dynlock_value*) rs_malloc(sizeof(struct CRYPTO_dynlock_value));
|
||||
if (!value)
|
||||
return NULL;
|
||||
}
|
||||
|
||||
pthread_mutex_init(&value->mutex, NULL);
|
||||
|
||||
return value;
|
||||
@ -166,10 +166,10 @@ static void dyn_destroy_function(struct CRYPTO_dynlock_value *l, const char */*f
|
||||
bool tls_init()
|
||||
{
|
||||
/* static locks area */
|
||||
mutex_buf = (pthread_mutex_t*) malloc(CRYPTO_num_locks() * sizeof(pthread_mutex_t));
|
||||
if (mutex_buf == NULL) {
|
||||
mutex_buf = (pthread_mutex_t*) rs_malloc(CRYPTO_num_locks() * sizeof(pthread_mutex_t));
|
||||
if (mutex_buf == NULL)
|
||||
return false;
|
||||
}
|
||||
|
||||
for (int i = 0; i < CRYPTO_num_locks(); i++) {
|
||||
pthread_mutex_init(&mutex_buf[i], NULL);
|
||||
}
|
||||
@ -1259,7 +1259,11 @@ bool AuthSSLimpl::encrypt(void *&out, int &outlen, const void *in, int inlen,
|
||||
int out_offset = 0;
|
||||
|
||||
int max_evp_key_size = EVP_PKEY_size(public_key);
|
||||
ek = (unsigned char*)malloc(max_evp_key_size);
|
||||
ek = (unsigned char*)rs_malloc(max_evp_key_size);
|
||||
|
||||
if(ek == NULL)
|
||||
return false ;
|
||||
|
||||
const EVP_CIPHER *cipher = EVP_aes_128_cbc();
|
||||
int cipher_block_size = EVP_CIPHER_block_size(cipher);
|
||||
int size_net_ekl = sizeof(net_ekl);
|
||||
@ -1273,8 +1277,13 @@ bool AuthSSLimpl::encrypt(void *&out, int &outlen, const void *in, int inlen,
|
||||
}
|
||||
|
||||
// now assign memory to out accounting for data, and cipher block size, key length, and key length val
|
||||
out = (unsigned char*)malloc(inlen + cipher_block_size + size_net_ekl + eklen + EVP_MAX_IV_LENGTH);
|
||||
out = (unsigned char*)rs_malloc(inlen + cipher_block_size + size_net_ekl + eklen + EVP_MAX_IV_LENGTH);
|
||||
|
||||
if(out == NULL)
|
||||
{
|
||||
free(ek) ;
|
||||
return false ;
|
||||
}
|
||||
net_ekl = htonl(eklen);
|
||||
memcpy((unsigned char*)out + out_offset, &net_ekl, size_net_ekl);
|
||||
out_offset += size_net_ekl;
|
||||
@ -1343,6 +1352,12 @@ bool AuthSSLimpl::decrypt(void *&out, int &outlen, const void *in, int inlen)
|
||||
unsigned char iv[EVP_MAX_IV_LENGTH];
|
||||
int ek_mkl = EVP_PKEY_size(mOwnPrivateKey);
|
||||
ek = (unsigned char*)malloc(ek_mkl);
|
||||
|
||||
if(ek == NULL)
|
||||
{
|
||||
std::cerr << "(EE) Cannot allocate memory for " << ek_mkl << " bytes in " << __PRETTY_FUNCTION__ << std::endl;
|
||||
return false ;
|
||||
}
|
||||
EVP_CIPHER_CTX_init(&ctx);
|
||||
|
||||
int in_offset = 0, out_currOffset = 0;
|
||||
@ -1380,8 +1395,13 @@ bool AuthSSLimpl::decrypt(void *&out, int &outlen, const void *in, int inlen)
|
||||
return false;
|
||||
}
|
||||
|
||||
out = (unsigned char*)malloc(inlen - in_offset);
|
||||
out = (unsigned char*)rs_malloc(inlen - in_offset);
|
||||
|
||||
if(out == NULL)
|
||||
{
|
||||
free(ek) ;
|
||||
return false ;
|
||||
}
|
||||
if(!EVP_OpenUpdate(&ctx, (unsigned char*) out, &out_currOffset, (unsigned char*)in + in_offset, inlen - in_offset)) {
|
||||
free(ek);
|
||||
free(out) ;
|
||||
|
@ -27,6 +27,7 @@
|
||||
#include "pqi/authssl.h"
|
||||
#include "util/rsnet.h"
|
||||
#include "util/rsdir.h"
|
||||
#include "util/rsmemory.h"
|
||||
|
||||
// #define DEBUG_PQIBIN
|
||||
|
||||
@ -314,7 +315,13 @@ BinMemInterface::BinMemInterface(int defsize, int flags)
|
||||
:bin_flags(flags), buf(NULL), size(defsize),
|
||||
recvsize(0), readloc(0), hash(NULL), bcount(0)
|
||||
{
|
||||
buf = malloc(defsize);
|
||||
buf = rs_malloc(defsize);
|
||||
|
||||
if(buf == NULL)
|
||||
{
|
||||
close() ;
|
||||
return ;
|
||||
}
|
||||
if (bin_flags & BIN_FLAGS_HASH_DATA)
|
||||
{
|
||||
hash = new pqihash();
|
||||
@ -326,7 +333,13 @@ BinMemInterface::BinMemInterface(const void *data, const int defsize, int flags)
|
||||
:bin_flags(flags), buf(NULL), size(defsize),
|
||||
recvsize(0), readloc(0), hash(NULL), bcount(0)
|
||||
{
|
||||
buf = malloc(defsize);
|
||||
buf = rs_malloc(defsize);
|
||||
|
||||
if(buf == NULL)
|
||||
{
|
||||
close() ;
|
||||
return ;
|
||||
}
|
||||
if (bin_flags & BIN_FLAGS_HASH_DATA)
|
||||
{
|
||||
hash = new pqihash();
|
||||
|
@ -290,7 +290,11 @@ bool getLocalAddresses(std::list<sockaddr_storage> & addrs)
|
||||
#ifdef WINDOWS_SYS
|
||||
// Seems strange to me but M$ documentation suggests to allocate this way...
|
||||
DWORD bf_size = 16000;
|
||||
IP_ADAPTER_ADDRESSES* adapter_addresses = (IP_ADAPTER_ADDRESSES*) malloc(bf_size);
|
||||
IP_ADAPTER_ADDRESSES* adapter_addresses = (IP_ADAPTER_ADDRESSES*) rs_malloc(bf_size);
|
||||
|
||||
if(adapter_addresses == NULL)
|
||||
return false ;
|
||||
|
||||
DWORD error = GetAdaptersAddresses(AF_UNSPEC,
|
||||
GAA_FLAG_SKIP_MULTICAST |
|
||||
GAA_FLAG_SKIP_DNS_SERVER |
|
||||
|
@ -46,6 +46,7 @@
|
||||
#include <fstream>
|
||||
|
||||
#include "util/rsdebug.h"
|
||||
#include "util/rsmemory.h"
|
||||
#include "util/rsstring.h"
|
||||
|
||||
//
|
||||
@ -194,7 +195,12 @@ int pqistore::writePkt(RsItem *pqi)
|
||||
#endif
|
||||
|
||||
uint32_t pktsize = rsSerialiser->size(pqi);
|
||||
void *ptr = malloc(pktsize);
|
||||
|
||||
RsTemporaryMemory ptr(pktsize) ;
|
||||
|
||||
if(ptr == NULL)
|
||||
return 0 ;
|
||||
|
||||
if (!(rsSerialiser->serialise(pqi, ptr, &pktsize)))
|
||||
{
|
||||
#ifdef PQISTORE_DEBUG
|
||||
@ -203,7 +209,6 @@ int pqistore::writePkt(RsItem *pqi)
|
||||
pqioutput(PQL_ALERT, pqistorezone, out);
|
||||
#endif
|
||||
|
||||
free(ptr);
|
||||
if (!(bio_flags & BIN_FLAGS_NO_DELETE))
|
||||
delete pqi;
|
||||
return 0;
|
||||
@ -218,7 +223,6 @@ int pqistore::writePkt(RsItem *pqi)
|
||||
pqi -> print_string(out);
|
||||
pqioutput(PQL_ALERT, pqistorezone, out);
|
||||
|
||||
free(ptr);
|
||||
if (!(bio_flags & BIN_FLAGS_NO_DELETE))
|
||||
delete pqi;
|
||||
return 0;
|
||||
@ -232,7 +236,6 @@ int pqistore::writePkt(RsItem *pqi)
|
||||
pqi -> print_string(out);
|
||||
pqioutput(PQL_ALERT, pqistorezone, out);
|
||||
|
||||
free(ptr);
|
||||
if (!(bio_flags & BIN_FLAGS_NO_DELETE))
|
||||
delete pqi;
|
||||
|
||||
@ -250,7 +253,6 @@ int pqistore::writePkt(RsItem *pqi)
|
||||
pqioutput(PQL_ALERT, pqistorezone, out);
|
||||
#endif
|
||||
|
||||
free(ptr);
|
||||
if (!(bio_flags & BIN_FLAGS_NO_DELETE))
|
||||
delete pqi;
|
||||
|
||||
@ -262,7 +264,6 @@ int pqistore::writePkt(RsItem *pqi)
|
||||
pqioutput(PQL_DEBUG_BASIC, pqistorezone, out);
|
||||
#endif
|
||||
|
||||
free(ptr);
|
||||
if (!(bio_flags & BIN_FLAGS_NO_DELETE))
|
||||
delete pqi;
|
||||
|
||||
@ -288,7 +289,10 @@ int pqistore::readPkt(RsItem **item_out)
|
||||
|
||||
// initial read size: basic packet.
|
||||
int blen = getRsPktBaseSize();
|
||||
void *block = malloc(blen);
|
||||
void *block = rs_malloc(blen);
|
||||
|
||||
if(block == NULL)
|
||||
return false ;
|
||||
|
||||
int tmplen;
|
||||
/* we have the header */
|
||||
@ -495,7 +499,10 @@ int pqiSSLstore::readPkt(RsItem **item_out)
|
||||
|
||||
// initial read size: basic packet.
|
||||
int blen = getRsPktBaseSize();
|
||||
void *block = malloc(blen);
|
||||
void *block = rs_malloc(blen);
|
||||
|
||||
if(block == NULL)
|
||||
return false ;
|
||||
|
||||
int tmplen;
|
||||
/* we have the header */
|
||||
|
@ -315,7 +315,11 @@ int pqistreamer::queue_outpqi_locked(RsItem *pqi,uint32_t& pktsize)
|
||||
/* decide which type of packet it is */
|
||||
|
||||
pktsize = mRsSerialiser->size(pqi);
|
||||
void *ptr = malloc(pktsize);
|
||||
void *ptr = rs_malloc(pktsize);
|
||||
|
||||
if(ptr == NULL)
|
||||
return 0 ;
|
||||
|
||||
|
||||
#ifdef DEBUG_PQISTREAMER
|
||||
std::cerr << "pqistreamer::queue_outpqi() serializing packet with packet size : " << pktsize << std::endl;
|
||||
@ -441,7 +445,6 @@ int pqistreamer::handleoutgoing_locked()
|
||||
mPkt_wpending_size = 0 ;
|
||||
}
|
||||
|
||||
outSentBytes_locked(sentbytes);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -469,10 +472,10 @@ int pqistreamer::handleoutgoing_locked()
|
||||
}
|
||||
#endif
|
||||
|
||||
outSentBytes_locked(sentbytes);
|
||||
return 0;
|
||||
}
|
||||
#define GROUP_OUTGOING_PACKETS 1
|
||||
#define PACKET_GROUPING_SIZE_LIMIT 32768
|
||||
// send a out_pkt., else send out_data. unless
|
||||
// there is a pending packet.
|
||||
if (!mPkt_wpending)
|
||||
@ -482,7 +485,7 @@ int pqistreamer::handleoutgoing_locked()
|
||||
mPkt_wpending_size = 0 ;
|
||||
int k=0;
|
||||
|
||||
while(mPkt_wpending_size < maxbytes && (dta = locked_pop_out_data())!=NULL )
|
||||
while(mPkt_wpending_size < (uint32_t)maxbytes && mPkt_wpending_size < PACKET_GROUPING_SIZE_LIMIT && (dta = locked_pop_out_data())!=NULL )
|
||||
{
|
||||
uint32_t s = getRsItemSize(dta);
|
||||
mPkt_wpending = realloc(mPkt_wpending,s+mPkt_wpending_size) ;
|
||||
@ -524,12 +527,12 @@ int pqistreamer::handleoutgoing_locked()
|
||||
pqioutput(PQL_DEBUG_BASIC, pqistreamerzone, out);
|
||||
#endif
|
||||
|
||||
outSentBytes_locked(sentbytes);
|
||||
// pkt_wpending will kept til next time.
|
||||
// ensuring exactly the same data is written (openSSL requirement).
|
||||
return -1;
|
||||
}
|
||||
++nsent;
|
||||
outSentBytes_locked(mPkt_wpending_size); // this is the only time where we know exactly what was sent.
|
||||
|
||||
#ifdef DEBUG_TRANSFERS
|
||||
std::cerr << "pqistreamer::handleoutgoing_locked() Sent Packet len: " << mPkt_wpending_size << " @ " << RsUtil::AccurateTimeString();
|
||||
@ -549,7 +552,6 @@ int pqistreamer::handleoutgoing_locked()
|
||||
if(nsent > 0)
|
||||
std::cerr << "nsent = " << nsent << ", total bytes=" << sentbytes << std::endl;
|
||||
#endif
|
||||
outSentBytes_locked(sentbytes);
|
||||
return 1;
|
||||
}
|
||||
|
||||
@ -568,7 +570,6 @@ int pqistreamer::handleincoming_locked()
|
||||
if(!(mBio->isactive()))
|
||||
{
|
||||
mReading_state = reading_state_initial ;
|
||||
inReadBytes_locked(readbytes);
|
||||
free_rpend_locked();
|
||||
return 0;
|
||||
}
|
||||
@ -606,8 +607,6 @@ start_packet_read:
|
||||
{
|
||||
pqioutput(PQL_DEBUG_BASIC, pqistreamerzone, "pqistreamer::handleincoming() Didn't read BasePkt!");
|
||||
|
||||
inReadBytes_locked(readbytes);
|
||||
|
||||
// error.... (either blocked or failure)
|
||||
if (tmplen == 0)
|
||||
{
|
||||
@ -824,6 +823,8 @@ continue_packet:
|
||||
std::cerr << "[" << (void*)pthread_self() << "] " << "deserializing. Size=" << pktlen << std::endl ;
|
||||
#endif
|
||||
|
||||
inReadBytes_locked(pktlen); // only count deserialised packets, because that's what is actually been transfered.
|
||||
|
||||
RsItem *pkt = mRsSerialiser->deserialise(block, &pktlen);
|
||||
|
||||
if ((pkt != NULL) && (0 < handleincomingitem_locked(pkt,pktlen)))
|
||||
@ -854,7 +855,6 @@ continue_packet:
|
||||
}
|
||||
#endif
|
||||
|
||||
inReadBytes_locked(readbytes);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -1045,7 +1045,10 @@ void pqistreamer::allocate_rpend_locked()
|
||||
return;
|
||||
|
||||
mPkt_rpend_size = getRsPktMaxSize();
|
||||
mPkt_rpending = malloc(mPkt_rpend_size);
|
||||
mPkt_rpending = rs_malloc(mPkt_rpend_size);
|
||||
|
||||
if(mPkt_rpending == NULL)
|
||||
return ;
|
||||
|
||||
// avoid uninitialized (and random) memory read.
|
||||
memset(mPkt_rpending,0,mPkt_rpend_size) ;
|
||||
|
@ -87,7 +87,7 @@ class GxsReputation
|
||||
class RsGxsIdGroup
|
||||
{
|
||||
public:
|
||||
RsGxsIdGroup(): mLastUsageTS(0), mPgpKnown(false) { return; }
|
||||
RsGxsIdGroup(): mLastUsageTS(0), mPgpKnown(false),mIsAContact(false) { return; }
|
||||
~RsGxsIdGroup() { return; }
|
||||
|
||||
|
||||
|
@ -464,10 +464,11 @@ virtual void getOwnAvatarData(unsigned char *& data,int& size) = 0 ;
|
||||
/****************************************/
|
||||
|
||||
virtual bool joinVisibleChatLobby(const ChatLobbyId& lobby_id,const RsGxsId& own_id) = 0 ;
|
||||
virtual bool isLobbyId(const RsPeerId& virtual_peer_id,ChatLobbyId& lobby_id) = 0;
|
||||
virtual bool getVirtualPeerId(const ChatLobbyId& lobby_id,RsPeerId& vpid) = 0;
|
||||
/// get ids of subscribed lobbies
|
||||
virtual void getChatLobbyList(std::list<ChatLobbyId>& cl_list) = 0;
|
||||
/// get lobby info of a subscribed chat lobby. Returns true if lobby id is valid.
|
||||
virtual bool getChatLobbyInfo(const ChatLobbyId& id,ChatLobbyInfo& info) = 0 ;
|
||||
/// get info about all lobbies, subscribed and unsubscribed
|
||||
virtual void getListOfNearbyChatLobbies(std::vector<VisibleChatLobbyRecord>& public_lobbies) = 0 ;
|
||||
virtual void invitePeerToLobby(const ChatLobbyId& lobby_id,const RsPeerId& peer_id) = 0;
|
||||
virtual bool acceptLobbyInvite(const ChatLobbyId& id,const RsGxsId& identity) = 0 ;
|
||||
|
@ -160,7 +160,7 @@ class RsPlugin
|
||||
// creates a new resource api handler object. ownership is transferred to the caller.
|
||||
// the caller should supply a statetokenserver, and keep it valid until destruction
|
||||
// the plugin should return a entry point name. this is to make the entry point name independent from file names
|
||||
virtual resource_api::ResourceRouter* new_resource_api_handler(const RsPlugInInterfaces& ifaces, resource_api::StateTokenServer* sts, std::string &entrypoint) const { return 0;}
|
||||
virtual resource_api::ResourceRouter* new_resource_api_handler(const RsPlugInInterfaces& /* ifaces */, resource_api::StateTokenServer* /* sts */, std::string & /*entrypoint*/) const { return 0;}
|
||||
|
||||
// Shutdown
|
||||
virtual void stop() {}
|
||||
|
@ -41,6 +41,8 @@ public:
|
||||
|
||||
struct ReputationInfo
|
||||
{
|
||||
ReputationInfo() : mOwnOpinion(OPINION_NEUTRAL), mOverallReputationScore(REPUTATION_THRESHOLD_DEFAULT), mFriendAverage(REPUTATION_THRESHOLD_DEFAULT),mAssessment(ASSESSMENT_OK){}
|
||||
|
||||
RsReputations::Opinion mOwnOpinion ;
|
||||
float mOverallReputationScore ;
|
||||
float mFriendAverage ;
|
||||
|
@ -444,15 +444,6 @@ void p3Msgs::setCustomStateString(const std::string& state_string)
|
||||
mChatSrv->setOwnCustomStateString(state_string) ;
|
||||
}
|
||||
|
||||
bool p3Msgs::getVirtualPeerId(const ChatLobbyId& id,RsPeerId& peer_id)
|
||||
{
|
||||
return mChatSrv->getVirtualPeerId(id,peer_id) ;
|
||||
}
|
||||
bool p3Msgs::isLobbyId(const RsPeerId& peer_id,ChatLobbyId& id)
|
||||
{
|
||||
return mChatSrv->isLobbyId(peer_id,id) ;
|
||||
}
|
||||
|
||||
bool p3Msgs::getChatLobbyInfo(const ChatLobbyId& id,ChatLobbyInfo& linfo)
|
||||
{
|
||||
return mChatSrv->getChatLobbyInfo(id,linfo) ;
|
||||
|
@ -138,8 +138,6 @@ class p3Msgs: public RsMsgs
|
||||
|
||||
virtual bool joinVisibleChatLobby(const ChatLobbyId& id, const RsGxsId &own_id) ;
|
||||
virtual void getListOfNearbyChatLobbies(std::vector<VisibleChatLobbyRecord>& public_lobbies) ;
|
||||
virtual bool getVirtualPeerId(const ChatLobbyId& id,RsPeerId& vpid) ;
|
||||
virtual bool isLobbyId(const RsPeerId& virtual_peer_id,ChatLobbyId& lobby_id) ;
|
||||
virtual void getChatLobbyList(std::list<ChatLobbyId>& cl_list) ;
|
||||
virtual bool getChatLobbyInfo(const ChatLobbyId& id,ChatLobbyInfo& info) ;
|
||||
virtual void invitePeerToLobby(const ChatLobbyId&, const RsPeerId&) ;
|
||||
|
@ -273,7 +273,13 @@ bool RsLoginHandler::tryAutoLogin(const RsPeerId& ssl_id,std::string& ssl_passwd
|
||||
fseek(fp, 0, SEEK_END);
|
||||
datalen = ftell(fp);
|
||||
fseek(fp, 0, SEEK_SET);
|
||||
dataptr = (char *) malloc(datalen);
|
||||
dataptr = (char *) rs_malloc(datalen);
|
||||
|
||||
if(data_ptr == NULL)
|
||||
{
|
||||
fclose(fp);
|
||||
return false;
|
||||
}
|
||||
fread(dataptr, 1, datalen, fp);
|
||||
fclose(fp);
|
||||
|
||||
|
@ -40,6 +40,7 @@ bool getRawUInt8(void *data, uint32_t size, uint32_t *offset, uint8_t *out)
|
||||
/* first check there is space */
|
||||
if (size < *offset + 1)
|
||||
{
|
||||
std::cerr << "(EE) Cannot deserialise uint8_t: not enough size." << std::endl;
|
||||
return false;
|
||||
}
|
||||
void *buf = (void *) &(((uint8_t *) data)[*offset]);
|
||||
@ -56,6 +57,7 @@ bool setRawUInt8(void *data, uint32_t size, uint32_t *offset, uint8_t in)
|
||||
/* first check there is space */
|
||||
if (size < *offset + 1)
|
||||
{
|
||||
std::cerr << "(EE) Cannot serialise uint8_t: not enough size." << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -74,6 +76,7 @@ bool getRawUInt16(void *data, uint32_t size, uint32_t *offset, uint16_t *out)
|
||||
/* first check there is space */
|
||||
if (size < *offset + 2)
|
||||
{
|
||||
std::cerr << "(EE) Cannot deserialise uint16_t: not enough size." << std::endl;
|
||||
return false;
|
||||
}
|
||||
void *buf = (void *) &(((uint8_t *) data)[*offset]);
|
||||
@ -92,6 +95,7 @@ bool setRawUInt16(void *data, uint32_t size, uint32_t *offset, uint16_t in)
|
||||
/* first check there is space */
|
||||
if (size < *offset + 2)
|
||||
{
|
||||
std::cerr << "(EE) Cannot serialise uint16_t: not enough size." << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -114,6 +118,7 @@ bool getRawUInt32(void *data, uint32_t size, uint32_t *offset, uint32_t *out)
|
||||
/* first check there is space */
|
||||
if (size < *offset + 4)
|
||||
{
|
||||
std::cerr << "(EE) Cannot deserialise uint32_t: not enough size." << std::endl;
|
||||
return false;
|
||||
}
|
||||
void *buf = (void *) &(((uint8_t *) data)[*offset]);
|
||||
@ -132,6 +137,7 @@ bool setRawUInt32(void *data, uint32_t size, uint32_t *offset, uint32_t in)
|
||||
/* first check there is space */
|
||||
if (size < *offset + 4)
|
||||
{
|
||||
std::cerr << "(EE) Cannot serialise uint32_t: not enough size." << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -154,6 +160,7 @@ bool getRawUInt64(void *data, uint32_t size, uint32_t *offset, uint64_t *out)
|
||||
/* first check there is space */
|
||||
if (size < *offset + 8)
|
||||
{
|
||||
std::cerr << "(EE) Cannot deserialise uint64_t: not enough size." << std::endl;
|
||||
return false;
|
||||
}
|
||||
void *buf = (void *) &(((uint8_t *) data)[*offset]);
|
||||
@ -172,6 +179,7 @@ bool setRawUInt64(void *data, uint32_t size, uint32_t *offset, uint64_t in)
|
||||
/* first check there is space */
|
||||
if (size < *offset + 8)
|
||||
{
|
||||
std::cerr << "(EE) Cannot serialise uint64_t: not enough size." << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -231,12 +239,13 @@ bool getRawString(void *data, uint32_t size, uint32_t *offset, std::string &outS
|
||||
}
|
||||
|
||||
/* check there is space for string */
|
||||
if (size < *offset + len)
|
||||
if(len > size || size-len < *offset) // better than if(size < *offset + len) because it avoids integer overflow
|
||||
{
|
||||
std::cerr << "getRawString() not enough size" << std::endl;
|
||||
return false;
|
||||
}
|
||||
uint8_t *buf = &(((uint8_t *) data)[*offset]);
|
||||
|
||||
for (uint32_t i = 0; i < len; i++)
|
||||
{
|
||||
outStr += buf[i];
|
||||
@ -250,11 +259,10 @@ bool setRawString(void *data, uint32_t size, uint32_t *offset, const std::string
|
||||
{
|
||||
uint32_t len = inStr.length();
|
||||
/* first check there is space */
|
||||
if (size < *offset + 4 + len)
|
||||
|
||||
if(size < 4 || len > size-4 || size-len-4 < *offset) // better than if(size < *offset + len + 4) because it avoids integer overflow
|
||||
{
|
||||
//#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "setRawString() Not enough size" << std::endl;
|
||||
//#endif
|
||||
return false;
|
||||
}
|
||||
|
||||
|
@ -899,7 +899,144 @@ RsMsgGRouterMap* RsMsgSerialiser::deserialiseMsgGRouterMap(void* data, uint32_t*
|
||||
|
||||
/************************* end of definition of msgGRouterMap serialisation functions ************************/
|
||||
|
||||
/************************* definition of msgDistantMessageMap serialisation functions ************************/
|
||||
|
||||
std::ostream& RsMsgDistantMessagesHashMap::print(std::ostream& out, uint16_t indent)
|
||||
{
|
||||
printRsItemBase(out, "RsMsgDistantMessagesHashMap", indent);
|
||||
uint16_t int_Indent = indent + 2;
|
||||
|
||||
for(std::map<Sha1CheckSum,uint32_t>::const_iterator it(hash_map.begin());it!=hash_map.end();++it)
|
||||
{
|
||||
printIndent(out, int_Indent);
|
||||
out << " " << std::hex << it->first << std::dec << " : " << it->second << std::endl;
|
||||
}
|
||||
|
||||
printRsItemEnd(out, "RsMsgDistantMessagesHashMap", indent);
|
||||
|
||||
return out;
|
||||
}
|
||||
|
||||
void RsMsgDistantMessagesHashMap::clear()
|
||||
{
|
||||
hash_map.clear() ;
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
uint32_t RsMsgDistantMessagesHashMap::serial_size(bool)
|
||||
{
|
||||
uint32_t s = 8; /* header */
|
||||
|
||||
s += 4; // number of entries
|
||||
s += (Sha1CheckSum::SIZE_IN_BYTES+4)*hash_map.size(); // entries
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
bool RsMsgDistantMessagesHashMap::serialise(void *data, uint32_t& pktsize,bool config)
|
||||
{
|
||||
uint32_t tlvsize = serial_size(config) ;
|
||||
uint32_t offset = 0;
|
||||
|
||||
if (pktsize < tlvsize)
|
||||
return false; /* not enough space */
|
||||
|
||||
pktsize = tlvsize;
|
||||
|
||||
bool ok = true;
|
||||
|
||||
ok &= setRsItemHeader(data, tlvsize, PacketId(), tlvsize);
|
||||
|
||||
#ifdef RSSERIAL_DEBUG
|
||||
std::cerr << "RsMsgSerialiser::serialiseMsgDistantMessagesHashMap() Header: " << ok << std::endl;
|
||||
std::cerr << "RsMsgSerialiser::serialiseMsgDistantMessagesHashMap() Size: " << tlvsize << std::endl;
|
||||
#endif
|
||||
|
||||
/* skip the header */
|
||||
offset += 8;
|
||||
|
||||
ok &= setRawUInt32(data, tlvsize, &offset, hash_map.size());
|
||||
|
||||
for(std::map<Sha1CheckSum,uint32_t>::const_iterator it=hash_map.begin();ok && it!=hash_map.end();++it)
|
||||
{
|
||||
ok &= it->first.serialise(data, tlvsize, offset) ;
|
||||
ok &= setRawUInt32(data, tlvsize, &offset, it->second);
|
||||
}
|
||||
|
||||
if (offset != tlvsize)
|
||||
{
|
||||
ok = false;
|
||||
std::cerr << "RsMsgSerialiser::serialiseMsgDistantMessagesHashMap() Size Error! " << std::endl;
|
||||
}
|
||||
|
||||
return ok;
|
||||
}
|
||||
|
||||
RsMsgDistantMessagesHashMap* RsMsgSerialiser::deserialiseMsgDistantMessageHashMap(void* data, uint32_t* pktsize)
|
||||
{
|
||||
/* get the type and size */
|
||||
uint32_t rstype = getRsItemId(data);
|
||||
uint32_t rssize = getRsItemSize(data);
|
||||
|
||||
uint32_t offset = 0;
|
||||
|
||||
|
||||
if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) ||
|
||||
(RS_SERVICE_TYPE_MSG != getRsItemService(rstype)) ||
|
||||
(RS_PKT_SUBTYPE_MSG_DISTANT_MSG_MAP != getRsItemSubType(rstype)))
|
||||
{
|
||||
return NULL; /* wrong type */
|
||||
}
|
||||
|
||||
if (*pktsize < rssize) /* check size */
|
||||
return NULL; /* not enough data */
|
||||
|
||||
/* set the packet length */
|
||||
*pktsize = rssize;
|
||||
|
||||
bool ok = true;
|
||||
|
||||
/* ready to load */
|
||||
RsMsgDistantMessagesHashMap *item = new RsMsgDistantMessagesHashMap();
|
||||
item->clear();
|
||||
|
||||
/* skip the header */
|
||||
offset += 8;
|
||||
|
||||
uint32_t s=0 ;
|
||||
|
||||
/* get mandatory parts first */
|
||||
ok &= getRawUInt32(data, rssize, &offset, &s);
|
||||
|
||||
for(uint32_t i=0;i<s && ok;++i)
|
||||
{
|
||||
Sha1CheckSum s ;
|
||||
uint32_t tm ;
|
||||
|
||||
ok &= s.deserialise(data, rssize, offset) ;
|
||||
ok &= getRawUInt32(data, rssize, &offset, &tm);
|
||||
|
||||
item->hash_map.insert(std::make_pair(s,tm)) ;
|
||||
}
|
||||
|
||||
if (offset != rssize)
|
||||
{
|
||||
/* error */
|
||||
std::cerr << "(EE) size error in packet deserialisation: p3MsgItem, subtype " << getRsItemSubType(rstype) << ". offset=" << offset << " != rssize=" << rssize << std::endl;
|
||||
delete item;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (!ok)
|
||||
{
|
||||
std::cerr << "(EE) size error in packet deserialisation: p3MsgItem, subtype " << getRsItemSubType(rstype) << std::endl;
|
||||
delete item;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return item;
|
||||
}
|
||||
/************************************** Message ParentId **********************/
|
||||
|
||||
std::ostream& RsMsgParentId::print(std::ostream& out, uint16_t indent)
|
||||
@ -1042,27 +1179,14 @@ RsItem* RsMsgSerialiser::deserialise(void *data, uint32_t *pktsize)
|
||||
|
||||
switch(getRsItemSubType(rstype))
|
||||
{
|
||||
case RS_PKT_SUBTYPE_DEFAULT:
|
||||
return deserialiseMsgItem(data, pktsize);
|
||||
break;
|
||||
case RS_PKT_SUBTYPE_MSG_SRC_TAG:
|
||||
return deserialiseMsgSrcIdItem(data, pktsize);
|
||||
break;
|
||||
case RS_PKT_SUBTYPE_MSG_PARENT_TAG:
|
||||
return deserialiseMsgParentIdItem(data, pktsize);
|
||||
break;
|
||||
case RS_PKT_SUBTYPE_MSG_TAG_TYPE:
|
||||
return deserialiseTagItem(data, pktsize);
|
||||
break;
|
||||
case RS_PKT_SUBTYPE_MSG_INVITE:
|
||||
return deserialisePublicMsgInviteConfigItem(data, pktsize);
|
||||
break;
|
||||
case RS_PKT_SUBTYPE_MSG_TAGS:
|
||||
return deserialiseMsgTagItem(data, pktsize);
|
||||
break;
|
||||
case RS_PKT_SUBTYPE_MSG_GROUTER_MAP:
|
||||
return deserialiseMsgGRouterMap(data, pktsize);
|
||||
break;
|
||||
case RS_PKT_SUBTYPE_DEFAULT: return deserialiseMsgItem(data, pktsize);
|
||||
case RS_PKT_SUBTYPE_MSG_SRC_TAG: return deserialiseMsgSrcIdItem(data, pktsize);
|
||||
case RS_PKT_SUBTYPE_MSG_PARENT_TAG: return deserialiseMsgParentIdItem(data, pktsize);
|
||||
case RS_PKT_SUBTYPE_MSG_TAG_TYPE: return deserialiseTagItem(data, pktsize);
|
||||
case RS_PKT_SUBTYPE_MSG_INVITE: return deserialisePublicMsgInviteConfigItem(data, pktsize);
|
||||
case RS_PKT_SUBTYPE_MSG_TAGS: return deserialiseMsgTagItem(data, pktsize);
|
||||
case RS_PKT_SUBTYPE_MSG_GROUTER_MAP: return deserialiseMsgGRouterMap(data, pktsize);
|
||||
case RS_PKT_SUBTYPE_MSG_DISTANT_MSG_MAP: return deserialiseMsgDistantMessageHashMap(data, pktsize);
|
||||
default:
|
||||
return NULL;
|
||||
break;
|
||||
|
@ -51,6 +51,7 @@ const uint8_t RS_PKT_SUBTYPE_MSG_SRC_TAG = 0x05;
|
||||
const uint8_t RS_PKT_SUBTYPE_MSG_PARENT_TAG = 0x06;
|
||||
const uint8_t RS_PKT_SUBTYPE_MSG_INVITE = 0x07;
|
||||
const uint8_t RS_PKT_SUBTYPE_MSG_GROUTER_MAP = 0x08;
|
||||
const uint8_t RS_PKT_SUBTYPE_MSG_DISTANT_MSG_MAP = 0x09;
|
||||
|
||||
|
||||
/**************************************************************************/
|
||||
@ -226,7 +227,23 @@ class RsMsgGRouterMap : public RsMessageItem
|
||||
//
|
||||
std::map<GRouterMsgPropagationId,uint32_t> ongoing_msgs ;
|
||||
};
|
||||
class RsMsgDistantMessagesHashMap : public RsMessageItem
|
||||
{
|
||||
public:
|
||||
RsMsgDistantMessagesHashMap() : RsMessageItem(RS_PKT_SUBTYPE_MSG_DISTANT_MSG_MAP) {}
|
||||
|
||||
std::ostream &print(std::ostream &out, uint16_t indent = 0);
|
||||
|
||||
virtual bool serialise(void *data,uint32_t& size,bool config) ;
|
||||
virtual uint32_t serial_size(bool config) ;
|
||||
|
||||
virtual ~RsMsgDistantMessagesHashMap() {}
|
||||
virtual void clear();
|
||||
|
||||
// ----------- Specific fields ------------- //
|
||||
//
|
||||
std::map<Sha1CheckSum,uint32_t> hash_map ;
|
||||
};
|
||||
class RsMsgParentId : public RsMessageItem
|
||||
{
|
||||
public:
|
||||
@ -276,6 +293,7 @@ class RsMsgSerialiser: public RsSerialType
|
||||
virtual RsMsgParentId *deserialiseMsgParentIdItem(void *data, uint32_t *size);
|
||||
virtual RsPublicMsgInviteConfigItem *deserialisePublicMsgInviteConfigItem(void *data, uint32_t *size);
|
||||
virtual RsMsgGRouterMap *deserialiseMsgGRouterMap(void *data, uint32_t *size);
|
||||
virtual RsMsgDistantMessagesHashMap *deserialiseMsgDistantMessageHashMap(void *data, uint32_t *size);
|
||||
|
||||
bool m_bConfiguration; // is set to true for saving configuration (enables serialising msgId)
|
||||
};
|
||||
|
@ -34,6 +34,7 @@
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#include "util/rsmemory.h"
|
||||
#include "retroshare/rstypes.h"
|
||||
|
||||
/*******************************************************************
|
||||
@ -181,7 +182,7 @@ class RsRawItem: public RsItem
|
||||
RsRawItem(uint32_t t, uint32_t size)
|
||||
:RsItem(t), len(size)
|
||||
{
|
||||
data = malloc(len);
|
||||
data = rs_malloc(len);
|
||||
}
|
||||
|
||||
virtual ~RsRawItem()
|
||||
|
@ -24,6 +24,7 @@
|
||||
*
|
||||
*/
|
||||
|
||||
#include "util/rsmemory.h"
|
||||
#include "serialiser/rstlvbinary.h"
|
||||
|
||||
#include "serialiser/rstlvbase.h"
|
||||
@ -78,7 +79,11 @@ bool RsTlvBinaryData::setBinData(const void *data, uint32_t size)
|
||||
return true;
|
||||
}
|
||||
|
||||
bin_data = malloc(bin_len);
|
||||
bin_data = rs_malloc(bin_len);
|
||||
|
||||
if(bin_data == NULL)
|
||||
return false ;
|
||||
|
||||
memcpy(bin_data, data, bin_len);
|
||||
return true;
|
||||
}
|
||||
|
@ -916,6 +916,12 @@ bool SSGxsChannelGroup::load(const std::string &input)
|
||||
mAutoDownload = false;
|
||||
mDownloadDirectory.clear();
|
||||
|
||||
if(input.empty())
|
||||
{
|
||||
std::cerr << "(EE) SSGxsChannelGroup::load() asked to load a null string. Weird." << std::endl;
|
||||
return false ;
|
||||
}
|
||||
|
||||
RsTemporaryMemory tmpmem(input.length());
|
||||
|
||||
if (1 == sscanf(input.c_str(), "D:%d", &download_val))
|
||||
|
@ -98,7 +98,8 @@ void RsGxsImage::take(uint8_t *data, uint32_t size)
|
||||
// NB Must make sure that we always use malloc/free for this data.
|
||||
uint8_t *RsGxsImage::allocate(uint32_t size)
|
||||
{
|
||||
uint8_t *val = (uint8_t *) malloc(size);
|
||||
uint8_t *val = (uint8_t *) rs_malloc(size);
|
||||
|
||||
#ifdef DEBUG_GXSCOMMON
|
||||
std::cerr << "RsGxsImage()::allocate(" << (void *) val << ")";
|
||||
std::cerr << std::endl;
|
||||
|
@ -51,7 +51,9 @@
|
||||
#include "util/rsstring.h"
|
||||
#include "util/radix64.h"
|
||||
#include "util/rsrandom.h"
|
||||
#include "util/rsmemory.h"
|
||||
#include "util/rsprint.h"
|
||||
#include "util/rsthreads.h"
|
||||
|
||||
#include <unistd.h>
|
||||
#include <iomanip>
|
||||
@ -67,6 +69,8 @@ using namespace Rs::Msgs;
|
||||
|
||||
const int msgservicezone = 54319;
|
||||
|
||||
static const uint32_t RS_MSG_DISTANT_MESSAGE_HASH_KEEP_TIME = 2*30*86400 ; // keep msg hashes for 2 months to avoid re-sent msgs
|
||||
|
||||
/* Another little hack ..... unique message Ids
|
||||
* will be handled in this class.....
|
||||
* These are unique within this run of the server,
|
||||
@ -78,13 +82,15 @@ const int msgservicezone = 54319;
|
||||
* (3) from storage...
|
||||
*/
|
||||
|
||||
|
||||
p3MsgService::p3MsgService(p3ServiceControl *sc, p3IdService *id_serv)
|
||||
:p3Service(), p3Config(), mIdService(id_serv), mServiceCtrl(sc), mMsgMtx("p3MsgService"), mMsgUniqueId(time(NULL))
|
||||
:p3Service(), p3Config(), mIdService(id_serv), mServiceCtrl(sc), mMsgMtx("p3MsgService"), mMsgUniqueId(0)
|
||||
{
|
||||
_serialiser = new RsMsgSerialiser();
|
||||
_serialiser = new RsMsgSerialiser(); // this serialiser is used for services. It's not the same than the one returned by setupSerialiser(). We need both!!
|
||||
addSerialType(_serialiser);
|
||||
|
||||
mMsgUniqueId = 1 ; // MsgIds are not transmitted, but only used locally as a storage index. As such, thay do not need to be different
|
||||
// at friends nodes.
|
||||
|
||||
mShouldEnableDistantMessaging = true ;
|
||||
mDistantMessagingEnabled = false ;
|
||||
mDistantMessagePermissions = RS_DISTANT_MESSAGING_CONTACT_PERMISSION_FLAG_FILTER_NONE ;
|
||||
@ -114,7 +120,7 @@ RsServiceInfo p3MsgService::getServiceInfo()
|
||||
|
||||
uint32_t p3MsgService::getNewUniqueMsgId()
|
||||
{
|
||||
RsStackMutex stack(mMsgMtx); /********** STACK LOCKED MTX ******/
|
||||
RS_STACK_MUTEX(mMsgMtx); /********** STACK LOCKED MTX ******/
|
||||
return mMsgUniqueId++;
|
||||
}
|
||||
|
||||
@ -136,6 +142,7 @@ int p3MsgService::tick()
|
||||
{
|
||||
manageDistantPeers() ;
|
||||
checkOutgoingMessages();
|
||||
cleanListOfReceivedMessageHashes();
|
||||
|
||||
last_management_time = now ;
|
||||
}
|
||||
@ -143,6 +150,24 @@ int p3MsgService::tick()
|
||||
return 0;
|
||||
}
|
||||
|
||||
void p3MsgService::cleanListOfReceivedMessageHashes()
|
||||
{
|
||||
RS_STACK_MUTEX(mMsgMtx); /********** STACK LOCKED MTX ******/
|
||||
|
||||
time_t now = time(NULL) ;
|
||||
|
||||
for(std::map<Sha1CheckSum,uint32_t>::iterator it(mRecentlyReceivedDistantMessageHashes.begin());it!=mRecentlyReceivedDistantMessageHashes.end();)
|
||||
if(now > RS_MSG_DISTANT_MESSAGE_HASH_KEEP_TIME + it->second)
|
||||
{
|
||||
std::cerr << "p3MsgService(): cleanListOfReceivedMessageHashes(). Removing old hash " << it->first << ", aged " << now - it->second << " secs ago" << std::endl;
|
||||
std::map<Sha1CheckSum,uint32_t>::iterator tmp(it) ;
|
||||
++tmp ;
|
||||
mRecentlyReceivedDistantMessageHashes.erase(it) ;
|
||||
it=tmp ;
|
||||
}
|
||||
else
|
||||
++it ;
|
||||
}
|
||||
|
||||
int p3MsgService::status()
|
||||
{
|
||||
@ -152,7 +177,7 @@ int p3MsgService::status()
|
||||
return 1;
|
||||
}
|
||||
|
||||
void p3MsgService::processMsg(RsMsgItem *mi, bool incoming)
|
||||
void p3MsgService::processIncomingMsg(RsMsgItem *mi)
|
||||
{
|
||||
mi -> recvTime = time(NULL);
|
||||
mi -> msgId = getNewUniqueMsgId();
|
||||
@ -160,8 +185,6 @@ void p3MsgService::processMsg(RsMsgItem *mi, bool incoming)
|
||||
{
|
||||
RsStackMutex stack(mMsgMtx); /*** STACK LOCKED MTX ***/
|
||||
|
||||
if (incoming)
|
||||
{
|
||||
/* from a peer */
|
||||
|
||||
mi->msgFlags &= (RS_MSG_FLAGS_DISTANT | RS_MSG_FLAGS_SYSTEM); // remove flags except those
|
||||
@ -176,24 +199,18 @@ void p3MsgService::processMsg(RsMsgItem *mi, bool incoming)
|
||||
rs_sprintf(out, "%lu", mi->msgId);
|
||||
notify->AddFeedItem(RS_FEED_ITEM_MESSAGE, out, "", "");
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
mi->msgFlags |= RS_MSG_OUTGOING;
|
||||
}
|
||||
|
||||
imsg[mi->msgId] = mi;
|
||||
RsMsgSrcId* msi = new RsMsgSrcId();
|
||||
msi->msgId = mi->msgId;
|
||||
msi->srcId = mi->PeerId();
|
||||
mSrcIds.insert(std::pair<uint32_t, RsMsgSrcId*>(msi->msgId, msi));
|
||||
|
||||
IndicateConfigChanged(); /**** INDICATE MSG CONFIG CHANGED! *****/
|
||||
|
||||
/**** STACK UNLOCKED ***/
|
||||
}
|
||||
|
||||
if (incoming)
|
||||
{
|
||||
// If the peer is allowed to push files, then auto-download the recommended files.
|
||||
if(rsPeers->servicePermissionFlags(mi->PeerId()) & RS_NODE_PERM_ALLOW_PUSH)
|
||||
{
|
||||
@ -203,7 +220,6 @@ void p3MsgService::processMsg(RsMsgItem *mi, bool incoming)
|
||||
for(std::list<RsTlvFileItem>::const_iterator it(mi->attachment.items.begin());it!=mi->attachment.items.end();++it)
|
||||
rsFiles->FileRequest((*it).name,(*it).hash,(*it).filesize,std::string(),RS_FILE_REQ_ANONYMOUS_ROUTING,srcIds) ;
|
||||
}
|
||||
}
|
||||
|
||||
RsServer::notify()->notifyListChange(NOTIFY_LIST_MESSAGELIST,NOTIFY_TYPE_ADD);
|
||||
}
|
||||
@ -271,7 +287,7 @@ void p3MsgService::handleIncomingItem(RsMsgItem *mi)
|
||||
|
||||
if(checkAndRebuildPartialMessage(mi)) // only returns true when a msg is complete.
|
||||
{
|
||||
processMsg(mi, true);
|
||||
processIncomingMsg(mi);
|
||||
changed = true ;
|
||||
}
|
||||
if(changed)
|
||||
@ -338,15 +354,17 @@ int p3MsgService::checkOutgoingMessages()
|
||||
* if online, send
|
||||
*/
|
||||
|
||||
time_t now = time(NULL);
|
||||
bool changed = false ;
|
||||
std::list<RsMsgItem*> output_queue ;
|
||||
|
||||
{
|
||||
RS_STACK_MUTEX(mMsgMtx); /********** STACK LOCKED MTX ******/
|
||||
|
||||
const RsPeerId& ownId = mServiceCtrl->getOwnId();
|
||||
|
||||
std::list<uint32_t>::iterator it;
|
||||
std::list<uint32_t> toErase;
|
||||
RsStackMutex stack(mMsgMtx); /********** STACK LOCKED MTX ******/
|
||||
|
||||
std::map<uint32_t, RsMsgItem *>::iterator mit;
|
||||
for(mit = msgOutgoing.begin(); mit != msgOutgoing.end(); ++mit)
|
||||
@ -356,10 +374,18 @@ int p3MsgService::checkOutgoingMessages()
|
||||
|
||||
/* find the certificate */
|
||||
RsPeerId pid = mit->second->PeerId();
|
||||
bool should_send = false ;
|
||||
|
||||
if( pid == ownId
|
||||
|| ( (mit->second->msgFlags & RS_MSG_FLAGS_DISTANT) && (!(mit->second->msgFlags & RS_MSG_FLAGS_ROUTED)))
|
||||
|| mServiceCtrl->isPeerConnected(getServiceInfo().mServiceType, pid) ) /* FEEDBACK Msg to Ourselves */
|
||||
if( pid == ownId)
|
||||
should_send = true ;
|
||||
|
||||
if( mServiceCtrl->isPeerConnected(getServiceInfo().mServiceType, pid) ) /* FEEDBACK Msg to Ourselves */
|
||||
should_send = true ;
|
||||
|
||||
if((mit->second->msgFlags & RS_MSG_FLAGS_DISTANT) && !(mit->second->msgFlags & RS_MSG_FLAGS_ROUTED))
|
||||
should_send = true ;
|
||||
|
||||
if(should_send)
|
||||
{
|
||||
/* send msg */
|
||||
pqioutput(PQL_DEBUG_BASIC, msgservicezone,
|
||||
@ -464,6 +490,10 @@ bool p3MsgService::saveList(bool& cleanup, std::list<RsItem*>& itemList)
|
||||
|
||||
itemList.push_back(grmap) ;
|
||||
|
||||
RsMsgDistantMessagesHashMap *ghm = new RsMsgDistantMessagesHashMap ;
|
||||
ghm->hash_map = mRecentlyReceivedDistantMessageHashes ;
|
||||
itemList.push_back(ghm) ;
|
||||
|
||||
RsConfigKeyValueSet *vitem = new RsConfigKeyValueSet ;
|
||||
RsTlvKeyValue kv;
|
||||
kv.key = "DISTANT_MESSAGES_ENABLED" ;
|
||||
@ -485,7 +515,7 @@ void p3MsgService::saveDone()
|
||||
mMsgMtx.unlock();
|
||||
}
|
||||
|
||||
RsSerialiser* p3MsgService::setupSerialiser()
|
||||
RsSerialiser* p3MsgService::setupSerialiser() // this serialiser is used for config. So it adds somemore info in the serialised items
|
||||
{
|
||||
RsSerialiser *rss = new RsSerialiser ;
|
||||
|
||||
@ -544,7 +574,7 @@ bool p3MsgService::loadList(std::list<RsItem*>& load)
|
||||
RsMsgSrcId* msi;
|
||||
RsMsgParentId* msp;
|
||||
RsMsgGRouterMap* grm;
|
||||
// RsPublicMsgInviteConfigItem* msv;
|
||||
RsMsgDistantMessagesHashMap *ghm;
|
||||
|
||||
std::list<RsMsgItem*> items;
|
||||
std::list<RsItem*>::iterator it;
|
||||
@ -552,6 +582,8 @@ bool p3MsgService::loadList(std::list<RsItem*>& load)
|
||||
std::map<uint32_t, RsPeerId> srcIdMsgMap;
|
||||
std::map<uint32_t, RsPeerId>::iterator srcIt;
|
||||
|
||||
uint32_t max_msg_id = 0 ;
|
||||
|
||||
// load items and calculate next unique msgId
|
||||
for(it = load.begin(); it != load.end(); ++it)
|
||||
{
|
||||
@ -559,9 +591,9 @@ bool p3MsgService::loadList(std::list<RsItem*>& load)
|
||||
if (NULL != (mitem = dynamic_cast<RsMsgItem *>(*it)))
|
||||
{
|
||||
/* STORE MsgID */
|
||||
if (mitem->msgId >= mMsgUniqueId) {
|
||||
mMsgUniqueId = mitem->msgId + 1;
|
||||
}
|
||||
if (mitem->msgId > max_msg_id)
|
||||
max_msg_id = mitem->msgId ;
|
||||
|
||||
items.push_back(mitem);
|
||||
}
|
||||
else if (NULL != (grm = dynamic_cast<RsMsgGRouterMap *>(*it)))
|
||||
@ -570,6 +602,17 @@ bool p3MsgService::loadList(std::list<RsItem*>& load)
|
||||
for(std::map<GRouterMsgPropagationId,uint32_t>::const_iterator it(grm->ongoing_msgs.begin());it!=grm->ongoing_msgs.end();++it)
|
||||
_ongoing_messages.insert(*it) ;
|
||||
}
|
||||
else if(NULL != (ghm = dynamic_cast<RsMsgDistantMessagesHashMap*>(*it)))
|
||||
{
|
||||
mRecentlyReceivedDistantMessageHashes = ghm->hash_map ;
|
||||
|
||||
#ifdef DEBUG_DISTANT_MSG
|
||||
std::cerr << " loaded recently received message map: " << std::endl;
|
||||
|
||||
for(std::map<Sha1CheckSum,uint32_t>::const_iterator it(mRecentlyReceivedDistantMessageHashes.begin());it!=mRecentlyReceivedDistantMessageHashes.end();++it)
|
||||
std::cerr << " " << it->first << " received " << time(NULL)-it->second << " secs ago." << std::endl;
|
||||
#endif
|
||||
}
|
||||
else if(NULL != (mtt = dynamic_cast<RsMsgTagType *>(*it)))
|
||||
{
|
||||
// delete standard tags as they are now save in config
|
||||
@ -636,6 +679,7 @@ bool p3MsgService::loadList(std::list<RsItem*>& load)
|
||||
continue ;
|
||||
}
|
||||
}
|
||||
mMsgUniqueId = max_msg_id + 1; // make it unique with respect to what was loaded. Not totally safe, but works 99.9999% of the cases.
|
||||
load.clear() ;
|
||||
|
||||
// sort items into lists
|
||||
@ -1030,32 +1074,31 @@ bool p3MsgService::setMsgParentId(uint32_t msgId, uint32_t msgParentId)
|
||||
/****************************************/
|
||||
/****************************************/
|
||||
/* Message Items */
|
||||
uint32_t p3MsgService::sendMessage(RsMsgItem *item)
|
||||
uint32_t p3MsgService::sendMessage(RsMsgItem *item) // no from field because it's implicitly our own PeerId
|
||||
{
|
||||
if(!item)
|
||||
return 0 ;
|
||||
|
||||
pqioutput(PQL_DEBUG_BASIC, msgservicezone,
|
||||
"p3MsgService::sendMessage()");
|
||||
pqioutput(PQL_DEBUG_BASIC, msgservicezone, "p3MsgService::sendMessage()");
|
||||
|
||||
item->msgId = getNewUniqueMsgId(); /* grabs Mtx as well */
|
||||
item->msgFlags |= (RS_MSG_FLAGS_OUTGOING | RS_MSG_FLAGS_PENDING); /* add pending flag */
|
||||
|
||||
{
|
||||
RsStackMutex stack(mMsgMtx); /********** STACK LOCKED MTX ******/
|
||||
RS_STACK_MUTEX(mMsgMtx) ;
|
||||
|
||||
/* add pending flag */
|
||||
item->msgFlags |= (RS_MSG_FLAGS_OUTGOING | RS_MSG_FLAGS_PENDING);
|
||||
/* STORE MsgID */
|
||||
msgOutgoing[item->msgId] = item;
|
||||
|
||||
if (item->PeerId() != mServiceCtrl->getOwnId()) {
|
||||
if (item->PeerId() != mServiceCtrl->getOwnId())
|
||||
{
|
||||
/* not to the loopback device */
|
||||
|
||||
RsMsgSrcId* msi = new RsMsgSrcId();
|
||||
msi->msgId = item->msgId;
|
||||
msi->srcId = item->PeerId();
|
||||
msi->srcId = mServiceCtrl->getOwnId();
|
||||
mSrcIds.insert(std::pair<uint32_t, RsMsgSrcId*>(msi->msgId, msi));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
IndicateConfigChanged(); /**** INDICATE MSG CONFIG CHANGED! *****/
|
||||
@ -1066,12 +1109,36 @@ uint32_t p3MsgService::sendMessage(RsMsgItem *item)
|
||||
}
|
||||
uint32_t p3MsgService::sendDistantMessage(RsMsgItem *item,const RsGxsId& from)
|
||||
{
|
||||
uint32_t msg_id = sendMessage(item) ;
|
||||
if(!item)
|
||||
return 0 ;
|
||||
|
||||
item->msgId = getNewUniqueMsgId(); /* grabs Mtx as well */
|
||||
item->msgFlags |= (RS_MSG_FLAGS_DISTANT | RS_MSG_FLAGS_OUTGOING | RS_MSG_FLAGS_PENDING); /* add pending flag */
|
||||
|
||||
{
|
||||
RS_STACK_MUTEX(mMsgMtx) ;
|
||||
mDistantOutgoingMsgSigners[msg_id] = from ;
|
||||
|
||||
return msg_id ;
|
||||
/* STORE MsgID */
|
||||
msgOutgoing[item->msgId] = item;
|
||||
mDistantOutgoingMsgSigners[item->msgId] = from ;
|
||||
|
||||
if (item->PeerId() != mServiceCtrl->getOwnId())
|
||||
{
|
||||
/* not to the loopback device */
|
||||
|
||||
RsMsgSrcId* msi = new RsMsgSrcId();
|
||||
msi->msgId = item->msgId;
|
||||
msi->srcId = RsPeerId(from) ;
|
||||
mSrcIds.insert(std::pair<uint32_t, RsMsgSrcId*>(msi->msgId, msi));
|
||||
}
|
||||
}
|
||||
|
||||
IndicateConfigChanged(); /**** INDICATE MSG CONFIG CHANGED! *****/
|
||||
|
||||
RsServer::notify()->notifyListChange(NOTIFY_LIST_MESSAGELIST, NOTIFY_TYPE_ADD);
|
||||
|
||||
return item->msgId;
|
||||
|
||||
}
|
||||
|
||||
bool p3MsgService::MessageSend(MessageInfo &info)
|
||||
@ -1084,7 +1151,8 @@ bool p3MsgService::MessageSend(MessageInfo &info)
|
||||
for(std::set<RsGxsId>::const_iterator pit = info.rsgxsid_msgcc.begin(); pit != info.rsgxsid_msgcc.end(); ++pit) sendDistantMessage(initMIRsMsg(info, *pit),info.rsgxsid_srcId);
|
||||
for(std::set<RsGxsId>::const_iterator pit = info.rsgxsid_msgbcc.begin(); pit != info.rsgxsid_msgbcc.end(); ++pit) sendDistantMessage(initMIRsMsg(info, *pit),info.rsgxsid_srcId);
|
||||
|
||||
/* send to ourselves as well */
|
||||
// store message in outgoing list. In order to appear as sent the message needs to have the OUTGOING flg, but no pending flag on.
|
||||
|
||||
RsMsgItem *msg = initMIRsMsg(info, mServiceCtrl->getOwnId());
|
||||
|
||||
if (msg)
|
||||
@ -1095,10 +1163,17 @@ bool p3MsgService::MessageSend(MessageInfo &info)
|
||||
msg->msgFlags |= RS_MSG_FLAGS_SIGNATURE_CHECKS; // this is always true, since we are sending the message
|
||||
|
||||
/* use processMsg to get the new msgId */
|
||||
processMsg(msg, false);
|
||||
msg->recvTime = time(NULL);
|
||||
msg->msgId = getNewUniqueMsgId();
|
||||
|
||||
// return new message id
|
||||
rs_sprintf(info.msgId, "%lu", msg->msgId);
|
||||
msg->msgFlags |= RS_MSG_OUTGOING;
|
||||
|
||||
imsg[msg->msgId] = msg;
|
||||
|
||||
RsServer::notify()->notifyListChange(NOTIFY_LIST_MESSAGELIST,NOTIFY_TYPE_ADD);
|
||||
//
|
||||
// // return new message id
|
||||
// rs_sprintf(info.msgId, "%lu", msg->msgId);
|
||||
}
|
||||
|
||||
return true;
|
||||
@ -1138,7 +1213,7 @@ bool p3MsgService::SystemMessage(const std::string &title, const std::string &me
|
||||
|
||||
msg->rspeerid_msgto.ids.insert(ownId);
|
||||
|
||||
processMsg(msg, true);
|
||||
processIncomingMsg(msg);
|
||||
|
||||
return true;
|
||||
}
|
||||
@ -1762,7 +1837,7 @@ void p3MsgService::manageDistantPeers()
|
||||
{
|
||||
#ifdef DEBUG_DISTANT_MSG
|
||||
for(std::list<RsGxsId>::const_iterator it(own_id_list.begin());it!=own_id_list.end();++it)
|
||||
std::cerr << (b?"Enabling":"Disabling") << " distant messaging, with peer id = " << *it << std::endl;
|
||||
std::cerr << (mShouldEnableDistantMessaging?"Enabling":"Disabling") << " distant messaging, with peer id = " << *it << std::endl;
|
||||
#endif
|
||||
|
||||
for(std::list<RsGxsId>::const_iterator it(own_id_list.begin());it!=own_id_list.end();++it)
|
||||
@ -1782,16 +1857,35 @@ void p3MsgService::notifyDataStatus(const GRouterMsgPropagationId& id,uint32_t d
|
||||
{
|
||||
if(data_status == GROUTER_CLIENT_SERVICE_DATA_STATUS_FAILED)
|
||||
{
|
||||
std::cerr << __PRETTY_FUNCTION__ << ": Not fully implemented. The global router fails to send apacket, but we don't deal with it. Please remind the devs to do it" << std::endl;
|
||||
RS_STACK_MUTEX(mMsgMtx); /********** STACK LOCKED MTX ******/
|
||||
|
||||
std::cerr << "(WW) p3MsgService::notifyDataStatus: Global router tells us that item ID " << id << " could not be delivered on time." ;
|
||||
std::map<GRouterMsgPropagationId,uint32_t>::iterator it = _ongoing_messages.find(id) ;
|
||||
|
||||
if(it == _ongoing_messages.end())
|
||||
{
|
||||
std::cerr << " (EE) cannot find pending message to acknowledge. Weird. grouter id = " << id << std::endl;
|
||||
return ;
|
||||
}
|
||||
if(data_status != GROUTER_CLIENT_SERVICE_DATA_STATUS_RECEIVED)
|
||||
uint32_t msg_id = it->second ;
|
||||
std::cerr << " message id = " << msg_id << std::endl;
|
||||
|
||||
std::map<uint32_t,RsMsgItem*>::iterator mit = msgOutgoing.find(msg_id) ;
|
||||
|
||||
if(mit == msgOutgoing.end())
|
||||
{
|
||||
std::cerr << "p3MsgService: unhandled data status info from global router for msg ID " << id << ": this is a bug." << std::endl;
|
||||
std::cerr << " (EE) message has been notified as not delivered, but it not on outgoing list. Something's wrong!!" << std::endl;
|
||||
return ;
|
||||
}
|
||||
std::cerr << " reseting the ROUTED flag so that the message is requested again" << std::endl;
|
||||
|
||||
mit->second->msgFlags &= ~RS_MSG_FLAGS_ROUTED ; // clear the routed flag so that the message is requested again
|
||||
return ;
|
||||
}
|
||||
|
||||
RsStackMutex stack(mMsgMtx); /********** STACK LOCKED MTX ******/
|
||||
if(data_status == GROUTER_CLIENT_SERVICE_DATA_STATUS_RECEIVED)
|
||||
{
|
||||
RS_STACK_MUTEX(mMsgMtx); /********** STACK LOCKED MTX ******/
|
||||
#ifdef DEBUG_DISTANT_MSG
|
||||
std::cerr << "p3MsgService::acknowledgeDataReceived(): acknowledging data received for msg propagation id " << id << std::endl;
|
||||
#endif
|
||||
@ -1820,6 +1914,10 @@ void p3MsgService::notifyDataStatus(const GRouterMsgPropagationId& id,uint32_t d
|
||||
|
||||
RsServer::notify()->notifyListChange(NOTIFY_LIST_MESSAGELIST,NOTIFY_TYPE_ADD);
|
||||
IndicateConfigChanged() ;
|
||||
|
||||
return ;
|
||||
}
|
||||
std::cerr << "p3MsgService: unhandled data status info from global router for msg ID " << id << ": this is a bug." << std::endl;
|
||||
}
|
||||
bool p3MsgService::acceptDataFromPeer(const RsGxsId& to_gxs_id)
|
||||
{
|
||||
@ -1851,8 +1949,20 @@ void p3MsgService::receiveGRouterData(const RsGxsId& destination_key, const RsGx
|
||||
{
|
||||
std::cerr << "p3MsgService::receiveGRouterData(): received message item of size " << data_size << ", for key " << destination_key << std::endl;
|
||||
|
||||
RsItem *item = _serialiser->deserialise(data,&data_size) ;
|
||||
// first make sure that we havn't already received the data. Since we allow to re-send messages, it's necessary to check.
|
||||
|
||||
Sha1CheckSum hash = RsDirUtil::sha1sum(data,data_size) ;
|
||||
|
||||
if(mRecentlyReceivedDistantMessageHashes.find(hash) != mRecentlyReceivedDistantMessageHashes.end())
|
||||
{
|
||||
std::cerr << "(WW) receiving distant message of hash " << hash << " more than once. This is not a bug, unless it happens very often." << std::endl;
|
||||
free(data) ;
|
||||
return ;
|
||||
}
|
||||
mRecentlyReceivedDistantMessageHashes[hash] = time(NULL) ;
|
||||
IndicateConfigChanged() ;
|
||||
|
||||
RsItem *item = _serialiser->deserialise(data,&data_size) ;
|
||||
free(data) ;
|
||||
|
||||
RsMsgItem *msg_item = dynamic_cast<RsMsgItem*>(item) ;
|
||||
@ -1877,7 +1987,8 @@ void p3MsgService::sendDistantMsgItem(RsMsgItem *msgitem)
|
||||
RsGxsId destination_key_id(msgitem->PeerId()) ;
|
||||
RsGxsId signing_key_id ;
|
||||
|
||||
msgitem->msgFlags |= RS_MSG_FLAGS_DISTANT ;
|
||||
msgitem->msgFlags |= RS_MSG_FLAGS_DISTANT ;// just in case, but normally we should always have this flag set, when ending up here.
|
||||
|
||||
{
|
||||
RS_STACK_MUTEX(mMsgMtx) ;
|
||||
|
||||
@ -1899,15 +2010,14 @@ void p3MsgService::sendDistantMsgItem(RsMsgItem *msgitem)
|
||||
std::cerr << " signing : " << signing_key_id << std::endl;
|
||||
#endif
|
||||
|
||||
// The item is serialized and turned into a generic turtle item.
|
||||
// The item is serialized and turned into a generic turtle item. Use use the explicit serialiser to make sure that the msgId is not included
|
||||
|
||||
uint32_t msg_serialized_rssize = _serialiser->size(msgitem) ;
|
||||
unsigned char *msg_serialized_data = new unsigned char[msg_serialized_rssize] ;
|
||||
uint32_t msg_serialized_rssize = msgitem->serial_size(false) ;
|
||||
RsTemporaryMemory msg_serialized_data(msg_serialized_rssize) ;
|
||||
|
||||
if(!_serialiser->serialise(msgitem,msg_serialized_data,&msg_serialized_rssize))
|
||||
if(!msgitem->serialise(msg_serialized_data,msg_serialized_rssize,false))
|
||||
{
|
||||
std::cerr << "(EE) p3MsgService::sendTurtleData(): Serialization error." << std::endl;
|
||||
delete[] msg_serialized_data ;
|
||||
return ;
|
||||
}
|
||||
#ifdef DEBUG_DISTANT_MSG
|
||||
@ -1917,8 +2027,6 @@ void p3MsgService::sendDistantMsgItem(RsMsgItem *msgitem)
|
||||
GRouterMsgPropagationId grouter_message_id ;
|
||||
mGRouter->sendData(destination_key_id,GROUTER_CLIENT_ID_MESSAGES,msg_serialized_data,msg_serialized_rssize,signing_key_id,grouter_message_id) ;
|
||||
|
||||
delete[] msg_serialized_data ;
|
||||
|
||||
// now store the grouter id along with the message id, so that we can keep track of received messages
|
||||
|
||||
{
|
||||
|
@ -158,9 +158,10 @@ class p3MsgService: public p3Service, public p3Config, public pqiServiceMonitor,
|
||||
uint32_t sendMessage(RsMsgItem *item);
|
||||
uint32_t sendDistantMessage(RsMsgItem *item,const RsGxsId& signing_gxs_id);
|
||||
void checkSizeAndSendMessage(RsMsgItem *msg);
|
||||
void cleanListOfReceivedMessageHashes();
|
||||
|
||||
int incomingMsgs();
|
||||
void processMsg(RsMsgItem *mi, bool incoming);
|
||||
void processIncomingMsg(RsMsgItem *mi) ;
|
||||
bool checkAndRebuildPartialMessage(RsMsgItem*) ;
|
||||
|
||||
void initRsMI(RsMsgItem *msg, Rs::Msgs::MessageInfo &mi);
|
||||
@ -194,6 +195,7 @@ class p3MsgService: public p3Service, public p3Config, public pqiServiceMonitor,
|
||||
std::map<uint32_t, RsMsgTags*> mMsgTags;
|
||||
|
||||
uint32_t mMsgUniqueId;
|
||||
std::map<Sha1CheckSum,uint32_t> mRecentlyReceivedDistantMessageHashes;
|
||||
|
||||
// used delete msgSrcIds after config save
|
||||
std::map<uint32_t, RsMsgSrcId*> mSrcIds;
|
||||
|
@ -26,7 +26,11 @@ bool RsPhotoThumbnail::copyFrom(const RsPhotoThumbnail &nail)
|
||||
|
||||
size = nail.size;
|
||||
type = nail.type;
|
||||
data = (uint8_t *) malloc(size);
|
||||
data = (uint8_t *) rs_malloc(size);
|
||||
|
||||
if(data == NULL)
|
||||
return false ;
|
||||
|
||||
memcpy(data, nail.data, size);
|
||||
|
||||
return true;
|
||||
|
@ -36,6 +36,7 @@
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <util/rsmemory.h>
|
||||
|
||||
#include <iostream>
|
||||
|
||||
@ -79,7 +80,9 @@ TcpPacket::TcpPacket(uint8 *ptr, int size)
|
||||
if (size > 0)
|
||||
{
|
||||
datasize = size;
|
||||
data = (uint8 *) malloc(datasize);
|
||||
data = (uint8 *) rs_malloc(datasize);
|
||||
|
||||
if(data != NULL)
|
||||
memcpy(data, (void *) ptr, size);
|
||||
}
|
||||
return;
|
||||
@ -185,7 +188,17 @@ int TcpPacket::readPacket(void *buf, int size)
|
||||
free(data);
|
||||
}
|
||||
datasize = size - TCP_PSEUDO_HDR_SIZE;
|
||||
data = (uint8 *) malloc(datasize);
|
||||
|
||||
if(datasize == 0) // this happens!
|
||||
{
|
||||
data = NULL ;
|
||||
return 0 ;
|
||||
}
|
||||
|
||||
data = (uint8 *) rs_malloc(datasize);
|
||||
|
||||
if(data == NULL)
|
||||
return 0 ;
|
||||
|
||||
/* now the data */
|
||||
memcpy(data, (void *) &(((uint8 *) buf)[20]), datasize);
|
||||
|
@ -26,6 +26,7 @@
|
||||
#include "udprelay.h"
|
||||
#include <iostream>
|
||||
#include <time.h>
|
||||
#include <util/rsmemory.h>
|
||||
|
||||
/*
|
||||
* #define DEBUG_UDP_RELAY 1
|
||||
@ -70,7 +71,7 @@ UdpRelayReceiver::UdpRelayReceiver(UdpPublisher *pub)
|
||||
setRelayClassMax(UDP_RELAY_CLASS_GENERAL, UDP_RELAY_DEFAULT_GENERAL, UDP_RELAY_DEFAULT_BANDWIDTH);
|
||||
|
||||
/* only allocate this space once */
|
||||
mTmpSendPkt = malloc(MAX_RELAY_UDP_PACKET_SIZE);
|
||||
mTmpSendPkt = rs_malloc(MAX_RELAY_UDP_PACKET_SIZE);
|
||||
mTmpSendSize = MAX_RELAY_UDP_PACKET_SIZE;
|
||||
|
||||
clearDataTransferred();
|
||||
|
@ -29,6 +29,7 @@
|
||||
|
||||
#include "util/rsrandom.h"
|
||||
#include "util/rsprint.h"
|
||||
#include "util/rsmemory.h"
|
||||
#include "util/rsstring.h"
|
||||
|
||||
static const int STUN_TTL = 64;
|
||||
@ -535,7 +536,11 @@ bool UdpStun_generate_stun_pkt(void *stun_pkt, int *len)
|
||||
void *UdpStun_generate_stun_reply(struct sockaddr_in *stun_addr, int *len)
|
||||
{
|
||||
/* just the header */
|
||||
void *stun_pkt = malloc(28);
|
||||
void *stun_pkt = rs_malloc(28);
|
||||
|
||||
if(!stun_pkt)
|
||||
return NULL ;
|
||||
|
||||
((uint16_t *) stun_pkt)[0] = (uint16_t) htons(0x0101);
|
||||
((uint16_t *) stun_pkt)[1] = (uint16_t) htons(28); /* only header + 8 byte addr */
|
||||
/* transaction id - should be random */
|
||||
|
@ -284,19 +284,24 @@ RsTurtleRegExpSearchRequestItem::RsTurtleRegExpSearchRequestItem(void *data,uint
|
||||
uint32_t n =0 ;
|
||||
ok &= getRawUInt32(data,pktsize,&offset,&n) ;
|
||||
|
||||
if(ok)
|
||||
expr._tokens.resize(n) ;
|
||||
|
||||
for(uint32_t i=0;i<n;++i) ok &= getRawUInt8(data,pktsize,&offset,&expr._tokens[i]) ;
|
||||
for(uint32_t i=0;i<n && ok;++i) ok &= getRawUInt8(data,pktsize,&offset,&expr._tokens[i]) ;
|
||||
|
||||
ok &= getRawUInt32(data,pktsize,&offset,&n) ;
|
||||
|
||||
if(ok)
|
||||
expr._ints.resize(n) ;
|
||||
|
||||
for(uint32_t i=0;i<n;++i) ok &= getRawUInt32(data,pktsize,&offset,&expr._ints[i]) ;
|
||||
for(uint32_t i=0;i<n && ok;++i) ok &= getRawUInt32(data,pktsize,&offset,&expr._ints[i]) ;
|
||||
|
||||
ok &= getRawUInt32(data,pktsize,&offset,&n) ;
|
||||
|
||||
if(ok)
|
||||
expr._strings.resize(n) ;
|
||||
|
||||
for(uint32_t i=0;i<n;++i) ok &= GetTlvString(data, pktsize, &offset, TLV_TYPE_STR_VALUE, expr._strings[i]);
|
||||
for(uint32_t i=0;i<n && ok;++i) ok &= GetTlvString(data, pktsize, &offset, TLV_TYPE_STR_VALUE, expr._strings[i]);
|
||||
|
||||
#ifdef WINDOWS_SYS // No Exceptions in Windows compile. (drbobs).
|
||||
UNREFERENCED_LOCAL_VARIABLE(rssize);
|
||||
@ -531,6 +536,9 @@ RsTurtleGenericDataItem::RsTurtleGenericDataItem(void *data,uint32_t pktsize)
|
||||
uint32_t offset = 8; // skip the header
|
||||
uint32_t rssize = getRsItemSize(data);
|
||||
|
||||
if(rssize > pktsize)
|
||||
throw std::runtime_error("RsTurtleTunnelOkItem::() wrong rssize (exceeds pktsize).") ;
|
||||
|
||||
/* add mandatory parts first */
|
||||
|
||||
bool ok = true ;
|
||||
@ -540,7 +548,11 @@ RsTurtleGenericDataItem::RsTurtleGenericDataItem(void *data,uint32_t pktsize)
|
||||
#ifdef P3TURTLE_DEBUG
|
||||
std::cerr << " request_id=" << (void*)request_id << ", tunnel_id=" << (void*)tunnel_id << std::endl ;
|
||||
#endif
|
||||
data_bytes = malloc(data_size) ;
|
||||
|
||||
if(data_size > rssize || rssize - data_size < offset)
|
||||
throw std::runtime_error("RsTurtleTunnelOkItem::() wrong data_size (exceeds rssize).") ;
|
||||
|
||||
data_bytes = rs_malloc(data_size) ;
|
||||
|
||||
if(data_bytes != NULL)
|
||||
{
|
||||
@ -548,10 +560,7 @@ RsTurtleGenericDataItem::RsTurtleGenericDataItem(void *data,uint32_t pktsize)
|
||||
offset += data_size ;
|
||||
}
|
||||
else
|
||||
{
|
||||
std::cerr << "(EE) RsTurtleGenericDataItem: Error. Cannot allocate data for a size of " << data_size << " bytes." <<std::endl;
|
||||
offset = 0 ; // generate an error
|
||||
}
|
||||
|
||||
#ifdef WINDOWS_SYS // No Exceptions in Windows compile. (drbobs).
|
||||
UNREFERENCED_LOCAL_VARIABLE(rssize);
|
||||
|
@ -30,6 +30,7 @@
|
||||
#include <assert.h>
|
||||
#include "rscompress.h"
|
||||
#include "zlib.h"
|
||||
#include "util/rsmemory.h"
|
||||
|
||||
// 16K buffer size.
|
||||
//
|
||||
@ -42,7 +43,10 @@ bool RsCompress::compress_memory_chunk(const uint8_t *input_mem,const uint32_t i
|
||||
uint32_t output_offset = 0 ;
|
||||
uint32_t input_offset = 0 ;
|
||||
output_size = 1024 ;
|
||||
output_mem = (uint8_t*)malloc(output_size) ;
|
||||
output_mem = (uint8_t*)rs_malloc(output_size) ;
|
||||
|
||||
if(!output_mem)
|
||||
return false ;
|
||||
|
||||
int ret, flush;
|
||||
unsigned have;
|
||||
@ -113,7 +117,10 @@ bool RsCompress::uncompress_memory_chunk(const uint8_t *input_mem,const uint32_t
|
||||
output_size = input_size ;
|
||||
uint32_t output_offset = 0 ;
|
||||
uint32_t input_offset = 0 ;
|
||||
output_mem = (uint8_t*)malloc(output_size) ;
|
||||
output_mem = (uint8_t*)rs_malloc(output_size) ;
|
||||
|
||||
if(!output_mem)
|
||||
return false ;
|
||||
|
||||
int ret;
|
||||
unsigned have;
|
||||
|
@ -33,6 +33,7 @@
|
||||
#include "util/rsdir.h"
|
||||
#include "util/rsstring.h"
|
||||
#include "util/rsrandom.h"
|
||||
#include "util/rsmemory.h"
|
||||
#include "retroshare/rstypes.h"
|
||||
#include "rsthreads.h"
|
||||
#include <iostream>
|
||||
@ -267,7 +268,14 @@ bool RsDirUtil::copyFile(const std::string& source,const std::string& dest)
|
||||
size_t T=0;
|
||||
|
||||
static const int BUFF_SIZE = 10485760 ; // 10 MB buffer to speed things up.
|
||||
void *buffer = malloc(BUFF_SIZE) ;
|
||||
RsTemporaryMemory buffer(BUFF_SIZE) ;
|
||||
|
||||
if(!buffer)
|
||||
{
|
||||
fclose(in) ;
|
||||
fclose(out) ;
|
||||
return false ;
|
||||
}
|
||||
|
||||
bool bRet = true;
|
||||
|
||||
@ -286,8 +294,6 @@ bool RsDirUtil::copyFile(const std::string& source,const std::string& dest)
|
||||
fclose(in) ;
|
||||
fclose(out) ;
|
||||
|
||||
free(buffer) ;
|
||||
|
||||
return true ;
|
||||
|
||||
#endif
|
||||
|
32
libretroshare/src/util/rsmemory.cc
Normal file
@ -0,0 +1,32 @@
|
||||
#include "util/rsmemory.h"
|
||||
|
||||
void *rs_malloc(size_t size)
|
||||
{
|
||||
static const size_t SAFE_MEMALLOC_THRESHOLD = 1024*1024*1024 ; // 1Gb should be enough for everything!
|
||||
|
||||
if(size == 0)
|
||||
{
|
||||
std::cerr << "(EE) Memory allocation error. A chunk of size 0 was requested. Callstack:" << std::endl;
|
||||
print_stacktrace() ;
|
||||
return NULL ;
|
||||
}
|
||||
|
||||
if(size > SAFE_MEMALLOC_THRESHOLD)
|
||||
{
|
||||
std::cerr << "(EE) Memory allocation error. A chunk of size 0 was requested. Callstack:" << std::endl;
|
||||
print_stacktrace() ;
|
||||
return NULL ;
|
||||
}
|
||||
|
||||
void *mem = malloc(size) ;
|
||||
|
||||
if(mem == NULL)
|
||||
{
|
||||
std::cerr << "(EE) Memory allocation error for a chunk of " << size << " bytes. Callstack:" << std::endl;
|
||||
print_stacktrace() ;
|
||||
return NULL ;
|
||||
}
|
||||
|
||||
return mem ;
|
||||
}
|
||||
|
@ -1,6 +1,10 @@
|
||||
#pragma once
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <iostream>
|
||||
#include <util/stacktrace.h>
|
||||
|
||||
void *rs_malloc(size_t size) ;
|
||||
|
||||
// This is a scope guard to release the memory block when going of of the current scope.
|
||||
// Can be very useful to auto-delete some memory on quit without the need to call free each time.
|
||||
@ -24,7 +28,7 @@ class RsTemporaryMemory
|
||||
public:
|
||||
RsTemporaryMemory(size_t s)
|
||||
{
|
||||
_mem = (unsigned char *)malloc(s) ;
|
||||
_mem = (unsigned char *)rs_malloc(s) ;
|
||||
|
||||
if(_mem)
|
||||
_size = s ;
|
||||
@ -53,5 +57,3 @@ private:
|
||||
RsTemporaryMemory& operator=(const RsTemporaryMemory&) { return *this ;}
|
||||
RsTemporaryMemory(const RsTemporaryMemory&) {}
|
||||
};
|
||||
|
||||
|
||||
|
@ -145,7 +145,12 @@ bool RsRecogn::loadSigningKeys(std::map<RsGxsId, RsGxsRecognSignerItem *> &signM
|
||||
|
||||
/* store in */
|
||||
uint32_t datalen = recognSerialiser.size(item);
|
||||
uint8_t *data = (uint8_t *) malloc(datalen);
|
||||
|
||||
RsTemporaryMemory data(datalen) ;
|
||||
|
||||
if(!data)
|
||||
return false ;
|
||||
|
||||
uint32_t pktlen = datalen;
|
||||
int signOk = 0;
|
||||
|
||||
@ -181,8 +186,6 @@ bool RsRecogn::loadSigningKeys(std::map<RsGxsId, RsGxsRecognSignerItem *> &signM
|
||||
#endif // DEBUG_RECOGN
|
||||
delete item;
|
||||
}
|
||||
|
||||
free(data);
|
||||
}
|
||||
|
||||
/* clean up */
|
||||
@ -233,7 +236,12 @@ bool RsRecogn::validateTagSignature(RsGxsRecognSignerItem *signer, RsGxsRecognTa
|
||||
RsGxsRecognSerialiser serialiser;
|
||||
|
||||
uint32_t datalen = serialiser.size(item);
|
||||
uint8_t *data = (uint8_t *) malloc(datalen);
|
||||
|
||||
RsTemporaryMemory data(datalen) ;
|
||||
|
||||
if(!data)
|
||||
return false ;
|
||||
|
||||
int signOk = 0;
|
||||
|
||||
uint32_t pktlen = datalen;
|
||||
@ -263,8 +271,6 @@ bool RsRecogn::validateTagSignature(RsGxsRecognSignerItem *signer, RsGxsRecognTa
|
||||
EVP_MD_CTX_destroy(mdctx);
|
||||
EVP_PKEY_free(signKey);
|
||||
|
||||
free(data);
|
||||
|
||||
return (signOk == 1);
|
||||
}
|
||||
|
||||
|
@ -1,6 +1,7 @@
|
||||
#include <iostream>
|
||||
#include "smallobject.h"
|
||||
#include "util/rsthreads.h"
|
||||
#include "util/rsmemory.h"
|
||||
|
||||
using namespace RsMemoryManagement ;
|
||||
|
||||
@ -206,7 +207,7 @@ SmallObjectAllocator::~SmallObjectAllocator()
|
||||
void *SmallObjectAllocator::allocate(size_t bytes)
|
||||
{
|
||||
if(bytes > _maxObjectSize)
|
||||
return malloc(bytes) ;
|
||||
return rs_malloc(bytes) ;
|
||||
else if(_lastAlloc != NULL && _lastAlloc->blockSize() == bytes)
|
||||
return _lastAlloc->allocate() ;
|
||||
else
|
||||
|
@ -117,6 +117,9 @@ void *ops_mallocz(size_t n)
|
||||
{
|
||||
void *m=malloc(n);
|
||||
|
||||
if(m == NULL)
|
||||
fprintf(stderr,"(EE) Cannot allocate %d bytes of memory in %s\n",n,__PRETTY_FUNCTION__) ;
|
||||
else
|
||||
memset(m,'\0',n);
|
||||
|
||||
return m;
|
||||
|
@ -68,7 +68,11 @@ win32 {
|
||||
}
|
||||
|
||||
macx {
|
||||
|
||||
#You can found some information here:
|
||||
#https://developer.apple.com/library/mac/documentation/Porting/Conceptual/PortingUnix/compiling/compiling.html
|
||||
QMAKE_LFLAGS_PLUGIN -= -dynamiclib
|
||||
QMAKE_LFLAGS_PLUGIN += -bundle
|
||||
QMAKE_LFLAGS_PLUGIN += -bundle_loader "../../retroshare-gui/src/RetroShare06.app/Contents/MacOS/RetroShare06"
|
||||
|
||||
OBJECTS_DIR = temp/obj
|
||||
MOC_DIR = temp/moc
|
||||
|
@ -121,8 +121,6 @@ macx {
|
||||
INCLUDEPATH += . $$INC_DIR
|
||||
|
||||
LIBS = -lcurl -lxml2 -lxslt -lcrypto
|
||||
|
||||
error(Missing RetroShare-gui library. Remove Plugins from RetroShare.pro))
|
||||
}
|
||||
|
||||
openbsd-* {
|
||||
|
@ -110,8 +110,6 @@ macx {
|
||||
message(Use system opencv libraries.)
|
||||
LIBS += -lopencv_core -lopencv_highgui -lopencv_imgproc
|
||||
}
|
||||
|
||||
error(Missing RetroShare-gui library. Remove Plugins from RetroShare.pro))
|
||||
}
|
||||
|
||||
|
||||
|
@ -1,5 +1,6 @@
|
||||
#include "SpeexProcessor.h"
|
||||
|
||||
#include <util/rsmemory.h>
|
||||
#include <speex/speex.h>
|
||||
#include <speex/speex_preprocess.h>
|
||||
|
||||
@ -350,7 +351,11 @@ void SpeexOutputProcessor::putNetworkPacket(QString name, QByteArray packet) {
|
||||
if (userJitterHash.contains(name)) {
|
||||
userJitter = userJitterHash.value(name);
|
||||
} else {
|
||||
userJitter = (SpeexJitter*)malloc(sizeof(SpeexJitter));
|
||||
userJitter = (SpeexJitter*)rs_malloc(sizeof(SpeexJitter));
|
||||
|
||||
if(!userJitter)
|
||||
return ;
|
||||
|
||||
speex_jitter_init(userJitter, speex_decoder_init(&speex_wb_mode), SAMPLING_RATE);
|
||||
int on = 1;
|
||||
speex_decoder_ctl(userJitter->dec, SPEEX_SET_ENH, &on);
|
||||
|
@ -10,6 +10,8 @@
|
||||
#include <QBuffer>
|
||||
#include <QImage>
|
||||
|
||||
#include "util/rsmemory.h"
|
||||
|
||||
#include "VideoProcessor.h"
|
||||
#include "QVideoDevice.h"
|
||||
|
||||
@ -384,7 +386,10 @@ bool JPEGVideo::encodeData(const QImage& image,uint32_t /* size_hint */,RsVOIPDa
|
||||
buffer.open(QIODevice::WriteOnly) ;
|
||||
encoded_frame.save(&buffer,"JPEG") ;
|
||||
|
||||
voip_chunk.data = malloc(HEADER_SIZE + qb.size());
|
||||
voip_chunk.data = rs_malloc(HEADER_SIZE + qb.size());
|
||||
|
||||
if(!voip_chunk.data)
|
||||
return false ;
|
||||
|
||||
// build header
|
||||
uint32_t flags = differential_frame ? JPEG_VIDEO_FLAGS_DIFFERENTIAL_FRAME : 0x0 ;
|
||||
@ -679,7 +684,11 @@ bool FFmpegVideo::encodeData(const QImage& image, uint32_t target_encoding_bitra
|
||||
|
||||
if(got_output)
|
||||
{
|
||||
voip_chunk.data = malloc(pkt.size + HEADER_SIZE) ;
|
||||
voip_chunk.data = rs_malloc(pkt.size + HEADER_SIZE) ;
|
||||
|
||||
if(!voip_chunk.data)
|
||||
return false ;
|
||||
|
||||
uint32_t flags = 0;
|
||||
|
||||
((unsigned char *)voip_chunk.data)[0] = VideoProcessor::VIDEO_PROCESSOR_CODEC_ID_MPEG_VIDEO & 0xff ;
|
||||
|
@ -280,11 +280,10 @@ int p3VOIP::sendVoipData(const RsPeerId& peer_id,const RsVOIPDataChunk& chunk)
|
||||
std::cerr << "Cannot allocate RsVOIPDataItem !" << std::endl;
|
||||
return false ;
|
||||
}
|
||||
item->voip_data = malloc(chunk.size) ;
|
||||
item->voip_data = rs_malloc(chunk.size) ;
|
||||
|
||||
if(item->voip_data == NULL)
|
||||
{
|
||||
std::cerr << "Cannot allocate RsVOIPDataItem.voip_data of size " << chunk.size << " !" << std::endl;
|
||||
delete item ;
|
||||
return false ;
|
||||
}
|
||||
@ -432,7 +431,13 @@ bool p3VOIP::getIncomingData(const RsPeerId& peer_id,std::vector<RsVOIPDataChunk
|
||||
{
|
||||
RsVOIPDataChunk chunk ;
|
||||
chunk.size = (*it2)->data_size ;
|
||||
chunk.data = malloc((*it2)->data_size) ;
|
||||
chunk.data = rs_malloc((*it2)->data_size) ;
|
||||
|
||||
if(chunk.data == NULL)
|
||||
{
|
||||
delete *it2 ;
|
||||
continue ;
|
||||
}
|
||||
|
||||
uint32_t type_flags = (*it2)->flags & (RS_VOIP_FLAGS_AUDIO_DATA | RS_VOIP_FLAGS_VIDEO_DATA) ;
|
||||
if(type_flags == RS_VOIP_FLAGS_AUDIO_DATA)
|
||||
|
@ -447,7 +447,14 @@ RsVOIPDataItem::RsVOIPDataItem(void *data, uint32_t pktsize)
|
||||
ok &= getRawUInt32(data, rssize, &offset, &flags);
|
||||
ok &= getRawUInt32(data, rssize, &offset, &data_size);
|
||||
|
||||
voip_data = malloc(data_size) ;
|
||||
if(data_size > rssize || rssize - data_size < offset)
|
||||
throw std::runtime_error("Not enough space.") ;
|
||||
|
||||
voip_data = rs_malloc(data_size) ;
|
||||
|
||||
if(!voip_data)
|
||||
throw std::runtime_error("Serialization error.") ;
|
||||
|
||||
memcpy(voip_data,&((uint8_t*)data)[offset],data_size) ;
|
||||
offset += data_size ;
|
||||
|
||||
|
@ -501,10 +501,7 @@ void ChatLobbyWidget::updateDisplay()
|
||||
#endif
|
||||
|
||||
|
||||
bool subscribed = false;
|
||||
if (rsMsgs->getVirtualPeerId(lobby.lobby_id, vpid)) {
|
||||
subscribed = true;
|
||||
}
|
||||
bool subscribed = std::find(lobbies.begin(), lobbies.end(), lobby.lobby_id) != lobbies.end();
|
||||
|
||||
QTreeWidgetItem *item = NULL;
|
||||
QTreeWidgetItem *lobby_item =NULL;
|
||||
@ -1101,13 +1098,10 @@ void ChatLobbyWidget::readChatLobbyInvites()
|
||||
continue ;
|
||||
}
|
||||
|
||||
rsMsgs->acceptLobbyInvite((*it).lobby_id,chosen_id);
|
||||
|
||||
RsPeerId vpid;
|
||||
if(rsMsgs->getVirtualPeerId((*it).lobby_id,vpid ))
|
||||
if(rsMsgs->acceptLobbyInvite((*it).lobby_id,chosen_id))
|
||||
ChatDialog::chatFriend(ChatId((*it).lobby_id),true);
|
||||
else
|
||||
std::cerr << "No lobby known with id 0x" << std::hex << (*it).lobby_id << std::dec << std::endl;
|
||||
std::cerr << "Can't join lobby with id 0x" << std::hex << (*it).lobby_id << std::dec << std::endl;
|
||||
|
||||
}
|
||||
}
|
||||
|
@ -6,8 +6,8 @@
|
||||
<rect>
|
||||
<x>0</x>
|
||||
<y>0</y>
|
||||
<width>1484</width>
|
||||
<height>791</height>
|
||||
<width>745</width>
|
||||
<height>500</height>
|
||||
</rect>
|
||||
</property>
|
||||
<property name="sizePolicy">
|
||||
@ -35,6 +35,18 @@
|
||||
<enum>QFrame::Sunken</enum>
|
||||
</property>
|
||||
<layout class="QHBoxLayout" name="horizontalLayout">
|
||||
<property name="leftMargin">
|
||||
<number>2</number>
|
||||
</property>
|
||||
<property name="topMargin">
|
||||
<number>2</number>
|
||||
</property>
|
||||
<property name="rightMargin">
|
||||
<number>2</number>
|
||||
</property>
|
||||
<property name="bottomMargin">
|
||||
<number>2</number>
|
||||
</property>
|
||||
<item>
|
||||
<widget class="QLabel" name="titleBarPixmap">
|
||||
<property name="minimumSize">
|
||||
@ -107,7 +119,7 @@
|
||||
</layout>
|
||||
</widget>
|
||||
</item>
|
||||
<item>
|
||||
<item row="1" column="0">
|
||||
<widget class="QSplitter" name="splitter">
|
||||
<property name="orientation">
|
||||
<enum>Qt::Horizontal</enum>
|
||||
@ -226,16 +238,7 @@
|
||||
</item>
|
||||
</layout>
|
||||
</widget>
|
||||
<widget class="QTabWidget" name="tabWidget1">
|
||||
<property name="currentIndex">
|
||||
<number>0</number>
|
||||
</property>
|
||||
<widget class="QWidget" name="tab_2">
|
||||
<attribute name="title">
|
||||
<string>Person</string>
|
||||
</attribute>
|
||||
<layout class="QVBoxLayout" name="verticalLayout">
|
||||
<item>
|
||||
<widget class="QWidget" name="layoutWidget">
|
||||
<layout class="QVBoxLayout" name="verticalLayout_4">
|
||||
<item>
|
||||
<widget class="QFrame" name="headerFrame">
|
||||
@ -245,6 +248,33 @@
|
||||
<property name="frameShadow">
|
||||
<enum>QFrame::Raised</enum>
|
||||
</property>
|
||||
<layout class="QGridLayout" name="gridLayout_4">
|
||||
<property name="horizontalSpacing">
|
||||
<number>12</number>
|
||||
</property>
|
||||
<item row="0" column="0" rowspan="2">
|
||||
<widget class="QLabel" name="avlabel">
|
||||
<property name="minimumSize">
|
||||
<size>
|
||||
<width>64</width>
|
||||
<height>64</height>
|
||||
</size>
|
||||
</property>
|
||||
<property name="maximumSize">
|
||||
<size>
|
||||
<width>64</width>
|
||||
<height>64</height>
|
||||
</size>
|
||||
</property>
|
||||
<property name="styleSheet">
|
||||
<string notr="true"/>
|
||||
</property>
|
||||
<property name="text">
|
||||
<string/>
|
||||
</property>
|
||||
<property name="frameShadow">
|
||||
<enum>QFrame::Raised</enum>
|
||||
</property>
|
||||
<layout class="QGridLayout" name="gridLayout_4">
|
||||
<property name="horizontalSpacing">
|
||||
<number>12</number>
|
||||
|
@ -852,8 +852,6 @@ void MessagesDialog::insertMessages()
|
||||
|
||||
rsMail -> getMessageSummaries(msgList);
|
||||
|
||||
std::cerr << "MessagesDialog::insertMessages()" << std::endl;
|
||||
|
||||
int filterColumn = ui.filterLineEdit->currentFilter();
|
||||
|
||||
/* check the mode we are in */
|
||||
@ -1098,25 +1096,34 @@ void MessagesDialog::insertMessages()
|
||||
// From ....
|
||||
{
|
||||
bool setText = true;
|
||||
if (msgbox == RS_MSG_INBOX || msgbox == RS_MSG_OUTBOX) {
|
||||
if (msgbox == RS_MSG_INBOX || msgbox == RS_MSG_OUTBOX)
|
||||
{
|
||||
if ((it->msgflags & RS_MSG_SYSTEM) && it->srcId == ownId) {
|
||||
text = "RetroShare";
|
||||
} else {
|
||||
}
|
||||
else
|
||||
{
|
||||
if (it->msgflags & RS_MSG_DISTANT)
|
||||
{
|
||||
// distant message
|
||||
setText = false;
|
||||
if (gotInfo || rsMail->getMessage(it->msgId, msgInfo)) {
|
||||
gotInfo = true;
|
||||
|
||||
if(msgbox != RS_MSG_INBOX && !msgInfo.rsgxsid_msgto.empty())
|
||||
item->setId(RsGxsId(*msgInfo.rsgxsid_msgto.begin()), COLUMN_FROM, false);
|
||||
else
|
||||
item->setId(RsGxsId(msgInfo.rsgxsid_srcId), COLUMN_FROM, false);
|
||||
} else {
|
||||
}
|
||||
else
|
||||
std::cerr << "MessagesDialog::insertMsgTxtAndFiles() Couldn't find Msg" << std::endl;
|
||||
}
|
||||
} else {
|
||||
else
|
||||
text = QString::fromUtf8(rsPeers->getPeerName(it->srcId).c_str());
|
||||
}
|
||||
}
|
||||
} else {
|
||||
else
|
||||
{
|
||||
if (gotInfo || rsMail->getMessage(it->msgId, msgInfo)) {
|
||||
gotInfo = true;
|
||||
|
||||
@ -1459,8 +1466,6 @@ void MessagesDialog::setMsgStar(const QList<QTreeWidgetItem*> &items, bool star)
|
||||
|
||||
void MessagesDialog::insertMsgTxtAndFiles(QTreeWidgetItem *item, bool bSetToRead)
|
||||
{
|
||||
std::cerr << "MessagesDialog::insertMsgTxtAndFiles()" << std::endl;
|
||||
|
||||
/* get its Ids */
|
||||
std::string cid;
|
||||
std::string mid;
|
||||
|
@ -71,6 +71,8 @@ PluginManager::defaultLoad( )
|
||||
QStringList currAvailable = workDir.entryList(QDir::Files);
|
||||
#if defined(Q_OS_WIN)
|
||||
QRegExp trx("*.dll") ;
|
||||
#elif defined(__MACH__)
|
||||
QRegExp trx("*.dylib");
|
||||
#else
|
||||
QRegExp trx("*.so");
|
||||
#endif
|
||||
|
@ -533,6 +533,20 @@ QVariant RetroshareDirModel::data(const QModelIndex &index, int role) const
|
||||
{
|
||||
if(details->min_age > ageIndicator)
|
||||
return QVariant(QColor(Qt::gray)) ;
|
||||
else if(RemoteMode)
|
||||
{
|
||||
FileInfo info;
|
||||
QVariant local_file_color = QVariant(QColor(Qt::red));
|
||||
if(rsFiles->alreadyHaveFile(details->hash, info))
|
||||
return local_file_color;
|
||||
|
||||
std::list<RsFileHash> downloads;
|
||||
rsFiles->FileDownloads(downloads);
|
||||
if(std::find(downloads.begin(), downloads.end(), details->hash) != downloads.end())
|
||||
return local_file_color;
|
||||
else
|
||||
return QVariant();
|
||||
}
|
||||
else
|
||||
return QVariant() ; // standard
|
||||
} /* end of TextColorRole */
|
||||
|
@ -363,9 +363,6 @@ void SharedFilesDialog::changeCurrentViewModel(int viewTypeIndex)
|
||||
|
||||
ui.dirTreeView->header()->headerDataChanged(Qt::Horizontal, COLUMN_NAME, COLUMN_DIR) ;
|
||||
|
||||
#ifdef DONT_USE_SEARCH_IN_TREE_VIEW
|
||||
if(viewTypeIndex == VIEW_TYPE_FLAT)
|
||||
#endif
|
||||
FilterItems();
|
||||
}
|
||||
|
||||
@ -1017,6 +1014,11 @@ void SharedFilesDialog::startFilter()
|
||||
|
||||
void SharedFilesDialog::FilterItems()
|
||||
{
|
||||
#ifdef DONT_USE_SEARCH_IN_TREE_VIEW
|
||||
if(proxyModel == tree_proxyModel)
|
||||
return;
|
||||
#endif
|
||||
|
||||
QString text = ui.filterPatternLineEdit->text();
|
||||
|
||||
setCursor(Qt::WaitCursor);
|
||||
|
@ -1391,7 +1391,13 @@ void ChatWidget::smileyWidget()
|
||||
|
||||
void ChatWidget::addSmiley()
|
||||
{
|
||||
ui->chatTextEdit->textCursor().insertText(qobject_cast<QPushButton*>(sender())->toolTip().split("|").first());
|
||||
QString smiley = qobject_cast<QPushButton*>(sender())->toolTip().split("|").first();
|
||||
// add trailing space
|
||||
smiley += QString(" ");
|
||||
// add preceding space when needed (not at start of text or preceding space already exists)
|
||||
if(!ui->chatTextEdit->textCursor().atStart() && ui->chatTextEdit->toPlainText()[ui->chatTextEdit->textCursor().position() - 1] != QChar(' '))
|
||||
smiley = QString(" ") + smiley;
|
||||
ui->chatTextEdit->textCursor().insertText(smiley);
|
||||
}
|
||||
|
||||
void ChatWidget::clearChatHistory()
|
||||
|
@ -11,12 +11,21 @@
|
||||
</rect>
|
||||
</property>
|
||||
<layout class="QGridLayout" name="gridLayout">
|
||||
<property name="leftMargin">
|
||||
<number>0</number>
|
||||
</property>
|
||||
<property name="topMargin">
|
||||
<number>0</number>
|
||||
</property>
|
||||
<property name="rightMargin">
|
||||
<number>0</number>
|
||||
</property>
|
||||
<property name="bottomMargin">
|
||||
<number>0</number>
|
||||
</property>
|
||||
<property name="verticalSpacing">
|
||||
<number>2</number>
|
||||
</property>
|
||||
<property name="margin">
|
||||
<number>0</number>
|
||||
</property>
|
||||
<item row="1" column="0">
|
||||
<layout class="QHBoxLayout" name="hl_TextChat">
|
||||
<property name="spacing">
|
||||
@ -37,7 +46,16 @@
|
||||
<enum>QFrame::Raised</enum>
|
||||
</property>
|
||||
<layout class="QVBoxLayout" name="verticalLayout_2">
|
||||
<property name="margin">
|
||||
<property name="leftMargin">
|
||||
<number>0</number>
|
||||
</property>
|
||||
<property name="topMargin">
|
||||
<number>0</number>
|
||||
</property>
|
||||
<property name="rightMargin">
|
||||
<number>0</number>
|
||||
</property>
|
||||
<property name="bottomMargin">
|
||||
<number>0</number>
|
||||
</property>
|
||||
<item>
|
||||
@ -113,7 +131,16 @@
|
||||
<enum>QFrame::Box</enum>
|
||||
</property>
|
||||
<layout class="QHBoxLayout" name="horizontalLayout_2">
|
||||
<property name="margin">
|
||||
<property name="leftMargin">
|
||||
<number>6</number>
|
||||
</property>
|
||||
<property name="topMargin">
|
||||
<number>6</number>
|
||||
</property>
|
||||
<property name="rightMargin">
|
||||
<number>6</number>
|
||||
</property>
|
||||
<property name="bottomMargin">
|
||||
<number>6</number>
|
||||
</property>
|
||||
<item>
|
||||
@ -299,7 +326,16 @@ border-image: url(:/images/closepressed.png)
|
||||
<enum>QFrame::Sunken</enum>
|
||||
</property>
|
||||
<layout class="QHBoxLayout" name="horizontalLayout">
|
||||
<property name="margin">
|
||||
<property name="leftMargin">
|
||||
<number>2</number>
|
||||
</property>
|
||||
<property name="topMargin">
|
||||
<number>2</number>
|
||||
</property>
|
||||
<property name="rightMargin">
|
||||
<number>2</number>
|
||||
</property>
|
||||
<property name="bottomMargin">
|
||||
<number>2</number>
|
||||
</property>
|
||||
<item>
|
||||
@ -326,8 +362,8 @@ border-image: url(:/images/closepressed.png)
|
||||
<enum>Qt::NoFocus</enum>
|
||||
</property>
|
||||
<property name="icon">
|
||||
<iconset resource="../images.qrc">
|
||||
<normaloff>:/images/emoticons/kopete/kopete020.png</normaloff>:/images/emoticons/kopete/kopete020.png</iconset>
|
||||
<iconset resource="../emojione.qrc">
|
||||
<normaloff>:/emojione/1F603.png</normaloff>:/emojione/1F603.png</iconset>
|
||||
</property>
|
||||
<property name="iconSize">
|
||||
<size>
|
||||
@ -486,7 +522,16 @@ border-image: url(:/images/closepressed.png)
|
||||
<enum>QFrame::Plain</enum>
|
||||
</property>
|
||||
<layout class="QHBoxLayout" name="HL_pluginButtonFrame">
|
||||
<property name="margin">
|
||||
<property name="leftMargin">
|
||||
<number>2</number>
|
||||
</property>
|
||||
<property name="topMargin">
|
||||
<number>2</number>
|
||||
</property>
|
||||
<property name="rightMargin">
|
||||
<number>2</number>
|
||||
</property>
|
||||
<property name="bottomMargin">
|
||||
<number>2</number>
|
||||
</property>
|
||||
</layout>
|
||||
@ -556,7 +601,16 @@ border-image: url(:/images/closepressed.png)
|
||||
<enum>QFrame::Sunken</enum>
|
||||
</property>
|
||||
<layout class="QHBoxLayout" name="hlTitleBarFrame">
|
||||
<property name="margin">
|
||||
<property name="leftMargin">
|
||||
<number>2</number>
|
||||
</property>
|
||||
<property name="topMargin">
|
||||
<number>2</number>
|
||||
</property>
|
||||
<property name="rightMargin">
|
||||
<number>2</number>
|
||||
</property>
|
||||
<property name="bottomMargin">
|
||||
<number>2</number>
|
||||
</property>
|
||||
<item>
|
||||
@ -637,7 +691,16 @@ border-image: url(:/images/closepressed.png)
|
||||
<enum>QFrame::Plain</enum>
|
||||
</property>
|
||||
<layout class="QHBoxLayout" name="HL_pluginTitleFrame">
|
||||
<property name="margin">
|
||||
<property name="leftMargin">
|
||||
<number>2</number>
|
||||
</property>
|
||||
<property name="topMargin">
|
||||
<number>2</number>
|
||||
</property>
|
||||
<property name="rightMargin">
|
||||
<number>2</number>
|
||||
</property>
|
||||
<property name="bottomMargin">
|
||||
<number>2</number>
|
||||
</property>
|
||||
</layout>
|
||||
@ -652,7 +715,16 @@ border-image: url(:/images/closepressed.png)
|
||||
<enum>QFrame::Raised</enum>
|
||||
</property>
|
||||
<layout class="QGridLayout" name="gridLayout_2">
|
||||
<property name="margin">
|
||||
<property name="leftMargin">
|
||||
<number>0</number>
|
||||
</property>
|
||||
<property name="topMargin">
|
||||
<number>0</number>
|
||||
</property>
|
||||
<property name="rightMargin">
|
||||
<number>0</number>
|
||||
</property>
|
||||
<property name="bottomMargin">
|
||||
<number>0</number>
|
||||
</property>
|
||||
<item row="0" column="5">
|
||||
@ -1020,6 +1092,7 @@ border-image: url(:/images/closepressed.png)
|
||||
</customwidgets>
|
||||
<resources>
|
||||
<include location="../images.qrc"/>
|
||||
<include location="../emojione.qrc"/>
|
||||
</resources>
|
||||
<connections/>
|
||||
</ui>
|
||||
|
@ -1,3 +1,5 @@
|
||||
#include <iostream>
|
||||
|
||||
#include <QDesktopServices>
|
||||
#include <QPainter>
|
||||
|
||||
@ -72,13 +74,23 @@ void RSTextBrowser::paintEvent(QPaintEvent *event)
|
||||
|
||||
QVariant RSTextBrowser::loadResource(int type, const QUrl &name)
|
||||
{
|
||||
if (mShowImages || type != QTextDocument::ImageResource || name.scheme().compare("data", Qt::CaseInsensitive) != 0) {
|
||||
return QTextBrowser::loadResource(type, name);
|
||||
}
|
||||
// case 1: always trust the image if it comes from an internal resource
|
||||
|
||||
if (mImageBlockWidget) {
|
||||
if(name.scheme().compare("qrc",Qt::CaseInsensitive)==0 && type == QTextDocument::ImageResource)
|
||||
return QTextBrowser::loadResource(type, name);
|
||||
|
||||
// case 2: only display if the user allows it. Data resources can be bad (svg bombs) but we filter them out globally at the network layer.
|
||||
// It would be good to add here a home-made resource loader that only loads images and not svg crap, just in case.
|
||||
|
||||
if(name.scheme().compare("data",Qt::CaseInsensitive)==0 && mShowImages)
|
||||
return QTextBrowser::loadResource(type, name);
|
||||
|
||||
// case 3: otherwise, do not display
|
||||
|
||||
std::cerr << "TEXTBROWSER: refusing load ressource request: type=" << type << " scheme=" << name.scheme().toStdString() << ", url=" << name.toString().toStdString() << std::endl;
|
||||
|
||||
if (mImageBlockWidget)
|
||||
mImageBlockWidget->show();
|
||||
}
|
||||
|
||||
return QPixmap(":/trolltech/styles/commonstyle/images/file-16.png");
|
||||
}
|
||||
|
@ -6,8 +6,8 @@
|
||||
<rect>
|
||||
<x>0</x>
|
||||
<y>0</y>
|
||||
<width>635</width>
|
||||
<height>634</height>
|
||||
<width>678</width>
|
||||
<height>727</height>
|
||||
</rect>
|
||||
</property>
|
||||
<property name="windowTitle">
|
||||
@ -60,7 +60,7 @@
|
||||
<item row="0" column="0">
|
||||
<widget class="QTabWidget" name="stabWidget">
|
||||
<property name="currentIndex">
|
||||
<number>2</number>
|
||||
<number>0</number>
|
||||
</property>
|
||||
<widget class="QWidget" name="tab">
|
||||
<attribute name="icon">
|
||||
@ -470,6 +470,9 @@
|
||||
</item>
|
||||
<item row="1" column="0">
|
||||
<widget class="QCheckBox" name="_allow_push_CB">
|
||||
<property name="toolTip">
|
||||
<string><html><head/><body><p>This option allows you to automatically download a file that is recommended in an message coming from this node. This can be used for instance to send files between your own nodes.</p></body></html></string>
|
||||
</property>
|
||||
<property name="text">
|
||||
<string>Auto-download recommended files from this node</string>
|
||||
</property>
|
||||
@ -495,12 +498,6 @@
|
||||
</layout>
|
||||
</widget>
|
||||
<customwidgets>
|
||||
<customwidget>
|
||||
<class>AvatarWidget</class>
|
||||
<extends>QLabel</extends>
|
||||
<header>gui/common/AvatarWidget.h</header>
|
||||
<container>1</container>
|
||||
</customwidget>
|
||||
<customwidget>
|
||||
<class>HeaderFrame</class>
|
||||
<extends>QFrame</extends>
|
||||
@ -512,6 +509,12 @@
|
||||
<extends>QTextBrowser</extends>
|
||||
<header>gui/common/RSTextBrowser.h</header>
|
||||
</customwidget>
|
||||
<customwidget>
|
||||
<class>AvatarWidget</class>
|
||||
<extends>QLabel</extends>
|
||||
<header>gui/common/AvatarWidget.h</header>
|
||||
<container>1</container>
|
||||
</customwidget>
|
||||
</customwidgets>
|
||||
<resources>
|
||||
<include location="../images.qrc"/>
|
||||
|
@ -94,7 +94,7 @@
|
||||
<item>
|
||||
<widget class="QLabel" name="userCertLabel">
|
||||
<property name="text">
|
||||
<string>The text below is your PGP certificate. You have to provide it to your friend</string>
|
||||
<string>The text below is your Retroshare certificate. You have to provide it to your friend</string>
|
||||
</property>
|
||||
</widget>
|
||||
</item>
|
||||
@ -278,7 +278,7 @@
|
||||
<item>
|
||||
<widget class="QLabel" name="friendCertLabel">
|
||||
<property name="text">
|
||||
<string>Please, paste your friend's PGP certificate into the box below</string>
|
||||
<string>Please, paste your friend's Retroshare certificate into the box below</string>
|
||||
</property>
|
||||
</widget>
|
||||
</item>
|
||||
@ -291,6 +291,9 @@
|
||||
<family>Courier New</family>
|
||||
</font>
|
||||
</property>
|
||||
<property name="toolTip">
|
||||
<string><html><head/><body><p>This box expects your friend's Retroshare certificate. WARNING: this is different from your friend's PGP key. Do not paste your friend's PGP key here (not even a part of it). It's not going to work.</p></body></html></string>
|
||||
</property>
|
||||
<property name="lineWrapMode">
|
||||
<enum>QPlainTextEdit::NoWrap</enum>
|
||||
</property>
|
||||
@ -524,16 +527,7 @@
|
||||
<layout class="QGridLayout" name="gridLayout">
|
||||
<item row="0" column="0">
|
||||
<layout class="QHBoxLayout" name="horizontalLayout_10">
|
||||
<property name="leftMargin">
|
||||
<number>9</number>
|
||||
</property>
|
||||
<property name="topMargin">
|
||||
<number>9</number>
|
||||
</property>
|
||||
<property name="rightMargin">
|
||||
<number>9</number>
|
||||
</property>
|
||||
<property name="bottomMargin">
|
||||
<property name="margin">
|
||||
<number>9</number>
|
||||
</property>
|
||||
<item>
|
||||
|
@ -6,7 +6,7 @@
|
||||
<rect>
|
||||
<x>0</x>
|
||||
<y>0</y>
|
||||
<width>861</width>
|
||||
<width>990</width>
|
||||
<height>668</height>
|
||||
</rect>
|
||||
</property>
|
||||
@ -27,7 +27,7 @@
|
||||
<item>
|
||||
<widget class="QTabWidget" name="stabWidget">
|
||||
<property name="currentIndex">
|
||||
<number>0</number>
|
||||
<number>1</number>
|
||||
</property>
|
||||
<widget class="QWidget" name="tab">
|
||||
<attribute name="title">
|
||||
@ -61,6 +61,9 @@
|
||||
</item>
|
||||
<item row="1" column="1">
|
||||
<widget class="QLineEdit" name="pgpfingerprint">
|
||||
<property name="toolTip">
|
||||
<string><html><head/><body><p>The PGP key fingerprint is a---supposedly unforgeable---characteristics of the PGP key. In order to make sure that you're dealing with the right key, compare the fingerprints.</p></body></html></string>
|
||||
</property>
|
||||
<property name="readOnly">
|
||||
<bool>true</bool>
|
||||
</property>
|
||||
@ -78,6 +81,9 @@
|
||||
</item>
|
||||
<item row="2" column="1">
|
||||
<widget class="QComboBox" name="trustlevel_CB">
|
||||
<property name="toolTip">
|
||||
<string><html><head/><body><p>The trust level is an optional and local parameter that you can set in order to remember your option about a given PGP key. It is not used whatsoever to authorize connections. </p></body></html></string>
|
||||
</property>
|
||||
<item>
|
||||
<property name="text">
|
||||
<string>Unset</string>
|
||||
@ -158,7 +164,11 @@
|
||||
</property>
|
||||
<layout class="QVBoxLayout" name="_11">
|
||||
<item>
|
||||
<widget class="RSTextBrowser" name="signers"/>
|
||||
<widget class="RSTextBrowser" name="signers">
|
||||
<property name="toolTip">
|
||||
<string><html><head/><body><p><span style=" font-size:10pt;">Signing a friend's key is a way to express your trust into this friend, to your other friends. The signatures below cryptographically attest that owners of the listed keys recognise the current PGP key as authentic.</span></p></body></html></string>
|
||||
</property>
|
||||
</widget>
|
||||
</item>
|
||||
</layout>
|
||||
</widget>
|
||||
@ -174,10 +184,8 @@
|
||||
<string><!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN" "http://www.w3.org/TR/REC-html40/strict.dtd">
|
||||
<html><head><meta name="qrichtext" content="1" /><style type="text/css">
|
||||
p, li { white-space: pre-wrap; }
|
||||
</style></head><body style=" font-family:'Sans'; font-size:10pt; font-weight:400; font-style:normal;">
|
||||
<p align="justify" style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Signing a friend's key is a way to express your trust into this friend, to your other friends. Besides, only signed peers will receive information about your other trusted friends.</p>
|
||||
<p align="justify" style="-qt-paragraph-type:empty; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"></p>
|
||||
<p align="justify" style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Signing a key cannot be undone, so do it wisely.</p></body></html></string>
|
||||
</style></head><body style=" font-family:'Sans'; font-size:9pt; font-weight:400; font-style:normal;">
|
||||
<p align="justify" style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><span style=" font-size:10pt;">Signing a friend's key is a way to express your trust into this friend, to your other friends. It helps them to decide whether to allow connections from that key based on your own trust. Signing a key is absolutely optional and cannot be undone, so do it wisely.</span></p></body></html></string>
|
||||
</property>
|
||||
<property name="text">
|
||||
<string>Sign this PGP key</string>
|
||||
@ -199,6 +207,9 @@ p, li { white-space: pre-wrap; }
|
||||
</item>
|
||||
<item>
|
||||
<widget class="QCheckBox" name="signGPGKeyCheckBox">
|
||||
<property name="toolTip">
|
||||
<string><html><head/><body><p><span style=" font-size:10pt;">Signing a friend's key is a way to express your trust into this friend, to your other friends. It helps them to decide whether to allow connections from that key based on your own trust. Signing a key is absolutely optional and cannot be undone, so do it wisely.</span></p></body></html></string>
|
||||
</property>
|
||||
<property name="text">
|
||||
<string>Sign PGP key</string>
|
||||
</property>
|
||||
@ -219,6 +230,9 @@ p, li { white-space: pre-wrap; }
|
||||
</item>
|
||||
<item>
|
||||
<widget class="QToolButton" name="denyFriendButton">
|
||||
<property name="toolTip">
|
||||
<string><html><head/><body><p>Click here if you want to refuse connections to nodes authenticated by this key.</p></body></html></string>
|
||||
</property>
|
||||
<property name="text">
|
||||
<string>Deny connections</string>
|
||||
</property>
|
||||
@ -239,6 +253,9 @@ p, li { white-space: pre-wrap; }
|
||||
</item>
|
||||
<item>
|
||||
<widget class="QToolButton" name="make_friend_button">
|
||||
<property name="toolTip">
|
||||
<string><html><head/><body><p>Click this if you want your node to accept connecting to Retroshare nodes authenticated by this PGP key. This is done automatically when exchanging your Retroshare certificate with someone. In order to make friends, it is better to exchange certificates than accept connections from a given key, since the certificate also contain useful connection information (IP, DNS, SSL ids, etc).</p></body></html></string>
|
||||
</property>
|
||||
<property name="text">
|
||||
<string>Accept connections</string>
|
||||
</property>
|
||||
@ -292,6 +309,9 @@ p, li { white-space: pre-wrap; }
|
||||
<layout class="QHBoxLayout" name="horizontalLayout">
|
||||
<item>
|
||||
<widget class="QCheckBox" name="_shouldAddSignatures_CB_2">
|
||||
<property name="toolTip">
|
||||
<string><html><head/><body><p>This button will toggle the inclusion of signatures in the ascii display of the PGP key. See the comments about signatures in the other tab. </p></body></html></string>
|
||||
</property>
|
||||
<property name="text">
|
||||
<string>Include signatures</string>
|
||||
</property>
|
||||
|
@ -188,16 +188,6 @@
|
||||
<file>emojione/1F199.png</file>
|
||||
<file>emojione/1F201.png</file>
|
||||
<file>emojione/1F202.png</file>
|
||||
<file>emojione/1F232.png</file>
|
||||
<file>emojione/1F233.png</file>
|
||||
<file>emojione/1F234.png</file>
|
||||
<file>emojione/1F235.png</file>
|
||||
<file>emojione/1F236.png</file>
|
||||
<file>emojione/1F237.png</file>
|
||||
<file>emojione/1F238.png</file>
|
||||
<file>emojione/1F239.png</file>
|
||||
<file>emojione/1F250.png</file>
|
||||
<file>emojione/1F251.png</file>
|
||||
<file>emojione/1F300.png</file>
|
||||
<file>emojione/1F301.png</file>
|
||||
<file>emojione/1F302.png</file>
|
||||
@ -400,6 +390,7 @@
|
||||
<file>emojione/1F597.png</file>
|
||||
<file>emojione/1F598.png</file>
|
||||
<file>emojione/1F599.png</file>
|
||||
<file>emojione/1F59E.png</file>
|
||||
<file>emojione/1F600.png</file>
|
||||
<file>emojione/1F601.png</file>
|
||||
<file>emojione/1F602.png</file>
|
||||
@ -544,8 +535,6 @@
|
||||
<file>emojione/2934.png</file>
|
||||
<file>emojione/2935.png</file>
|
||||
<file>emojione/3030.png</file>
|
||||
<file>emojione/3297.png</file>
|
||||
<file>emojione/3299.png</file>
|
||||
<file>emojione/1f910.png</file>
|
||||
<file>emojione/1f911.png</file>
|
||||
<file>emojione/1f912.png</file>
|
||||
|
Before Width: | Height: | Size: 1.0 KiB After Width: | Height: | Size: 950 B |
Before Width: | Height: | Size: 987 B After Width: | Height: | Size: 1010 B |
Before Width: | Height: | Size: 866 B After Width: | Height: | Size: 892 B |
Before Width: | Height: | Size: 656 B After Width: | Height: | Size: 693 B |
Before Width: | Height: | Size: 899 B After Width: | Height: | Size: 879 B |
Before Width: | Height: | Size: 967 B After Width: | Height: | Size: 948 B |
Before Width: | Height: | Size: 786 B After Width: | Height: | Size: 814 B |
Before Width: | Height: | Size: 923 B After Width: | Height: | Size: 904 B |
Before Width: | Height: | Size: 961 B After Width: | Height: | Size: 956 B |
Before Width: | Height: | Size: 782 B After Width: | Height: | Size: 795 B |
Before Width: | Height: | Size: 1002 B After Width: | Height: | Size: 930 B |
Before Width: | Height: | Size: 976 B After Width: | Height: | Size: 920 B |
Before Width: | Height: | Size: 1.6 KiB After Width: | Height: | Size: 1.5 KiB |
Before Width: | Height: | Size: 1.4 KiB After Width: | Height: | Size: 1.3 KiB |
Before Width: | Height: | Size: 1.5 KiB After Width: | Height: | Size: 1.4 KiB |
Before Width: | Height: | Size: 1.3 KiB After Width: | Height: | Size: 1.2 KiB |
Before Width: | Height: | Size: 689 B After Width: | Height: | Size: 840 B |
Before Width: | Height: | Size: 710 B After Width: | Height: | Size: 793 B |
Before Width: | Height: | Size: 881 B After Width: | Height: | Size: 919 B |
Before Width: | Height: | Size: 672 B After Width: | Height: | Size: 725 B |
Before Width: | Height: | Size: 951 B After Width: | Height: | Size: 931 B |
Before Width: | Height: | Size: 748 B After Width: | Height: | Size: 771 B |