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

Fixed the FriendFeed backup of messages:

Browse Source 
* switched to one universal PendingCache list.
   * added mHistoricalCaches variable to p3distrib - to indicate when old caches have been loaded.
   * added calls to p3GroupDistrib::HistoricalCachesDone() in rsinit.cc
   * added "historical" parameter to lots of p3distrib functions.
   * updated child classes to only add FeedItems if (historical == false).
   * Switched Validate / Duplicate Msg checks to speed up historical data load.
   * corrected rsrandom function for OSX.
   * bugfix to rsloginhandler function. (compile error).
   


git-svn-id: http://svn.code.sf.net/p/retroshare/code/trunk@4008 b45a01b8-16f6-495d-af2f-9b41ad6348cc
This commit is contained in:
drbob 2011-02-02 21:03:46 +00:00
parent 8c35ecdc67
commit 0dcef10ec2
11 changed files with 198 additions and 112 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -2142,7 +2142,17 @@ int RsServer::StartupRetroShare()
getPqiNotify()->ClearFeedItems(RS_FEED_ITEM_MESSAGE); getPqiNotify()->ClearFeedItems(RS_FEED_ITEM_MESSAGE);
//getPqiNotify()->ClearFeedItems(RS_FEED_ITEM_FILES_NEW); //getPqiNotify()->ClearFeedItems(RS_FEED_ITEM_FILES_NEW);
/* flag that the basic Caches are now in the pending Queues */
#ifndef MINIMAL_LIBRS
mForums->HistoricalCachesDone();
mChannels->HistoricalCachesDone();
#ifdef RS_USE_BLOGS
mBlogs->HistoricalCachesDone();
#endif
#endif // MINIMAL_LIBRS
/**************************************************************************/ /**************************************************************************/
/* Add AuthGPG services */ /* Add AuthGPG services */
/**************************************************************************/ /**************************************************************************/

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

