mirror of
https://github.com/RetroShare/RetroShare.git
synced 2024-12-29 01:16:20 -05:00
merged with upstream/master
This commit is contained in:
csoler
commit
70648398e2
@ -1,5 +1,40 @@
|
||||
retroshare06 (0.6.0-1.XXXXXX~YYYYYY) YYYYYY; urgency=low
|
||||
|
||||
0dc43c3 csoler Sat, 23 Apr 2016 08:29:53 -0400 Merge pull request #338 from Nyfor/master
|
||||
5e94c77 Nyfor Mon, 4 Apr 2016 12:07:09 +0200 Fixed compilation for Clang.
|
||||
d696f72 csoler Fri, 22 Apr 2016 20:38:07 -0400 fixed compilation
|
||||
acd059b csoler Fri, 22 Apr 2016 18:49:42 -0400 removed potential memory leak in TransfersDialog
|
||||
52cf66a csoler Fri, 22 Apr 2016 17:55:15 -0400 fixed memory leak in SubscribeToolButton menu
|
||||
55e8087 csoler Fri, 22 Apr 2016 17:30:55 -0400 added missing free for public keys used in envelop encryption
|
||||
10230df csoler Fri, 22 Apr 2016 16:50:43 -0400 added missing SSL shutdown when replacing existing connection
|
||||
5261c3c csoler Thu, 21 Apr 2016 22:23:07 -0400 prevented turtle to not deleting a config item when it is not cast
|
||||
e9fa9eb csoler Thu, 21 Apr 2016 22:07:50 -0400 removed tricky memory leak in chat lobbies due to handling of partial messages
|
||||
7aea6e5 csoler Thu, 21 Apr 2016 22:07:10 -0400 removed some debug info
|
||||
eca83fd csoler Thu, 21 Apr 2016 19:54:50 -0400 removed some debug info
|
||||
fba3d37 csoler Thu, 21 Apr 2016 19:47:34 -0400 fixed memory leak after receiving RsNxsItem deserialised from decrypted memory
|
||||
0d3ff0e csoler Thu, 21 Apr 2016 19:46:47 -0400 fixed possible uninitialised memory read in memory decryption return
|
||||
0c711a4 csoler Thu, 21 Apr 2016 19:41:21 -0400 added missing calls to EVP_CIPHER_CTX_cleanup() to release memory after decryption, causing memory
|
||||
3fae108 csoler Thu, 21 Apr 2016 12:58:48 -0400 removed div by zero in transfers dialog
|
||||
0572492 csoler Wed, 20 Apr 2016 21:20:47 -0400 severely reduced packet grouping, which limited the effectiveness of QoS
|
||||
d6ae71e csoler Wed, 20 Apr 2016 20:21:29 -0400 removed pointer to QStringList in QHash, causing memory loss
|
||||
aba3d2f csoler Wed, 20 Apr 2016 18:24:02 -0400 removed memory leak due to zeroing (on purpose!) a data chunk in GRouter before deleting it
|
||||
d017771 csoler Wed, 20 Apr 2016 18:08:26 -0400 fixed missing sendTime in distant chat, causing inconsistent display in GUI
|
||||
80a9fec csoler Tue, 19 Apr 2016 22:18:25 -0400 Merge pull request #353 from crhode/master
|
||||
39553a6 csoler Tue, 19 Apr 2016 21:58:30 -0400 removed debug info
|
||||
5645e44 Manuel Davis Tue, 19 Apr 2016 11:32:56 -0500 Change regular expression(s) for identifying hotlinks in feral text.
|
||||
8be53dd Manuel Davis Tue, 19 Apr 2016 11:11:58 -0500 Improve inserting placemark in ChatLobby.
|
||||
26af7c9 csoler Sun, 17 Apr 2016 22:58:48 -0400 changed heart beat limit to a larger value. Apparently too tight a value causes disconnections due
|
||||
c14c240 csoler Sun, 17 Apr 2016 00:51:45 -0400 fixed update of circles GUI using a timer. This is not optimal, and should be replaced by a proper
|
||||
3000f94 csoler Sat, 16 Apr 2016 22:44:06 -0400 separated subscribe status from wether we are part of a circle or not. Still needs update of GUI
|
||||
b861aa9 csoler Sat, 16 Apr 2016 17:10:36 -0400 Merge pull request #352 from AsamK/trailing_semicolon
|
||||
e7ec204 AsamK Sat, 16 Apr 2016 20:40:24 +0200 Add trailing semi-colon to MimeType in .desktop files
|
||||
fa8a585 csoler Fri, 15 Apr 2016 18:25:53 -0400 removed some debug info
|
||||
d642934 csoler Fri, 15 Apr 2016 18:25:41 -0400 increased frequency of update for banned PGP nodes
|
||||
|
||||
-- Cyril Soler <csoler@users.sourceforge.net> Sun, 24 Apr 2016 12:00:00 -0500
|
||||
|
||||
retroshare06 (0.6.0-1.20160415.26574fd9~trusty) trusty; urgency=low
|
||||
|
||||
2552b55 defnax Fri, 15 Apr 2016 20:32:00 +0200 Merge branch 'master' of https://github.com/RetroShare/RetroShare
|
||||
85942f4 defnax Fri, 15 Apr 2016 20:30:32 +0200 improving the create circle layout
|
||||
cb6c2c9 csoler Thu, 14 Apr 2016 23:49:55 -0400 Merge pull request #350 from csoler/v0.6-Circles
|
||||
|
||||
@ -15,19 +15,75 @@ INCLUDEPATH += ../../libretroshare/src
|
||||
unix {
|
||||
|
||||
webui_files.path = "$${DATA_DIR}/webui"
|
||||
webui_files.files = webui/*
|
||||
webui_files.files = webui/app.js webui/app.css webui/index.html
|
||||
INSTALLS += webui_files
|
||||
|
||||
webui_img_files.path = "$${DATA_DIR}/webui/img"
|
||||
webui_img_files.files = ../../retroshare-gui/src/gui/images/logo/logo_splash.png
|
||||
INSTALLS += webui_img_files
|
||||
|
||||
create_webfiles.commands = sh $$_PRO_FILE_PWD_/webui-src/make-src/build.sh $$_PRO_FILE_PWD_
|
||||
QMAKE_EXTRA_TARGETS += create_webfiles
|
||||
PRE_TARGETDEPS += create_webfiles
|
||||
#create_webfiles.commands = sh $$_PRO_FILE_PWD_/webui-src/make-src/build.sh $$_PRO_FILE_PWD_
|
||||
#QMAKE_EXTRA_TARGETS += create_webfiles
|
||||
#POST_TARGETDEPS += create_webfiles
|
||||
|
||||
# create dummy files
|
||||
system(webui-src/make-src/init.sh .)
|
||||
#QMAKE_POST_LINK=sh $$_PRO_FILE_PWD_/webui-src/make-src/build.sh $$_PRO_FILE_PWD_
|
||||
|
||||
WEBUI_SRC_SCRIPT = webui-src/make-src/build.sh
|
||||
|
||||
WEBUI_SRC_HTML = $$WEBUI_SRC_SCRIPT
|
||||
WEBUI_SRC_HTML += webui-src/app/assets/index.html
|
||||
|
||||
WEBUI_SRC_JS = $$WEBUI_SRC_SCRIPT
|
||||
WEBUI_SRC_JS += webui-src/app/accountselect.js
|
||||
WEBUI_SRC_JS += webui-src/app/adddownloads.js
|
||||
WEBUI_SRC_JS += webui-src/app/addidentity.js
|
||||
WEBUI_SRC_JS += webui-src/app/addpeer.js
|
||||
WEBUI_SRC_JS += webui-src/app/chat.js
|
||||
WEBUI_SRC_JS += webui-src/app/createlogin.js
|
||||
WEBUI_SRC_JS += webui-src/app/downloads.js
|
||||
WEBUI_SRC_JS += webui-src/app/forums.js
|
||||
WEBUI_SRC_JS += webui-src/app/home.js
|
||||
WEBUI_SRC_JS += webui-src/app/identities.js
|
||||
WEBUI_SRC_JS += webui-src/app/main.js
|
||||
WEBUI_SRC_JS += webui-src/app/menudef.js
|
||||
WEBUI_SRC_JS += webui-src/app/menu.js
|
||||
WEBUI_SRC_JS += webui-src/app/mithril.js
|
||||
WEBUI_SRC_JS += webui-src/app/mithril.min.js
|
||||
WEBUI_SRC_JS += webui-src/app/peers.js
|
||||
WEBUI_SRC_JS += webui-src/app/retroshare.js
|
||||
WEBUI_SRC_JS += webui-src/app/search.js
|
||||
WEBUI_SRC_JS += webui-src/app/searchresult.js
|
||||
WEBUI_SRC_JS += webui-src/app/servicecontrol.js
|
||||
WEBUI_SRC_JS += webui-src/app/settings.js
|
||||
WEBUI_SRC_JS += webui-src/app/waiting.js
|
||||
|
||||
WEBUI_SRC_CSS = $$WEBUI_SRC_SCRIPT
|
||||
WEBUI_SRC_CSS += webui-src/app/green-black.scss
|
||||
WEBUI_SRC_CSS += webui-src/app/_reset.scss
|
||||
WEBUI_SRC_CSS += webui-src/app/_chat.sass
|
||||
WEBUI_SRC_CSS += webui-src/app/main.sass
|
||||
|
||||
|
||||
create_webfiles_html.output = webui/index.html
|
||||
create_webfiles_html.input = WEBUI_SRC_HTML
|
||||
create_webfiles_html.commands = sh $$_PRO_FILE_PWD_/webui-src/make-src/build.sh $$_PRO_FILE_PWD_ index.html .
|
||||
create_webfiles_html.variable_out = OBJECTS
|
||||
create_webfiles_html.CONFIG = combine no_link
|
||||
|
||||
create_webfiles_js.output = webui/app.js
|
||||
create_webfiles_js.input = WEBUI_SRC_JS
|
||||
create_webfiles_js.commands = sh $$_PRO_FILE_PWD_/webui-src/make-src/build.sh $$_PRO_FILE_PWD_ app.js .
|
||||
create_webfiles_js.variable_out = OBJECTS
|
||||
create_webfiles_js.CONFIG = combine no_link
|
||||
|
||||
create_webfiles_css.output = webui/app.css
|
||||
create_webfiles_css.input = WEBUI_SRC_CSS
|
||||
create_webfiles_css.commands = sh $$_PRO_FILE_PWD_/webui-src/make-src/build.sh $$_PRO_FILE_PWD_ app.css .
|
||||
create_webfiles_css.variable_out = OBJECTS
|
||||
create_webfiles_css.CONFIG = combine no_link
|
||||
|
||||
|
||||
QMAKE_EXTRA_COMPILERS += create_webfiles_html create_webfiles_js create_webfiles_css
|
||||
}
|
||||
|
||||
win32{
|
||||
@ -44,9 +100,10 @@ win32{
|
||||
MAKE_SRC=$$PRO_PATH\\webui-src\\make-src
|
||||
}
|
||||
|
||||
create_webfiles.commands = $$MAKE_SRC\\build.bat $$PRO_PATH
|
||||
QMAKE_EXTRA_TARGETS += create_webfiles
|
||||
PRE_TARGETDEPS += create_webfiles
|
||||
#create_webfiles.commands = $$MAKE_SRC\\build.bat $$PRO_PATH
|
||||
#QMAKE_EXTRA_TARGETS += create_webfiles
|
||||
#PRE_TARGETDEPS += create_webfiles
|
||||
QMAKE_POST_LINK=$$MAKE_SRC\\build.bat $$PRO_PATH
|
||||
|
||||
# create dummy files
|
||||
system($$MAKE_SRC\\init.bat .)
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
|
||||
# create webfiles from sources at compile time (works without npm/node.js)
|
||||
|
||||
if [ "$1" = "" ];then
|
||||
if [ "$1" = "" ]; then
|
||||
publicdest=../../webui
|
||||
src=..
|
||||
else
|
||||
@ -10,19 +10,25 @@ else
|
||||
src=$1/webui-src
|
||||
fi
|
||||
|
||||
if [ -d "$publicdest" ]; then
|
||||
if [ "$2" = "" ]; then
|
||||
|
||||
if [ -d "$publicdest" ]; then
|
||||
echo remove existing $publicdest
|
||||
rm $publicdest -R
|
||||
fi
|
||||
fi
|
||||
|
||||
echo mkdir $publicdest
|
||||
mkdir $publicdest
|
||||
if [ ! -d "$publicdest" ]; then
|
||||
echo mkdir $publicdest
|
||||
mkdir $publicdest
|
||||
fi
|
||||
|
||||
echo building app.js
|
||||
echo - copy template.js ...
|
||||
cp $src/make-src/template.js $publicdest/app.js
|
||||
if [ "$2" = "" ]||[ "$2" = "app.js" ]; then
|
||||
echo building app.js
|
||||
echo - copy template.js ...
|
||||
cp $src/make-src/template.js $publicdest/app.js
|
||||
|
||||
for filename in $src/app/*.js; do
|
||||
for filename in $src/app/*.js; do
|
||||
fname=$(basename "$filename")
|
||||
fname="${fname%.*}"
|
||||
echo - adding $fname ...
|
||||
@ -30,14 +36,27 @@ for filename in $src/app/*.js; do
|
||||
cat $filename >> $publicdest/app.js
|
||||
echo >> $publicdest/app.js
|
||||
echo }\)\; >> $publicdest/app.js
|
||||
done
|
||||
done
|
||||
fi
|
||||
|
||||
echo building app.css
|
||||
cat $src/app/green-black.scss >> $publicdest/app.css
|
||||
cat $src/make-src/main.css >> $publicdest/app.css
|
||||
cat $src/make-src/chat.css >> $publicdest/app.css
|
||||
if [ "$2" = "" ]||[ "$2" = "app.css" ]; then
|
||||
echo building app.css
|
||||
cat $src/app/green-black.scss >> $publicdest/app.css
|
||||
cat $src/make-src/main.css >> $publicdest/app.css
|
||||
cat $src/make-src/chat.css >> $publicdest/app.css
|
||||
fi
|
||||
|
||||
echo copy index.html
|
||||
cp $src/app/assets/index.html $publicdest/index.html
|
||||
if [ "$2" = "" ]||[ "$2" = "index.html" ]; then
|
||||
echo copy index.html
|
||||
cp $src/app/assets/index.html $publicdest/index.html
|
||||
fi
|
||||
|
||||
if [ "$2" != "" ]&&[ "$3" != "" ]; then
|
||||
if [ ! -d "$3/webui" ]; then
|
||||
echo mkdir $3/webui
|
||||
mkdir $3/webui
|
||||
fi
|
||||
echo copy $2 nach $3/webui/$2
|
||||
cp $publicdest/$2 $3/webui/$2
|
||||
fi
|
||||
echo build.sh complete
|
||||
|
||||
@ -264,9 +264,12 @@ bool DistantChatService::initiateDistantChatConnexion(const RsGxsId& to_gxs_id,
|
||||
RsChatMsgItem *item = new RsChatMsgItem;
|
||||
item->message = "[Starting distant chat. Please wait for secure tunnel to be established]" ;
|
||||
item->chatFlags = RS_CHAT_FLAG_PRIVATE ;
|
||||
item->sendTime = time(NULL) ;
|
||||
item->PeerId(RsPeerId(tunnel_id)) ;
|
||||
handleRecvChatMsgItem(item) ;
|
||||
|
||||
delete item ; // item is replaced by NULL if partial, but this is not the case here.
|
||||
|
||||
return true ;
|
||||
}
|
||||
|
||||
|
||||
@ -63,7 +63,7 @@ public:
|
||||
|
||||
// derived in p3ChatService, so as to pass down some info
|
||||
virtual void handleIncomingItem(RsItem *) = 0;
|
||||
virtual bool handleRecvChatMsgItem(RsChatMsgItem *ci)=0 ;
|
||||
virtual bool handleRecvChatMsgItem(RsChatMsgItem *& ci)=0 ;
|
||||
|
||||
bool handleOutgoingItem(RsChatItem *) ;
|
||||
bool handleRecvItem(RsChatItem *) ;
|
||||
|
||||
@ -424,11 +424,6 @@ void DistributedChatService::checkSizeAndSendLobbyMessage(RsChatItem *msg)
|
||||
sendChatItem(msg) ;
|
||||
}
|
||||
|
||||
bool DistributedChatService::locked_checkAndRebuildPartialLobbyMessage(RsChatLobbyMsgItem *ci)
|
||||
{
|
||||
return true ;
|
||||
}
|
||||
|
||||
bool DistributedChatService::handleRecvItem(RsChatItem *item)
|
||||
{
|
||||
switch(item->PacketSubType())
|
||||
|
||||
@ -90,7 +90,6 @@ class DistributedChatService
|
||||
void addToSaveList(std::list<RsItem*>& list) const ;
|
||||
bool processLoadListItem(const RsItem *item) ;
|
||||
|
||||
bool locked_checkAndRebuildPartialLobbyMessage(RsChatLobbyMsgItem *) ;
|
||||
void checkSizeAndSendLobbyMessage(RsChatItem *) ;
|
||||
|
||||
bool sendLobbyChat(const ChatLobbyId &lobby_id, const std::string&) ;
|
||||
|
||||
@ -428,7 +428,14 @@ bool p3ChatService::sendChat(ChatId destination, std::string msg)
|
||||
return true;
|
||||
}
|
||||
|
||||
bool p3ChatService::locked_checkAndRebuildPartialMessage(RsChatMsgItem *ci)
|
||||
// This method might take control over the memory, or modify it, possibly adding missing parts.
|
||||
// This function looks weird because it cannot duplicate the message since it does not know
|
||||
// what type of object it is and the duplicate method of lobby messages is reserved for
|
||||
// ChatLobby bouncing objects.
|
||||
//
|
||||
// Returns false if the item shouldn't be used (and replaced to NULL)
|
||||
|
||||
bool p3ChatService::locked_checkAndRebuildPartialMessage(RsChatMsgItem *& ci)
|
||||
{
|
||||
// Check is the item is ending an incomplete item.
|
||||
//
|
||||
@ -446,12 +453,15 @@ bool p3ChatService::locked_checkAndRebuildPartialMessage(RsChatMsgItem *ci)
|
||||
ci->message = it->second->message + ci->message ;
|
||||
ci->chatFlags |= it->second->chatFlags ;
|
||||
|
||||
delete it->second ;
|
||||
// always remove existing partial. The compound message is in ci now.
|
||||
|
||||
if(!ci_is_incomplete)
|
||||
delete it->second ;
|
||||
_pendingPartialMessages.erase(it) ;
|
||||
}
|
||||
|
||||
// now decide what to do: if ci is incomplete, store it and replace the pointer with NULL
|
||||
// if complete, return it.
|
||||
|
||||
if(ci_is_incomplete)
|
||||
{
|
||||
#ifdef CHAT_DEBUG
|
||||
@ -459,7 +469,8 @@ bool p3ChatService::locked_checkAndRebuildPartialMessage(RsChatMsgItem *ci)
|
||||
#endif
|
||||
// The item is a partial message. Push it, and wait for the rest.
|
||||
//
|
||||
_pendingPartialMessages[ci->PeerId()] = ci ;
|
||||
_pendingPartialMessages[ci->PeerId()] = ci ; // cannot use duplicate() here
|
||||
ci = NULL ; // takes memory ownership over ci
|
||||
return false ;
|
||||
}
|
||||
else
|
||||
@ -504,7 +515,9 @@ void p3ChatService::handleIncomingItem(RsItem *item)
|
||||
RsChatMsgItem *ci = dynamic_cast<RsChatMsgItem*>(item) ;
|
||||
if(ci != NULL)
|
||||
{
|
||||
if(! handleRecvChatMsgItem(ci))
|
||||
handleRecvChatMsgItem(ci);
|
||||
|
||||
if(ci)
|
||||
delete ci ;
|
||||
|
||||
return ; // don't delete! It's handled by handleRecvChatMsgItem in some specific cases only.
|
||||
@ -665,7 +678,7 @@ bool p3ChatService::checkForMessageSecurity(RsChatMsgItem *ci)
|
||||
return true ;
|
||||
}
|
||||
|
||||
bool p3ChatService::handleRecvChatMsgItem(RsChatMsgItem *ci)
|
||||
bool p3ChatService::handleRecvChatMsgItem(RsChatMsgItem *& ci)
|
||||
{
|
||||
time_t now = time(NULL);
|
||||
std::string name;
|
||||
@ -674,15 +687,8 @@ bool p3ChatService::handleRecvChatMsgItem(RsChatMsgItem *ci)
|
||||
{
|
||||
RsStackMutex stack(mChatMtx); /********** STACK LOCKED MTX ******/
|
||||
|
||||
// This crap is because chat lobby messages use a different method for chunking messages using an additional
|
||||
// subpacket ID, and a list of lobbies. We cannot just collapse the two because it would make the normal chat
|
||||
// (and chat lobbies) not backward compatible.
|
||||
|
||||
if(!DistributedChatService::locked_checkAndRebuildPartialLobbyMessage(dynamic_cast<RsChatLobbyMsgItem*>(ci)))
|
||||
return true ;
|
||||
|
||||
if(!locked_checkAndRebuildPartialMessage(ci))
|
||||
return true ;
|
||||
if(!locked_checkAndRebuildPartialMessage(ci)) // we make sure this call does not take control over the memory
|
||||
return true ; // message is a subpart of an existing message. So everything ok, but we need to return.
|
||||
}
|
||||
|
||||
// Check for security. This avoids bombing messages, and so on.
|
||||
|
||||
@ -205,7 +205,8 @@ private:
|
||||
void receiveStateString(const RsPeerId& id,const std::string& s) ;
|
||||
|
||||
/// methods for handling various Chat items.
|
||||
bool handleRecvChatMsgItem(RsChatMsgItem *item) ; // returns false if the item should be deleted.
|
||||
virtual bool handleRecvChatMsgItem(RsChatMsgItem *&item) ; // NULL-ifies the item if memory ownership is taken
|
||||
|
||||
void handleRecvChatStatusItem(RsChatStatusItem *item) ;
|
||||
void handleRecvChatAvatarItem(RsChatAvatarItem *item) ;
|
||||
|
||||
@ -220,7 +221,8 @@ private:
|
||||
void checkSizeAndSendMessage(RsChatMsgItem *item) ; // keep for compatibility for a few weeks.
|
||||
|
||||
/// Called when a RsChatMsgItem is received. The item may be collapsed with any waiting partial chat item from the same peer.
|
||||
bool locked_checkAndRebuildPartialMessage(RsChatMsgItem *) ;
|
||||
/// if so, the chat item will be turned to NULL
|
||||
bool locked_checkAndRebuildPartialMessage(RsChatMsgItem *&) ;
|
||||
|
||||
RsChatAvatarItem *makeOwnAvatarItem() ;
|
||||
RsChatStatusItem *makeOwnCustomStateStringItem() ;
|
||||
|
||||
@ -613,7 +613,6 @@ RsGRouterAbstractMsgItem *GRouterDataInfo::addDataChunk(RsGRouterTransactionChun
|
||||
{
|
||||
RsItem *data_item = RsGRouterSerialiser().deserialise(incoming_data_buffer->chunk_data,&incoming_data_buffer->chunk_size) ;
|
||||
|
||||
incoming_data_buffer->chunk_data = NULL;
|
||||
delete incoming_data_buffer;
|
||||
incoming_data_buffer = NULL ;
|
||||
|
||||
|
||||
@ -225,20 +225,13 @@ private:
|
||||
void handleLowLevelTransactionAckItem(RsGRouterTransactionAcknItem*) ;
|
||||
|
||||
static Sha1CheckSum computeDataItemHash(RsGRouterGenericDataItem *data_item);
|
||||
#ifdef __APPLE__
|
||||
public:
|
||||
#endif
|
||||
class nullstream: public std::ostream {};
|
||||
|
||||
std::ostream& grouter_debug() const
|
||||
{
|
||||
static nullstream null ;
|
||||
|
||||
static std::ostream null(0);
|
||||
return _debug_enabled?(std::cerr):null;
|
||||
}
|
||||
#ifdef __APPLE__
|
||||
private:
|
||||
#endif
|
||||
|
||||
void routePendingObjects() ;
|
||||
void handleTunnels() ;
|
||||
void autoWash() ;
|
||||
@ -364,5 +357,3 @@ private:
|
||||
|
||||
uint64_t _random_salt ;
|
||||
};
|
||||
|
||||
template<typename T> p3GRouter::nullstream& operator<<(p3GRouter::nullstream& ns,const T&) { return ns ; }
|
||||
|
||||
@ -44,13 +44,12 @@ static RsGxsId getRsaKeyFingerprint(RSA *pubkey)
|
||||
int lenn = BN_num_bytes(pubkey -> n);
|
||||
int lene = BN_num_bytes(pubkey -> e);
|
||||
|
||||
unsigned char *tmp = new unsigned char[lenn+lene];
|
||||
RsTemporaryMemory tmp(lenn+lene) ;
|
||||
|
||||
BN_bn2bin(pubkey -> n, tmp);
|
||||
BN_bn2bin(pubkey -> e, &tmp[lenn]);
|
||||
|
||||
Sha1CheckSum s = RsDirUtil::sha1sum(tmp,lenn+lene) ;
|
||||
delete[] tmp ;
|
||||
|
||||
// Copy first CERTSIGNLEN bytes from the hash of the public modulus and exponent
|
||||
// We should not be using strings here, but a real ID. To be done later.
|
||||
@ -363,11 +362,21 @@ bool GxsSecurity::validateNxsMsg(const RsNxsMsg& msg, const RsTlvKeySignature& s
|
||||
RsGxsMessageId msgId = msgMeta.mMsgId, origMsgId = msgMeta.mOrigMsgId;
|
||||
msgMeta.mOrigMsgId.clear();
|
||||
msgMeta.mMsgId.clear();
|
||||
int signOk = 0 ;
|
||||
|
||||
{
|
||||
EVP_PKEY *signKey = EVP_PKEY_new();
|
||||
EVP_PKEY_assign_RSA(signKey, rsakey);
|
||||
EVP_MD_CTX *mdctx = EVP_MD_CTX_create();
|
||||
|
||||
uint32_t metaDataLen = msgMeta.serial_size();
|
||||
uint32_t allMsgDataLen = metaDataLen + msg.msg.bin_len;
|
||||
char* metaData = new char[metaDataLen];
|
||||
char* allMsgData = new char[allMsgDataLen]; // msgData + metaData
|
||||
|
||||
RsTemporaryMemory metaData(metaDataLen) ;
|
||||
RsTemporaryMemory allMsgData(allMsgDataLen) ;
|
||||
|
||||
if(!metaData || !allMsgData)
|
||||
return false ;
|
||||
|
||||
msgMeta.serialise(metaData, &metaDataLen);
|
||||
|
||||
@ -375,23 +384,17 @@ bool GxsSecurity::validateNxsMsg(const RsNxsMsg& msg, const RsTlvKeySignature& s
|
||||
memcpy(allMsgData, msg.msg.bin_data, msg.msg.bin_len);
|
||||
memcpy(allMsgData+(msg.msg.bin_len), metaData, metaDataLen);
|
||||
|
||||
delete[] metaData ;
|
||||
|
||||
EVP_PKEY *signKey = EVP_PKEY_new();
|
||||
EVP_PKEY_assign_RSA(signKey, rsakey);
|
||||
|
||||
/* calc and check signature */
|
||||
EVP_MD_CTX *mdctx = EVP_MD_CTX_create();
|
||||
|
||||
EVP_VerifyInit(mdctx, EVP_sha1());
|
||||
EVP_VerifyUpdate(mdctx, allMsgData, allMsgDataLen);
|
||||
int signOk = EVP_VerifyFinal(mdctx, sigbuf, siglen, signKey);
|
||||
|
||||
delete[] allMsgData ;
|
||||
signOk = EVP_VerifyFinal(mdctx, sigbuf, siglen, signKey);
|
||||
|
||||
/* clean up */
|
||||
EVP_PKEY_free(signKey);
|
||||
EVP_MD_CTX_destroy(mdctx);
|
||||
}
|
||||
|
||||
msgMeta.mOrigMsgId = origMsgId;
|
||||
msgMeta.mMsgId = msgId;
|
||||
@ -425,6 +428,8 @@ bool GxsSecurity::encrypt(uint8_t *& out, uint32_t &outlen, const uint8_t *in, u
|
||||
// [--- Encrypted session key length ---|--- Encrypted session key ---|--- IV ---|---- Encrypted data ---]
|
||||
//
|
||||
|
||||
out = NULL ;
|
||||
|
||||
RSA *tmpkey = ::extractPublicKey(key) ;
|
||||
RSA *rsa_publish_pub = RSAPublicKey_dup(tmpkey) ;
|
||||
RSA_free(tmpkey) ;
|
||||
@ -521,6 +526,8 @@ bool GxsSecurity::encrypt(uint8_t *& out, uint32_t &outlen, const uint8_t *in, u
|
||||
// free encrypted key data
|
||||
free(ek);
|
||||
|
||||
EVP_CIPHER_CTX_cleanup(&ctx);
|
||||
|
||||
outlen = out_offset;
|
||||
return true;
|
||||
}
|
||||
@ -538,11 +545,12 @@ bool GxsSecurity::encrypt(uint8_t *& out, uint32_t &outlen, const uint8_t *in, u
|
||||
//
|
||||
|
||||
out = NULL ;
|
||||
EVP_CIPHER_CTX ctx;
|
||||
EVP_CIPHER_CTX_init(&ctx);
|
||||
std::vector<EVP_PKEY *> public_keys(keys.size(),NULL);
|
||||
|
||||
try
|
||||
{
|
||||
std::vector<EVP_PKEY *> public_keys(keys.size(),NULL);
|
||||
|
||||
for(uint32_t i=0;i<keys.size();++i)
|
||||
{
|
||||
RSA *tmpkey = ::extractPublicKey(keys[i]) ;
|
||||
@ -561,9 +569,7 @@ bool GxsSecurity::encrypt(uint8_t *& out, uint32_t &outlen, const uint8_t *in, u
|
||||
}
|
||||
}
|
||||
|
||||
EVP_CIPHER_CTX ctx;
|
||||
unsigned char iv[EVP_MAX_IV_LENGTH];
|
||||
EVP_CIPHER_CTX_init(&ctx);
|
||||
|
||||
std::vector<unsigned char *> ek(keys.size(),NULL) ;
|
||||
std::vector<int> eklen(keys.size(),0) ;
|
||||
@ -587,6 +593,11 @@ bool GxsSecurity::encrypt(uint8_t *& out, uint32_t &outlen, const uint8_t *in, u
|
||||
if(!EVP_SealInit(&ctx, EVP_aes_128_cbc(), ek.data(), eklen.data(), iv, public_keys.data(), keys.size()))
|
||||
return false;
|
||||
|
||||
// now we can release the encryption keys
|
||||
for(uint32_t i=0;i<public_keys.size();++i)
|
||||
EVP_PKEY_free(public_keys[i]) ;
|
||||
public_keys.clear() ;
|
||||
|
||||
int total_ek_size = MULTI_ENCRYPTION_FORMAT_v001_ENCRYPTED_KEY_SIZE * keys.size() ;
|
||||
|
||||
int max_outlen = MULTI_ENCRYPTION_FORMAT_v001_HEADER_SIZE + MULTI_ENCRYPTION_FORMAT_v001_NUMBER_OF_KEYS_SIZE + total_ek_size + EVP_MAX_IV_LENGTH + (inlen + cipher_block_size) ;
|
||||
@ -653,15 +664,23 @@ bool GxsSecurity::encrypt(uint8_t *& out, uint32_t &outlen, const uint8_t *in, u
|
||||
if(ek[i]) free(ek[i]);
|
||||
|
||||
outlen = out_offset;
|
||||
|
||||
EVP_CIPHER_CTX_cleanup(&ctx);
|
||||
return true;
|
||||
}
|
||||
catch(std::exception& e)
|
||||
{
|
||||
std::cerr << "(EE) Exception caught while encrypting: " << e.what() << std::endl;
|
||||
|
||||
EVP_CIPHER_CTX_cleanup(&ctx);
|
||||
|
||||
if(out) free(out) ;
|
||||
out = NULL ;
|
||||
|
||||
for(uint32_t i=0;i<public_keys.size();++i)
|
||||
EVP_PKEY_free(public_keys[i]) ;
|
||||
public_keys.clear() ;
|
||||
|
||||
return false ;
|
||||
}
|
||||
}
|
||||
@ -675,6 +694,7 @@ bool GxsSecurity::decrypt(uint8_t *& out, uint32_t & outlen, const uint8_t *in,
|
||||
//
|
||||
// This method can be used to decrypt multi-encrypted data, if passing he correct encrypted key block (corresponding to the given key)
|
||||
|
||||
out = NULL ;
|
||||
#ifdef GXS_SECURITY_DEBUG
|
||||
std::cerr << "GxsSecurity::decrypt() " << std::endl;
|
||||
#endif
|
||||
@ -767,6 +787,7 @@ bool GxsSecurity::decrypt(uint8_t *& out, uint32_t & outlen, const uint8_t *in,
|
||||
outlen += out_currOffset;
|
||||
free(ek);
|
||||
|
||||
EVP_CIPHER_CTX_cleanup(&ctx);
|
||||
return true;
|
||||
}
|
||||
|
||||
@ -783,9 +804,13 @@ bool GxsSecurity::decrypt(uint8_t *& out, uint32_t & outlen, const uint8_t *in,
|
||||
#ifdef DISTRIB_DEBUG
|
||||
std::cerr << "GxsSecurity::decrypt() " << std::endl;
|
||||
#endif
|
||||
EVP_CIPHER_CTX ctx;
|
||||
EVP_CIPHER_CTX_init(&ctx);
|
||||
|
||||
try
|
||||
{
|
||||
out = NULL ;
|
||||
|
||||
// check that the input block has a valid format.
|
||||
|
||||
uint32_t offset = 0 ;
|
||||
@ -826,8 +851,6 @@ bool GxsSecurity::decrypt(uint8_t *& out, uint32_t & outlen, const uint8_t *in,
|
||||
|
||||
// decrypt
|
||||
|
||||
EVP_CIPHER_CTX ctx;
|
||||
EVP_CIPHER_CTX_init(&ctx);
|
||||
bool succeed = false;
|
||||
|
||||
for(uint32_t j=0;j<keys.size() && !succeed;++j)
|
||||
@ -855,6 +878,9 @@ bool GxsSecurity::decrypt(uint8_t *& out, uint32_t & outlen, const uint8_t *in,
|
||||
{
|
||||
succeed = EVP_OpenInit(&ctx, EVP_aes_128_cbc(),in + encrypted_keys_offset + i*MULTI_ENCRYPTION_FORMAT_v001_ENCRYPTED_KEY_SIZE , MULTI_ENCRYPTION_FORMAT_v001_ENCRYPTED_KEY_SIZE, in+IV_offset, privateKey);
|
||||
|
||||
if(!succeed)
|
||||
EVP_CIPHER_CTX_cleanup(&ctx);
|
||||
|
||||
#ifdef GXS_SECURITY_DEBUG
|
||||
std::cerr << " encrypted key at offset " << encrypted_keys_offset + i*MULTI_ENCRYPTION_FORMAT_v001_ENCRYPTED_KEY_SIZE << ": " << succeed << std::endl;
|
||||
#endif
|
||||
@ -890,6 +916,7 @@ bool GxsSecurity::decrypt(uint8_t *& out, uint32_t & outlen, const uint8_t *in,
|
||||
#ifdef GXS_SECURITY_DEBUG
|
||||
std::cerr << " successfully decrypted block of size " << outlen << std::endl;
|
||||
#endif
|
||||
EVP_CIPHER_CTX_cleanup(&ctx);
|
||||
return true;
|
||||
}
|
||||
catch(std::exception& e)
|
||||
@ -905,6 +932,7 @@ bool GxsSecurity::decrypt(uint8_t *& out, uint32_t & outlen, const uint8_t *in,
|
||||
out = NULL ;
|
||||
}
|
||||
|
||||
EVP_CIPHER_CTX_cleanup(&ctx);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
@ -61,7 +61,7 @@ static const uint32_t INDEX_AUTHEN_ADMIN = 0x00000040; // admin key
|
||||
|
||||
#define GXS_MASK "GXS_MASK_HACK"
|
||||
|
||||
#define GEN_EXCH_DEBUG 1
|
||||
//#define GEN_EXCH_DEBUG 1
|
||||
|
||||
#define MSG_CLEANUP_PERIOD 60*5 // 5 minutes
|
||||
#define INTEGRITY_CHECK_PERIOD 60*30 // 30 minutes
|
||||
|
||||
@ -1626,8 +1626,10 @@ void RsGxsNetService::recvNxsItemQueue()
|
||||
GXSNETDEBUG_P_(item->PeerId()) << " decrypted item " << std::endl;
|
||||
#endif
|
||||
}
|
||||
#ifdef NXS_NET_DEBUG_7
|
||||
else
|
||||
std::cerr << "(EE) Could not decrypt incoming encrypted NXS item. Probably a friend subscribed to a circle-restricted group." << std::endl;
|
||||
GXSNETDEBUG_P_(item->PeerId()) << " (EE) Could not decrypt incoming encrypted NXS item. Probably a friend subscribed to a circle-restricted group." << std::endl;
|
||||
#endif
|
||||
}
|
||||
|
||||
switch(ni->PacketSubType())
|
||||
@ -1638,6 +1640,7 @@ void RsGxsNetService::recvNxsItemQueue()
|
||||
case RS_PKT_SUBTYPE_NXS_GRP_PUBLISH_KEY_ITEM:handleRecvPublishKeys (dynamic_cast<RsNxsGroupPublishKeyItem*>(ni)) ; break ;
|
||||
|
||||
default:
|
||||
if(ni->PacketSubType() != RS_PKT_SUBTYPE_NXS_ENCRYPTED_DATA_ITEM)
|
||||
std::cerr << "Unhandled item subtype " << (uint32_t) ni->PacketSubType() << " in RsGxsNetService: " << std::endl; break;
|
||||
}
|
||||
delete item ;
|
||||
@ -3861,7 +3864,9 @@ bool RsGxsNetService::decryptSingleNxsItem(const RsNxsEncryptedDataItem *encrypt
|
||||
|
||||
if(!GxsSecurity::decrypt(decrypted_mem,decrypted_len, (uint8_t*)encrypted_item->encrypted_data.bin_data,encrypted_item->encrypted_data.bin_len,private_keys))
|
||||
{
|
||||
std::cerr << "Failed! Cannot decrypt this item." << std::endl;
|
||||
#ifdef NXS_NET_DEBUG_7
|
||||
GXSNETDEBUG_P_(encrypted_item->PeerId()) << " Failed! Cannot decrypt this item." << std::endl;
|
||||
#endif
|
||||
decrypted_mem = NULL ; // for safety
|
||||
return false ;
|
||||
}
|
||||
@ -3876,6 +3881,7 @@ bool RsGxsNetService::decryptSingleNxsItem(const RsNxsEncryptedDataItem *encrypt
|
||||
if(decrypted_mem!=NULL)
|
||||
{
|
||||
ditem = RsNxsSerialiser(mServType).deserialise(decrypted_mem,&decrypted_len) ;
|
||||
free(decrypted_mem) ;
|
||||
|
||||
if(ditem != NULL)
|
||||
{
|
||||
|
||||
@ -153,7 +153,7 @@ int pqiperson::tick()
|
||||
#endif
|
||||
|
||||
//if lastHeartbeatReceived is 0, it might be not activated so don't do a net reset.
|
||||
if ( active && time(NULL) > lastHeartbeatReceived + HEARTBEAT_REPEAT_TIME * 5)
|
||||
if ( active && time(NULL) > lastHeartbeatReceived + HEARTBEAT_REPEAT_TIME * 20)
|
||||
{
|
||||
int ageLastIncoming = time(NULL) - activepqi->getLastIncomingTS();
|
||||
|
||||
|
||||
@ -6,6 +6,8 @@
|
||||
|
||||
#include "pqiqos.h"
|
||||
|
||||
const uint32_t pqiQoS::MAX_PACKET_COUNTER_VALUE = (1 << 24) ;
|
||||
|
||||
pqiQoS::pqiQoS(uint32_t nb_levels,float alpha)
|
||||
: _item_queues(nb_levels),_alpha(alpha)
|
||||
{
|
||||
@ -14,6 +16,7 @@ pqiQoS::pqiQoS(uint32_t nb_levels,float alpha)
|
||||
float c = 1.0f ;
|
||||
float inc = alpha ;
|
||||
_nb_items = 0 ;
|
||||
_id_counter = 0 ;
|
||||
|
||||
for(int i=((int)nb_levels)-1;i>=0;--i,c *= alpha)
|
||||
{
|
||||
@ -44,7 +47,7 @@ void pqiQoS::print() const
|
||||
std::cerr << std::endl;
|
||||
}
|
||||
|
||||
void pqiQoS::in_rsItem(void *ptr,int priority)
|
||||
void pqiQoS::in_rsItem(void *ptr,int size,int priority)
|
||||
{
|
||||
if(uint32_t(priority) >= _item_queues.size())
|
||||
{
|
||||
@ -52,8 +55,11 @@ void pqiQoS::in_rsItem(void *ptr,int priority)
|
||||
priority = _item_queues.size()-1 ;
|
||||
}
|
||||
|
||||
_item_queues[priority].push(ptr) ;
|
||||
_item_queues[priority].push(ptr,size,_id_counter++) ;
|
||||
++_nb_items ;
|
||||
|
||||
if(_id_counter >= MAX_PACKET_COUNTER_VALUE)
|
||||
_id_counter = 0 ;
|
||||
}
|
||||
|
||||
// int pqiQoS::gatherStatistics(std::vector<uint32_t>& per_service_count,std::vector<uint32_t>& per_priority_count) const
|
||||
@ -80,7 +86,7 @@ void pqiQoS::in_rsItem(void *ptr,int priority)
|
||||
// }
|
||||
|
||||
|
||||
void *pqiQoS::out_rsItem()
|
||||
void *pqiQoS::out_rsItem(uint32_t max_slice_size, uint32_t& size, bool& starts, bool& ends, uint32_t& packet_id)
|
||||
{
|
||||
// Go through the queues. Increment counters.
|
||||
|
||||
@ -105,11 +111,21 @@ void *pqiQoS::out_rsItem()
|
||||
if(last >= 0)
|
||||
{
|
||||
assert(_nb_items > 0) ;
|
||||
|
||||
// now chop a slice of this item
|
||||
|
||||
void *res = _item_queues[last].slice(max_slice_size,size,starts,ends,packet_id) ;
|
||||
|
||||
if(ends)
|
||||
--_nb_items ;
|
||||
return _item_queues[last].pop();
|
||||
|
||||
return res ;
|
||||
}
|
||||
else
|
||||
return NULL ;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@ -36,14 +36,26 @@
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <iostream>
|
||||
#include <vector>
|
||||
#include <list>
|
||||
|
||||
#include <util/rsmemory.h>
|
||||
|
||||
class pqiQoS
|
||||
{
|
||||
public:
|
||||
public:
|
||||
pqiQoS(uint32_t max_levels,float alpha) ;
|
||||
|
||||
struct ItemRecord
|
||||
{
|
||||
void *data ;
|
||||
uint32_t current_offset ;
|
||||
uint32_t size ;
|
||||
uint32_t id ;
|
||||
};
|
||||
|
||||
class ItemQueue
|
||||
{
|
||||
public:
|
||||
@ -56,17 +68,74 @@ class pqiQoS
|
||||
if(_items.empty())
|
||||
return NULL ;
|
||||
|
||||
void *item = _items.front() ;
|
||||
void *item = _items.front().data ;
|
||||
_items.pop_front() ;
|
||||
--_item_count ;
|
||||
|
||||
return item ;
|
||||
}
|
||||
|
||||
void push(void *item)
|
||||
void *slice(uint32_t max_size,uint32_t& size,bool& starts,bool& ends,uint32_t& packet_id)
|
||||
{
|
||||
_items.push_back(item) ;
|
||||
++_item_count ;
|
||||
if(_items.empty())
|
||||
return NULL ;
|
||||
|
||||
ItemRecord& rec(_items.front()) ;
|
||||
packet_id = rec.id ;
|
||||
|
||||
// readily get rid of the item if it can be sent as a whole
|
||||
|
||||
if(rec.current_offset == 0 && rec.size < max_size)
|
||||
{
|
||||
starts = true ;
|
||||
ends = true ;
|
||||
size = rec.size ;
|
||||
|
||||
return pop() ;
|
||||
}
|
||||
starts = (rec.current_offset == 0) ;
|
||||
ends = (rec.current_offset + max_size >= rec.size) ;
|
||||
|
||||
if(rec.size <= rec.current_offset)
|
||||
{
|
||||
std::cerr << "(EE) severe error in slicing in QoS." << std::endl;
|
||||
pop() ;
|
||||
return NULL ;
|
||||
}
|
||||
|
||||
size = std::min(max_size, uint32_t((int)rec.size - (int)rec.current_offset)) ;
|
||||
void *mem = rs_malloc(size) ;
|
||||
|
||||
if(!mem)
|
||||
{
|
||||
std::cerr << "(EE) memory allocation error in QoS." << std::endl;
|
||||
pop() ;
|
||||
return NULL ;
|
||||
}
|
||||
|
||||
memcpy(mem,&((unsigned char*)rec.data)[rec.current_offset],size) ;
|
||||
|
||||
if(ends) // we're taking the whole stuff. So we can delete the entry.
|
||||
{
|
||||
free(rec.data) ;
|
||||
_items.pop_front() ;
|
||||
}
|
||||
else
|
||||
rec.current_offset += size ; // by construction, !ends implies rec.current_offset < rec.size
|
||||
|
||||
return mem ;
|
||||
}
|
||||
|
||||
void push(void *item,uint32_t size,uint32_t id)
|
||||
{
|
||||
ItemRecord rec ;
|
||||
|
||||
rec.data = item ;
|
||||
rec.current_offset = 0 ;
|
||||
rec.size = size ;
|
||||
rec.id = id ;
|
||||
|
||||
_items.push_back(rec) ;
|
||||
}
|
||||
|
||||
uint32_t size() const { return _item_count ; }
|
||||
@ -75,16 +144,17 @@ class pqiQoS
|
||||
float _counter ;
|
||||
float _inc ;
|
||||
uint32_t _item_count ;
|
||||
std::list<void*> _items ;
|
||||
|
||||
std::list<ItemRecord> _items ;
|
||||
};
|
||||
|
||||
// This function pops items from the queue, y order of priority
|
||||
//
|
||||
void *out_rsItem() ;
|
||||
void *out_rsItem(uint32_t max_slice_size,uint32_t& size,bool& starts,bool& ends,uint32_t& packet_id) ;
|
||||
|
||||
// This function is used to queue items.
|
||||
//
|
||||
void in_rsItem(void *item,int priority) ;
|
||||
void in_rsItem(void *item, int size, int priority) ;
|
||||
|
||||
void print() const ;
|
||||
uint64_t qos_queue_size() const { return _nb_items ; }
|
||||
@ -99,12 +169,15 @@ class pqiQoS
|
||||
|
||||
void computeTotalItemSize() const ;
|
||||
int debug_computeTotalItemSize() const ;
|
||||
private:
|
||||
private:
|
||||
// This vector stores the lists of items with equal priorities.
|
||||
//
|
||||
std::vector<ItemQueue> _item_queues ;
|
||||
float _alpha ;
|
||||
uint64_t _nb_items ;
|
||||
uint32_t _id_counter ;
|
||||
|
||||
static const uint32_t MAX_PACKET_COUNTER_VALUE ;
|
||||
};
|
||||
|
||||
|
||||
|
||||
@ -50,12 +50,12 @@ int pqiQoSstreamer::getQueueSize(bool in)
|
||||
// return pqiQoS::gatherStatistics(per_service_count,per_priority_count) ;
|
||||
//}
|
||||
|
||||
void pqiQoSstreamer::locked_storeInOutputQueue(void *ptr,int priority)
|
||||
void pqiQoSstreamer::locked_storeInOutputQueue(void *ptr,int size,int priority)
|
||||
{
|
||||
_total_item_size += getRsItemSize(ptr) ;
|
||||
_total_item_size += size ;
|
||||
++_total_item_count ;
|
||||
|
||||
pqiQoS::in_rsItem(ptr,priority) ;
|
||||
pqiQoS::in_rsItem(ptr,size,priority) ;
|
||||
}
|
||||
|
||||
void pqiQoSstreamer::locked_clear_out_queue()
|
||||
@ -65,13 +65,15 @@ void pqiQoSstreamer::locked_clear_out_queue()
|
||||
_total_item_count = 0 ;
|
||||
}
|
||||
|
||||
void *pqiQoSstreamer::locked_pop_out_data()
|
||||
void *pqiQoSstreamer::locked_pop_out_data(uint32_t max_slice_size, uint32_t& size, bool& starts, bool& ends, uint32_t& packet_id)
|
||||
{
|
||||
void *out = pqiQoS::out_rsItem() ;
|
||||
void *out = pqiQoS::out_rsItem(max_slice_size,size,starts,ends,packet_id) ;
|
||||
|
||||
if(out != NULL)
|
||||
{
|
||||
_total_item_size -= getRsItemSize(out) ;
|
||||
|
||||
if(ends)
|
||||
--_total_item_count ;
|
||||
}
|
||||
|
||||
|
||||
@ -36,11 +36,11 @@ class pqiQoSstreamer: public pqithreadstreamer, public pqiQoS
|
||||
static const uint32_t PQI_QOS_STREAMER_MAX_LEVELS = 10 ;
|
||||
static const float PQI_QOS_STREAMER_ALPHA ;
|
||||
|
||||
virtual void locked_storeInOutputQueue(void *ptr,int priority) ;
|
||||
virtual void locked_storeInOutputQueue(void *ptr, int size, int priority) ;
|
||||
virtual int locked_out_queue_size() const { return _total_item_count ; }
|
||||
virtual void locked_clear_out_queue() ;
|
||||
virtual int locked_compute_out_pkt_size() const { return _total_item_size ; }
|
||||
virtual void *locked_pop_out_data() ;
|
||||
virtual void *locked_pop_out_data(uint32_t max_slice_size,uint32_t& size,bool& starts,bool& ends,uint32_t& packet_id);
|
||||
//virtual int locked_gatherStatistics(std::vector<uint32_t>& per_service_count,std::vector<uint32_t>& per_priority_count) const; // extracting data.
|
||||
|
||||
|
||||
|
||||
@ -1074,6 +1074,12 @@ int pqissl::Initiate_SSL_Connection()
|
||||
"pqissl::Initiate_SSL_Connection() SSL Connection Okay");
|
||||
#endif
|
||||
|
||||
if(ssl_connection != NULL)
|
||||
{
|
||||
SSL_shutdown(ssl_connection);
|
||||
SSL_free(ssl_connection) ;
|
||||
}
|
||||
|
||||
ssl_connection = ssl;
|
||||
|
||||
net_internal_SSL_set_fd(ssl, sockfd);
|
||||
@ -1851,6 +1857,10 @@ bool pqissl::moretoread(uint32_t usec)
|
||||
#endif
|
||||
return 1;
|
||||
}
|
||||
else if(SSL_pending(ssl_connection) > 0)
|
||||
{
|
||||
return 1 ;
|
||||
}
|
||||
else
|
||||
{
|
||||
#ifdef PQISSL_DEBUG
|
||||
|
||||
@ -30,6 +30,7 @@
|
||||
#include "util/rsdebug.h"
|
||||
#include "util/rsstring.h"
|
||||
#include "util/rsprint.h"
|
||||
#include "util/rsscopetimer.h"
|
||||
|
||||
#include "pqi/pqistreamer.h"
|
||||
#include "rsserver/p3face.h"
|
||||
@ -41,12 +42,26 @@ const int pqistreamerzone = 8221;
|
||||
static const int PQISTREAM_ABS_MAX = 100000000; /* 100 MB/sec (actually per loop) */
|
||||
static const int PQISTREAM_AVG_PERIOD = 5; // update speed estimate every 5 seconds
|
||||
static const float PQISTREAM_AVG_FRAC = 0.8; // for bandpass filter over speed estimate.
|
||||
static const int PQISTREAM_OPTIMAL_PACKET_SIZE = 512; // It is believed that this value should be lower than TCP slices and large enough as compare to encryption padding.
|
||||
// most importantly, it should be constant, so as to allow correct QoS.
|
||||
static const int PQISTREAM_SLICE_FLAG_STARTS = 0x01; //
|
||||
static const int PQISTREAM_SLICE_FLAG_ENDS = 0x02; // these flags should be kept in the range 0x01-0x08
|
||||
static const int PQISTREAM_SLICE_PROTOCOL_VERSION_ID_01 = 0x10; // Protocol version ID. Should hold on the 4 lower bits.
|
||||
static const int PQISTREAM_PARTIAL_PACKET_HEADER_SIZE = 8; // Same size than normal header, to make the code simpler.
|
||||
static const int PQISTREAM_PACKET_SLICING_PROBE_DELAY = 60; // send every 60 secs.
|
||||
|
||||
// This is a probe packet, that won't deserialise (it's empty) but will not cause problems to old peers either, since they will ignore
|
||||
// it. This packet however will be understood by new peers as a signal to enable packet slicing. This should go when all peers use the
|
||||
// same protocol.
|
||||
|
||||
static uint8_t PACKET_SLICING_PROBE_BYTES[8] = { 0x02, 0xaa, 0xbb, 0xcc, 0x00, 0x00, 0x00, 0x08 } ;
|
||||
|
||||
/* This removes the print statements (which hammer pqidebug) */
|
||||
/***
|
||||
#define RSITEM_DEBUG 1
|
||||
#define DEBUG_TRANSFERS 1
|
||||
#define DEBUG_PQISTREAMER 1
|
||||
#define DEBUG_PACKET_SLICING 1
|
||||
***/
|
||||
|
||||
#ifdef DEBUG_TRANSFERS
|
||||
@ -64,6 +79,9 @@ pqistreamer::pqistreamer(RsSerialiser *rss, const RsPeerId& id, BinInterface *bi
|
||||
{
|
||||
RsStackMutex stack(mStreamerMtx); /**** LOCKED MUTEX ****/
|
||||
|
||||
mAcceptsPacketSlicing = false ; // by default. Will be turned into true when everyone's ready.
|
||||
mLastSentPacketSlicingProbe = 0 ;
|
||||
|
||||
mAvgLastUpdate = mCurrReadTS = mCurrSentTS = time(NULL);
|
||||
mIncomingSize = 0 ;
|
||||
|
||||
@ -95,7 +113,9 @@ pqistreamer::pqistreamer(RsSerialiser *rss, const RsPeerId& id, BinInterface *bi
|
||||
pqistreamer::~pqistreamer()
|
||||
{
|
||||
RsStackMutex stack(mStreamerMtx); /**** LOCKED MUTEX ****/
|
||||
|
||||
#ifdef DEBUG_PQISTREAMER
|
||||
std::cerr << "Closing pqistreamer." << std::endl;
|
||||
#endif
|
||||
pqioutput(PQL_DEBUG_ALL, pqistreamerzone, "pqistreamer::~pqistreamer() Destruction!");
|
||||
|
||||
if (mBio_flags & BIN_FLAGS_NO_CLOSE)
|
||||
@ -185,7 +205,7 @@ void pqistreamer::updateRates()
|
||||
{
|
||||
int64_t diff = int64_t(t) - int64_t(mAvgLastUpdate) ;
|
||||
|
||||
float avgReadpSec = getRate(true) * PQISTREAM_AVG_FRAC + (1.0 - PQISTREAM_AVG_FRAC) * mAvgReadCount/(1000.0 * float(diff));
|
||||
float avgReadpSec = getRate(true ) * PQISTREAM_AVG_FRAC + (1.0 - PQISTREAM_AVG_FRAC) * mAvgReadCount/(1000.0 * float(diff));
|
||||
float avgSentpSec = getRate(false) * PQISTREAM_AVG_FRAC + (1.0 - PQISTREAM_AVG_FRAC) * mAvgSentCount/(1000.0 * float(diff));
|
||||
|
||||
#ifdef DEBUG_PQISTREAMER
|
||||
@ -256,6 +276,7 @@ int pqistreamer::tick_send(uint32_t timeout)
|
||||
{
|
||||
handleoutgoing_locked();
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
@ -278,7 +299,7 @@ int pqistreamer::status()
|
||||
return 0;
|
||||
}
|
||||
|
||||
void pqistreamer::locked_storeInOutputQueue(void *ptr,int)
|
||||
void pqistreamer::locked_storeInOutputQueue(void *ptr,int,int)
|
||||
{
|
||||
mOutPkts.push_back(ptr);
|
||||
}
|
||||
@ -316,7 +337,7 @@ int pqistreamer::queue_outpqi_locked(RsItem *pqi,uint32_t& pktsize)
|
||||
|
||||
if (mRsSerialiser->serialise(pqi, ptr, &pktsize))
|
||||
{
|
||||
locked_storeInOutputQueue(ptr,pqi->priority_level()) ;
|
||||
locked_storeInOutputQueue(ptr,pktsize,pqi->priority_level()) ;
|
||||
|
||||
if (!(mBio_flags & BIN_FLAGS_NO_DELETE))
|
||||
{
|
||||
@ -399,6 +420,33 @@ time_t pqistreamer::getLastIncomingTS()
|
||||
return mLastIncomingTs;
|
||||
}
|
||||
|
||||
// Packet slicing:
|
||||
//
|
||||
// Old : 02 0014 03 00000026 [data, 26 bytes] => [version 1B] [service 2B][subpacket 1B] [size 4B]
|
||||
// New2: pp ff xxxxxxxx ssss [data, sss bytes] => [protocol version 1B] [flags 1B] [2^32 packet count] [2^16 size]
|
||||
//
|
||||
// Encode protocol on 1.0 Bytes ( 8 bits)
|
||||
// Encode flags on 1.0 Bytes ( 8 bits)
|
||||
// 0x01 => incomplete packet continued after
|
||||
// 0x02 => packet ending a previously incomplete packet
|
||||
//
|
||||
// Encode packet ID on 4.0 Bytes (32 bits) => packet counter = [0...2^32]
|
||||
// Encode size on 2.0 Bytes (16 bits) => 65536 // max slice size = 65536
|
||||
//
|
||||
// Backward compatibility:
|
||||
// * send one packet with service + subpacket = aabbcc. Old peers will silently ignore such packets. Full packet header is: 02aabbcc 00000008
|
||||
// * if received, mark the peer as able to decode the new packet type
|
||||
// In pqiQoS:
|
||||
// - limit packet grouping to max size 512.
|
||||
// - new peers need to read flux, and properly extract partial sizes, and combine packets based on packet counter.
|
||||
// - on sending, RS grabs slices of max size 1024 from pqiQoS. If smaller, possibly pack them together.
|
||||
// pqiQoS keeps track of sliced packets and makes sure the output is consistent:
|
||||
// * when a large packet needs to be send, only takes a slice and return it, and update the remaining part
|
||||
// * always consider priority when taking new slices => a newly arrived fast packet will always get through.
|
||||
//
|
||||
// Max slice size should be customisable, depending on bandwidth. To be tested...
|
||||
//
|
||||
|
||||
int pqistreamer::handleoutgoing_locked()
|
||||
{
|
||||
#ifdef DEBUG_PQISTREAMER
|
||||
@ -417,6 +465,10 @@ int pqistreamer::handleoutgoing_locked()
|
||||
{
|
||||
/* if we are not active - clear anything in the queues. */
|
||||
locked_clear_out_queue() ;
|
||||
#ifdef DEBUG_PACKET_SLICING
|
||||
std::cerr << "(II) Switching off packet slicing." << std::endl;
|
||||
#endif
|
||||
mAcceptsPacketSlicing = false ;
|
||||
|
||||
/* also remove the pending packets */
|
||||
if (mPkt_wpending)
|
||||
@ -440,57 +492,111 @@ int pqistreamer::handleoutgoing_locked()
|
||||
if ((!(mBio->cansend(0))) || (maxbytes < sentbytes))
|
||||
{
|
||||
|
||||
#ifdef DEBUG_TRANSFERS
|
||||
#ifdef DEBUG_PACKET_SLICING
|
||||
if (maxbytes < sentbytes)
|
||||
{
|
||||
std::cerr << "pqistreamer::handleoutgoing_locked() Stopped sending sentbytes > maxbytes. Sent " << sentbytes << " bytes ";
|
||||
std::cerr << std::endl;
|
||||
}
|
||||
std::cerr << "pqistreamer::handleoutgoing_locked() Stopped sending: bio not ready. maxbytes=" << maxbytes << ", sentbytes=" << sentbytes << std::endl;
|
||||
else
|
||||
{
|
||||
std::cerr << "pqistreamer::handleoutgoing_locked() Stopped sending at cansend() is false";
|
||||
std::cerr << std::endl;
|
||||
}
|
||||
std::cerr << "pqistreamer::handleoutgoing_locked() Stopped sending: sentbytes=" << sentbytes << ", max=" << maxbytes << std::endl;
|
||||
#endif
|
||||
|
||||
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.
|
||||
// send a out_pkt., else send out_data. unless there is a pending packet. The strategy is to
|
||||
// - grab as many packets as possible while below the optimal packet size, so as to allow some packing and decrease encryption padding overhead (suposeddly)
|
||||
// - limit packets size to OPTIMAL_PACKET_SIZE when sending big packets so as to keep as much QoS as possible.
|
||||
|
||||
if (!mPkt_wpending)
|
||||
#ifdef GROUP_OUTGOING_PACKETS
|
||||
{
|
||||
void *dta;
|
||||
mPkt_wpending_size = 0 ;
|
||||
int k=0;
|
||||
|
||||
while(mPkt_wpending_size < (uint32_t)maxbytes && mPkt_wpending_size < PACKET_GROUPING_SIZE_LIMIT && (dta = locked_pop_out_data())!=NULL )
|
||||
// Checks for inserting a packet slicing probe. We do that to send the other peer the information that packet slicing can be used.
|
||||
// if so, we enable it for the session. This should be removed (because it's unnecessary) when all users have switched to the new version.
|
||||
time_t now = time(NULL) ;
|
||||
|
||||
if((!mAcceptsPacketSlicing) && now > mLastSentPacketSlicingProbe + PQISTREAM_PACKET_SLICING_PROBE_DELAY)
|
||||
{
|
||||
uint32_t s = getRsItemSize(dta);
|
||||
mPkt_wpending = realloc(mPkt_wpending,s+mPkt_wpending_size) ;
|
||||
memcpy( &((char*)mPkt_wpending)[mPkt_wpending_size],dta,s) ;
|
||||
#ifdef DEBUG_PACKET_SLICING
|
||||
std::cerr << "(II) Inserting packet slicing probe in traffic" << std::endl;
|
||||
#endif
|
||||
|
||||
mPkt_wpending_size = 8 ;
|
||||
mPkt_wpending = rs_malloc(8) ;
|
||||
memcpy(mPkt_wpending,PACKET_SLICING_PROBE_BYTES,8) ;
|
||||
|
||||
mLastSentPacketSlicingProbe = now ;
|
||||
}
|
||||
|
||||
uint32_t slice_size=0;
|
||||
bool slice_starts=true ;
|
||||
bool slice_ends=true ;
|
||||
uint32_t slice_packet_id=0 ;
|
||||
|
||||
do
|
||||
{
|
||||
int desired_packet_size = mAcceptsPacketSlicing?PQISTREAM_OPTIMAL_PACKET_SIZE:(getRsPktMaxSize());
|
||||
|
||||
dta = locked_pop_out_data(desired_packet_size,slice_size,slice_starts,slice_ends,slice_packet_id) ;
|
||||
|
||||
if(!dta)
|
||||
break ;
|
||||
|
||||
if(slice_starts && slice_ends) // good old method. Send the packet as is, since it's a full packet.
|
||||
{
|
||||
#ifdef DEBUG_PACKET_SLICING
|
||||
std::cerr << "sending full slice, old style. Size=" << slice_size << std::endl;
|
||||
#endif
|
||||
mPkt_wpending = realloc(mPkt_wpending,slice_size+mPkt_wpending_size) ;
|
||||
memcpy( &((char*)mPkt_wpending)[mPkt_wpending_size],dta,slice_size) ;
|
||||
free(dta);
|
||||
mPkt_wpending_size += s ;
|
||||
mPkt_wpending_size += slice_size ;
|
||||
++k ;
|
||||
}
|
||||
else // partial packet. We make a special header for it and insert it in the stream
|
||||
{
|
||||
if(slice_size > 0xffff || !mAcceptsPacketSlicing)
|
||||
{
|
||||
std::cerr << "(EE) protocol error in pqitreamer: slice size is too large and cannot be encoded." ;
|
||||
free(mPkt_wpending) ;
|
||||
mPkt_wpending_size = 0;
|
||||
return -1 ;
|
||||
}
|
||||
#ifdef DEBUG_PACKET_SLICING
|
||||
std::cerr << "sending partial slice, packet ID=" << std::hex << slice_packet_id << std::dec << ", size=" << slice_size << std::endl;
|
||||
#endif
|
||||
|
||||
mPkt_wpending = realloc(mPkt_wpending,slice_size+mPkt_wpending_size+PQISTREAM_PARTIAL_PACKET_HEADER_SIZE) ;
|
||||
memcpy( &((char*)mPkt_wpending)[mPkt_wpending_size+PQISTREAM_PARTIAL_PACKET_HEADER_SIZE],dta,slice_size) ;
|
||||
free(dta);
|
||||
|
||||
// New2: pp ff xxxxxxxx ssss [data, sss bytes] => [flags 1B] [protocol version 1B] [2^32 packet count] [2^16 size]
|
||||
|
||||
uint8_t partial_flags = 0 ;
|
||||
if(slice_starts) partial_flags |= PQISTREAM_SLICE_FLAG_STARTS ;
|
||||
if(slice_ends ) partial_flags |= PQISTREAM_SLICE_FLAG_ENDS ;
|
||||
|
||||
((char*)mPkt_wpending)[mPkt_wpending_size+0x00] = PQISTREAM_SLICE_PROTOCOL_VERSION_ID_01 ;
|
||||
((char*)mPkt_wpending)[mPkt_wpending_size+0x01] = partial_flags ;
|
||||
((char*)mPkt_wpending)[mPkt_wpending_size+0x02] = uint8_t(slice_packet_id >> 24) & 0xff ;
|
||||
((char*)mPkt_wpending)[mPkt_wpending_size+0x03] = uint8_t(slice_packet_id >> 16) & 0xff ;
|
||||
((char*)mPkt_wpending)[mPkt_wpending_size+0x04] = uint8_t(slice_packet_id >> 8) & 0xff ;
|
||||
((char*)mPkt_wpending)[mPkt_wpending_size+0x05] = uint8_t(slice_packet_id >> 0) & 0xff ;
|
||||
((char*)mPkt_wpending)[mPkt_wpending_size+0x06] = uint8_t(slice_size >> 8) & 0xff ;
|
||||
((char*)mPkt_wpending)[mPkt_wpending_size+0x07] = uint8_t(slice_size >> 0) & 0xff ;
|
||||
|
||||
mPkt_wpending_size += slice_size + PQISTREAM_PARTIAL_PACKET_HEADER_SIZE;
|
||||
++k ;
|
||||
}
|
||||
}
|
||||
while(mPkt_wpending_size < (uint32_t)maxbytes && mPkt_wpending_size < PQISTREAM_OPTIMAL_PACKET_SIZE ) ;
|
||||
|
||||
#ifdef DEBUG_PQISTREAMER
|
||||
if(k > 1)
|
||||
std::cerr << "Packed " << k << " packets into " << mPkt_wpending_size << " bytes." << std::endl;
|
||||
#endif
|
||||
}
|
||||
#else
|
||||
{
|
||||
void *dta = locked_pop_out_data() ;
|
||||
|
||||
if(dta != NULL)
|
||||
{
|
||||
mPkt_wpending = dta ;
|
||||
mPkt_wpending_size = getRsItemSize(dta);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
if (mPkt_wpending)
|
||||
{
|
||||
// write packet.
|
||||
@ -507,12 +613,19 @@ int pqistreamer::handleoutgoing_locked()
|
||||
// std::cerr << out << std::endl ;
|
||||
pqioutput(PQL_DEBUG_BASIC, pqistreamerzone, out);
|
||||
#endif
|
||||
std::cerr << PeerId() << ": sending failed. Only " << ss << " bytes sent over " << mPkt_wpending_size << std::endl;
|
||||
|
||||
// pkt_wpending will kept til next time.
|
||||
// ensuring exactly the same data is written (openSSL requirement).
|
||||
return -1;
|
||||
}
|
||||
#ifdef DEBUG_PQISTREAMER
|
||||
else
|
||||
std::cerr << PeerId() << ": sent " << ss << " bytes " << std::endl;
|
||||
#endif
|
||||
|
||||
++nsent;
|
||||
|
||||
outSentBytes_locked(mPkt_wpending_size); // this is the only time where we know exactly what was sent.
|
||||
|
||||
#ifdef DEBUG_TRANSFERS
|
||||
@ -562,7 +675,7 @@ int pqistreamer::handleincoming_locked()
|
||||
void *block = mPkt_rpending;
|
||||
|
||||
// initial read size: basic packet.
|
||||
int blen = getRsPktBaseSize();
|
||||
int blen = getRsPktBaseSize(); // this is valid for both packet slices and normal un-sliced packets (same header size)
|
||||
|
||||
int maxin = inAllowedBytes_locked();
|
||||
|
||||
@ -623,33 +736,56 @@ start_packet_read:
|
||||
}
|
||||
}
|
||||
#ifdef DEBUG_PQISTREAMER
|
||||
std::cerr << "[" << (void*)pthread_self() << "] " << "block 0 : " << (int)(((unsigned char*)block)[0]) << " " << (int)(((unsigned char*)block)[1]) << " " << (int)(((unsigned char*)block)[2]) << " "
|
||||
<< (int)(((unsigned char*)block)[3]) << " "
|
||||
<< (int)(((unsigned char*)block)[4]) << " "
|
||||
<< (int)(((unsigned char*)block)[5]) << " "
|
||||
<< (int)(((unsigned char*)block)[6]) << " "
|
||||
<< (int)(((unsigned char*)block)[7]) << " " << std::endl ;
|
||||
std::cerr << "[" << (void*)pthread_self() << "] " << "block 0 : " << RsUtil::BinToHex(block,8) << std::endl;
|
||||
#endif
|
||||
|
||||
readbytes += blen;
|
||||
mReading_state = reading_state_packet_started ;
|
||||
mFailed_read_attempts = 0 ; // reset failed read, as the packet has been totally read.
|
||||
|
||||
// Check for packet slicing probe (04/26/2016). To be removed when everyone uses it.
|
||||
|
||||
if(!memcmp(block,PACKET_SLICING_PROBE_BYTES,8))
|
||||
{
|
||||
mAcceptsPacketSlicing = true ;
|
||||
#ifdef DEBUG_PACKET_SLICING
|
||||
std::cerr << "(II) Enabling packet slicing!" << std::endl;
|
||||
#endif
|
||||
}
|
||||
}
|
||||
continue_packet:
|
||||
{
|
||||
// workout how much more to read.
|
||||
int extralen = getRsItemSize(block) - blen;
|
||||
|
||||
bool is_partial_packet = false ;
|
||||
bool is_packet_starting = (((char*)block)[1] == PQISTREAM_SLICE_FLAG_STARTS) ; // STARTS and ENDS flags are actually never combined.
|
||||
bool is_packet_ending = (((char*)block)[1] == PQISTREAM_SLICE_FLAG_ENDS) ;
|
||||
bool is_packet_middle = (((char*)block)[1] == 0x00) ;
|
||||
|
||||
uint32_t extralen =0;
|
||||
uint32_t slice_packet_id =0;
|
||||
|
||||
if( ((char*)block)[0] == PQISTREAM_SLICE_PROTOCOL_VERSION_ID_01 && ( is_packet_starting || is_packet_middle || is_packet_ending))
|
||||
{
|
||||
extralen = (uint32_t(((uint8_t*)block)[6]) << 8 ) + (uint32_t(((uint8_t*)block)[7]));
|
||||
slice_packet_id = (uint32_t(((uint8_t*)block)[2]) << 24) + (uint32_t(((uint8_t*)block)[3]) << 16) + (uint32_t(((uint8_t*)block)[4]) << 8) + (uint32_t(((uint8_t*)block)[5]) << 0);
|
||||
|
||||
#ifdef DEBUG_PACKET_SLICING
|
||||
std::cerr << "Reading partial packet from mem block " << RsUtil::BinToHex((char*)block,8) << ": packet_id=" << std::hex << slice_packet_id << std::dec << ", len=" << extralen << std::endl;
|
||||
#endif
|
||||
is_partial_packet = true ;
|
||||
|
||||
mAcceptsPacketSlicing = true ; // this is needed
|
||||
}
|
||||
else
|
||||
extralen = getRsItemSize(block) - blen; // old style packet type
|
||||
|
||||
#ifdef DEBUG_PQISTREAMER
|
||||
std::cerr << "[" << (void*)pthread_self() << "] " << "continuing packet getRsItemSize(block) = " << getRsItemSize(block) << std::endl ;
|
||||
std::cerr << "[" << (void*)pthread_self() << "] " << "continuing packet extralen = " << extralen << std::endl ;
|
||||
|
||||
std::cerr << "[" << (void*)pthread_self() << "] " << "continuing packet state=" << mReading_state << std::endl ;
|
||||
std::cerr << "[" << (void*)pthread_self() << "] " << "block 1 : " << (int)(((unsigned char*)block)[0]) << " " << (int)(((unsigned char*)block)[1]) << " " << (int)(((unsigned char*)block)[2]) << " " << (int)(((unsigned char*)block)[3]) << " "
|
||||
<< (int)(((unsigned char*)block)[4]) << " "
|
||||
<< (int)(((unsigned char*)block)[5]) << " "
|
||||
<< (int)(((unsigned char*)block)[6]) << " "
|
||||
<< (int)(((unsigned char*)block)[7]) << " " << std::endl ;
|
||||
std::cerr << "[" << (void*)pthread_self() << "] " << "block 1 : " << RsUtil::BinToHex(block,8) << std::endl;
|
||||
#endif
|
||||
if (extralen > maxlen - blen)
|
||||
{
|
||||
@ -670,15 +806,9 @@ continue_packet:
|
||||
msg += "\n";
|
||||
rs_sprintf_append(msg, "(M:%d B:%d E:%d)\n", maxlen, blen, extralen);
|
||||
msg += "\n";
|
||||
rs_sprintf_append(msg, "block = %d %d %d %d %d %d %d %d\n",
|
||||
(int)(((unsigned char*)block)[0]),
|
||||
(int)(((unsigned char*)block)[1]),
|
||||
(int)(((unsigned char*)block)[2]),
|
||||
(int)(((unsigned char*)block)[3]),
|
||||
(int)(((unsigned char*)block)[4]),
|
||||
(int)(((unsigned char*)block)[5]),
|
||||
(int)(((unsigned char*)block)[6]),
|
||||
(int)(((unsigned char*)block)[7])) ;
|
||||
msg += "block = " ;
|
||||
msg += RsUtil::BinToHex((char*)block,8);
|
||||
|
||||
msg += "\n";
|
||||
msg += "Please get your friends to upgrade to the latest version";
|
||||
msg += "\n";
|
||||
@ -745,17 +875,8 @@ continue_packet:
|
||||
msgout += "If it happens manny time, please contact the developers, and send them these numbers:";
|
||||
msgout += "\n";
|
||||
|
||||
rs_sprintf_append(msgout, "block = %d %d %d %d %d %d %d %d\n",
|
||||
(int)(((unsigned char*)block)[0]),
|
||||
(int)(((unsigned char*)block)[1]),
|
||||
(int)(((unsigned char*)block)[2]),
|
||||
(int)(((unsigned char*)block)[3]),
|
||||
(int)(((unsigned char*)block)[4]),
|
||||
(int)(((unsigned char*)block)[5]),
|
||||
(int)(((unsigned char*)block)[6]),
|
||||
(int)(((unsigned char*)block)[7]));
|
||||
|
||||
//notify->AddSysMessage(0, RS_SYS_WARNING, title, msgout.str());
|
||||
msgout += "block = " ;
|
||||
msgout += RsUtil::BinToHex((char*)block,8) + "\n" ;
|
||||
|
||||
std::cerr << msgout << std::endl;
|
||||
}
|
||||
@ -776,11 +897,7 @@ continue_packet:
|
||||
}
|
||||
#ifdef DEBUG_PQISTREAMER
|
||||
std::cerr << "[" << (void*)pthread_self() << "] " << "continuing packet state=" << mReading_state << std::endl ;
|
||||
std::cerr << "[" << (void*)pthread_self() << "] " << "block 2 : " << (int)(((unsigned char*)extradata)[0]) << " " << (int)(((unsigned char*)extradata)[1]) << " " << (int)(((unsigned char*)extradata)[2]) << " " << (int)(((unsigned char*)extradata)[3]) << " "
|
||||
<< (int)(((unsigned char*)extradata)[4]) << " "
|
||||
<< (int)(((unsigned char*)extradata)[5]) << " "
|
||||
<< (int)(((unsigned char*)extradata)[6]) << " "
|
||||
<< (int)(((unsigned char*)extradata)[7]) << " " << std::endl ;
|
||||
std::cerr << "[" << (void*)pthread_self() << "] " << "block 2 : " << RsUtil::BinToHex(extradata,8) << std::endl;
|
||||
#endif
|
||||
|
||||
mFailed_read_attempts = 0 ;
|
||||
@ -797,14 +914,21 @@ continue_packet:
|
||||
}
|
||||
#endif
|
||||
|
||||
// std::cerr << "Deserializing packet of size " << pktlen <<std::endl ;
|
||||
|
||||
uint32_t pktlen = blen+extralen ;
|
||||
#ifdef DEBUG_PQISTREAMER
|
||||
std::cerr << "[" << (void*)pthread_self() << "] " << "deserializing. Size=" << pktlen << std::endl ;
|
||||
std::cerr << "[" << (void*)pthread_self() << "] " << RsUtil::BinToHex((char*)block,8) << "...: deserializing. Size=" << pktlen << std::endl ;
|
||||
#endif
|
||||
RsItem *pkt ;
|
||||
|
||||
RsItem *pkt = mRsSerialiser->deserialise(block, &pktlen);
|
||||
if(is_partial_packet)
|
||||
{
|
||||
#ifdef DEBUG_PACKET_SLICING
|
||||
std::cerr << "Inputing partial packet " << RsUtil::BinToHex((char*)block,8) << std::endl;
|
||||
#endif
|
||||
pkt = addPartialPacket(block,pktlen,slice_packet_id,is_packet_starting,is_packet_ending) ;
|
||||
}
|
||||
else
|
||||
pkt = mRsSerialiser->deserialise(block, &pktlen);
|
||||
|
||||
if ((pkt != NULL) && (0 < handleincomingitem_locked(pkt,pktlen)))
|
||||
{
|
||||
@ -813,7 +937,7 @@ continue_packet:
|
||||
#endif
|
||||
inReadBytes_locked(pktlen); // only count deserialised packets, because that's what is actually been transfered.
|
||||
}
|
||||
else
|
||||
else if (!is_partial_packet)
|
||||
{
|
||||
#ifdef DEBUG_PQISTREAMER
|
||||
pqioutput(PQL_ALERT, pqistreamerzone, "Failed to handle Packet!");
|
||||
@ -844,6 +968,91 @@ continue_packet:
|
||||
return 0;
|
||||
}
|
||||
|
||||
RsItem *pqistreamer::addPartialPacket(const void *block,uint32_t len,uint32_t slice_packet_id,bool is_packet_starting,bool is_packet_ending)
|
||||
{
|
||||
#ifdef DEBUG_PACKET_SLICING
|
||||
std::cerr << "Receiving partial packet. size=" << len << ", ID=" << std::hex << slice_packet_id << std::dec << ", starting:" << is_packet_starting << ", ending:" << is_packet_ending ;
|
||||
#endif
|
||||
|
||||
if(is_packet_starting && is_packet_ending)
|
||||
{
|
||||
std::cerr << " (EE) unexpected situation: both starting and ending" << std::endl;
|
||||
return NULL ;
|
||||
}
|
||||
|
||||
uint32_t slice_length = len - PQISTREAM_PARTIAL_PACKET_HEADER_SIZE ;
|
||||
unsigned char *slice_data = &((unsigned char*)block)[PQISTREAM_PARTIAL_PACKET_HEADER_SIZE] ;
|
||||
|
||||
std::map<uint32_t,PartialPacketRecord>::iterator it = mPartialPackets.find(slice_packet_id) ;
|
||||
|
||||
if(it == mPartialPackets.end())
|
||||
{
|
||||
// make sure we really have a starting packet. Otherwise this is an error.
|
||||
|
||||
if(!is_packet_starting)
|
||||
{
|
||||
std::cerr << " (EE) non starting packet has no record. Dropping" << std::endl;
|
||||
return NULL ;
|
||||
}
|
||||
PartialPacketRecord& rec = mPartialPackets[slice_packet_id] ;
|
||||
|
||||
rec.mem = rs_malloc(slice_length) ;
|
||||
|
||||
if(!rec.mem)
|
||||
{
|
||||
std::cerr << " (EE) Cannot allocate memory for slice of size " << slice_length << std::endl;
|
||||
return NULL ;
|
||||
}
|
||||
|
||||
memcpy(rec.mem, slice_data, slice_length) ; ;
|
||||
rec.size = slice_length ;
|
||||
|
||||
#ifdef DEBUG_PACKET_SLICING
|
||||
std::cerr << " => stored in new record (size=" << rec.size << std::endl;
|
||||
#endif
|
||||
|
||||
return NULL ; // no need to check for ending
|
||||
}
|
||||
else
|
||||
{
|
||||
PartialPacketRecord& rec = it->second ;
|
||||
|
||||
if(is_packet_starting)
|
||||
{
|
||||
std::cerr << "(WW) dropping unfinished existing packet that gets to be replaced by new starting packet." << std::endl;
|
||||
free(rec.mem);
|
||||
rec.size = 0 ;
|
||||
}
|
||||
// make sure this is a continuing packet, otherwise this is an error.
|
||||
|
||||
rec.mem = realloc(rec.mem, rec.size + slice_length) ;
|
||||
memcpy( &((char*)rec.mem)[rec.size],slice_data,slice_length) ;
|
||||
rec.size += slice_length ;
|
||||
|
||||
#ifdef DEBUG_PACKET_SLICING
|
||||
std::cerr << " => added to existing record size=" << rec.size ;
|
||||
#endif
|
||||
|
||||
if(is_packet_ending)
|
||||
{
|
||||
#ifdef DEBUG_PACKET_SLICING
|
||||
std::cerr << " => deserialising: mem=" << RsUtil::BinToHex((char*)rec.mem,std::min(8u,rec.size)) << std::endl;
|
||||
#endif
|
||||
RsItem *item = mRsSerialiser->deserialise(rec.mem, &rec.size);
|
||||
|
||||
free(rec.mem) ;
|
||||
mPartialPackets.erase(it) ;
|
||||
return item ;
|
||||
}
|
||||
else
|
||||
{
|
||||
#ifdef DEBUG_PACKET_SLICING
|
||||
std::cerr << std::endl;
|
||||
#endif
|
||||
return NULL ;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* BandWidth Management Assistance */
|
||||
|
||||
@ -1074,8 +1283,13 @@ int pqistreamer::locked_gatherStatistics(std::list<RSTrafficClue>& out_lst,std::
|
||||
return 1 ;
|
||||
}
|
||||
|
||||
void *pqistreamer::locked_pop_out_data()
|
||||
void *pqistreamer::locked_pop_out_data(uint32_t max_slice_size,uint32_t& size,bool& starts,bool& ends,uint32_t& packet_id)
|
||||
{
|
||||
size = 0 ;
|
||||
starts = true ;
|
||||
ends = true ;
|
||||
packet_id = 0 ;
|
||||
|
||||
void *res = NULL ;
|
||||
|
||||
if (!mOutPkts.empty())
|
||||
@ -1089,3 +1303,5 @@ void *pqistreamer::locked_pop_out_data()
|
||||
}
|
||||
return res ;
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -40,6 +40,12 @@
|
||||
// The interface does not handle connection, just communication.
|
||||
// possible bioflags: BIN_FLAGS_NO_CLOSE | BIN_FLAGS_NO_DELETE
|
||||
|
||||
struct PartialPacketRecord
|
||||
{
|
||||
void *mem ;
|
||||
uint32_t size ;
|
||||
};
|
||||
|
||||
class pqistreamer: public PQInterface
|
||||
{
|
||||
public:
|
||||
@ -71,12 +77,11 @@ class pqistreamer: public PQInterface
|
||||
|
||||
// These methods are redefined in pqiQoSstreamer
|
||||
//
|
||||
virtual void locked_storeInOutputQueue(void *ptr,int priority) ;
|
||||
virtual void locked_storeInOutputQueue(void *ptr, int size, int priority) ;
|
||||
virtual int locked_out_queue_size() const ;
|
||||
virtual void locked_clear_out_queue() ;
|
||||
virtual int locked_compute_out_pkt_size() const ;
|
||||
virtual void *locked_pop_out_data() ;
|
||||
//virtual int locked_gatherStatistics(std::vector<uint32_t>& per_service_count,std::vector<uint32_t>& per_priority_count) const; // extracting data.
|
||||
virtual void *locked_pop_out_data(uint32_t max_slice_size,uint32_t& size,bool& starts,bool& ends,uint32_t& packet_id);
|
||||
virtual int locked_gatherStatistics(std::list<RSTrafficClue>& outqueue_stats,std::list<RSTrafficClue>& inqueue_stats); // extracting data.
|
||||
|
||||
void updateRates() ;
|
||||
@ -156,7 +161,12 @@ class pqistreamer: public PQInterface
|
||||
std::list<RSTrafficClue> mCurrentStatsChunk_Out ;
|
||||
time_t mStatisticsTimeStamp ;
|
||||
|
||||
bool mAcceptsPacketSlicing ;
|
||||
time_t mLastSentPacketSlicingProbe ;
|
||||
void locked_addTrafficClue(const RsItem *pqi, uint32_t pktsize, std::list<RSTrafficClue> &lst);
|
||||
RsItem *addPartialPacket(const void *block, uint32_t len, uint32_t slice_packet_id,bool packet_starting,bool packet_ending);
|
||||
|
||||
std::map<uint32_t,PartialPacketRecord> mPartialPackets ;
|
||||
};
|
||||
|
||||
#endif //MRK_PQI_STREAMER_HEADER
|
||||
|
||||
@ -69,8 +69,12 @@ static double getCurrentTS()
|
||||
return cts;
|
||||
}
|
||||
|
||||
const double RsServer::minTimeDelta = 0.1; // 25;
|
||||
const double RsServer::maxTimeDelta = 0.5;
|
||||
// These values should be tunable from the GUI, to offer a compromise between speed and CPU use.
|
||||
// In some cases (VOIP) it's likely that we will need to set them temporarily to a very low
|
||||
// value, in order to favor a fast feedback
|
||||
|
||||
const double RsServer::minTimeDelta = 0.05; // 25;
|
||||
const double RsServer::maxTimeDelta = 0.2;
|
||||
const double RsServer::kickLimit = 0.15;
|
||||
|
||||
|
||||
|
||||
@ -366,11 +366,7 @@ int RsInit::InitRetroShare(int argcIgnored, char **argvIgnored, bool strictCheck
|
||||
#ifdef LOCALNET_TESTING
|
||||
>> parameter('R',"restrict-port" ,portRestrictions ,"port1-port2","Apply port restriction" ,false)
|
||||
#endif
|
||||
#ifdef __APPLE__
|
||||
>> help('h',"help","Display this Help") ;
|
||||
#else
|
||||
>> help() ;
|
||||
#endif
|
||||
|
||||
as.defaultErrorHandling(true) ;
|
||||
|
||||
|
||||
@ -96,6 +96,9 @@ const uint16_t RS_SERVICE_TYPE_PLUGIN_ARADO_ID = 0x2001;
|
||||
const uint16_t RS_SERVICE_TYPE_PLUGIN_QCHESS_ID = 0x2002;
|
||||
const uint16_t RS_SERVICE_TYPE_PLUGIN_FEEDREADER = 0x2003;
|
||||
|
||||
// Reserved for packet slicing probes.
|
||||
const uint16_t RS_SERVICE_TYPE_PACKET_SLICING_PROBE = 0xAABB;
|
||||
|
||||
// Nabu's services.
|
||||
const uint16_t RS_SERVICE_TYPE_PLUGIN_FIDO_GW = 0xF1D0;
|
||||
const uint16_t RS_SERVICE_TYPE_PLUGIN_ZERORESERVE = 0xBEEF;
|
||||
|
||||
@ -23,6 +23,8 @@
|
||||
*
|
||||
*/
|
||||
|
||||
#include <iomanip>
|
||||
|
||||
#include "util/rsdir.h"
|
||||
#include "retroshare/rsiface.h"
|
||||
#include "pqi/pqibin.h"
|
||||
@ -38,7 +40,6 @@
|
||||
* #define DEBUG_RTT 1
|
||||
****/
|
||||
|
||||
|
||||
/* DEFINE INTERFACE POINTER! */
|
||||
RsRtt *rsRtt = NULL;
|
||||
|
||||
@ -168,7 +169,7 @@ int p3rtt::sendPackets()
|
||||
pt = mSentPingTime;
|
||||
}
|
||||
|
||||
if (now - pt > RTT_PING_PERIOD)
|
||||
if (now >= pt+RTT_PING_PERIOD)
|
||||
{
|
||||
sendPingMeasurements();
|
||||
|
||||
@ -190,19 +191,10 @@ void p3rtt::sendPingMeasurements()
|
||||
|
||||
mServiceCtrl->getPeersConnected(getServiceInfo().mServiceType, idList);
|
||||
|
||||
#ifdef DEBUG_RTT
|
||||
std::cerr << "p3rtt::sendPingMeasurements() @ts: " << ts;
|
||||
std::cerr << std::endl;
|
||||
#endif
|
||||
|
||||
/* prepare packets */
|
||||
std::set<RsPeerId>::iterator it;
|
||||
for(it = idList.begin(); it != idList.end(); ++it)
|
||||
{
|
||||
#ifdef DEBUG_RTT
|
||||
std::cerr << "p3rtt::sendPingMeasurements() Pinging: " << *it;
|
||||
std::cerr << std::endl;
|
||||
#endif
|
||||
double ts = getCurrentTS();
|
||||
|
||||
/* create the packet */
|
||||
@ -214,11 +206,8 @@ void p3rtt::sendPingMeasurements()
|
||||
storePingAttempt(*it, ts, mCounter);
|
||||
|
||||
#ifdef DEBUG_RTT
|
||||
std::cerr << "p3rtt::sendPingMeasurements() With Packet:";
|
||||
std::cerr << std::endl;
|
||||
pingPkt->print(std::cerr, 10);
|
||||
std::cerr << "p3rtt::sendPingMeasurements() Pinging: " << *it << " [" << pingPkt->mSeqNo << "," << std::hex << pingPkt->mPingTS << std::dec << "]" << std::endl;;
|
||||
#endif
|
||||
|
||||
sendItem(pingPkt);
|
||||
}
|
||||
|
||||
@ -256,30 +245,28 @@ int p3rtt::handlePing(RsItem *item)
|
||||
/* cast to right type */
|
||||
RsRttPingItem *ping = (RsRttPingItem *) item;
|
||||
|
||||
double ts = getCurrentTS();
|
||||
#ifdef DEBUG_RTT
|
||||
std::cerr << "p3rtt::handlePing() Recvd Packet from: " << ping->PeerId();
|
||||
std::cerr << std::endl;
|
||||
std::cerr << "p3rtt::handlePing() from: " << ping->PeerId() << " - [" << ping->mSeqNo << "," << std::hex << ping->mPingTS << std::dec << "] " << std::endl;
|
||||
std::cerr << "incoming ping travel time: " << ts - convert64bitsToTs(ping->mPingTS) << std::endl;
|
||||
#endif
|
||||
|
||||
/* with a ping, we just respond as quickly as possible - they do all the analysis */
|
||||
RsRttPongItem *pong = new RsRttPongItem();
|
||||
|
||||
|
||||
pong->PeerId(ping->PeerId());
|
||||
pong->mPingTS = ping->mPingTS;
|
||||
pong->mSeqNo = ping->mSeqNo;
|
||||
|
||||
// add our timestamp.
|
||||
double ts = getCurrentTS();
|
||||
pong->mPongTS = convertTsTo64bits(ts);
|
||||
|
||||
|
||||
static double mLastResponseToPong = 0.0 ;// bad stuff
|
||||
#ifdef DEBUG_RTT
|
||||
std::cerr << "p3rtt::handlePing() With Packet:";
|
||||
std::cerr << std::endl;
|
||||
pong->print(std::cerr, 10);
|
||||
std::cerr << "Delay since last response to PONG: " << ts - mLastResponseToPong << std::endl;
|
||||
#endif
|
||||
|
||||
mLastResponseToPong = ts ;
|
||||
sendItem(pong);
|
||||
return true ;
|
||||
}
|
||||
@ -291,9 +278,7 @@ int p3rtt::handlePong(RsItem *item)
|
||||
RsRttPongItem *pong = (RsRttPongItem *) item;
|
||||
|
||||
#ifdef DEBUG_RTT
|
||||
std::cerr << "p3rtt::handlePong() Recvd Packet from: " << pong->PeerId();
|
||||
std::cerr << std::endl;
|
||||
pong->print(std::cerr, 10);
|
||||
std::cerr << "p3rtt::handlePong() from: " << pong->PeerId() << " - [" << pong->mSeqNo << "," << std::hex << pong->mPingTS << " -> " << pong->mPongTS << std::dec << "] "<< std::endl;
|
||||
#endif
|
||||
|
||||
/* with a pong, we do the maths! */
|
||||
@ -305,21 +290,12 @@ int p3rtt::handlePong(RsItem *item)
|
||||
double offset = pongTS - (recvTS - rtt / 2.0); // so to get to their time, we go ourTS + offset.
|
||||
|
||||
#ifdef DEBUG_RTT
|
||||
std::cerr << "p3rtt::handlePong() Timing:";
|
||||
std::cerr << std::endl;
|
||||
std::cerr << "\tpingTS: " << pingTS;
|
||||
std::cerr << std::endl;
|
||||
std::cerr << "\tpongTS: " << pongTS;
|
||||
std::cerr << std::endl;
|
||||
std::cerr << "\trecvTS: " << recvTS;
|
||||
std::cerr << std::endl;
|
||||
std::cerr << "\t ==> rtt: " << rtt;
|
||||
std::cerr << std::endl;
|
||||
std::cerr << "\t ==> offset: " << offset;
|
||||
std::cerr << std::endl;
|
||||
std::cerr << "incoming pong travel time: " << recvTS - convert64bitsToTs(pong->mPongTS) << std::endl;
|
||||
std::cerr << " RTT analysis: pingTS: " << std::setprecision(16) << pingTS << ", pongTS: " << pongTS
|
||||
<< ", recvTS: " << std::setprecision(16) << recvTS << " ==> rtt: " << rtt << ", offset: " << offset << std::endl;
|
||||
#endif
|
||||
|
||||
storePongResult(pong->PeerId(), pong->mSeqNo, pingTS, rtt, offset);
|
||||
storePongResult(pong->PeerId(), pong->mSeqNo, recvTS, rtt, offset);
|
||||
return true ;
|
||||
}
|
||||
|
||||
@ -333,6 +309,9 @@ int p3rtt::storePingAttempt(const RsPeerId& id, double ts, uint32_t seqno)
|
||||
/* find corresponding local data */
|
||||
RttPeerInfo *peerInfo = locked_GetPeerInfo(id);
|
||||
|
||||
#ifdef DEBUG_RTT
|
||||
std::cerr << "Delay since previous ping attempt: " << ts - peerInfo->mCurrentPingTS << std::endl;
|
||||
#endif
|
||||
peerInfo->mCurrentPingTS = ts;
|
||||
peerInfo->mCurrentPingCounter = seqno;
|
||||
|
||||
@ -349,7 +328,7 @@ int p3rtt::storePingAttempt(const RsPeerId& id, double ts, uint32_t seqno)
|
||||
|
||||
|
||||
|
||||
int p3rtt::storePongResult(const RsPeerId& id, uint32_t counter, double ts, double rtt, double offset)
|
||||
int p3rtt::storePongResult(const RsPeerId& id, uint32_t counter, double recv_ts, double rtt, double offset)
|
||||
{
|
||||
RsStackMutex stack(mRttMtx); /****** LOCKED MUTEX *******/
|
||||
|
||||
@ -366,8 +345,12 @@ int p3rtt::storePongResult(const RsPeerId& id, uint32_t counter, double ts, doub
|
||||
{
|
||||
peerInfo->mCurrentPongRecvd = true;
|
||||
}
|
||||
#ifdef DEBUG_RTT
|
||||
if(!peerInfo->mPongResults.empty())
|
||||
std::cerr << "Delay since last pong: " << recv_ts - peerInfo->mPongResults.back().mTS << std::endl;
|
||||
#endif
|
||||
|
||||
peerInfo->mPongResults.push_back(RsRttPongResult(ts, rtt, offset));
|
||||
peerInfo->mPongResults.push_back(RsRttPongResult(recv_ts, rtt, offset));
|
||||
|
||||
|
||||
while(peerInfo->mPongResults.size() > MAX_PONG_RESULTS)
|
||||
|
||||
@ -84,7 +84,7 @@ virtual bool recvItem(RsItem *item); // Overloaded from p3FastService.
|
||||
int handlePong(RsItem *item);
|
||||
|
||||
int storePingAttempt(const RsPeerId& id, double ts, uint32_t mCounter);
|
||||
int storePongResult(const RsPeerId& id, uint32_t counter, double ts, double rtt, double offset);
|
||||
int storePongResult(const RsPeerId& id, uint32_t counter, double recv_ts, double rtt, double offset);
|
||||
|
||||
|
||||
/*!
|
||||
|
||||
@ -726,7 +726,7 @@ bool p3turtle::loadList(std::list<RsItem*>& load)
|
||||
}
|
||||
}
|
||||
|
||||
delete vitem ;
|
||||
delete *it ;
|
||||
}
|
||||
load.clear() ;
|
||||
return true ;
|
||||
|
||||
@ -141,15 +141,10 @@ namespace
|
||||
inline OptionHolder(char s,
|
||||
const char* l,
|
||||
const char* desc);
|
||||
#ifdef __APPLE__
|
||||
friend OptionHolder help(char s,
|
||||
const char* l,
|
||||
const char* desc);
|
||||
#else
|
||||
friend OptionHolder help(char s='h',
|
||||
const char* l="help",
|
||||
const char* desc="Display this help");
|
||||
#endif
|
||||
|
||||
private:
|
||||
std::string shortName_;
|
||||
std::string longName_;
|
||||
|
||||
@ -13,7 +13,7 @@ void *rs_malloc(size_t size)
|
||||
|
||||
if(size > SAFE_MEMALLOC_THRESHOLD)
|
||||
{
|
||||
std::cerr << "(EE) Memory allocation error. A chunk of size 0 was requested. Callstack:" << std::endl;
|
||||
std::cerr << "(EE) Memory allocation error. A chunk of size larger than " << SAFE_MEMALLOC_THRESHOLD << " was requested. Callstack:" << std::endl;
|
||||
print_stacktrace() ;
|
||||
return NULL ;
|
||||
}
|
||||
|
||||
@ -219,8 +219,8 @@ TransfersDialog::TransfersDialog(QWidget *parent)
|
||||
|
||||
// workaround for Qt bug, should be solved in next Qt release 4.7.0
|
||||
// http://bugreports.qt.nokia.com/browse/QTBUG-8270
|
||||
QShortcut *Shortcut = new QShortcut(QKeySequence (Qt::Key_Delete), ui.downloadList, 0, 0, Qt::WidgetShortcut);
|
||||
connect(Shortcut, SIGNAL(activated()), this, SLOT( cancel ()));
|
||||
mShortcut = new QShortcut(QKeySequence (Qt::Key_Delete), ui.downloadList, 0, 0, Qt::WidgetShortcut);
|
||||
connect(mShortcut, SIGNAL(activated()), this, SLOT( cancel ()));
|
||||
|
||||
//Selection Setup
|
||||
selection = ui.downloadList->selectionModel();
|
||||
@ -942,7 +942,8 @@ int TransfersDialog::addItem(int row, const FileInfo &fileInfo)
|
||||
|
||||
qlonglong completed = fileInfo.transfered;
|
||||
qlonglong remaining = fileInfo.size - fileInfo.transfered;
|
||||
qlonglong downloadtime = (fileInfo.size - fileInfo.transfered) / (fileInfo.tfRate * 1024.0);
|
||||
|
||||
qlonglong downloadtime = (fileInfo.tfRate > 0)?( (fileInfo.size - fileInfo.transfered) / (fileInfo.tfRate * 1024.0) ) : 0 ;
|
||||
qint64 qi64LastDL = fileInfo.lastTS ; //std::numeric_limits<qint64>::max();
|
||||
|
||||
if (qi64LastDL == 0) // file is complete, or any raison why the time has not been set properly
|
||||
@ -1355,7 +1356,7 @@ void TransfersDialog::insertTransfers()
|
||||
qlonglong fileSize = info.size;
|
||||
qlonglong completed = pit->transfered;
|
||||
// double progress = (info.size > 0)?(pit->transfered * 100.0 / info.size):0.0;
|
||||
qlonglong remaining = (info.size - pit->transfered) / (pit->tfRate * 1024.0);
|
||||
qlonglong remaining = (pit->tfRate>0)?((info.size - pit->transfered) / (pit->tfRate * 1024.0)):0;
|
||||
|
||||
// Estimate the completion. We need something more accurate, meaning that we need to
|
||||
// transmit the completion info.
|
||||
|
||||
@ -31,6 +31,7 @@
|
||||
|
||||
#define IMAGE_TRANSFERS ":/icons/ktorrent_128.png"
|
||||
|
||||
class QShortcut;
|
||||
class DLListDelegate;
|
||||
class ULListDelegate;
|
||||
class QStandardItemModel;
|
||||
@ -243,6 +244,8 @@ private:
|
||||
QString downloads;
|
||||
QString uploads;
|
||||
|
||||
QShortcut *mShortcut ;
|
||||
|
||||
/** Qt Designer generated object */
|
||||
Ui::TransfersDialog ui;
|
||||
|
||||
|
||||
@ -1725,7 +1725,11 @@ void ChatWidget::quote()
|
||||
|
||||
void ChatWidget::dropPlacemark()
|
||||
{
|
||||
ui->textBrowser->append("----------");
|
||||
ui->textBrowser->moveCursor(QTextCursor::End); // *append* inserts text at end but with formatting in effect at
|
||||
ui->textBrowser->append("----------"); // current cursor position, such as in the middle of a hotlink,
|
||||
// which would be strange. This OTOH inserts text with
|
||||
// formatting in effect on the last line, which may be strange
|
||||
// or not.
|
||||
}
|
||||
|
||||
void ChatWidget::saveImage()
|
||||
|
||||
@ -10,6 +10,7 @@ SubscribeToolButton::SubscribeToolButton(QWidget *parent) :
|
||||
{
|
||||
mSubscribed = false;
|
||||
|
||||
mMenu = NULL ;
|
||||
setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
|
||||
|
||||
#ifdef USE_MENUBUTTONPOPUP
|
||||
@ -46,14 +47,18 @@ void SubscribeToolButton::updateUi()
|
||||
setIcon(QIcon(":/images/accepted16.png"));
|
||||
setText(tr("Subscribed"));
|
||||
|
||||
QMenu *menu = new QMenu;
|
||||
menu->addAction(QIcon(":/images/cancel.png"), tr("Unsubscribe"), this, SLOT(unsubscribePrivate()));
|
||||
if(mMenu != NULL) // that's because setMenu does not give away memory ownership
|
||||
delete mMenu ;
|
||||
|
||||
mMenu = new QMenu;
|
||||
mMenu->addAction(QIcon(":/images/cancel.png"), tr("Unsubscribe"), this, SLOT(unsubscribePrivate()));
|
||||
|
||||
if (!mSubscribedActions.empty()) {
|
||||
menu->addSeparator();
|
||||
menu->addActions(mSubscribedActions);
|
||||
mMenu->addSeparator();
|
||||
mMenu->addActions(mSubscribedActions);
|
||||
}
|
||||
setMenu(menu);
|
||||
|
||||
setMenu(mMenu);
|
||||
|
||||
#ifndef USE_MENUBUTTONPOPUP
|
||||
disconnect(this, SIGNAL(clicked()), this, SLOT(subscribePrivate()));
|
||||
|
||||
@ -26,6 +26,7 @@ private:
|
||||
private:
|
||||
bool mSubscribed;
|
||||
QList<QAction*> mSubscribedActions;
|
||||
QMenu *mMenu ;
|
||||
};
|
||||
|
||||
#endif // SUBSCRIBETOOLBUTTON_H
|
||||
|
||||
@ -259,7 +259,7 @@ void GraphWidget::keyPressEvent(QKeyEvent *event)
|
||||
}
|
||||
}
|
||||
|
||||
static void convolveWithGaussian(double *forceMap,int S,int /*s*/)
|
||||
static void convolveWithGaussian(double *forceMap,unsigned int S,int /*s*/)
|
||||
{
|
||||
static double *bf = NULL ;
|
||||
|
||||
@ -267,8 +267,8 @@ static void convolveWithGaussian(double *forceMap,int S,int /*s*/)
|
||||
{
|
||||
bf = new double[S*S*2] ;
|
||||
|
||||
for(int i=0;i<S;++i)
|
||||
for(int j=0;j<S;++j)
|
||||
for(unsigned int i=0;i<S;++i)
|
||||
for(unsigned int j=0;j<S;++j)
|
||||
{
|
||||
int x = (i<S/2)?i:(S-i) ;
|
||||
int y = (j<S/2)?j:(S-j) ;
|
||||
@ -284,8 +284,8 @@ static void convolveWithGaussian(double *forceMap,int S,int /*s*/)
|
||||
unsigned long nn[2] = {S,S};
|
||||
fourn(&forceMap[-1],&nn[-1],2,1) ;
|
||||
|
||||
for(int i=0;i<S;++i)
|
||||
for(int j=0;j<S;++j)
|
||||
for(unsigned int i=0;i<S;++i)
|
||||
for(unsigned int j=0;j<S;++j)
|
||||
{
|
||||
float a = forceMap[2*(i+S*j)]*bf[2*(i+S*j)] - forceMap[2*(i+S*j)+1]*bf[2*(i+S*j)+1] ;
|
||||
float b = forceMap[2*(i+S*j)]*bf[2*(i+S*j)+1] + forceMap[2*(i+S*j)+1]*bf[2*(i+S*j)] ;
|
||||
@ -296,7 +296,7 @@ static void convolveWithGaussian(double *forceMap,int S,int /*s*/)
|
||||
|
||||
fourn(&forceMap[-1],&nn[-1],2,-1) ;
|
||||
|
||||
for(int i=0;i<S*S*2;++i)
|
||||
for(unsigned int i=0;i<S*S*2;++i)
|
||||
forceMap[i] /= S*S;
|
||||
}
|
||||
|
||||
|
||||
@ -362,21 +362,21 @@ Rshare::showUsageMessageBox()
|
||||
out << "<table>";
|
||||
//out << trow(tcol("-"ARG_HELP) +
|
||||
// tcol(tr("Displays this usage message and exits.")));
|
||||
out << trow(tcol("-"ARG_RESET) +
|
||||
out << trow(tcol("-" ARG_RESET) +
|
||||
tcol(tr("Resets ALL stored RetroShare settings.")));
|
||||
out << trow(tcol("-"ARG_DATADIR" <dir>") +
|
||||
out << trow(tcol("-" ARG_DATADIR" <dir>") +
|
||||
tcol(tr("Sets the directory RetroShare uses for data files.")));
|
||||
out << trow(tcol("-"ARG_LOGFILE" <file>") +
|
||||
out << trow(tcol("-" ARG_LOGFILE" <file>") +
|
||||
tcol(tr("Sets the name and location of RetroShare's logfile.")));
|
||||
out << trow(tcol("-"ARG_LOGLEVEL" <level>") +
|
||||
out << trow(tcol("-" ARG_LOGLEVEL" <level>") +
|
||||
tcol(tr("Sets the verbosity of RetroShare's logging.") +
|
||||
"<br>[" + Log::logLevels().join("|") +"]"));
|
||||
out << trow(tcol("-"ARG_GUISTYLE" <style>") +
|
||||
out << trow(tcol("-" ARG_GUISTYLE" <style>") +
|
||||
tcol(tr("Sets RetroShare's interface style.") +
|
||||
"<br>[" + QStyleFactory::keys().join("|") + "]"));
|
||||
out << trow(tcol("-"ARG_GUISTYLESHEET" <stylesheet>") +
|
||||
out << trow(tcol("-" ARG_GUISTYLESHEET" <stylesheet>") +
|
||||
tcol(tr("Sets RetroShare's interface stylesheets.")));
|
||||
out << trow(tcol("-"ARG_LANGUAGE" <language>") +
|
||||
out << trow(tcol("-" ARG_LANGUAGE" <language>") +
|
||||
tcol(tr("Sets RetroShare's language.") +
|
||||
"<br>[" + LanguageSupport::languageCodes().join("|") + "]"));
|
||||
out << "</table>";
|
||||
|
||||
@ -17,6 +17,10 @@
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
||||
* Boston, MA 02110-1301, USA.
|
||||
*
|
||||
* ccr . 2016 Jan 30 . Change regular expression(s) for identifying
|
||||
* . . hotlinks in feral text.
|
||||
*
|
||||
****************************************************************/
|
||||
|
||||
#include <QApplication>
|
||||
@ -56,7 +60,7 @@ protected:
|
||||
|
||||
public:
|
||||
const EmbeddedType myType;
|
||||
QRegExp myRE;
|
||||
QList<QRegExp> myREs;
|
||||
};
|
||||
|
||||
/**
|
||||
@ -67,10 +71,42 @@ class EmbedInHtmlAhref : public EmbedInHtml
|
||||
public:
|
||||
EmbedInHtmlAhref() : EmbedInHtml(Ahref)
|
||||
{
|
||||
myRE.setPattern("(\\bretroshare://[^\\s]*)|(\\bhttps?://[^\\s]*)|(\\bfile://[^\\s]*)|(\\bwww\\.[^\\s]*)");
|
||||
// myRE.setPattern("(\\bretroshare://[^\\s]*)|(\\bhttps?://[^\\s]*)|(\\bfile://[^\\s]*)|(\\bwww\\.[^\\s]*)");
|
||||
|
||||
// The following regular expressions for finding URLs in
|
||||
// plain text are borrowed from *gnome-terminal*:
|
||||
|
||||
QString regPassCharset = "[-\\w,?;\\.:/!%$^*&~\\\"#']";
|
||||
QString regHost = "[-\\w]+(\\.[-\\w]+)*";
|
||||
QString regPort = "(?:\\:\\d{1,5})?";
|
||||
QString regPathCharset = "[-\\w_$\\.+!*,;@&=?/~#%]";
|
||||
QString regPathTermSet = "[^\\]'.}<>) \\t\\r\\n,\\\"]";
|
||||
QStringList regSchemes;
|
||||
// regSchemes.append("news:");
|
||||
// regSchemes.append("telnet:");
|
||||
// regSchemes.append("nntp:");
|
||||
// regSchemes.append("file:/");
|
||||
regSchemes.append("https?:");
|
||||
// regSchemes.append("ftps?:");
|
||||
// regSchemes.append("sftp:");
|
||||
// regSchemes.append("webcal:");
|
||||
regSchemes.append("retroshare:");
|
||||
QString regScheme = "((?:" + regSchemes.join(")|(?:") + "))";
|
||||
QString regUserPass = "[-\\w]+(?:%s+)?" % regPassCharset;
|
||||
QString regUrlPath = "(?:(/" + regPathCharset + "+(?:[(]" + regPathCharset +"*[)])*" + regPathCharset + "*)*" + regPathTermSet + ")?";
|
||||
QStringList regHotLinkFinders;
|
||||
regHotLinkFinders.append(regScheme + "//(?:" + regUserPass + "@)?"+ regHost + regPort + regUrlPath);
|
||||
// regHotLinkFinders.append("(?:(?:www)|(?:ftp))[-\\w]*\\." + regHost + regPort + regUrlPath);
|
||||
// regHotLinkFinders.append("(?:(?:callto:)|(?:h323:)|(?:sip:))[-\\w][-\\w\\.]*(?:" + regPort + "/[a-z0-9]+)?@" + regHost);
|
||||
// regHotLinkFinders.append("(?:mailto:)?[-\\w][-\\w\\.]*@[-\\w]+\\." + regHost);
|
||||
// regHotLinkFinders.append("news:[\\w^_{|}~!\\\"#$%&'()*+,\\./;:=?`]+");
|
||||
while (!regHotLinkFinders.isEmpty()) {
|
||||
myREs.append(QRegExp(regHotLinkFinders.takeFirst(), Qt::CaseInsensitive));
|
||||
};
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* This class is used to store information for embedding smileys into <img/> tags.
|
||||
*
|
||||
@ -134,7 +170,7 @@ void RsHtml::initEmoticons(const QHash< QString, QString >& hash)
|
||||
*/
|
||||
}
|
||||
newRE.chop(1); // remove last |
|
||||
defEmbedImg.myRE.setPattern(newRE);
|
||||
defEmbedImg.myREs.append(QRegExp(newRE));
|
||||
}
|
||||
|
||||
bool RsHtml::canReplaceAnchor(QDomDocument &/*doc*/, QDomElement &/*element*/, const RetroShareLink &link)
|
||||
@ -243,7 +279,7 @@ void RsHtml::replaceAnchorWithImg(QDomDocument &doc, QDomElement &element, QText
|
||||
* nodes. Any other kind of node is terminal.
|
||||
*
|
||||
* If the node is of type Text, its data is checked against the user-provided
|
||||
* regular expression. If there is a match, the text is cut in three parts: the
|
||||
* regular expression(s). If there is a match, the text is cut in three parts: the
|
||||
* preceding part that will be inserted before, the part to be replaced, and the
|
||||
* following part which will be itself checked against the regular expression.
|
||||
*
|
||||
@ -252,13 +288,10 @@ void RsHtml::replaceAnchorWithImg(QDomDocument &doc, QDomElement &element, QText
|
||||
*
|
||||
* @param[in] doc The whole DOM tree, necessary to create new nodes
|
||||
* @param[in,out] currentElement The current node (which is of type Element)
|
||||
* @param[in] embedInfos The regular expression and the type of embedding to use
|
||||
* @param[in] embedInfos The regular expression(s) and the type of embedding to use
|
||||
*/
|
||||
void RsHtml::embedHtml(QTextDocument *textDocument, QDomDocument& doc, QDomElement& currentElement, EmbedInHtml& embedInfos, ulong flag)
|
||||
{
|
||||
if(embedInfos.myRE.pattern().length() == 0) // we'll get stuck with an empty regexp
|
||||
return;
|
||||
|
||||
QDomNodeList children = currentElement.childNodes();
|
||||
for(uint index = 0; index < (uint)children.length(); index++) {
|
||||
QDomNode node = children.item(index);
|
||||
@ -300,13 +333,18 @@ void RsHtml::embedHtml(QTextDocument *textDocument, QDomDocument& doc, QDomEleme
|
||||
else if(node.isText()) {
|
||||
// child is a text, we parse it
|
||||
QString tempText = node.toText().data();
|
||||
if(embedInfos.myRE.indexIn(tempText) == -1)
|
||||
for (int patNdx = 0; patNdx < embedInfos.myREs.size(); ++patNdx) {
|
||||
QRegExp myRE = embedInfos.myREs.at(patNdx);
|
||||
if(myRE.pattern().length() == 0) // we'll get stuck with an empty regexp
|
||||
return;
|
||||
|
||||
if(myRE.indexIn(tempText) == -1)
|
||||
continue;
|
||||
|
||||
// there is at least one link inside, we start replacing
|
||||
int currentPos = 0;
|
||||
int nextPos = 0;
|
||||
while((nextPos = embedInfos.myRE.indexIn(tempText, currentPos)) != -1) {
|
||||
while((nextPos = myRE.indexIn(tempText, currentPos)) != -1) {
|
||||
// if nextPos == 0 it means the text begins by a link
|
||||
if(nextPos > 0) {
|
||||
QDomText textPart = doc.createTextNode(tempText.mid(currentPos, nextPos - currentPos));
|
||||
@ -320,10 +358,10 @@ void RsHtml::embedHtml(QTextDocument *textDocument, QDomDocument& doc, QDomEleme
|
||||
case Ahref:
|
||||
{
|
||||
insertedTag = doc.createElement("a");
|
||||
insertedTag.setAttribute("href", embedInfos.myRE.cap(0));
|
||||
insertedTag.appendChild(doc.createTextNode(embedInfos.myRE.cap(0)));
|
||||
insertedTag.setAttribute("href", myRE.cap(0));
|
||||
insertedTag.appendChild(doc.createTextNode(myRE.cap(0)));
|
||||
|
||||
RetroShareLink link(embedInfos.myRE.cap(0));
|
||||
RetroShareLink link(myRE.cap(0));
|
||||
if (link.valid()) {
|
||||
QString title = link.title();
|
||||
if (!title.isEmpty()) {
|
||||
@ -340,11 +378,11 @@ void RsHtml::embedHtml(QTextDocument *textDocument, QDomDocument& doc, QDomEleme
|
||||
{
|
||||
insertedTag = doc.createElement("img");
|
||||
const EmbedInHtmlImg& embedImg = static_cast<const EmbedInHtmlImg&>(embedInfos);
|
||||
// embedInfos.myRE.cap(0) may include spaces at the end/beginning -> trim!
|
||||
insertedTag.setAttribute("src", embedImg.smileys[embedInfos.myRE.cap(0).trimmed()]);
|
||||
// myRE.cap(0) may include spaces at the end/beginning -> trim!
|
||||
insertedTag.setAttribute("src", embedImg.smileys[myRE.cap(0).trimmed()]);
|
||||
/*
|
||||
* NOTE
|
||||
* Trailing spaces are matched, too. This leads to embedInfos.myRE.matchedLength() being incorrect.
|
||||
* Trailing spaces are matched, too. This leads to myRE.matchedLength() being incorrect.
|
||||
* This hack reduces nextPos by one so that the new value of currentPos is calculated corretly.
|
||||
* This is needed to match multiple smileys since the leading whitespace in front of a smiley is required!
|
||||
*
|
||||
@ -353,7 +391,7 @@ void RsHtml::embedHtml(QTextDocument *textDocument, QDomDocument& doc, QDomEleme
|
||||
* NOTE
|
||||
* Preceding spaces are also matched and removed.
|
||||
*/
|
||||
if(embedInfos.myRE.cap(0).endsWith(' '))
|
||||
if(myRE.cap(0).endsWith(' '))
|
||||
nextPos--;
|
||||
}
|
||||
break;
|
||||
@ -362,7 +400,7 @@ void RsHtml::embedHtml(QTextDocument *textDocument, QDomDocument& doc, QDomEleme
|
||||
currentElement.insertBefore(insertedTag, node);
|
||||
index++;
|
||||
|
||||
currentPos = nextPos + embedInfos.myRE.matchedLength();
|
||||
currentPos = nextPos + myRE.matchedLength();
|
||||
}
|
||||
|
||||
// text after the last link, only if there's one, don't touch the index
|
||||
@ -375,10 +413,18 @@ void RsHtml::embedHtml(QTextDocument *textDocument, QDomDocument& doc, QDomEleme
|
||||
index--;
|
||||
|
||||
currentElement.removeChild(node);
|
||||
break;
|
||||
// We'd better not expect that
|
||||
// subsequent hotlink patterns
|
||||
// wouldn't also match replacements
|
||||
// we've already made. They might, so
|
||||
// skip 'em to be safe.
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Save space and tab out of bracket that XML loose.
|
||||
*
|
||||
@ -612,7 +658,7 @@ static void findBestColor(QString &val, qreal bglum, qreal desiredContrast)
|
||||
*/
|
||||
static void optimizeHtml(QDomDocument& doc
|
||||
, QDomElement& currentElement
|
||||
, QHash<QString, QStringList*> &stylesList
|
||||
, QHash<QString, QStringList> &stylesList
|
||||
, QHash<QString, QString> &knownStyle)
|
||||
{
|
||||
if (doc.documentElement().namedItem("style").toElement().attributeNode("RSOptimized").isAttr()) {
|
||||
@ -631,10 +677,10 @@ static void optimizeHtml(QDomDocument& doc
|
||||
QString keyvalue = pair.at(1);
|
||||
keyvalue.replace(";","");
|
||||
QStringList classUsingIt(pair.at(0).split(','));
|
||||
QStringList* exported = new QStringList();
|
||||
QStringList exported ;
|
||||
foreach (QString keyVal, classUsingIt) {
|
||||
if(!keyVal.trimmed().isEmpty()) {
|
||||
exported->append(keyVal.trimmed().replace(".",""));
|
||||
exported.append(keyVal.trimmed().replace(".",""));
|
||||
}
|
||||
}
|
||||
|
||||
@ -759,14 +805,10 @@ static void optimizeHtml(QDomDocument& doc
|
||||
foreach (QString pair, styles) {
|
||||
pair.replace(" ","");
|
||||
if (!pair.isEmpty()) {
|
||||
QStringList* stylesListItem = stylesList.value(pair);
|
||||
if(!stylesListItem){
|
||||
// If value doesn't exist create it
|
||||
stylesListItem = new QStringList();
|
||||
stylesList.insert(pair, stylesListItem);
|
||||
}
|
||||
QStringList& stylesListItem = stylesList[pair];
|
||||
|
||||
//Add the new class to this value
|
||||
stylesListItem->push_back(className);
|
||||
stylesListItem.push_back(className);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -800,7 +842,7 @@ static void optimizeHtml(QDomDocument& doc
|
||||
* @param desiredMinimumFontSize: Minimum font size.
|
||||
*/
|
||||
static void styleCreate(QDomDocument& doc
|
||||
, QHash<QString, QStringList*> stylesList
|
||||
, QHash<QString, QStringList>& stylesList
|
||||
, unsigned int flag
|
||||
, qreal bglum
|
||||
, qreal desiredContrast
|
||||
@ -840,12 +882,12 @@ static void styleCreate(QDomDocument& doc
|
||||
|
||||
QString style = "";
|
||||
|
||||
QHashIterator<QString, QStringList*> it(stylesList);
|
||||
QHashIterator<QString, QStringList> it(stylesList);
|
||||
while(it.hasNext()) {
|
||||
it.next();
|
||||
QStringList* classUsingIt = it.value();
|
||||
const QStringList& classUsingIt ( it.value()) ;
|
||||
bool first = true;
|
||||
foreach(QString className, *classUsingIt) {
|
||||
foreach(QString className, classUsingIt) {
|
||||
if (!className.trimmed().isEmpty()) {
|
||||
style += QString(first?".":",.") + className;// + " ";
|
||||
first = false;
|
||||
@ -961,7 +1003,8 @@ void RsHtml::optimizeHtml(QString &text, unsigned int flag /*= 0*/
|
||||
}
|
||||
|
||||
QDomElement body = doc.documentElement();
|
||||
QHash<QString, QStringList*> stylesList;
|
||||
|
||||
QHash<QString, QStringList> stylesList;
|
||||
QHash<QString, QString> knownStyle;
|
||||
|
||||
::optimizeHtml(doc, body, stylesList, knownStyle);
|
||||
|
||||
@ -86,11 +86,8 @@ int main(int argc, char **argv)
|
||||
// unfinished
|
||||
//args >> parameter("http-listen", listenAddress, "ipv6 address", "Listen only on the specified address.", false);
|
||||
args >> option("http-allow-all", allowAllIps, "allow connections from all IP adresses (default= localhost only)");
|
||||
#ifdef __APPLE__
|
||||
args >> help('h',"help","Display this Help");
|
||||
#else
|
||||
args >> help();
|
||||
#endif
|
||||
|
||||
if (args.helpRequested())
|
||||
{
|
||||
std::cerr << args.usage() << std::endl;
|
||||
|
||||
Loading…
Reference in New Issue
Block a user