Git-Mirrors/RetroShare
1
0
Fork 0
mirror of https://github.com/RetroShare/RetroShare.git synced 2024-10-01 02:35:48 -04:00
Code Issues Actions Packages Projects Releases Wiki Activity

merged with upstream head

Browse Source
This commit is contained in:
csoler 2015-10-25 20:42:41 -04:00
commit f24bddf6f1
204 changed files with 9044 additions and 6814 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.travis.yml
View File

@ -7,7 +7,7 @@ before_install:
- echo $LANG - echo $LANG
- echo $LC_ALL - echo $LC_ALL
- sudo apt-get update - sudo apt-get update
- sudo apt-get install build-essential checkinstall cmake g++ git libavcodec-dev libavformat-dev libbz2-dev libcurl4-openssl-dev libdc1394-22-dev libglib2.0-dev libcv-dev libopencv-highgui-dev libhighgui-dev - sudo apt-get install build-essential checkinstall cmake g++ git libavutil-dev libavcodec-dev libavformat-dev libbz2-dev libcurl4-openssl-dev libdc1394-22-dev libglib2.0-dev libcv-dev libopencv-highgui-dev libhighgui-dev
- sudo apt-get install libgnome-keyring-dev libgstreamer-plugins-base0.10-dev libgstreamer0.10-dev libjasper-dev libjpeg-dev libmicrohttpd-dev libopencv-dev libprotobuf-dev libqt4-dev - sudo apt-get install libgnome-keyring-dev libgstreamer-plugins-base0.10-dev libgstreamer0.10-dev libjasper-dev libjpeg-dev libmicrohttpd-dev libopencv-dev libprotobuf-dev libqt4-dev
- sudo apt-get install libspeex-dev libspeexdsp-dev libsqlite3-dev libssl-dev libswscale-dev - sudo apt-get install libspeex-dev libspeexdsp-dev libsqlite3-dev libssl-dev libswscale-dev
- sudo apt-get install libtbb-dev libtiff4-dev libupnp-dev libv4l-dev libxine-dev libxslt1-dev libxss-dev make pkg-config protobuf-compiler python-dev python-numpy subversion git yasm qtmobility-dev - sudo apt-get install libtbb-dev libtiff4-dev libupnp-dev libv4l-dev libxine-dev libxslt1-dev libxss-dev make pkg-config protobuf-compiler python-dev python-numpy subversion git yasm qtmobility-dev

11
RetroShare.pro
View File

@ -7,7 +7,6 @@ SUBDIRS += \
libbitdht \ libbitdht \
libretroshare \ libretroshare \
libresapi \ libresapi \
pegmarkdown \
retroshare_gui \ retroshare_gui \
retroshare_nogui \ retroshare_nogui \
plugins plugins
@ -22,10 +21,8 @@ libretroshare.depends = openpgpsdk libbitdht
libresapi.file = libresapi/src/libresapi.pro libresapi.file = libresapi/src/libresapi.pro
libresapi.depends = libretroshare libresapi.depends = libretroshare
pegmarkdown.file = supportlibs/pegmarkdown/pegmarkdown.pro
retroshare_gui.file = retroshare-gui/src/retroshare-gui.pro retroshare_gui.file = retroshare-gui/src/retroshare-gui.pro
retroshare_gui.depends = libretroshare libresapi pegmarkdown retroshare_gui.depends = libretroshare libresapi
retroshare_gui.target = retroshare-gui retroshare_gui.target = retroshare-gui
retroshare_nogui.file = retroshare-nogui/src/retroshare-nogui.pro retroshare_nogui.file = retroshare-nogui/src/retroshare-nogui.pro
@ -35,3 +32,9 @@ retroshare_nogui.target = retroshare-nogui
plugins.file = plugins/plugins.pro plugins.file = plugins/plugins.pro
plugins.depends = retroshare_gui plugins.depends = retroshare_gui
plugins.target = plugins plugins.target = plugins
wikipoos {
SUBDIRS += pegmarkdown
pegmarkdown.file = supportlibs/pegmarkdown/pegmarkdown.pro
retroshare_gui.depends += pegmarkdown
}

242
build_scripts/Debian+Ubuntu/changelog
View File

@ -1,5 +1,243 @@
retroshare06 (0.6.0-1.XXXXXX~YYYYYY) YYYYYY; urgency=low retroshare06 (0.6.0-1.XXXXXX~YYYYYY) YYYYYY; urgency=low
0120234 csoler 12 Oct 2015 15:06:12 -0400 Merge pull request #143 from csoler/v0.6-Reputations
71c8dfd csoler 12 Oct 2015 14:45:11 -0400 manual merge before creating a conflict-free PR
f18cc82 csoler 12 Oct 2015 14:22:51 -0400 fixed up constants for reputation system, now that is has been tested
e6bb307 csoler 12 Oct 2015 14:04:23 -0400 added update for forum messages list when an author gets banned
7dc5984 csoler 12 Oct 2015 14:03:53 -0400 added update for forum messages list when an author gets banned
022ac10 defnax 12 Oct 2015 18:58:12 +0200 Merge pull request #141 from PhenomRetroShare/AddVOIP_ReactivateSoundEvents
3d32fab Phenom 12 Oct 2015 18:25:03 +0200 Reactivate SoundEvents in VOIP.
86b47d8 csoler 12 Oct 2015 10:58:24 -0400 reduced icon size a little bit in GxsTreeWidgetItem
5a3756f csoler 12 Oct 2015 10:41:48 -0400 fixed bug on reputation cutoff. Updated tooltips
36101a9 csoler 12 Oct 2015 00:28:21 -0400 fixed small bug preventing msg exchange
82c16c6 csoler 11 Oct 2015 22:08:19 -0400 fixed GUI tooltips over banned items. Added dropping of messages from banned ide
1a76bea csoler 11 Oct 2015 21:41:35 -0400 enabled bannign button in forums, and disable message passing for banned users
ad4dabf csoler 11 Oct 2015 13:31:54 -0400 Merge pull request #140 from PhenomRetroShare/AddVOIP_Accept,RingAndHangUp
ebe48f4 csoler 11 Oct 2015 11:12:11 -0400 added proper memory release after mallocs in distant chat (SVN bug 383)
e309dd6 csoler 11 Oct 2015 10:00:11 -0400 fixed banning users from forum threads
6a3f4ce Phenom 11 Oct 2015 10:31:06 +0200 Update Toaster when ringing.
f750818 csoler 10 Oct 2015 21:25:06 -0400 added proper icons and names for banned users
68ca57c csoler 10 Oct 2015 18:27:15 -0400 added removal of messages frm banned users
3deee00 Phenom 10 Oct 2015 18:47:07 +0200 Hang Up when close chat window.
1989f36 Phenom 10 Oct 2015 15:21:59 +0200 Add Accept, Ring and HangUp event for Video and Audio. Now you don't send data b
1a229ef defnax 10 Oct 2015 14:16:12 +0200 Fixed to display GXS ID item with a better icon size
59d2ca9 csoler 9 Oct 2015 18:55:07 -0400 fixed bug causing uninitialised friend average reputation to be shown
338fcee csoler 9 Oct 2015 18:51:16 -0400 added button in forums to flag poster identity as bad
ce96e88 csoler 9 Oct 2015 17:51:10 -0400 debugging of reputation system
ffb8f73 defnax 9 Oct 2015 12:07:23 +0200 Merge branch 'master' of https://github.com/RetroShare/RetroShare
e97f23d defnax 9 Oct 2015 12:06:16 +0200 Improved icon size display on GroupTree.
bb7a8f2 csoler 8 Oct 2015 23:54:18 -0400 fixed some reputation sending bugs
8c6c934 csoler 8 Oct 2015 23:02:34 -0400 fixed a few bugs in reputation items serialisation code and GUI display
1cf9c34 csoler 8 Oct 2015 19:48:22 -0400 fixed compilation for MacOS
4a4625e csoler 8 Oct 2015 18:54:12 -0400 fixed compilation for windows (to be tested)
3d21d99 csoler 8 Oct 2015 18:39:50 -0400 added debug info for reputation system
80ed6d1 csoler 7 Oct 2015 23:44:24 -0400 added pruning of opinions to limit data in memory. Fixed up types and sending/rec
e776eff csoler 7 Oct 2015 21:24:31 -0400 added new method rsGetHostByName to use gethostbyname_r for re-entrant calls. Upd
f1f722a csoler 7 Oct 2015 19:08:35 -0400 added missing shutdown of non responsive socket that could leak FDs (suggested by
39672b2 csoler 7 Oct 2015 18:59:58 -0400 fixed typo causing non free of mutex_buf structure in pqissl.cc
3cbf0f6 defnax 7 Oct 2015 20:13:18 +0200 Fixed Cert Display on Email Invite Page
78e6f67 csoler 6 Oct 2015 23:56:39 -0400 added some documentation in p3gxsreputation.cc, and the method for computing fina
b094089 csoler 6 Oct 2015 22:39:14 -0400 fixed compilation
95bdd7f defnax 7 Oct 2015 01:35:31 +0200 Fixed ChatWidget Margin's Set Alignment for frame off's Video icon
993ca63 defnax 6 Oct 2015 19:58:42 +0200 Fixed icons display
3f116e2 defnax 6 Oct 2015 18:54:43 +0200 display voip icons in a bigger size
fedb8f7 csoler 6 Oct 2015 09:47:54 -0400 Merge pull request #129 from PhenomRetroShare/FixVOIP_AllowVOIPToSaveSetting
ff46d90 csoler 6 Oct 2015 08:58:30 -0400 Merge pull request #120 from PhenomRetroShare/AddVOIP_HideChatTextButton
9f6bc0c csoler 6 Oct 2015 00:11:18 -0400 added code for all reputation items
05d95d3 Phenom 5 Oct 2015 21:04:20 +0200 Use QFontMetricsF to define Icon size.
2b1d39c Phenom 4 Oct 2015 14:12:20 +0200 Add HideChat Button. Change layout of video when text is hidden. Add toolbar in f
5d8972e Phenom 3 Oct 2015 02:11:52 +0200 Add real FullScreen Mode
0120234 csoler 12 Oct 2015 15:06:12 -0400 Merge pull request #143 from csoler/v0.6-Reputations
71c8dfd csoler 12 Oct 2015 14:45:11 -0400 manual merge before creating a conflict-free PR
f18cc82 csoler 12 Oct 2015 14:22:51 -0400 fixed up constants for reputation system, now that is has been tested
e6bb307 csoler 12 Oct 2015 14:04:23 -0400 added update for forum messages list when an author gets banned
7dc5984 csoler 12 Oct 2015 14:03:53 -0400 added update for forum messages list when an author gets banned
022ac10 defnax 12 Oct 2015 18:58:12 +0200 Merge pull request #141 from PhenomRetroShare/AddVOIP_ReactivateSoundEvents
3d32fab Phenom 12 Oct 2015 18:25:03 +0200 Reactivate SoundEvents in VOIP.
86b47d8 csoler 12 Oct 2015 10:58:24 -0400 reduced icon size a little bit in GxsTreeWidgetItem
5a3756f csoler 12 Oct 2015 10:41:48 -0400 fixed bug on reputation cutoff. Updated tooltips
36101a9 csoler 12 Oct 2015 00:28:21 -0400 fixed small bug preventing msg exchange
82c16c6 csoler 11 Oct 2015 22:08:19 -0400 fixed GUI tooltips over banned items. Added dropping of messages from banned ide
1a76bea csoler 11 Oct 2015 21:41:35 -0400 enabled bannign button in forums, and disable message passing for banned users
ad4dabf csoler 11 Oct 2015 13:31:54 -0400 Merge pull request #140 from PhenomRetroShare/AddVOIP_Accept,RingAndHangUp
ebe48f4 csoler 11 Oct 2015 11:12:11 -0400 added proper memory release after mallocs in distant chat (SVN bug 383)
e309dd6 csoler 11 Oct 2015 10:00:11 -0400 fixed banning users from forum threads
6a3f4ce Phenom 11 Oct 2015 10:31:06 +0200 Update Toaster when ringing.
f750818 csoler 10 Oct 2015 21:25:06 -0400 added proper icons and names for banned users
68ca57c csoler 10 Oct 2015 18:27:15 -0400 added removal of messages frm banned users
3deee00 Phenom 10 Oct 2015 18:47:07 +0200 Hang Up when close chat window.
1989f36 Phenom 10 Oct 2015 15:21:59 +0200 Add Accept, Ring and HangUp event for Video and Audio. Now you don't send data b
1a229ef defnax 10 Oct 2015 14:16:12 +0200 Fixed to display GXS ID item with a better icon size
59d2ca9 csoler 9 Oct 2015 18:55:07 -0400 fixed bug causing uninitialised friend average reputation to be shown
338fcee csoler 9 Oct 2015 18:51:16 -0400 added button in forums to flag poster identity as bad
ce96e88 csoler 9 Oct 2015 17:51:10 -0400 debugging of reputation system
ffb8f73 defnax 9 Oct 2015 12:07:23 +0200 Merge branch 'master' of https://github.com/RetroShare/RetroShare
e97f23d defnax 9 Oct 2015 12:06:16 +0200 Improved icon size display on GroupTree.
bb7a8f2 csoler 8 Oct 2015 23:54:18 -0400 fixed some reputation sending bugs
8c6c934 csoler 8 Oct 2015 23:02:34 -0400 fixed a few bugs in reputation items serialisation code and GUI display
1cf9c34 csoler 8 Oct 2015 19:48:22 -0400 fixed compilation for MacOS
4a4625e csoler 8 Oct 2015 18:54:12 -0400 fixed compilation for windows (to be tested)
3d21d99 csoler 8 Oct 2015 18:39:50 -0400 added debug info for reputation system
80ed6d1 csoler 7 Oct 2015 23:44:24 -0400 added pruning of opinions to limit data in memory. Fixed up types and sending/rec
e776eff csoler 7 Oct 2015 21:24:31 -0400 added new method rsGetHostByName to use gethostbyname_r for re-entrant calls. Upd
f1f722a csoler 7 Oct 2015 19:08:35 -0400 added missing shutdown of non responsive socket that could leak FDs (suggested by
39672b2 csoler 7 Oct 2015 18:59:58 -0400 fixed typo causing non free of mutex_buf structure in pqissl.cc
3cbf0f6 defnax 7 Oct 2015 20:13:18 +0200 Fixed Cert Display on Email Invite Page
78e6f67 csoler 6 Oct 2015 23:56:39 -0400 added some documentation in p3gxsreputation.cc, and the method for computing fina
b094089 csoler 6 Oct 2015 22:39:14 -0400 fixed compilation
95bdd7f defnax 7 Oct 2015 01:35:31 +0200 Fixed ChatWidget Margin's Set Alignment for frame off's Video icon
993ca63 defnax 6 Oct 2015 19:58:42 +0200 Fixed icons display
3f116e2 defnax 6 Oct 2015 18:54:43 +0200 display voip icons in a bigger size
fedb8f7 csoler 6 Oct 2015 09:47:54 -0400 Merge pull request #129 from PhenomRetroShare/FixVOIP_AllowVOIPToSaveSetting
ff46d90 csoler 6 Oct 2015 08:58:30 -0400 Merge pull request #120 from PhenomRetroShare/AddVOIP_HideChatTextButton
9f6bc0c csoler 6 Oct 2015 00:11:18 -0400 added code for all reputation items
05d95d3 Phenom 5 Oct 2015 21:04:20 +0200 Use QFontMetricsF to define Icon size.
2b1d39c Phenom 4 Oct 2015 14:12:20 +0200 Add HideChat Button. Change layout of video when text is hidden. Add toolbar in f
5d8972e Phenom 3 Oct 2015 02:11:52 +0200 Add real FullScreen Mode
8a7e359 Phenom 1 Oct 2015 23:41:34 +0200 Add a button on VOIP to hide text when video is on.
3c8f232 Phenom 5 Oct 2015 19:15:53 +0200 Allow VOIP to save its settings.
d4c838b csoler 5 Oct 2015 08:51:33 -0400 Merge pull request #127 from sehraf/pr-disable-sorting
6a570af sehraf 5 Oct 2015 09:26:36 +0200 disable sorting while editing network view
7a7f4c9 csoler 4 Oct 2015 23:18:31 -0400 added missing file
317e7ea csoler 4 Oct 2015 23:14:49 -0400 added some backend for reputation system
c17dddb csoler 4 Oct 2015 17:47:30 -0400 updated GUI for reputation
b5bfddd csoler 3 Oct 2015 22:08:24 -0400 commit from PR#86 for VOIP, modified so as to restore real-time preview and video
9158ed6 csoler 3 Oct 2015 10:46:36 -0400 fixed potential buffer overrun (reported by GuessWho)
7fa687a csoler 3 Oct 2015 10:29:08 -0400 Merge pull request #119 from PhenomRetroShare/AddWebUI_BroadcastInLobbiesLis
b22069c csoler 3 Oct 2015 10:28:17 -0400 Merge pull request #123 from PhenomRetroShare/Fix_ChatWidgetDeleteKeyEvent
64389e3 Phenom 3 Oct 2015 11:00:16 +0200 Fiw Delete key event in ChatWidget.
904ea94 Phenom 2 Oct 2015 19:10:54 +0200 Remove (void)
986853d Phenom 1 Oct 2015 18:49:39 +0200 Add Broadcast in list of lobbies. Before you can only write text on it if unread
b055500 csoler 2 Oct 2015 11:03:52 -0400 Merge pull request #117 from G10h4ck/master
bd94fcd csoler 2 Oct 2015 10:53:00 -0400 Merge pull request #98 from PhenomRetroShare/AddMinimumFontSizeInChat
f6abe2f csoler 2 Oct 2015 10:50:14 -0400 Merge pull request #115 from PhenomRetroShare/AddWebUI_LobbyOrderByType
e83ae76 Gio 27 Sep 2015 20:15:41 +0200 pqiconnect remove ni NULL pointer check as it would crash anyway for null pointer d
28b9a44 Gio 27 Sep 2015 15:29:32 +0200 Write in a sane way pqissl::connect_parameter
b16ecc8 Gio 27 Sep 2015 15:11:55 +0200 Remove some garbage from pqissl
d6ba9a2 Phenom 25 Sep 2015 17:00:50 +0200 Order in WebUI Lobbies by first: auto_subscribe, is_private and then subscribed
3025f4d csoler 24 Sep 2015 18:18:11 -0400 removed aliasign problem that breaks compilation on gentoo
22d4893 csoler 24 Sep 2015 18:03:19 -0400 removed a few compilation warning that might cause compilation errors on some sy
0614a24 csoler 23 Sep 2015 22:11:50 -0400 Merge pull request #111 from csoler/v0.6-ImprovedExtIPDetermination
24b3325 csoler 23 Sep 2015 21:45:15 -0400 Improved reliability of the determination of external address: removed DHT stunn
323d894 csoler 22 Sep 2015 23:21:14 -0400 Merge pull request #110 from jenster/newbranchformychanges
68fd1b2 jenster 22 Sep 2015 18:33:16 -0700 First Mac/OSX compile fixes
6071be9 csoler 22 Sep 2015 11:20:28 -0400 Merge pull request #109 from AsamK/workaround_broken_sqlcipher
c80ad59 AsamK 22 Sep 2015 16:31:21 +0200 Add workaround for broken sqlcipher packages
7293cd3 csoler 21 Sep 2015 22:58:58 -0400 updated ubuntu changelog
1d54630 thunder2 17 Sep 2015 10:05:31 +0200 Fixed Windows compile.
66691d4 csoler 16 Sep 2015 20:01:39 -0400 Merge pull request #108 from sehraf/i2p
04abfad sehraf 16 Sep 2015 17:01:20 +0200 manually reverted changes by Qt Creator
7c7e4f8 sehraf 16 Sep 2015 12:13:54 +0200 added ip addr. field to the add certificate dialog
6202e83 sehraf 16 Sep 2015 11:48:32 +0200 add default case to gui instead of falling back to tor labeling
d3d184f sehraf 16 Sep 2015 11:09:04 +0200 added simple step-by-step guide to add a I2P server tunnel
e54358a sehraf 16 Sep 2015 10:55:33 +0200 added simple step-by-step guide to add a I2P client tunnel
1dd3375 sehraf 15 Sep 2015 17:14:55 +0200 hide debug output
d24b281 sehraf 15 Sep 2015 17:10:48 +0200 optimizations * reduced calls to mPeermgr * use switch convenience * small fixes
bfcf43f sehraf 15 Sep 2015 16:18:46 +0200 fixed connection type detection and other small things
8725aab sehraf 14 Sep 2015 15:14:39 +0200 gui fixes
6b87c38 sehraf 14 Sep 2015 14:56:14 +0200 small fixes
6ec1919 sehraf 14 Sep 2015 12:39:46 +0200 gui changes
b0251e3 sehraf 14 Sep 2015 12:12:28 +0200 generalized tooltips
4b19e73 sehraf 14 Sep 2015 09:56:43 +0200 added comments to functions
8a7e359 Phenom 1 Oct 2015 23:41:34 +0200 Add a button on VOIP to hide text when video is on.
3c8f232 Phenom 5 Oct 2015 19:15:53 +0200 Allow VOIP to save its settings.
d4c838b csoler 5 Oct 2015 08:51:33 -0400 Merge pull request #127 from sehraf/pr-disable-sorting
6a570af sehraf 5 Oct 2015 09:26:36 +0200 disable sorting while editing network view
7a7f4c9 csoler 4 Oct 2015 23:18:31 -0400 added missing file
317e7ea csoler 4 Oct 2015 23:14:49 -0400 added some backend for reputation system
c17dddb csoler 4 Oct 2015 17:47:30 -0400 updated GUI for reputation
b5bfddd csoler 3 Oct 2015 22:08:24 -0400 commit from PR#86 for VOIP, modified so as to restore real-time preview and video
9158ed6 csoler 3 Oct 2015 10:46:36 -0400 fixed potential buffer overrun (reported by GuessWho)
7fa687a csoler 3 Oct 2015 10:29:08 -0400 Merge pull request #119 from PhenomRetroShare/AddWebUI_BroadcastInLobbiesLis
b22069c csoler 3 Oct 2015 10:28:17 -0400 Merge pull request #123 from PhenomRetroShare/Fix_ChatWidgetDeleteKeyEvent
64389e3 Phenom 3 Oct 2015 11:00:16 +0200 Fiw Delete key event in ChatWidget.
904ea94 Phenom 2 Oct 2015 19:10:54 +0200 Remove (void)
986853d Phenom 1 Oct 2015 18:49:39 +0200 Add Broadcast in list of lobbies. Before you can only write text on it if unread
b055500 csoler 2 Oct 2015 11:03:52 -0400 Merge pull request #117 from G10h4ck/master
bd94fcd csoler 2 Oct 2015 10:53:00 -0400 Merge pull request #98 from PhenomRetroShare/AddMinimumFontSizeInChat
f6abe2f csoler 2 Oct 2015 10:50:14 -0400 Merge pull request #115 from PhenomRetroShare/AddWebUI_LobbyOrderByType
e83ae76 Gio 27 Sep 2015 20:15:41 +0200 pqiconnect remove ni NULL pointer check as it would crash anyway for null pointer d
28b9a44 Gio 27 Sep 2015 15:29:32 +0200 Write in a sane way pqissl::connect_parameter
b16ecc8 Gio 27 Sep 2015 15:11:55 +0200 Remove some garbage from pqissl
d6ba9a2 Phenom 25 Sep 2015 17:00:50 +0200 Order in WebUI Lobbies by first: auto_subscribe, is_private and then subscribed
3025f4d csoler 24 Sep 2015 18:18:11 -0400 removed aliasign problem that breaks compilation on gentoo
22d4893 csoler 24 Sep 2015 18:03:19 -0400 removed a few compilation warning that might cause compilation errors on some sy
0614a24 csoler 23 Sep 2015 22:11:50 -0400 Merge pull request #111 from csoler/v0.6-ImprovedExtIPDetermination
24b3325 csoler 23 Sep 2015 21:45:15 -0400 Improved reliability of the determination of external address: removed DHT stunn
323d894 csoler 22 Sep 2015 23:21:14 -0400 Merge pull request #110 from jenster/newbranchformychanges
68fd1b2 jenster 22 Sep 2015 18:33:16 -0700 First Mac/OSX compile fixes
6071be9 csoler 22 Sep 2015 11:20:28 -0400 Merge pull request #109 from AsamK/workaround_broken_sqlcipher
c80ad59 AsamK 22 Sep 2015 16:31:21 +0200 Add workaround for broken sqlcipher packages
-- Cyril Soler <csoler@users.sourceforge.net> Mon, 12 Oct 2015 20:00:00 +0100
retroshare06 (0.6.0-1.7293cd3~trusty) trusty; urgency=low
7293cd3 csoler Mon, 21 Sep 2015 22:58:58 -0400 updated ubuntu changelog
1d54630 thunder2 17 Sep 2015 10:05:31 +0200 Fixed Windows compile.
66691d4 csoler 16 Sep 2015 20:01:39 -0400 Merge pull request #108 from sehraf/i2p
04abfad sehraf 16 Sep 2015 17:01:20 +0200 manually reverted changes by Qt Creator
7c7e4f8 sehraf 16 Sep 2015 12:13:54 +0200 added ip addr. field to the add certificate dialog
6202e83 sehraf 16 Sep 2015 11:48:32 +0200 add default case to gui instead of falling back to tor labeling
d3d184f sehraf 16 Sep 2015 11:09:04 +0200 added simple step-by-step guide to add a I2P server tunnel
e54358a sehraf 16 Sep 2015 10:55:33 +0200 added simple step-by-step guide to add a I2P client tunnel
1dd3375 sehraf 15 Sep 2015 17:14:55 +0200 hide debug output
d24b281 sehraf 15 Sep 2015 17:10:48 +0200 optimizations * reduced calls to mPeermgr * use switch convenience * small fixes
bfcf43f sehraf 15 Sep 2015 16:18:46 +0200 fixed connection type detection and other small things
8725aab sehraf 14 Sep 2015 15:14:39 +0200 gui fixes
6b87c38 sehraf 14 Sep 2015 14:56:14 +0200 small fixes
6ec1919 sehraf 14 Sep 2015 12:39:46 +0200 gui changes
b0251e3 sehraf 14 Sep 2015 12:12:28 +0200 generalized tooltips
4b19e73 sehraf 14 Sep 2015 09:56:43 +0200 added comments to functions
900e51b csoler 13 Sep 2015 18:08:06 -0400 Merge pull request #107 from PhenomRetroShare/AddFriendListItemMouseEvents
48e6618 Phenom 13 Sep 2015 19:00:31 +0200 Send Mouse event to FriendList's item, since ElidedLabel was fixed.
7195d4c csoler 10 Sep 2015 09:41:28 -0400 Merge pull request #105 from ericthefish/master
4880fc4 Ivan Lucas 10 Sep 2015 11:21:01 +0100 Fixed grammar on add friend wizard by rewording slightly
840e930 Ivan Lucas 10 Sep 2015 10:29:15 +0100 Fix Spelling and Grammar
770e934 Ivan Lucas 10 Sep 2015 10:18:14 +0100 Merge remote-tracking branch 'upstream/master'
4a0539c csoler 9 Sep 2015 19:57:07 -0400 Merge pull request #103 from AsamK/html_parsing
1acd4a3 csoler 9 Sep 2015 16:44:59 -0400 Merge pull request #104 from PhenomRetroShare/Fix_ElidedLabel_mousePresEvent
ce9fc7b Phenom 9 Sep 2015 22:37:38 +0200 Fix ElidedLabel::mousePressEvent.
75a7a89 Ivan Lucas 9 Sep 2015 15:19:17 +0100 Fix typo
7aad9c1 AsamK 9 Sep 2015 13:36:00 +0200 Improve HTML parsing in libresapi
b8c3c89 AsamK 9 Sep 2015 11:53:01 +0200 Extract getPlainText method
ebd5da5 thunder2 8 Sep 2015 16:34:22 +0200 Optimizations in RsGenExchange, p3GxsForums and p3GxsChannels. - Removed not used variables
avoid copy constructors - Use swap instead of operator= to move elements of std containers
490b88c csoler 8 Sep 2015 14:17:29 -0400 Merge pull request #100 from ericthefish/master
a2e7e4d Ivan Lucas 8 Sep 2015 16:12:50 +0100 Fixed spelling/grammar
4f8b098 Ivan Lucas 8 Sep 2015 16:00:00 +0100 Fixing spelling
c4061fc thunder2 7 Sep 2015 22:27:04 +0200 Removed not used time consuming calculation of row count from RetroCursor.
29a1fa2 thunder2 7 Sep 2015 21:48:18 +0200 Removed unnecessary copy of results in RsGxsDataAccess.
0bc77d7 sehraf 8 Sep 2015 13:48:30 +0200 added some error handling
da417ee csoler 7 Sep 2015 20:38:47 -0400 Merge pull request #96 from AsamK/qmake_3
63e38af csoler 7 Sep 2015 20:36:03 -0400 Merge pull request #94 from AsamK/correct_libav_version
03d99ae sehraf 7 Sep 2015 23:55:57 +0200 made GenCertDislog more generic
4fc6c73 sehraf 7 Sep 2015 23:40:52 +0200 replaced some ifs with switch
e2768e0 defnax 7 Sep 2015 23:34:39 +0200 Added last used field to Person Details Window
fed4345 sehraf 7 Sep 2015 22:57:54 +0200 made server settings more generic and added i2p support
95d6b06 sehraf 7 Sep 2015 18:46:19 +0200 first working version
0107f4e sehraf 7 Sep 2015 12:59:21 +0200 first run on gui integration
ba74c04 sehraf 7 Sep 2015 11:51:24 +0200 removed duplicated code, fixed compile, few additions
c17d0e1 sehraf 7 Sep 2015 11:22:15 +0200 add i2p support to libretroshare
2c1743f defnax 7 Sep 2015 15:13:32 +0200 Added send message function for Participants list.
cc4be39 defnax 7 Sep 2015 15:08:56 +0200 Merge branch 'master' of https://github.com/RetroShare/RetroShare
0793a6a AsamK 6 Sep 2015 14:19:21 +0200 Use PLUGIN_DIR to define plugin directory only once
fe1ec9d AsamK 5 Sep 2015 22:49:57 +0200 Fixed mac compile. Moved sqlcipher.a to libretroshare.pro
571336e AsamK 5 Sep 2015 23:49:15 +0200 Move duplicate common stuff out of platform parts
66b9557 AsamK 5 Sep 2015 23:48:24 +0200 Use PKGCONFIG instead of manually specifying LIBS for Linux
b8e3a43 thunder2 6 Sep 2015 21:28:34 +0200 Auto download of recommended files adds the sender as source of the download.
5f36500 thunder2 6 Sep 2015 14:21:05 +0200 Fixed click in column "Friend nodes" in FriendList.
869077b thunder2 5 Sep 2015 12:46:18 +0200 Combined selects in RsDataService::retrieveNxsGrps/RsDataService::retrieveNxsMsgs.
d6f50c7 AsamK 5 Sep 2015 15:44:10 +0200 Fix libav version check
e9a5523 defnax 5 Sep 2015 00:16:07 +0200 Merge branch 'master' of https://github.com/RetroShare/RetroShare
7f8dae9 defnax 4 Sep 2015 16:33:43 +0200 Merge branch 'master' of https://github.com/RetroShare/RetroShare
07c5030 defnax 3 Sep 2015 17:41:30 +0200 Merge branch 'master' of https://github.com/RetroShare/RetroShare
3d6e978 defnax 2 Sep 2015 13:06:15 +0200 Fixed Status Label on Distant Chat
-- Cyril Soler <csoler@users.sourceforge.net> Mon, 21 Sep 2015 20:00:00 +0100
retroshare06 (0.6.0-1.20150905.8bb76c95~trusty) trusty; urgency=low
a276986 ( ) Merge pull request #60 from PhenomRetroShare/Fix_AllowChatTextFormatOption a276986 ( ) Merge pull request #60 from PhenomRetroShare/Fix_AllowChatTextFormatOption
88a6931 (GUI ) Allow Chat Text Format Option working. 88a6931 (GUI ) Allow Chat Text Format Option working.
0b5b20d ( ) Merge pull request #59 from AsamK/qmake_improvements 0b5b20d ( ) Merge pull request #59 from AsamK/qmake_improvements
@ -98,9 +336,9 @@ retroshare06 (0.6.0-1.XXXXXX~YYYYYY) YYYYYY; urgency=low
4d7f733 (Packaging ) fixed bug in git parameter in packaging script 4d7f733 (Packaging ) fixed bug in git parameter in packaging script
9734f32 (Packaging ) updated ubuntu changelog. improved ubuntu packaging script 9734f32 (Packaging ) updated ubuntu changelog. improved ubuntu packaging script
-- Cyril Soler <csoler@users.sourceforge.net> Sun, 16 Aug 2015 20:00:00 +0100 -- Cyril Soler <csoler@users.sourceforge.net> Sun, 05 Sep 2015 20:00:00 +0100
retroshare06 (0.6.0-1.20150816~9734f32a) trusty; urgency=low retroshare06 (0.6.0-1.20150816.9734f32a~trusty) trusty; urgency=low
f6b830d (branch merging) Merge pull request #35 from hunbernd/chat-fix f6b830d (branch merging) Merge pull request #35 from hunbernd/chat-fix
16859a1 (GUI ) Fix: chatlobby toaster not working 16859a1 (GUI ) Fix: chatlobby toaster not working

44
libbitdht/src/bitdht/Makefile
View File

@ -1,44 +0,0 @@
CPPFLAGS += -g -Wall -D BE_DEBUG -lpthread
LDFLAGS += -g -Wall -D BE_DEBUG -lpthread
CFLAGS += -g -Wall -D BE_DEBUG
CC = g++
LIB = -lpthread
CPPLIB = -lpthread
EXEC = bdmsgs_test bdmetric_test bdquery_test bdspace_test bdspace_test2 bdnode_test bdnode_test2 bdstore_test
EXEC += bdnode_multitest1 bdmidids_test
EXEC += udpbitdht_nettest bencode_test
EXEC += bdmgr_multitest
#EXEC += bdudp_test
all: $(EXEC)
OBJ = bencode.o bdmsgs.o bdobj.o
OBJ += bdpeer.o bdquery.o bdnode.o bdstore.o bdhash.o
OBJ += bdmanager.o bdstddht.o
# udp base objs
OBJ += bdthreads.o udplayer.o udpstack.o
OBJ += udpbitdht.o
bdmsgs_test: $(OBJ) bdmsgs_test.o
bdmetric_test: $(OBJ) bdmetric_test.o
bdquery_test: $(OBJ) bdquery_test.o
bdspace_test: $(OBJ) bdspace_test.o
bdspace_test2: $(OBJ) bdspace_test2.o
bdnode_test: $(OBJ) bdnode_test.o
bdnode_test2: $(OBJ) bdnode_test2.o
bdmidids_test: $(OBJ) bdmidids_test.o
bdnode_multitest1: $(OBJ) bdnode_multitest1.o
bdmgr_multitest: $(OBJ) bdmgr_multitest.o
bdstore_test: $(OBJ) bdstore_test.o
bdudp_test: $(OBJ) bdudp_test.o
udpbitdht_nettest: $(OBJ) udpbitdht_nettest.o
bencode_test: $(OBJ) bencode_test.o
clean:
rm -f *.o core $(EXEC)
.PHONY: all clean

16
libbitdht/src/example/Makefile
View File

@ -1,16 +0,0 @@
CXXFLAGS = -Wall -g -I..
#CXXFLAGS += -arch i386 # OSX
LIBS = -L../lib -lbitdht -lpthread
EXEC : bssdht
EGOBJ = bdhandler.o bssdht.o bootstrap_fn.o
bssdht: $(EGOBJ)
$(CXX) $(CXXFLAGS) -o bssdht $(EGOBJ) $(LIBS)

14
libbitdht/src/libbitdht.pro
View File

@ -4,6 +4,8 @@ TEMPLATE = lib
CONFIG += staticlib CONFIG += staticlib
CONFIG -= qt CONFIG -= qt
TARGET = bitdht TARGET = bitdht
DESTDIR = lib
QMAKE_CXXFLAGS *= -Wall -DBE_DEBUG QMAKE_CXXFLAGS *= -Wall -DBE_DEBUG
profiling { profiling {
@ -27,7 +29,6 @@ debug {
################################# Linux ########################################## ################################# Linux ##########################################
linux-* { linux-* {
DESTDIR = lib
QMAKE_CC = g++ QMAKE_CC = g++
} }
@ -50,7 +51,6 @@ unix {
win32-x-g++ { win32-x-g++ {
OBJECTS_DIR = temp/win32xgcc/obj OBJECTS_DIR = temp/win32xgcc/obj
DESTDIR = lib.win32xgcc
# These have been replaced by _WIN32 && __MINGW32__ # These have been replaced by _WIN32 && __MINGW32__
# DEFINES *= WINDOWS_SYS WIN32 WIN_CROSS_UBUNTU # DEFINES *= WINDOWS_SYS WIN32 WIN_CROSS_UBUNTU
QMAKE_CXXFLAGS *= -Wmissing-include-dirs QMAKE_CXXFLAGS *= -Wmissing-include-dirs
@ -70,7 +70,6 @@ win32 {
DEFINES *= STATICLIB WIN32_LEAN_AND_MEAN _USE_32BIT_TIME_T DEFINES *= STATICLIB WIN32_LEAN_AND_MEAN _USE_32BIT_TIME_T
# These have been replaced by _WIN32 && __MINGW32__ # These have been replaced by _WIN32 && __MINGW32__
#DEFINES *= WINDOWS_SYS WIN32 STATICLIB MINGW #DEFINES *= WINDOWS_SYS WIN32 STATICLIB MINGW
DESTDIR = lib
# Switch on extra warnings # Switch on extra warnings
QMAKE_CFLAGS += -Wextra QMAKE_CFLAGS += -Wextra
@ -93,18 +92,21 @@ mac {
QMAKE_CC = g++ QMAKE_CC = g++
OBJECTS_DIR = temp/obj OBJECTS_DIR = temp/obj
MOC_DIR = temp/moc MOC_DIR = temp/moc
DESTDIR = lib
} }
################################# FreeBSD ########################################## ################################# FreeBSD ##########################################
freebsd-* { freebsd-* {
DESTDIR = lib
} }
################################# OpenBSD ########################################## ################################# OpenBSD ##########################################
openbsd-* { openbsd-* {
}
################################# Haiku ##########################################
haiku-* {
DESTDIR = lib DESTDIR = lib
} }
@ -168,5 +170,3 @@ SOURCES += \
bitdht/bdquerymgr.cc \ bitdht/bdquerymgr.cc \
util/bdbloom.cc \ util/bdbloom.cc \
bitdht/bdfriendlist.cc \ bitdht/bdfriendlist.cc \

91
libbitdht/src/tests/Makefile
View File

@ -1,91 +0,0 @@
LIB_TOP_DIR = ..
TEST_TOP_DIR = $(LIB_TOP_DIR)/tests
##### Define any flags that are needed for this section #######
###############################################################
###############################################################
include $(TEST_TOP_DIR)/scripts/config.mk
###############################################################
# Generic Test Harnesses.
TESTOBJ = bdmetric_test.o bdmsgs_test.o bdnode_test.o bdspace_test.o
TESTOBJ += bdmgr_multitest.o bdquery_test.o bdstore_test.o
TESTOBJ += bdmidids_test.o bdspace_test2.o udpbitdht_nettest.o
TESTOBJ += bdbloom_test.o bdbloom_makefilter.o
#TESTOBJ += bencode_test.o bdudp_test.o
#TESTOBJ = bdnode_test.o bdnode_multitest1.o bdnode_test2.o
TESTS = bdmetric_test bdmsgs_test bdspace_test
TESTS += bdmgr_multitest bdquery_test bdstore_test
TESTS += bdmidids_test bdspace_test2 udpbitdht_nettest
TESTS += bdbloom_test
#TESTS += bencode_test bdudp_test
#Tests to Fix.
#TESTS = bdnode_test bdnode_multitest1 bdnode_test2
MANUAL_TESTS =
all: tests $(MANUAL_TESTS)
bdmsgs_test: bdmsgs_test.o
$(CC) $(CFLAGS) -o bdmsgs_test bdmsgs_test.o $(LIBS)
bdmetric_test: bdmetric_test.o
$(CC) $(CFLAGS) -o bdmetric_test bdmetric_test.o $(LIBS)
bdquery_test: bdquery_test.o
$(CC) $(CFLAGS) -o bdquery_test bdquery_test.o $(LIBS)
bdspace_test: bdspace_test.o
$(CC) $(CFLAGS) -o bdspace_test bdspace_test.o $(LIBS)
bdspace_test2: bdspace_test2.o
$(CC) $(CFLAGS) -o bdspace_test2 bdspace_test2.o $(LIBS)
bdnode_test: bdnode_test.o
$(CC) $(CFLAGS) -o bdnode_test bdnode_test.o $(LIBS)
bdnode_test2: bdnode_test2.o
$(CC) $(CFLAGS) -o bdnode_test2 bdnode_test2.o $(LIBS)
bdmidids_test: bdmidids_test.o
$(CC) $(CFLAGS) -o bdmidids_test bdmidids_test.o $(LIBS)
bdnode_multitest1: bdnode_multitest1.o
$(CC) $(CFLAGS) -o bdnode_multitest1 bdnode_multitest1.o $(LIBS)
bdmgr_multitest: bdmgr_multitest.o
$(CC) $(CFLAGS) -o bdmgr_multitest bdmgr_multitest.o $(LIBS)
bdstore_test: bdstore_test.o
$(CC) $(CFLAGS) -o bdstore_test bdstore_test.o $(LIBS)
bdudp_test: bdudp_test.o
$(CC) $(CFLAGS) -o bdudp_test bdudp_test.o $(LIBS)
udpbitdht_nettest: udpbitdht_nettest.o
$(CC) $(CFLAGS) -o udpbitdht_nettest udpbitdht_nettest.o $(LIBS)
bencode_test: bencode_test.o
$(CC) $(CFLAGS) -o bencode_test bencode_test.o $(LIBS)
bdbloom_test: bdbloom_test.o
$(CC) $(CFLAGS) -o bdbloom_test bdbloom_test.o $(LIBS)
bdbloom_makefilter: bdbloom_makefilter.o
$(CC) $(CFLAGS) -o bdbloom_makefilter bdbloom_makefilter.o $(LIBS)
clobber: remove_extra_files
remove_extra_files:
-$(RM) $(MANUAL_TESTS)
###############################################################
include $(TEST_TOP_DIR)/scripts/rules.mk
###############################################################

1
libbitdht/src/udp/udplayer.cc
View File

@ -32,6 +32,7 @@
#include <string.h> #include <string.h>
#include <stdlib.h> #include <stdlib.h>
#include <time.h> #include <time.h>
#include <sys/select.h>
/*** /***
* #define UDP_ENABLE_BROADCAST 1 * #define UDP_ENABLE_BROADCAST 1

2
libbitdht/src/util/bdrandom.cc
View File

@ -13,7 +13,7 @@ static bool auto_seed = bdRandom::seed( (time(NULL) + ((uint32_t) pthread_self()
#else #else
#ifdef __APPLE__ #ifdef __APPLE__
static bool auto_seed = bdRandom::seed( (time(NULL) + pthread_mach_thread_np(pthread_self())*0x1293fe + (getpid()^0x113ef76b))^0x18e34a12 ) ; static bool auto_seed = bdRandom::seed( (time(NULL) + pthread_mach_thread_np(pthread_self())*0x1293fe + (getpid()^0x113ef76b))^0x18e34a12 ) ;
#elif defined(__FreeBSD__) #elif defined(__FreeBSD__) || (__HAIKU__)
// since this is completely insecure anyway, just kludge for now // since this is completely insecure anyway, just kludge for now
static bool auto_seed = bdRandom::seed(time(NULL)); static bool auto_seed = bdRandom::seed(time(NULL));
#elif defined(__OpenBSD__) #elif defined(__OpenBSD__)

165
libresapi/src/api/ChatHandler.cpp
View File

@ -42,6 +42,12 @@ StreamBase& operator << (StreamBase& left, ChatHandler::Msg& m)
bool compare_lobby_id(const ChatHandler::Lobby& l1, const ChatHandler::Lobby& l2) bool compare_lobby_id(const ChatHandler::Lobby& l1, const ChatHandler::Lobby& l2)
{ {
if(l1.auto_subscribe && !l2.auto_subscribe) return true;
if(!l1.auto_subscribe && l2.auto_subscribe) return false;
if(l1.is_private && !l2.is_private) return true;
if(!l1.is_private && l2.is_private) return false;
if(l1.subscribed && !l2.subscribed) return true;
if(!l1.subscribed && l2.subscribed) return false;
return l1.id < l2.id; return l1.id < l2.id;
} }
@ -65,13 +71,17 @@ StreamBase& operator <<(StreamBase& left, KeyValueReference<ChatLobbyId> kv)
StreamBase& operator << (StreamBase& left, ChatHandler::Lobby& l) StreamBase& operator << (StreamBase& left, ChatHandler::Lobby& l)
{ {
ChatId chatId(l.id);
if (l.is_broadcast)
chatId = ChatId::makeBroadcastId();
left << makeKeyValueReference("id", l.id) left << makeKeyValueReference("id", l.id)
<< makeKeyValue("chat_id", ChatId(l.id).toStdString()) << makeKeyValue("chat_id", chatId.toStdString())
<< makeKeyValueReference("name",l.name) << makeKeyValueReference("name",l.name)
<< makeKeyValueReference("topic", l.topic) << makeKeyValueReference("topic", l.topic)
<< makeKeyValueReference("subscribed", l.subscribed) << makeKeyValueReference("subscribed", l.subscribed)
<< makeKeyValueReference("auto_subscribe", l.auto_subscribe) << makeKeyValueReference("auto_subscribe", l.auto_subscribe)
<< makeKeyValueReference("is_private", l.is_private) << makeKeyValueReference("is_private", l.is_private)
<< makeKeyValueReference("is_broadcast", l.is_broadcast)
<< makeKeyValueReference("gxs_id", l.gxs_id); << makeKeyValueReference("gxs_id", l.gxs_id);
return left; return left;
} }
@ -157,11 +167,26 @@ void ChatHandler::tick()
l.subscribed = true; l.subscribed = true;
l.auto_subscribe = info.lobby_flags & RS_CHAT_LOBBY_FLAGS_AUTO_SUBSCRIBE; l.auto_subscribe = info.lobby_flags & RS_CHAT_LOBBY_FLAGS_AUTO_SUBSCRIBE;
l.is_private = !(info.lobby_flags & RS_CHAT_LOBBY_FLAGS_PUBLIC); l.is_private = !(info.lobby_flags & RS_CHAT_LOBBY_FLAGS_PUBLIC);
l.is_broadcast = false;
l.gxs_id = info.gxs_id; l.gxs_id = info.gxs_id;
lobbies.push_back(l); lobbies.push_back(l);
} }
} }
ChatId id = ChatId::makeBroadcastId();
{
Lobby l;
l.id = id.toLobbyId();
l.name = "BroadCast";
l.topic = "Retroshare broadcast chat: messages are sent to all connected friends.";
l.subscribed = true;
l.auto_subscribe = false;
l.is_private = false;
l.is_broadcast = true;
l.gxs_id = id.toGxsId();
lobbies.push_back(l);
}
std::vector<VisibleChatLobbyRecord> unsubscribed_lobbies; std::vector<VisibleChatLobbyRecord> unsubscribed_lobbies;
mRsMsgs->getListOfNearbyChatLobbies(unsubscribed_lobbies); mRsMsgs->getListOfNearbyChatLobbies(unsubscribed_lobbies);
for(std::vector<VisibleChatLobbyRecord>::iterator vit = unsubscribed_lobbies.begin(); vit != unsubscribed_lobbies.end(); ++vit) for(std::vector<VisibleChatLobbyRecord>::iterator vit = unsubscribed_lobbies.begin(); vit != unsubscribed_lobbies.end(); ++vit)
@ -176,6 +201,7 @@ void ChatHandler::tick()
l.subscribed = false; l.subscribed = false;
l.auto_subscribe = info.lobby_flags & RS_CHAT_LOBBY_FLAGS_AUTO_SUBSCRIBE; l.auto_subscribe = info.lobby_flags & RS_CHAT_LOBBY_FLAGS_AUTO_SUBSCRIBE;
l.is_private = !(info.lobby_flags & RS_CHAT_LOBBY_FLAGS_PUBLIC); l.is_private = !(info.lobby_flags & RS_CHAT_LOBBY_FLAGS_PUBLIC);
l.is_broadcast = false;
l.gxs_id = RsGxsId(); l.gxs_id = RsGxsId();
lobbies.push_back(l); lobbies.push_back(l);
} }
@ -294,62 +320,7 @@ void ChatHandler::tick()
// remove html tags from chat message // remove html tags from chat message
// extract links form href // extract links form href
const std::string& in = msg.msg; getPlainText(msg.msg, m.msg, m.links);
std::string out;
bool ignore = false;
bool keep_link = false;
std::string last_six_chars;
Triple current_link;
std::vector<Triple> links;
for(unsigned int i = 0; i < in.size(); ++i)
{
if(keep_link && in[i] == '"')
{
keep_link = false;
current_link.second = out.size();
}
if(last_six_chars == "href=\"")
{
keep_link = true;
current_link.first = out.size();
}
// "rising edge" sets mode to ignore
if(in[i] == '<')
{
ignore = true;
}
if(!ignore || keep_link)
out += in[i];
// "falling edge" resets mode to keep
if(in[i] == '>')
ignore = false;
last_six_chars += in[i];
if(last_six_chars.size() > 6)
last_six_chars = last_six_chars.substr(1);
std::string a = "</a>";
if( current_link.first != -1
&& last_six_chars.size() >= a.size()
&& last_six_chars.substr(last_six_chars.size()-a.size()) == a)
{
// only allow these protocols
// we don't want for example javascript:alert(0)
std::string http = "http://";
std::string https = "https://";
std::string retroshare = "retroshare://";
if( out.substr(current_link.first, http.size()) == http
|| out.substr(current_link.first, https.size()) == https
|| out.substr(current_link.first, retroshare.size()) == retroshare)
{
current_link.third = out.size();
links.push_back(current_link);
}
current_link = Triple();
}
}
m.msg = out;
m.links = links;
m.recv_time = msg.recvTime; m.recv_time = msg.recvTime;
m.send_time = msg.sendTime; m.send_time = msg.sendTime;
@ -390,7 +361,77 @@ void ChatHandler::tick()
} }
} }
void ChatHandler::handleWildcard(Request &req, Response &resp) void ChatHandler::getPlainText(const std::string& in, std::string &out, std::vector<Triple> &links)
{
if (in.size() == 0)
return;
if (in[0] != '<' || in[in.size() - 1] != '>')
{
// It's a plain text message without HTML
out = in;
return;
}
bool ignore = false;
bool keep_link = false;
std::string last_six_chars;
unsigned int tag_start_index = 0;
Triple current_link;
for(unsigned int i = 0; i < in.size(); ++i)
{
if(keep_link && in[i] == '"')
{
keep_link = false;
current_link.second = out.size();
}
if(last_six_chars == "href=\"")
{
keep_link = true;
current_link.first = out.size();
}
// "rising edge" sets mode to ignore
if(in[i] == '<')
{
tag_start_index = i;
ignore = true;
}
if(!ignore || keep_link)
out += in[i];
// "falling edge" resets mode to keep
if(in[i] == '>') {
// leave ignore mode on, if it's a style tag
if (tag_start_index == 0 || tag_start_index + 6 > i || in.substr(tag_start_index, 6) != "<style")
ignore = false;
}
last_six_chars += in[i];
if(last_six_chars.size() > 6)
last_six_chars = last_six_chars.substr(1);
std::string a = "</a>";
if( current_link.first != -1
&& last_six_chars.size() >= a.size()
&& last_six_chars.substr(last_six_chars.size()-a.size()) == a)
{
// only allow these protocols
// we don't want for example javascript:alert(0)
std::string http = "http://";
std::string https = "https://";
std::string retroshare = "retroshare://";
if( out.substr(current_link.first, http.size()) == http
|| out.substr(current_link.first, https.size()) == https
|| out.substr(current_link.first, retroshare.size()) == retroshare)
{
current_link.third = out.size();
links.push_back(current_link);
}
current_link = Triple();
}
}
}
void ChatHandler::handleWildcard(Request &/*req*/, Response &resp)
{ {
RS_STACK_MUTEX(mMtx); /********** LOCKED **********/ RS_STACK_MUTEX(mMtx); /********** LOCKED **********/
resp.mDataStream.getStreamToMember(); resp.mDataStream.getStreamToMember();
@ -447,7 +488,7 @@ void ChatHandler::handleSubscribeLobby(Request &req, Response &resp)
resp.setFail("lobby join failed. (See console for more info)"); resp.setFail("lobby join failed. (See console for more info)");
} }
void ChatHandler::handleUnsubscribeLobby(Request &req, Response &resp) void ChatHandler::handleUnsubscribeLobby(Request &req, Response &/*resp*/)
{ {
ChatLobbyId id = 0; ChatLobbyId id = 0;
req.mStream << makeKeyValueReference("id", id); req.mStream << makeKeyValueReference("id", id);
@ -626,17 +667,17 @@ void ChatHandler::handleInfo(Request &req, Response &resp)
resp.setOk(); resp.setOk();
} }
void ChatHandler::handleTypingLabel(Request &req, Response &resp) void ChatHandler::handleTypingLabel(Request &/*req*/, Response &/*resp*/)
{ {
} }
void ChatHandler::handleSendStatus(Request &req, Response &resp) void ChatHandler::handleSendStatus(Request &/*req*/, Response &/*resp*/)
{ {
} }
void ChatHandler::handleUnreadMsgs(Request &req, Response &resp) void ChatHandler::handleUnreadMsgs(Request &/*req*/, Response &resp)
{ {
RS_STACK_MUTEX(mMtx); /********** LOCKED **********/ RS_STACK_MUTEX(mMtx); /********** LOCKED **********/

6
libresapi/src/api/ChatHandler.h
View File

@ -57,13 +57,14 @@ public:
class Lobby{ class Lobby{
public: public:
Lobby(): id(0), subscribed(false), auto_subscribe(false), is_private(false){} Lobby(): id(0), subscribed(false), auto_subscribe(false), is_private(false), is_broadcast(false){}
ChatLobbyId id; ChatLobbyId id;
std::string name; std::string name;
std::string topic; std::string topic;
bool subscribed; bool subscribed;
bool auto_subscribe; bool auto_subscribe;
bool is_private; bool is_private;
bool is_broadcast;
RsGxsId gxs_id;// for subscribed lobbies: the id we use to write messages RsGxsId gxs_id;// for subscribed lobbies: the id we use to write messages
@ -75,6 +76,7 @@ public:
&& subscribed == l.subscribed && subscribed == l.subscribed
&& auto_subscribe == l.auto_subscribe && auto_subscribe == l.auto_subscribe
&& is_private == l.is_private && is_private == l.is_private
&& is_broadcast == l.is_broadcast
&& gxs_id == l.gxs_id; && gxs_id == l.gxs_id;
} }
}; };
@ -102,6 +104,8 @@ private:
void handleSendStatus(Request& req, Response& resp); void handleSendStatus(Request& req, Response& resp);
void handleUnreadMsgs(Request& req, Response& resp); void handleUnreadMsgs(Request& req, Response& resp);
void getPlainText(const std::string& in, std::string &out, std::vector<Triple> &links);
StateTokenServer* mStateTokenServer; StateTokenServer* mStateTokenServer;
RsNotify* mNotify; RsNotify* mNotify;
RsMsgs* mRsMsgs; RsMsgs* mRsMsgs;

4
libresapi/src/api/Operators.cpp
View File

@ -14,9 +14,9 @@ StreamBase& operator <<(StreamBase& left, KeyValueReference<uint32_t> ref)
{ {
digit = num % 10; digit = num % 10;
num = num / 10; num = num / 10;
str += (char)(digit + '0'); str = (char)(digit + '0') + str;
} }
str += (char)(num + '0'); str = (char)(num + '0') + str;
left << makeKeyValueReference(ref.key, str); left << makeKeyValueReference(ref.key, str);
} }
else else

8
libresapi/src/libresapi.pro
View File

@ -2,8 +2,10 @@
TEMPLATE = lib TEMPLATE = lib
CONFIG += staticlib CONFIG += staticlib
CONFIG += create_prl
CONFIG -= qt CONFIG -= qt
TARGET = resapi TARGET = resapi
TARGET_PRL = libresapi
DESTDIR = lib DESTDIR = lib
CONFIG += libmicrohttpd CONFIG += libmicrohttpd
@ -26,6 +28,12 @@ win32{
} }
libmicrohttpd{ libmicrohttpd{
linux {
CONFIG += link_pkgconfig
PKGCONFIG *= libmicrohttpd
} else {
LIBS *= -lmicrohttpd
}
SOURCES += \ SOURCES += \
api/ApiServerMHD.cpp api/ApiServerMHD.cpp

2
libresapi/src/webfiles/gui.jsx
View File

@ -1467,7 +1467,7 @@ var ChatWidget = React.createClass({
<ChatInfoWidget id={this.props.id}/> <ChatInfoWidget id={this.props.id}/>
{ {
this.state.data.map(function(msg){ this.state.data.map(function(msg){
return <div key={msg.id}>{msg.send_time} {msg.author_name}: {markup(msg.msg, msg.links)}</div>; return <div key={msg.id}>{new Date(msg.send_time*1000).toLocaleTimeString()} {msg.author_name}: {markup(msg.msg, msg.links)}</div>;
}) })
} }
<input type="text" ref="input" onKeyDown={ <input type="text" ref="input" onKeyDown={

2
libresapi/src/webui/gui.jsx
View File

@ -1467,7 +1467,7 @@ var ChatWidget = React.createClass({
<ChatInfoWidget id={this.props.id}/> <ChatInfoWidget id={this.props.id}/>
{ {
this.state.data.map(function(msg){ this.state.data.map(function(msg){
return <div key={msg.id}>{msg.send_time} {msg.author_name}: {markup(msg.msg, msg.links)}</div>; return <div key={msg.id}>{new Date(msg.send_time*1000).toLocaleTimeString()} {msg.author_name}: {markup(msg.msg, msg.links)}</div>;
}) })
} }
<input type="text" ref="input" onKeyDown={ <input type="text" ref="input" onKeyDown={

23
libretroshare/src/chat/distantchat.cc
View File

@ -31,6 +31,7 @@
#include "openssl/err.h" #include "openssl/err.h"
#include "util/rsaes.h" #include "util/rsaes.h"
#include "util/rsmemory.h"
#include <serialiser/rsmsgitems.h> #include <serialiser/rsmsgitems.h>
@ -435,10 +436,6 @@ bool DistantChatService::handleEncryptedData(const uint8_t *data_bytes,uint32_t
{ {
RS_STACK_MUTEX(mDistantChatMtx); /********** STACK LOCKED MTX ******/ RS_STACK_MUTEX(mDistantChatMtx); /********** STACK LOCKED MTX ******/
uint32_t decrypted_size = RsAES::get_buffer_size(data_size-8);
uint8_t *decrypted_data = new uint8_t[decrypted_size];
uint8_t aes_key[DISTANT_CHAT_AES_KEY_SIZE] ;
std::map<RsPeerId,DistantChatDHInfo>::iterator it = _distant_chat_virtual_peer_ids.find(virtual_peer_id) ; std::map<RsPeerId,DistantChatDHInfo>::iterator it = _distant_chat_virtual_peer_ids.find(virtual_peer_id) ;
if(it == _distant_chat_virtual_peer_ids.end()) if(it == _distant_chat_virtual_peer_ids.end())
@ -455,8 +452,11 @@ bool DistantChatService::handleEncryptedData(const uint8_t *data_bytes,uint32_t
std::cerr << "(EE) no GXS id data for ID=" << gxs_id << ". This is a bug." << std::endl; std::cerr << "(EE) no GXS id data for ID=" << gxs_id << ". This is a bug." << std::endl;
return true ; return true ;
} }
uint8_t aes_key[DISTANT_CHAT_AES_KEY_SIZE] ;
memcpy(aes_key,it2->second.aes_key,DISTANT_CHAT_AES_KEY_SIZE) ; memcpy(aes_key,it2->second.aes_key,DISTANT_CHAT_AES_KEY_SIZE) ;
uint32_t decrypted_size = RsAES::get_buffer_size(data_size-8);
uint8_t *decrypted_data = new uint8_t[decrypted_size];
#ifdef DEBUG_DISTANT_CHAT #ifdef DEBUG_DISTANT_CHAT
std::cerr << " Using IV: " << std::hex << *(uint64_t*)data_bytes << std::dec << std::endl; std::cerr << " Using IV: " << std::hex << *(uint64_t*)data_bytes << std::dec << std::endl;
std::cerr << " Decrypted buffer size: " << decrypted_size << std::endl; std::cerr << " Decrypted buffer size: " << decrypted_size << std::endl;
@ -540,7 +540,7 @@ void DistantChatService::handleRecvDHPublicKey(RsChatDHPublicKeyItem *item)
#endif #endif
uint32_t pubkey_size = BN_num_bytes(item->public_key) ; uint32_t pubkey_size = BN_num_bytes(item->public_key) ;
unsigned char *data = (unsigned char *)malloc(pubkey_size) ; RsTemporaryMemory data(pubkey_size) ;
BN_bn2bin(item->public_key, data) ; BN_bn2bin(item->public_key, data) ;
RsTlvSecurityKey signature_key ; RsTlvSecurityKey signature_key ;
@ -585,7 +585,7 @@ void DistantChatService::handleRecvDHPublicKey(RsChatDHPublicKeyItem *item)
signature_key = item->gxs_key ; signature_key = item->gxs_key ;
} }
if(!GxsSecurity::validateSignature((char*)data,pubkey_size,signature_key,item->signature)) if(!GxsSecurity::validateSignature((char*)(uint8_t*)data,pubkey_size,signature_key,item->signature))
{ {
std::cerr << "(SS) Signature was verified and it doesn't check! This is a security issue!" << std::endl; std::cerr << "(SS) Signature was verified and it doesn't check! This is a security issue!" << std::endl;
return ; return ;
@ -690,10 +690,10 @@ bool DistantChatService::locked_sendDHPublicKey(const DH *dh,const RsGxsId& own_
uint32_t error_status ; uint32_t error_status ;
uint32_t size = BN_num_bytes(dhitem->public_key) ; uint32_t size = BN_num_bytes(dhitem->public_key) ;
unsigned char *data = (unsigned char *)malloc(size) ; RsTemporaryMemory data(size) ;
BN_bn2bin(dhitem->public_key, data) ; BN_bn2bin(dhitem->public_key, data) ;
if(!mGixs->signData((unsigned char*)data,size,own_gxs_id,signature,error_status)) if(!mGixs->signData(data,size,own_gxs_id,signature,error_status))
{ {
switch(error_status) switch(error_status)
{ {
@ -702,11 +702,9 @@ bool DistantChatService::locked_sendDHPublicKey(const DH *dh,const RsGxsId& own_
default: std::cerr << "(EE) Unknown error when signing" << std::endl; default: std::cerr << "(EE) Unknown error when signing" << std::endl;
break ; break ;
} }
free(data) ;
delete(dhitem); delete(dhitem);
return false; return false;
} }
free(data) ;
if(!mGixs->getKey(own_gxs_id,signature_key_public)) if(!mGixs->getKey(own_gxs_id,signature_key_public))
{ {
@ -810,19 +808,16 @@ void DistantChatService::sendTurtleData(RsChatItem *item)
else else
{ {
uint32_t rssize = item->serial_size(); uint32_t rssize = item->serial_size();
uint8_t *buff = (uint8_t*)malloc(rssize) ; RsTemporaryMemory buff(rssize) ;
if(!item->serialise(buff,rssize)) if(!item->serialise(buff,rssize))
{ {
std::cerr << "(EE) DistantChatService::sendTurtleData(): Could not serialise item!" << std::endl; std::cerr << "(EE) DistantChatService::sendTurtleData(): Could not serialise item!" << std::endl;
free(buff) ;
delete item ; delete item ;
return ; return ;
} }
sendEncryptedTurtleData(buff,rssize,RsGxsId(item->PeerId())) ; sendEncryptedTurtleData(buff,rssize,RsGxsId(item->PeerId())) ;
free(buff) ;
} }
delete item ; delete item ;
} }

28
libretroshare/src/chat/distributedchat.cc
View File

@ -34,6 +34,7 @@
#include "pqi/p3historymgr.h" #include "pqi/p3historymgr.h"
#include "retroshare/rspeers.h" #include "retroshare/rspeers.h"
#include "retroshare/rsiface.h" #include "retroshare/rsiface.h"
#include "retroshare/rsreputations.h"
#include "retroshare/rsidentity.h" #include "retroshare/rsidentity.h"
#include "rsserver/p3face.h" #include "rsserver/p3face.h"
#include "gxs/rsgixs.h" #include "gxs/rsgixs.h"
@ -168,13 +169,25 @@ bool DistributedChatService::handleRecvChatLobbyMsgItem(RsChatMsgItem *ci)
{ {
RsIdentityDetails details; RsIdentityDetails details;
if(!rsIdentity->getIdDetails(cli->signature.keyId,details) || !details.mPgpKnown) if(!rsIdentity->getIdDetails(cli->signature.keyId,details))
{
std::cerr << "(WW) cannot get ID " << cli->signature.keyId << " for checking signature of lobby item." << std::endl;
return false;
}
if(!details.mPgpLinked)
{ {
std::cerr << "(WW) Received a lobby msg/item that is not PGP-authed (id=" << cli->signature.keyId << "), whereas the lobby flags require it. Rejecting!" << std::endl; std::cerr << "(WW) Received a lobby msg/item that is not PGP-authed (id=" << cli->signature.keyId << "), whereas the lobby flags require it. Rejecting!" << std::endl;
return false ; return false ;
} }
} }
if(rsReputations->isIdentityBanned(cli->signature.keyId))
{
std::cerr << "(WW) Received lobby msg/item from banned identity " << cli->signature.keyId << ". Dropping it." << std::endl;
return false ;
}
if(!bounceLobbyObject(cli,cli->PeerId())) // forwards the message to friends, keeps track of subscribers, etc. if(!bounceLobbyObject(cli,cli->PeerId())) // forwards the message to friends, keeps track of subscribers, etc.
return false; return false;
@ -665,13 +678,24 @@ void DistributedChatService::handleRecvChatLobbyEventItem(RsChatLobbyEventItem *
{ {
RsIdentityDetails details; RsIdentityDetails details;
if(!rsIdentity->getIdDetails(item->signature.keyId,details) || !details.mPgpKnown) if(!rsIdentity->getIdDetails(item->signature.keyId,details))
{
std::cerr << "(WW) cannot get ID " << item->signature.keyId << " for checking signature of lobby item." << std::endl;
return ;
}
if(!details.mPgpLinked)
{ {
std::cerr << "(WW) Received a lobby msg/item that is not PGP-authed (ID=" << item->signature.keyId << "), whereas the lobby flags require it. Rejecting!" << std::endl; std::cerr << "(WW) Received a lobby msg/item that is not PGP-authed (ID=" << item->signature.keyId << "), whereas the lobby flags require it. Rejecting!" << std::endl;
return ; return ;
} }
} }
if(rsReputations->isIdentityBanned(item->signature.keyId))
{
std::cerr << "(WW) Received lobby msg/item from banned identity " << item->signature.keyId << ". Dropping it." << std::endl;
return ;
}
addTimeShiftStatistics((int)now - (int)item->sendTime) ; addTimeShiftStatistics((int)now - (int)item->sendTime) ;
if(now+100 > (time_t) item->sendTime + MAX_KEEP_MSG_RECORD) // the message is older than the max cache keep minus 100 seconds ! It's too old, and is going to make an echo! if(now+100 > (time_t) item->sendTime + MAX_KEEP_MSG_RECORD) // the message is older than the max cache keep minus 100 seconds ! It's too old, and is going to make an echo!

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

@ -175,6 +175,7 @@ HashCache::HashCache(const std::string& path)
if(!f->good()) if(!f->good())
{ {
delete f ;
std::cerr << "Unencrypted file cache not present either." << std::endl; std::cerr << "Unencrypted file cache not present either." << std::endl;
return ; return ;
} }

6
libretroshare/src/dbase/findex.cc
View File

@ -780,7 +780,7 @@ int FileIndex::loadIndex(const std::string& filename, const RsFileHash& expected
fclose(file); fclose(file);
return 0; return 0;
} }
int bytesread = 0 ; uint64_t bytesread = 0 ;
if(size != (bytesread = fread(compressed_data,1,size,file))) if(size != (bytesread = fread(compressed_data,1,size,file)))
{ {
std::cerr << "FileIndex::loadIndex(): can't read " << size << " bytes from file " << filename << ". Only " << bytesread << " actually read." << std::endl; std::cerr << "FileIndex::loadIndex(): can't read " << size << " bytes from file " << filename << ". Only " << bytesread << " actually read." << std::endl;
@ -1089,7 +1089,7 @@ int FileIndex::saveIndex(const std::string& filename, RsFileHash &fileHash, uint
std::cerr << "FileIndex::saveIndex error opening file for writting: " << filename << ". Giving up." << std::endl; std::cerr << "FileIndex::saveIndex error opening file for writting: " << filename << ". Giving up." << std::endl;
return 0; return 0;
} }
int outwritten ; uint32_t outwritten ;
if(compressed_data_size != (outwritten=fwrite(compressed_data,1,compressed_data_size,file))) if(compressed_data_size != (outwritten=fwrite(compressed_data,1,compressed_data_size,file)))
{ {
@ -1370,7 +1370,7 @@ void *FileIndex::findRef(const std::string& fpath) const
std::cerr << "FileIndex::updateFileEntry() NULL parent"; std::cerr << "FileIndex::updateFileEntry() NULL parent";
std::cerr << std::endl; std::cerr << std::endl;
//#endif //#endif
return false; return NULL;
} }
std::cerr << "Found parent directory: " << std::endl; std::cerr << "Found parent directory: " << std::endl;
std::cerr << " parent.name = " << parent->name << std::endl; std::cerr << " parent.name = " << parent->name << std::endl;

2
libretroshare/src/ft/ftchunkmap.cc
View File

@ -96,7 +96,7 @@ void ChunkMap::setAvailabilityMap(const CompressedChunkMap& map)
// do some sanity check // do some sanity check
// //
if( (((int)_map.size()-1)>>5) >= map._map.size() ) if( (((int)_map.size()-1)>>5) >= (int)map._map.size() )
{ {
std::cerr << "ChunkMap::setPeerAvailabilityMap: Compressed chunkmap received is too small or corrupted." << std::endl; std::cerr << "ChunkMap::setPeerAvailabilityMap: Compressed chunkmap received is too small or corrupted." << std::endl;
return ; return ;

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

@ -551,7 +551,7 @@ bool GxsSecurity::decrypt(uint8_t *& out, uint32_t & outlen, const uint8_t *in,
in_offset += size_net_ekl; in_offset += size_net_ekl;
// Conservative limits to detect weird errors due to corrupted encoding. // Conservative limits to detect weird errors due to corrupted encoding.
if(eklen < 0 || eklen > 512 || eklen+in_offset > inlen) if(eklen < 0 || eklen > 512 || eklen+in_offset > (int)inlen)
{ {
std::cerr << "Error while deserialising encryption key length: eklen = " << std::dec << eklen << ". Giving up decryption." << std::endl; std::cerr << "Error while deserialising encryption key length: eklen = " << std::dec << eklen << ". Giving up decryption." << std::endl;
free(ek); free(ek);

248
libretroshare/src/gxs/rsdataservice.cc
View File

@ -152,6 +152,11 @@ RsDataService::RsDataService(const std::string &serviceDir, const std::string &d
mColMsg_MetaData = addColumn(mMsgColumns, KEY_NXS_META); mColMsg_MetaData = addColumn(mMsgColumns, KEY_NXS_META);
mColMsg_MsgId = addColumn(mMsgColumns, KEY_MSG_ID); mColMsg_MsgId = addColumn(mMsgColumns, KEY_MSG_ID);
// for retrieving msg data with meta
mMsgColumnsWithMeta = mMsgColumns;
mColMsg_WithMetaOffset = mMsgColumnsWithMeta.size();
mMsgColumnsWithMeta.insert(mMsgColumnsWithMeta.end(), mMsgMetaColumns.begin(), mMsgMetaColumns.end());
// for retrieving grp meta data // for retrieving grp meta data
mColGrpMeta_GrpId = addColumn(mGrpMetaColumns, KEY_GRP_ID); mColGrpMeta_GrpId = addColumn(mGrpMetaColumns, KEY_GRP_ID);
mColGrpMeta_TimeStamp = addColumn(mGrpMetaColumns, KEY_TIME_STAMP); mColGrpMeta_TimeStamp = addColumn(mGrpMetaColumns, KEY_TIME_STAMP);
@ -184,6 +189,11 @@ RsDataService::RsDataService(const std::string &serviceDir, const std::string &d
mColGrp_NxsData = addColumn(mGrpColumns, KEY_NXS_DATA); mColGrp_NxsData = addColumn(mGrpColumns, KEY_NXS_DATA);
mColGrp_MetaData = addColumn(mGrpColumns, KEY_NXS_META); mColGrp_MetaData = addColumn(mGrpColumns, KEY_NXS_META);
// for retrieving grp data with meta
mGrpColumnsWithMeta = mGrpColumns;
mColGrp_WithMetaOffset = mGrpColumnsWithMeta.size();
mGrpColumnsWithMeta.insert(mGrpColumnsWithMeta.end(), mGrpMetaColumns.begin(), mGrpMetaColumns.end());
// Group id columns // Group id columns
mColGrpId_GrpId = addColumn(mGrpIdColumn, KEY_GRP_ID); mColGrpId_GrpId = addColumn(mGrpIdColumn, KEY_GRP_ID);
@ -474,7 +484,7 @@ bool RsDataService::finishReleaseUpdate(int release, bool result)
return result; return result;
} }
RsGxsGrpMetaData* RsDataService::locked_getGrpMeta(RetroCursor &c) RsGxsGrpMetaData* RsDataService::locked_getGrpMeta(RetroCursor &c, int colOffset)
{ {
#ifdef RS_DATA_SERVICE_DEBUG #ifdef RS_DATA_SERVICE_DEBUG
std::cerr << "RsDataService::locked_getGrpMeta()"; std::cerr << "RsDataService::locked_getGrpMeta()";
@ -492,27 +502,27 @@ RsGxsGrpMetaData* RsDataService::locked_getGrpMeta(RetroCursor &c)
// grpId // grpId
std::string tempId; std::string tempId;
c.getString(mColGrpMeta_GrpId, tempId); c.getString(mColGrpMeta_GrpId + colOffset, tempId);
grpMeta->mGroupId = RsGxsGroupId(tempId); grpMeta->mGroupId = RsGxsGroupId(tempId);
c.getString(mColGrpMeta_NxsIdentity, tempId); c.getString(mColGrpMeta_NxsIdentity + colOffset, tempId);
grpMeta->mAuthorId = RsGxsId(tempId); grpMeta->mAuthorId = RsGxsId(tempId);
c.getString(mColGrpMeta_Name, grpMeta->mGroupName); c.getString(mColGrpMeta_Name + colOffset, grpMeta->mGroupName);
c.getString(mColGrpMeta_OrigGrpId, tempId); c.getString(mColGrpMeta_OrigGrpId + colOffset, tempId);
grpMeta->mOrigGrpId = RsGxsGroupId(tempId); grpMeta->mOrigGrpId = RsGxsGroupId(tempId);
c.getString(mColGrpMeta_ServString, grpMeta->mServiceString); c.getString(mColGrpMeta_ServString + colOffset, grpMeta->mServiceString);
std::string temp; std::string temp;
c.getString(mColGrpMeta_NxsHash, temp); c.getString(mColGrpMeta_NxsHash + colOffset, temp);
grpMeta->mHash = RsFileHash(temp); grpMeta->mHash = RsFileHash(temp);
grpMeta->mReputationCutOff = c.getInt32(mColGrpMeta_RepCutoff); grpMeta->mReputationCutOff = c.getInt32(mColGrpMeta_RepCutoff + colOffset);
grpMeta->mSignFlags = c.getInt32(mColGrpMeta_SignFlags); grpMeta->mSignFlags = c.getInt32(mColGrpMeta_SignFlags + colOffset);
grpMeta->mPublishTs = c.getInt32(mColGrpMeta_TimeStamp); grpMeta->mPublishTs = c.getInt32(mColGrpMeta_TimeStamp + colOffset);
grpMeta->mGroupFlags = c.getInt32(mColGrpMeta_NxsFlags); grpMeta->mGroupFlags = c.getInt32(mColGrpMeta_NxsFlags + colOffset);
grpMeta->mGrpSize = c.getInt32(mColGrpMeta_NxsDataLen); grpMeta->mGrpSize = c.getInt32(mColGrpMeta_NxsDataLen + colOffset);
offset = 0; data = NULL; data_len = 0; offset = 0; data = NULL; data_len = 0;
data = (char*)c.getData(mColGrpMeta_KeySet, data_len); data = (char*)c.getData(mColGrpMeta_KeySet + colOffset, data_len);
if(data) if(data)
ok &= grpMeta->keys.GetTlv(data, data_len, &offset); ok &= grpMeta->keys.GetTlv(data, data_len, &offset);
@ -520,22 +530,22 @@ RsGxsGrpMetaData* RsDataService::locked_getGrpMeta(RetroCursor &c)
grpMeta->keys.TlvClear() ; grpMeta->keys.TlvClear() ;
// local meta // local meta
grpMeta->mSubscribeFlags = c.getInt32(mColGrpMeta_SubscrFlag); grpMeta->mSubscribeFlags = c.getInt32(mColGrpMeta_SubscrFlag + colOffset);
grpMeta->mPop = c.getInt32(mColGrpMeta_Pop); grpMeta->mPop = c.getInt32(mColGrpMeta_Pop + colOffset);
grpMeta->mVisibleMsgCount = c.getInt32(mColGrpMeta_MsgCount); grpMeta->mVisibleMsgCount = c.getInt32(mColGrpMeta_MsgCount + colOffset);
grpMeta->mLastPost = c.getInt32(mColGrpMeta_LastPost); grpMeta->mLastPost = c.getInt32(mColGrpMeta_LastPost + colOffset);
grpMeta->mGroupStatus = c.getInt32(mColGrpMeta_Status); grpMeta->mGroupStatus = c.getInt32(mColGrpMeta_Status + colOffset);
c.getString(mColGrpMeta_CircleId, tempId); c.getString(mColGrpMeta_CircleId + colOffset, tempId);
grpMeta->mCircleId = RsGxsCircleId(tempId); grpMeta->mCircleId = RsGxsCircleId(tempId);
grpMeta->mCircleType = c.getInt32(mColGrpMeta_CircleType); grpMeta->mCircleType = c.getInt32(mColGrpMeta_CircleType + colOffset);
c.getString(mColGrpMeta_InternCircle, tempId); c.getString(mColGrpMeta_InternCircle + colOffset, tempId);
grpMeta->mInternalCircle = RsGxsCircleId(tempId); grpMeta->mInternalCircle = RsGxsCircleId(tempId);
std::string s ; c.getString(mColGrpMeta_Originator, s) ; std::string s ; c.getString(mColGrpMeta_Originator + colOffset, s) ;
grpMeta->mOriginator = RsPeerId(s); grpMeta->mOriginator = RsPeerId(s);
grpMeta->mAuthenFlags = c.getInt32(mColGrpMeta_AuthenFlags); grpMeta->mAuthenFlags = c.getInt32(mColGrpMeta_AuthenFlags + colOffset);
grpMeta->mRecvTS = c.getInt32(mColGrpMeta_RecvTs); grpMeta->mRecvTS = c.getInt32(mColGrpMeta_RecvTs + colOffset);
c.getString(mColGrpMeta_ParentGrpId, tempId); c.getString(mColGrpMeta_ParentGrpId, tempId);
@ -591,7 +601,7 @@ RsNxsGrp* RsDataService::locked_getGroup(RetroCursor &c)
return NULL; return NULL;
} }
RsGxsMsgMetaData* RsDataService::locked_getMsgMeta(RetroCursor &c) RsGxsMsgMetaData* RsDataService::locked_getMsgMeta(RetroCursor &c, int colOffset)
{ {
RsGxsMsgMetaData* msgMeta = new RsGxsMsgMetaData(); RsGxsMsgMetaData* msgMeta = new RsGxsMsgMetaData();
@ -602,44 +612,43 @@ RsGxsMsgMetaData* RsDataService::locked_getMsgMeta(RetroCursor &c)
char* data = NULL; char* data = NULL;
std::string gId; std::string gId;
c.getString(mColMsgMeta_GrpId, gId); c.getString(mColMsgMeta_GrpId + colOffset, gId);
msgMeta->mGroupId = RsGxsGroupId(gId); msgMeta->mGroupId = RsGxsGroupId(gId);
std::string temp; std::string temp;
c.getString(mColMsgMeta_MsgId, temp); c.getString(mColMsgMeta_MsgId + colOffset, temp);
msgMeta->mMsgId = RsGxsMessageId(temp); msgMeta->mMsgId = RsGxsMessageId(temp);
// without these, a msg is meaningless // without these, a msg is meaningless
ok &= (!msgMeta->mGroupId.isNull()) && (!msgMeta->mMsgId.isNull()); ok &= (!msgMeta->mGroupId.isNull()) && (!msgMeta->mMsgId.isNull());
c.getString(mColMsgMeta_OrigMsgId, temp); c.getString(mColMsgMeta_OrigMsgId + colOffset, temp);
msgMeta->mOrigMsgId = RsGxsMessageId(temp); msgMeta->mOrigMsgId = RsGxsMessageId(temp);
c.getString(mColMsgMeta_NxsIdentity, temp); c.getString(mColMsgMeta_NxsIdentity + colOffset, temp);
msgMeta->mAuthorId = RsGxsId(temp); msgMeta->mAuthorId = RsGxsId(temp);
c.getString(mColMsgMeta_Name, msgMeta->mMsgName); c.getString(mColMsgMeta_Name + colOffset, msgMeta->mMsgName);
c.getString(mColMsgMeta_NxsServString, msgMeta->mServiceString); c.getString(mColMsgMeta_NxsServString + colOffset, msgMeta->mServiceString);
c.getString(mColMsgMeta_NxsHash, temp); c.getString(mColMsgMeta_NxsHash + colOffset, temp);
msgMeta->mHash = RsFileHash(temp); msgMeta->mHash = RsFileHash(temp);
msgMeta->recvTS = c.getInt32(mColMsgMeta_RecvTs); msgMeta->recvTS = c.getInt32(mColMsgMeta_RecvTs + colOffset);
offset = 0; offset = 0;
data = (char*)c.getData(mColMsgMeta_SignSet, data_len); data = (char*)c.getData(mColMsgMeta_SignSet + colOffset, data_len);
msgMeta->signSet.GetTlv(data, data_len, &offset); msgMeta->signSet.GetTlv(data, data_len, &offset);
msgMeta->mMsgSize = c.getInt32(mColMsgMeta_NxsDataLen); msgMeta->mMsgSize = c.getInt32(mColMsgMeta_NxsDataLen + colOffset);
msgMeta->mMsgFlags = c.getInt32(mColMsgMeta_NxsFlags); msgMeta->mMsgFlags = c.getInt32(mColMsgMeta_NxsFlags + colOffset);
msgMeta->mPublishTs = c.getInt32(mColMsgMeta_TimeStamp); msgMeta->mPublishTs = c.getInt32(mColMsgMeta_TimeStamp + colOffset);
offset = 0; data_len = 0; offset = 0; data_len = 0;
// thread and parent id // thread and parent id
c.getString(mColMsgMeta_MsgThreadId, temp); c.getString(mColMsgMeta_MsgThreadId + colOffset, temp);
msgMeta->mThreadId = RsGxsMessageId(temp); msgMeta->mThreadId = RsGxsMessageId(temp);
c.getString(mColMsgMeta_MsgParentId, temp); c.getString(mColMsgMeta_MsgParentId + colOffset, temp);
msgMeta->mParentId = RsGxsMessageId(temp); msgMeta->mParentId = RsGxsMessageId(temp);
// local meta // local meta
msgMeta->mMsgStatus = c.getInt32(mColMsgMeta_MsgStatus); msgMeta->mMsgStatus = c.getInt32(mColMsgMeta_MsgStatus + colOffset);
msgMeta->mChildTs = c.getInt32(mColMsgMeta_ChildTs); msgMeta->mChildTs = c.getInt32(mColMsgMeta_ChildTs + colOffset);
if(ok) if(ok)
return msgMeta; return msgMeta;
@ -1020,13 +1029,13 @@ int RsDataService::retrieveNxsGrps(std::map<RsGxsGroupId, RsNxsGrp *> &grp, bool
if(grp.empty()){ if(grp.empty()){
RsStackMutex stack(mDbMutex); RsStackMutex stack(mDbMutex);
RetroCursor* c = mDb->sqlQuery(GRP_TABLE_NAME, mGrpColumns, "", ""); RetroCursor* c = mDb->sqlQuery(GRP_TABLE_NAME, withMeta ? mGrpColumnsWithMeta : mGrpColumns, "", "");
if(c) if(c)
{ {
std::vector<RsNxsGrp*> grps; std::vector<RsNxsGrp*> grps;
locked_retrieveGroups(c, grps); locked_retrieveGroups(c, grps, withMeta ? mColGrp_WithMetaOffset : 0);
std::vector<RsNxsGrp*>::iterator vit = grps.begin(); std::vector<RsNxsGrp*>::iterator vit = grps.begin();
#ifdef RS_DATA_SERVICE_DEBUG_TIME #ifdef RS_DATA_SERVICE_DEBUG_TIME
@ -1051,12 +1060,12 @@ int RsDataService::retrieveNxsGrps(std::map<RsGxsGroupId, RsNxsGrp *> &grp, bool
for(; mit != grp.end(); ++mit) for(; mit != grp.end(); ++mit)
{ {
const RsGxsGroupId& grpId = mit->first; const RsGxsGroupId& grpId = mit->first;
RetroCursor* c = mDb->sqlQuery(GRP_TABLE_NAME, mGrpColumns, "grpId='" + grpId.toStdString() + "'", ""); RetroCursor* c = mDb->sqlQuery(GRP_TABLE_NAME, withMeta ? mGrpColumnsWithMeta : mGrpColumns, "grpId='" + grpId.toStdString() + "'", "");
if(c) if(c)
{ {
std::vector<RsNxsGrp*> grps; std::vector<RsNxsGrp*> grps;
locked_retrieveGroups(c, grps); locked_retrieveGroups(c, grps, withMeta ? mColGrp_WithMetaOffset : 0);
if(!grps.empty()) if(!grps.empty())
{ {
@ -1085,38 +1094,10 @@ int RsDataService::retrieveNxsGrps(std::map<RsGxsGroupId, RsNxsGrp *> &grp, bool
std::cerr << "RsDataService::retrieveNxsGrps() " << mDbName << ", Requests: " << requestedGroups << ", Results: " << resultCount << ", Time: " << timer.duration() << std::endl; std::cerr << "RsDataService::retrieveNxsGrps() " << mDbName << ", Requests: " << requestedGroups << ", Results: " << resultCount << ", Time: " << timer.duration() << std::endl;
#endif #endif
if(withMeta && !grp.empty())
{
std::map<RsGxsGroupId, RsGxsGrpMetaData*> metaMap;
std::map<RsGxsGroupId, RsNxsGrp *>::iterator mit = grp.begin();
for(; mit != grp.end(); ++mit)
metaMap.insert(std::make_pair(mit->first, (RsGxsGrpMetaData*)(NULL)));
retrieveGxsGrpMetaData(metaMap);
mit = grp.begin();
for(; mit != grp.end(); ++mit)
{
RsNxsGrp* grpPtr = grp[mit->first];
grpPtr->metaData = metaMap[mit->first];
#ifdef RS_DATA_SERVICE_DEBUG
std::cerr << "RsDataService::retrieveNxsGrps() GrpId: " << mit->first.toStdString();
std::cerr << " CircleType: " << (uint32_t) grpPtr->metaData->mCircleType;
std::cerr << " CircleId: " << grpPtr->metaData->mCircleId.toStdString();
std::cerr << std::endl;
#endif
}
#ifdef RS_DATA_SERVICE_DEBUG_TIME
std::cerr << "RsDataService::retrieveNxsGrps() " << mDbName << ", Time with meta: " << timer.duration() << std::endl;
#endif
}
return 1; return 1;
} }
void RsDataService::locked_retrieveGroups(RetroCursor* c, std::vector<RsNxsGrp*>& grps){ void RsDataService::locked_retrieveGroups(RetroCursor* c, std::vector<RsNxsGrp*>& grps, int metaOffset){
if(c){ if(c){
bool valid = c->moveToFirst(); bool valid = c->moveToFirst();
@ -1127,6 +1108,9 @@ void RsDataService::locked_retrieveGroups(RetroCursor* c, std::vector<RsNxsGrp*>
// only add the latest grp info // only add the latest grp info
if(g) if(g)
{ {
if (metaOffset) {
g->metaData = locked_getGrpMeta(*c, metaOffset);
}
grps.push_back(g); grps.push_back(g);
} }
valid = c->moveToNext(); valid = c->moveToNext();
@ -1143,8 +1127,6 @@ int RsDataService::retrieveNxsMsgs(const GxsMsgReq &reqIds, GxsMsgResult &msg, b
GxsMsgReq::const_iterator mit = reqIds.begin(); GxsMsgReq::const_iterator mit = reqIds.begin();
GxsMsgReq metaReqIds;// collects metaReqIds if needed
for(; mit != reqIds.end(); ++mit) for(; mit != reqIds.end(); ++mit)
{ {
@ -1158,15 +1140,11 @@ int RsDataService::retrieveNxsMsgs(const GxsMsgReq &reqIds, GxsMsgResult &msg, b
RsStackMutex stack(mDbMutex); RsStackMutex stack(mDbMutex);
RetroCursor* c = mDb->sqlQuery(MSG_TABLE_NAME, mMsgColumns, KEY_GRP_ID+ "='" + grpId.toStdString() + "'", ""); RetroCursor* c = mDb->sqlQuery(MSG_TABLE_NAME, withMeta ? mMsgColumnsWithMeta : mMsgColumns, KEY_GRP_ID+ "='" + grpId.toStdString() + "'", "");
if(c) if(c)
{ {
locked_retrieveMessages(c, msgSet); locked_retrieveMessages(c, msgSet, withMeta ? mColMsg_WithMetaOffset : 0);
#ifdef RS_DATA_SERVICE_DEBUG_TIME
resultCount += msgSet.size();
#endif
} }
delete c; delete c;
@ -1180,36 +1158,24 @@ int RsDataService::retrieveNxsMsgs(const GxsMsgReq &reqIds, GxsMsgResult &msg, b
RsStackMutex stack(mDbMutex); RsStackMutex stack(mDbMutex);
RetroCursor* c = mDb->sqlQuery(MSG_TABLE_NAME, mMsgColumns, KEY_GRP_ID+ "='" + grpId.toStdString() RetroCursor* c = mDb->sqlQuery(MSG_TABLE_NAME, withMeta ? mMsgColumnsWithMeta : mMsgColumns, KEY_GRP_ID+ "='" + grpId.toStdString()
+ "' AND " + KEY_MSG_ID + "='" + msgId.toStdString() + "'", ""); + "' AND " + KEY_MSG_ID + "='" + msgId.toStdString() + "'", "");
if(c) if(c)
{ {
locked_retrieveMessages(c, msgSet); locked_retrieveMessages(c, msgSet, withMeta ? mColMsg_WithMetaOffset : 0);
#ifdef RS_DATA_SERVICE_DEBUG_TIME
resultCount += c->getResultCount();
#endif
} }
delete c; delete c;
} }
} }
#ifdef RS_DATA_SERVICE_DEBUG_TIME
resultCount += msgSet.size();
#endif
msg[grpId] = msgSet; msg[grpId] = msgSet;
if(withMeta)
{
std::vector<RsGxsMessageId> msgIds;
std::vector<RsNxsMsg*>::iterator lit = msgSet.begin(),
lit_end = msgSet.end();
for(; lit != lit_end; ++lit)
msgIds.push_back( (*lit)->msgId );
metaReqIds[grpId] = msgIds;
}
msgSet.clear(); msgSet.clear();
} }
@ -1217,73 +1183,19 @@ int RsDataService::retrieveNxsMsgs(const GxsMsgReq &reqIds, GxsMsgResult &msg, b
std::cerr << "RsDataService::retrieveNxsMsgs() " << mDbName << ", Requests: " << reqIds.size() << ", Results: " << resultCount << ", Time: " << timer.duration() << std::endl; std::cerr << "RsDataService::retrieveNxsMsgs() " << mDbName << ", Requests: " << reqIds.size() << ", Results: " << resultCount << ", Time: " << timer.duration() << std::endl;
#endif #endif
// tres expensive !?
if(withMeta)
{
GxsMsgMetaResult metaResult;
// request with meta ids so there is no chance of
// a mem leak being left over
retrieveGxsMsgMetaData(metaReqIds, metaResult);
GxsMsgResult::iterator mit2 = msg.begin(), mit2_end = msg.end();
for(; mit2 != mit2_end; ++mit2)
{
const RsGxsGroupId& grpId = mit2->first;
std::vector<RsNxsMsg*>& msgV = msg[grpId];
std::vector<RsNxsMsg*>::iterator lit = msgV.begin(),
lit_end = msgV.end();
// as retrieval only attempts to retrieve what was found this elimiates chance
// of a memory fault as all are assigned
for(; lit != lit_end; ++lit)
{
std::vector<RsGxsMsgMetaData*>& msgMetaV = metaResult[grpId];
std::vector<RsGxsMsgMetaData*>::iterator meta_lit = msgMetaV.begin();
RsNxsMsg* msgPtr = *lit;
for(; meta_lit != msgMetaV.end(); )
{
RsGxsMsgMetaData* meta = *meta_lit;
if(meta->mMsgId == msgPtr->msgId)
{
msgPtr->metaData = meta;
meta_lit = msgMetaV.erase(meta_lit);
}else{
++meta_lit;
}
}
}
std::vector<RsGxsMsgMetaData*>& msgMetaV = metaResult[grpId];
std::vector<RsGxsMsgMetaData*>::iterator meta_lit;
// clean up just in case, should not go in here
for(meta_lit = msgMetaV.begin(); meta_lit !=
msgMetaV.end(); )
{
RsGxsMsgMetaData* meta = *meta_lit;
delete meta;
meta_lit = msgMetaV.erase(meta_lit);
}
}
#ifdef RS_DATA_SERVICE_DEBUG_TIME
std::cerr << "RsDataService::retrieveNxsMsgs() " << mDbName << ", Time with meta: " << timer.duration() << std::endl;
#endif
}
return 1; return 1;
} }
void RsDataService::locked_retrieveMessages(RetroCursor *c, std::vector<RsNxsMsg *> &msgs) void RsDataService::locked_retrieveMessages(RetroCursor *c, std::vector<RsNxsMsg *> &msgs, int metaOffset)
{ {
bool valid = c->moveToFirst(); bool valid = c->moveToFirst();
while(valid){ while(valid){
RsNxsMsg* m = locked_getMessage(*c); RsNxsMsg* m = locked_getMessage(*c);
if(m){ if(m){
if (metaOffset) {
m->metaData = locked_getMsgMeta(*c, metaOffset);
}
msgs.push_back(m); msgs.push_back(m);
} }
@ -1318,10 +1230,6 @@ int RsDataService::retrieveGxsMsgMetaData(const GxsMsgReq& reqIds, GxsMsgMetaRes
if (c) if (c)
{ {
locked_retrieveMsgMeta(c, metaSet); locked_retrieveMsgMeta(c, metaSet);
#ifdef RS_DATA_SERVICE_DEBUG_TIME
resultCount += metaSet.size();
#endif
} }
}else{ }else{
@ -1336,14 +1244,14 @@ int RsDataService::retrieveGxsMsgMetaData(const GxsMsgReq& reqIds, GxsMsgMetaRes
if (c) if (c)
{ {
locked_retrieveMsgMeta(c, metaSet); locked_retrieveMsgMeta(c, metaSet);
#ifdef RS_DATA_SERVICE_DEBUG_TIME
resultCount += c->getResultCount();
#endif
} }
} }
} }
#ifdef RS_DATA_SERVICE_DEBUG_TIME
resultCount += metaSet.size();
#endif
msgMeta[grpId] = metaSet; msgMeta[grpId] = metaSet;
} }
@ -1361,7 +1269,7 @@ void RsDataService::locked_retrieveMsgMeta(RetroCursor *c, std::vector<RsGxsMsgM
{ {
bool valid = c->moveToFirst(); bool valid = c->moveToFirst();
while(valid){ while(valid){
RsGxsMsgMetaData* m = locked_getMsgMeta(*c); RsGxsMsgMetaData* m = locked_getMsgMeta(*c, 0);
if(m != NULL) if(m != NULL)
msgMeta.push_back(m); msgMeta.push_back(m);
@ -1402,7 +1310,7 @@ int RsDataService::retrieveGxsGrpMetaData(std::map<RsGxsGroupId, RsGxsGrpMetaDat
while(valid) while(valid)
{ {
RsGxsGrpMetaData* g = locked_getGrpMeta(*c); RsGxsGrpMetaData* g = locked_getGrpMeta(*c, 0);
if(g) if(g)
{ {
grp[g->mGroupId] = g; grp[g->mGroupId] = g;
@ -1431,7 +1339,7 @@ int RsDataService::retrieveGxsGrpMetaData(std::map<RsGxsGroupId, RsGxsGrpMetaDat
while(valid) while(valid)
{ {
RsGxsGrpMetaData* g = locked_getGrpMeta(*c); RsGxsGrpMetaData* g = locked_getGrpMeta(*c, 0);
if(g) if(g)
{ {

17
libretroshare/src/gxs/rsdataservice.h
View File

@ -181,14 +181,15 @@ private:
* @param c cursor to result set * @param c cursor to result set
* @param msgs messages retrieved from cursor are stored here * @param msgs messages retrieved from cursor are stored here
*/ */
void locked_retrieveMessages(RetroCursor* c, std::vector<RsNxsMsg*>& msgs); void locked_retrieveMessages(RetroCursor* c, std::vector<RsNxsMsg*>& msgs, int metaOffset);
/*! /*!
* Retrieves all the grp results from a cursor * Retrieves all the grp results from a cursor
* @param c cursor to result set * @param c cursor to result set
* @param grps groups retrieved from cursor are stored here * @param grps groups retrieved from cursor are stored here
* @param withMeta this initialise the metaData member of the nxsgroups retrieved
*/ */
void locked_retrieveGroups(RetroCursor* c, std::vector<RsNxsGrp*>& grps); void locked_retrieveGroups(RetroCursor* c, std::vector<RsNxsGrp*>& grps, int metaOffset);
/*! /*!
* Retrieves all the msg meta results from a cursor * Retrieves all the msg meta results from a cursor
@ -201,13 +202,13 @@ private:
* extracts a msg meta item from a cursor at its * extracts a msg meta item from a cursor at its
* current position * current position
*/ */
RsGxsMsgMetaData* locked_getMsgMeta(RetroCursor& c); RsGxsMsgMetaData* locked_getMsgMeta(RetroCursor& c, int colOffset);
/*! /*!
* extracts a grp meta item from a cursor at its * extracts a grp meta item from a cursor at its
* current position * current position
*/ */
RsGxsGrpMetaData* locked_getGrpMeta(RetroCursor& c); RsGxsGrpMetaData* locked_getGrpMeta(RetroCursor& c, int colOffset);
/*! /*!
* extracts a msg item from a cursor at its * extracts a msg item from a cursor at its
@ -257,10 +258,12 @@ private:
std::list<std::string> mMsgColumns; std::list<std::string> mMsgColumns;
std::list<std::string> mMsgMetaColumns; std::list<std::string> mMsgMetaColumns;
std::list<std::string> mMsgColumnsWithMeta;
std::list<std::string> mMsgIdColumn; std::list<std::string> mMsgIdColumn;
std::list<std::string> mGrpColumns; std::list<std::string> mGrpColumns;
std::list<std::string> mGrpMetaColumns; std::list<std::string> mGrpMetaColumns;
std::list<std::string> mGrpColumnsWithMeta;
std::list<std::string> mGrpIdColumn; std::list<std::string> mGrpIdColumn;
// Message meta column // Message meta column
@ -287,6 +290,9 @@ private:
int mColMsg_MetaData; int mColMsg_MetaData;
int mColMsg_MsgId; int mColMsg_MsgId;
// Message columns with meta
int mColMsg_WithMetaOffset;
// Group meta columns // Group meta columns
int mColGrpMeta_GrpId; int mColGrpMeta_GrpId;
int mColGrpMeta_TimeStamp; int mColGrpMeta_TimeStamp;
@ -319,6 +325,9 @@ private:
int mColGrp_NxsData; int mColGrp_NxsData;
int mColGrp_MetaData; int mColGrp_MetaData;
// Group columns with meta
int mColGrp_WithMetaOffset;
// Group id columns // Group id columns
int mColGrpId_GrpId; int mColGrpId_GrpId;

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

@ -1198,7 +1198,6 @@ bool RsGenExchange::getGroupMeta(const uint32_t &token, std::list<RsGroupMetaDat
return ok; return ok;
} }
bool RsGenExchange::getMsgMeta(const uint32_t &token, bool RsGenExchange::getMsgMeta(const uint32_t &token,
GxsMsgMetaMap &msgInfo) GxsMsgMetaMap &msgInfo)
{ {
@ -1215,7 +1214,6 @@ bool RsGenExchange::getMsgMeta(const uint32_t &token,
{ {
std::vector<RsGxsMsgMetaData*>& metaV = mit->second; std::vector<RsGxsMsgMetaData*>& metaV = mit->second;
msgInfo[mit->first] = std::vector<RsMsgMetaData>();
std::vector<RsMsgMetaData>& msgInfoV = msgInfo[mit->first]; std::vector<RsMsgMetaData>& msgInfoV = msgInfo[mit->first];
std::vector<RsGxsMsgMetaData*>::iterator vit = metaV.begin(); std::vector<RsGxsMsgMetaData*>::iterator vit = metaV.begin();
@ -1244,7 +1242,6 @@ bool RsGenExchange::getMsgRelatedMeta(const uint32_t &token, GxsMsgRelatedMetaMa
{ {
std::vector<RsGxsMsgMetaData*>& metaV = mit->second; std::vector<RsGxsMsgMetaData*>& metaV = mit->second;
msgMeta[mit->first] = std::vector<RsMsgMetaData>();
std::vector<RsMsgMetaData>& msgInfoV = msgMeta[mit->first]; std::vector<RsMsgMetaData>& msgInfoV = msgMeta[mit->first];
std::vector<RsGxsMsgMetaData*>::iterator vit = metaV.begin(); std::vector<RsGxsMsgMetaData*>::iterator vit = metaV.begin();
@ -1328,14 +1325,14 @@ bool RsGenExchange::getMsgData(const uint32_t &token, GxsMsgDataMap &msgItems)
RS_STACK_MUTEX(mGenMtx) ; RS_STACK_MUTEX(mGenMtx) ;
NxsMsgDataResult msgResult; NxsMsgDataResult msgResult;
bool ok = mDataAccess->getMsgData(token, msgResult); bool ok = mDataAccess->getMsgData(token, msgResult);
NxsMsgDataResult::iterator mit = msgResult.begin();
if(ok) if(ok)
{ {
NxsMsgDataResult::iterator mit = msgResult.begin();
for(; mit != msgResult.end(); ++mit) for(; mit != msgResult.end(); ++mit)
{ {
std::vector<RsGxsMsgItem*> gxsMsgItems;
const RsGxsGroupId& grpId = mit->first; const RsGxsGroupId& grpId = mit->first;
std::vector<RsGxsMsgItem*>& gxsMsgItems = msgItems[grpId];
std::vector<RsNxsMsg*>& nxsMsgsV = mit->second; std::vector<RsNxsMsg*>& nxsMsgsV = mit->second;
std::vector<RsNxsMsg*>::iterator vit = nxsMsgsV.begin(); std::vector<RsNxsMsg*>::iterator vit = nxsMsgsV.begin();
for(; vit != nxsMsgsV.end(); ++vit) for(; vit != nxsMsgsV.end(); ++vit)
@ -1368,7 +1365,6 @@ bool RsGenExchange::getMsgData(const uint32_t &token, GxsMsgDataMap &msgItems)
} }
delete msg; delete msg;
} }
msgItems[grpId] = gxsMsgItems;
} }
} }
return ok; return ok;
@ -1380,17 +1376,15 @@ bool RsGenExchange::getMsgRelatedData(const uint32_t &token, GxsMsgRelatedDataMa
NxsMsgRelatedDataResult msgResult; NxsMsgRelatedDataResult msgResult;
bool ok = mDataAccess->getMsgRelatedData(token, msgResult); bool ok = mDataAccess->getMsgRelatedData(token, msgResult);
if(ok) if(ok)
{ {
NxsMsgRelatedDataResult::iterator mit = msgResult.begin(); NxsMsgRelatedDataResult::iterator mit = msgResult.begin();
for(; mit != msgResult.end(); ++mit) for(; mit != msgResult.end(); ++mit)
{ {
std::vector<RsGxsMsgItem*> gxsMsgItems;
const RsGxsGrpMsgIdPair& msgId = mit->first; const RsGxsGrpMsgIdPair& msgId = mit->first;
std::vector<RsGxsMsgItem*> &gxsMsgItems = msgItems[msgId];
std::vector<RsNxsMsg*>& nxsMsgsV = mit->second; std::vector<RsNxsMsg*>& nxsMsgsV = mit->second;
std::vector<RsNxsMsg*>::iterator vit std::vector<RsNxsMsg*>::iterator vit = nxsMsgsV.begin();
= nxsMsgsV.begin();
for(; vit != nxsMsgsV.end(); ++vit) for(; vit != nxsMsgsV.end(); ++vit)
{ {
RsNxsMsg*& msg = *vit; RsNxsMsg*& msg = *vit;
@ -1423,15 +1417,11 @@ bool RsGenExchange::getMsgRelatedData(const uint32_t &token, GxsMsgRelatedDataMa
delete msg; delete msg;
} }
msgItems[msgId] = gxsMsgItems;
} }
} }
return ok; return ok;
} }
RsTokenService* RsGenExchange::getTokenService() RsTokenService* RsGenExchange::getTokenService()
{ {
return mDataAccess; return mDataAccess;
@ -2365,6 +2355,12 @@ void RsGenExchange::publishGrps()
} }
else if(ret == SERVICE_CREATE_FAIL_TRY_LATER) else if(ret == SERVICE_CREATE_FAIL_TRY_LATER)
{ {
// if the service is not ready yet, reset the start timestamp to give the service more time
// the service should have it's own timeout mechanism
// services should return SERVICE_CREATE_FAIL if the action timed out
// at the moment this is only important for the idservice:
// the idservice may ask the user for a password, and the user needs time
ggps.mStartTS = now;
create = CREATE_FAIL_TRY_LATER; create = CREATE_FAIL_TRY_LATER;
} }
else if(ret == SERVICE_CREATE_FAIL) else if(ret == SERVICE_CREATE_FAIL)

26
libretroshare/src/gxs/rsgxsdataaccess.cc
View File

@ -448,7 +448,7 @@ bool RsGxsDataAccess::getGroupData(const uint32_t& token, std::list<RsNxsGrp*>&
if(gmreq) if(gmreq)
{ {
grpData = gmreq->mGroupData; grpData.swap(gmreq->mGroupData);
gmreq->mGroupData.clear(); gmreq->mGroupData.clear();
locked_updateRequestStatus(token, GXS_REQUEST_V2_STATUS_DONE); locked_updateRequestStatus(token, GXS_REQUEST_V2_STATUS_DONE);
}else{ }else{
@ -480,7 +480,7 @@ bool RsGxsDataAccess::getMsgData(const uint32_t& token, NxsMsgDataResult& msgDat
if(mdreq) if(mdreq)
{ {
msgData = mdreq->mMsgData; msgData.swap(mdreq->mMsgData);
mdreq->mMsgData.clear(); mdreq->mMsgData.clear();
locked_updateRequestStatus(token, GXS_REQUEST_V2_STATUS_DONE); locked_updateRequestStatus(token, GXS_REQUEST_V2_STATUS_DONE);
} }
@ -517,7 +517,7 @@ bool RsGxsDataAccess::getMsgRelatedData(const uint32_t &token, NxsMsgRelatedData
if(mrireq) if(mrireq)
{ {
msgData = mrireq->mMsgDataResult; msgData.swap(mrireq->mMsgDataResult);
mrireq->mMsgDataResult.clear(); mrireq->mMsgDataResult.clear();
locked_updateRequestStatus(token, GXS_REQUEST_V2_STATUS_DONE); locked_updateRequestStatus(token, GXS_REQUEST_V2_STATUS_DONE);
} }
@ -551,7 +551,7 @@ bool RsGxsDataAccess::getMsgSummary(const uint32_t& token, GxsMsgMetaResult& msg
if(mmreq) if(mmreq)
{ {
msgInfo = mmreq->mMsgMetaData; msgInfo.swap(mmreq->mMsgMetaData);
mmreq->mMsgMetaData.clear(); mmreq->mMsgMetaData.clear();
locked_updateRequestStatus(token, GXS_REQUEST_V2_STATUS_DONE); locked_updateRequestStatus(token, GXS_REQUEST_V2_STATUS_DONE);
@ -591,7 +591,7 @@ bool RsGxsDataAccess::getMsgRelatedSummary(const uint32_t &token, MsgRelatedMeta
if(mrireq) if(mrireq)
{ {
msgMeta = mrireq->mMsgMetaResult; msgMeta.swap(mrireq->mMsgMetaResult);
mrireq->mMsgMetaResult.clear(); mrireq->mMsgMetaResult.clear();
locked_updateRequestStatus(token, GXS_REQUEST_V2_STATUS_DONE); locked_updateRequestStatus(token, GXS_REQUEST_V2_STATUS_DONE);
} }
@ -630,7 +630,7 @@ bool RsGxsDataAccess::getMsgRelatedList(const uint32_t &token, MsgRelatedIdResul
if(mrireq) if(mrireq)
{ {
msgIds = mrireq->mMsgIdResult; msgIds.swap(mrireq->mMsgIdResult);
mrireq->mMsgIdResult.clear(); mrireq->mMsgIdResult.clear();
locked_updateRequestStatus(token, GXS_REQUEST_V2_STATUS_DONE); locked_updateRequestStatus(token, GXS_REQUEST_V2_STATUS_DONE);
} }
@ -664,7 +664,7 @@ bool RsGxsDataAccess::getMsgList(const uint32_t& token, GxsMsgIdResult& msgIds)
if(mireq) if(mireq)
{ {
msgIds = mireq->mMsgIdResult; msgIds.swap(mireq->mMsgIdResult);
mireq->mMsgIdResult.clear(); mireq->mMsgIdResult.clear();
locked_updateRequestStatus(token, GXS_REQUEST_V2_STATUS_DONE); locked_updateRequestStatus(token, GXS_REQUEST_V2_STATUS_DONE);
} }
@ -697,7 +697,7 @@ bool RsGxsDataAccess::getGroupList(const uint32_t& token, std::list<RsGxsGroupId
if(gireq) if(gireq)
{ {
groupIds = gireq->mGroupIdResult; groupIds.swap(gireq->mGroupIdResult);
gireq->mGroupIdResult.clear(); gireq->mGroupIdResult.clear();
locked_updateRequestStatus(token, GXS_REQUEST_V2_STATUS_DONE); locked_updateRequestStatus(token, GXS_REQUEST_V2_STATUS_DONE);
@ -1032,31 +1032,25 @@ bool RsGxsDataAccess::getGroupList(const std::list<RsGxsGroupId>& grpIdsIn, cons
bool RsGxsDataAccess::getMsgData(MsgDataReq* req) bool RsGxsDataAccess::getMsgData(MsgDataReq* req)
{ {
GxsMsgResult result;
GxsMsgReq msgIdOut; GxsMsgReq msgIdOut;
// filter based on options // filter based on options
getMsgList(req->mMsgIds, req->Options, msgIdOut); getMsgList(req->mMsgIds, req->Options, msgIdOut);
mDataStore->retrieveNxsMsgs(msgIdOut, result, true, true); mDataStore->retrieveNxsMsgs(msgIdOut, req->mMsgData, true, true);
req->mMsgData = result;
return true; return true;
} }
bool RsGxsDataAccess::getMsgSummary(MsgMetaReq* req) bool RsGxsDataAccess::getMsgSummary(MsgMetaReq* req)
{ {
GxsMsgMetaResult result;
GxsMsgReq msgIdOut; GxsMsgReq msgIdOut;
// filter based on options // filter based on options
getMsgList(req->mMsgIds, req->Options, msgIdOut); getMsgList(req->mMsgIds, req->Options, msgIdOut);
mDataStore->retrieveGxsMsgMetaData(msgIdOut, result); mDataStore->retrieveGxsMsgMetaData(msgIdOut, req->mMsgMetaData);
req->mMsgMetaData = result;
return true; return true;
} }

19
libretroshare/src/gxs/rsgxsnetservice.cc
View File

@ -30,6 +30,7 @@
#include "rsgxsnetservice.h" #include "rsgxsnetservice.h"
#include "retroshare/rsconfig.h" #include "retroshare/rsconfig.h"
#include "retroshare/rsreputations.h"
#include "retroshare/rsgxsflags.h" #include "retroshare/rsgxsflags.h"
#include "retroshare/rsgxscircles.h" #include "retroshare/rsgxscircles.h"
#include "pgp/pgpauxutils.h" #include "pgp/pgpauxutils.h"
@ -1996,7 +1997,13 @@ void RsGxsNetService::locked_genReqMsgTransaction(NxsTransaction* tr)
std::cerr << ", no group meta found. Givign up." << std::endl; std::cerr << ", no group meta found. Givign up." << std::endl;
continue; continue;
} }
if(rsReputations->isIdentityBanned(syncItem->authorId))
{
std::cerr << ", Identity " << syncItem->authorId << " is banned. Not requesting message!" << std::endl;
continue ;
}
if(mReputations->haveReputation(syncItem->authorId) || noAuthor) if(mReputations->haveReputation(syncItem->authorId) || noAuthor)
{ {
GixsReputation rep; GixsReputation rep;
@ -2009,7 +2016,7 @@ void RsGxsNetService::locked_genReqMsgTransaction(NxsTransaction* tr)
// if author is required for this message, it will simply get dropped // if author is required for this message, it will simply get dropped
// at genexchange side of things // at genexchange side of things
if(rep.score > (int)grpMeta->mReputationCutOff || noAuthor) if(rep.score >= (int)grpMeta->mReputationCutOff || noAuthor)
{ {
#ifdef NXS_NET_DEBUG #ifdef NXS_NET_DEBUG
std::cerr << ", passed! Adding message to req list." << std::endl; std::cerr << ", passed! Adding message to req list." << std::endl;
@ -2210,7 +2217,13 @@ void RsGxsNetService::locked_genReqGrpTransaction(NxsTransaction* tr)
haveItem = true; haveItem = true;
latestVersion = grpSyncItem->publishTs > metaIter->second->mPublishTs; latestVersion = grpSyncItem->publishTs > metaIter->second->mPublishTs;
} }
if(!grpSyncItem->authorId.isNull() && rsReputations->isIdentityBanned(grpSyncItem->authorId))
{
std::cerr << " Identity " << grpSyncItem->authorId << " is banned. Not syncing group." << std::endl;
continue ;
}
if( (mGrpAutoSync && !haveItem) || latestVersion) if( (mGrpAutoSync && !haveItem) || latestVersion)
{ {
// determine if you need to check reputation // determine if you need to check reputation

4
libretroshare/src/gxs/rsgxsnetutils.cc
View File

@ -99,7 +99,7 @@ bool MsgRespPending::accepted()
GixsReputation rep; GixsReputation rep;
if(getAuthorRep(rep, entry.mAuthorId, mPeerId)) if(getAuthorRep(rep, entry.mAuthorId, mPeerId))
{ {
if(rep.score > mCutOff) if(rep.score >= mCutOff)
{ {
entry.mPassedVetting = true; entry.mPassedVetting = true;
count++; count++;
@ -134,7 +134,7 @@ bool GrpRespPending::accepted()
if(getAuthorRep(rep, entry.mAuthorId, mPeerId)) if(getAuthorRep(rep, entry.mAuthorId, mPeerId))
{ {
if(rep.score > mCutOff) if(rep.score >= mCutOff)
{ {
entry.mPassedVetting = true; entry.mPassedVetting = true;
count++; count++;

1719
libretroshare/src/libretroshare.pro
View File

File diff suppressed because it is too large Load Diff

2
libretroshare/src/pgp/pgpkeyutil.cc
View File

@ -125,7 +125,7 @@ std::string PGPKeyManagement::makeArmouredKey(const unsigned char *keydata,size_
uint32_t crc = compute24bitsCRC((unsigned char *)keydata,key_size) ; uint32_t crc = compute24bitsCRC((unsigned char *)keydata,key_size) ;
unsigned char tmp[3] = { (crc >> 16) & 0xff, (crc >> 8) & 0xff, crc & 0xff } ; unsigned char tmp[3] = { uint8_t((crc >> 16) & 0xff), uint8_t((crc >> 8) & 0xff), uint8_t(crc & 0xff) } ;
std::string crc_string ; std::string crc_string ;
Radix64::encode((const char *)tmp,3,crc_string) ; Radix64::encode((const char *)tmp,3,crc_string) ;

77
libretroshare/src/pqi/Makefile
View File

@ -1,77 +0,0 @@
RS_TOP_DIR = ..
##### Define any flags that are needed for this section #######
###############################################################
###############################################################
include $(RS_TOP_DIR)/scripts/config.mk
###############################################################
BASE_OBJ = pqisecurity.o pqinetwork.o
#pqi_base.o
LOOP_OBJ = pqiloopback.o
STREAM_OBJ = pqistreamer.o pqiarchive.o pqistore.o pqibin.o
MGR_OBJ = pqimonitor.o p3dhtmgr.o p3connmgr.o p3cfgmgr.o p3authmgr.o
GRP_OBJ = pqiperson.o pqihandler.o pqiservice.o pqipersongrp.o
SSL_OBJ = pqissl.o pqissllistener.o pqisslpersongrp.o cleanupxpgp.o
UDP_OBJ = pqissludp.o
OTHER_OBJ = p3notify.o
TESTOBJ = net_test.o dht_test.o net_test1.o netiface_test.o
#conn_test.o
TESTS = net_test dht_test net_test1 netiface_test
#conn_test
ifdef PQI_USE_XPGP
SSL_OBJ += authxpgp.o
TESTOBJ += xpgp_id.o
TESTS += xpgp_id
else
ifdef PQI_USE_SSLONLY
SSL_OBJ += authssl.o
else
SSL_OBJ += authssl.o authgpg.o
TESTOBJ += gpgme_tst.o
TESTS += gpgme_tst
endif
endif
RSOBJ = $(BASE_OBJ) $(LOOP_OBJ) \
$(STREAM_OBJ) \
$(MGR_OBJ) \
$(SSL_OBJ) \
$(UDP_OBJ) \
$(GRP_OBJ) \
$(OTHER_OBJ)
all: librs tests
gpgme_tst: gpgme_tst.o
$(CC) $(CFLAGS) -o gpgme_tst gpgme_tst.o $(LIBS)
xpgp_id: xpgp_id.o
$(CC) $(CFLAGS) -o xpgp_id xpgp_id.o $(LIBS)
dht_test: dht_test.o
$(CC) $(CFLAGS) -o dht_test dht_test.o $(LIBS)
conn_test: conn_test.o
$(CC) $(CFLAGS) -o conn_test conn_test.o $(LIBS)
net_test: net_test.o
$(CC) $(CFLAGS) -o net_test net_test.o $(LIBS)
net_test1: net_test1.o
$(CC) $(CFLAGS) -o net_test1 net_test1.o $(LIBS)
netiface_test: netiface_test.o
$(CC) $(CFLAGS) -o netiface_test netiface_test.o $(LIBS)
###############################################################
include $(RS_TOP_DIR)/scripts/rules.mk
###############################################################

2
libretroshare/src/pqi/authssl.cc
View File

@ -198,7 +198,7 @@ void tls_cleanup()
CRYPTO_set_locking_callback(NULL); CRYPTO_set_locking_callback(NULL);
CRYPTO_set_id_callback(NULL); CRYPTO_set_id_callback(NULL);
if (mutex_buf == NULL) { if (mutex_buf != NULL) {
for (int i = 0; i < CRYPTO_num_locks(); i++) { for (int i = 0; i < CRYPTO_num_locks(); i++) {
pthread_mutex_destroy(&mutex_buf[i]); pthread_mutex_destroy(&mutex_buf[i]);
} }

103
libretroshare/src/pqi/p3linkmgr.cc
View File

@ -964,24 +964,25 @@ bool p3LinkMgrIMPL::connectResult(const RsPeerId &id, bool success, bool isIncom
if (flags == RS_NET_CONN_UDP_ALL) if (flags == RS_NET_CONN_UDP_ALL)
{ {
#ifdef LINKMGR_DEBUG #ifdef LINKMGR_DEBUG
#endif
std::cerr << "p3LinkMgrIMPL::connectResult() Sending Feedback for UDP connection"; std::cerr << "p3LinkMgrIMPL::connectResult() Sending Feedback for UDP connection";
std::cerr << std::endl; std::cerr << std::endl;
#endif
if (success) if (success)
{ {
#ifdef LINKMGR_DEBUG #ifdef LINKMGR_DEBUG
#endif
std::cerr << "p3LinkMgrIMPL::connectResult() UDP Update CONNECTED to: " << id; std::cerr << "p3LinkMgrIMPL::connectResult() UDP Update CONNECTED to: " << id;
std::cerr << std::endl; std::cerr << std::endl;
#endif
mNetMgr->netAssistStatusUpdate(id, NETMGR_DHT_FEEDBACK_CONNECTED); mNetMgr->netAssistStatusUpdate(id, NETMGR_DHT_FEEDBACK_CONNECTED);
} }
else else
{ {
#ifdef LINKMGR_DEBUG #ifdef LINKMGR_DEBUG
#endif
std::cerr << "p3LinkMgrIMPL::connectResult() UDP Update FAILED to: " << id; std::cerr << "p3LinkMgrIMPL::connectResult() UDP Update FAILED to: " << id;
std::cerr << std::endl; std::cerr << std::endl;
#endif
/* have no differentiation between failure and closed? */ /* have no differentiation between failure and closed? */
mNetMgr->netAssistStatusUpdate(id, NETMGR_DHT_FEEDBACK_CONN_FAILED); mNetMgr->netAssistStatusUpdate(id, NETMGR_DHT_FEEDBACK_CONN_FAILED);
@ -1624,6 +1625,17 @@ bool p3LinkMgrIMPL::retryConnectTCP(const RsPeerId &id)
/* first possibility - is it a hidden peer */ /* first possibility - is it a hidden peer */
if (mPeerMgr->isHiddenPeer(id)) if (mPeerMgr->isHiddenPeer(id))
{ {
/* check for valid hidden type */
uint32_t type = mPeerMgr->getHiddenType(id);
if (type & (~RS_HIDDEN_TYPE_MASK))
{
#ifdef LINKMGR_DEBUG
std::cerr << "p3LinkMgrIMPL::retryConnectTCP() invalid hidden type (" << type << ") -> return false";
std::cerr << std::endl;
#endif
return false;
}
struct sockaddr_storage proxy_addr; struct sockaddr_storage proxy_addr;
std::string domain_addr; std::string domain_addr;
uint16_t domain_port; uint16_t domain_port;
@ -1636,7 +1648,7 @@ bool p3LinkMgrIMPL::retryConnectTCP(const RsPeerId &id)
std::map<RsPeerId, peerConnectState>::iterator it; std::map<RsPeerId, peerConnectState>::iterator it;
if (mFriendList.end() != (it = mFriendList.find(id))) if (mFriendList.end() != (it = mFriendList.find(id)))
{ {
locked_ConnectAttempt_ProxyAddress(&(it->second), proxy_addr, domain_addr, domain_port); locked_ConnectAttempt_ProxyAddress(&(it->second), type, proxy_addr, domain_addr, domain_port);
return locked_ConnectAttempt_Complete(&(it->second)); return locked_ConnectAttempt_Complete(&(it->second));
} }
} }
@ -1698,7 +1710,7 @@ bool p3LinkMgrIMPL::retryConnectTCP(const RsPeerId &id)
#define MAX_TCP_ADDR_AGE (3600 * 24 * 14) // two weeks in seconds. #define MAX_TCP_ADDR_AGE (3600 * 24 * 14) // two weeks in seconds.
bool p3LinkMgrIMPL::locked_CheckPotentialAddr(const struct sockaddr_storage &addr, time_t age) bool p3LinkMgrIMPL::locked_CheckPotentialAddr(const struct sockaddr_storage &addr, time_t age)
{ {
#ifdef LINKMGR_DEBUG #ifdef LINKMGR_DEBUG
std::cerr << "p3LinkMgrIMPL::locked_CheckPotentialAddr("; std::cerr << "p3LinkMgrIMPL::locked_CheckPotentialAddr(";
@ -1719,13 +1731,8 @@ bool p3LinkMgrIMPL::locked_CheckPotentialAddr(const struct sockaddr_storage &ad
return false; return false;
} }
bool isValid = sockaddr_storage_isValidNet(addr);
bool isLoopback = sockaddr_storage_isLoopbackNet(addr);
// bool isPrivate = sockaddr_storage_isPrivateNet(addr);
bool isExternal = sockaddr_storage_isExternalNet(addr);
/* if invalid - quick rejection */ /* if invalid - quick rejection */
if (!isValid) if ( ! sockaddr_storage_isValidNet(addr) )
{ {
#ifdef LINKMGR_DEBUG #ifdef LINKMGR_DEBUG
std::cerr << "p3LinkMgrIMPL::locked_CheckPotentialAddr() REJECTING - INVALID"; std::cerr << "p3LinkMgrIMPL::locked_CheckPotentialAddr() REJECTING - INVALID";
@ -1760,60 +1767,7 @@ bool p3LinkMgrIMPL::locked_CheckPotentialAddr(const struct sockaddr_storage &ad
return false ; return false ;
} }
/* if it is an external address, we'll accept it. return true;
* - even it is meant to be a local address.
*/
if (isExternal)
{
#ifdef LINKMGR_DEBUG
std::cerr << "p3LinkMgrIMPL::locked_CheckPotentialAddr() ACCEPTING - EXTERNAL";
std::cerr << std::endl;
#endif
return true;
}
/* if loopback, then okay - probably proxy connection (or local testing).
*/
if (isLoopback)
{
#ifdef LINKMGR_DEBUG
std::cerr << "p3LinkMgrIMPL::locked_CheckPotentialAddr() ACCEPTING - LOOPBACK";
std::cerr << std::endl;
#endif
return true;
}
/* get here, it is private or loopback
* - can only connect to these addresses if we are on the same subnet.
- check net against our local address.
*/
#ifdef LINKMGR_DEBUG
std::cerr << "p3LinkMgrIMPL::locked_CheckPotentialAddr() Checking sameNet against: ";
std::cerr << sockaddr_storage_iptostring(mLocalAddress);
std::cerr << ")";
std::cerr << std::endl;
#endif
if (sockaddr_storage_samenet(mLocalAddress, addr))
{
#ifdef LINKMGR_DEBUG
std::cerr << "p3LinkMgrIMPL::locked_CheckPotentialAddr() ACCEPTING - PRIVATE & sameNET";
std::cerr << std::endl;
#endif
return true;
}
#ifdef LINKMGR_DEBUG
std::cerr << "p3LinkMgrIMPL::locked_CheckPotentialAddr() REJECTING - PRIVATE & !sameNET";
std::cerr << std::endl;
#endif
/* else it fails */
return false;
} }
@ -2018,7 +1972,7 @@ void p3LinkMgrIMPL::locked_ConnectAttempt_AddDynDNS(peerConnectState *peer, std
} }
void p3LinkMgrIMPL::locked_ConnectAttempt_ProxyAddress(peerConnectState *peer, const struct sockaddr_storage &proxy_addr, const std::string &domain_addr, uint16_t domain_port) void p3LinkMgrIMPL::locked_ConnectAttempt_ProxyAddress(peerConnectState *peer, const uint32_t type, const struct sockaddr_storage &proxy_addr, const std::string &domain_addr, uint16_t domain_port)
{ {
#ifdef LINKMGR_DEBUG #ifdef LINKMGR_DEBUG
std::cerr << "p3LinkMgrIMPL::locked_ConnectAttempt_ProxyAddress() trying address: " << domain_addr << ":" << domain_port << std::endl; std::cerr << "p3LinkMgrIMPL::locked_ConnectAttempt_ProxyAddress() trying address: " << domain_addr << ":" << domain_port << std::endl;
@ -2026,7 +1980,22 @@ void p3LinkMgrIMPL::locked_ConnectAttempt_ProxyAddress(peerConnectState *peer,
peerConnectAddress pca; peerConnectAddress pca;
pca.addr = proxy_addr; pca.addr = proxy_addr;
pca.type = RS_NET_CONN_TCP_HIDDEN; switch (type) {
case RS_HIDDEN_TYPE_TOR:
pca.type = RS_NET_CONN_TCP_HIDDEN_TOR;
break;
case RS_HIDDEN_TYPE_I2P:
pca.type = RS_NET_CONN_TCP_HIDDEN_I2P;
break;
case RS_HIDDEN_TYPE_UNKNOWN:
default:
/**** THIS CASE SHOULD NOT BE TRIGGERED - since this function is called with a valid hidden type only ****/
std::cerr << "p3LinkMgrIMPL::locked_ConnectAttempt_ProxyAddress() hidden type of addr: " << domain_addr << " is unkown -> THIS SHOULD NEVER HAPPEN!" << std::endl;
std::cerr << " - peer : " << peer->id << "(" << peer->name << ")" << std::endl;
std::cerr << " - proxy: " << sockaddr_storage_tostring(proxy_addr) << std::endl;
std::cerr << " - addr : " << domain_addr << ":" << domain_port << std::endl;
pca.type = RS_NET_CONN_TCP_UNKNOW_TOPOLOGY;
}
//for the delay, we add a random time and some more time when the friend list is big //for the delay, we add a random time and some more time when the friend list is big
pca.delay = P3CONNMGR_TCP_DEFAULT_DELAY; pca.delay = P3CONNMGR_TCP_DEFAULT_DELAY;

13
libretroshare/src/pqi/p3linkmgr.h
View File

@ -40,16 +40,17 @@ class DNSResolver ;
/* order of attempts ... */ /* order of attempts ... */
const uint32_t RS_NET_CONN_TCP_ALL = 0x000f; const uint32_t RS_NET_CONN_TCP_ALL = 0x00ff;
const uint32_t RS_NET_CONN_UDP_ALL = 0x00f0; const uint32_t RS_NET_CONN_UDP_ALL = 0x0f00;
const uint32_t RS_NET_CONN_TCP_LOCAL = 0x0001; const uint32_t RS_NET_CONN_TCP_LOCAL = 0x0001;
const uint32_t RS_NET_CONN_TCP_EXTERNAL = 0x0002; const uint32_t RS_NET_CONN_TCP_EXTERNAL = 0x0002;
const uint32_t RS_NET_CONN_TCP_UNKNOW_TOPOLOGY = 0x0004; const uint32_t RS_NET_CONN_TCP_UNKNOW_TOPOLOGY = 0x0004;
const uint32_t RS_NET_CONN_TCP_HIDDEN = 0x0008; const uint32_t RS_NET_CONN_TCP_HIDDEN_TOR = 0x0008;
const uint32_t RS_NET_CONN_TCP_HIDDEN_I2P = 0x0010;
const uint32_t RS_NET_CONN_UDP_DHT_SYNC = 0x0010; const uint32_t RS_NET_CONN_UDP_DHT_SYNC = 0x0100;
const uint32_t RS_NET_CONN_UDP_PEER_SYNC = 0x0020; /* coming soon */ const uint32_t RS_NET_CONN_UDP_PEER_SYNC = 0x0200; /* coming soon */
// These are set in pqipersongroup. // These are set in pqipersongroup.
const uint32_t RS_TCP_STD_TIMEOUT_PERIOD = 5; /* 5 seconds! */ const uint32_t RS_TCP_STD_TIMEOUT_PERIOD = 5; /* 5 seconds! */
@ -302,7 +303,7 @@ void locked_ConnectAttempt_CurrentAddresses(peerConnectState *peer, const struc
void locked_ConnectAttempt_HistoricalAddresses(peerConnectState *peer, const pqiIpAddrSet &ipAddrs); void locked_ConnectAttempt_HistoricalAddresses(peerConnectState *peer, const pqiIpAddrSet &ipAddrs);
void locked_ConnectAttempt_AddDynDNS(peerConnectState *peer, std::string dyndns, uint16_t dynPort); void locked_ConnectAttempt_AddDynDNS(peerConnectState *peer, std::string dyndns, uint16_t dynPort);
void locked_ConnectAttempt_AddTunnel(peerConnectState *peer); void locked_ConnectAttempt_AddTunnel(peerConnectState *peer);
void locked_ConnectAttempt_ProxyAddress(peerConnectState *peer, const struct sockaddr_storage &proxy_addr, const std::string &domain_addr, uint16_t domain_port); void locked_ConnectAttempt_ProxyAddress(peerConnectState *peer, const uint32_t type, const struct sockaddr_storage &proxy_addr, const std::string &domain_addr, uint16_t domain_port);
bool locked_ConnectAttempt_Complete(peerConnectState *peer); bool locked_ConnectAttempt_Complete(peerConnectState *peer);

259
libretroshare/src/pqi/p3netmgr.cc
View File

@ -696,9 +696,9 @@ void p3NetMgrIMPL::netExtCheck()
bool isStable = false; bool isStable = false;
struct sockaddr_storage tmpip ; struct sockaddr_storage tmpip ;
std::map<sockaddr_storage,ZeroInt> address_votes ; std::map<sockaddr_storage,ZeroInt> address_votes ;
/* check for External Address */ /* check for External Address */
/* in order of importance */ /* in order of importance */
/* (1) UPnP -> which handles itself */ /* (1) UPnP -> which handles itself */
{ {
@ -708,35 +708,41 @@ void p3NetMgrIMPL::netExtCheck()
/* net Assist */ /* net Assist */
if (netAssistExtAddress(tmpip)) if (netAssistExtAddress(tmpip))
{ {
#if defined(NETMGR_DEBUG_TICK) || defined(NETMGR_DEBUG_RESET) #if defined(NETMGR_DEBUG_TICK) || defined(NETMGR_DEBUG_RESET)
std::cerr << "p3NetMgrIMPL::netExtCheck() Ext supplied from netAssistExternalAddress()" << std::endl; std::cerr << "p3NetMgrIMPL::netExtCheck() Ext supplied from netAssistExternalAddress()" << std::endl;
#endif #endif
if(sockaddr_storage_isValidNet(tmpip)) if(sockaddr_storage_isValidNet(tmpip))
{ {
if(rsBanList->isAddressAccepted(tmpip,RSBANLIST_CHECKING_FLAGS_BLACKLIST)) if(rsBanList->isAddressAccepted(tmpip,RSBANLIST_CHECKING_FLAGS_BLACKLIST))
{ {
// must be stable??? // must be stable???
isStable = true; isStable = true;
mNetFlags.mExtAddr = tmpip; //mNetFlags.mExtAddr = tmpip;
mNetFlags.mExtAddrOk = true; mNetFlags.mExtAddrOk = true;
mNetFlags.mExtAddrStableOk = isStable; mNetFlags.mExtAddrStableOk = isStable;
address_votes[tmpip].n++ ; address_votes[tmpip].n++ ;
}
else std::cerr << "NetAssistAddress reported external address " << sockaddr_storage_iptostring(tmpip) << std::endl;
std::cerr << "(SS) netAssisExternalAddress returned wrong own IP " << sockaddr_storage_iptostring(tmpip) << " (banned). Rejecting." << std::endl; }
} else
std::cerr << "(SS) netAssisExternalAddress returned banned own IP " << sockaddr_storage_iptostring(tmpip) << " (banned). Rejecting." << std::endl;
}
#if defined(NETMGR_DEBUG_TICK) || defined(NETMGR_DEBUG_RESET) #if defined(NETMGR_DEBUG_TICK) || defined(NETMGR_DEBUG_RESET)
else else
{ {
std::cerr << "p3NetMgrIMPL::netExtCheck() Bad Address supplied from netAssistExternalAddress()" << std::endl; std::cerr << "p3NetMgrIMPL::netExtCheck() Bad Address supplied from netAssistExternalAddress()" << std::endl;
} }
#endif #endif
} }
} }
#ifdef ALLOW_DHT_STUNNER
// (cyril) I disabled this because it's pretty dangerous. The DHT can report a wrong address quite easily
// if the other DHT peers are not collaborating.
/* Next ask the DhtStunner */ /* Next ask the DhtStunner */
{ {
#if defined(NETMGR_DEBUG_TICK) || defined(NETMGR_DEBUG_RESET) #if defined(NETMGR_DEBUG_TICK) || defined(NETMGR_DEBUG_RESET)
@ -748,30 +754,31 @@ void p3NetMgrIMPL::netExtCheck()
if (mDhtStunner) if (mDhtStunner)
{ {
/* input network bits */ /* input network bits */
if (mDhtStunner->getExternalAddr(tmpaddr, isstable)) if (mDhtStunner->getExternalAddr(tmpaddr, isstable))
{ {
if(rsBanList->isAddressAccepted(tmpaddr,RSBANLIST_CHECKING_FLAGS_BLACKLIST)) if(rsBanList->isAddressAccepted(tmpaddr,RSBANLIST_CHECKING_FLAGS_BLACKLIST))
{ {
// must be stable??? // must be stable???
isStable = (isstable == 1); isStable = (isstable == 1);
mNetFlags.mExtAddr = tmpaddr; //mNetFlags.mExtAddr = tmpaddr;
mNetFlags.mExtAddrOk = true; mNetFlags.mExtAddrOk = true;
mNetFlags.mExtAddrStableOk = isStable; mNetFlags.mExtAddrStableOk = isStable;
address_votes[tmpaddr].n++ ; address_votes[tmpaddr].n++ ;
#ifdef NETMGR_DEBUG_STATEBOX #ifdef NETMGR_DEBUG_STATEBOX
std::cerr << "p3NetMgrIMPL::netExtCheck() From DhtStunner: "; std::cerr << "p3NetMgrIMPL::netExtCheck() From DhtStunner: ";
std::cerr << sockaddr_storage_tostring(tmpaddr); std::cerr << sockaddr_storage_tostring(tmpaddr);
std::cerr << " Stable: " << (uint32_t) isstable; std::cerr << " Stable: " << (uint32_t) isstable;
std::cerr << std::endl; std::cerr << std::endl;
#endif #endif
} }
else else
std::cerr << "(SS) DHTStunner returned wrong own IP " << sockaddr_storage_iptostring(tmpaddr) << " (banned). Rejecting." << std::endl; std::cerr << "(SS) DHTStunner returned wrong own IP " << sockaddr_storage_iptostring(tmpaddr) << " (banned). Rejecting." << std::endl;
} }
} }
} }
#endif
/* otherwise ask ExtAddrFinder */ /* otherwise ask ExtAddrFinder */
{ {
@ -782,119 +789,159 @@ void p3NetMgrIMPL::netExtCheck()
std::cerr << "p3NetMgrIMPL::netExtCheck() checking ExtAddrFinder" << std::endl; std::cerr << "p3NetMgrIMPL::netExtCheck() checking ExtAddrFinder" << std::endl;
#endif #endif
bool extFinderOk = mExtAddrFinder->hasValidIP(tmpip); bool extFinderOk = mExtAddrFinder->hasValidIP(tmpip);
if (extFinderOk) if (extFinderOk)
{ {
#if defined(NETMGR_DEBUG_TICK) || defined(NETMGR_DEBUG_RESET) #if defined(NETMGR_DEBUG_TICK) || defined(NETMGR_DEBUG_RESET)
std::cerr << "p3NetMgrIMPL::netExtCheck() Ext supplied by ExtAddrFinder" << std::endl; std::cerr << "p3NetMgrIMPL::netExtCheck() Ext supplied by ExtAddrFinder" << std::endl;
#endif #endif
/* best guess at port */ /* best guess at port */
sockaddr_storage_setport(tmpip, sockaddr_storage_port(mLocalAddr)); sockaddr_storage_setport(tmpip, sockaddr_storage_port(mLocalAddr));
#if defined(NETMGR_DEBUG_TICK) || defined(NETMGR_DEBUG_RESET) #if defined(NETMGR_DEBUG_TICK) || defined(NETMGR_DEBUG_RESET)
std::cerr << "p3NetMgrIMPL::netExtCheck() "; std::cerr << "p3NetMgrIMPL::netExtCheck() ";
std::cerr << "ExtAddr: " << sockaddr_storage_tostring(tmpip); std::cerr << "ExtAddr: " << sockaddr_storage_tostring(tmpip);
std::cerr << std::endl; std::cerr << std::endl;
#endif #endif
mNetFlags.mExtAddr = tmpip; //mNetFlags.mExtAddr = tmpip;
mNetFlags.mExtAddrOk = true; mNetFlags.mExtAddrOk = true;
address_votes[tmpip].n++ ; address_votes[tmpip].n++ ;
/* XXX HACK TO FIX */ /* XXX HACK TO FIX */
#warning "ALLOWING ExtAddrFinder -> ExtAddrStableOk = true (which it is not normally)" #warning "ALLOWING ExtAddrFinder -> ExtAddrStableOk = true (which it is not normally)"
mNetFlags.mExtAddrStableOk = true; mNetFlags.mExtAddrStableOk = true;
std::cerr << "ExtAddrFinder reported external address " << sockaddr_storage_iptostring(tmpip) << std::endl;
} }
} }
} }
/* any other sources ??? */ /* also ask peer mgr. */
if (mPeerMgr)
{
#if defined(NETMGR_DEBUG_TICK) || defined(NETMGR_DEBUG_RESET)
std::cerr << "p3NetMgrIMPL::netExtCheck() checking mPeerMgr" << std::endl;
#endif
uint8_t isstable ; // unused
sockaddr_storage tmpaddr ;
if (mPeerMgr->getExtAddressReportedByFriends(tmpaddr, isstable))
{
#if defined(NETMGR_DEBUG_TICK) || defined(NETMGR_DEBUG_RESET)
std::cerr << "p3NetMgrIMPL::netExtCheck() Ext supplied by ExtAddrFinder" << std::endl;
#endif
/* best guess at port */
sockaddr_storage_setport(tmpaddr, sockaddr_storage_port(mLocalAddr));
#if defined(NETMGR_DEBUG_TICK) || defined(NETMGR_DEBUG_RESET)
std::cerr << "p3NetMgrIMPL::netExtCheck() ";
std::cerr << "ExtAddr: " << sockaddr_storage_tostring(tmpip);
std::cerr << std::endl;
#endif
//mNetFlags.mExtAddr = tmpaddr;
mNetFlags.mExtAddrOk = true;
mNetFlags.mExtAddrStableOk = isstable;
address_votes[tmpaddr].n++ ;
std::cerr << "PeerMgr reported external address " << sockaddr_storage_iptostring(tmpaddr) << std::endl;
}
#if defined(NETMGR_DEBUG_TICK) || defined(NETMGR_DEBUG_RESET)
else
std::cerr << " No reliable address returned." << std::endl;
#endif
}
/* any other sources ??? */
/* finalise address */ /* finalise address */
if (mNetFlags.mExtAddrOk) if (mNetFlags.mExtAddrOk)
{ {
// look at votes. // look at votes.
std::cerr << "Figuring out ext addr from voting:" << std::endl; std::cerr << "Figuring out ext addr from voting:" << std::endl;
uint32_t admax = 0 ; uint32_t admax = 0 ;
for(std::map<sockaddr_storage,ZeroInt>::const_iterator it(address_votes.begin());it!=address_votes.end();++it) for(std::map<sockaddr_storage,ZeroInt>::const_iterator it(address_votes.begin());it!=address_votes.end();++it)
{ {
std::cerr << " Vote: " << sockaddr_storage_iptostring(it->first) << " : " << it->second.n << " votes." ; std::cerr << " Vote: " << sockaddr_storage_iptostring(it->first) << " : " << it->second.n << " votes." ;
if(it->second.n > admax) if(it->second.n > admax)
{ {
mNetFlags.mExtAddr = it->first ; mNetFlags.mExtAddr = it->first ;
admax = it->second.n ; admax = it->second.n ;
std::cerr << " Kept!" << std::endl; std::cerr << " Kept!" << std::endl;
} }
else else
std::cerr << " Discarded." << std::endl; std::cerr << " Discarded." << std::endl;
} }
#if defined(NETMGR_DEBUG_TICK) || defined(NETMGR_DEBUG_RESET) #if defined(NETMGR_DEBUG_TICK) || defined(NETMGR_DEBUG_RESET)
std::cerr << "p3NetMgrIMPL::netExtCheck() "; std::cerr << "p3NetMgrIMPL::netExtCheck() ";
std::cerr << "ExtAddr: " << sockaddr_storage_tostring(mNetFlags.mExtAddr); std::cerr << "ExtAddr: " << sockaddr_storage_tostring(mNetFlags.mExtAddr);
std::cerr << std::endl; std::cerr << std::endl;
#endif #endif
//update ip address list //update ip address list
mExtAddr = mNetFlags.mExtAddr; mExtAddr = mNetFlags.mExtAddr;
mNetStatus = RS_NET_DONE; mNetStatus = RS_NET_DONE;
netSetupDone = true; netSetupDone = true;
#if defined(NETMGR_DEBUG_TICK) || defined(NETMGR_DEBUG_RESET) #if defined(NETMGR_DEBUG_TICK) || defined(NETMGR_DEBUG_RESET)
std::cerr << "p3NetMgrIMPL::netExtCheck() Ext Ok: RS_NET_DONE" << std::endl; std::cerr << "p3NetMgrIMPL::netExtCheck() Ext Ok: RS_NET_DONE" << std::endl;
#endif #endif
if (!mNetFlags.mExtAddrStableOk) if (!mNetFlags.mExtAddrStableOk)
{ {
#if defined(NETMGR_DEBUG_TICK) || defined(NETMGR_DEBUG_RESET) #if defined(NETMGR_DEBUG_TICK) || defined(NETMGR_DEBUG_RESET)
std::cerr << "p3NetMgrIMPL::netUdpCheck() UDP Unstable :( "; std::cerr << "p3NetMgrIMPL::netUdpCheck() UDP Unstable :( ";
std::cerr << std::endl; std::cerr << std::endl;
std::cerr << "p3NetMgrIMPL::netUdpCheck() We are unreachable"; std::cerr << "p3NetMgrIMPL::netUdpCheck() We are unreachable";
std::cerr << std::endl; std::cerr << std::endl;
std::cerr << "netMode => RS_NET_MODE_UNREACHABLE"; std::cerr << "netMode => RS_NET_MODE_UNREACHABLE";
std::cerr << std::endl; std::cerr << std::endl;
#endif #endif
// Due to the new UDP connections - we can still connect some of the time! // Due to the new UDP connections - we can still connect some of the time!
// So limit warning! // So limit warning!
//mNetMode &= ~(RS_NET_MODE_ACTUAL); //mNetMode &= ~(RS_NET_MODE_ACTUAL);
//mNetMode |= RS_NET_MODE_UNREACHABLE; //mNetMode |= RS_NET_MODE_UNREACHABLE;
/* send a system warning message */ /* send a system warning message */
//pqiNotify *notify = getPqiNotify(); //pqiNotify *notify = getPqiNotify();
//if (notify) //if (notify)
{ {
std::string title = std::string title =
"Warning: Bad Firewall Configuration"; "Warning: Bad Firewall Configuration";
std::string msg; std::string msg;
msg += " **** WARNING **** \n"; msg += " **** WARNING **** \n";
msg += "Retroshare has detected that you are behind"; msg += "Retroshare has detected that you are behind";
msg += " a restrictive Firewall\n"; msg += " a restrictive Firewall\n";
msg += "\n"; msg += "\n";
msg += "You will have limited connectivity to other firewalled peers\n"; msg += "You will have limited connectivity to other firewalled peers\n";
msg += "\n"; msg += "\n";
msg += "You can fix this by:\n"; msg += "You can fix this by:\n";
msg += " (1) opening an External Port\n"; msg += " (1) opening an External Port\n";
msg += " (2) enabling UPnP, or\n"; msg += " (2) enabling UPnP, or\n";
msg += " (3) get a new (approved) Firewall/Router\n"; msg += " (3) get a new (approved) Firewall/Router\n";
//notify->AddSysMessage(0, RS_SYS_WARNING, title, msg); //notify->AddSysMessage(0, RS_SYS_WARNING, title, msg);
std::cerr << msg << std::endl; std::cerr << msg << std::endl;
} }
} }
} }
if (mNetFlags.mExtAddrOk) if (mNetFlags.mExtAddrOk)
{ {

460
libretroshare/src/pqi/p3peermgr.cc
View File

@ -74,17 +74,20 @@ const uint32_t PEER_IP_CONNECT_STATE_MAX_LIST_SIZE = 4;
#define MIN_RETRY_PERIOD 140 #define MIN_RETRY_PERIOD 140
static const std::string kConfigDefaultProxyServerIpAddr = "127.0.0.1"; static const std::string kConfigDefaultProxyServerIpAddr = "127.0.0.1";
static const uint16_t kConfigDefaultProxyServerPort = 9050; // standard port. static const uint16_t kConfigDefaultProxyServerPortTor = 9050; // standard port.
static const uint16_t kConfigDefaultProxyServerPortI2P = 10; // there is no standard port though
static const std::string kConfigKeyExtIpFinder = "USE_EXTR_IP_FINDER"; static const std::string kConfigKeyExtIpFinder = "USE_EXTR_IP_FINDER";
static const std::string kConfigKeyProxyServerIpAddr = "PROXY_SERVER_IPADDR"; static const std::string kConfigKeyProxyServerIpAddrTor = "PROXY_SERVER_IPADDR";
static const std::string kConfigKeyProxyServerPort = "PROXY_SERVER_PORT"; static const std::string kConfigKeyProxyServerPortTor = "PROXY_SERVER_PORT";
static const std::string kConfigKeyProxyServerIpAddrI2P = "PROXY_SERVER_IPADDR_I2P";
static const std::string kConfigKeyProxyServerPortI2P = "PROXY_SERVER_PORT_I2P";
void printConnectState(std::ostream &out, peerState &peer); void printConnectState(std::ostream &out, peerState &peer);
peerState::peerState() peerState::peerState()
:netMode(RS_NET_MODE_UNKNOWN), vs_disc(RS_VS_DISC_FULL), vs_dht(RS_VS_DHT_FULL), lastcontact(0), :netMode(RS_NET_MODE_UNKNOWN), vs_disc(RS_VS_DISC_FULL), vs_dht(RS_VS_DHT_FULL), lastcontact(0),
hiddenNode(false), hiddenPort(0) hiddenNode(false), hiddenPort(0), hiddenType(RS_HIDDEN_TYPE_NONE)
{ {
sockaddr_storage_clear(localaddr); sockaddr_storage_clear(localaddr);
sockaddr_storage_clear(serveraddr); sockaddr_storage_clear(serveraddr);
@ -130,13 +133,21 @@ p3PeerMgrIMPL::p3PeerMgrIMPL(const RsPeerId& ssl_own_id, const RsPgpId& gpg_own_
lastGroupId = 1; lastGroupId = 1;
// setup default ProxyServerAddress. // setup default ProxyServerAddress.
sockaddr_storage_clear(mProxyServerAddress); // Tor
sockaddr_storage_ipv4_aton(mProxyServerAddress, sockaddr_storage_clear(mProxyServerAddressTor);
sockaddr_storage_ipv4_aton(mProxyServerAddressTor,
kConfigDefaultProxyServerIpAddr.c_str()); kConfigDefaultProxyServerIpAddr.c_str());
sockaddr_storage_ipv4_setport(mProxyServerAddress, sockaddr_storage_ipv4_setport(mProxyServerAddressTor,
kConfigDefaultProxyServerPort); kConfigDefaultProxyServerPortTor);
// I2P
sockaddr_storage_clear(mProxyServerAddressI2P);
sockaddr_storage_ipv4_aton(mProxyServerAddressI2P,
kConfigDefaultProxyServerIpAddr.c_str());
sockaddr_storage_ipv4_setport(mProxyServerAddressI2P,
kConfigDefaultProxyServerPortI2P);
mProxyServerStatus = RS_NET_PROXY_STATUS_UNKNOWN ; mProxyServerStatusTor = RS_NET_PROXY_STATUS_UNKNOWN ;
mProxyServerStatusI2P = RS_NET_PROXY_STATUS_UNKNOWN;
} }
#ifdef PEER_DEBUG #ifdef PEER_DEBUG
@ -169,6 +180,7 @@ bool p3PeerMgrIMPL::setupHiddenNode(const std::string &hiddenAddress, const uint
mOwnState.hiddenNode = true; mOwnState.hiddenNode = true;
mOwnState.hiddenPort = hiddenPort; mOwnState.hiddenPort = hiddenPort;
mOwnState.hiddenDomain = hiddenAddress; mOwnState.hiddenDomain = hiddenAddress;
mOwnState.hiddenType = hiddenDomainToHiddenType(hiddenAddress);
} }
forceHiddenNode(); forceHiddenNode();
@ -188,6 +200,7 @@ bool p3PeerMgrIMPL::forceHiddenNode()
#endif #endif
} }
mOwnState.hiddenNode = true; mOwnState.hiddenNode = true;
mOwnState.hiddenType = hiddenDomainToHiddenType(mOwnState.hiddenDomain);
// force external address - otherwise its invalid. // force external address - otherwise its invalid.
sockaddr_storage_clear(mOwnState.serveraddr); sockaddr_storage_clear(mOwnState.serveraddr);
@ -372,8 +385,43 @@ bool p3PeerMgrIMPL::isHidden()
return mOwnState.hiddenNode; return mOwnState.hiddenNode;
} }
/**
* @brief checks the hidden type of the own peer.
* @param type type to check
* @return true when the peer has the same hidden type than type
*/
bool p3PeerMgrIMPL::isHidden(const uint32_t type)
{
RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/
switch (type) {
case RS_HIDDEN_TYPE_TOR:
return mOwnState.hiddenType == RS_HIDDEN_TYPE_TOR;
break;
case RS_HIDDEN_TYPE_I2P:
return mOwnState.hiddenType == RS_HIDDEN_TYPE_I2P;
break;
default:
#ifdef PEER_DEBUG
std::cerr << "p3PeerMgrIMPL::isHidden(" << type << ") unkown type -> false";
std::cerr << std::endl;
#endif
return false;
break;
}
}
bool p3PeerMgrIMPL::isHiddenPeer(const RsPeerId &ssl_id) bool p3PeerMgrIMPL::isHiddenPeer(const RsPeerId &ssl_id)
{
return isHiddenPeer(ssl_id, RS_HIDDEN_TYPE_NONE);
}
/**
* @brief checks the hidden type of a given ssl id. When type RS_HIDDEN_TYPE_NONE is choosen it returns the 'hiddenNode' value instead
* @param ssl_id to check
* @param type type to check. Use RS_HIDDEN_TYPE_NONE to check 'hiddenNode' value
* @return true when the peer has the same hidden type than type
*/
bool p3PeerMgrIMPL::isHiddenPeer(const RsPeerId &ssl_id, const uint32_t type)
{ {
RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/ RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/
@ -394,9 +442,91 @@ bool p3PeerMgrIMPL::isHiddenPeer(const RsPeerId &ssl_id)
std::cerr << "p3PeerMgrIMPL::isHiddenPeer(" << ssl_id << ") = " << (it->second).hiddenNode; std::cerr << "p3PeerMgrIMPL::isHiddenPeer(" << ssl_id << ") = " << (it->second).hiddenNode;
std::cerr << std::endl; std::cerr << std::endl;
#endif #endif
return (it->second).hiddenNode; switch (type) {
case RS_HIDDEN_TYPE_TOR:
return (it->second).hiddenType == RS_HIDDEN_TYPE_TOR;
break;
case RS_HIDDEN_TYPE_I2P:
return (it->second).hiddenType == RS_HIDDEN_TYPE_I2P;
break;
default:
return (it->second).hiddenNode;
break;
}
} }
bool hasEnding (std::string const &fullString, std::string const &ending) {
if (fullString.length() < ending.length())
return false;
return (0 == fullString.compare (fullString.length() - ending.length(), ending.length(), ending));
}
/**
* @brief resolves the hidden type (tor or i2p) from a domain
* @param domain to check
* @return RS_HIDDEN_TYPE_TOR, RS_HIDDEN_TYPE_I2P or RS_HIDDEN_TYPE_NONE
*
* Tor: ^[a-z2-7]{16}\.onion$
*
* I2P: There is more than one address:
* - pub. key in base64
* - hash in base32 ( ^[a-z2-7]{52}\.b32\.i2p$ )
* - "normal" .i2p domains
*/
uint32_t p3PeerMgrIMPL::hiddenDomainToHiddenType(const std::string &domain)
{
if(hasEnding(domain, ".onion"))
return RS_HIDDEN_TYPE_TOR;
if(hasEnding(domain, ".i2p"))
return RS_HIDDEN_TYPE_I2P;
#ifdef PEER_DEBUG
std::cerr << "p3PeerMgrIMPL::hiddenDomainToHiddenType() unknown hidden type: " << domain;
std::cerr << std::endl;
#endif
return RS_HIDDEN_TYPE_UNKNOWN;
}
/**
* @brief returns the hidden type of a peer
* @param ssl_id peer id
* @return hidden type
*/
uint32_t p3PeerMgrIMPL::getHiddenType(const RsPeerId &ssl_id)
{
RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/
if (ssl_id == AuthSSL::getAuthSSL()->OwnId())
return mOwnState.hiddenType;
/* check for existing */
std::map<RsPeerId, peerState>::iterator it;
it = mFriendList.find(ssl_id);
if (it == mFriendList.end())
{
#ifdef PEER_DEBUG
std::cerr << "p3PeerMgrIMPL::getHiddenType(" << ssl_id << ") Missing Peer => false";
std::cerr << std::endl;
#endif
return false;
}
#ifdef PEER_DEBUG
std::cerr << "p3PeerMgrIMPL::getHiddenType(" << ssl_id << ") = " << (it->second).hiddenType;
std::cerr << std::endl;
#endif
return (it->second).hiddenType;
}
/**
* @brief sets hidden domain and port for a given ssl ID
* @param ssl_id peer to set domain and port for
* @param domain_addr
* @param domain_port
* @return true on success
*/
bool p3PeerMgrIMPL::setHiddenDomainPort(const RsPeerId &ssl_id, const std::string &domain_addr, const uint16_t domain_port) bool p3PeerMgrIMPL::setHiddenDomainPort(const RsPeerId &ssl_id, const std::string &domain_addr, const uint16_t domain_port)
{ {
RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/ RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/
@ -426,6 +556,7 @@ bool p3PeerMgrIMPL::setHiddenDomainPort(const RsPeerId &ssl_id, const std::strin
mOwnState.hiddenNode = true; mOwnState.hiddenNode = true;
mOwnState.hiddenDomain = domain; mOwnState.hiddenDomain = domain;
mOwnState.hiddenPort = domain_port; mOwnState.hiddenPort = domain_port;
mOwnState.hiddenType = hiddenDomainToHiddenType(domain);
#ifdef PEER_DEBUG #ifdef PEER_DEBUG
std::cerr << "p3PeerMgrIMPL::setHiddenDomainPort() Set own State"; std::cerr << "p3PeerMgrIMPL::setHiddenDomainPort() Set own State";
std::cerr << std::endl; std::cerr << std::endl;
@ -448,6 +579,7 @@ bool p3PeerMgrIMPL::setHiddenDomainPort(const RsPeerId &ssl_id, const std::strin
it->second.hiddenDomain = domain; it->second.hiddenDomain = domain;
it->second.hiddenPort = domain_port; it->second.hiddenPort = domain_port;
it->second.hiddenNode = true; it->second.hiddenNode = true;
it->second.hiddenType = hiddenDomainToHiddenType(domain);
#ifdef PEER_DEBUG #ifdef PEER_DEBUG
std::cerr << "p3PeerMgrIMPL::setHiddenDomainPort() Set Peers State"; std::cerr << "p3PeerMgrIMPL::setHiddenDomainPort() Set Peers State";
std::cerr << std::endl; std::cerr << std::endl;
@ -456,15 +588,40 @@ bool p3PeerMgrIMPL::setHiddenDomainPort(const RsPeerId &ssl_id, const std::strin
return true; return true;
} }
bool p3PeerMgrIMPL::setProxyServerAddress(const struct sockaddr_storage &proxy_addr) /**
* @brief sets the proxy server address for a hidden service
* @param type hidden service type
* @param proxy_addr proxy address
* @return true on success
*/
bool p3PeerMgrIMPL::setProxyServerAddress(const uint32_t type, const struct sockaddr_storage &proxy_addr)
{ {
RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/ RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/
if (!sockaddr_storage_same(mProxyServerAddress,proxy_addr)) switch (type) {
{ case RS_HIDDEN_TYPE_I2P:
IndicateConfigChanged(); /**** INDICATE MSG CONFIG CHANGED! *****/ if (!sockaddr_storage_same(mProxyServerAddressI2P, proxy_addr))
mProxyServerAddress = proxy_addr; {
IndicateConfigChanged(); /**** INDICATE MSG CONFIG CHANGED! *****/
mProxyServerAddressI2P = proxy_addr;
}
break;
case RS_HIDDEN_TYPE_TOR:
if (!sockaddr_storage_same(mProxyServerAddressTor, proxy_addr))
{
IndicateConfigChanged(); /**** INDICATE MSG CONFIG CHANGED! *****/
mProxyServerAddressTor = proxy_addr;
}
break;
case RS_HIDDEN_TYPE_UNKNOWN:
default:
#ifdef PEER_DEBUG
std::cerr << "p3PeerMgrIMPL::setProxyServerAddress() unknown hidden type " << type << " -> false";
std::cerr << std::endl;
#endif
return false;
} }
return true; return true;
} }
@ -480,21 +637,71 @@ bool p3PeerMgrIMPL::resetOwnExternalAddressList()
return true ; return true ;
} }
bool p3PeerMgrIMPL::getProxyServerStatus(uint32_t& proxy_status) /**
{ * @brief returs proxy server status for a hidden service proxy
RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/ * @param type hidden service type
* @param proxy_status
proxy_status = mProxyServerStatus; * @return true on success
return true; */
} bool p3PeerMgrIMPL::getProxyServerStatus(const uint32_t type, uint32_t& proxy_status)
bool p3PeerMgrIMPL::getProxyServerAddress(struct sockaddr_storage &proxy_addr)
{ {
RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/ RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/
proxy_addr = mProxyServerAddress; switch (type) {
case RS_HIDDEN_TYPE_I2P:
proxy_status = mProxyServerStatusI2P;
break;
case RS_HIDDEN_TYPE_TOR:
proxy_status = mProxyServerStatusTor;
break;
case RS_HIDDEN_TYPE_UNKNOWN:
default:
#ifdef PEER_DEBUG
std::cerr << "p3PeerMgrIMPL::getProxyServerStatus() unknown hidden type " << type << " -> false";
std::cerr << std::endl;
#endif
return false;
}
return true; return true;
} }
/**
* @brief returs proxy server address for a hidden service proxy
* @param type hidden service type
* @param proxy_addr
* @return true on success
*/
bool p3PeerMgrIMPL::getProxyServerAddress(const uint32_t type, struct sockaddr_storage &proxy_addr)
{
RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/
switch (type) {
case RS_HIDDEN_TYPE_I2P:
proxy_addr = mProxyServerAddressI2P;
break;
case RS_HIDDEN_TYPE_TOR:
proxy_addr = mProxyServerAddressTor;
break;
case RS_HIDDEN_TYPE_UNKNOWN:
default:
#ifdef PEER_DEBUG
std::cerr << "p3PeerMgrIMPL::getProxyServerAddress() unknown hidden type " << type << " -> false";
std::cerr << std::endl;
#endif
return false;
}
return true;
}
/**
* @brief looks up the proxy address and domain/port that have to be used when connecting to a peer
* @param ssl_id peer to connect to
* @param proxy_addr proxy address to be used
* @param domain_addr domain to connect to
* @param domain_port port to connect to
* @return true on success
*/
bool p3PeerMgrIMPL::getProxyAddress(const RsPeerId &ssl_id, struct sockaddr_storage &proxy_addr, std::string &domain_addr, uint16_t &domain_port) bool p3PeerMgrIMPL::getProxyAddress(const RsPeerId &ssl_id, struct sockaddr_storage &proxy_addr, std::string &domain_addr, uint16_t &domain_port)
{ {
RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/ RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/
@ -515,7 +722,21 @@ bool p3PeerMgrIMPL::getProxyAddress(const RsPeerId &ssl_id, struct sockaddr_stor
domain_addr = it->second.hiddenDomain; domain_addr = it->second.hiddenDomain;
domain_port = it->second.hiddenPort; domain_port = it->second.hiddenPort;
proxy_addr = mProxyServerAddress; switch (it->second.hiddenType) {
case RS_HIDDEN_TYPE_I2P:
proxy_addr = mProxyServerAddressI2P;
break;
case RS_HIDDEN_TYPE_TOR:
proxy_addr = mProxyServerAddressTor;
break;
case RS_HIDDEN_TYPE_UNKNOWN:
default:
#ifdef PEER_DEBUG
std::cerr << "p3PeerMgrIMPL::getProxyAddress() no valid hidden type (" << it->second.hiddenType << ") for peer id " << ssl_id << " -> false";
std::cerr << std::endl;
#endif
return false;
}
return true; return true;
} }
@ -805,7 +1026,7 @@ bool p3PeerMgrIMPL::removeFriend(const RsPgpId &id)
RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/ RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/
/* move to othersList */ /* move to othersList */
bool success = false; //bool success = false;
std::map<RsPeerId, peerState>::iterator it; std::map<RsPeerId, peerState>::iterator it;
//remove ssl and gpg_ids //remove ssl and gpg_ids
for(it = mFriendList.begin(); it != mFriendList.end(); ++it) for(it = mFriendList.begin(); it != mFriendList.end(); ++it)
@ -822,7 +1043,7 @@ bool p3PeerMgrIMPL::removeFriend(const RsPgpId &id)
mOthersList[it->second.id] = peer; mOthersList[it->second.id] = peer;
mStatusChanged = true; mStatusChanged = true;
success = true; //success = true;
} }
} }
@ -878,7 +1099,7 @@ bool p3PeerMgrIMPL::removeFriend(const RsPeerId &id, bool removePgpId)
RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/ RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/
/* move to othersList */ /* move to othersList */
bool success = false; //bool success = false;
std::map<RsPeerId, peerState>::iterator it; std::map<RsPeerId, peerState>::iterator it;
//remove ssl and gpg_ids //remove ssl and gpg_ids
for(it = mFriendList.begin(); it != mFriendList.end(); ++it) for(it = mFriendList.begin(); it != mFriendList.end(); ++it)
@ -897,7 +1118,7 @@ bool p3PeerMgrIMPL::removeFriend(const RsPeerId &id, bool removePgpId)
mOthersList[id] = peer; mOthersList[id] = peer;
mStatusChanged = true; mStatusChanged = true;
success = true; //success = true;
} }
} }
@ -1246,20 +1467,51 @@ bool p3PeerMgrIMPL::addCandidateForOwnExternalAddress(const RsPeerId &from, cons
// * emit a warnign when the address is unknown // * emit a warnign when the address is unknown
// * if multiple peers report the same address => notify the LinkMgr that the external address had changed. // * if multiple peers report the same address => notify the LinkMgr that the external address had changed.
sockaddr_storage addr_filtered ; sockaddr_storage addr_filtered ;
sockaddr_storage_copyip(addr_filtered,addr) ; sockaddr_storage_clear(addr_filtered) ;
sockaddr_storage_copyip(addr_filtered,addr) ;
#ifdef PEER_DEBUG #ifdef PEER_DEBUG
std::cerr << "Own external address is " << sockaddr_storage_iptostring(addr_filtered) << ", as reported by friend " << from << std::endl; std::cerr << "Own external address is " << sockaddr_storage_iptostring(addr_filtered) << ", as reported by friend " << from << std::endl;
#endif #endif
if(!sockaddr_storage_isExternalNet(addr_filtered)) if(!sockaddr_storage_isExternalNet(addr_filtered))
{
#ifdef PEER_DEBUG
std::cerr << " address is not an external address. Returning false" << std::endl ;
#endif
return false ;
}
// Update a list of own IPs:
// - remove old values for that same peer
// - remove values for non connected peers
{ {
#ifdef PEER_DEBUG RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/
std::cerr << " address is not an external address. Returning false" << std::endl ;
#endif mReportedOwnAddresses[from] = addr_filtered ;
return false ;
for(std::map<RsPeerId,sockaddr_storage>::iterator it(mReportedOwnAddresses.begin());it!=mReportedOwnAddresses.end();)
if(!mLinkMgr->isOnline(it->first))
{
std::map<RsPeerId,sockaddr_storage>::iterator tmp(it) ;
++tmp ;
mReportedOwnAddresses.erase(it) ;
it=tmp ;
}
else
++it ;
sockaddr_storage current_best_ext_address_guess ;
uint32_t count ;
locked_computeCurrentBestOwnExtAddressCandidate(current_best_ext_address_guess,count) ;
std::cerr << "p3PeerMgr:: Current external address is calculated to be: " << sockaddr_storage_iptostring(current_best_ext_address_guess) << " (simultaneously reported by " << count << " peers)." << std::endl;
} }
// now current
sockaddr_storage own_addr ; sockaddr_storage own_addr ;
@ -1282,10 +1534,56 @@ bool p3PeerMgrIMPL::addCandidateForOwnExternalAddress(const RsPeerId &from, cons
RsServer::notify()->AddFeedItem(RS_FEED_ITEM_SEC_IP_WRONG_EXTERNAL_IP_REPORTED, from.toStdString(), sockaddr_storage_iptostring(own_addr), sockaddr_storage_iptostring(addr)); RsServer::notify()->AddFeedItem(RS_FEED_ITEM_SEC_IP_WRONG_EXTERNAL_IP_REPORTED, from.toStdString(), sockaddr_storage_iptostring(own_addr), sockaddr_storage_iptostring(addr));
} }
// we could also sweep over all connected friends and see if some report a different address.
return true ; return true ;
} }
bool p3PeerMgrIMPL::locked_computeCurrentBestOwnExtAddressCandidate(sockaddr_storage& addr, uint32_t& count)
{
std::map<sockaddr_storage,ZeroedInt> addr_counts ;
for(std::map<RsPeerId,sockaddr_storage>::iterator it(mReportedOwnAddresses.begin());it!=mReportedOwnAddresses.end();++it)
++addr_counts[it->second].n ;
#ifdef PEER_DEBUG
std::cerr << "Current ext addr statistics:" << std::endl;
#endif
count = 0 ;
for(std::map<sockaddr_storage,ZeroedInt>::const_iterator it(addr_counts.begin());it!=addr_counts.end();++it)
{
if(uint32_t(it->second.n) > count)
{
addr = it->first ;
count = it->second.n ;
}
#ifdef PEER_DEBUG
std::cerr << sockaddr_storage_iptostring(it->first) << " : " << it->second.n << std::endl;
#endif
}
return true ;
}
bool p3PeerMgrIMPL::getExtAddressReportedByFriends(sockaddr_storage &addr, uint8_t& isstable)
{
RsStackMutex stack(mPeerMtx); /****** STACK LOCK MUTEX *******/
uint32_t count ;
locked_computeCurrentBestOwnExtAddressCandidate(addr,count) ;
#ifdef PEER_DEBUG
std::cerr << "Estimation count = " << count << ". Trusted? = " << (count>=2) << std::endl;
#endif
return count >= 2 ;// 2 is not conservative enough. 3 should be probably better.
}
static bool cleanIpList(std::list<pqiIpAddress>& lst,const RsPeerId& pid,p3LinkMgr *link_mgr) static bool cleanIpList(std::list<pqiIpAddress>& lst,const RsPeerId& pid,p3LinkMgr *link_mgr)
{ {
bool changed = false ; bool changed = false ;
@ -1620,9 +1918,10 @@ bool p3PeerMgrIMPL::saveList(bool &cleanup, std::list<RsItem *>& saveData)
cleanup = false; cleanup = false;
bool useExtAddrFinder = mNetMgr->getIPServersEnabled(); bool useExtAddrFinder = mNetMgr->getIPServersEnabled();
// Store Proxy Server. /* gather these information before mPeerMtx is locked! */
struct sockaddr_storage proxy_addr; struct sockaddr_storage proxy_addr_tor, proxy_addr_i2p;
getProxyServerAddress(proxy_addr); getProxyServerAddress(RS_HIDDEN_TYPE_TOR, proxy_addr_tor);
getProxyServerAddress(RS_HIDDEN_TYPE_I2P, proxy_addr_i2p);
mPeerMtx.lock(); /****** MUTEX LOCKED *******/ mPeerMtx.lock(); /****** MUTEX LOCKED *******/
@ -1733,17 +2032,33 @@ bool p3PeerMgrIMPL::saveList(bool &cleanup, std::list<RsItem *>& saveData)
vitem->tlvkvs.pairs.push_back(kv) ; vitem->tlvkvs.pairs.push_back(kv) ;
// Store Proxy Server.
// Tor
#ifdef PEER_DEBUG #ifdef PEER_DEBUG
std::cerr << "Saving proxyServerAddress: " << sockaddr_storage_tostring(proxy_addr); std::cerr << "Saving proxyServerAddress for Tor: " << sockaddr_storage_tostring(proxy_addr_tor);
std::cerr << std::endl; std::cerr << std::endl;
#endif #endif
kv.key = kConfigKeyProxyServerIpAddr; kv.key = kConfigKeyProxyServerIpAddrTor;
kv.value = sockaddr_storage_iptostring(proxy_addr); kv.value = sockaddr_storage_iptostring(proxy_addr_tor);
vitem->tlvkvs.pairs.push_back(kv) ; vitem->tlvkvs.pairs.push_back(kv) ;
kv.key = kConfigKeyProxyServerPort; kv.key = kConfigKeyProxyServerPortTor;
kv.value = sockaddr_storage_porttostring(proxy_addr); kv.value = sockaddr_storage_porttostring(proxy_addr_tor);
vitem->tlvkvs.pairs.push_back(kv) ;
// I2P
#ifdef PEER_DEBUG
std::cerr << "Saving proxyServerAddress for I2P: " << sockaddr_storage_tostring(proxy_addr_i2p);
std::cerr << std::endl;
#endif
kv.key = kConfigKeyProxyServerIpAddrI2P;
kv.value = sockaddr_storage_iptostring(proxy_addr_i2p);
vitem->tlvkvs.pairs.push_back(kv) ;
kv.key = kConfigKeyProxyServerPortI2P;
kv.value = sockaddr_storage_porttostring(proxy_addr_i2p);
vitem->tlvkvs.pairs.push_back(kv) ; vitem->tlvkvs.pairs.push_back(kv) ;
saveData.push_back(vitem); saveData.push_back(vitem);
@ -1779,8 +2094,10 @@ bool p3PeerMgrIMPL::loadList(std::list<RsItem *>& load)
// DEFAULTS. // DEFAULTS.
bool useExtAddrFinder = true; bool useExtAddrFinder = true;
std::string proxyIpAddress = kConfigDefaultProxyServerIpAddr; std::string proxyIpAddressTor = kConfigDefaultProxyServerIpAddr;
uint16_t proxyPort = kConfigDefaultProxyServerPort; uint16_t proxyPortTor = kConfigDefaultProxyServerPortTor;
std::string proxyIpAddressI2P = kConfigDefaultProxyServerIpAddr;
uint16_t proxyPortI2P = kConfigDefaultProxyServerPortI2P;
if (load.empty()) { if (load.empty()) {
std::cerr << "p3PeerMgrIMPL::loadList() list is empty, it may be a configuration problem." << std::endl; std::cerr << "p3PeerMgrIMPL::loadList() list is empty, it may be a configuration problem." << std::endl;
@ -1876,20 +2193,38 @@ bool p3PeerMgrIMPL::loadList(std::list<RsItem *>& load)
std::cerr << "setting use_extr_addr_finder to " << useExtAddrFinder << std::endl ; std::cerr << "setting use_extr_addr_finder to " << useExtAddrFinder << std::endl ;
#endif #endif
} }
else if (kit->key == kConfigKeyProxyServerIpAddr) // Tor
else if (kit->key == kConfigKeyProxyServerIpAddrTor)
{ {
proxyIpAddress = kit->value; proxyIpAddressTor = kit->value;
#ifdef PEER_DEBUG #ifdef PEER_DEBUG
std::cerr << "Loaded proxyIpAddress: " << proxyIpAddress; std::cerr << "Loaded proxyIpAddress for Tor: " << proxyIpAddressTor;
std::cerr << std::endl ; std::cerr << std::endl ;
#endif #endif
} }
else if (kit->key == kConfigKeyProxyServerPort) else if (kit->key == kConfigKeyProxyServerPortTor)
{ {
proxyPort = atoi(kit->value.c_str()); proxyPortTor = atoi(kit->value.c_str());
#ifdef PEER_DEBUG #ifdef PEER_DEBUG
std::cerr << "Loaded proxyPort: " << proxyPort; std::cerr << "Loaded proxyPort for Tor: " << proxyPortTor;
std::cerr << std::endl ;
#endif
}
// I2p
else if (kit->key == kConfigKeyProxyServerIpAddrI2P)
{
proxyIpAddressI2P = kit->value;
#ifdef PEER_DEBUG
std::cerr << "Loaded proxyIpAddress for I2P: " << proxyIpAddressI2P;
std::cerr << std::endl ;
#endif
}
else if (kit->key == kConfigKeyProxyServerPortI2P)
{
proxyPortI2P = atoi(kit->value.c_str());
#ifdef PEER_DEBUG
std::cerr << "Loaded proxyPort for I2P: " << proxyPortI2P;
std::cerr << std::endl ; std::cerr << std::endl ;
#endif #endif
} }
@ -2005,13 +2340,24 @@ bool p3PeerMgrIMPL::loadList(std::list<RsItem *>& load)
// Configure Proxy Server. // Configure Proxy Server.
struct sockaddr_storage proxy_addr; struct sockaddr_storage proxy_addr;
// Tor
sockaddr_storage_clear(proxy_addr); sockaddr_storage_clear(proxy_addr);
sockaddr_storage_ipv4_aton(proxy_addr, proxyIpAddress.c_str()); sockaddr_storage_ipv4_aton(proxy_addr, proxyIpAddressTor.c_str());
sockaddr_storage_ipv4_setport(proxy_addr, proxyPort); sockaddr_storage_ipv4_setport(proxy_addr, proxyPortTor);
if (sockaddr_storage_isValidNet(proxy_addr)) if (sockaddr_storage_isValidNet(proxy_addr))
{ {
setProxyServerAddress(proxy_addr); setProxyServerAddress(RS_HIDDEN_TYPE_TOR, proxy_addr);
}
// I2P
sockaddr_storage_clear(proxy_addr);
sockaddr_storage_ipv4_aton(proxy_addr, proxyIpAddressI2P.c_str());
sockaddr_storage_ipv4_setport(proxy_addr, proxyPortI2P);
if (sockaddr_storage_isValidNet(proxy_addr))
{
setProxyServerAddress(RS_HIDDEN_TYPE_I2P, proxy_addr);
} }
return true; return true;

39
libretroshare/src/pqi/p3peermgr.h
View File

@ -90,6 +90,7 @@ class peerState
bool hiddenNode; /* all IP addresses / dyndns must be blank */ bool hiddenNode; /* all IP addresses / dyndns must be blank */
std::string hiddenDomain; std::string hiddenDomain;
uint16_t hiddenPort; uint16_t hiddenPort;
uint32_t hiddenType;
std::string location; std::string location;
std::string name; std::string name;
@ -153,6 +154,7 @@ virtual bool setLocalAddress(const RsPeerId &id, const struct sockaddr_storage
virtual bool setExtAddress(const RsPeerId &id, const struct sockaddr_storage &addr) = 0; virtual bool setExtAddress(const RsPeerId &id, const struct sockaddr_storage &addr) = 0;
virtual bool setDynDNS(const RsPeerId &id, const std::string &dyndns) = 0; virtual bool setDynDNS(const RsPeerId &id, const std::string &dyndns) = 0;
virtual bool addCandidateForOwnExternalAddress(const RsPeerId& from, const struct sockaddr_storage &addr) = 0; virtual bool addCandidateForOwnExternalAddress(const RsPeerId& from, const struct sockaddr_storage &addr) = 0;
virtual bool getExtAddressReportedByFriends(struct sockaddr_storage& addr,uint8_t& isstable) = 0;
virtual bool setNetworkMode(const RsPeerId &id, uint32_t netMode) = 0; virtual bool setNetworkMode(const RsPeerId &id, uint32_t netMode) = 0;
virtual bool setVisState(const RsPeerId &id, uint16_t vs_disc, uint16_t vs_dht) = 0; virtual bool setVisState(const RsPeerId &id, uint16_t vs_disc, uint16_t vs_dht) = 0;
@ -185,12 +187,16 @@ virtual bool getPeerName(const RsPeerId &ssl_id, std::string &name) = 0;
virtual bool getGpgId(const RsPeerId &sslId, RsPgpId &gpgId) = 0; virtual bool getGpgId(const RsPeerId &sslId, RsPgpId &gpgId) = 0;
virtual uint32_t getConnectionType(const RsPeerId &sslId) = 0; virtual uint32_t getConnectionType(const RsPeerId &sslId) = 0;
virtual bool setProxyServerAddress(const struct sockaddr_storage &proxy_addr) = 0; virtual bool setProxyServerAddress(const uint32_t type, const struct sockaddr_storage &proxy_addr) = 0;
virtual bool getProxyServerAddress(struct sockaddr_storage &proxy_addr) = 0; virtual bool getProxyServerAddress(const uint32_t type, struct sockaddr_storage &proxy_addr) = 0;
virtual bool getProxyServerStatus(uint32_t& status) = 0; virtual bool getProxyServerStatus(const uint32_t type, uint32_t& status) = 0;
virtual bool isHidden() = 0; virtual bool isHidden() = 0;
virtual bool isHidden(const uint32_t type) = 0;
virtual bool isHiddenPeer(const RsPeerId &ssl_id) = 0; virtual bool isHiddenPeer(const RsPeerId &ssl_id) = 0;
virtual bool isHiddenPeer(const RsPeerId &ssl_id, const uint32_t type) = 0;
virtual bool getProxyAddress(const RsPeerId &ssl_id, struct sockaddr_storage &proxy_addr, std::string &domain_addr, uint16_t &domain_port) = 0; virtual bool getProxyAddress(const RsPeerId &ssl_id, struct sockaddr_storage &proxy_addr, std::string &domain_addr, uint16_t &domain_port) = 0;
virtual uint32_t hiddenDomainToHiddenType(const std::string &domain) = 0;
virtual uint32_t getHiddenType(const RsPeerId &ssl_id) = 0;
virtual int getFriendCount(bool ssl, bool online) = 0; virtual int getFriendCount(bool ssl, bool online) = 0;
@ -200,6 +206,7 @@ virtual int getFriendCount(bool ssl, bool online) = 0;
// Single Use Function... shouldn't be here. used by p3serverconfig.cc // Single Use Function... shouldn't be here. used by p3serverconfig.cc
virtual bool haveOnceConnected() = 0; virtual bool haveOnceConnected() = 0;
virtual bool locked_computeCurrentBestOwnExtAddressCandidate(sockaddr_storage &addr, uint32_t &count)=0;
/*************************************************************************************************/ /*************************************************************************************************/
/*************************************************************************************************/ /*************************************************************************************************/
@ -256,6 +263,7 @@ virtual bool setLocalAddress(const RsPeerId &id, const struct sockaddr_storage
virtual bool setExtAddress(const RsPeerId &id, const struct sockaddr_storage &addr); virtual bool setExtAddress(const RsPeerId &id, const struct sockaddr_storage &addr);
virtual bool setDynDNS(const RsPeerId &id, const std::string &dyndns); virtual bool setDynDNS(const RsPeerId &id, const std::string &dyndns);
virtual bool addCandidateForOwnExternalAddress(const RsPeerId& from, const struct sockaddr_storage &addr) ; virtual bool addCandidateForOwnExternalAddress(const RsPeerId& from, const struct sockaddr_storage &addr) ;
virtual bool getExtAddressReportedByFriends(struct sockaddr_storage& addr, uint8_t &isstable) ;
virtual bool setNetworkMode(const RsPeerId &id, uint32_t netMode); virtual bool setNetworkMode(const RsPeerId &id, uint32_t netMode);
virtual bool setVisState(const RsPeerId &id, uint16_t vs_disc, uint16_t vs_dht); virtual bool setVisState(const RsPeerId &id, uint16_t vs_disc, uint16_t vs_dht);
@ -288,12 +296,16 @@ virtual bool getPeerName(const RsPeerId& ssl_id, std::string& name);
virtual bool getGpgId(const RsPeerId& sslId, RsPgpId& gpgId); virtual bool getGpgId(const RsPeerId& sslId, RsPgpId& gpgId);
virtual uint32_t getConnectionType(const RsPeerId& sslId); virtual uint32_t getConnectionType(const RsPeerId& sslId);
virtual bool setProxyServerAddress(const struct sockaddr_storage &proxy_addr); virtual bool setProxyServerAddress(const uint32_t type, const struct sockaddr_storage &proxy_addr);
virtual bool getProxyServerAddress(struct sockaddr_storage &proxy_addr); virtual bool getProxyServerAddress(const uint32_t type, struct sockaddr_storage &proxy_addr);
virtual bool getProxyServerStatus(uint32_t &proxy_status); virtual bool getProxyServerStatus(const uint32_t type, uint32_t &proxy_status);
virtual bool isHidden(); virtual bool isHidden();
virtual bool isHiddenPeer(const RsPeerId& ssl_id); virtual bool isHidden(const uint32_t type);
virtual bool isHiddenPeer(const RsPeerId &ssl_id);
virtual bool isHiddenPeer(const RsPeerId &ssl_id, const uint32_t type);
virtual bool getProxyAddress(const RsPeerId& ssl_id, struct sockaddr_storage &proxy_addr, std::string &domain_addr, uint16_t &domain_port); virtual bool getProxyAddress(const RsPeerId& ssl_id, struct sockaddr_storage &proxy_addr, std::string &domain_addr, uint16_t &domain_port);
virtual uint32_t hiddenDomainToHiddenType(const std::string &domain);
virtual uint32_t getHiddenType(const RsPeerId &ssl_id);
virtual int getFriendCount(bool ssl, bool online); virtual int getFriendCount(bool ssl, bool online);
@ -327,6 +339,7 @@ int getConnectAddresses(const RsPeerId &id,
struct sockaddr_storage &lAddr, struct sockaddr_storage &eAddr, struct sockaddr_storage &lAddr, struct sockaddr_storage &eAddr,
pqiIpAddrSet &histAddrs, std::string &dyndns); pqiIpAddrSet &histAddrs, std::string &dyndns);
protected: protected:
/* Internal Functions */ /* Internal Functions */
@ -335,6 +348,8 @@ bool removeBannedIps();
void printPeerLists(std::ostream &out); void printPeerLists(std::ostream &out);
virtual bool locked_computeCurrentBestOwnExtAddressCandidate(sockaddr_storage &addr, uint32_t &count);
protected: protected:
/*****************************************************************/ /*****************************************************************/
/*********************** p3config ******************************/ /*********************** p3config ******************************/
@ -349,7 +364,7 @@ void printPeerLists(std::ostream &out);
p3LinkMgrIMPL *mLinkMgr; p3LinkMgrIMPL *mLinkMgr;
p3NetMgrIMPL *mNetMgr; p3NetMgrIMPL *mNetMgr;
private: private:
RsMutex mPeerMtx; /* protects below */ RsMutex mPeerMtx; /* protects below */
@ -362,6 +377,8 @@ private:
std::map<RsPeerId, peerState> mFriendList; // <SSLid , peerState> std::map<RsPeerId, peerState> mFriendList; // <SSLid , peerState>
std::map<RsPeerId, peerState> mOthersList; std::map<RsPeerId, peerState> mOthersList;
std::map<RsPeerId,sockaddr_storage> mReportedOwnAddresses ;
std::list<RsPeerGroupItem *> groupList; std::list<RsPeerGroupItem *> groupList;
uint32_t lastGroupId; uint32_t lastGroupId;
@ -369,8 +386,10 @@ private:
std::map<RsPgpId, ServicePermissionFlags> mFriendsPermissionFlags ; // permission flags for each gpg key std::map<RsPgpId, ServicePermissionFlags> mFriendsPermissionFlags ; // permission flags for each gpg key
struct sockaddr_storage mProxyServerAddress; struct sockaddr_storage mProxyServerAddressTor;
uint32_t mProxyServerStatus ; struct sockaddr_storage mProxyServerAddressI2P;
uint32_t mProxyServerStatusTor ;
uint32_t mProxyServerStatusI2P ;
}; };

4
libretroshare/src/pqi/p3servicecontrol.cc
View File

@ -148,7 +148,7 @@ public:
uint32_t tmp ; uint32_t tmp ;
ok &= getRawUInt32(data, rssize, &offset, &tmp); ok &= getRawUInt32(data, rssize, &offset, &tmp);
for(int i=0;i<tmp && offset < rssize;++i) for(uint32_t i=0;i<tmp && offset < rssize;++i)
{ {
RsPeerId peer_id ; RsPeerId peer_id ;
ok &= peer_id.deserialise(data,rssize,offset) ; ok &= peer_id.deserialise(data,rssize,offset) ;
@ -157,7 +157,7 @@ public:
ok &= getRawUInt32(data, rssize, &offset, &tmp); ok &= getRawUInt32(data, rssize, &offset, &tmp);
for(int i=0;i<tmp && offset < rssize;++i) for(uint32_t i=0;i<tmp && offset < rssize;++i)
{ {
RsPeerId peer_id ; RsPeerId peer_id ;
ok &= peer_id.deserialise(data,rssize,offset) ; ok &= peer_id.deserialise(data,rssize,offset) ;

3
libretroshare/src/pqi/pqi_base.h
View File

@ -249,7 +249,8 @@ class PQInterface: public RateInterface
const uint32_t PQI_CONNECT_TCP = 0x0001; const uint32_t PQI_CONNECT_TCP = 0x0001;
const uint32_t PQI_CONNECT_UDP = 0x0002; const uint32_t PQI_CONNECT_UDP = 0x0002;
const uint32_t PQI_CONNECT_HIDDEN_TCP = 0x0004; const uint32_t PQI_CONNECT_HIDDEN_TOR_TCP = 0x0004;
const uint32_t PQI_CONNECT_HIDDEN_I2P_TCP = 0x0008;
#define BIN_FLAGS_NO_CLOSE 0x0001 #define BIN_FLAGS_NO_CLOSE 0x0001

4
libretroshare/src/pqi/pqibin.cc
View File

@ -500,7 +500,7 @@ void printNetBinID(std::ostream &out, const RsPeerId& id, uint32_t t)
{ {
out << "TCP)"; out << "TCP)";
} }
else if (t == PQI_CONNECT_HIDDEN_TCP) else if (t & (PQI_CONNECT_HIDDEN_TOR_TCP | PQI_CONNECT_HIDDEN_I2P_TCP))
{ {
out << "HTCP"; out << "HTCP";
} }
@ -544,7 +544,7 @@ int NetBinDummy::connect(const struct sockaddr_storage &raddr)
std::cerr << std::endl; std::cerr << std::endl;
if (parent()) if (parent())
{ {
struct sockaddr_storage addr = raddr; //struct sockaddr_storage addr = raddr;
parent()->notifyEvent(this, CONNECT_FAILED, raddr); parent()->notifyEvent(this, CONNECT_FAILED, raddr);
} }
} }

65
libretroshare/src/pqi/pqinetwork.cc
View File

@ -55,6 +55,11 @@ int errno;
#endif #endif
#ifdef __HAIKU__
#include <sys/sockio.h>
#define IFF_RUNNING 0x0001
#endif
/********************************** WINDOWS/UNIX SPECIFIC PART ******************/ /********************************** WINDOWS/UNIX SPECIFIC PART ******************/
#ifndef WINDOWS_SYS #ifndef WINDOWS_SYS
@ -758,52 +763,6 @@ bool getLocalInterfaces(struct sockaddr_storage &existAddr, std::list<struct soc
return false; return false;
} }
bool sameNet(const struct in_addr *addr, const struct in_addr *addr2)
{
#ifdef NET_DEBUG
std::cerr << "sameNet: " << rs_inet_ntoa(*addr);
std::cerr << " VS " << rs_inet_ntoa(*addr2);
std::cerr << std::endl;
#endif
struct in_addr addrnet, addrnet2;
addrnet.s_addr = inet_netof(*addr);
addrnet2.s_addr = inet_netof(*addr2);
#ifdef NET_DEBUG
std::cerr << " (" << rs_inet_ntoa(addrnet);
std::cerr << " =?= " << rs_inet_ntoa(addrnet2);
std::cerr << ")" << std::endl;
#endif
in_addr_t address1 = htonl(addr->s_addr);
in_addr_t address2 = htonl(addr2->s_addr);
// handle case for private net: 172.16.0.0/12
if (address1>>20 == (172<<4 | 16>>4))
{
return (address1>>20 == address2>>20);
}
return (inet_netof(*addr) == inet_netof(*addr2));
}
bool isSameSubnet(struct in_addr *addr1, struct in_addr *addr2)
{
/*
* check that the (addr1 & 255.255.255.0) == (addr2 & 255.255.255.0)
*/
unsigned long a1 = ntohl(addr1->s_addr);
unsigned long a2 = ntohl(addr2->s_addr);
return ((a1 & 0xffffff00) == (a2 & 0xffffff00));
}
/* This just might be portable!!! will see!!! /* This just might be portable!!! will see!!!
* Unfortunately this is usable on winXP+, determined by: (_WIN32_WINNT >= 0x0501) * Unfortunately this is usable on winXP+, determined by: (_WIN32_WINNT >= 0x0501)
* but not older platforms.... which must use gethostbyname. * but not older platforms.... which must use gethostbyname.
@ -899,16 +858,14 @@ int unix_close(int fd)
return ret; return ret;
} }
int unix_socket(int /*domain*/, int /*type*/, int /*protocol*/) int unix_socket(int domain, int type, int protocol)
{ {
int osock = socket(PF_INET, SOCK_STREAM, 0); int osock = socket(domain, type, protocol);
/******************* WINDOWS SPECIFIC PART ******************/
#ifdef WINDOWS_SYS // WINDOWS
#ifdef WINDOWS_SYS
#ifdef NET_DEBUG #ifdef NET_DEBUG
std::cerr << "unix_socket()" << std::endl; std::cerr << "unix_socket()" << std::endl;
#endif #endif // NET_DEBUG
if ((unsigned) osock == INVALID_SOCKET) if ((unsigned) osock == INVALID_SOCKET)
{ {
@ -916,8 +873,8 @@ int unix_socket(int /*domain*/, int /*type*/, int /*protocol*/)
osock = -1; osock = -1;
errno = WinToUnixError(WSAGetLastError()); errno = WinToUnixError(WSAGetLastError());
} }
#endif #endif // WINDOWS_SYS
/******************* WINDOWS SPECIFIC PART ******************/
return osock; return osock;
} }

5
libretroshare/src/pqi/pqinetwork.h
View File

@ -38,6 +38,7 @@
#include <arpa/inet.h> #include <arpa/inet.h>
#include <sys/poll.h> #include <sys/poll.h>
#include <errno.h>
//socket blocking/options. //socket blocking/options.
#include <fcntl.h> #include <fcntl.h>
@ -104,10 +105,6 @@ int inaddr_cmp(struct sockaddr_in addr1, unsigned long);
bool getPreferredInterface(struct sockaddr_storage &existAddr, struct sockaddr_storage &prefAddr); // returns best addr. bool getPreferredInterface(struct sockaddr_storage &existAddr, struct sockaddr_storage &prefAddr); // returns best addr.
bool getLocalInterfaces(struct sockaddr_storage &existAddr, std::list<struct sockaddr_storage> &addrs); // returns all possible addrs. bool getLocalInterfaces(struct sockaddr_storage &existAddr, std::list<struct sockaddr_storage> &addrs); // returns all possible addrs.
// checks (addr1 & 255.255.255.0) == (addr2 & 255.255.255.0)
bool isSameSubnet(struct in_addr *addr1, struct in_addr *addr2);
bool sameNet(const struct in_addr *addr, const struct in_addr *addr2);
in_addr_t pqi_inet_netof(struct in_addr addr); // our implementation. in_addr_t pqi_inet_netof(struct in_addr addr); // our implementation.
bool LookupDNSAddr(std::string name, struct sockaddr_in &addr); bool LookupDNSAddr(std::string name, struct sockaddr_in &addr);

59
libretroshare/src/pqi/pqiperson.h
View File

@ -48,57 +48,36 @@ static const int HEARTBEAT_REPEAT_TIME = 5;
#include "pqi/pqiqosstreamer.h" #include "pqi/pqiqosstreamer.h"
#include "pqi/pqithreadstreamer.h" #include "pqi/pqithreadstreamer.h"
class pqiconnect: public pqiQoSstreamer, public NetInterface class pqiconnect : public pqiQoSstreamer, public NetInterface
{ {
public: public:
pqiconnect(PQInterface *parent, RsSerialiser *rss, NetBinInterface *ni_in) pqiconnect(PQInterface *parent, RsSerialiser *rss, NetBinInterface *ni_in) :
:pqiQoSstreamer(parent, rss, ni_in->PeerId(), ni_in, 0), // pqistreamer will cleanup NetInterface. pqiQoSstreamer(parent, rss, ni_in->PeerId(), ni_in, 0), // pqistreamer will cleanup NetInterface.
NetInterface(NULL, ni_in->PeerId()), // No need for callback NetInterface(NULL, ni_in->PeerId()), // No need for callback
ni(ni_in) ni(ni_in) {}
{
if (!ni_in)
{
std::cerr << "pqiconnect::pqiconnect() NetInterface == NULL, FATAL!";
std::cerr << std::endl;
exit(1);
}
return;
}
virtual ~pqiconnect() { return; } virtual ~pqiconnect() {}
virtual bool getCryptoParams(RsPeerCryptoParams& params) ; virtual bool getCryptoParams(RsPeerCryptoParams& params);
// presents a virtual NetInterface -> passes to ni. // presents a virtual NetInterface -> passes to ni.
virtual int connect(const struct sockaddr_storage &raddr) { return ni->connect(raddr); } virtual int connect(const struct sockaddr_storage &raddr) { return ni->connect(raddr); }
virtual int listen() { return ni -> listen(); } virtual int listen() { return ni->listen(); }
virtual int stoplistening() { return ni -> stoplistening(); } virtual int stoplistening() { return ni->stoplistening(); }
virtual int reset() { return ni -> reset(); } virtual int reset() { return ni->reset(); }
virtual int disconnect() { return ni -> reset(); } virtual int disconnect() { return ni->reset(); }
virtual bool connect_parameter(uint32_t type, uint32_t value) { return ni -> connect_parameter(type, value);} virtual bool connect_parameter(uint32_t type, uint32_t value) { return ni->connect_parameter(type, value);}
virtual bool connect_parameter(uint32_t type, std::string value) { return ni -> connect_parameter(type, value);} virtual bool connect_parameter(uint32_t type, std::string value) { return ni->connect_parameter(type, value);}
virtual bool connect_additional_address(uint32_t type, const struct sockaddr_storage &addr) { return ni -> connect_additional_address(type, addr);} virtual bool connect_additional_address(uint32_t type, const struct sockaddr_storage &addr) { return ni->connect_additional_address(type, addr); }
virtual int getConnectAddress(struct sockaddr_storage &raddr){ return ni->getConnectAddress(raddr); }
virtual int getConnectAddress(struct sockaddr_storage &raddr){ return ni->getConnectAddress(raddr); }
// get the contact from the net side! // get the contact from the net side!
virtual const RsPeerId& PeerId() virtual const RsPeerId& PeerId() { return ni->PeerId(); }
{
if (ni)
{
return ni->PeerId();
}
else
{
return PQInterface::PeerId();
}
}
// to check if our interface. // to check if our interface.
virtual bool thisNetInterface(NetInterface *ni_in) { return (ni_in == ni); } virtual bool thisNetInterface(NetInterface *ni_in) { return (ni_in == ni); }
protected: protected:
NetBinInterface *ni; NetBinInterface *ni;
protected:
}; };

20
libretroshare/src/pqi/pqipersongrp.cc
View File

@ -617,15 +617,19 @@ int pqipersongrp::connectPeer(const RsPeerId& id
uint32_t ptype; uint32_t ptype;
if (type & RS_NET_CONN_TCP_ALL) if (type & RS_NET_CONN_TCP_ALL)
{ {
if (type == RS_NET_CONN_TCP_HIDDEN) switch (type) {
{ case RS_NET_CONN_TCP_HIDDEN_TOR:
ptype = PQI_CONNECT_HIDDEN_TCP; ptype = PQI_CONNECT_HIDDEN_TOR_TCP;
timeout = RS_TCP_HIDDEN_TIMEOUT_PERIOD; timeout = RS_TCP_HIDDEN_TIMEOUT_PERIOD;
} break;
else case RS_NET_CONN_TCP_HIDDEN_I2P:
{ ptype = PQI_CONNECT_HIDDEN_I2P_TCP;
timeout = RS_TCP_HIDDEN_TIMEOUT_PERIOD;
break;
default:
ptype = PQI_CONNECT_TCP; ptype = PQI_CONNECT_TCP;
timeout = RS_TCP_STD_TIMEOUT_PERIOD; timeout = RS_TCP_STD_TIMEOUT_PERIOD;
break;
} }
#ifdef PGRP_DEBUG #ifdef PGRP_DEBUG
std::cerr << " pqipersongrp::connectPeer() connecting with TCP: Timeout :" << timeout; std::cerr << " pqipersongrp::connectPeer() connecting with TCP: Timeout :" << timeout;

4
libretroshare/src/pqi/pqiqos.cc
View File

@ -27,7 +27,7 @@ void pqiQoS::clear()
{ {
void *item ; void *item ;
for(int i=0;i<_item_queues.size();++i) for(uint32_t i=0;i<_item_queues.size();++i)
while( (item = _item_queues[i].pop()) != NULL) while( (item = _item_queues[i].pop()) != NULL)
free(item) ; free(item) ;
@ -46,7 +46,7 @@ void pqiQoS::print() const
void pqiQoS::in_rsItem(void *ptr,int priority) void pqiQoS::in_rsItem(void *ptr,int priority)
{ {
if(priority >= _item_queues.size()) if(uint32_t(priority) >= _item_queues.size())
{ {
std::cerr << "pqiQoS::in_rsRawItem() ****Warning****: priority " << priority << " out of scope [0," << _item_queues.size()-1 << "]. Priority will be clamped to maximum value." << std::endl; std::cerr << "pqiQoS::in_rsRawItem() ****Warning****: priority " << priority << " out of scope [0," << _item_queues.size()-1 << "]. Priority will be clamped to maximum value." << std::endl;
priority = _item_queues.size()-1 ; priority = _item_queues.size()-1 ;

69
libretroshare/src/pqi/pqissl.cc
View File

@ -103,7 +103,7 @@ pqissl::pqissl(pqissllistener *l, PQInterface *parent, p3LinkMgr *lm)
sslmode(PQISSL_ACTIVE), ssl_connection(NULL), sockfd(-1), sslmode(PQISSL_ACTIVE), ssl_connection(NULL), sockfd(-1),
readpkt(NULL), pktlen(0), total_len(0), readpkt(NULL), pktlen(0), total_len(0),
attempt_ts(0), attempt_ts(0),
sameLAN(false), n_read_zero(0), mReadZeroTS(0), ssl_connect_timeout(0), n_read_zero(0), mReadZeroTS(0), ssl_connect_timeout(0),
mConnectDelay(0), mConnectTS(0), mConnectDelay(0), mConnectTS(0),
mConnectTimeout(0), mTimeoutTS(0) mConnectTimeout(0), mTimeoutTS(0)
{ {
@ -255,7 +255,6 @@ int pqissl::reset_locked()
sockfd = -1; sockfd = -1;
waiting = WAITING_NOT; waiting = WAITING_NOT;
ssl_connection = NULL; ssl_connection = NULL;
sameLAN = false;
n_read_zero = 0; n_read_zero = 0;
mReadZeroTS = 0; mReadZeroTS = 0;
total_len = 0 ; total_len = 0 ;
@ -286,54 +285,40 @@ int pqissl::reset_locked()
return 1; return 1;
} }
bool pqissl::connect_parameter(uint32_t type, const std::string &value) bool pqissl::connect_parameter(uint32_t type, uint32_t value)
{ {
RsStackMutex stack(mSslMtx); /**** LOCKED MUTEX ****/ #ifdef PQISSL_LOG_DEBUG
std::cerr << "pqissl::connect_parameter() Peer: " << PeerId();
/* remove unused parameter warnings */
(void) type;
(void) value;
return false;
}
bool pqissl::connect_parameter(uint32_t type, uint32_t value)
{
RsStackMutex stack(mSslMtx); /**** LOCKED MUTEX ****/
#ifdef PQISSL_LOG_DEBUG
{
std::string out = "pqissl::connect_parameter() Peer: " + PeerId();
rs_sprintf_append(out, " type: %u value: %u", type, value);
rslog(RSL_DEBUG_ALL, pqisslzone, out);
}
#endif #endif
if (type == NET_PARAM_CONNECT_DELAY) switch(type)
{ {
#ifdef PQISSL_LOG_DEBUG case NET_PARAM_CONNECT_DELAY:
std::string out = "pqissl::connect_parameter() Peer: " + PeerId(); {
rs_sprintf_append(out, " DELAY: %u", value); #ifdef PQISSL_LOG_DEBUG
rslog(RSL_DEBUG_BASIC, pqisslzone, out); std::cerr << " DELAY: " << value << std::endl;
#endif #endif
RS_STACK_MUTEX(mSslMtx);
mConnectDelay = value; mConnectDelay = value;
return true; return true;
} }
else if (type == NET_PARAM_CONNECT_TIMEOUT) case NET_PARAM_CONNECT_TIMEOUT:
{ {
#ifdef PQISSL_LOG_DEBUG #ifdef PQISSL_LOG_DEBUG
std::string out = "pqissl::connect_parameter() Peer: " + PeerId(); std::cerr << " TIMEOUT: " << value << std::endl;
rs_sprintf_append(out, " TIMEOUT: %u", value);
rslog(RSL_DEBUG_BASIC, pqisslzone, out);
#endif #endif
RS_STACK_MUTEX(mSslMtx);
mConnectTimeout = value; mConnectTimeout = value;
return true; return true;
} }
return false; default:
//return NetInterface::connect_parameter(type, value); {
#ifdef PQISSL_LOG_DEBUG
std::cerr << " type: " << type << " value: " << value << std::endl;
#endif
return false;
}
}
} }
@ -1472,22 +1457,12 @@ int pqissl::accept_locked(SSL *ssl, int fd, const struct sockaddr_storage &forei
struct sockaddr_storage localaddr; struct sockaddr_storage localaddr;
mLinkMgr->getLocalAddress(localaddr); mLinkMgr->getLocalAddress(localaddr);
sameLAN = sockaddr_storage_samesubnet(remote_addr, localaddr);
{ {
std::string out = "pqissl::accept() SUCCESSFUL connection to: " + PeerId().toStdString(); std::string out = "pqissl::accept() SUCCESSFUL connection to: " + PeerId().toStdString();
out += " localaddr: " + sockaddr_storage_iptostring(localaddr); out += " localaddr: " + sockaddr_storage_iptostring(localaddr);
out += " remoteaddr: " + sockaddr_storage_iptostring(remote_addr); out += " remoteaddr: " + sockaddr_storage_iptostring(remote_addr);
if (sameLAN)
{
out += " SAME LAN";
}
else
{
out += " DIFF LANs";
}
rslog(RSL_WARNING, pqisslzone, out); rslog(RSL_WARNING, pqisslzone, out);
} }

4
libretroshare/src/pqi/pqissl.h
View File

@ -98,7 +98,7 @@ virtual int reset();
virtual int disconnect(); virtual int disconnect();
virtual int getConnectAddress(struct sockaddr_storage &raddr); virtual int getConnectAddress(struct sockaddr_storage &raddr);
virtual bool connect_parameter(uint32_t type, const std::string &value); virtual bool connect_parameter(uint32_t /*type*/, const std::string & /*value*/) { return false; }
virtual bool connect_parameter(uint32_t type, uint32_t value); virtual bool connect_parameter(uint32_t type, uint32_t value);
// BinInterface // BinInterface
@ -196,8 +196,6 @@ virtual int net_internal_fcntl_nonblock(int fd);
int attempt_ts; int attempt_ts;
bool sameLAN; /* flag use to allow high-speed transfers */
int n_read_zero; /* a counter to determine if the connection is really dead */ int n_read_zero; /* a counter to determine if the connection is really dead */
time_t mReadZeroTS; /* timestamp of first READ_ZERO occurance */ time_t mReadZeroTS; /* timestamp of first READ_ZERO occurance */

7
libretroshare/src/pqi/pqissllistener.cc
View File

@ -123,6 +123,10 @@ int pqissllistenbase::setuplisten()
err = fcntl(lsock, F_SETFL, O_NONBLOCK); err = fcntl(lsock, F_SETFL, O_NONBLOCK);
if (err < 0) if (err < 0)
{ {
shutdown(lsock,SHUT_RDWR) ;
close(lsock) ;
lsock = -1 ;
std::string out; std::string out;
rs_sprintf(out, "Error: Cannot make socket NON-Blocking: %d", err); rs_sprintf(out, "Error: Cannot make socket NON-Blocking: %d", err);
pqioutput(PQL_ERROR, pqissllistenzone, out); pqioutput(PQL_ERROR, pqissllistenzone, out);
@ -145,6 +149,9 @@ int pqissllistenbase::setuplisten()
unsigned long int on = 1; unsigned long int on = 1;
if (0 != (err = ioctlsocket(lsock, FIONBIO, &on))) if (0 != (err = ioctlsocket(lsock, FIONBIO, &on)))
{ {
closesocket(lsock) ;
lsock = -1 ;
std::string out; std::string out;
rs_sprintf(out, "pqissllistenbase::setuplisten() Error: Cannot make socket NON-Blocking: %d\n", err); rs_sprintf(out, "pqissllistenbase::setuplisten() Error: Cannot make socket NON-Blocking: %d\n", err);
out += "Socket Error: " + socket_errorType(WSAGetLastError()); out += "Socket Error: " + socket_errorType(WSAGetLastError());

31
libretroshare/src/pqi/pqisslpersongrp.cc
View File

@ -91,7 +91,36 @@ pqiperson * pqisslpersongrp::locked_createPerson(const RsPeerId& id, pqilistener
pqiconnect *pqisc = new pqiconnect(pqip, rss, pqis); pqiconnect *pqisc = new pqiconnect(pqip, rss, pqis);
pqip -> addChildInterface(PQI_CONNECT_HIDDEN_TCP, pqisc); /* first select type based on peer */
uint32_t typePeer = mPeerMgr->getHiddenType(id);
switch (typePeer) {
case RS_HIDDEN_TYPE_TOR:
pqip -> addChildInterface(PQI_CONNECT_HIDDEN_TOR_TCP, pqisc);
break;
case RS_HIDDEN_TYPE_I2P:
pqip -> addChildInterface(PQI_CONNECT_HIDDEN_I2P_TCP, pqisc);
break;
default:
/* peer is not a hidden one but we are */
/* select type based on ourselves */
uint32_t typeOwn = mPeerMgr->getHiddenType(AuthSSL::getAuthSSL()->OwnId());
switch (typeOwn) {
case RS_HIDDEN_TYPE_I2P:
pqip -> addChildInterface(PQI_CONNECT_HIDDEN_I2P_TCP, pqisc);
break;
default:
/* this case shouldn't happen! */
std::cerr << "pqisslpersongrp::locked_createPerson WARNING INVALID HIDDEN TYPES - THIS SHOULD NOT HAPPEN!" << std::endl;
std::cerr << " - ID: " << id << std::endl;
std::cerr << " - mPeerMgr->isHidden(): " << mPeerMgr->isHidden() << std::endl;
std::cerr << " - mPeerMgr->isHiddenPeer(id): " << mPeerMgr->isHiddenPeer(id) << std::endl;
std::cerr << " - hidden types: peer=" << typePeer << " own=" << typeOwn << std::endl;
std::cerr << " --> falling back to Tor" << std::endl;
case RS_HIDDEN_TYPE_TOR:
pqip -> addChildInterface(PQI_CONNECT_HIDDEN_TOR_TCP, pqisc);
break;
}
}
} }
else else
{ {

281
libretroshare/src/pqi/sslfns.cc
View File

@ -72,102 +72,79 @@ X509_REQ *GenerateX509Req(
std::string loc, std::string state, std::string country, std::string loc, std::string state, std::string country,
int nbits_in, std::string &errString) int nbits_in, std::string &errString)
{ {
/* generate request */ /* generate request */
X509_REQ *req=X509_REQ_new(); X509_REQ *req=X509_REQ_new();
// setup output. // setup output.
BIO *bio_out = NULL; BIO *bio_out = BIO_new(BIO_s_file());
bio_out = BIO_new(BIO_s_file()); BIO_set_fp(bio_out,stdout,BIO_NOCLOSE);
BIO_set_fp(bio_out,stdout,BIO_NOCLOSE);
EVP_PKEY *pkey = NULL; EVP_PKEY *pkey = NULL;
X509_NAME *x509_name = NULL ;
RSA *rsa = NULL ;
// first generate a key.... try
if ((pkey=EVP_PKEY_new()) == NULL) {
{ // first generate a key....
fprintf(stderr,"GenerateX509Req: Couldn't Create Key\n"); if ((pkey=EVP_PKEY_new()) == NULL)
errString = "Couldn't Create Key"; {
return 0; fprintf(stderr,"GenerateX509Req: Couldn't Create Key\n");
} throw std::runtime_error("Couldn't Create Key") ;
}
int nbits = 2048; int nbits = 2048;
unsigned long e = 0x10001; unsigned long e = 0x10001;
if ((nbits_in >= 512) && (nbits_in <= 4096)) if ((nbits_in >= 512) && (nbits_in <= 4096))
{ {
nbits = nbits_in; nbits = nbits_in;
} }
else else
{ {
fprintf(stderr,"GenerateX509Req: strange num of nbits: %d\n", nbits_in); fprintf(stderr,"GenerateX509Req: strange num of nbits: %d\n", nbits_in);
fprintf(stderr,"GenerateX509Req: reverting to %d\n", nbits); fprintf(stderr,"GenerateX509Req: reverting to %d\n", nbits);
} }
rsa = RSA_generate_key(nbits, e, NULL, NULL);
RSA *rsa = RSA_generate_key(nbits, e, NULL, NULL); if ((rsa == NULL) || !EVP_PKEY_assign_RSA(pkey, rsa))
if ((rsa == NULL) || !EVP_PKEY_assign_RSA(pkey, rsa)) throw std::runtime_error("Couldn't generate RSA Key");
{
if(rsa) RSA_free(rsa);
fprintf(stderr,"GenerateX509Req: Couldn't Generate RSA Key!\n");
errString = "Couldn't generate RSA Key";
return 0;
}
// open the file.
FILE *out;
if (NULL == (out = RsDirUtil::rs_fopen(pkey_file.c_str(), "w")))
throw std::runtime_error("Couldn't Create Key File \"" + pkey_file + "\"");
// open the file. const EVP_CIPHER *cipher = EVP_des_ede3_cbc();
FILE *out;
if (NULL == (out = RsDirUtil::rs_fopen(pkey_file.c_str(), "w")))
{
fprintf(stderr,"GenerateX509Req: Couldn't Create Key File!");
fprintf(stderr," : %s\n", pkey_file.c_str());
errString = "Couldn't Create Key File"; if (!PEM_write_PrivateKey(out,pkey,cipher, NULL,0,NULL,(void *) passwd.c_str()))
return 0; {
} fclose(out) ;
throw std::runtime_error("Couldn't Save Private Key to file \""+pkey_file+"\"");
}
const EVP_CIPHER *cipher = EVP_des_ede3_cbc(); fclose(out);
if (!PEM_write_PrivateKey(out,pkey,cipher, // We have now created a private key....
NULL,0,NULL,(void *) passwd.c_str())) std::cerr << "GenerateX509Req() Saved Private Key to file \"" << pkey_file << "\"" << std::endl;
{
fprintf(stderr,"GenerateX509Req() Couldn't Save Private Key");
fprintf(stderr," : %s\n", pkey_file.c_str());
errString = "Couldn't Save Private Key File"; /********** Test Loading the private Key.... ************/
return 0; FILE *tst_in = NULL;
} EVP_PKEY *tst_pkey = NULL;
fclose(out);
// We have now created a private key.... if (NULL == (tst_in = RsDirUtil::rs_fopen(pkey_file.c_str(), "rb")))
fprintf(stderr,"GenerateX509Req() Saved Private Key"); throw std::runtime_error("GenerateX509Req() Couldn't Open Private Key file \""+pkey_file+"\"") ;
fprintf(stderr," : %s\n", pkey_file.c_str());
/********** Test Loading the private Key.... ************/ if (NULL == (tst_pkey = PEM_read_PrivateKey(tst_in,NULL,NULL,(void *) passwd.c_str())))
FILE *tst_in = NULL; {
EVP_PKEY *tst_pkey = NULL; fclose(tst_in);
if (NULL == (tst_in = RsDirUtil::rs_fopen(pkey_file.c_str(), "rb"))) throw std::runtime_error("GenerateX509Req() Couldn't read Private Key file \""+pkey_file+"\"") ;
{ }
fprintf(stderr,"GenerateX509Req() Couldn't Open Private Key");
fprintf(stderr," : %s\n", pkey_file.c_str());
errString = "Couldn't Open Private Key"; fclose(tst_in);
return 0; EVP_PKEY_free(tst_pkey);
}
if (NULL == (tst_pkey = /* Fill in details: fields.
PEM_read_PrivateKey(tst_in,NULL,NULL,(void *) passwd.c_str())))
{
fprintf(stderr,"GenerateX509Req() Couldn't Read Private Key");
fprintf(stderr," : %s\n", pkey_file.c_str());
errString = "Couldn't Read Private Key";
return 0;
}
fclose(tst_in);
EVP_PKEY_free(tst_pkey);
/********** Test Loading the private Key.... ************/
/* Fill in details: fields.
req->req_info; req->req_info;
req->req_info->enc; req->req_info->enc;
req->req_info->version; req->req_info->version;
@ -175,108 +152,88 @@ X509_REQ *GenerateX509Req(
req->req_info->pubkey; req->req_info->pubkey;
****************************/ ****************************/
long version = 0x00; long version = 0x00;
unsigned long chtype = MBSTRING_UTF8; unsigned long chtype = MBSTRING_UTF8;
X509_NAME *x509_name = X509_NAME_new(); x509_name = X509_NAME_new();
// fill in the request. // fill in the request.
/**** X509_REQ -> Version ********************************/ /**** X509_REQ -> Version ********************************/
if (!X509_REQ_set_version(req,version)) /* version 1 */ if(!X509_REQ_set_version(req,version)) /* version 1 */
{ throw std::runtime_error("GenerateX509Req(): Couldn't Set SSL certificate Version!");
fprintf(stderr,"GenerateX509Req(): Couldn't Set Version!\n");
errString = "Couldn't Set Version"; /**** X509_REQ -> Version ********************************/
return 0; /**** X509_REQ -> Key ********************************/
}
/**** X509_REQ -> Version ********************************/
/**** X509_REQ -> Key ********************************/
if (!X509_REQ_set_pubkey(req,pkey)) if (!X509_REQ_set_pubkey(req,pkey))
{ throw std::runtime_error("GenerateX509Req(): Couldn't Set SSL certificate PUBKEY!");
fprintf(stderr,"GenerateX509Req() Couldn't Set PUBKEY !\n");
errString = "Couldn't Set PubKey"; /**** SUBJECT ********************************/
return 0; // create the name.
}
/**** SUBJECT ********************************/ // fields to add.
// create the name. // commonName CN
// emailAddress (none)
// organizationName O
// localityName L
// stateOrProvinceName ST
// countryName C
// fields to add. if (0 == strlen(name.c_str()))
// commonName CN throw std::runtime_error("No name! Aborting.") ;
// emailAddress (none)
// organizationName O
// localityName L
// stateOrProvinceName ST
// countryName C
if (0 < strlen(name.c_str())) X509_NAME_add_entry_by_txt(x509_name, "CN", chtype, (unsigned char *) name.c_str(), -1, -1, 0);
{
X509_NAME_add_entry_by_txt(x509_name, "CN", chtype,
(unsigned char *) name.c_str(), -1, -1, 0);
}
else
{
fprintf(stderr,"GenerateX509Req(): No Name -> Not creating X509 Cert Req\n");
errString = "No Name, Aborting";
return 0;
}
if (0 < strlen(email.c_str())) if (0 < strlen(email.c_str()))
{ X509_NAME_add_entry_by_NID(x509_name, 48, 0, (unsigned char *) email.c_str(), -1, -1, 0);
//X509_NAME_add_entry_by_txt(x509_name, "Email", 0,
// (unsigned char *) ui -> gen_email -> value(), -1, -1, 0);
X509_NAME_add_entry_by_NID(x509_name, 48, 0,
(unsigned char *) email.c_str(), -1, -1, 0);
}
if (0 < strlen(org.c_str())) if (0 < strlen(org.c_str()))
{ X509_NAME_add_entry_by_txt(x509_name, "O", chtype, (unsigned char *) org.c_str(), -1, -1, 0);
X509_NAME_add_entry_by_txt(x509_name, "O", chtype,
(unsigned char *) org.c_str(), -1, -1, 0);
}
if (0 < strlen(loc.c_str())) if (0 < strlen(loc.c_str()))
{ X509_NAME_add_entry_by_txt(x509_name, "L", chtype, (unsigned char *) loc.c_str(), -1, -1, 0);
X509_NAME_add_entry_by_txt(x509_name, "L", chtype,
(unsigned char *) loc.c_str(), -1, -1, 0);
}
if (0 < strlen(state.c_str())) if (0 < strlen(state.c_str()))
{ X509_NAME_add_entry_by_txt(x509_name, "ST", chtype, (unsigned char *) state.c_str(), -1, -1, 0);
X509_NAME_add_entry_by_txt(x509_name, "ST", chtype,
(unsigned char *) state.c_str(), -1, -1, 0);
}
if (0 < strlen(country.c_str())) if (0 < strlen(country.c_str()))
{ X509_NAME_add_entry_by_txt(x509_name, "C", chtype, (unsigned char *) country.c_str(), -1, -1, 0);
X509_NAME_add_entry_by_txt(x509_name, "C", chtype,
(unsigned char *) country.c_str(), -1, -1, 0);
}
if (!X509_REQ_set_subject_name(req,x509_name)) if (!X509_REQ_set_subject_name(req,x509_name))
{ throw std::runtime_error("GenerateX509Req() Couldn't Set Name to Request!");
fprintf(stderr,"GenerateX509Req() Couldn't Set Name to Request!\n");
X509_NAME_free(x509_name);
errString = "Couldn't Set Name"; X509_NAME_free(x509_name);
return 0;
}
X509_NAME_free(x509_name); /**** SUBJECT ********************************/
/**** SUBJECT ********************************/
if (!X509_REQ_sign(req,pkey,EVP_sha1())) if (!X509_REQ_sign(req,pkey,EVP_sha1()))
{ throw std::runtime_error("GenerateX509Req() Failed to sign REQ");
fprintf(stderr,"GenerateX509Req() Failed to Sign REQ\n");
errString = "Couldn't Sign Req"; errString = "No Error";
return 0;
}
errString = "No Error"; return req;
return req; }
catch(std::exception& e)
{
std::cerr << "(EE) Key creation failed: " << e.what() << std::endl;
errString = e.what() ;
req = NULL ;
}
if(rsa)
RSA_free(rsa);
if(x509_name)
X509_NAME_free(x509_name);
if(bio_out)
BIO_free_all(bio_out) ;
if(pkey)
EVP_PKEY_free(pkey);
return req ;
} }
#define SERIAL_RAND_BITS 64 #define SERIAL_RAND_BITS 64

25
libretroshare/src/retroshare/Makefile
View File

@ -1,25 +0,0 @@
RS_TOP_DIR = ..
##### Define any flags that are needed for this section #######
###############################################################
###############################################################
include $(RS_TOP_DIR)/scripts/config.mk
###############################################################
OBJ = notifytxt.o retroshare.o
#TESTOBJ =
TESTS = retroshare-nogui
all: tests
retroshare-nogui: $(OBJ)
$(CC) $(CFLAGS) -o retroshare-nogui $(OBJ) $(LIBS)
###############################################################
include $(RS_TOP_DIR)/scripts/rules.mk
###############################################################

14
libretroshare/src/retroshare/rsidentity.h
View File

@ -32,6 +32,7 @@
#include "retroshare/rstokenservice.h" #include "retroshare/rstokenservice.h"
#include "retroshare/rsgxsifacehelper.h" #include "retroshare/rsgxsifacehelper.h"
#include "retroshare/rsreputations.h"
#include "retroshare/rsids.h" #include "retroshare/rsids.h"
#include "serialiser/rstlvimage.h" #include "serialiser/rstlvimage.h"
#include "retroshare/rsgxscommon.h" #include "retroshare/rsgxscommon.h"
@ -158,8 +159,7 @@ class RsIdentityDetails
{ {
public: public:
RsIdentityDetails() RsIdentityDetails()
:mIsOwnId(false), mPgpLinked(false), mPgpKnown(false), :mIsOwnId(false), mPgpLinked(false), mPgpKnown(false), mLastUsageTS(0) { return; }
mReputation(), mLastUsageTS(0) { return; }
RsGxsId mId; RsGxsId mId;
@ -175,8 +175,12 @@ public:
// Recogn details. // Recogn details.
std::list<RsRecognTag> mRecognTags; std::list<RsRecognTag> mRecognTags;
// reputation details. // Cyril: Reputation details. At some point we might want to merge information
GxsReputation mReputation; // between the two into a single global score. Since the old reputation system
// is not finished yet, I leave this in place. We should decide what to do with it.
GxsReputation mReputation_oldSystem; // this is the old "mReputation" field, which apparently is not used.
RsReputations::ReputationInfo mReputation;
// avatar // avatar
RsGxsImage mAvatar ; RsGxsImage mAvatar ;
@ -214,7 +218,7 @@ public:
/********************************************************************************************/ /********************************************************************************************/
/********************************************************************************************/ /********************************************************************************************/
// For Other Services.... // For Other Services....
// It should be impossible for them to get a message which we don't have the identity. // It should be impossible for them to get a message which we don't have the identity.
// Its a major error if we don't have the identity. // Its a major error if we don't have the identity.

16
libretroshare/src/retroshare/rspeers.h
View File

@ -63,6 +63,14 @@ const uint32_t RS_NETMODE_EXT = 0x0003;
const uint32_t RS_NETMODE_HIDDEN = 0x0004; const uint32_t RS_NETMODE_HIDDEN = 0x0004;
const uint32_t RS_NETMODE_UNREACHABLE = 0x0005; const uint32_t RS_NETMODE_UNREACHABLE = 0x0005;
/* Hidden Type */
const uint32_t RS_HIDDEN_TYPE_NONE = 0x0000;
const uint32_t RS_HIDDEN_TYPE_UNKNOWN = 0x0001;
const uint32_t RS_HIDDEN_TYPE_TOR = 0x0002;
const uint32_t RS_HIDDEN_TYPE_I2P = 0x0004;
/* mask to match all valid hidden types */
const uint32_t RS_HIDDEN_TYPE_MASK = RS_HIDDEN_TYPE_I2P | RS_HIDDEN_TYPE_TOR;
/* Visibility */ /* Visibility */
const uint32_t RS_VS_DISC_OFF = 0x0000; const uint32_t RS_VS_DISC_OFF = 0x0000;
const uint32_t RS_VS_DISC_MINIMAL = 0x0001; const uint32_t RS_VS_DISC_MINIMAL = 0x0001;
@ -96,7 +104,8 @@ const uint32_t RS_PEER_CONNECTSTATE_TRYING_UDP = 3;
const uint32_t RS_PEER_CONNECTSTATE_CONNECTED_TCP = 4; const uint32_t RS_PEER_CONNECTSTATE_CONNECTED_TCP = 4;
const uint32_t RS_PEER_CONNECTSTATE_CONNECTED_UDP = 5; const uint32_t RS_PEER_CONNECTSTATE_CONNECTED_UDP = 5;
const uint32_t RS_PEER_CONNECTSTATE_CONNECTED_TOR = 6; const uint32_t RS_PEER_CONNECTSTATE_CONNECTED_TOR = 6;
const uint32_t RS_PEER_CONNECTSTATE_CONNECTED_UNKNOWN = 7; const uint32_t RS_PEER_CONNECTSTATE_CONNECTED_I2P = 7;
const uint32_t RS_PEER_CONNECTSTATE_CONNECTED_UNKNOWN = 8;
/* Error codes for certificate cleaning and cert parsing. Numbers should not overlap. */ /* Error codes for certificate cleaning and cert parsing. Numbers should not overlap. */
@ -232,6 +241,7 @@ class RsPeerDetails
bool isHiddenNode; bool isHiddenNode;
std::string hiddenNodeAddress; std::string hiddenNodeAddress;
uint16_t hiddenNodePort; uint16_t hiddenNodePort;
uint32_t hiddenType;
// Filled in for Standard Node. // Filled in for Standard Node.
std::string localAddr; std::string localAddr;
@ -350,8 +360,8 @@ class RsPeers
virtual bool setNetworkMode(const RsPeerId &ssl_id, uint32_t netMode) = 0; virtual bool setNetworkMode(const RsPeerId &ssl_id, uint32_t netMode) = 0;
virtual bool setVisState(const RsPeerId &ssl_id, uint16_t vs_disc, uint16_t vs_dht) = 0; virtual bool setVisState(const RsPeerId &ssl_id, uint16_t vs_disc, uint16_t vs_dht) = 0;
virtual bool getProxyServer(std::string &addr, uint16_t &port,uint32_t& status_flags) = 0; virtual bool getProxyServer(const uint32_t type, std::string &addr, uint16_t &port,uint32_t& status_flags) = 0;
virtual bool setProxyServer(const std::string &addr, const uint16_t port) = 0; virtual bool setProxyServer(const uint32_t type, const std::string &addr, const uint16_t port) = 0;
virtual void getIPServersList(std::list<std::string>& ip_servers) = 0; virtual void getIPServersList(std::list<std::string>& ip_servers) = 0;
virtual void allowServerIPDetermination(bool) = 0; virtual void allowServerIPDetermination(bool) = 0;

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

@ -40,6 +40,7 @@ extern RsPluginHandler *rsPlugins ;
class p3Service ; class p3Service ;
class RsServiceControl ; class RsServiceControl ;
class RsReputations ;
class RsTurtle ; class RsTurtle ;
class RsDht ; class RsDht ;
class RsDisc ; class RsDisc ;
@ -116,6 +117,7 @@ public:
RsUtil::inited_ptr<PgpAuxUtils> mPgpAuxUtils; RsUtil::inited_ptr<PgpAuxUtils> mPgpAuxUtils;
RsUtil::inited_ptr<RsGxsForums> mGxsForums; RsUtil::inited_ptr<RsGxsForums> mGxsForums;
RsUtil::inited_ptr<RsGxsChannels> mGxsChannels; RsUtil::inited_ptr<RsGxsChannels> mGxsChannels;
RsUtil::inited_ptr<RsReputations> mReputations;
}; };
class RsPlugin class RsPlugin

58
libretroshare/src/retroshare/rsreputations.h Normal file
View File

@ -0,0 +1,58 @@
/*
* libretroshare/src/services: rsreputation.h
*
* Services for RetroShare.
*
* Copyright 2015 by Cyril Soler
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License Version 2 as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
* USA.
*
* Please report all bugs and problems to "csoler@users.sourceforge.net".
*
*/
#pragma once
#include "retroshare/rsids.h"
#include "retroshare/rsgxsifacetypes.h"
class RsReputations
{
public:
// This is the interface file for the reputation system
//
enum Opinion { OPINION_NEGATIVE = 0, OPINION_NEUTRAL = 1, OPINION_POSITIVE = 2 } ;
enum Assessment { ASSESSMENT_BAD = 0, ASSESSMENT_OK = 1 } ;
struct ReputationInfo
{
RsReputations::Opinion mOwnOpinion ;
float mOverallReputationScore ;
float mFriendAverage ;
RsReputations::Assessment mAssessment; // this should help clients in taking decisions
};
virtual bool setOwnOpinion(const RsGxsId& key_id, const Opinion& op) =0;
virtual bool getReputationInfo(const RsGxsId& id,ReputationInfo& info) =0 ;
// This one is a proxy designed to allow fast checking of a GXS id.
// it basically returns true if assessment is not ASSESSMENT_OK
virtual bool isIdentityBanned(const RsGxsId& id) =0;
};
// To access reputations from anywhere
//
extern RsReputations *rsReputations ;

35
libretroshare/src/rsserver/Makefile
View File

@ -1,35 +0,0 @@
RS_TOP_DIR = ..
##### Define any flags that are needed for this section #######
###############################################################
###############################################################
include $(RS_TOP_DIR)/scripts/config.mk
###############################################################
RSOBJ = rsinit.o \
p3peers.o \
p3rank.o \
p3photo.o \
p3msgs.o \
p3blog.o \
p3discovery.o \
p3face-server.o \
p3face-config.o \
p3face-msgs.o \
rsiface.o \
rstypes.o
#TESTOBJ =
#TESTS =
all: librs tests
#tlvbase_test : tlvbase_test.o
# $(CC) $(CFLAGS) -o tlvbase_test tlvbase_test.o $(OBJ) $(LIBS)
###############################################################
include $(RS_TOP_DIR)/scripts/rules.mk
###############################################################

110
libretroshare/src/rsserver/p3peers.cc
View File

@ -313,6 +313,7 @@ bool p3Peers::getPeerDetails(const RsPeerId& id, RsPeerDetails &d)
d.isHiddenNode = true; d.isHiddenNode = true;
d.hiddenNodeAddress = ps.hiddenDomain; d.hiddenNodeAddress = ps.hiddenDomain;
d.hiddenNodePort = ps.hiddenPort; d.hiddenNodePort = ps.hiddenPort;
d.hiddenType = ps.hiddenType;
d.localAddr = sockaddr_storage_iptostring(ps.localaddr); d.localAddr = sockaddr_storage_iptostring(ps.localaddr);
d.localPort = sockaddr_storage_port(ps.localaddr); d.localPort = sockaddr_storage_port(ps.localaddr);
d.extAddr = "hidden"; d.extAddr = "hidden";
@ -324,6 +325,7 @@ bool p3Peers::getPeerDetails(const RsPeerId& id, RsPeerDetails &d)
d.isHiddenNode = false; d.isHiddenNode = false;
d.hiddenNodeAddress = ""; d.hiddenNodeAddress = "";
d.hiddenNodePort = 0; d.hiddenNodePort = 0;
d.hiddenType = RS_HIDDEN_TYPE_NONE;
d.localAddr = sockaddr_storage_iptostring(ps.localaddr); d.localAddr = sockaddr_storage_iptostring(ps.localaddr);
d.localPort = sockaddr_storage_port(ps.localaddr); d.localPort = sockaddr_storage_port(ps.localaddr);
@ -435,20 +437,79 @@ bool p3Peers::getPeerDetails(const RsPeerId& id, RsPeerDetails &d)
} }
else if (pcs.state & RS_PEER_S_CONNECTED) else if (pcs.state & RS_PEER_S_CONNECTED)
{ {
if(isProxyAddress(pcs.connectaddr) || mPeerMgr->isHidden()) /* peer is connected - determine how and set proper connectState */
d.connectState = RS_PEER_CONNECTSTATE_CONNECTED_TOR; if(mPeerMgr->isHidden())
else if (pcs.connecttype == RS_NET_CONN_TCP_ALL) {
{ uint32_t type;
d.connectState = RS_PEER_CONNECTSTATE_CONNECTED_TCP; /* hidden location */
} /* use connection direction to determine connection type */
else if (pcs.connecttype == RS_NET_CONN_UDP_ALL) if(pcs.actAsServer)
{ {
d.connectState = RS_PEER_CONNECTSTATE_CONNECTED_UDP; /* incoming connection */
} /* use own type to set connectState */
else type = mPeerMgr->getHiddenType(AuthSSL::getAuthSSL()->OwnId());
{ switch (type) {
d.connectState = RS_PEER_CONNECTSTATE_CONNECTED_UNKNOWN; case RS_HIDDEN_TYPE_TOR:
} d.connectState = RS_PEER_CONNECTSTATE_CONNECTED_TOR;
break;
case RS_HIDDEN_TYPE_I2P:
d.connectState = RS_PEER_CONNECTSTATE_CONNECTED_I2P;
break;
default:
d.connectState = RS_PEER_CONNECTSTATE_CONNECTED_UNKNOWN;
break;
}
}
else
{
/* outgoing connection */
/* use peer hidden type to set connectState */
switch (ps.hiddenType) {
case RS_HIDDEN_TYPE_TOR:
d.connectState = RS_PEER_CONNECTSTATE_CONNECTED_TOR;
break;
case RS_HIDDEN_TYPE_I2P:
d.connectState = RS_PEER_CONNECTSTATE_CONNECTED_I2P;
break;
default:
d.connectState = RS_PEER_CONNECTSTATE_CONNECTED_UNKNOWN;
break;
}
}
}
else if (ps.hiddenType & RS_HIDDEN_TYPE_MASK)
{
/* hidden peer */
/* use hidden type to set connectState */
switch (ps.hiddenType) {
case RS_HIDDEN_TYPE_TOR:
d.connectState = RS_PEER_CONNECTSTATE_CONNECTED_TOR;
break;
case RS_HIDDEN_TYPE_I2P:
d.connectState = RS_PEER_CONNECTSTATE_CONNECTED_I2P;
break;
default:
d.connectState = RS_PEER_CONNECTSTATE_CONNECTED_UNKNOWN;
break;
}
}
else
{
/* peer and we are normal nodes */
/* use normal detection to set connectState */
if (pcs.connecttype == RS_NET_CONN_TCP_ALL)
{
d.connectState = RS_PEER_CONNECTSTATE_CONNECTED_TCP;
}
else if (pcs.connecttype == RS_NET_CONN_UDP_ALL)
{
d.connectState = RS_PEER_CONNECTSTATE_CONNECTED_UDP;
}
else
{
d.connectState = RS_PEER_CONNECTSTATE_CONNECTED_UNKNOWN;
}
}
} }
d.wasDeniedConnection = pcs.wasDeniedConnection; d.wasDeniedConnection = pcs.wasDeniedConnection;
@ -457,13 +518,13 @@ bool p3Peers::getPeerDetails(const RsPeerId& id, RsPeerDetails &d)
return true; return true;
} }
bool p3Peers::isProxyAddress(const sockaddr_storage& addr) bool p3Peers::isProxyAddress(const uint32_t type, const sockaddr_storage& addr)
{ {
uint16_t port ; uint16_t port ;
std::string string_addr; std::string string_addr;
uint32_t status ; uint32_t status ;
if(!getProxyServer(string_addr, port, status)) if(!getProxyServer(type, string_addr, port, status))
return false ; return false ;
return sockaddr_storage_iptostring(addr)==string_addr && sockaddr_storage_port(addr)==port ; return sockaddr_storage_iptostring(addr)==string_addr && sockaddr_storage_port(addr)==port ;
@ -923,21 +984,21 @@ bool p3Peers::setVisState(const RsPeerId &id, uint16_t vs_disc, uint16_t vs_dht)
return mPeerMgr->setVisState(id, vs_disc, vs_dht); return mPeerMgr->setVisState(id, vs_disc, vs_dht);
} }
bool p3Peers::getProxyServer(std::string &addr, uint16_t &port, uint32_t &status) bool p3Peers::getProxyServer(const uint32_t type, std::string &addr, uint16_t &port, uint32_t &status)
{ {
#ifdef P3PEERS_DEBUG #ifdef P3PEERS_DEBUG
std::cerr << "p3Peers::getProxyServer()" << std::endl; std::cerr << "p3Peers::getProxyServer()" << std::endl;
#endif #endif
struct sockaddr_storage proxy_addr; struct sockaddr_storage proxy_addr;
mPeerMgr->getProxyServerAddress(proxy_addr); mPeerMgr->getProxyServerAddress(type, proxy_addr);
addr = sockaddr_storage_iptostring(proxy_addr); addr = sockaddr_storage_iptostring(proxy_addr);
port = sockaddr_storage_port(proxy_addr); port = sockaddr_storage_port(proxy_addr);
mPeerMgr->getProxyServerStatus(status); mPeerMgr->getProxyServerStatus(type, status);
return true; return true;
} }
bool p3Peers::setProxyServer(const std::string &addr_str, const uint16_t port) bool p3Peers::setProxyServer(const uint32_t type, const std::string &addr_str, const uint16_t port)
{ {
#ifdef P3PEERS_DEBUG #ifdef P3PEERS_DEBUG
std::cerr << "p3Peers::setProxyServer() " << std::endl; std::cerr << "p3Peers::setProxyServer() " << std::endl;
@ -958,7 +1019,7 @@ bool p3Peers::setProxyServer(const std::string &addr_str, const uint16_t port)
#endif #endif
/********************************** WINDOWS/UNIX SPECIFIC PART *******************/ /********************************** WINDOWS/UNIX SPECIFIC PART *******************/
{ {
return mPeerMgr->setProxyServerAddress(addr); return mPeerMgr->setProxyServerAddress(type, addr);
} }
else else
{ {
@ -1017,7 +1078,7 @@ bool p3Peers::GetPGPBase64StringAndCheckSum( const RsPgpId& gpg_id,
uint32_t crc = PGPKeyManagement::compute24bitsCRC((unsigned char *)mem_block,mem_block_size) ; uint32_t crc = PGPKeyManagement::compute24bitsCRC((unsigned char *)mem_block,mem_block_size) ;
unsigned char tmp[3] = { (crc >> 16) & 0xff, (crc >> 8) & 0xff, crc & 0xff } ; unsigned char tmp[3] = { uint8_t((crc >> 16) & 0xff), uint8_t((crc >> 8) & 0xff), uint8_t(crc & 0xff) } ;
Radix64::encode((const char *)tmp,3,gpg_base64_checksum) ; Radix64::encode((const char *)tmp,3,gpg_base64_checksum) ;
delete[] mem_block ; delete[] mem_block ;
@ -1107,6 +1168,7 @@ bool p3Peers::loadDetailsFromStringCert(const std::string &certstr, RsPeerDetai
{ {
pd.hiddenNodeAddress = domain; pd.hiddenNodeAddress = domain;
pd.hiddenNodePort = port; pd.hiddenNodePort = port;
pd.hiddenType = mPeerMgr->hiddenDomainToHiddenType(domain);
} }
} }
else else
@ -1311,7 +1373,7 @@ RsPeerDetails::RsPeerDetails()
hasSignedMe(false),accept_connection(false), hasSignedMe(false),accept_connection(false),
state(0),localAddr(""),localPort(0),extAddr(""),extPort(0),netMode(0),vs_disc(0), vs_dht(0), state(0),localAddr(""),localPort(0),extAddr(""),extPort(0),netMode(0),vs_disc(0), vs_dht(0),
lastConnect(0),connectState(0),connectStateString(""),connectPeriod(0),foundDHT(false), lastConnect(0),connectState(0),connectStateString(""),connectPeriod(0),foundDHT(false),
wasDeniedConnection(false), deniedTS(0) wasDeniedConnection(false), deniedTS(0), hiddenType(RS_HIDDEN_TYPE_NONE)
{ {
} }

6
libretroshare/src/rsserver/p3peers.h
View File

@ -94,9 +94,9 @@ virtual bool setDynDNS(const RsPeerId &id, const std::string &dyndns);
virtual bool setNetworkMode(const RsPeerId &id, uint32_t netMode); virtual bool setNetworkMode(const RsPeerId &id, uint32_t netMode);
virtual bool setVisState(const RsPeerId &id, uint16_t vs_disc, uint16_t vs_dht); virtual bool setVisState(const RsPeerId &id, uint16_t vs_disc, uint16_t vs_dht);
virtual bool getProxyServer(std::string &addr, uint16_t &port,uint32_t& status); virtual bool getProxyServer(const uint32_t type, std::string &addr, uint16_t &port,uint32_t& status);
virtual bool setProxyServer(const std::string &addr, const uint16_t port); virtual bool setProxyServer(const uint32_t type,const std::string &addr, const uint16_t port);
virtual bool isProxyAddress(const sockaddr_storage&); virtual bool isProxyAddress(const uint32_t type,const sockaddr_storage&);
virtual void getIPServersList(std::list<std::string>& ip_servers) ; virtual void getIPServersList(std::list<std::string>& ip_servers) ;
virtual void allowServerIPDetermination(bool) ; virtual void allowServerIPDetermination(bool) ;

2
libretroshare/src/rsserver/rsaccounts.cc
View File

@ -994,7 +994,7 @@ bool RsAccountsDetail::GenerateSSLCertificate(const RsPgpId& pgp_id, const s
return false; return false;
} }
int nbits = 2048; int nbits = 4096;
std::string pgp_name = AuthGPG::getAuthGPG()->getGPGName(pgp_id); std::string pgp_name = AuthGPG::getAuthGPG()->getGPGName(pgp_id);

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

@ -819,6 +819,7 @@ bool RsInit::SetHiddenLocation(const std::string& hiddenaddress, uint16_t port)
RsFiles *rsFiles = NULL; RsFiles *rsFiles = NULL;
RsTurtle *rsTurtle = NULL ; RsTurtle *rsTurtle = NULL ;
RsReputations *rsReputations = NULL ;
#ifdef ENABLE_GROUTER #ifdef ENABLE_GROUTER
RsGRouter *rsGRouter = NULL ; RsGRouter *rsGRouter = NULL ;
#endif #endif
@ -847,6 +848,7 @@ RsGRouter *rsGRouter = NULL ;
#endif #endif
#endif #endif
#include "services/p3gxsreputation.h"
#include "services/p3serviceinfo.h" #include "services/p3serviceinfo.h"
#include "services/p3heartbeat.h" #include "services/p3heartbeat.h"
#include "services/p3discovery2.h" #include "services/p3discovery2.h"
@ -1251,7 +1253,7 @@ int RsServer::StartupRetroShare()
std::vector<std::string> plugins_directories ; std::vector<std::string> plugins_directories ;
#ifndef WINDOWS_SYS #ifndef WINDOWS_SYS
plugins_directories.push_back(std::string(LIB_DIR) + "/retroshare/extensions6/") ; plugins_directories.push_back(std::string(PLUGIN_DIR)) ;
#endif #endif
std::string extensions_dir = rsAccounts->PathBaseDirectory() + "/extensions6/" ; std::string extensions_dir = rsAccounts->PathBaseDirectory() + "/extensions6/" ;
plugins_directories.push_back(extensions_dir) ; plugins_directories.push_back(extensions_dir) ;
@ -1357,6 +1359,11 @@ int RsServer::StartupRetroShare()
mPosted->setNetworkExchangeService(posted_ns) ; mPosted->setNetworkExchangeService(posted_ns) ;
/**** Reputation system ****/
p3GxsReputation *mReputations = new p3GxsReputation(mLinkMgr) ;
rsReputations = mReputations ;
/**** Wiki GXS service ****/ /**** Wiki GXS service ****/
@ -1364,9 +1371,9 @@ int RsServer::StartupRetroShare()
RS_SERVICE_GXS_TYPE_WIKI, RS_SERVICE_GXS_TYPE_WIKI,
NULL, rsInitConfig->gxs_passwd); NULL, rsInitConfig->gxs_passwd);
#ifdef RS_USE_WIKI
p3Wiki *mWiki = new p3Wiki(wiki_ds, NULL, mGxsIdService); p3Wiki *mWiki = new p3Wiki(wiki_ds, NULL, mGxsIdService);
// create GXS wiki service
// create GXS photo service
RsGxsNetService* wiki_ns = new RsGxsNetService( RsGxsNetService* wiki_ns = new RsGxsNetService(
RS_SERVICE_GXS_TYPE_WIKI, wiki_ds, nxsMgr, RS_SERVICE_GXS_TYPE_WIKI, wiki_ds, nxsMgr,
mWiki, mWiki->getServiceInfo(), mWiki, mWiki->getServiceInfo(),
@ -1374,6 +1381,7 @@ int RsServer::StartupRetroShare()
pgpAuxUtils); pgpAuxUtils);
mWiki->setNetworkExchangeService(wiki_ns) ; mWiki->setNetworkExchangeService(wiki_ns) ;
#endif
/**** Forum GXS service ****/ /**** Forum GXS service ****/
@ -1443,7 +1451,9 @@ int RsServer::StartupRetroShare()
pqih->addService(gxsid_ns, true); pqih->addService(gxsid_ns, true);
pqih->addService(gxscircles_ns, true); pqih->addService(gxscircles_ns, true);
pqih->addService(posted_ns, true); pqih->addService(posted_ns, true);
#ifdef RS_USE_WIKI
pqih->addService(wiki_ns, true); pqih->addService(wiki_ns, true);
#endif
pqih->addService(gxsforums_ns, true); pqih->addService(gxsforums_ns, true);
pqih->addService(gxschannels_ns, true); pqih->addService(gxschannels_ns, true);
//pqih->addService(photo_ns, true); //pqih->addService(photo_ns, true);
@ -1489,8 +1499,8 @@ int RsServer::StartupRetroShare()
pqih -> addService(mDisc,true); pqih -> addService(mDisc,true);
pqih -> addService(msgSrv,true); pqih -> addService(msgSrv,true);
pqih -> addService(chatSrv,true); pqih -> addService(chatSrv,true);
pqih -> addService(mStatusSrv,true); pqih -> addService(mStatusSrv,true);
pqih -> addService(mReputations,true);
// set interfaces for plugins // set interfaces for plugins
// //
@ -1511,6 +1521,8 @@ int RsServer::StartupRetroShare()
interfaces.mPgpAuxUtils = pgpAuxUtils; interfaces.mPgpAuxUtils = pgpAuxUtils;
interfaces.mGxsForums = mGxsForums; interfaces.mGxsForums = mGxsForums;
interfaces.mGxsChannels = mGxsChannels; interfaces.mGxsChannels = mGxsChannels;
interfaces.mReputations = mReputations;
mPluginsManager->setInterfaces(interfaces); mPluginsManager->setInterfaces(interfaces);
// now add plugin objects inside the loop: // now add plugin objects inside the loop:
@ -1598,12 +1610,13 @@ int RsServer::StartupRetroShare()
mConfigMgr->addConfiguration("peers.cfg", mPeerMgr); mConfigMgr->addConfiguration("peers.cfg", mPeerMgr);
mConfigMgr->addConfiguration("general.cfg", mGeneralConfig); mConfigMgr->addConfiguration("general.cfg", mGeneralConfig);
mConfigMgr->addConfiguration("msgs.cfg", msgSrv); mConfigMgr->addConfiguration("msgs.cfg", msgSrv);
mConfigMgr->addConfiguration("chat.cfg", chatSrv); mConfigMgr->addConfiguration("chat.cfg", chatSrv);
mConfigMgr->addConfiguration("p3History.cfg", mHistoryMgr); mConfigMgr->addConfiguration("p3History.cfg", mHistoryMgr);
mConfigMgr->addConfiguration("p3Status.cfg", mStatusSrv); mConfigMgr->addConfiguration("p3Status.cfg", mStatusSrv);
mConfigMgr->addConfiguration("turtle.cfg", tr); mConfigMgr->addConfiguration("turtle.cfg", tr);
mConfigMgr->addConfiguration("banlist.cfg", mBanList); mConfigMgr->addConfiguration("banlist.cfg", mBanList);
mConfigMgr->addConfiguration("servicecontrol.cfg", serviceCtrl); mConfigMgr->addConfiguration("servicecontrol.cfg", serviceCtrl);
mConfigMgr->addConfiguration("reputations.cfg", mReputations);
#ifdef ENABLE_GROUTER #ifdef ENABLE_GROUTER
mConfigMgr->addConfiguration("grouter.cfg", gr); mConfigMgr->addConfiguration("grouter.cfg", gr);
#endif #endif
@ -1619,7 +1632,9 @@ int RsServer::StartupRetroShare()
mConfigMgr->addConfiguration("gxschannels.cfg", gxschannels_ns); mConfigMgr->addConfiguration("gxschannels.cfg", gxschannels_ns);
mConfigMgr->addConfiguration("gxscircles.cfg", gxscircles_ns); mConfigMgr->addConfiguration("gxscircles.cfg", gxscircles_ns);
mConfigMgr->addConfiguration("posted.cfg", posted_ns); mConfigMgr->addConfiguration("posted.cfg", posted_ns);
#ifdef RS_USE_WIKI
mConfigMgr->addConfiguration("wiki.cfg", wiki_ns); mConfigMgr->addConfiguration("wiki.cfg", wiki_ns);
#endif
//mConfigMgr->addConfiguration("photo.cfg", photo_ns); //mConfigMgr->addConfiguration("photo.cfg", photo_ns);
//mConfigMgr->addConfiguration("wire.cfg", wire_ns); //mConfigMgr->addConfiguration("wire.cfg", wire_ns);
#endif #endif
@ -1728,7 +1743,9 @@ int RsServer::StartupRetroShare()
// Must Set the GXS pointers before starting threads. // Must Set the GXS pointers before starting threads.
rsIdentity = mGxsIdService; rsIdentity = mGxsIdService;
rsGxsCircles = mGxsCircles; rsGxsCircles = mGxsCircles;
#if RS_USE_WIKI
rsWiki = mWiki; rsWiki = mWiki;
#endif
rsPosted = mPosted; rsPosted = mPosted;
rsGxsForums = mGxsForums; rsGxsForums = mGxsForums;
rsGxsChannels = mGxsChannels; rsGxsChannels = mGxsChannels;
@ -1739,7 +1756,9 @@ int RsServer::StartupRetroShare()
startServiceThread(mGxsIdService); startServiceThread(mGxsIdService);
startServiceThread(mGxsCircles); startServiceThread(mGxsCircles);
startServiceThread(mPosted); startServiceThread(mPosted);
#if RS_USE_WIKI
startServiceThread(mWiki); startServiceThread(mWiki);
#endif
startServiceThread(mGxsForums); startServiceThread(mGxsForums);
startServiceThread(mGxsChannels); startServiceThread(mGxsChannels);
@ -1750,7 +1769,9 @@ int RsServer::StartupRetroShare()
startServiceThread(gxsid_ns); startServiceThread(gxsid_ns);
startServiceThread(gxscircles_ns); startServiceThread(gxscircles_ns);
startServiceThread(posted_ns); startServiceThread(posted_ns);
#if RS_USE_WIKI
startServiceThread(wiki_ns); startServiceThread(wiki_ns);
#endif
startServiceThread(gxsforums_ns); startServiceThread(gxsforums_ns);
startServiceThread(gxschannels_ns); startServiceThread(gxschannels_ns);

20
libretroshare/src/rsserver/rsloginhandler.cc
View File

@ -4,7 +4,6 @@
#include "rsloginhandler.h" #include "rsloginhandler.h"
#include "util/rsdir.h" #include "util/rsdir.h"
#include "rsaccounts.h" #include "rsaccounts.h"
#if defined(UBUNTU) || defined(__FreeBSD__) || defined(__OpenBSD__) #if defined(UBUNTU) || defined(__FreeBSD__) || defined(__OpenBSD__)
#include <gnome-keyring-1/gnome-keyring.h> #include <gnome-keyring-1/gnome-keyring.h>
@ -118,6 +117,7 @@ bool RsLoginHandler::tryAutoLogin(const RsPeerId& ssl_id,std::string& ssl_passwd
std::cerr << "RsTryAutoLogin()" << std::endl; std::cerr << "RsTryAutoLogin()" << std::endl;
/******************************** WINDOWS/UNIX SPECIFIC PART ******************/ /******************************** WINDOWS/UNIX SPECIFIC PART ******************/
#ifndef __HAIKU__
#ifndef WINDOWS_SYS /* UNIX */ #ifndef WINDOWS_SYS /* UNIX */
#if defined(UBUNTU) || defined(__FreeBSD__) || defined(__OpenBSD__) #if defined(UBUNTU) || defined(__FreeBSD__) || defined(__OpenBSD__)
@ -145,8 +145,9 @@ bool RsLoginHandler::tryAutoLogin(const RsPeerId& ssl_id,std::string& ssl_passwd
void *passwordData = NULL; void *passwordData = NULL;
UInt32 passwordLength = 0; UInt32 passwordLength = 0;
const char *userId = ssl_id.c_str(); std::string idtemp = ssl_id.toStdString();
UInt32 uidLength = strlen(ssl_id.c_str()); const char *userId = idtemp.c_str();
UInt32 uidLength = strlen(userId);
SecKeychainItemRef itemRef = NULL; SecKeychainItemRef itemRef = NULL;
OSStatus status = SecKeychainFindGenericPassword ( OSStatus status = SecKeychainFindGenericPassword (
@ -348,6 +349,7 @@ bool RsLoginHandler::tryAutoLogin(const RsPeerId& ssl_id,std::string& ssl_passwd
LocalFree(DataOut.pbData); LocalFree(DataOut.pbData);
return isDecrypt; return isDecrypt;
#endif
#endif #endif
/******************************** WINDOWS/UNIX SPECIFIC PART ******************/ /******************************** WINDOWS/UNIX SPECIFIC PART ******************/
@ -360,6 +362,7 @@ bool RsLoginHandler::enableAutoLogin(const RsPeerId& ssl_id,const std::string& s
std::cerr << "RsStoreAutoLogin()" << std::endl; std::cerr << "RsStoreAutoLogin()" << std::endl;
/******************************** WINDOWS/UNIX SPECIFIC PART ******************/ /******************************** WINDOWS/UNIX SPECIFIC PART ******************/
#ifndef __HAIKU__
#ifndef WINDOWS_SYS /* UNIX */ #ifndef WINDOWS_SYS /* UNIX */
#if defined(UBUNTU) || defined(__FreeBSD__) || defined(__OpenBSD__) #if defined(UBUNTU) || defined(__FreeBSD__) || defined(__OpenBSD__)
if(GNOME_KEYRING_RESULT_OK == gnome_keyring_store_password_sync(&my_schema, NULL, (gchar*)("RetroShare password for SSL Id "+ssl_id.toStdString()).c_str(),(gchar*)ssl_passwd.c_str(),"RetroShare SSL Id",ssl_id.toStdString().c_str(),NULL)) if(GNOME_KEYRING_RESULT_OK == gnome_keyring_store_password_sync(&my_schema, NULL, (gchar*)("RetroShare password for SSL Id "+ssl_id.toStdString()).c_str(),(gchar*)ssl_passwd.c_str(),"RetroShare SSL Id",ssl_id.toStdString().c_str(),NULL))
@ -381,8 +384,9 @@ bool RsLoginHandler::enableAutoLogin(const RsPeerId& ssl_id,const std::string& s
const void *password = ssl_passwd.c_str(); const void *password = ssl_passwd.c_str();
UInt32 passwordLength = strlen(ssl_passwd.c_str()); UInt32 passwordLength = strlen(ssl_passwd.c_str());
const char *userid = ssl_id.c_str(); std::string idtemp = ssl_id.toStdString();
UInt32 uidLength = strlen(ssl_id.c_str()); const char *userid = idtemp.c_str();
UInt32 uidLength = strlen(userid);
OSStatus status = SecKeychainAddGenericPassword ( OSStatus status = SecKeychainAddGenericPassword (
NULL, // default keychain NULL, // default keychain
@ -517,6 +521,7 @@ bool RsLoginHandler::enableAutoLogin(const RsPeerId& ssl_id,const std::string& s
/******************************** WINDOWS/UNIX SPECIFIC PART ******************/ /******************************** WINDOWS/UNIX SPECIFIC PART ******************/
return false; return false;
#endif
} }
bool RsLoginHandler::clearAutoLogin(const RsPeerId& ssl_id) bool RsLoginHandler::clearAutoLogin(const RsPeerId& ssl_id)
@ -540,8 +545,9 @@ bool RsLoginHandler::clearAutoLogin(const RsPeerId& ssl_id)
void *passwordData = NULL; void *passwordData = NULL;
UInt32 passwordLength = 0; UInt32 passwordLength = 0;
const char *userId = ssl_id.c_str(); std::string idtemp = ssl_id.toStdString();
UInt32 uidLength = strlen(ssl_id.c_str()); const char *userId = idtemp.c_str();
UInt32 uidLength = strlen(userId);
SecKeychainItemRef itemRef = NULL; SecKeychainItemRef itemRef = NULL;
OSStatus status = SecKeychainFindGenericPassword ( OSStatus status = SecKeychainFindGenericPassword (

494
libretroshare/src/serialiser/rsgxsreputationitems.cc
View File

@ -23,9 +23,10 @@
* *
*/ */
#include <stdio.h>
#include <time.h>
#include "serialiser/rsbaseserial.h" #include "serialiser/rsbaseserial.h"
#include "serialiser/rsbanlistitems.h" #include "serialiser/rsgxsreputationitems.h"
#include "serialiser/rstlvbanlist.h"
/*** /***
#define RSSERIAL_DEBUG 1 #define RSSERIAL_DEBUG 1
@ -35,170 +36,395 @@
/*************************************************************************/ /*************************************************************************/
#ifdef SUSPENDED bool RsReputationItem::serialise_header(void *data,uint32_t& pktsize,uint32_t& tlvsize, uint32_t& offset) const
RsBanListItem::~RsBanListItem()
{ {
return; tlvsize = serial_size() ;
} offset = 0;
void RsBanListItem::clear() if (pktsize < tlvsize)
{
peerList.TlvClear();
}
std::ostream &RsBanListItem::print(std::ostream &out, uint16_t indent)
{
printRsItemBase(out, "RsBanListItem", indent);
uint16_t int_Indent = indent + 2;
peerList.print(out, int_Indent);
printRsItemEnd(out, "RsBanListItem", indent);
return out;
}
uint32_t RsBanListSerialiser::sizeList(RsBanListItem *item)
{
uint32_t s = 8; /* header */
s += item->peerList.TlvSize();
return s;
}
/* serialise the data to the buffer */
bool RsBanListSerialiser::serialiseList(RsBanListItem *item, void *data, uint32_t *pktsize)
{
uint32_t tlvsize = sizeList(item);
uint32_t offset = 0;
if (*pktsize < tlvsize)
return false; /* not enough space */ return false; /* not enough space */
*pktsize = tlvsize; pktsize = tlvsize;
bool ok = true;
ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize);
if(!setRsItemHeader(data, tlvsize, PacketId(), tlvsize))
{
std::cerr << "RsReputationItem::serialise_header(): ERROR. Not enough size!" << std::endl;
return false ;
}
#ifdef RSSERIAL_DEBUG #ifdef RSSERIAL_DEBUG
std::cerr << "RsDsdvSerialiser::serialiseRoute() Header: " << ok << std::endl; std::cerr << "RsReputationItem::serialise() Header: " << ok << std::endl;
std::cerr << "RsDsdvSerialiser::serialiseRoute() Size: " << tlvsize << std::endl;
#endif #endif
/* skip the header */
offset += 8; offset += 8;
/* add mandatory parts first */ return true ;
ok &= item->peerList.SetTlv(data, tlvsize, &offset);
if (offset != tlvsize)
{
ok = false;
#ifdef RSSERIAL_DEBUG
std::cerr << "RsDsdvSerialiser::serialiseRoute() Size Error! " << std::endl;
#endif
}
return ok;
}
RsBanListItem *RsBanListSerialiser::deserialiseList(void *data, uint32_t *pktsize)
{
/* get the type and size */
uint32_t rstype = getRsItemId(data);
uint32_t tlvsize = getRsItemSize(data);
uint32_t offset = 0;
if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) ||
(RS_SERVICE_TYPE_BANLIST != getRsItemService(rstype)) ||
(RS_PKT_SUBTYPE_BANLIST_ITEM != getRsItemSubType(rstype)))
{
return NULL; /* wrong type */
}
if (*pktsize < tlvsize) /* check size */
return NULL; /* not enough data */
/* set the packet length */
*pktsize = tlvsize;
bool ok = true;
/* ready to load */
RsBanListItem *item = new RsBanListItem();
item->clear();
/* skip the header */
offset += 8;
/* add mandatory parts first */
ok &= item->peerList.GetTlv(data, tlvsize, &offset);
if (offset != tlvsize)
{
/* error */
delete item;
return NULL;
}
if (!ok)
{
delete item;
return NULL;
}
return item;
} }
/*************************************************************************/ /*************************************************************************/
uint32_t RsBanListSerialiser::size(RsItem *i) void RsGxsReputationSetItem::clear()
{ {
RsBanListItem *dri; mOpinions.clear() ;
if (NULL != (dri = dynamic_cast<RsBanListItem *>(i)))
{
return sizeList(dri);
}
return 0;
} }
bool RsBanListSerialiser::serialise(RsItem *i, void *data, uint32_t *pktsize) void RsGxsReputationUpdateItem::clear()
{ {
RsBanListItem *dri; mOpinions.clear() ;
if (NULL != (dri = dynamic_cast<RsBanListItem *>(i)))
{
return serialiseList(dri, data, pktsize);
}
return false;
} }
RsItem *RsBanListSerialiser::deserialise(void *data, uint32_t *pktsize) /*************************************************************************/
/*************************************************************************/
/*************************************************************************/
std::ostream& RsGxsReputationConfigItem::print(std::ostream &out, uint16_t indent)
{
printRsItemBase(out, "RsReputationConfigItem", indent);
uint16_t int_Indent = indent + 2;
out << "mPeerId: " << mPeerId << std::endl;
out << "last update: " << time(NULL) - mLatestUpdate << " secs ago." << std::endl;
out << "last query : " << time(NULL) - mLastQuery << " secs ago." << std::endl;
printRsItemEnd(out, "RsReputationConfigItem", indent);
return out;
}
std::ostream& RsGxsReputationSetItem::print(std::ostream &out, uint16_t indent)
{
printRsItemBase(out, "RsReputationSetItem", indent);
uint16_t int_Indent = indent + 2;
out << "GxsId: " << mGxsId << std::endl;
out << "mOwnOpinion: " << mOwnOpinion << std::endl;
out << "mOwnOpinionTS : " << time(NULL) - mOwnOpinionTS << " secs ago." << std::endl;
out << "Opinions from neighbors: " << std::endl;
for(std::map<RsPeerId,uint32_t>::const_iterator it(mOpinions.begin());it!=mOpinions.end();++it)
out << " " << it->first << ": " << it->second << std::endl;
printRsItemEnd(out, "RsReputationSetItem", indent);
return out;
}
std::ostream& RsGxsReputationUpdateItem::print(std::ostream &out, uint16_t indent)
{
printRsItemBase(out, "RsReputationUpdateItem", indent);
uint16_t int_Indent = indent + 2;
out << "from: " << PeerId() << std::endl;
out << "last update: " << time(NULL) - mLatestUpdate << " secs ago." << std::endl;
for(std::map<RsGxsId,uint32_t>::const_iterator it(mOpinions.begin());it!=mOpinions.end();++it)
out << " " << it->first << ": " << it->second << std::endl;
printRsItemEnd(out, "RsReputationUpdateItem", indent);
return out;
}
std::ostream& RsGxsReputationRequestItem::print(std::ostream &out, uint16_t indent)
{
printRsItemBase(out, "RsReputationRequestItem", indent);
uint16_t int_Indent = indent + 2;
out << "last update: " << time(NULL) - mLastUpdate << " secs ago." << std::endl;
printRsItemEnd(out, "RsReputationRequestItem", indent);
return out;
}
/*************************************************************************/
uint32_t RsGxsReputationConfigItem::serial_size() const
{
uint32_t s = 8; /* header */
s += mPeerId.serial_size() ; // PeerId
s += 4 ; // mLatestUpdate
s += 4 ; // mLastQuery
return s ;
}
uint32_t RsGxsReputationSetItem::serial_size() const
{
uint32_t s = 8; /* header */
s += mGxsId.serial_size() ;
s += 4 ; // mOwnOpinion
s += 4 ; // mOwnOpinionTS
s += 4 ; // mOpinions.size()
s += (4+RsPeerId::serial_size()) * mOpinions.size() ;
return s ;
}
uint32_t RsGxsReputationUpdateItem::serial_size() const
{
uint32_t s = 8; /* header */
s += 4 ; // mLatestUpdate
s += 4 ; // mOpinions.size();
s += (RsGxsId::serial_size() + 4) * mOpinions.size() ;
return s ;
}
uint32_t RsGxsReputationRequestItem::serial_size() const
{
uint32_t s = 8; /* header */
s += 4 ; // mLastUpdate
return s;
}
/*************************************************************************/
bool RsGxsReputationConfigItem::serialise(void *data, uint32_t& pktsize) const
{
uint32_t tlvsize ;
uint32_t offset=0;
if(!serialise_header(data,pktsize,tlvsize,offset))
return false ;
bool ok = true;
ok &= mPeerId.serialise(data,tlvsize,offset) ;
ok &= setRawUInt32(data, tlvsize, &offset, mLatestUpdate);
ok &= setRawUInt32(data, tlvsize, &offset, mLastQuery);
if (offset != tlvsize)
{
ok = false;
std::cerr << "RsGxsReputationConfigItem::serialisedata() size error! " << std::endl;
}
return ok;
}
bool RsGxsReputationSetItem::serialise(void *data, uint32_t& pktsize) const
{
uint32_t tlvsize ;
uint32_t offset=0;
if(!serialise_header(data,pktsize,tlvsize,offset))
return false ;
bool ok = true;
ok &= mGxsId.serialise(data,tlvsize,offset) ;
ok &= setRawUInt32(data, tlvsize, &offset, mOwnOpinion);
ok &= setRawUInt32(data, tlvsize, &offset, mOwnOpinionTS);
ok &= setRawUInt32(data, tlvsize, &offset, mOpinions.size());
for(std::map<RsPeerId,uint32_t>::const_iterator it(mOpinions.begin());it!=mOpinions.end();++it)
{
ok &= it->first.serialise(data,tlvsize,offset) ;
ok &= setRawUInt32(data, tlvsize, &offset, it->second) ;
}
if (offset != tlvsize)
{
ok = false;
std::cerr << "RsGxsReputationSetItem::serialisedata() size error! " << std::endl;
}
return ok;
}
bool RsGxsReputationUpdateItem::serialise(void *data, uint32_t& pktsize) const
{
uint32_t tlvsize ;
uint32_t offset=0;
if(!serialise_header(data,pktsize,tlvsize,offset))
return false ;
bool ok = true;
ok &= setRawUInt32(data, tlvsize, &offset, mLatestUpdate);
ok &= setRawUInt32(data, tlvsize, &offset, mOpinions.size());
for(std::map<RsGxsId,uint32_t>::const_iterator it(mOpinions.begin());ok && it!=mOpinions.end();++it)
{
ok &= it->first.serialise(data, tlvsize, offset) ;
ok &= setRawUInt32(data, tlvsize, &offset, it->second) ;
}
if (offset != tlvsize)
{
ok = false;
std::cerr << "RsGxsReputationUpdateItem::serialisedata() size error! " << std::endl;
}
return ok;
}
/* serialise the data to the buffer */
bool RsGxsReputationRequestItem::serialise(void *data, uint32_t& pktsize) const
{
uint32_t tlvsize ;
uint32_t offset=0;
if(!serialise_header(data,pktsize,tlvsize,offset))
return false ;
bool ok = true;
ok &= setRawUInt32(data, tlvsize, &offset, mLastUpdate);
if (offset != tlvsize)
{
ok = false;
std::cerr << "RsGxsReputationRequestItem::serialisedata() size error! " << std::endl;
}
return ok;
}
/*************************************************************************/
RsGxsReputationConfigItem *RsGxsReputationSerialiser::deserialiseReputationConfigItem(void *data,uint32_t size)
{
uint32_t offset = 8; // skip the header
uint32_t rssize = getRsItemSize(data);
bool ok = true ;
RsGxsReputationConfigItem *item = new RsGxsReputationConfigItem() ;
/* add mandatory parts first */
ok &= item->mPeerId.deserialise(data, size, offset) ;
ok &= getRawUInt32(data, size, &offset, &item->mLatestUpdate);
ok &= getRawUInt32(data, size, &offset, &item->mLastQuery);
if (offset != rssize || !ok)
{
std::cerr << __PRETTY_FUNCTION__ << ": error while deserialising! Item will be dropped." << std::endl;
delete item;
return NULL ;
}
return item;
}
RsGxsReputationSetItem *RsGxsReputationSerialiser::deserialiseReputationSetItem(void *data,uint32_t tlvsize)
{
uint32_t offset = 8; // skip the header
uint32_t rssize = getRsItemSize(data);
bool ok = true ;
RsGxsReputationSetItem *item = new RsGxsReputationSetItem() ;
/* add mandatory parts first */
ok &= item->mGxsId.deserialise(data, tlvsize, offset) ;
ok &= getRawUInt32(data, tlvsize, &offset, &item->mOwnOpinion);
ok &= getRawUInt32(data, tlvsize, &offset, &item->mOwnOpinionTS);
uint32_t S ;
ok &= getRawUInt32(data, tlvsize, &offset, &S);
for(int i=0;ok && i<S;++i)
{
RsPeerId pid ;
uint32_t op ;
ok &= pid.deserialise(data, tlvsize, offset) ;
ok &= getRawUInt32(data, tlvsize, &offset, &op);
if(ok)
item->mOpinions[pid] = op ;
}
if (offset != rssize || !ok)
{
std::cerr << __PRETTY_FUNCTION__ << ": error while deserialising! Item will be dropped." << std::endl;
delete item;
return NULL ;
}
return item;
}
RsGxsReputationUpdateItem *RsGxsReputationSerialiser::deserialiseReputationUpdateItem(void *data,uint32_t tlvsize)
{
uint32_t offset = 8; // skip the header
uint32_t rssize = getRsItemSize(data);
bool ok = true ;
RsGxsReputationUpdateItem *item = new RsGxsReputationUpdateItem() ;
/* add mandatory parts first */
ok &= getRawUInt32(data, tlvsize, &offset, &item->mLatestUpdate);
uint32_t S ;
ok &= getRawUInt32(data, tlvsize, &offset, &S) ;
for(uint32_t i=0;ok && i<S;++i)
{
RsGxsId gid ;
uint32_t op ;
ok &= gid.deserialise(data, tlvsize, offset) ;
ok &= getRawUInt32(data, tlvsize, &offset, &op);
if(ok)
item->mOpinions[gid] = op ;
}
if (offset != rssize || !ok)
{
std::cerr << __PRETTY_FUNCTION__ << ": error while deserialising! Item will be dropped." << std::endl;
delete item;
return NULL ;
}
return item;
}
RsGxsReputationRequestItem *RsGxsReputationSerialiser::deserialiseReputationRequestItem(void *data,uint32_t tlvsize)
{
uint32_t offset = 8; // skip the header
uint32_t rssize = getRsItemSize(data);
bool ok = true ;
RsGxsReputationRequestItem *item = new RsGxsReputationRequestItem() ;
/* add mandatory parts first */
ok &= getRawUInt32(data, tlvsize, &offset, &item->mLastUpdate);
if (offset != rssize || !ok)
{
std::cerr << __PRETTY_FUNCTION__ << ": error while deserialising! Item will be dropped." << std::endl;
delete item;
return NULL ;
}
return item;
}
/*************************************************************************/
RsItem *RsGxsReputationSerialiser::deserialise(void *data, uint32_t *pktsize)
{ {
/* get the type and size */ /* get the type and size */
uint32_t rstype = getRsItemId(data); uint32_t rstype = getRsItemId(data);
if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || (RS_SERVICE_GXS_TYPE_REPUTATION != getRsItemService(rstype)))
(RS_SERVICE_TYPE_BANLIST != getRsItemService(rstype))) {
{ std::cerr << "RsReputationSerialiser::deserialise(): wrong item type " << std::hex << rstype << std::dec << std::endl;
return NULL; /* wrong type */ return NULL; /* wrong type */
} }
switch(getRsItemSubType(rstype)) switch(getRsItemSubType(rstype))
{ {
case RS_PKT_SUBTYPE_BANLIST_ITEM: case RS_PKT_SUBTYPE_GXS_REPUTATION_SET_ITEM : return deserialiseReputationSetItem (data, *pktsize);
return deserialiseList(data, pktsize); case RS_PKT_SUBTYPE_GXS_REPUTATION_UPDATE_ITEM : return deserialiseReputationUpdateItem (data, *pktsize);
break; case RS_PKT_SUBTYPE_GXS_REPUTATION_REQUEST_ITEM: return deserialiseReputationRequestItem(data, *pktsize);
case RS_PKT_SUBTYPE_GXS_REPUTATION_CONFIG_ITEM : return deserialiseReputationConfigItem (data, *pktsize);
default: default:
std::cerr << "RsGxsReputationSerialiser::deserialise(): unknown item subtype " << std::hex<< rstype << std::dec << std::endl;
return NULL; return NULL;
break; break;
} }
} }
#endif
/*************************************************************************/ /*************************************************************************/

171
libretroshare/src/serialiser/rsgxsreputationitems.h
View File

@ -32,88 +32,94 @@
#include "serialiser/rsserial.h" #include "serialiser/rsserial.h"
#include "retroshare/rsgxsifacetypes.h" #include "retroshare/rsgxsifacetypes.h"
#define RS_PKT_SUBTYPE_GXSREPUTATION_CONFIG_ITEM 0x01 #define RS_PKT_SUBTYPE_GXS_REPUTATION_CONFIG_ITEM 0x01
#define RS_PKT_SUBTYPE_GXSREPUTATION_SET_ITEM 0x02 #define RS_PKT_SUBTYPE_GXS_REPUTATION_SET_ITEM 0x02
#define RS_PKT_SUBTYPE_GXSREPUTATION_UPDATE_ITEM 0x03 #define RS_PKT_SUBTYPE_GXS_REPUTATION_UPDATE_ITEM 0x03
#define RS_PKT_SUBTYPE_GXSREPUTATION_REQUEST_ITEM 0x04 #define RS_PKT_SUBTYPE_GXS_REPUTATION_REQUEST_ITEM 0x04
/**************************************************************************/ /**************************************************************************/
class RsReputationItem: public RsItem
class RsGxsReputationConfigItem: public RsItem
{ {
public: public:
RsGxsReputationConfigItem() RsReputationItem(uint8_t reputation_subtype) : RsItem(RS_PKT_VERSION_SERVICE,RS_SERVICE_GXS_TYPE_REPUTATION,reputation_subtype)
:RsItem(RS_PKT_VERSION_SERVICE, RS_SERVICE_GXS_TYPE_REPUTATION, {
RS_PKT_SUBTYPE_GXSREPUTATION_CONFIG_ITEM) setPriorityLevel(QOS_PRIORITY_RS_GXSREPUTATION_ITEM);
{ }
setPriorityLevel(QOS_PRIORITY_RS_GXSREPUTATION_ITEM);
return;
}
virtual ~RsGxsReputationConfigItem(); virtual ~RsReputationItem() {}
virtual void clear();
std::ostream &print(std::ostream &out, uint16_t indent = 0);
std::string mPeerId; virtual bool serialise(void *data,uint32_t& size) const = 0 ;
virtual uint32_t serial_size() const = 0 ;
virtual void clear() = 0 ;
virtual std::ostream& print(std::ostream &out, uint16_t indent = 0) = 0;
protected:
bool serialise_header(void *data, uint32_t& pktsize, uint32_t& tlvsize, uint32_t& offset) const;
};
class RsGxsReputationConfigItem: public RsReputationItem
{
public:
RsGxsReputationConfigItem() :RsReputationItem(RS_PKT_SUBTYPE_GXS_REPUTATION_CONFIG_ITEM) {}
virtual ~RsGxsReputationConfigItem() {}
virtual void clear() {}
std::ostream &print(std::ostream &out, uint16_t indent = 0);
virtual bool serialise(void *data,uint32_t& size) const ;
virtual uint32_t serial_size() const ;
RsPeerId mPeerId;
uint32_t mLatestUpdate; // timestamp they returned. uint32_t mLatestUpdate; // timestamp they returned.
uint32_t mLastQuery; // when we sent out. uint32_t mLastQuery; // when we sent out.
}; };
class RsGxsReputationSetItem: public RsItem class RsGxsReputationSetItem: public RsReputationItem
{ {
public: public:
RsGxsReputationSetItem() RsGxsReputationSetItem() :RsReputationItem(RS_PKT_SUBTYPE_GXS_REPUTATION_SET_ITEM) {}
:RsItem(RS_PKT_VERSION_SERVICE, RS_SERVICE_GXS_TYPE_REPUTATION,
RS_PKT_SUBTYPE_GXSREPUTATION_SET_ITEM)
{
setPriorityLevel(QOS_PRIORITY_RS_GXSREPUTATION_ITEM);
return;
}
virtual ~RsGxsReputationSetItem(); virtual ~RsGxsReputationSetItem() {}
virtual void clear(); virtual void clear();
std::ostream &print(std::ostream &out, uint16_t indent = 0); std::ostream &print(std::ostream &out, uint16_t indent = 0);
std::string mGxsId; virtual bool serialise(void *data,uint32_t& size) const ;
virtual uint32_t serial_size() const ;
RsGxsId mGxsId;
uint32_t mOwnOpinion; uint32_t mOwnOpinion;
uint32_t mOwnOpinionTs; uint32_t mOwnOpinionTS;
uint32_t mReputation; std::map<RsPeerId, uint32_t> mOpinions; // RsPeerId -> Opinion.
std::map<std::string, uint32_t> mOpinions; // RsPeerId -> Opinion.
}; };
class RsGxsReputationUpdateItem: public RsItem class RsGxsReputationUpdateItem: public RsReputationItem
{ {
public: public:
RsGxsReputationUpdateItem() RsGxsReputationUpdateItem() :RsReputationItem(RS_PKT_SUBTYPE_GXS_REPUTATION_UPDATE_ITEM) {}
:RsItem(RS_PKT_VERSION_SERVICE, RS_SERVICE_GXS_TYPE_REPUTATION,
RS_PKT_SUBTYPE_GXSREPUTATION_UPDATE_ITEM)
{
setPriorityLevel(QOS_PRIORITY_RS_GXSREPUTATION_ITEM);
return;
}
virtual ~RsGxsReputationUpdateItem(); virtual ~RsGxsReputationUpdateItem() {}
virtual void clear(); virtual void clear();
std::ostream &print(std::ostream &out, uint16_t indent = 0); std::ostream &print(std::ostream &out, uint16_t indent = 0);
std::map<RsGxsId, uint32_t> mOpinions; // GxsId -> Opinion. virtual bool serialise(void *data,uint32_t& size) const ;
uint32_t mLatestUpdate; virtual uint32_t serial_size() const ;
uint32_t mLatestUpdate;
std::map<RsGxsId, uint32_t> mOpinions; // GxsId -> Opinion.
}; };
class RsGxsReputationRequestItem: public RsItem class RsGxsReputationRequestItem: public RsReputationItem
{ {
public: public:
RsGxsReputationRequestItem() RsGxsReputationRequestItem() :RsReputationItem(RS_PKT_SUBTYPE_GXS_REPUTATION_REQUEST_ITEM) {}
:RsItem(RS_PKT_VERSION_SERVICE, RS_SERVICE_GXS_TYPE_REPUTATION,
RS_PKT_SUBTYPE_GXSREPUTATION_REQUEST_ITEM)
{
setPriorityLevel(QOS_PRIORITY_RS_GXSREPUTATION_ITEM);
return;
}
virtual ~RsGxsReputationRequestItem(); virtual ~RsGxsReputationRequestItem() {}
virtual void clear(); virtual void clear() {}
std::ostream &print(std::ostream &out, uint16_t indent = 0); std::ostream &print(std::ostream &out, uint16_t indent = 0);
virtual bool serialise(void *data,uint32_t& size) const ;
virtual uint32_t serial_size() const ;
uint32_t mLastUpdate; uint32_t mLastUpdate;
}; };
@ -121,39 +127,26 @@ std::ostream &print(std::ostream &out, uint16_t indent = 0);
class RsGxsReputationSerialiser: public RsSerialType class RsGxsReputationSerialiser: public RsSerialType
{ {
public: public:
RsGxsReputationSerialiser() RsGxsReputationSerialiser() :RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_GXS_TYPE_REPUTATION){}
:RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_GXS_TYPE_REPUTATION)
{ return; }
virtual ~RsGxsReputationSerialiser()
{ return; }
virtual uint32_t size(RsItem *);
virtual bool serialise (RsItem *item, void *data, uint32_t *size);
virtual RsItem * deserialise(void *data, uint32_t *size);
private: virtual ~RsGxsReputationSerialiser(){}
virtual uint32_t sizeConfig(RsGxsReputationConfigItem *);
virtual bool serialiseConfig(RsGxsReputationConfigItem *item, void *data, uint32_t *size);
virtual RsGxsReputationConfigItem *deserialiseConfig(void *data, uint32_t *size);
virtual uint32_t sizeSet(RsGxsReputationSetItem *);
virtual bool serialiseSet(RsGxsReputationSetItem *item, void *data, uint32_t *size);
virtual RsGxsReputationSetItem *deserialiseSet(void *data, uint32_t *size);
virtual uint32_t sizeUpdate(RsGxsReputationUpdateItem *);
virtual bool serialiseUpdate(RsGxsReputationUpdateItem *item, void *data, uint32_t *size);
virtual RsGxsReputationUpdateItem *deserialiseUpdate(void *data, uint32_t *size);
virtual uint32_t sizeRequest(RsGxsReputationRequestItem *);
virtual bool serialiseRequest(RsGxsReputationRequestItem *item, void *data, uint32_t *size);
virtual RsGxsReputationRequestItem *deserialiseRequest(void *data, uint32_t *size);
virtual uint32_t size(RsItem *item)
{
return dynamic_cast<RsReputationItem*>(item)->serial_size() ;
}
virtual bool serialise (RsItem *item, void *data, uint32_t *size)
{
return dynamic_cast<RsReputationItem*>(item)->serialise(data,*size) ;
}
virtual RsItem * deserialise(void *data, uint32_t *size);
private:
static RsGxsReputationConfigItem *deserialiseReputationConfigItem (void *data, uint32_t size);
static RsGxsReputationSetItem *deserialiseReputationSetItem (void *data, uint32_t size);
static RsGxsReputationUpdateItem *deserialiseReputationUpdateItem (void *data, uint32_t size);
static RsGxsReputationRequestItem *deserialiseReputationRequestItem(void *data, uint32_t size);
}; };
/**************************************************************************/ /**************************************************************************/

2
libretroshare/src/serialiser/rsserial.cc
View File

@ -427,7 +427,7 @@ RsItem * RsSerialiser::deserialise(void *data, uint32_t *size)
std::cerr << "RsSerialiser::deserialise() pkt_size: " << pkt_size << " vs *size: " << *size; std::cerr << "RsSerialiser::deserialise() pkt_size: " << pkt_size << " vs *size: " << *size;
std::cerr << std::endl; std::cerr << std::endl;
RsItem *item2 = (it->second)->deserialise(data, &pkt_size); //RsItem *item2 = (it->second)->deserialise(data, &pkt_size);
uint32_t failedtype = getRsItemId(data); uint32_t failedtype = getRsItemId(data);
std::cerr << "RsSerialiser::deserialise() FAILED PACKET Size: "; std::cerr << "RsSerialiser::deserialise() FAILED PACKET Size: ";

4
libretroshare/src/serialiser/rstlvbase.cc
View File

@ -523,9 +523,9 @@ static bool readHex(char s1,char s2,uint8_t& v)
static bool find_decoded_string(const std::string& in,const std::string& suspicious_string) static bool find_decoded_string(const std::string& in,const std::string& suspicious_string)
{ {
int ss_pointer = 0 ; uint32_t ss_pointer = 0 ;
for(int i=0;i<in.length();++i) for(uint32_t i=0;i<in.length();++i)
{ {
uint8_t hexv ; uint8_t hexv ;
char next_char ; char next_char ;

36
libretroshare/src/services/Makefile
View File

@ -1,36 +0,0 @@
RS_TOP_DIR = ..
##### Define any flags that are needed for this section #######
###############################################################
###############################################################
include $(RS_TOP_DIR)/scripts/config.mk
###############################################################
RSOBJ = p3service.o p3chatservice.o p3msgservice.o \
p3gamelauncher.o p3ranking.o p3disc.o \
p3photoservice.o \
p3distrib.o \
p3status.o \
p3Qblog.o \
p3forums.o \
p3channels.o \
p3portservice.o
# dummy forums interface.
# p3forums-dummy.o \
TESTOBJ = forum_test.o
TESTS = forum_test
all: librs tests
forum_test : forum_test.o
$(CC) $(CFLAGS) -o forum_test forum_test.o $(OBJ) $(LIBS)
###############################################################
include $(RS_TOP_DIR)/scripts/rules.mk
###############################################################

8
libretroshare/src/services/p3banlist.cc
View File

@ -439,8 +439,6 @@ void p3BanList::getBannedIps(std::list<BanListPeer> &lst)
lst.clear() ; lst.clear() ;
for(std::map<sockaddr_storage,BanListPeer>::const_iterator it(mBanSet.begin());it!=mBanSet.end();++it) for(std::map<sockaddr_storage,BanListPeer>::const_iterator it(mBanSet.begin());it!=mBanSet.end();++it)
{ {
bool already_banned = false ;
if(!acceptedBanSet_locked(it->second)) if(!acceptedBanSet_locked(it->second))
continue ; continue ;
@ -498,7 +496,7 @@ bool p3BanList::addIpRange(const sockaddr_storage &addr, int masked_bytes,uint32
{ {
RS_STACK_MUTEX(mBanMtx) ; RS_STACK_MUTEX(mBanMtx) ;
if(getBitRange(addr) > masked_bytes) if(getBitRange(addr) > uint32_t(masked_bytes))
{ {
std::cerr << "(EE) Input to p3BanList::addIpRange is inconsistent: ip=" << sockaddr_storage_iptostring(addr) << "/" << 32-8*masked_bytes << std::endl; std::cerr << "(EE) Input to p3BanList::addIpRange is inconsistent: ip=" << sockaddr_storage_iptostring(addr) << "/" << 32-8*masked_bytes << std::endl;
return false ; return false ;
@ -955,7 +953,7 @@ bool p3BanList::addBanEntry(const RsPeerId &peerId, const struct sockaddr_storag
{ {
/* see if it needs an update */ /* see if it needs an update */
if ((mit->second.reason != reason) || if ((mit->second.reason != reason) ||
(mit->second.level != level) || (mit->second.level != uint32_t(level)) ||
(mit->second.mTs < time_stamp)) (mit->second.mTs < time_stamp))
{ {
/* update */ /* update */
@ -1044,7 +1042,7 @@ int p3BanList::condenseBanSources_locked()
continue; continue;
} }
int lvl = lit->second.level; uint32_t lvl = lit->second.level;
if (it->first != ownId) if (it->first != ownId)
{ {
/* as from someone else, increment level */ /* as from someone else, increment level */

1
libretroshare/src/services/p3gxschannels.cc
View File

@ -337,7 +337,6 @@ bool p3GxsChannels::getPostData(const uint32_t &token, std::vector<RsGxsChannelP
for(; mit != msgData.end(); ++mit) for(; mit != msgData.end(); ++mit)
{ {
RsGxsGroupId grpId = mit->first;
std::vector<RsGxsMsgItem*>& msgItems = mit->second; std::vector<RsGxsMsgItem*>& msgItems = mit->second;
std::vector<RsGxsMsgItem*>::iterator vit = msgItems.begin(); std::vector<RsGxsMsgItem*>::iterator vit = msgItems.begin();

4
libretroshare/src/services/p3gxsforums.cc
View File

@ -199,8 +199,7 @@ bool p3GxsForums::getGroupData(const uint32_t &token, std::vector<RsGxsForumGrou
if (item) if (item)
{ {
RsGxsForumGroup grp = item->mGroup; RsGxsForumGroup grp = item->mGroup;
item->mGroup.mMeta = item->meta; grp.mMeta = item->meta;
grp.mMeta = item->mGroup.mMeta;
delete item; delete item;
groups.push_back(grp); groups.push_back(grp);
} }
@ -230,7 +229,6 @@ bool p3GxsForums::getMsgData(const uint32_t &token, std::vector<RsGxsForumMsg> &
for(; mit != msgData.end(); ++mit) for(; mit != msgData.end(); ++mit)
{ {
RsGxsGroupId grpId = mit->first;
std::vector<RsGxsMsgItem*>& msgItems = mit->second; std::vector<RsGxsMsgItem*>& msgItems = mit->second;
std::vector<RsGxsMsgItem*>::iterator vit = msgItems.begin(); std::vector<RsGxsMsgItem*>::iterator vit = msgItems.begin();

561
libretroshare/src/services/p3gxsreputation.cc
View File

@ -38,13 +38,6 @@
* #define DEBUG_REPUTATION 1 * #define DEBUG_REPUTATION 1
****/ ****/
/* DEFINE INTERFACE POINTER! */
//RsGxsReputation *rsGxsReputation = NULL;
const int kMaximumPeerAge = 180; // half a year.
const int kMaximumSetSize = 100;
/************ IMPLEMENTATION NOTES ********************************* /************ IMPLEMENTATION NOTES *********************************
* *
* p3GxsReputation shares opinions / reputations with peers. * p3GxsReputation shares opinions / reputations with peers.
@ -61,8 +54,12 @@ const int kMaximumSetSize = 100;
* last update -----------> * last update ----------->
* <----------- modified opinions. * <----------- modified opinions.
* *
* This service will have to store a huge amount of data. * If not clever enough, this service will have to store a huge amount of data.
* need to workout how to reduce it. * To make things tractable we do this:
* - do not store reputations when no data is present, or when all friends are neutral
* - only send a neutral opinion when they are a true change over someone's opinion
* - only send a neutral opinion when it is a true change over someone's opinion
* - auto-clean reputations for default values
* *
* std::map<RsGxsId, Reputation> mReputations. * std::map<RsGxsId, Reputation> mReputations.
* std::multimap<time_t, RsGxsId> mUpdated. * std::multimap<time_t, RsGxsId> mUpdated.
@ -70,55 +67,72 @@ const int kMaximumSetSize = 100;
* std::map<RsPeerId, ReputationConfig> mConfig; * std::map<RsPeerId, ReputationConfig> mConfig;
* *
* Updates from p3GxsReputation -> p3IdService. * Updates from p3GxsReputation -> p3IdService.
*
*
* Updates from p3IdService -> p3GxsReputation. * Updates from p3IdService -> p3GxsReputation.
* *
* Each peer locally stores reputations for all GXS ids. If not stored, a default value
* is used, corresponding to a neutral opinion. Peers also share their reputation level
* with their neighbor nodes.
*
* The calculation method is the following:
*
* Local values:
* Good: 2
* Neutral: 1
* Bad: 0
* *
* Overall reputation score:
*
* if(own_opinion == 0) // means we dont' care
* r = average_of_friends_opinions
* else
* r = own_opinion
*
* Decisions based on reputation score:
*
* 0 x1 1 x2 2
* | <-----------------------------------------------------------------------> |
* ---------+
* Lobbies | Msgs dropped
* Forums | Msgs dropped
* Messages | Msgs dropped
* ---------+----------------------------------------------------------------------------
*
* We select x1=0.5
*
* => to kill an identity, either you, or at least 50% of your friends need to flag it
* as bad.
* Rules:
* * a single peer cannot drastically change the behavior of a given GXS id
* * it should be easy for many peers to globally kill a GXS id
*
* Typical examples:
*
* Friends | Friend average | Own | alpha | Score
* -----------+---------------------+----------+------------+--------------
* 10 | 0.5 | 1 | 0.25 | 0.375
* 10 | 1.0 | 1 | 0.25 | 1.0
* 10 | 1.0 | 0 | 0.25 | 1.0
*
* To check:
* [ ] Opinions are saved/loaded accross restart
* [ ] Opinions are transmitted to friends
* [ ] Opinions are transmitted to friends when updated
*
* To do:
* [ ] Add debug info
* [ ] Test the whole thing
* [X] Implement a system to allow not storing info when we don't have it
*/ */
const int32_t REPUTATION_OFFSET = 100000; static const uint32_t LOWER_LIMIT = 0; // used to filter valid Opinion values from serialized data
const int32_t LOWER_LIMIT = -100; static const uint32_t UPPER_LIMIT = 2; // used to filter valid Opinion values from serialized data
const int32_t UPPER_LIMIT = 100; static const float REPUTATION_ASSESSMENT_THRESHOLD_X1 = 0.5f ; // reputation under which the peer gets killed
static const int kMaximumPeerAge = 180; // half a year.
int32_t ConvertFromSerialised(uint32_t value, bool limit) static const int kMaximumSetSize = 100; // max set of updates to send at once.
{ static const int ACTIVE_FRIENDS_UPDATE_PERIOD = 600 ; // 10 minutes
int32_t converted = ((int32_t) value) - REPUTATION_OFFSET ; static const int ACTIVE_FRIENDS_ONLINE_DELAY = 86400*7 ; // 1 week.
if (limit) static const int kReputationRequestPeriod = 600; // 10 mins
{ static const int kReputationStoreWait = 180; // 3 minutes.
if (converted < LOWER_LIMIT)
{
converted = LOWER_LIMIT;
}
if (converted > UPPER_LIMIT)
{
converted = UPPER_LIMIT;
}
}
return converted;
}
uint32_t ConvertToSerialised(int32_t value, bool limit)
{
if (limit)
{
if (value < LOWER_LIMIT)
{
value = LOWER_LIMIT;
}
if (value > UPPER_LIMIT)
{
value = UPPER_LIMIT;
}
}
value += REPUTATION_OFFSET;
if (value < 0)
{
value = 0;
}
return (uint32_t) value;
}
@ -126,14 +140,15 @@ p3GxsReputation::p3GxsReputation(p3LinkMgr *lm)
:p3Service(), p3Config(), :p3Service(), p3Config(),
mReputationMtx("p3GxsReputation"), mLinkMgr(lm) mReputationMtx("p3GxsReputation"), mLinkMgr(lm)
{ {
addSerialType(new RsGxsReputationSerialiser()); addSerialType(new RsGxsReputationSerialiser());
mRequestTime = 0; mRequestTime = 0;
mStoreTime = 0; mStoreTime = 0;
mReputationsUpdated = false; mReputationsUpdated = false;
mLastActiveFriendsUpdate = 0 ;
mAverageActiveFriends = 0 ;
} }
const std::string GXS_REPUTATION_APP_NAME = "gxsreputation"; const std::string GXS_REPUTATION_APP_NAME = "gxsreputation";
const uint16_t GXS_REPUTATION_APP_MAJOR_VERSION = 1; const uint16_t GXS_REPUTATION_APP_MAJOR_VERSION = 1;
const uint16_t GXS_REPUTATION_APP_MINOR_VERSION = 0; const uint16_t GXS_REPUTATION_APP_MINOR_VERSION = 0;
@ -150,13 +165,30 @@ RsServiceInfo p3GxsReputation::getServiceInfo()
GXS_REPUTATION_MIN_MINOR_VERSION); GXS_REPUTATION_MIN_MINOR_VERSION);
} }
int p3GxsReputation::tick() int p3GxsReputation::tick()
{ {
processIncoming(); processIncoming();
sendPackets(); sendPackets();
time_t now = time(NULL);
if(mLastActiveFriendsUpdate + ACTIVE_FRIENDS_UPDATE_PERIOD < now)
{
updateActiveFriends() ;
cleanup() ;
mLastActiveFriendsUpdate = now ;
}
#ifdef DEBUG_REPUTATION
static time_t last_debug_print = time(NULL) ;
if(now > 10+last_debug_print)
{
last_debug_print = now ;
debug_print() ;
}
#endif
return 0; return 0;
} }
@ -165,7 +197,53 @@ int p3GxsReputation::status()
return 1; return 1;
} }
void p3GxsReputation::cleanup()
{
// remove opinions from friends that havn't been seen online for more than the specified delay
#ifdef DEBUG_REPUTATION
std::cerr << "p3GxsReputation::cleanup() " << std::endl;
#endif
std::cerr << __PRETTY_FUNCTION__ << ": not implemented. TODO!" << std::endl;
}
void p3GxsReputation::updateActiveFriends()
{
RsStackMutex stack(mReputationMtx); /****** LOCKED MUTEX *******/
// keep track of who is recently connected. That will give a value to average friend
// for this, we count all friends that have been online in the last week.
time_t now = time(NULL) ;
std::list<RsPeerId> idList ;
mLinkMgr->getFriendList(idList) ;
mAverageActiveFriends = 0 ;
#ifdef DEBUG_REPUTATION
std::cerr << " counting recently online peers." << std::endl;
#endif
for(std::list<RsPeerId>::const_iterator it(idList.begin());it!=idList.end();++it)
{
RsPeerDetails details ;
#ifdef DEBUG_REPUTATION
std::cerr << " " << *it << ": last seen " << now - details.lastConnect << " secs ago" << std::endl;
#endif
if(rsPeers->getPeerDetails(*it, details) && now < details.lastConnect + ACTIVE_FRIENDS_ONLINE_DELAY)
++mAverageActiveFriends ;
}
#ifdef DEBUG_REPUTATION
std::cerr << " new count: " << mAverageActiveFriends << std::endl;
#endif
}
static RsReputations::Opinion safe_convert_uint32t_to_opinion(uint32_t op)
{
return RsReputations::Opinion(std::min((uint32_t)op,UPPER_LIMIT)) ;
}
/***** Implementation ******/ /***** Implementation ******/
bool p3GxsReputation::processIncoming() bool p3GxsReputation::processIncoming()
@ -184,40 +262,31 @@ bool p3GxsReputation::processIncoming()
switch(item->PacketSubType()) switch(item->PacketSubType())
{ {
default: default:
case RS_PKT_SUBTYPE_GXSREPUTATION_CONFIG_ITEM: case RS_PKT_SUBTYPE_GXS_REPUTATION_CONFIG_ITEM:
case RS_PKT_SUBTYPE_GXSREPUTATION_SET_ITEM: case RS_PKT_SUBTYPE_GXS_REPUTATION_SET_ITEM:
std::cerr << "p3GxsReputation::processingIncoming() Unknown Item"; std::cerr << "p3GxsReputation::processingIncoming() Unknown Item";
std::cerr << std::endl; std::cerr << std::endl;
itemOk = false; itemOk = false;
break; break;
case RS_PKT_SUBTYPE_GXSREPUTATION_REQUEST_ITEM: case RS_PKT_SUBTYPE_GXS_REPUTATION_REQUEST_ITEM:
{ {
RsGxsReputationRequestItem *requestItem = RsGxsReputationRequestItem *requestItem = dynamic_cast<RsGxsReputationRequestItem *>(item);
dynamic_cast<RsGxsReputationRequestItem *>(item);
if (requestItem) if (requestItem)
{
SendReputations(requestItem); SendReputations(requestItem);
}
else else
{
itemOk = false; itemOk = false;
}
} }
break; break;
case RS_PKT_SUBTYPE_GXSREPUTATION_UPDATE_ITEM: case RS_PKT_SUBTYPE_GXS_REPUTATION_UPDATE_ITEM:
{ {
RsGxsReputationUpdateItem *updateItem = RsGxsReputationUpdateItem *updateItem = dynamic_cast<RsGxsReputationUpdateItem *>(item);
dynamic_cast<RsGxsReputationUpdateItem *>(item);
if (updateItem) if (updateItem)
{
RecvReputations(updateItem); RecvReputations(updateItem);
}
else else
{
itemOk = false; itemOk = false;
}
} }
break; break;
} }
@ -237,8 +306,9 @@ bool p3GxsReputation::processIncoming()
bool p3GxsReputation::SendReputations(RsGxsReputationRequestItem *request) bool p3GxsReputation::SendReputations(RsGxsReputationRequestItem *request)
{ {
std::cerr << "p3GxsReputation::SendReputations()"; #ifdef DEBUG_REPUTATION
std::cerr << std::endl; std::cerr << "p3GxsReputation::SendReputations()" << std::endl;
#endif
RsPeerId peerId = request->PeerId(); RsPeerId peerId = request->PeerId();
time_t last_update = request->mLastUpdate; time_t last_update = request->mLastUpdate;
@ -252,12 +322,13 @@ bool p3GxsReputation::SendReputations(RsGxsReputationRequestItem *request)
int count = 0; int count = 0;
int totalcount = 0; int totalcount = 0;
RsGxsReputationUpdateItem *pkt = new RsGxsReputationUpdateItem(); RsGxsReputationUpdateItem *pkt = new RsGxsReputationUpdateItem();
pkt->PeerId(peerId); pkt->PeerId(peerId);
for(;tit != mUpdated.end(); ++tit) for(;tit != mUpdated.end(); ++tit)
{ {
/* find */ /* find */
std::map<RsGxsId, Reputation>::iterator rit; std::map<RsGxsId, Reputation>::iterator rit = mReputations.find(tit->second);
rit = mReputations.find(tit->second);
if (rit == mReputations.end()) if (rit == mReputations.end())
{ {
std::cerr << "p3GxsReputation::SendReputations() ERROR Missing Reputation"; std::cerr << "p3GxsReputation::SendReputations() ERROR Missing Reputation";
@ -275,8 +346,9 @@ bool p3GxsReputation::SendReputations(RsGxsReputationRequestItem *request)
} }
RsGxsId gxsId = rit->first; RsGxsId gxsId = rit->first;
pkt->mOpinions[gxsId] = ConvertToSerialised(rit->second.mOwnOpinion, true); pkt->mOpinions[gxsId] = rit->second.mOwnOpinion;
pkt->mLatestUpdate = rit->second.mOwnOpinionTs; pkt->mLatestUpdate = rit->second.mOwnOpinionTs;
if (pkt->mLatestUpdate == (uint32_t) now) if (pkt->mLatestUpdate == (uint32_t) now)
{ {
// if we could possibly get another Update at this point (same second). // if we could possibly get another Update at this point (same second).
@ -289,10 +361,13 @@ bool p3GxsReputation::SendReputations(RsGxsReputationRequestItem *request)
if (count > kMaximumSetSize) if (count > kMaximumSetSize)
{ {
#ifdef DEBUG_REPUTATION
std::cerr << "p3GxsReputation::SendReputations() Sending Full Packet"; std::cerr << "p3GxsReputation::SendReputations() Sending Full Packet";
std::cerr << std::endl; std::cerr << std::endl;
#endif
sendItem(pkt); sendItem(pkt);
pkt = new RsGxsReputationUpdateItem(); pkt = new RsGxsReputationUpdateItem();
pkt->PeerId(peerId); pkt->PeerId(peerId);
count = 0; count = 0;
@ -301,8 +376,10 @@ bool p3GxsReputation::SendReputations(RsGxsReputationRequestItem *request)
if (!pkt->mOpinions.empty()) if (!pkt->mOpinions.empty())
{ {
#ifdef DEBUG_REPUTATION
std::cerr << "p3GxsReputation::SendReputations() Sending Final Packet"; std::cerr << "p3GxsReputation::SendReputations() Sending Final Packet";
std::cerr << std::endl; std::cerr << std::endl;
#endif
sendItem(pkt); sendItem(pkt);
} }
@ -311,52 +388,125 @@ bool p3GxsReputation::SendReputations(RsGxsReputationRequestItem *request)
delete pkt; delete pkt;
} }
#ifdef DEBUG_REPUTATION
std::cerr << "p3GxsReputation::SendReputations() Total Count: " << totalcount; std::cerr << "p3GxsReputation::SendReputations() Total Count: " << totalcount;
std::cerr << std::endl; std::cerr << std::endl;
#endif
return true; return true;
} }
void p3GxsReputation::locked_updateOpinion(const RsPeerId& from,const RsGxsId& about,RsReputations::Opinion op)
{
/* find matching Reputation */
std::map<RsGxsId, Reputation>::iterator rit = mReputations.find(about);
RsReputations::Opinion new_opinion = safe_convert_uint32t_to_opinion(op);
RsReputations::Opinion old_opinion = RsReputations::OPINION_NEUTRAL ; // default if not set
bool updated = false ;
#ifdef DEBUG_REPUTATION
std::cerr << "p3GxsReputation::update opinion of " << about << " from " << from << " to " << op << std::endl;
#endif
// now 4 cases;
// Opinion already stored
// New opinion is same: nothing to do
// New opinion is different: if neutral, remove entry
// Nothing stored
// New opinion is neutral: nothing to do
// New opinion is != 1: create entry and store
if (rit == mReputations.end())
{
#ifdef DEBUG_REPUTATION
std::cerr << " no preview record"<< std::endl;
#endif
if(new_opinion != RsReputations::OPINION_NEUTRAL)
{
mReputations[about] = Reputation(about);
rit = mReputations.find(about);
}
else
{
#ifdef DEBUG_REPUTATION
std::cerr << " no changes!"<< std::endl;
#endif
return ; // nothing to do
}
}
Reputation& reputation = rit->second;
std::map<RsPeerId,RsReputations::Opinion>::iterator it2 = reputation.mOpinions.find(from) ;
if(it2 == reputation.mOpinions.end())
{
if(new_opinion != RsReputations::OPINION_NEUTRAL)
{
reputation.mOpinions[from] = new_opinion; // filters potentially tweaked reputation score sent by friend
updated = true ;
}
}
else
{
old_opinion = it2->second ;
if(new_opinion == RsReputations::OPINION_NEUTRAL)
{
reputation.mOpinions.erase(it2) ; // don't store when the opinion is neutral
updated = true ;
}
else if(new_opinion != old_opinion)
{
it2->second = new_opinion ;
updated = true ;
}
}
if(reputation.mOpinions.empty() && reputation.mOwnOpinion == RsReputations::OPINION_NEUTRAL)
{
mReputations.erase(rit) ;
#ifdef DEBUG_REPUTATION
std::cerr << " own is neutral and no opinions from friends => remove entry" << std::endl;
#endif
updated = true ;
}
else if(updated)
{
#ifdef DEBUG_REPUTATION
std::cerr << " reputation changed. re-calculating." << std::endl;
#endif
reputation.updateReputation(mAverageActiveFriends) ;
}
if(updated)
IndicateConfigChanged() ;
}
bool p3GxsReputation::RecvReputations(RsGxsReputationUpdateItem *item) bool p3GxsReputation::RecvReputations(RsGxsReputationUpdateItem *item)
{ {
std::cerr << "p3GxsReputation::RecvReputations()"; #ifdef DEBUG_REPUTATION
std::cerr << std::endl; std::cerr << "p3GxsReputation::RecvReputations() from " << item->PeerId() << std::endl;
#endif
RsPeerId peerid = item->PeerId(); RsPeerId peerid = item->PeerId();
std::map<RsGxsId, uint32_t>::iterator it; for( std::map<RsGxsId, uint32_t>::iterator it = item->mOpinions.begin(); it != item->mOpinions.end(); ++it)
for(it = item->mOpinions.begin(); it != item->mOpinions.end(); ++it)
{ {
RsStackMutex stack(mReputationMtx); /****** LOCKED MUTEX *******/ RsStackMutex stack(mReputationMtx); /****** LOCKED MUTEX *******/
/* find matching Reputation */ locked_updateOpinion(peerid,it->first,safe_convert_uint32t_to_opinion(it->second));
std::map<RsGxsId, Reputation>::iterator rit;
RsGxsId gxsId(it->first);
rit = mReputations.find(gxsId);
if (rit == mReputations.end())
{
mReputations[gxsId] = Reputation(gxsId);
rit = mReputations.find(gxsId);
}
Reputation &reputation = rit->second;
reputation.mOpinions[peerid] = ConvertFromSerialised(it->second, true);
int previous = reputation.mReputation;
if (previous != reputation.CalculateReputation())
{
// updated from the network.
mUpdatedReputations.insert(gxsId);
}
} }
updateLatestUpdate(peerid, item->mLatestUpdate);
updateLatestUpdate(peerid,item->mLatestUpdate);
return true; return true;
} }
bool p3GxsReputation::updateLatestUpdate(RsPeerId peerid, time_t ts) bool p3GxsReputation::updateLatestUpdate(RsPeerId peerid,time_t latest_update)
{ {
RsStackMutex stack(mReputationMtx); /****** LOCKED MUTEX *******/ RsStackMutex stack(mReputationMtx); /****** LOCKED MUTEX *******/
@ -367,11 +517,12 @@ bool p3GxsReputation::updateLatestUpdate(RsPeerId peerid, time_t ts)
mConfig[peerid] = ReputationConfig(peerid); mConfig[peerid] = ReputationConfig(peerid);
it = mConfig.find(peerid) ; it = mConfig.find(peerid) ;
} }
it->second.mLatestUpdate = ts; it->second.mLatestUpdate = latest_update ;
mReputationsUpdated = true; mReputationsUpdated = true;
// Switched to periodic save due to scale of data. // Switched to periodic save due to scale of data.
//IndicateConfigChanged();
IndicateConfigChanged();
return true; return true;
} }
@ -380,14 +531,75 @@ bool p3GxsReputation::updateLatestUpdate(RsPeerId peerid, time_t ts)
* Opinion * Opinion
****/ ****/
bool p3GxsReputation::updateOpinion(const RsGxsId& gxsid, int opinion) bool p3GxsReputation::getReputationInfo(const RsGxsId& gxsid, RsReputations::ReputationInfo& info)
{ {
RsStackMutex stack(mReputationMtx); /****** LOCKED MUTEX *******/
#ifdef DEBUG_REPUTATION
std::cerr << "getReputationInfo() for " << gxsid << std::endl;
#endif
std::map<RsGxsId,Reputation>::const_iterator it = mReputations.find(gxsid);
if (it == mReputations.end())
{
info.mOwnOpinion = RsReputations::OPINION_NEUTRAL ;
info.mFriendAverage = RsReputations::OPINION_NEUTRAL ;
info.mOverallReputationScore = float(RsReputations::OPINION_NEUTRAL) ;
info.mAssessment = RsReputations::ASSESSMENT_OK ;
#ifdef DEBUG_REPUTATION
std::cerr << " no information present. Returning default. OwnOp = " << info.mOwnOpinion << ", overall score=" << info.mAssessment << std::endl;
#endif
}
else
{
info.mOwnOpinion = RsReputations::Opinion(it->second.mOwnOpinion) ;
info.mOverallReputationScore = it->second.mReputation ;
info.mFriendAverage = it->second.mFriendAverage ;
if(info.mOverallReputationScore > REPUTATION_ASSESSMENT_THRESHOLD_X1)
info.mAssessment = RsReputations::ASSESSMENT_OK ;
else
info.mAssessment = RsReputations::ASSESSMENT_BAD ;
#ifdef DEBUG_REPUTATION
std::cerr << " information present. OwnOp = " << info.mOwnOpinion << ", overall score=" << info.mAssessment << std::endl;
#endif
}
return true ;
}
bool p3GxsReputation::isIdentityBanned(const RsGxsId &id)
{
RsReputations::ReputationInfo info ;
getReputationInfo(id,info) ;
#ifdef DEBUG_REPUTATION
std::cerr << "isIdentityBanned(): returning " << (info.mAssessment == RsReputations::ASSESSMENT_BAD) << " for GXS id " << id << std::endl;
#endif
return info.mAssessment == RsReputations::ASSESSMENT_BAD ;
}
bool p3GxsReputation::setOwnOpinion(const RsGxsId& gxsid, const RsReputations::Opinion& opinion)
{
#ifdef DEBUG_REPUTATION
std::cerr << "setOwnOpinion(): for GXS id " << gxsid << " to " << opinion << std::endl;
#endif
if(gxsid.isNull())
{
std::cerr << " ID " << gxsid << " is rejected. Look for a bug in calling method." << std::endl;
return false ;
}
RsStackMutex stack(mReputationMtx); /****** LOCKED MUTEX *******/ RsStackMutex stack(mReputationMtx); /****** LOCKED MUTEX *******/
std::map<RsGxsId, Reputation>::iterator rit; std::map<RsGxsId, Reputation>::iterator rit;
/* find matching Reputation */ /* find matching Reputation */
rit = mReputations.find(gxsid); rit = mReputations.find(gxsid);
if (rit == mReputations.end()) if (rit == mReputations.end())
{ {
mReputations[gxsid] = Reputation(gxsid); mReputations[gxsid] = Reputation(gxsid);
@ -420,14 +632,15 @@ bool p3GxsReputation::updateOpinion(const RsGxsId& gxsid, int opinion)
time_t now = time(NULL); time_t now = time(NULL);
reputation.mOwnOpinion = opinion; reputation.mOwnOpinion = opinion;
reputation.mOwnOpinionTs = now; reputation.mOwnOpinionTs = now;
reputation.CalculateReputation(); reputation.updateReputation(mAverageActiveFriends);
mUpdated.insert(std::make_pair(now, gxsid)); mUpdated.insert(std::make_pair(now, gxsid));
mUpdatedReputations.insert(gxsid); mUpdatedReputations.insert(gxsid);
mReputationsUpdated = true; mReputationsUpdated = true;
// Switched to periodic save due to scale of data. // Switched to periodic save due to scale of data.
//IndicateConfigChanged(); IndicateConfigChanged();
return true; return true;
} }
@ -448,6 +661,9 @@ bool p3GxsReputation::saveList(bool& cleanup, std::list<RsItem*> &savelist)
cleanup = true; cleanup = true;
RsStackMutex stack(mReputationMtx); /****** LOCKED MUTEX *******/ RsStackMutex stack(mReputationMtx); /****** LOCKED MUTEX *******/
#ifdef DEBUG_REPUTATION
std::cerr << "p3GxsReputation::saveList()" << std::endl;
#endif
/* save */ /* save */
std::map<RsPeerId, ReputationConfig>::iterator it; std::map<RsPeerId, ReputationConfig>::iterator it;
for(it = mConfig.begin(); it != mConfig.end(); ++it) for(it = mConfig.begin(); it != mConfig.end(); ++it)
@ -459,7 +675,7 @@ bool p3GxsReputation::saveList(bool& cleanup, std::list<RsItem*> &savelist)
} }
RsGxsReputationConfigItem *item = new RsGxsReputationConfigItem(); RsGxsReputationConfigItem *item = new RsGxsReputationConfigItem();
item->mPeerId = it->first.toStdString(); item->mPeerId = it->first;
item->mLatestUpdate = it->second.mLatestUpdate; item->mLatestUpdate = it->second.mLatestUpdate;
item->mLastQuery = it->second.mLastQuery; item->mLastQuery = it->second.mLastQuery;
savelist.push_back(item); savelist.push_back(item);
@ -470,16 +686,15 @@ bool p3GxsReputation::saveList(bool& cleanup, std::list<RsItem*> &savelist)
for(rit = mReputations.begin(); rit != mReputations.end(); ++rit, count++) for(rit = mReputations.begin(); rit != mReputations.end(); ++rit, count++)
{ {
RsGxsReputationSetItem *item = new RsGxsReputationSetItem(); RsGxsReputationSetItem *item = new RsGxsReputationSetItem();
item->mGxsId = rit->first.toStdString(); item->mGxsId = rit->first;
item->mOwnOpinion = ConvertToSerialised(rit->second.mOwnOpinion, false); item->mOwnOpinion = rit->second.mOwnOpinion;
item->mOwnOpinionTs = rit->second.mOwnOpinionTs; item->mOwnOpinionTS = rit->second.mOwnOpinionTs;
item->mReputation = ConvertToSerialised(rit->second.mReputation, false);
std::map<RsPeerId, int32_t>::iterator oit; std::map<RsPeerId, RsReputations::Opinion>::iterator oit;
for(oit = rit->second.mOpinions.begin(); oit != rit->second.mOpinions.end(); ++oit) for(oit = rit->second.mOpinions.begin(); oit != rit->second.mOpinions.end(); ++oit)
{ {
// should be already limited. // should be already limited.
item->mOpinions[oit->first.toStdString()] = ConvertToSerialised(oit->second, false); item->mOpinions[oit->first] = (uint32_t)oit->second;
} }
savelist.push_back(item); savelist.push_back(item);
@ -495,6 +710,9 @@ void p3GxsReputation::saveDone()
bool p3GxsReputation::loadList(std::list<RsItem *>& loadList) bool p3GxsReputation::loadList(std::list<RsItem *>& loadList)
{ {
#ifdef DEBUG_REPUTATION
std::cerr << "p3GxsReputation::saveList()" << std::endl;
#endif
std::list<RsItem *>::iterator it; std::list<RsItem *>::iterator it;
std::set<RsPeerId> peerSet; std::set<RsPeerId> peerSet;
@ -515,9 +733,8 @@ bool p3GxsReputation::loadList(std::list<RsItem *>& loadList)
} }
RsGxsReputationSetItem *set = dynamic_cast<RsGxsReputationSetItem *>(*it); RsGxsReputationSetItem *set = dynamic_cast<RsGxsReputationSetItem *>(*it);
if (set) if (set)
{
loadReputationSet(set, peerSet); loadReputationSet(set, peerSet);
}
delete (*it); delete (*it);
} }
@ -530,6 +747,9 @@ bool p3GxsReputation::loadReputationSet(RsGxsReputationSetItem *item, const std:
std::map<RsGxsId, Reputation>::iterator rit; std::map<RsGxsId, Reputation>::iterator rit;
if(item->mGxsId.isNull()) // just a protection against potential errors having put 00000 into ids.
return false ;
/* find matching Reputation */ /* find matching Reputation */
RsGxsId gxsId(item->mGxsId); RsGxsId gxsId(item->mGxsId);
rit = mReputations.find(gxsId); rit = mReputations.find(gxsId);
@ -542,26 +762,24 @@ bool p3GxsReputation::loadReputationSet(RsGxsReputationSetItem *item, const std:
Reputation &reputation = mReputations[gxsId]; Reputation &reputation = mReputations[gxsId];
// install opinions. // install opinions.
std::map<std::string, uint32_t>::const_iterator oit; std::map<RsPeerId, uint32_t>::const_iterator oit;
for(oit = item->mOpinions.begin(); oit != item->mOpinions.end(); ++oit) for(oit = item->mOpinions.begin(); oit != item->mOpinions.end(); ++oit)
{ {
// expensive ... but necessary. // expensive ... but necessary.
RsPeerId peerId(oit->first); RsPeerId peerId(oit->first);
if (peerSet.end() != peerSet.find(peerId)) if (peerSet.end() != peerSet.find(peerId))
{ reputation.mOpinions[peerId] = safe_convert_uint32t_to_opinion(oit->second);
reputation.mOpinions[peerId] = ConvertFromSerialised(oit->second, true);
}
} }
reputation.mOwnOpinion = ConvertFromSerialised(item->mOwnOpinion, false); reputation.mOwnOpinion = item->mOwnOpinion;
reputation.mOwnOpinionTs = item->mOwnOpinionTs; reputation.mOwnOpinionTs = item->mOwnOpinionTS;
// if dropping entries has changed the score -> must update. // if dropping entries has changed the score -> must update.
int previous = ConvertFromSerialised(item->mReputation, false);
if (previous != reputation.CalculateReputation()) //float old_reputation = reputation.mReputation ;
{ //mUpdatedReputations.insert(gxsId) ;
mUpdatedReputations.insert(gxsId);
} reputation.updateReputation(mAverageActiveFriends) ;
mUpdated.insert(std::make_pair(reputation.mOwnOpinionTs, gxsId)); mUpdated.insert(std::make_pair(reputation.mOwnOpinionTs, gxsId));
return true; return true;
@ -572,9 +790,6 @@ bool p3GxsReputation::loadReputationSet(RsGxsReputationSetItem *item, const std:
* Send Requests. * Send Requests.
****/ ****/
const int kReputationRequestPeriod = 3600;
const int kReputationStoreWait = 180; // 3 minutes.
int p3GxsReputation::sendPackets() int p3GxsReputation::sendPackets()
{ {
time_t now = time(NULL); time_t now = time(NULL);
@ -585,7 +800,7 @@ int p3GxsReputation::sendPackets()
storeTime = mStoreTime; storeTime = mStoreTime;
} }
if (now - requestTime > kReputationRequestPeriod) if (now > requestTime + kReputationRequestPeriod)
{ {
sendReputationRequests(); sendReputationRequests();
@ -629,48 +844,41 @@ void p3GxsReputation::sendReputationRequests()
mLinkMgr->getOnlineList(idList); mLinkMgr->getOnlineList(idList);
#ifdef DEBUG_REPUTATION
std::cerr << "p3GxsReputation::sendReputationRequests()";
std::cerr << std::endl;
#endif
/* prepare packets */ /* prepare packets */
std::list<RsPeerId>::iterator it; std::list<RsPeerId>::iterator it;
for(it = idList.begin(); it != idList.end(); ++it) for(it = idList.begin(); it != idList.end(); ++it)
{
#ifdef DEBUG_REPUTATION
std::cerr << "p3GxsReputation::sendReputationRequest() To: " << *it;
std::cerr << std::endl;
#endif
sendReputationRequest(*it); sendReputationRequest(*it);
}
} }
int p3GxsReputation::sendReputationRequest(RsPeerId peerid) int p3GxsReputation::sendReputationRequest(RsPeerId peerid)
{ {
std::cerr << "p3GxsReputation::sendReputationRequest(" << peerid << ")"; #ifdef DEBUG_REPUTATION
std::cerr << std::endl; std::cerr << " p3GxsReputation::sendReputationRequest(" << peerid << ") " ;
#endif
time_t now = time(NULL) ;
/* */ /* */
RsGxsReputationRequestItem *requestItem = RsGxsReputationRequestItem *requestItem = new RsGxsReputationRequestItem();
new RsGxsReputationRequestItem();
requestItem->PeerId(peerid); requestItem->PeerId(peerid);
{ {
RsStackMutex stack(mReputationMtx); /****** LOCKED MUTEX *******/ RsStackMutex stack(mReputationMtx); /****** LOCKED MUTEX *******/
/* find the last timestamp we have */ /* find the last timestamp we have */
std::map<RsPeerId, ReputationConfig>::iterator it; std::map<RsPeerId, ReputationConfig>::iterator it = mConfig.find(peerid);
it = mConfig.find(peerid);
if (it != mConfig.end()) if (it != mConfig.end())
{ {
#ifdef DEBUG_REPUTATION
std::cerr << " lastUpdate = " << now - it->second.mLatestUpdate << " secs ago. Requesting only more recent." << std::endl;
#endif
requestItem->mLastUpdate = it->second.mLatestUpdate; requestItem->mLastUpdate = it->second.mLatestUpdate;
} }
else else
{ {
#ifdef DEBUG_REPUTATION
std::cerr << " lastUpdate = never. Requesting all!" << std::endl;
#endif
// get whole list. // get whole list.
requestItem->mLastUpdate = 0; requestItem->mLastUpdate = 0;
} }
@ -680,4 +888,43 @@ int p3GxsReputation::sendReputationRequest(RsPeerId peerid)
return 1; return 1;
} }
void Reputation::updateReputation(uint32_t average_active_friends)
{
// the calculation of reputation makes the whole thing
int friend_total = 0;
// accounts for all friends. Neutral opinions count for 1-1=0
// because the average is performed over only accessible peers (not the total number) we need to shift to 1
for(std::map<RsPeerId,RsReputations::Opinion>::const_iterator it(mOpinions.begin());it!=mOpinions.end();++it)
friend_total += it->second - 1;
if(mOpinions.empty()) // includes the case of no friends!
mFriendAverage = 1.0f ;
else
mFriendAverage = 1.0+friend_total / float(std::max(average_active_friends,(uint32_t)mOpinions.size()));
if(mOwnOpinion == RsReputations::OPINION_NEUTRAL)
mReputation = mFriendAverage ;
else
mReputation = (float)mOwnOpinion ;
}
void p3GxsReputation::debug_print()
{
std::cerr << "Reputations database: " << std::endl;
std::cerr << " Average number of peers: " << mAverageActiveFriends << std::endl;
time_t now = time(NULL) ;
for(std::map<RsGxsId,Reputation>::const_iterator it(mReputations.begin());it!=mReputations.end();++it)
{
std::cerr << " ID=" << it->first << ", own: " << it->second.mOwnOpinion << ", Friend average: " << it->second.mFriendAverage << ", global_score: " << it->second.mReputation
<< ", last own update: " << now - it->second.mOwnOpinionTs << " secs ago." << std::endl;
for(std::map<RsPeerId,RsReputations::Opinion>::const_iterator it2(it->second.mOpinions.begin());it2!=it->second.mOpinions.end();++it2)
std::cerr << " " << it2->first << ": " << it2->second << std::endl;
}
}

58
libretroshare/src/services/p3gxsreputation.h
View File

@ -35,6 +35,7 @@
#include "serialiser/rsgxsreputationitems.h" #include "serialiser/rsgxsreputationitems.h"
#include "retroshare/rsidentity.h" #include "retroshare/rsidentity.h"
#include "retroshare/rsreputations.h"
#include "services/p3service.h" #include "services/p3service.h"
@ -58,19 +59,19 @@ class Reputation
{ {
public: public:
Reputation() Reputation()
:mOwnOpinion(0), mOwnOpinionTs(0), mReputation(0) { return; } :mOwnOpinion(RsReputations::OPINION_NEUTRAL), mOwnOpinionTs(0), mReputation(RsReputations::OPINION_NEUTRAL) { }
Reputation(const RsGxsId& about) Reputation(const RsGxsId& about)
:mGxsId(about), mOwnOpinion(0), mOwnOpinionTs(0), mReputation(0) { return; } :mOwnOpinion(RsReputations::OPINION_NEUTRAL), mOwnOpinionTs(0), mReputation(RsReputations::OPINION_NEUTRAL) { }
int32_t CalculateReputation(); void updateReputation(uint32_t average_active_friends);
RsGxsId mGxsId; std::map<RsPeerId, RsReputations::Opinion> mOpinions;
std::map<RsPeerId, int32_t> mOpinions;
int32_t mOwnOpinion; int32_t mOwnOpinion;
time_t mOwnOpinionTs; time_t mOwnOpinionTs;
int32_t mReputation; float mFriendAverage ;
float mReputation;
}; };
@ -80,37 +81,25 @@ int32_t CalculateReputation();
* *
*/ */
class p3GxsReputation: public p3Service, public p3Config /* , public pqiMonitor */ class p3GxsReputation: public p3Service, public p3Config, public RsReputations /* , public pqiMonitor */
{ {
public: public:
p3GxsReputation(p3LinkMgr *lm); p3GxsReputation(p3LinkMgr *lm);
virtual RsServiceInfo getServiceInfo(); virtual RsServiceInfo getServiceInfo();
/***** Interface for p3idservice *****/ /***** Interface for RsReputations *****/
virtual bool setOwnOpinion(const RsGxsId& key_id, const Opinion& op) ;
virtual bool updateOpinion(const RsGxsId& gxsid, int opinion); virtual bool getReputationInfo(const RsGxsId& id,ReputationInfo& info) ;
virtual bool isIdentityBanned(const RsGxsId& id) ;
/***** overloaded from p3Service *****/ /***** overloaded from p3Service *****/
/*!
* This retrieves all chat msg items and also (important!)
* processes chat-status items that are in service item queue. chat msg item requests are also processed and not returned
* (important! also) notifications sent to notify base on receipt avatar, immediate status and custom status
* : notifyCustomState, notifyChatStatus, notifyPeerHasNewAvatar
* @see NotifyBase
*/
virtual int tick(); virtual int tick();
virtual int status(); virtual int status();
/*! /*!
* Interface stuff. * Interface stuff.
*/ */
/*************** pqiMonitor callback ***********************/
//virtual void statusChange(const std::list<pqipeer> &plist);
/************* from p3Config *******************/ /************* from p3Config *******************/
virtual RsSerialiser *setupSerialiser() ; virtual RsSerialiser *setupSerialiser() ;
virtual bool saveList(bool& cleanup, std::list<RsItem*>&) ; virtual bool saveList(bool& cleanup, std::list<RsItem*>&) ;
@ -123,22 +112,27 @@ class p3GxsReputation: public p3Service, public p3Config /* , public pqiMonitor
bool SendReputations(RsGxsReputationRequestItem *request); bool SendReputations(RsGxsReputationRequestItem *request);
bool RecvReputations(RsGxsReputationUpdateItem *item); bool RecvReputations(RsGxsReputationUpdateItem *item);
bool updateLatestUpdate(RsPeerId peerid, time_t ts); bool updateLatestUpdate(RsPeerId peerid, time_t latest_update);
void updateActiveFriends() ;
// internal update of data. Takes care of cleaning empty boxes.
void locked_updateOpinion(const RsPeerId &from, const RsGxsId &about, RsReputations::Opinion op);
bool loadReputationSet(RsGxsReputationSetItem *item, const std::set<RsPeerId> &peerSet);
bool loadReputationSet(RsGxsReputationSetItem *item, int sendPackets();
const std::set<RsPeerId> &peerSet); void cleanup();
int sendPackets();
void sendReputationRequests(); void sendReputationRequests();
int sendReputationRequest(RsPeerId peerid); int sendReputationRequest(RsPeerId peerid);
void debug_print() ;
private: private:
RsMutex mReputationMtx; RsMutex mReputationMtx;
time_t mLastActiveFriendsUpdate;
time_t mRequestTime; time_t mRequestTime;
time_t mStoreTime; time_t mStoreTime;
bool mReputationsUpdated; bool mReputationsUpdated;
uint32_t mAverageActiveFriends ;
p3LinkMgr *mLinkMgr; p3LinkMgr *mLinkMgr;
@ -148,7 +142,7 @@ class p3GxsReputation: public p3Service, public p3Config /* , public pqiMonitor
std::multimap<time_t, RsGxsId> mUpdated; std::multimap<time_t, RsGxsId> mUpdated;
// set of Reputations to send to p3IdService. // set of Reputations to send to p3IdService.
std::set<RsGxsId> mUpdatedReputations; std::set<RsGxsId> mUpdatedReputations;
}; };
#endif //SERVICE_RSGXSREPUTATION_HEADER #endif //SERVICE_RSGXSREPUTATION_HEADER

13
libretroshare/src/services/p3idservice.cc
View File

@ -412,6 +412,8 @@ bool p3IdService:: getIdDetails(const RsGxsId &id, RsIdentityDetails &details)
// one utf8 symbol can be at most 4 bytes long - would be better to measure real unicode length !!! // one utf8 symbol can be at most 4 bytes long - would be better to measure real unicode length !!!
if(details.mNickname.length() > RSID_MAXIMUM_NICKNAME_SIZE*4) if(details.mNickname.length() > RSID_MAXIMUM_NICKNAME_SIZE*4)
details.mNickname = "[too long a name]" ; details.mNickname = "[too long a name]" ;
rsReputations->getReputationInfo(id,details.mReputation) ;
return true; return true;
} }
@ -421,6 +423,9 @@ bool p3IdService:: getIdDetails(const RsGxsId &id, RsIdentityDetails &details)
{ {
details = data.details; details = data.details;
details.mLastUsageTS = locked_getLastUsageTS(id) ; details.mLastUsageTS = locked_getLastUsageTS(id) ;
rsReputations->getReputationInfo(id,details.mReputation) ;
return true; return true;
} }
} }
@ -831,7 +836,7 @@ bool p3IdService::getReputation(const RsGxsId &id, GixsReputation &rep)
if (mPublicKeyCache.fetch(id, data)) if (mPublicKeyCache.fetch(id, data))
{ {
rep.id = id; rep.id = id;
rep.score = data.details.mReputation.mOverallScore; rep.score = 0;//data.details.mReputation.mOverallScore;
#ifdef DEBUG_IDS #ifdef DEBUG_IDS
std::cerr << "p3IdService::getReputation() id: "; std::cerr << "p3IdService::getReputation() id: ";
std::cerr << id.toStdString() << " score: " << std::cerr << id.toStdString() << " score: " <<
@ -1669,14 +1674,14 @@ void RsGxsIdCache::updateServiceString(std::string serviceString)
} }
// copy over Reputation scores. // copy over Reputation scores.
details.mReputation = ssdata.score.rep; //details.mReputation = ssdata.score.rep;
} }
else else
{ {
details.mPgpKnown = false; details.mPgpKnown = false;
details.mPgpId.clear(); details.mPgpId.clear();
details.mReputation.updateIdScore(false, false); //details.mReputation.updateIdScore(false, false);
details.mReputation.update(); //details.mReputation.update();
} }
} }

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

@ -187,19 +187,26 @@ void p3MsgService::processMsg(RsMsgItem *mi, bool incoming)
msi->srcId = mi->PeerId(); msi->srcId = mi->PeerId();
mSrcIds.insert(std::pair<uint32_t, RsMsgSrcId*>(msi->msgId, msi)); mSrcIds.insert(std::pair<uint32_t, RsMsgSrcId*>(msi->msgId, msi));
IndicateConfigChanged(); /**** INDICATE MSG CONFIG CHANGED! *****/ IndicateConfigChanged(); /**** INDICATE MSG CONFIG CHANGED! *****/
/**** STACK UNLOCKED ***/
} }
// If the peer is allowed to push files, then auto-download the recommended files.
if(rsPeers->servicePermissionFlags(mi->PeerId()) & RS_NODE_PERM_ALLOW_PUSH)
for(std::list<RsTlvFileItem>::const_iterator it(mi->attachment.items.begin());it!=mi->attachment.items.end();++it)
rsFiles->FileRequest((*it).name,(*it).hash,(*it).filesize,std::string(),RS_FILE_REQ_ANONYMOUS_ROUTING,std::list<RsPeerId>()) ;
if (incoming)
{
// If the peer is allowed to push files, then auto-download the recommended files.
if(rsPeers->servicePermissionFlags(mi->PeerId()) & RS_NODE_PERM_ALLOW_PUSH)
{
std::list<RsPeerId> srcIds;
srcIds.push_back(mi->PeerId());
for(std::list<RsTlvFileItem>::const_iterator it(mi->attachment.items.begin());it!=mi->attachment.items.end();++it)
rsFiles->FileRequest((*it).name,(*it).hash,(*it).filesize,std::string(),RS_FILE_REQ_ANONYMOUS_ROUTING,srcIds) ;
}
}
RsServer::notify()->notifyListChange(NOTIFY_LIST_MESSAGELIST,NOTIFY_TYPE_ADD); RsServer::notify()->notifyListChange(NOTIFY_LIST_MESSAGELIST,NOTIFY_TYPE_ADD);
/**** STACK UNLOCKED ***/
} }
bool p3MsgService::checkAndRebuildPartialMessage(RsMsgItem *ci) bool p3MsgService::checkAndRebuildPartialMessage(RsMsgItem *ci)
{ {
// Check is the item is ending an incomplete item. // Check is the item is ending an incomplete item.

2
libretroshare/src/tcponudp/tou.cc
View File

@ -35,6 +35,7 @@ static const int kInitStreamTable = 5;
#include <time.h> #include <time.h>
#include "udp/udpstack.h" #include "udp/udpstack.h"
#include "pqi/pqinetwork.h"
#include "tcpstream.h" #include "tcpstream.h"
#include <vector> #include <vector>
#include <iostream> #include <iostream>
@ -42,6 +43,7 @@ static const int kInitStreamTable = 5;
#include <errno.h> #include <errno.h>
#define DEBUG_TOU_INTERFACE 1 #define DEBUG_TOU_INTERFACE 1
#define EUSERS 87
struct TcpOnUdp_t struct TcpOnUdp_t
{ {

55
libretroshare/src/tests/dbase/Makefile
View File

@ -1,55 +0,0 @@
RS_TOP_DIR = ../..
DHT_TOP_DIR = ../../../../libbitdht/src
OPS_TOP_DIR = ../../../../openpgpsdk/src
##### Define any flags that are needed for this section #######
###############################################################
###############################################################
include $(RS_TOP_DIR)/tests/scripts/config.mk
###############################################################
TESTOBJ = fitest2.o fisavetest.o searchtest.o #ficachetest.o
#ficachetest.o
TESTS = fitest2 fisavetest searchtest #ficachetest
#ficachetest
ifeq ($(OS),Linux)
TESTOBJ += fimontest.o
TESTS += fimontest
endif
ifeq ($(OS),MacOSX)
TESTOBJ += fimontest.o
TESTS += fimontest
endif
all: tests
fitest2 : fitest2.o $(OBJ)
$(CC) $(CFLAGS) -o fitest2 fitest2.o $(OBJ) $(LIBS)
fisavetest : fisavetest.o $(OBJ)
$(CC) $(CFLAGS) -o fisavetest fisavetest.o $(OBJ) $(LIBS)
fimontest : fimontest.o $(OBJ)
$(CC) $(CFLAGS) -o fimontest fimontest.o $(OBJ) $(LIBS)
ficachetest : ficachetest.o $(OBJ)
$(CC) $(CFLAGS) -o ficachetest ficachetest.o $(OBJ) $(LIBS)
searchtest : searchtest.o $(OBJ)
$(CC) $(CFLAGS) -o searchtest searchtest.o $(OBJ) $(LIBS)
clobber: rmtestfiles
rmtestfiles:
$(RM) test.index
###############################################################
include $(RS_TOP_DIR)/tests/scripts/rules.mk
###############################################################

60
libretroshare/src/tests/ft/Makefile
View File

@ -1,60 +0,0 @@
RS_TOP_DIR = ../..
DHT_TOP_DIR = ../../../../libbitdht/src
OPS_TOP_DIR = ../../../../openpgpsdk/src
##### Define any flags that are needed for this section #######
###############################################################
###############################################################
include $(RS_TOP_DIR)/tests/scripts/config.mk
###############################################################
TESTOBJ = pqitestor.o ftfilemappertest.o ftfileprovidertest.o ftfilecreatortest.o ftextralisttest.o ftdataplextest.o fttransfermoduletest.o ftcrc32test.o ftcrossprovidercreatortest.o ftcontrollertest.o ftserver1test.o ftserver2test.o ftserver3test.o ftdata_dummy.o ftsearch_dummy.o
TESTS = ftfileprovidertest ftfilecreatortest ftextralisttest ftdataplextest fttransfermoduletest ftcrc32test ftcrossprovidercreatortest ftcontrollertest ftserver1test ftserver2test fttransfermoduletest ftserver3test
#ftfilemappertest
all: tests
ftfilemappertest : ftfilemappertest.o
$(CC) $(CFLAGS) -o ftfilemappertest ftfilemappertest.o $(LIBS)
ftcontrollertest : ftcontrollertest.o pqitestor.o
$(CC) $(CFLAGS) -o ftcontrollertest ftcontrollertest.o pqitestor.o $(LIBS)
ftfilecreatortest : ftfilecreatortest.o
$(CC) $(CFLAGS) -o ftfilecreatortest ftfilecreatortest.o $(LIBS)
ftcrossprovidercreatortest : ftcrossprovidercreatortest.o
$(CC) $(CFLAGS) -o ftcrossprovidercreatortest ftcrossprovidercreatortest.o $(LIBS)
ftfileprovidertest : ftfileprovidertest.o
$(CC) $(CFLAGS) -o ftfileprovidertest ftfileprovidertest.o $(LIBS)
fttransfermoduletest : fttransfermoduletest.o
$(CC) $(CFLAGS) -o fttransfermoduletest ftdata_dummy.o ftsearch_dummy.o fttransfermoduletest.o $(LIBS)
ftextralisttest : ftextralisttest.o
$(CC) $(CFLAGS) -o ftextralisttest ftextralisttest.o $(LIBS)
ftdataplextest : ftdataplextest.o ftsearch_dummy.o ftdata_dummy.o
$(CC) $(CFLAGS) -o ftdataplextest ftdata_dummy.o ftdataplextest.o ftsearch_dummy.o $(LIBS)
ftserver1test : ftserver1test.o pqitestor.o
$(CC) $(CFLAGS) -o ftserver1test ftserver1test.o pqitestor.o $(LIBS)
ftserver2test : ftserver2test.o pqitestor.o
$(CC) $(CFLAGS) -o ftserver2test ftserver2test.o pqitestor.o $(LIBS)
ftserver3test : ftserver3test.o pqitestor.o
$(CC) $(CFLAGS) -o ftserver3test ftserver3test.o pqitestor.o $(LIBS)
ftcrc32test : ftcrc32test.o
$(CC) $(CFLAGS) -O0 -g -o ftcrc32test ftcrc32test.o $(LIBS)
###############################################################
include $(RS_TOP_DIR)/tests/scripts/rules.mk
###############################################################

32
libretroshare/src/tests/general/Makefile
View File

@ -1,32 +0,0 @@
RS_TOP_DIR = ../..
DHT_TOP_DIR = ../../../../libbitdht/src
OPS_TOP_DIR = ../../../../openpgpsdk/src
##### Define any flags that are needed for this section #######
###############################################################
###############################################################
include $(RS_TOP_DIR)/tests/scripts/config.mk
###############################################################
TESTOBJ = netsetup_test.o random_test.o memory_management_test.o pgpkey_test.o
TESTS = netsetup_test random_test memory_management_test pgpkey_test
all: tests
pgpkey_test: pgpkey_test.o
$(CC) $(CFLAGS) -o pgpkey_test pgpkey_test.o $(LIBS)
netsetup_test: netsetup_test.o
$(CC) $(CFLAGS) -o netsetup_test netsetup_test.o $(LIBS)
random_test: random_test.o
$(CC) $(CFLAGS) -o random_test random_test.o $(LIBS)
memory_management_test: memory_management_test.o
$(CC) $(CFLAGS) -o memory_management_test memory_management_test.o $(LIBS)
###############################################################
include $(RS_TOP_DIR)/tests/scripts/rules.mk
###############################################################

39
libretroshare/src/tests/pgp/Makefile
View File

@ -1,39 +0,0 @@
RS_TOP_DIR = ../..
DHT_TOP_DIR = ../../../../libbitdht/src
OPS_TOP_DIR = ../../../../openpgpsdk/src
OPENPGP_INCLUDE_DIR = ../../../../openpgpsdk/src
##### Define any flags that are needed for this section #######
###############################################################
###############################################################
include $(RS_TOP_DIR)/tests/scripts/config.mk
###############################################################
TESTOBJ = test_pgp_handler.o test_pgp_signature_parsing.o test_key_parsing.o test_certificate.o test_identity_import.o
TESTS = test_pgp_handler test_pgp_signature_parsing test_key_parsing test_certificate test_identity_import
#rsbaseitem_test
all: tests
test_certificate : test_certificate.o
$(CC) $(CFLAGS) -o test_certificate test_certificate.o $(OBJ) $(LIBS) -L../../../../openpgpsdk/src/lib/ -lops -lbz2
test_identity_import : test_identity_import.o
$(CC) $(CFLAGS) -o test_identity_import test_identity_import.o $(OBJ) $(LIBS) -L../../../../openpgpsdk/src/lib/ -lops -lbz2
test_pgp_handler : test_pgp_handler.o
$(CC) $(CFLAGS) -o test_pgp_handler test_pgp_handler.o $(OBJ) $(LIBS) -L../../../../openpgpsdk/src/lib/ -lops -lbz2
test_pgp_signature_parsing : test_pgp_signature_parsing.o
$(CC) $(CFLAGS) -o test_pgp_signature_parsing test_pgp_signature_parsing.o $(OBJ) $(LIBS) -L../../../../openpgpsdk/src/lib/ -lops -lbz2
test_key_parsing : test_key_parsing.o
$(CC) $(CFLAGS) -o test_key_parsing test_key_parsing.o ../../../../openpgpsdk/src/lib/libops.a -lssl -lcrypto -lbz2
###############################################################
include $(RS_TOP_DIR)/scripts/rules.mk
###############################################################

93
libretroshare/src/tests/pqi/Makefile
View File

@ -1,93 +0,0 @@
RS_TOP_DIR = ../..
DHT_TOP_DIR = ../../../../libbitdht/src/
OPS_TOP_DIR = ../../../../openpgpsdk/src/
##### Define any flags that are needed for this section #######
###############################################################
###############################################################
include $(RS_TOP_DIR)/tests/scripts/config.mk
###############################################################
# Generic Test Harnesses.
TESTOBJ = conn_harness.o ppg_harness.o
TESTOBJ += pqiqos_test.o
TESTOBJ += net_test.o dht_test.o net_test1.o netiface_test.o dht_test.o
TESTOBJ += pkt_test.o pqiarchive_test.o pqiperson_test.o
TESTOBJ += extaddrfinder_test.o dnsresolver_test.o pqiipset_test.o
TESTOBJ += p3connmgr_reset_test.o p3connmgr_connect_test.o
#conn_test.o
TESTS = net_test net_test1 netiface_test pqiarchive_test pqiperson_test dnsresolver_test extaddrfinder_test
TESTS += pqiipset_test
TESTS += pqiqos_test
TESTS += p3connmgr_reset_test p3connmgr_connect_test
#TESTS = p3connmgr_test1
MANUAL_TESTS = dht_test
#conn_test
all: tests $(MANUAL_TESTS)
gpgme_tst: gpgme_tst.o
$(CC) $(CFLAGS) -o gpgme_tst gpgme_tst.o $(LIBS)
xpgp_id: xpgp_id.o
$(CC) $(CFLAGS) -o xpgp_id xpgp_id.o $(LIBS)
dht_test: dht_test.o
$(CC) $(CFLAGS) -o dht_test dht_test.o $(LIBS)
conn_test: conn_test.o
$(CC) $(CFLAGS) -o conn_test conn_test.o $(LIBS)
net_test: net_test.o
$(CC) $(CFLAGS) -o net_test net_test.o $(LIBS)
net_test1: net_test1.o
$(CC) $(CFLAGS) -o net_test1 net_test1.o $(LIBS)
netiface_test: netiface_test.o
$(CC) $(CFLAGS) -o netiface_test netiface_test.o $(LIBS)
pqiarchive_test: pqiarchive_test.o pkt_test.o
$(CC) $(CFLAGS) -o pqiarchive_test pkt_test.o pqiarchive_test.o $(LIBS)
pqiperson_test: pqiperson_test.o testconnect.o
$(CC) $(CFLAGS) -o pqiperson_test pqiperson_test.o testconnect.o $(LIBS) -lstdc++
extaddrfinder_test: extaddrfinder_test.o
$(CC) $(CFLAGS) -DEXTADDRSEARCH_DEBUG=1 -o extaddrfinder_test extaddrfinder_test.o $(LIBS)
pqiqos_test: pqiqos_test.o
$(CC) $(CFLAGS) -o pqiqos_test pqiqos_test.o $(LIBS)
dnsresolver_test: dnsresolver_test.o
$(CC) $(CFLAGS) -o dnsresolver_test dnsresolver_test.o $(LIBS)
pqiipset_test: pqiipset_test.o
$(CC) $(CFLAGS) -o pqiipset_test pqiipset_test.o $(LIBS)
p3connmgr_reset_test: p3connmgr_reset_test.o
$(CC) $(CFLAGS) -o p3connmgr_reset_test p3connmgr_reset_test.o $(LIBS)
p3connmgr_connect_test: p3connmgr_connect_test.o conn_harness.o ppg_harness.o
$(CC) $(CFLAGS) -o p3connmgr_connect_test p3connmgr_connect_test.o conn_harness.o ppg_harness.o $(LIBS)
p3connmgr_test1: p3connmgr_test1.o
$(CC) $(CFLAGS) -o p3connmgr_test1 p3connmgr_test1.o $(LIBS)
clobber: remove_extra_files
remove_extra_files:
-$(RM) $(MANUAL_TESTS)
###############################################################
include $(RS_TOP_DIR)/tests/scripts/rules.mk
###############################################################

2
libretroshare/src/tests/pqi/TestNotes.txt
View File

@ -70,9 +70,7 @@ Description:
(1) isExternalNet() (1) isExternalNet()
(2) isPrivateNet() (2) isPrivateNet()
(3) isLoopbackNet() (3) isLoopbackNet()
(4) sameNet()
(5) isValidNet() (5) isValidNet()
(6) isSameSubnet()
(7) pqi_inet_netof() (7) pqi_inet_netof()
------------------------------------------------------------ ------------------------------------------------------------

40
libretroshare/src/tests/pqi/net_test.cc
View File

@ -211,46 +211,6 @@ bool test_local_address_manipulation()
return true; return true;
} }
#if 0
std::ostream &showSocketError(std::ostream &out);
std::string socket_errorType(int err);
int sockaddr_cmp(struct sockaddr_in &addr1, struct sockaddr_in &addr2 );
int inaddr_cmp(struct sockaddr_in addr1, struct sockaddr_in addr1 );
int inaddr_cmp(struct sockaddr_in addr1, unsigned long);
std::list<std::string> getLocalInterfaces(); // returns all possible addrs.
bool isExternalNet(struct in_addr *addr); // if Valid & is not Private or Loopback.
bool isPrivateNet(struct in_addr *addr); // if inside 10.0.0.0 or
// other then firewalled.
bool isLoopbackNet(struct in_addr *addr);
bool sameNet(struct in_addr *addr, struct in_addr *addr2);
bool isValidNet(struct in_addr *addr);
// checks (addr1 & 255.255.255.0) == (addr2 & 255.255.255.0)
bool isSameSubnet(struct in_addr *addr1, struct in_addr *addr2);
struct in_addr getPreferredInterface(); // returns best addr.
in_addr_t pqi_inet_netof(struct in_addr addr); // our implementation.
bool LookupDNSAddr(std::string name, struct sockaddr_in &addr);
/* universal socket interface */
int unix_close(int sockfd);
int unix_socket(int domain, int type, int protocol);
int unix_fcntl_nonblock(int sockfd);
int unix_connect(int sockfd, const struct sockaddr *serv_addr, socklen_t addrlen);
int unix_getsockopt_error(int sockfd, int *err);
#endif
bool test_bind_addr(struct sockaddr_in addr); bool test_bind_addr(struct sockaddr_in addr);
bool test_address_listen() bool test_address_listen()

59
libretroshare/src/tests/pqi/net_test1.cc
View File

@ -53,9 +53,7 @@ const char * invalid_addrstr = "AAA.BBB.256.256";
int test_isExternalNet(); int test_isExternalNet();
int test_isPrivateNet(); int test_isPrivateNet();
int test_isLoopbackNet(); int test_isLoopbackNet();
int test_sameNet();
int test_isValidNet(); int test_isValidNet();
int test_isSameSubnet();
int test_pqi_inet_netof(); int test_pqi_inet_netof();
INITTEST(); INITTEST();
@ -67,9 +65,7 @@ int main(int argc, char **argv)
test_isExternalNet(); test_isExternalNet();
test_isPrivateNet(); test_isPrivateNet();
test_isLoopbackNet(); test_isLoopbackNet();
test_sameNet();
test_isValidNet(); test_isValidNet();
test_isSameSubnet();
test_pqi_inet_netof(); test_pqi_inet_netof();
FINALREPORT("net_test1"); FINALREPORT("net_test1");
@ -158,42 +154,6 @@ int test_isLoopbackNet()
return 1; return 1;
} }
int test_sameNet()
{
struct in_addr localnet1_addr;
struct in_addr localnet2_addr;
struct in_addr localnet3_addr;
struct in_addr localnet4_addr;
struct in_addr localnet5_addr;
struct in_addr localnet6_addr;
struct in_addr localnet7_addr;
struct in_addr localnet8_addr;
struct in_addr external_addr;
inet_aton(localnet1_addrstr, &localnet1_addr);
inet_aton(localnet2_addrstr, &localnet2_addr);
inet_aton(localnet3_addrstr, &localnet3_addr);
inet_aton(localnet4_addrstr, &localnet4_addr);
inet_aton(localnet5_addrstr, &localnet5_addr);
inet_aton(localnet6_addrstr, &localnet6_addr);
inet_aton(localnet7_addrstr, &localnet7_addr);
inet_aton(localnet8_addrstr, &localnet8_addr);
inet_aton(external_addrstr, &external_addr);
CHECK(sameNet(&localnet1_addr, &localnet5_addr)==true);
CHECK(sameNet(&localnet2_addr, &localnet6_addr)==true);
CHECK(sameNet(&localnet3_addr, &localnet7_addr)==true);
CHECK(sameNet(&localnet4_addr, &localnet8_addr)==true);
CHECK(sameNet(&localnet1_addr, &external_addr)==false);
CHECK(sameNet(&localnet2_addr, &external_addr)==false);
CHECK(sameNet(&localnet3_addr, &external_addr)==false);
CHECK(sameNet(&localnet4_addr, &external_addr)==false);
REPORT("sameNet()");
return 1;
}
int test_isValidNet() int test_isValidNet()
{ {
struct in_addr localnet1_addr; struct in_addr localnet1_addr;
@ -211,25 +171,6 @@ int test_isValidNet()
return 1; return 1;
} }
int test_isSameSubnet()
{
struct in_addr localnet1_addr;
struct in_addr classc1_addr;
struct in_addr classc2_addr;
inet_aton(localnet1_addrstr, &localnet1_addr);
//random class C addresses
inet_aton("197.67.28.93", &classc1_addr);
inet_aton("197.67.28.3", &classc2_addr);
CHECK(isSameSubnet(&localnet1_addr, &classc1_addr)==false);
CHECK(isSameSubnet(&classc1_addr, &classc2_addr)==true);
REPORT("isSameSubnet()");
return 1;
}
int test_pqi_inet_netof() int test_pqi_inet_netof()
{ {
struct in_addr localnet1_addr; struct in_addr localnet1_addr;

92
libretroshare/src/tests/serialiser/Makefile
View File

@ -1,92 +0,0 @@
RS_TOP_DIR = ../..
DHT_TOP_DIR = ../../../../libbitdht/src
OPS_TOP_DIR = ../../../../openpgpsdk/src
##### Define any flags that are needed for this section #######
###############################################################
###############################################################
include $(RS_TOP_DIR)/tests/scripts/config.mk
###############################################################
OBJ = rstlvutil.o
TESTOBJ = tlvbase_test.o tlvbase_test2.o rstunnelitem_test.o
TESTOBJ += tlvitems_test.o tlvstack_test.o rsserial_test.o
TESTOBJ += rstlvwidetest.o tlvrandom_test.o rsturtleitem_test.o
TESTOBJ += tlvtypes_test.o support.o distribitem_test.o rsmsgitem_test.o
TESTOBJ += rsstatusitem_test.o rsconfigitem_test.o
TESTOBJ += rsgrouteritem_test.o $(OBJ)
TESTS = tlvbase_test tlvbase_test2
#rstlvwidetest
TESTS += tlvitems_test tlvstack_test
#rstunnelitem_test
TESTS += tlvrandom_test rsturtleitem_test
#rsserial_test
TESTS += tlvtypes_test
#rsmsgitem_test
#distribitem_test
TESTS += rsstatusitem_test
#rsconfigitem_test
#TESTS += rsgrouteritem_test
#rsbaseitem_test
all: tests
tests: $(OBJ)
tlvbase_test : tlvbase_test.o
$(CC) $(CFLAGS) -o tlvbase_test tlvbase_test.o $(OBJ) $(LIBS)
tlvbase_test2 : tlvbase_test2.o
$(CC) $(CFLAGS) -o tlvbase_test2 tlvbase_test2.o $(OBJ) $(LIBS)
tlvitems_test : tlvitems_test.o
$(CC) $(CFLAGS) -o tlvitems_test tlvitems_test.o $(OBJ) $(LIBS)
tlvstack_test : tlvstack_test.o
$(CC) $(CFLAGS) -o tlvstack_test tlvstack_test.o $(OBJ) $(LIBS)
rsserial_test : rsserial_test.o
$(CC) $(CFLAGS) -o rsserial_test rsserial_test.o $(OBJ) $(LIBS)
rsgrouteritem_test : rsgrouteritem_test.o
$(CC) $(CFLAGS) -o rsgrouteritem_test rsgrouteritem_test.o $(OBJ) $(LIBS)
rsbaseitem_test : rsbaseitem_test.o
$(CC) $(CFLAGS) -o rsbaseitem_test rsbaseitem_test.o $(OBJ) $(LIBS)
#rstlvwidetest : rstlvwidetest.o
# $(CC) $(CFLAGS) -o rstlvwidetest rstlvwidetest.o $(OBJ) $(LIBS)
tlvrandom_test : tlvrandom_test.o
$(CC) $(CFLAGS) -o tlvrandom_test tlvrandom_test.o $(OBJ) $(LIBS)
rsturtleitem_test : rsturtleitem_test.o support.o
$(CC) $(CFLAGS) -o rsturtleitem_test rsturtleitem_test.o support.o $(OBJ) $(LIBS)
rstunnelitem_test : rstunnelitem_test.o support.o
$(CC) $(CFLAGS) -o rstunnelitem_test rstunnelitem_test.o support.o $(OBJ) $(LIBS)
tlvtypes_test : tlvtypes_test.o
$(CC) $(CFLAGS) -o tlvtypes_test tlvtypes_test.o $(OBJ) $(LIBS)
distribitem_test : distribitem_test.o support.o
$(CC) $(CFLAGS) -o distribitem_test distribitem_test.o support.o $(OBJ) $(LIBS)
rsmsgitem_test : rsmsgitem_test.o support.o
$(CC) $(CFLAGS) -o rsmsgitem_test rsmsgitem_test.o support.o $(OBJ) $(LIBS)
rsstatusitem_test : rsstatusitem_test.o support.o
$(CC) $(CFLAGS) -o rsstatusitem_test rsstatusitem_test.o support.o $(OBJ) $(LIBS)
rsconfigitem_test : rsconfigitem_test.o
$(CC) $(CFLAGS) -o rsconfigitem_test rsconfigitem_test.o support.o $(OBJ) $(LIBS)
###############################################################
include $(RS_TOP_DIR)/scripts/rules.mk
###############################################################

33
libretroshare/src/tests/services/Makefile
View File

@ -1,33 +0,0 @@
RS_TOP_DIR = ../..
DHT_TOP_DIR = ../../../../libbitdht/src
OPS_TOP_DIR = ../../../../openpgpsdk/src
##### Define any flags that are needed for this section #######
###############################################################
###############################################################
include $(RS_TOP_DIR)/tests/scripts/config.mk
###############################################################
TESTOBJ = servicetest.o forumservicetest.o chatservicetest.o
TESTOBJ += chattest.o distribtest.o
TESTS = chattest distribtest
all: tests
distribtest: distribtest.o servicetest.o forumservicetest.o
$(CC) $(CFLAGS) -o distribtest distribtest.o servicetest.o \
forumservicetest.o $(OBJ) $(LIBS)
chattest: chattest.o servicetest.o chatservicetest.o
$(CC) $(CFLAGS) -o chattest chattest.o servicetest.o \
chatservicetest.o $(OBJ) $(LIBS)
###############################################################
include $(RS_TOP_DIR)/scripts/rules.mk
###############################################################

83
libretroshare/src/tests/tcponudp/Makefile
View File

@ -1,83 +0,0 @@
RS_TOP_DIR = ../..
DHT_TOP_DIR = ../../../../libbitdht/src
OPS_TOP_DIR = ../../../../openpgpsdk/src
##### Define any flags that are needed for this section #######
###############################################################
###############################################################
include $(RS_TOP_DIR)/tests/scripts/config.mk
###############################################################
#BIOOBJ = bss_tou.o
#RSOBJ = tou_net.o udplayer.o udpsorter.o udptestfn.o extaddrfinder.o
#RSOBJ += tcppacket.o tcpstream.o tou.o $(BIOOBJ)
OBJ = udptestfn.o
EXECS = udpsock_test udpsort_test udp_server test_tou
EXECS += pair_tou stacks_tou bidir_tou timed_tou
#pair_tou reset_tou internal_tou largefile_tou
TESTOBJ = udpsock_test.o udpsort_test.o udp_server.o test_tou.o
TESTOBJ += pair_tou.o udptestfn.o
TESTOBJ += stacks_tou.o bidir_tou.o timed_tou.o
#TESTOBJ += pair_tou.o reset_tou.o largefile_tou.o
#internal_tou.o
TESTS = udpsock_test udpsort_test udp_server test_tou
TESTS += stacks_tou bidir_tou timed_tou
#TESTS += pair_tou
# Unfortunately the design of tou has changed over time.
# and these tests cannot be performed at the moment.
#TESTS += reset_tou largefile_tou
#internal_tou
all: tests $(EXECS)
udpsock_test : $(OBJ) udpsock_test.o
$(CC) $(CFLAGS) -o udpsock_test udpsock_test.o $(OBJ) $(LIBS)
udpsort_test : $(OBJ) udpsort_test.o
$(CC) $(CFLAGS) -o udpsort_test udpsort_test.o $(OBJ) $(LIBS)
udp_server: $(OBJ) udp_server.o
$(CC) $(CFLAGS) -o udp_server udp_server.o $(OBJ) $(LIBS)
test_tou : $(OBJ) test_tou.o
$(CC) $(CFLAGS) -o test_tou test_tou.o $(OBJ) $(LIBS)
pair_tou : $(OBJ) pair_tou.o
$(CC) $(CFLAGS) -o pair_tou pair_tou.o $(OBJ) $(LIBS)
stacks_tou : $(OBJ) stacks_tou.o
$(CC) $(CFLAGS) -o stacks_tou stacks_tou.o $(OBJ) $(LIBS)
bidir_tou : $(OBJ) bidir_tou.o
$(CC) $(CFLAGS) -o bidir_tou bidir_tou.o $(OBJ) $(LIBS)
timed_tou : $(OBJ) timed_tou.o
$(CC) $(CFLAGS) -o timed_tou timed_tou.o $(OBJ) $(LIBS)
reset_tou : $(OBJ) reset_tou.o
$(CC) $(CFLAGS) -o reset_tou reset_tou.o $(OBJ) $(LIBS)
internal_tou : $(OBJ) internal_tou.o
$(CC) $(CFLAGS) -o internal_tou internal_tou.o $(OBJ) $(LIBS)
largefile_tou : $(OBJ) largefile_tou.o
$(CC) $(CFLAGS) -o largefile_tou largefile_tou.o $(OBJ) $(LIBS)
# Extra Rule for BIOFLAGS
.c.o:
$(BIOCC) $(BIOCFLAGS) -c $<
###############################################################
include $(RS_TOP_DIR)/tests/scripts/rules.mk
###############################################################
CFLAGS += -DRS_USE_BITDHT -I$(DHT_TOP_DIR)

23
libretroshare/src/tests/upnp/Makefile
View File

@ -1,23 +0,0 @@
RS_TOP_DIR = ../..
DHT_TOP_DIR = ../../../../libbitdht/src
OPS_TOP_DIR = ../../../../openpgpsdk/src
##### Define any flags that are needed for this section #######
###############################################################
###############################################################
include $(RS_TOP_DIR)/tests/scripts/config.mk
###############################################################
TESTOBJ =
TESTS =
all: upnpforward
upnpforward: upnpforward.o
$(CC) $(CFLAGS) -o upnpforward upnpforward.o $(LIBS)
###############################################################
include $(RS_TOP_DIR)/tests/scripts/rules.mk
###############################################################

31
libretroshare/src/tests/util/Makefile
View File

@ -1,31 +0,0 @@
RS_TOP_DIR = ../..
DHT_TOP_DIR = ../../../../libbitdht/src
OPS_TOP_DIR = ../../../../openpgpsdk/src
##### Define any flags that are needed for this section #######
###############################################################
###############################################################
include $(RS_TOP_DIR)/tests/scripts/config.mk
###############################################################
TESTOBJ = dirtest.o compress_test.o sha1_test.o aes_test.o dchat_decrypt.o
TESTS = dirtest sha1_test aes_test compress_test dchat_decrypt
all: tests
sha1_test: sha1_test.o
$(CC) $(CFLAGS) -o sha1_test sha1_test.o $(LIBS)
compress_test: compress_test.o
$(CC) $(CFLAGS) -o compress_test compress_test.o $(LIBS)
dirtest: dirtest.o
$(CC) $(CFLAGS) -o dirtest dirtest.o $(LIBS)
dirtest: aes_test.o
$(CC) $(CFLAGS) -o aes_test aes_test.o $(LIBS)
dchat_decrypt: dchat_decrypt.o
$(CC) $(CFLAGS) -o dchat_decrypt dchat_decrypt.o $(LIBS)
###############################################################
include $(RS_TOP_DIR)/tests/scripts/rules.mk
###############################################################

23
libretroshare/src/turtle/Makefile
View File

@ -1,23 +0,0 @@
RS_TOP_DIR = ..
##### Define any flags that are needed for this section #######
###############################################################
###############################################################
include $(RS_TOP_DIR)/scripts/config.mk
###############################################################
RSOBJ = p3turtle.o rsturtleitem.o
#TESTOBJ =
#TESTS =
all: librs tests
#tlvbase_test : tlvbase_test.o
# $(CC) $(CFLAGS) -o tlvbase_test tlvbase_test.o $(OBJ) $(LIBS)
###############################################################
include $(RS_TOP_DIR)/scripts/rules.mk
###############################################################

6
libretroshare/src/turtle/p3turtle.cc
View File

@ -289,7 +289,11 @@ void p3turtle::locked_addDistantPeer(const TurtleFileHash&,TurtleTunnelId tid)
unsigned char tmp[RsPeerId::SIZE_IN_BYTES] ; unsigned char tmp[RsPeerId::SIZE_IN_BYTES] ;
memset(tmp,0,RsPeerId::SIZE_IN_BYTES) ; memset(tmp,0,RsPeerId::SIZE_IN_BYTES) ;
((uint32_t*)tmp)[0] = tid ; assert(sizeof(tid) == 4) ;
for(int i=0;i<4;++i)
tmp[i] = uint8_t( (tid >> ((3-i)*8)) & 0xff ) ;
RsPeerId virtual_peer_id(tmp) ; RsPeerId virtual_peer_id(tmp) ;
_virtual_peers[virtual_peer_id] = tid ; _virtual_peers[virtual_peer_id] = tid ;

28
libretroshare/src/upnp/Makefile
View File

@ -1,28 +0,0 @@
RS_TOP_DIR = ..
##### Define any flags that are needed for this section #######
###############################################################
EXTRA_CFLAGS += -I$(UPNPC_DIR) -DMINIUPNP_EXPORTS
###############################################################
include $(RS_TOP_DIR)/scripts/config.mk
###############################################################
CFLAGS += $(EXTRA_CFLAGS)
RSOBJ = upnphandler.o upnputil.o
TESTOBJ = upnptest.o
TESTS = upnptest
all: librs tests
upnptest: $(OBJ) upnptest.o
$(CC) $(CFLAGS) -o upnptest $(OBJ) upnptest.o $(LIBS)
###############################################################
include $(RS_TOP_DIR)/scripts/rules.mk
###############################################################

10
libretroshare/src/upnp/upnphandler_linux.cc
View File

@ -103,10 +103,18 @@ bool upnphandler::background_setup_upnp(bool start, bool stop)
data->start = start; data->start = start;
data->stop = stop; data->stop = stop;
pthread_create(&tid, 0, &doSetupUPnP, (void *) data); if(! pthread_create(&tid, 0, &doSetupUPnP, (void *) data))
{
pthread_detach(tid); /* so memory is reclaimed in linux */ pthread_detach(tid); /* so memory is reclaimed in linux */
return true; return true;
}
else
{
delete data ;
std::cerr << "(EE) Could not start background upnp thread!" << std::endl;
return false ;
}
} }
bool upnphandler::start_upnp() bool upnphandler::start_upnp()

15
libretroshare/src/upnp/upnphandler_miniupnp.cc
View File

@ -236,10 +236,17 @@ bool upnphandler::background_setup_upnp(bool start, bool stop)
data->start = start; data->start = start;
data->stop = stop; data->stop = stop;
pthread_create(&tid, 0, &doSetupUPnP, (void *) data); if(!pthread_create(&tid, 0, &doSetupUPnP, (void *) data))
pthread_detach(tid); /* so memory is reclaimed in linux */ {
pthread_detach(tid); /* so memory is reclaimed in linux */
return true; return true;
}
else
{
delete data ;
std::cerr << "(EE) Failed to start upnp thread." << std::endl;
return false ;
}
} }
bool upnphandler::start_upnp() bool upnphandler::start_upnp()

27
libretroshare/src/util/Makefile
View File

@ -1,27 +0,0 @@
RS_TOP_DIR = ..
##### Define any flags that are needed for this section #######
###############################################################
###############################################################
include $(RS_TOP_DIR)/scripts/config.mk
###############################################################
RSOBJ = rsthreads.o rsprint.o rsnet.o rsdebug.o rsdir.o rsversion.o
TESTOBJ = dirtest.o dir2test.o
TESTS = dirtest dir2test
all: librs tests
dirtest: $(OBJ) dirtest.o
$(CC) $(CFLAGS) -o dirtest dirtest.o $(OBJ) $(LIBS)
dir2test: $(OBJ) dir2test.o
$(CC) $(CFLAGS) -o dir2test dir2test.o $(OBJ) $(LIBS)
###############################################################
include $(RS_TOP_DIR)/scripts/rules.mk
###############################################################

57
libretroshare/src/util/dnsresolver.cc
View File

@ -62,25 +62,33 @@ void *solveDNSEntries(void *p)
if(!next_call.empty()) if(!next_call.empty())
{ {
hostent *pHost = gethostbyname(next_call.c_str()); in_addr in ;
bool succeed = rsGetHostByName(next_call.c_str(),in);
{
RsStackMutex mut(dnsr->_rdnsMtx) ;
{ DNSResolver::AddrInfo &info = (*dnsr->_addr_map)[next_call];
RsStackMutex mut(dnsr->_rdnsMtx) ;
DNSResolver::AddrInfo &info = (*dnsr->_addr_map)[next_call]; if(succeed)
{
if(pHost) info.state = DNSResolver::DNS_HAVE ;
// IPv4 for the moment.
struct sockaddr_in *addrv4p = (struct sockaddr_in *) &(info.addr);
addrv4p->sin_family = AF_INET;
addrv4p->sin_addr= in ;
addrv4p->sin_port = htons(0);
std::cerr << "LOOKUP succeeded: " << next_call.c_str() << " => " << rs_inet_ntoa(addrv4p->sin_addr) << std::endl;
}
else
{ {
info.state = DNSResolver::DNS_HAVE ;
// IPv4 for the moment.
struct sockaddr_in *addrv4p = (struct sockaddr_in *) &(info.addr);
addrv4p->sin_family = AF_INET;
addrv4p->sin_addr.s_addr = *(unsigned long*) (pHost->h_addr);
addrv4p->sin_port = htons(0);
}
else
info.state = DNSResolver::DNS_LOOKUP_ERROR ; info.state = DNSResolver::DNS_LOOKUP_ERROR ;
}
std::cerr << "DNSResolver: lookup error for address \"" << next_call.c_str() << "\"" << std::endl;
}
}
} }
} }
@ -93,15 +101,18 @@ void *solveDNSEntries(void *p)
void DNSResolver::start_request() void DNSResolver::start_request()
{ {
{ {
RsStackMutex mut(_rdnsMtx) ; RsStackMutex mut(_rdnsMtx) ;
*_thread_running = true ; *_thread_running = true ;
} }
void *data = (void *)this; void *data = (void *)this;
pthread_t tid ; pthread_t tid ;
pthread_create(&tid, 0, &solveDNSEntries, data);
pthread_detach(tid); /* so memory is reclaimed in linux */ if(! pthread_create(&tid, 0, &solveDNSEntries, data))
pthread_detach(tid); /* so memory is reclaimed in linux */
else
std::cerr << "(EE) Could not start DNS resolver thread!" << std::endl;
} }
void DNSResolver::reset() void DNSResolver::reset()

28
libretroshare/src/util/extaddrfinder.cc
View File

@ -2,6 +2,7 @@
#include "pqi/pqinetwork.h" #include "pqi/pqinetwork.h"
#include "util/rsstring.h" #include "util/rsstring.h"
#include "util/rsmemory.h"
#ifndef WIN32 #ifndef WIN32
#include <netdb.h> #include <netdb.h>
@ -58,7 +59,6 @@ static void getPage(const std::string& server_name,std::string& page)
int sockfd,n=0; // socket descriptor int sockfd,n=0; // socket descriptor
struct sockaddr_in serveur; // server's parameters struct sockaddr_in serveur; // server's parameters
memset(&serveur.sin_zero, 0, sizeof(serveur.sin_zero)); memset(&serveur.sin_zero, 0, sizeof(serveur.sin_zero));
struct hostent *hostinfo=NULL; // structure for storing the server's ip
char buf[1024]; char buf[1024];
char request[1024]; char request[1024];
@ -78,20 +78,21 @@ static void getPage(const std::string& server_name,std::string& page)
// get server's ipv4 adress // get server's ipv4 adress
hostinfo = gethostbyname(server_name.c_str()); in_addr in ;
if (hostinfo == NULL) /* l'hôte n'existe pas */ if(!rsGetHostByName(server_name.c_str(),in)) /* l'hôte n'existe pas */
{ {
std::cerr << "ExtAddrFinder: Unknown host " << server_name << std::endl; std::cerr << "ExtAddrFinder: Unknown host " << server_name << std::endl;
unix_close(sockfd); unix_close(sockfd);
return ; return ;
} }
serveur.sin_addr = *(struct in_addr*) hostinfo->h_addr; serveur.sin_addr = in ;
serveur.sin_port = htons(80); serveur.sin_port = htons(80);
#ifdef EXTADDRSEARCH_DEBUG #ifdef EXTADDRSEARCH_DEBUG
printf("Connection attempt\n"); printf("Connection attempt\n");
#endif #endif
std::cerr << "ExtAddrFinder: resolved hostname " << server_name << " to " << rs_inet_ntoa(in) << std::endl;
if(unix_connect(sockfd,(struct sockaddr *)&serveur, sizeof(serveur)) == -1) if(unix_connect(sockfd,(struct sockaddr *)&serveur, sizeof(serveur)) == -1)
{ {
@ -104,12 +105,18 @@ static void getPage(const std::string& server_name,std::string& page)
#endif #endif
// envoi // envoi
sprintf( request, if(snprintf( request,
1024,
"GET / HTTP/1.0\r\n" "GET / HTTP/1.0\r\n"
"Host: %s:%d\r\n" "Host: %s:%d\r\n"
"Connection: Close\r\n" "Connection: Close\r\n"
"\r\n", "\r\n",
server_name.c_str(), 80); server_name.c_str(), 80) > 1020)
{
std::cerr << "ExtAddrFinder: buffer overrun. The server name \"" << server_name << "\" is too long. This is quite unexpected." << std::endl;
unix_close(sockfd);
return ;
}
if(send(sockfd,request,strlen(request),0)== -1) if(send(sockfd,request,strlen(request),0)== -1)
{ {
@ -202,8 +209,11 @@ void ExtAddrFinder::start_request()
{ {
void *data = (void *)this; void *data = (void *)this;
pthread_t tid ; pthread_t tid ;
pthread_create(&tid, 0, &doExtAddrSearch, data);
pthread_detach(tid); /* so memory is reclaimed in linux */ if(! pthread_create(&tid, 0, &doExtAddrSearch, data))
pthread_detach(tid); /* so memory is reclaimed in linux */
else
std::cerr << "(EE) Could not start ExtAddrFinder thread." << std::endl;
} }
bool ExtAddrFinder::hasValidIP(struct sockaddr_storage &addr) bool ExtAddrFinder::hasValidIP(struct sockaddr_storage &addr)

29
libretroshare/src/util/retrodb.cc
View File

@ -598,7 +598,7 @@ bool RetroDb::tableExists(const std::string &tableName)
/********************** RetroCursor ************************/ /********************** RetroCursor ************************/
RetroCursor::RetroCursor(sqlite3_stmt *stmt) RetroCursor::RetroCursor(sqlite3_stmt *stmt)
: mStmt(NULL), mCount(0), mPosCounter(0) { : mStmt(NULL) {
open(stmt); open(stmt);
} }
@ -635,7 +635,6 @@ bool RetroCursor::moveToFirst(){
rc = sqlite3_step(mStmt); rc = sqlite3_step(mStmt);
if(rc == SQLITE_ROW){ if(rc == SQLITE_ROW){
mPosCounter = 0;
return true; return true;
} }
@ -673,17 +672,10 @@ bool RetroCursor::moveToLast(){
return false; return false;
}else{ }else{
mPosCounter = mCount;
return true; return true;
} }
} }
int RetroCursor::getResultCount() const {
if(isOpen())
return mCount;
else
return -1;
}
int RetroCursor::columnCount() const { int RetroCursor::columnCount() const {
if(isOpen()) if(isOpen())
@ -704,8 +696,6 @@ bool RetroCursor::close(){
int rc = sqlite3_finalize(mStmt); int rc = sqlite3_finalize(mStmt);
mStmt = NULL; mStmt = NULL;
mPosCounter = 0;
mCount = 0;
return (rc == SQLITE_OK); return (rc == SQLITE_OK);
} }
@ -725,12 +715,6 @@ bool RetroCursor::open(sqlite3_stmt *stm){
int rc = sqlite3_reset(mStmt); int rc = sqlite3_reset(mStmt);
if(rc == SQLITE_OK){ if(rc == SQLITE_OK){
while((rc = sqlite3_step(mStmt)) == SQLITE_ROW)
mCount++;
sqlite3_reset(mStmt);
return true; return true;
} }
else{ else{
@ -753,7 +737,6 @@ bool RetroCursor::moveToNext(){
int rc = sqlite3_step(mStmt); int rc = sqlite3_step(mStmt);
if(rc == SQLITE_ROW){ if(rc == SQLITE_ROW){
mPosCounter++;
return true; return true;
}else if(rc == SQLITE_DONE){ // no more results }else if(rc == SQLITE_DONE){ // no more results
@ -772,16 +755,6 @@ bool RetroCursor::moveToNext(){
} }
} }
int32_t RetroCursor::getPosition() const {
if(isOpen())
return mPosCounter;
else
return -1;
}
int32_t RetroCursor::getInt32(int columnIndex){ int32_t RetroCursor::getInt32(int columnIndex){
return sqlite3_column_int(mStmt, columnIndex); return sqlite3_column_int(mStmt, columnIndex);
} }

22
libretroshare/src/util/retrodb.h
View File

@ -239,12 +239,6 @@ public:
*/ */
bool moveToLast(); bool moveToLast();
/*!
* gets current position of cursor
* @return current position of cursor
*/
int32_t getPosition() const;
/* data retrieval */ /* data retrieval */
/*! /*!
@ -260,11 +254,10 @@ public:
/*! /*!
* *
* @return -1 if cursor is in error, otherwise number of rows in result * @return -1 if cursor is in error, otherwise number of columns in result
*/ */
int32_t getResultCount() const;
int32_t columnCount() const ; int32_t columnCount() const ;
/*! /*!
* Current statement is closed and discarded (finalised) * Current statement is closed and discarded (finalised)
* before actual opening occurs * before actual opening occurs
@ -274,8 +267,6 @@ public:
bool open(sqlite3_stmt* stm); bool open(sqlite3_stmt* stm);
public: public:
/*! /*!
* Returns the value of the requested column as a String. * Returns the value of the requested column as a String.
* @param columnIndex the zero-based index of the target column. * @param columnIndex the zero-based index of the target column.
@ -326,17 +317,8 @@ public:
getString(columnIndex, temp); getString(columnIndex, temp);
str = T(temp); str = T(temp);
} }
private: private:
sqlite3_stmt* mStmt; sqlite3_stmt* mStmt;
int mCount; /// number of results
int mPosCounter;
}; };
#endif // RSSQLITE_H #endif // RSSQLITE_H

12
libretroshare/src/util/rsaes.cc
View File

@ -61,7 +61,10 @@ bool RsAES::aes_crypt_8_16(const uint8_t *input_data,uint32_t input_data_length,
int f_len = 0; int f_len = 0;
if(output_data_length < (uint32_t)c_len) if(output_data_length < (uint32_t)c_len)
return false ; {
EVP_CIPHER_CTX_cleanup(&e_ctx) ;
return false ;
}
/* update ciphertext, c_len is filled with the length of ciphertext generated, /* update ciphertext, c_len is filled with the length of ciphertext generated,
*len is the size of plaintext in bytes */ *len is the size of plaintext in bytes */
@ -69,6 +72,7 @@ bool RsAES::aes_crypt_8_16(const uint8_t *input_data,uint32_t input_data_length,
if(!EVP_EncryptUpdate(&e_ctx, output_data, &c_len, input_data, input_data_length)) if(!EVP_EncryptUpdate(&e_ctx, output_data, &c_len, input_data, input_data_length))
{ {
std::cerr << "RsAES: decryption failed at end. Check padding." << std::endl; std::cerr << "RsAES: decryption failed at end. Check padding." << std::endl;
EVP_CIPHER_CTX_cleanup(&e_ctx) ;
return false ; return false ;
} }
@ -76,6 +80,7 @@ bool RsAES::aes_crypt_8_16(const uint8_t *input_data,uint32_t input_data_length,
if(!EVP_EncryptFinal_ex(&e_ctx, output_data+c_len, &f_len)) if(!EVP_EncryptFinal_ex(&e_ctx, output_data+c_len, &f_len))
{ {
std::cerr << "RsAES: decryption failed at end. Check padding." << std::endl; std::cerr << "RsAES: decryption failed at end. Check padding." << std::endl;
EVP_CIPHER_CTX_cleanup(&e_ctx) ;
return false ; return false ;
} }
@ -112,7 +117,10 @@ bool RsAES::aes_decrypt_8_16(const uint8_t *input_data,uint32_t input_data_lengt
int f_len = 0; int f_len = 0;
if(output_data_length < (uint32_t)c_len) if(output_data_length < (uint32_t)c_len)
{
EVP_CIPHER_CTX_cleanup(&e_ctx) ;
return false ; return false ;
}
output_data_length = c_len ; output_data_length = c_len ;
@ -122,6 +130,7 @@ bool RsAES::aes_decrypt_8_16(const uint8_t *input_data,uint32_t input_data_lengt
if(! EVP_DecryptUpdate(&e_ctx, output_data, &c_len, input_data, input_data_length)) if(! EVP_DecryptUpdate(&e_ctx, output_data, &c_len, input_data, input_data_length))
{ {
std::cerr << "RsAES: decryption failed." << std::endl; std::cerr << "RsAES: decryption failed." << std::endl;
EVP_CIPHER_CTX_cleanup(&e_ctx) ;
return false ; return false ;
} }
@ -129,6 +138,7 @@ bool RsAES::aes_decrypt_8_16(const uint8_t *input_data,uint32_t input_data_lengt
if(!EVP_DecryptFinal_ex(&e_ctx, output_data+c_len, &f_len)) if(!EVP_DecryptFinal_ex(&e_ctx, output_data+c_len, &f_len))
{ {
std::cerr << "RsAES: decryption failed at end. Check padding." << std::endl; std::cerr << "RsAES: decryption failed at end. Check padding." << std::endl;
EVP_CIPHER_CTX_cleanup(&e_ctx) ;
return false ; return false ;
} }

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

@ -27,7 +27,7 @@
// Includes for directory creation. // Includes for directory creation.
#include <sys/types.h> #include <sys/types.h>
#include <sys/stat.h> #include <sys/stat.h>
#include <sys/fcntl.h> #include <fcntl.h>
#include <unistd.h> #include <unistd.h>
#include "util/rsdir.h" #include "util/rsdir.h"

46
libretroshare/src/util/rsmemory.h
View File

@ -21,29 +21,37 @@
// //
class RsTemporaryMemory class RsTemporaryMemory
{ {
public: public:
RsTemporaryMemory(size_t s) RsTemporaryMemory(size_t s)
{ {
_mem = (unsigned char *)malloc(s) ; _mem = (unsigned char *)malloc(s) ;
}
operator unsigned char *() { return _mem ; } if(_mem)
_size = s ;
else
_size = 0 ;
}
~RsTemporaryMemory() operator unsigned char *() { return _mem ; }
{
if(_mem != NULL) size_t size() const { return _size ; }
{
free(_mem) ;
_mem = NULL ;
}
}
private: ~RsTemporaryMemory()
unsigned char *_mem ; {
if(_mem != NULL)
{
free(_mem) ;
_mem = NULL ;
}
}
// make it noncopyable private:
RsTemporaryMemory& operator=(const RsTemporaryMemory&) { return *this ;} unsigned char *_mem ;
RsTemporaryMemory(const RsTemporaryMemory&) {} size_t _size ;
// make it noncopyable
RsTemporaryMemory& operator=(const RsTemporaryMemory&) { return *this ;}
RsTemporaryMemory(const RsTemporaryMemory&) {}
}; };

35
libretroshare/src/util/rsnet.cc
View File

@ -26,6 +26,7 @@
#include "util/rsnet.h" #include "util/rsnet.h"
#include "util/rsthreads.h" #include "util/rsthreads.h"
#include "util/rsstring.h" #include "util/rsstring.h"
#include "util/rsmemory.h"
#ifdef WINDOWS_SYS #ifdef WINDOWS_SYS
#else #else
@ -72,6 +73,40 @@ void sockaddr_clear(struct sockaddr_in *addr)
addr->sin_family = AF_INET; addr->sin_family = AF_INET;
} }
bool rsGetHostByName(const std::string& hostname, in_addr& returned_addr)
{
#if defined(WINDOWS_SYS) || defined(__APPLE__) || defined(__HAIKU__)
hostent *result = gethostbyname(hostname.c_str()) ;
#else
RsTemporaryMemory mem(8192) ;
if(!mem)
{
std::cerr << __PRETTY_FUNCTION__ << ": Cannot allocate memory!" << std::endl;
return false; // Do something.
}
int error = 0;
struct hostent pHost;
struct hostent *result;
if(gethostbyname_r(hostname.c_str(), &pHost, (char*)(unsigned char*)mem, mem.size(), &result, &error) != 0)
{
std::cerr << __PRETTY_FUNCTION__ << ": cannot call gethostname_r. Internal error reported. Check buffer size." << std::endl;
return false ;
}
#endif
if(!result)
{
std::cerr << __PRETTY_FUNCTION__ << ": gethostname returned null result." << std::endl;
return false ;
}
// Use contents of result.
returned_addr.s_addr = *(unsigned long*) (result->h_addr);
return true ;
}
bool isValidNet(const struct in_addr *addr) bool isValidNet(const struct in_addr *addr)
{ {

Some files were not shown because too many files have changed in this diff Show More