@ -540,7 +540,8 @@ bool RsLoginHandler::clearAutoLogin(const std::string& ssl_id)
return false ; return false ;
} }
#else #else
std::string passwdfile = getAutologinFileName() ;
std::string passwdfile = getAutologinFileName(ssl_id) ;
FILE *fp = fopen(passwdfile.c_str(), "wb"); FILE *fp = fopen(passwdfile.c_str(), "wb");
@ -658,6 +659,7 @@ bool RsLoginHandler::getSSLPasswdFromGPGFile(const std::string& ssl_id,std::stri
} }
} }
std::string RsLoginHandler::getSSLPasswdFileName(const std::string& ssl_id) std::string RsLoginHandler::getSSLPasswdFileName(const std::string& ssl_id)
{ {
return RsInit::RsConfigKeysDirectory() + RsInit::dirSeperator() + "ssl_passphrase.pgp"; return RsInit::RsConfigKeysDirectory() + RsInit::dirSeperator() + "ssl_passphrase.pgp";

23
libretroshare/src/services/p3blogs.cc
View File

@ -292,14 +292,14 @@ const uint32_t DOWNLOAD_PERIOD = 7 * 24 * 3600;
* *
*/ */
bool p3Blogs::locked_eventDuplicateMsg(GroupInfo *grp, RsDistribMsg *msg, std::string id) bool p3Blogs::locked_eventDuplicateMsg(GroupInfo *grp, RsDistribMsg *msg, std::string id, bool historical)
{ {
return true; return true;
} }
#include "pqi/pqinotify.h" #include "pqi/pqinotify.h"
bool p3Blogs::locked_eventNewMsg(GroupInfo *grp, RsDistribMsg *msg, std::string id) bool p3Blogs::locked_eventNewMsg(GroupInfo *grp, RsDistribMsg *msg, std::string id, bool historical)
{ {
std::string grpId = msg->grpId; std::string grpId = msg->grpId;
std::string msgId = msg->msgId; std::string msgId = msg->msgId;
@ -311,7 +311,10 @@ bool p3Blogs::locked_eventNewMsg(GroupInfo *grp, RsDistribMsg *msg, std::string
std::cerr << " peerId: " << id; std::cerr << " peerId: " << id;
std::cerr << std::endl; std::cerr << std::endl;
getPqiNotify()->AddFeedItem(RS_FEED_ITEM_BLOG_MSG, grpId, msgId, nullId); if (!historical)
{
getPqiNotify()->AddFeedItem(RS_FEED_ITEM_BLOG_MSG, grpId, msgId, nullId);
}
/* request the files /* request the files
* NB: This could result in duplicates. * NB: This could result in duplicates.
@ -319,13 +322,13 @@ bool p3Blogs::locked_eventNewMsg(GroupInfo *grp, RsDistribMsg *msg, std::string
* *
* this is exactly what DuplicateMsg does. * this is exactly what DuplicateMsg does.
* */ * */
return locked_eventDuplicateMsg(grp, msg, id); return locked_eventDuplicateMsg(grp, msg, id, historical);
} }
void p3Blogs::locked_notifyGroupChanged(GroupInfo &grp, uint32_t flags) void p3Blogs::locked_notifyGroupChanged(GroupInfo &grp, uint32_t flags, bool historical)
{ {
std::string grpId = grp.grpId; std::string grpId = grp.grpId;
std::string msgId; std::string msgId;
@ -341,12 +344,18 @@ void p3Blogs::locked_notifyGroupChanged(GroupInfo &grp, uint32_t flags)
case GRP_NEW_UPDATE: case GRP_NEW_UPDATE:
std::cerr << "p3Blogs::locked_notifyGroupChanged() NEW UPDATE"; std::cerr << "p3Blogs::locked_notifyGroupChanged() NEW UPDATE";
std::cerr << std::endl; std::cerr << std::endl;
getPqiNotify()->AddFeedItem(RS_FEED_ITEM_BLOG_NEW, grpId, msgId, nullId); if (!historical)
{
getPqiNotify()->AddFeedItem(RS_FEED_ITEM_BLOG_NEW, grpId, msgId, nullId);
}
break; break;
case GRP_UPDATE: case GRP_UPDATE:
std::cerr << "p3Blogs::locked_notifyGroupChanged() UPDATE"; std::cerr << "p3Blogs::locked_notifyGroupChanged() UPDATE";
std::cerr << std::endl; std::cerr << std::endl;
getPqiNotify()->AddFeedItem(RS_FEED_ITEM_BLOG_UPDATE, grpId, msgId, nullId); if (!historical)
{
getPqiNotify()->AddFeedItem(RS_FEED_ITEM_BLOG_UPDATE, grpId, msgId, nullId);
}
break; break;
case GRP_LOAD_KEY: case GRP_LOAD_KEY:
std::cerr << "p3Blogs::locked_notifyGroupChanged() LOAD_KEY"; std::cerr << "p3Blogs::locked_notifyGroupChanged() LOAD_KEY";

6
libretroshare/src/services/p3blogs.h
View File

@ -114,9 +114,9 @@ virtual bool isReply(BlogMsgInfo& info);
/***************************************************************************************/ /***************************************************************************************/
protected: protected:
virtual void locked_notifyGroupChanged(GroupInfo &info, uint32_t flags); virtual void locked_notifyGroupChanged(GroupInfo &info, uint32_t flags, bool historical);
virtual bool locked_eventNewMsg(GroupInfo *, RsDistribMsg *, std::string); virtual bool locked_eventNewMsg(GroupInfo *, RsDistribMsg *, std::string, bool historical);
virtual bool locked_eventDuplicateMsg(GroupInfo *, RsDistribMsg *, std::string); virtual bool locked_eventDuplicateMsg(GroupInfo *, RsDistribMsg *, std::string, bool historical);
/****************************************/ /****************************************/

27
libretroshare/src/services/p3channels.cc
View File

@ -609,7 +609,7 @@ const uint32_t DOWNLOAD_PERIOD = 7 * 24 * 3600;
* on a subscription to a channel.. * on a subscription to a channel..
*/ */
bool p3Channels::locked_eventDuplicateMsg(GroupInfo *grp, RsDistribMsg *msg, std::string id) bool p3Channels::locked_eventDuplicateMsg(GroupInfo *grp, RsDistribMsg *msg, std::string id, bool historical)
{ {
std::string grpId = msg->grpId; std::string grpId = msg->grpId;
std::string msgId = msg->msgId; std::string msgId = msg->msgId;
@ -714,24 +714,27 @@ bool p3Channels::locked_eventDuplicateMsg(GroupInfo *grp, RsDistribMsg *msg, std
#include "pqi/pqinotify.h" #include "pqi/pqinotify.h"
bool p3Channels::locked_eventNewMsg(GroupInfo *grp, RsDistribMsg *msg, std::string id) bool p3Channels::locked_eventNewMsg(GroupInfo *grp, RsDistribMsg *msg, std::string id, bool historical)
{ {
std::string grpId = msg->grpId; std::string grpId = msg->grpId;
std::string msgId = msg->msgId; std::string msgId = msg->msgId;
std::string nullId; std::string nullId;
getPqiNotify()->AddFeedItem(RS_FEED_ITEM_CHAN_MSG, grpId, msgId, nullId); if (!historical)
{
getPqiNotify()->AddFeedItem(RS_FEED_ITEM_CHAN_MSG, grpId, msgId, nullId);
}
/* request the files /* request the files
* NB: This could result in duplicates. * NB: This could result in duplicates.
* which must be handled by ft side. * which must be handled by ft side.
* *
* this is exactly what DuplicateMsg does. * this is exactly what DuplicateMsg does.
* */ * */
return locked_eventDuplicateMsg(grp, msg, id); return locked_eventDuplicateMsg(grp, msg, id, historical);
} }
void p3Channels::locked_notifyGroupChanged(GroupInfo &grp, uint32_t flags) void p3Channels::locked_notifyGroupChanged(GroupInfo &grp, uint32_t flags, bool historical)
{ {
std::string grpId = grp.grpId; std::string grpId = grp.grpId;
std::string msgId; std::string msgId;
@ -744,14 +747,20 @@ void p3Channels::locked_notifyGroupChanged(GroupInfo &grp, uint32_t flags)
#ifdef CHANNEL_DEBUG #ifdef CHANNEL_DEBUG
std::cerr << "p3Channels::locked_notifyGroupChanged() NEW UPDATE" << std::endl; std::cerr << "p3Channels::locked_notifyGroupChanged() NEW UPDATE" << std::endl;
#endif #endif
getPqiNotify()->AddFeedItem(RS_FEED_ITEM_CHAN_NEW, grpId, msgId, nullId); if (!historical)
{
getPqiNotify()->AddFeedItem(RS_FEED_ITEM_CHAN_NEW, grpId, msgId, nullId);
}
rsicontrol->getNotify().notifyListChange(NOTIFY_LIST_CHANNELLIST_LOCKED, NOTIFY_TYPE_ADD); rsicontrol->getNotify().notifyListChange(NOTIFY_LIST_CHANNELLIST_LOCKED, NOTIFY_TYPE_ADD);
break; break;
case GRP_UPDATE: case GRP_UPDATE:
#ifdef CHANNEL_DEBUG #ifdef CHANNEL_DEBUG
std::cerr << "p3Channels::locked_notifyGroupChanged() UPDATE" << std::endl; std::cerr << "p3Channels::locked_notifyGroupChanged() UPDATE" << std::endl;
#endif #endif
getPqiNotify()->AddFeedItem(RS_FEED_ITEM_CHAN_UPDATE, grpId, msgId, nullId); if (!historical)
{
getPqiNotify()->AddFeedItem(RS_FEED_ITEM_CHAN_UPDATE, grpId, msgId, nullId);
}
rsicontrol->getNotify().notifyListChange(NOTIFY_LIST_CHANNELLIST_LOCKED, NOTIFY_TYPE_MOD); rsicontrol->getNotify().notifyListChange(NOTIFY_LIST_CHANNELLIST_LOCKED, NOTIFY_TYPE_MOD);
break; break;
case GRP_LOAD_KEY: case GRP_LOAD_KEY:
@ -800,7 +809,7 @@ void p3Channels::locked_notifyGroupChanged(GroupInfo &grp, uint32_t flags)
break; break;
} }
return p3GroupDistrib::locked_notifyGroupChanged(grp, flags); return p3GroupDistrib::locked_notifyGroupChanged(grp, flags, historical);
} }

6
libretroshare/src/services/p3channels.h
View File

@ -87,9 +87,9 @@ virtual void getPubKeysAvailableGrpIds(std::list<std::string>& grpIds);
/***************************************************************************************/ /***************************************************************************************/
protected: protected:
virtual void locked_notifyGroupChanged(GroupInfo &info, uint32_t flags); virtual void locked_notifyGroupChanged(GroupInfo &info, uint32_t flags, bool historical);
virtual bool locked_eventNewMsg(GroupInfo *, RsDistribMsg *, std::string); virtual bool locked_eventNewMsg(GroupInfo *, RsDistribMsg *, std::string, bool historical);
virtual bool locked_eventDuplicateMsg(GroupInfo *, RsDistribMsg *, std::string); virtual bool locked_eventDuplicateMsg(GroupInfo *, RsDistribMsg *, std::string, bool historical);
/****************************************/ /****************************************/

133
libretroshare/src/services/p3distrib.cc
View File

@ -69,6 +69,7 @@ p3GroupDistrib::p3GroupDistrib(uint16_t subtype,
:CacheSource(subtype, true, cs, sourcedir), :CacheSource(subtype, true, cs, sourcedir),
CacheStore(subtype, true, cs, cft, storedir), CacheStore(subtype, true, cs, cft, storedir),
p3Config(configId), p3ThreadedService(subtype), p3Config(configId), p3ThreadedService(subtype),
mHistoricalCaches(true),
mStorePeriod(storePeriod), mStorePeriod(storePeriod),
mPubPeriod(pubPeriod), mPubPeriod(pubPeriod),
mLastPublishTime(0), mLastPublishTime(0),
@ -177,7 +178,7 @@ int p3GroupDistrib::loadCache(const CacheData &data)
std::cerr << std::endl; std::cerr << std::endl;
#endif #endif
/* store the cache file for later processing */ /* store the cache file for later processing */
mPendingRemoteCache.push_back(data); mPendingCaches.push_back(CacheDataPending(data, false, mHistoricalCaches));
} }
if (data.size > 0) if (data.size > 0)
@ -206,7 +207,7 @@ bool p3GroupDistrib::loadLocalCache(const CacheData &data)
#endif #endif
/* store the cache file for later processing */ /* store the cache file for later processing */
mPendingLocalCache.push_back(data); mPendingCaches.push_back(CacheDataPending(data, true, mHistoricalCaches));
} }
if (data.size > 0) if (data.size > 0)
@ -218,6 +219,18 @@ bool p3GroupDistrib::loadLocalCache(const CacheData &data)
} }
/* Handle the Cache Pending Setup */
CacheDataPending::CacheDataPending(const CacheData &data, bool local, bool historical)
:mData(data), mLocal(local), mHistorical(historical)
{
return;
}
void p3GroupDistrib::HistoricalCachesDone()
{
RsStackMutex stack(distribMtx);
mHistoricalCaches = false; // called when Stored Caches have been added to Pending List.
}
/* From RsThread */ /* From RsThread */
void p3GroupDistrib::run() /* called once the thread is started */ void p3GroupDistrib::run() /* called once the thread is started */
@ -234,31 +247,22 @@ void p3GroupDistrib::run() /* called once the thread is started */
CacheData cache; CacheData cache;
bool validCache = false; bool validCache = false;
bool isLocal = false; bool isLocal = false;
bool isHistorical = false;
{ {
RsStackMutex stack(distribMtx); RsStackMutex stack(distribMtx);
if (mPendingLocalCache.size() > 0) if (mPendingCaches.size() > 0)
{ {
cache = mPendingLocalCache.front(); CacheDataPending &pendingCache = mPendingCaches.front();
mPendingLocalCache.pop_front(); cache = pendingCache.mData;
isLocal = pendingCache.mLocal;
isHistorical = pendingCache.mHistorical;
validCache = true; validCache = true;
isLocal = true; mPendingCaches.pop_front();
#ifdef DISTRIB_THREAD_DEBUG #ifdef DISTRIB_THREAD_DEBUG
std::cerr << "p3GroupDistrib::run() found pendingLocalCache"; std::cerr << "p3GroupDistrib::run() found pendingCache";
std::cerr << std::endl;
#endif
}
else if (mPendingRemoteCache.size() > 0)
{
cache = mPendingRemoteCache.front();
mPendingRemoteCache.pop_front();
validCache = true;
isLocal = false;
#ifdef DISTRIB_THREAD_DEBUG
std::cerr << "p3GroupDistrib::run() found pendingRemoteCache";
std::cerr << std::endl; std::cerr << std::endl;
#endif #endif
@ -267,7 +271,7 @@ void p3GroupDistrib::run() /* called once the thread is started */
if (validCache) if (validCache)
{ {
loadAnyCache(cache, isLocal); loadAnyCache(cache, isLocal, isHistorical);
#ifndef WINDOWS_SYS #ifndef WINDOWS_SYS
usleep(1000); usleep(1000);
@ -288,7 +292,7 @@ void p3GroupDistrib::run() /* called once the thread is started */
int p3GroupDistrib::loadAnyCache(const CacheData &data, bool local) int p3GroupDistrib::loadAnyCache(const CacheData &data, bool local, bool historical)
{ {
/* if subtype = 1 -> FileGroup, else -> FileMsgs */ /* if subtype = 1 -> FileGroup, else -> FileMsgs */
@ -304,11 +308,11 @@ int p3GroupDistrib::loadAnyCache(const CacheData &data, bool local)
if (data.cid.subid == 1) if (data.cid.subid == 1)
{ {
loadFileGroups(file, data.pid, local); loadFileGroups(file, data.pid, local, historical);
} }
else else
{ {
loadFileMsgs(file, data.cid.subid, data.pid, data.recvd, local); loadFileMsgs(file, data.cid.subid, data.pid, data.recvd, local, historical);
} }
return true; return true;
} }
@ -323,7 +327,7 @@ int p3GroupDistrib::loadAnyCache(const CacheData &data, bool local)
/* No need for special treatment for 'own' groups. /* No need for special treatment for 'own' groups.
* configuration should be loaded before cache files. * configuration should be loaded before cache files.
*/ */
void p3GroupDistrib::loadFileGroups(const std::string &filename, const std::string &src, bool local) void p3GroupDistrib::loadFileGroups(const std::string &filename, const std::string &src, bool local, bool historical)
{ {
#ifdef DISTRIB_DEBUG #ifdef DISTRIB_DEBUG
std::cerr << "p3GroupDistrib::loadFileGroups()"; std::cerr << "p3GroupDistrib::loadFileGroups()";
@ -354,11 +358,11 @@ void p3GroupDistrib::loadFileGroups(const std::string &filename, const std::stri
newKey = dynamic_cast<RsDistribGrpKey *>(item); newKey = dynamic_cast<RsDistribGrpKey *>(item);
if ((newGrp = dynamic_cast<RsDistribGrp *>(item))) if ((newGrp = dynamic_cast<RsDistribGrp *>(item)))
{ {
loadGroup(newGrp); loadGroup(newGrp, historical);
} }
else if ((newKey = dynamic_cast<RsDistribGrpKey *>(item))) else if ((newKey = dynamic_cast<RsDistribGrpKey *>(item)))
{ {
loadGroupKey(newKey); loadGroupKey(newKey, historical);
} }
else else
{ {
@ -384,7 +388,7 @@ void p3GroupDistrib::loadFileGroups(const std::string &filename, const std::stri
} }
void p3GroupDistrib::loadFileMsgs(const std::string &filename, uint16_t cacheSubId, const std::string &src, uint32_t ts, bool local) void p3GroupDistrib::loadFileMsgs(const std::string &filename, uint16_t cacheSubId, const std::string &src, uint32_t ts, bool local, bool historical)
{ {
#ifdef DISTRIB_DEBUG #ifdef DISTRIB_DEBUG
@ -418,7 +422,7 @@ void p3GroupDistrib::loadFileMsgs(const std::string &filename, uint16_t cacheSub
if ((newMsg = dynamic_cast<RsDistribSignedMsg *>(item))) if ((newMsg = dynamic_cast<RsDistribSignedMsg *>(item)))
{ {
loadMsg(newMsg, src, local); loadMsg(newMsg, src, local, historical);
} }
else else
{ {
@ -475,7 +479,7 @@ void p3GroupDistrib::loadFileMsgs(const std::string &filename, uint16_t cacheSub
/***************************************************************************************/ /***************************************************************************************/
void p3GroupDistrib::loadGroup(RsDistribGrp *newGrp) void p3GroupDistrib::loadGroup(RsDistribGrp *newGrp, bool historical)
{ {
/* load groupInfo */ /* load groupInfo */
const std::string &gid = newGrp -> grpId; const std::string &gid = newGrp -> grpId;
@ -574,9 +578,9 @@ void p3GroupDistrib::loadGroup(RsDistribGrp *newGrp)
/* Callback for any derived classes */ /* Callback for any derived classes */
if (isNew) if (isNew)
locked_notifyGroupChanged(it->second, GRP_NEW_UPDATE); locked_notifyGroupChanged(it->second, GRP_NEW_UPDATE, historical);
else else
locked_notifyGroupChanged(it->second, GRP_UPDATE); locked_notifyGroupChanged(it->second, GRP_UPDATE, historical);
} }
#ifdef DISTRIB_DEBUG #ifdef DISTRIB_DEBUG
@ -586,7 +590,7 @@ void p3GroupDistrib::loadGroup(RsDistribGrp *newGrp)
} }
bool p3GroupDistrib::loadGroupKey(RsDistribGrpKey *newKey) bool p3GroupDistrib::loadGroupKey(RsDistribGrpKey *newKey, bool historical)
{ {
/* load Key */ /* load Key */
const std::string &gid = newKey -> grpId; const std::string &gid = newKey -> grpId;
@ -659,7 +663,7 @@ bool p3GroupDistrib::loadGroupKey(RsDistribGrpKey *newKey)
} }
if (updateOk) if (updateOk)
locked_notifyGroupChanged(it->second, GRP_LOAD_KEY); locked_notifyGroupChanged(it->second, GRP_LOAD_KEY, historical);
@ -676,7 +680,7 @@ bool p3GroupDistrib::loadGroupKey(RsDistribGrpKey *newKey)
} }
void p3GroupDistrib::loadMsg(RsDistribSignedMsg *newMsg, const std::string &src, bool local) void p3GroupDistrib::loadMsg(RsDistribSignedMsg *newMsg, const std::string &src, bool local, bool historical)
{ {
/****************** check the msg ******************/ /****************** check the msg ******************/
/* Do the most likely checks to fail first.... /* Do the most likely checks to fail first....
@ -713,22 +717,12 @@ void p3GroupDistrib::loadMsg(RsDistribSignedMsg *newMsg, const std::string &src,
return; return;
} }
/****************** check the msg ******************/
if (!locked_validateDistribSignedMsg(git->second, newMsg))
{
#ifdef DISTRIB_DEBUG
std::cerr << "p3GroupDistrib::loadMsg() validate failed" << std::endl;
std::cerr << std::endl;
#endif
delete newMsg;
return;
}
/* check for duplicate message /****************** check the msg ******************/
* /* check for duplicate message, do this first to ensure minimal signature validations.
* do this after validate - because we are calling * therefore, duplicateMsg... could potentially be called on a dodgey msg (not a big problem!)
* duplicateMsg... only want to do if is good.
*/ */
std::map<std::string, RsDistribMsg *>::iterator mit; std::map<std::string, RsDistribMsg *>::iterator mit;
mit = (git->second).msgs.find(newMsg->msgId); mit = (git->second).msgs.find(newMsg->msgId);
if (mit != (git->second).msgs.end()) if (mit != (git->second).msgs.end())
@ -738,7 +732,18 @@ void p3GroupDistrib::loadMsg(RsDistribSignedMsg *newMsg, const std::string &src,
std::cerr << std::endl; std::cerr << std::endl;
#endif #endif
/* if already there -> remove */ /* if already there -> remove */
locked_eventDuplicateMsg(&(git->second), mit->second, src); locked_eventDuplicateMsg(&(git->second), mit->second, src, historical);
delete newMsg;
return;
}
/* if unique (new) msg - do validation */
if (!locked_validateDistribSignedMsg(git->second, newMsg))
{
#ifdef DISTRIB_DEBUG
std::cerr << "p3GroupDistrib::loadMsg() validate failed" << std::endl;
std::cerr << std::endl;
#endif
delete newMsg; delete newMsg;
return; return;
} }
@ -805,7 +810,7 @@ void p3GroupDistrib::loadMsg(RsDistribSignedMsg *newMsg, const std::string &src,
#endif #endif
/* Callback for any derived classes to play with */ /* Callback for any derived classes to play with */
locked_eventNewMsg(&(git->second), msg, src); locked_eventNewMsg(&(git->second), msg, src, historical);
/* else if group = subscribed | listener -> publish */ /* else if group = subscribed | listener -> publish */
/* if it has come from us... then it has been published already */ /* if it has come from us... then it has been published already */
@ -836,7 +841,7 @@ void p3GroupDistrib::loadMsg(RsDistribSignedMsg *newMsg, const std::string &src,
#endif #endif
delete newMsg; delete newMsg;
} }
locked_notifyGroupChanged(git->second, GRP_NEW_MSG); locked_notifyGroupChanged(git->second, GRP_NEW_MSG, historical);
} }
@ -1330,7 +1335,7 @@ bool p3GroupDistrib::subscribeToGroup(const std::string &grpId, bool subscrib
{ {
git->second.flags |= RS_DISTRIB_SUBSCRIBED; git->second.flags |= RS_DISTRIB_SUBSCRIBED;
locked_notifyGroupChanged(git->second, GRP_SUBSCRIBED); locked_notifyGroupChanged(git->second, GRP_SUBSCRIBED, false);
mGroupsRepublish = true; mGroupsRepublish = true;
/* reprocess groups messages .... so actions can be taken (by inherited) /* reprocess groups messages .... so actions can be taken (by inherited)
@ -1350,7 +1355,7 @@ bool p3GroupDistrib::subscribeToGroup(const std::string &grpId, bool subscrib
pit != git->second.sources.end(); pit++) pit != git->second.sources.end(); pit++)
{ {
if(*pit != mOwnId) if(*pit != mOwnId)
locked_eventDuplicateMsg(&(git->second), mit->second, *pit); locked_eventDuplicateMsg(&(git->second), mit->second, *pit, false);
} }
} }
} }
@ -1361,7 +1366,7 @@ bool p3GroupDistrib::subscribeToGroup(const std::string &grpId, bool subscrib
{ {
git->second.flags &= (~RS_DISTRIB_SUBSCRIBED); git->second.flags &= (~RS_DISTRIB_SUBSCRIBED);
locked_notifyGroupChanged(git->second, GRP_UNSUBSCRIBED); locked_notifyGroupChanged(git->second, GRP_UNSUBSCRIBED, false);
mGroupsRepublish = true; mGroupsRepublish = true;
} }
} }
@ -1402,7 +1407,7 @@ bool p3GroupDistrib::attemptPublishKeysRecvd()
if(locked_updateGroupPublishKey(it->second, mit->second)){ if(locked_updateGroupPublishKey(it->second, mit->second)){
locked_notifyGroupChanged(it->second, GRP_LOAD_KEY); locked_notifyGroupChanged(it->second, GRP_LOAD_KEY, false);
} }
if(it->second.flags & RS_DISTRIB_SUBSCRIBED){ if(it->second.flags & RS_DISTRIB_SUBSCRIBED){
@ -1646,7 +1651,7 @@ bool p3GroupDistrib::loadList(std::list<RsItem *>& load)
if ((newGrp = dynamic_cast<RsDistribGrp *>(*lit))) if ((newGrp = dynamic_cast<RsDistribGrp *>(*lit)))
{ {
const std::string &gid = newGrp -> grpId; const std::string &gid = newGrp -> grpId;
loadGroup(newGrp); loadGroup(newGrp, false);
subscribeToGroup(gid, true); subscribeToGroup(gid, true);
} }
@ -1662,14 +1667,14 @@ bool p3GroupDistrib::loadList(std::list<RsItem *>& load)
continue; continue;
} }
loadGroupKey(newKey); loadGroupKey(newKey, false);
} }
else if ((newMsg = dynamic_cast<RsDistribSignedMsg *>(*lit))) else if ((newMsg = dynamic_cast<RsDistribSignedMsg *>(*lit)))
{ {
newMsg->PeerId(mOwnId); newMsg->PeerId(mOwnId);
loadMsg(newMsg, mOwnId, false); /* false so it'll pushed to PendingPublish list */ loadMsg(newMsg, mOwnId, false, false); /* false so it'll pushed to PendingPublish list */
} }
else if ((newChildConfig = dynamic_cast<RsDistribConfigData *>(*lit))) else if ((newChildConfig = dynamic_cast<RsDistribConfigData *>(*lit)))
{ {
@ -1971,7 +1976,7 @@ std::string p3GroupDistrib::createGroup(std::wstring name, std::wstring desc, ui
EVP_PKEY_free(key_admin); EVP_PKEY_free(key_admin);
/******************* load up new Group *********************/ /******************* load up new Group *********************/
loadGroup(newGrp); loadGroup(newGrp, false);
/* add Keys to GroupInfo */ /* add Keys to GroupInfo */
RsStackMutex stack(distribMtx); /************* STACK MUTEX ************/ RsStackMutex stack(distribMtx); /************* STACK MUTEX ************/
@ -2094,7 +2099,7 @@ bool p3GroupDistrib::restoreGrpKeys(std::string grpId){
if(ok){ if(ok){
gi->flags |= RS_DISTRIB_SUBSCRIBED; gi->flags |= RS_DISTRIB_SUBSCRIBED;
locked_notifyGroupChanged(*gi, GRP_SUBSCRIBED); locked_notifyGroupChanged(*gi, GRP_SUBSCRIBED, false);
IndicateConfigChanged(); IndicateConfigChanged();
mGroupsRepublish = true; mGroupsRepublish = true;
} }
@ -2274,7 +2279,7 @@ void p3GroupDistrib::receivePubKeys(){
if(locked_updateGroupPublishKey(it->second, key_item)){ if(locked_updateGroupPublishKey(it->second, key_item)){
mPubKeyAvailableGrpId.insert(key_item->grpId); mPubKeyAvailableGrpId.insert(key_item->grpId);
locked_notifyGroupChanged(it->second, GRP_LOAD_KEY); locked_notifyGroupChanged(it->second, GRP_LOAD_KEY, false);
// keep key if user not subscribed // keep key if user not subscribed
if(it->second.flags & RS_DISTRIB_SUBSCRIBED){ if(it->second.flags & RS_DISTRIB_SUBSCRIBED){
@ -2483,7 +2488,7 @@ std::string p3GroupDistrib::publishMsg(RsDistribMsg *msg, bool personalSign)
*/ */
signedMsg->PeerId(mOwnId); signedMsg->PeerId(mOwnId);
loadMsg(signedMsg, mOwnId, false); loadMsg(signedMsg, mOwnId, false, false);
/* done */ /* done */
return msgId; return msgId;
@ -3683,7 +3688,7 @@ std::ostream &operator<<(std::ostream &out, const GroupInfo &info)
return out; return out;
} }
void p3GroupDistrib::locked_notifyGroupChanged(GroupInfo &info, uint32_t flags) void p3GroupDistrib::locked_notifyGroupChanged(GroupInfo &info, uint32_t flags, bool historical)
{ {
mGroupsChanged = true; mGroupsChanged = true;
info.grpChanged = true; info.grpChanged = true;

61
libretroshare/src/services/p3distrib.h
View File

@ -92,6 +92,22 @@ const uint32_t GROUP_KEY_DISTRIB_ADMIN = 0x0040;
#endif #endif
/*
* A data structure to store dummy (missing) msgs.
* They are added to the GroupInfo if there is a missing parent Msg of thread Msg
* Basic Logic is:
*
*/
class RsDistribDummyMsg
{
public:
std::string threadId;
std::string parentId;
std::string msgId;
};
//! for storing group keys to members of a group //! for storing group keys to members of a group
/*! /*!
* This key but be of many types, including private/public publish key, or admin prite key for group * This key but be of many types, including private/public publish key, or admin prite key for group
@ -247,6 +263,24 @@ const uint32_t GRP_UNSUBSCRIBED = 0x0006;
* Group id is the public admin keys id * Group id is the public admin keys id
* *
*/ */
/*
* To Handle Cache Data Loading.... we want to be able to seperate Historical
* from new data (primarily for the gui's benefit).
* to do this we have a mHistoricalCaches flag, which is automatically raised at startup,
* and a function is called to cancel it (HistoricalCachesDone()).
*/
class CacheDataPending
{
public:
CacheDataPending(const CacheData &data, bool local, bool historical);
CacheData mData;
bool mLocal;
bool mHistorical;
};
class p3GroupDistrib: public CacheSource, public CacheStore, public p3Config, public p3ThreadedService class p3GroupDistrib: public CacheSource, public CacheStore, public p3Config, public p3ThreadedService
{ {
public: public:
@ -272,18 +306,21 @@ class p3GroupDistrib: public CacheSource, public CacheStore, public p3Config, pu
/* From RsThread */ /* From RsThread */
virtual void run(); /* called once the thread is started */ virtual void run(); /* called once the thread is started */
void HistoricalCachesDone(); // called when Stored Caches have been added to Pending List.
private: private:
/* these lists are filled by the overloaded fns... then cleared by the thread */ /* these lists are filled by the overloaded fns... then cleared by the thread */
std::list<CacheData> mPendingLocalCache; bool mHistoricalCaches; // initially true.... falsified by HistoricalCachesDone()
std::list<CacheData> mPendingRemoteCache; std::list<CacheDataPending> mPendingCaches;
/* top level load */ /* top level load */
int loadAnyCache(const CacheData &data, bool local); int loadAnyCache(const CacheData &data, bool local, bool historical);
/* load cache files */ /* load cache files */
void loadFileGroups(const std::string &filename, const std::string &src, bool local); void loadFileGroups(const std::string &filename, const std::string &src, bool local, bool historical);
void loadFileMsgs(const std::string &filename, uint16_t cacheSubId, const std::string &src, uint32_t ts, bool local); void loadFileMsgs(const std::string &filename, uint16_t cacheSubId, const std::string &src, uint32_t ts, bool local, bool historical);
bool backUpKeys(const std::list<RsDistribGrpKey* > &keysToBackUp, std::string grpId); bool backUpKeys(const std::list<RsDistribGrpKey* > &keysToBackUp, std::string grpId);
void locked_sharePubKey(); void locked_sharePubKey();
@ -304,13 +341,13 @@ class p3GroupDistrib: public CacheSource, public CacheStore, public p3Config, pu
* @param src src of msg (peer id) * @param src src of msg (peer id)
* @param local is this a local cache msg (your msg) * @param local is this a local cache msg (your msg)
*/ */
void loadMsg(RsDistribSignedMsg *msg, const std::string &src, bool local); void loadMsg(RsDistribSignedMsg *msg, const std::string &src, bool local, bool historical);
/*! /*!
* adds newgrp to grp set, GroupInfo type created and stored * adds newgrp to grp set, GroupInfo type created and stored
* @param newGrp grp to be added * @param newGrp grp to be added
*/ */
void loadGroup(RsDistribGrp *newGrp); void loadGroup(RsDistribGrp *newGrp, bool historical);
/*! /*!
* Adds new keys dependent on whether it is an admin or publish key * Adds new keys dependent on whether it is an admin or publish key
@ -318,7 +355,7 @@ class p3GroupDistrib: public CacheSource, public CacheStore, public p3Config, pu
* @param newKey key to be added * @param newKey key to be added
* @return if key is loaded to group or stored return true * @return if key is loaded to group or stored return true
*/ */
bool loadGroupKey(RsDistribGrpKey *newKey); bool loadGroupKey(RsDistribGrpKey *newKey, bool historical);
/***************************************************************************************/ /***************************************************************************************/
@ -411,7 +448,7 @@ class p3GroupDistrib: public CacheSource, public CacheStore, public p3Config, pu
/*! /*!
* root version (p3Distrib::) of this function must be called * root version (p3Distrib::) of this function must be called
*/ */
virtual void locked_notifyGroupChanged(GroupInfo &info, uint32_t flags); virtual void locked_notifyGroupChanged(GroupInfo &info, uint32_t flags, bool historical);
/*! /*!
* client (inheriting class) should use this to determing behaviour of * client (inheriting class) should use this to determing behaviour of
@ -419,18 +456,20 @@ class p3GroupDistrib: public CacheSource, public CacheStore, public p3Config, pu
* @param group should be called when duplicate message loaded * @param group should be called when duplicate message loaded
* @param the duplicate message * @param the duplicate message
* @param id * @param id
* @param historical: is this msg from an historical cache
* @return successfully executed or not * @return successfully executed or not
*/ */
virtual bool locked_eventDuplicateMsg(GroupInfo *, RsDistribMsg *, std::string id) = 0; virtual bool locked_eventDuplicateMsg(GroupInfo *, RsDistribMsg *, std::string id, bool historical) = 0;
/*! /*!
* Inheriting class should implement this as a response to a new msg arriving * Inheriting class should implement this as a response to a new msg arriving
* @param * @param
* @param * @param
* @param id src of msg (peer id) * @param id src of msg (peer id)
* @param historical: is this msg from an historical cache
* @return * @return
*/ */
virtual bool locked_eventNewMsg(GroupInfo *, RsDistribMsg *, std::string id) = 0; virtual bool locked_eventNewMsg(GroupInfo *, RsDistribMsg *, std::string id, bool historical) = 0;
/***************************************************************************************/ /***************************************************************************************/
/********************************* p3Config ********************************************/ /********************************* p3Config ********************************************/

24
libretroshare/src/services/p3forums.cc
View File

@ -542,7 +542,7 @@ bool p3Forums::getMessageCount(const std::string &fId, unsigned int &newCount, u
#include "pqi/pqinotify.h" #include "pqi/pqinotify.h"
void p3Forums::locked_notifyGroupChanged(GroupInfo &grp, uint32_t flags) void p3Forums::locked_notifyGroupChanged(GroupInfo &grp, uint32_t flags, bool historical)
{ {
const std::string &grpId = grp.grpId; const std::string &grpId = grp.grpId;
std::string msgId; std::string msgId;
@ -551,11 +551,17 @@ void p3Forums::locked_notifyGroupChanged(GroupInfo &grp, uint32_t flags)
switch(flags) switch(flags)
{ {
case GRP_NEW_UPDATE: case GRP_NEW_UPDATE:
getPqiNotify()->AddFeedItem(RS_FEED_ITEM_FORUM_NEW, grpId, msgId, nullId); if (!historical)
{
getPqiNotify()->AddFeedItem(RS_FEED_ITEM_FORUM_NEW, grpId, msgId, nullId);
}
rsicontrol->getNotify().notifyListChange(NOTIFY_LIST_FORUMLIST_LOCKED, NOTIFY_TYPE_ADD); rsicontrol->getNotify().notifyListChange(NOTIFY_LIST_FORUMLIST_LOCKED, NOTIFY_TYPE_ADD);
break; break;
case GRP_UPDATE: case GRP_UPDATE:
getPqiNotify()->AddFeedItem(RS_FEED_ITEM_FORUM_UPDATE, grpId, msgId, nullId); if (!historical)
{
getPqiNotify()->AddFeedItem(RS_FEED_ITEM_FORUM_UPDATE, grpId, msgId, nullId);
}
rsicontrol->getNotify().notifyListChange(NOTIFY_LIST_FORUMLIST_LOCKED, NOTIFY_TYPE_MOD); rsicontrol->getNotify().notifyListChange(NOTIFY_LIST_FORUMLIST_LOCKED, NOTIFY_TYPE_MOD);
break; break;
case GRP_LOAD_KEY: case GRP_LOAD_KEY:
@ -570,21 +576,25 @@ void p3Forums::locked_notifyGroupChanged(GroupInfo &grp, uint32_t flags)
rsicontrol->getNotify().notifyListChange(NOTIFY_LIST_FORUMLIST_LOCKED, NOTIFY_TYPE_DEL); rsicontrol->getNotify().notifyListChange(NOTIFY_LIST_FORUMLIST_LOCKED, NOTIFY_TYPE_DEL);
break; break;
} }
return p3GroupDistrib::locked_notifyGroupChanged(grp, flags); return p3GroupDistrib::locked_notifyGroupChanged(grp, flags, historical);
} }
bool p3Forums::locked_eventDuplicateMsg(GroupInfo *grp, RsDistribMsg *msg, std::string id) bool p3Forums::locked_eventDuplicateMsg(GroupInfo *grp, RsDistribMsg *msg, std::string id, bool historical)
{ {
return true; return true;
} }
bool p3Forums::locked_eventNewMsg(GroupInfo *grp, RsDistribMsg *msg, std::string id) bool p3Forums::locked_eventNewMsg(GroupInfo *grp, RsDistribMsg *msg, std::string id, bool historical)
{ {
std::string grpId = msg->grpId; std::string grpId = msg->grpId;
std::string msgId = msg->msgId; std::string msgId = msg->msgId;
std::string nullId; std::string nullId;
getPqiNotify()->AddFeedItem(RS_FEED_ITEM_FORUM_MSG, grpId, msgId, nullId); if (!historical)
{
getPqiNotify()->AddFeedItem(RS_FEED_ITEM_FORUM_MSG, grpId, msgId, nullId);
}
return true; return true;
} }

7
libretroshare/src/services/p3forums.h
View File

@ -67,10 +67,9 @@ virtual bool getMessageCount(const std::string &fId, unsigned int &newCount, uns
/****************** Event Feedback (Overloaded form p3distrib) *************************/ /****************** Event Feedback (Overloaded form p3distrib) *************************/
/***************************************************************************************/ /***************************************************************************************/
virtual void locked_notifyGroupChanged(GroupInfo &grp, uint32_t flags); virtual void locked_notifyGroupChanged(GroupInfo &grp, uint32_t flags, bool historical);
virtual bool locked_eventDuplicateMsg(GroupInfo *, RsDistribMsg *, std::string); virtual bool locked_eventDuplicateMsg(GroupInfo *, RsDistribMsg *, std::string, bool historical);
virtual bool locked_eventNewMsg(GroupInfo *, RsDistribMsg *, std::string); virtual bool locked_eventNewMsg(GroupInfo *, RsDistribMsg *, std::string, bool historical);
/****************************************/ /****************************************/

7
libretroshare/src/util/rsrandom.cc
View File

@ -10,9 +10,12 @@ RsMutex RSRandom::rndMtx ;
#ifdef WINDOWS_SYS #ifdef WINDOWS_SYS
static bool auto_seed = RSRandom::seed( (time(NULL) + ((uint32_t) pthread_self().p)*0x1293fe)^0x18e34a12 ) ; static bool auto_seed = RSRandom::seed( (time(NULL) + ((uint32_t) pthread_self().p)*0x1293fe)^0x18e34a12 ) ;
#else #else
static bool auto_seed = RSRandom::seed( (time(NULL) + pthread_self()*0x1293fe + (getpid()^0x113ef76b))^0x18e34a12 ) ; #ifdef __APPLE__
static bool auto_seed = RSRandom::seed( (time(NULL) + pthread_mach_thread_np(pthread_self())*0x1293fe + (getpid()^0x113ef76b))^0x18e34a12 ) ;
#else
static bool auto_seed = RSRandom::seed( (time(NULL) + pthread_self()*0x1293fe + (getpid()^0x113ef76b))^0x18e34a12 ) ;
#endif
#endif #endif
bool RSRandom::seed(uint32_t s) bool RSRandom::seed(uint32_t s)
{ {
RsStackMutex mtx(rndMtx) ; RsStackMutex mtx(rndMtx) ;