diff --git a/libretroshare/src/ft/ftserver.cc b/libretroshare/src/ft/ftserver.cc index ed53740b3..d2d8ff6dd 100644 --- a/libretroshare/src/ft/ftserver.cc +++ b/libretroshare/src/ft/ftserver.cc @@ -64,8 +64,8 @@ static const time_t FILE_TRANSFER_LOW_PRIORITY_TASKS_PERIOD = 5 ; // low priorit /* Setup */ ftServer::ftServer(p3PeerMgr *pm, p3LinkMgr *lm) - : p3Service(RS_SERVICE_TYPE_FILE_TRANSFER), - mPeerMgr(pm), + : p3Service(), + mPeerMgr(pm), mLinkMgr(lm), mCacheStrapper(NULL), mFiStore(NULL), mFiMon(NULL), @@ -77,6 +77,23 @@ ftServer::ftServer(p3PeerMgr *pm, p3LinkMgr *lm) addSerialType(new RsFileTransferSerialiser()) ; } +const std::string FILE_TRANSFER_APP_NAME = "ft"; +const uint16_t FILE_TRANSFER_APP_MAJOR_VERSION = 1; +const uint16_t FILE_TRANSFER_APP_MINOR_VERSION = 0; +const uint16_t FILE_TRANSFER_MIN_MAJOR_VERSION = 1; +const uint16_t FILE_TRANSFER_MIN_MINOR_VERSION = 0; + +RsServiceInfo ftServer::getServiceInfo() +{ + return RsServiceInfo(RS_SERVICE_TYPE_FILE_TRANSFER, + FILE_TRANSFER_APP_NAME, + FILE_TRANSFER_APP_MAJOR_VERSION, + FILE_TRANSFER_APP_MINOR_VERSION, + FILE_TRANSFER_MIN_MAJOR_VERSION, + FILE_TRANSFER_MIN_MINOR_VERSION); +} + + void ftServer::setConfigDirectory(std::string path) { mConfigPath = path; diff --git a/libretroshare/src/ft/ftserver.h b/libretroshare/src/ft/ftserver.h index 83bc84647..eddf0fab5 100644 --- a/libretroshare/src/ft/ftserver.h +++ b/libretroshare/src/ft/ftserver.h @@ -84,6 +84,7 @@ class ftServer: public p3Service, public RsFiles, public ftDataSend, public RsTu /***************************************************************/ ftServer(p3PeerMgr *peerMgr, p3LinkMgr *linkMgr); + virtual RsServiceInfo getServiceInfo(); /* Assign important variables */ void setConfigDirectory(std::string path); diff --git a/libretroshare/src/gxs/rsgenexchange.h b/libretroshare/src/gxs/rsgenexchange.h index 31ee789e4..9f3d77006 100644 --- a/libretroshare/src/gxs/rsgenexchange.h +++ b/libretroshare/src/gxs/rsgenexchange.h @@ -133,6 +133,11 @@ public: virtual ~RsGenExchange(); + // Convention that this is implemented here. + // and passes to network service. + virtual RsServiceInfo getServiceInfo() = 0; + + /** S: Observer implementation **/ /*! diff --git a/libretroshare/src/gxs/rsgxsnetservice.cc b/libretroshare/src/gxs/rsgxsnetservice.cc index 4439ee519..b1c1c8007 100644 --- a/libretroshare/src/gxs/rsgxsnetservice.cc +++ b/libretroshare/src/gxs/rsgxsnetservice.cc @@ -41,11 +41,14 @@ const uint32_t RsGxsNetService::FRAGMENT_SIZE = 150000; RsGxsNetService::RsGxsNetService(uint16_t servType, RsGeneralDataService *gds, - RsNxsNetMgr *netMgr, RsNxsObserver *nxsObs, RsGixsReputation* reputations, RsGcxs* circles, bool grpAutoSync) - : p3Config(servType), p3ThreadedService(servType), + RsNxsNetMgr *netMgr, RsNxsObserver *nxsObs, + const RsServiceInfo serviceInfo, + RsGixsReputation* reputations, RsGcxs* circles, bool grpAutoSync) + : p3Config(servType), p3ThreadedService(), mTransactionTimeOut(TRANSAC_TIMEOUT), mServType(servType), mDataStore(gds), mTransactionN(0), mObserver(nxsObs), mNxsMutex("RsGxsNetService"), mNetMgr(netMgr), mSYNC_PERIOD(SYNC_PERIOD), - mSyncTs(0), mReputations(reputations), mCircles(circles), mGrpAutoSync(grpAutoSync), mGrpServerUpdateItem(NULL) + mSyncTs(0), mReputations(reputations), mCircles(circles), mGrpAutoSync(grpAutoSync), mGrpServerUpdateItem(NULL), + mServiceInfo(serviceInfo) { addSerialType(new RsNxsSerialiser(mServType)); diff --git a/libretroshare/src/gxs/rsgxsnetservice.h b/libretroshare/src/gxs/rsgxsnetservice.h index e3dc860e2..c9c07cf33 100644 --- a/libretroshare/src/gxs/rsgxsnetservice.h +++ b/libretroshare/src/gxs/rsgxsnetservice.h @@ -73,11 +73,16 @@ public: * @param nxsObs observer will be notified whenever new messages/grps * arrive */ - RsGxsNetService(uint16_t servType, RsGeneralDataService* gds, RsNxsNetMgr* netMgr, - RsNxsObserver* nxsObs = NULL, RsGixsReputation* repuations = NULL, RsGcxs* circles = NULL, bool grpAutoSync = true); + RsGxsNetService(uint16_t servType, RsGeneralDataService *gds, + RsNxsNetMgr *netMgr, + RsNxsObserver *nxsObs, // used to be = NULL. + const RsServiceInfo serviceInfo, + RsGixsReputation* reputations = NULL, RsGcxs* circles = NULL, bool grpAutoSync = true); virtual ~RsGxsNetService(); + virtual RsServiceInfo getServiceInfo() { return mServiceInfo; } + public: @@ -452,6 +457,7 @@ private: ClientGrpMap mClientGrpUpdateMap; RsGxsServerGrpUpdateItem* mGrpServerUpdateItem; + RsServiceInfo mServiceInfo; }; #endif // RSGXSNETSERVICE_H diff --git a/libretroshare/src/libretroshare.pro b/libretroshare/src/libretroshare.pro index 46300b7f3..34f2cd969 100644 --- a/libretroshare/src/libretroshare.pro +++ b/libretroshare/src/libretroshare.pro @@ -119,7 +119,8 @@ PUBLIC_HEADERS = retroshare/rsdisc.h \ retroshare/rstypes.h \ retroshare/rsdht.h \ retroshare/rsrtt.h \ - retroshare/rsconfig.h + retroshare/rsconfig.h \ + retroshare/rsservicecontrol.h \ HEADERS += plugins/pluginmanager.h \ @@ -383,7 +384,8 @@ HEADERS += pqi/authssl.h \ pqi/pqithreadstreamer.h \ pqi/pqiqosstreamer.h \ pqi/sslfns.h \ - pqi/pqinetstatebox.h + pqi/pqinetstatebox.h \ + pqi/p3servicecontrol.h \ # pqi/p3dhtmgr.h \ @@ -410,7 +412,9 @@ HEADERS += serialiser/rsbaseserial.h \ serialiser/rstlvkeys.h \ serialiser/rstlvkvwide.h \ serialiser/rstlvtypes.h \ + serialiser/rstlvgenericparam.h \ serialiser/rstlvgenericmap.h \ + serialiser/rstlvgenericmap.inl \ serialiser/rstlvmaps.h \ serialiser/rstlvutil.h \ serialiser/rstlvbanlist.h \ @@ -420,7 +424,8 @@ HEADERS += serialiser/rsbaseserial.h \ serialiser/rsheartbeatitems.h \ serialiser/rsrttitems.h \ serialiser/rsgxsrecognitems.h \ - serialiser/rsgxsupdateitems.h + serialiser/rsgxsupdateitems.h \ + serialiser/rsserviceinfoitems.h \ HEADERS += services/p3chatservice.h \ services/p3msgservice.h \ @@ -431,6 +436,7 @@ HEADERS += services/p3chatservice.h \ services/p3discovery2.h \ services/p3heartbeat.h \ services/p3rtt.h \ + services/p3serviceinfo.cc \ HEADERS += turtle/p3turtle.h \ turtle/rsturtleitem.h \ @@ -509,7 +515,8 @@ SOURCES += pqi/authgpg.cc \ pqi/pqithreadstreamer.cc \ pqi/pqiqosstreamer.cc \ pqi/sslfns.cc \ - pqi/pqinetstatebox.cc + pqi/pqinetstatebox.cc \ + pqi/p3servicecontrol.cc \ # pqi/p3dhtmgr.cc \ @@ -545,7 +552,7 @@ SOURCES += serialiser/rsbaseserial.cc \ serialiser/rstlvkeys.cc \ serialiser/rstlvkvwide.cc \ serialiser/rstlvtypes.cc \ - serialiser/rstlvgenericmap.cc \ + serialiser/rstlvgenericparam.cc \ serialiser/rstlvutil.cc \ serialiser/rstlvbanlist.cc \ serialiser/rsbanlistitems.cc \ @@ -554,7 +561,8 @@ SOURCES += serialiser/rsbaseserial.cc \ serialiser/rsheartbeatitems.cc \ serialiser/rsrttitems.cc \ serialiser/rsgxsrecognitems.cc \ - serialiser/rsgxsupdateitems.cc + serialiser/rsgxsupdateitems.cc \ + serialiser/rsserviceinfoitems.cc \ SOURCES += services/p3chatservice.cc \ services/p3msgservice.cc \ @@ -565,6 +573,7 @@ SOURCES += services/p3chatservice.cc \ services/p3discovery2.cc \ services/p3heartbeat.cc \ services/p3rtt.cc \ + services/p3serviceinfo.cc \ SOURCES += turtle/p3turtle.cc \ turtle/rsturtleitem.cc diff --git a/libretroshare/src/plugins/pluginmanager.cc b/libretroshare/src/plugins/pluginmanager.cc index 31c2d157b..c1637746a 100644 --- a/libretroshare/src/plugins/pluginmanager.cc +++ b/libretroshare/src/plugins/pluginmanager.cc @@ -410,7 +410,7 @@ void RsPluginManager::registerClientServices(p3ServiceServer *pqih) for(uint32_t i=0;i<_plugins.size();++i) if(_plugins[i].plugin != NULL && _plugins[i].plugin->rs_pqi_service() != NULL) { - pqih->addService(_plugins[i].plugin->rs_pqi_service()) ; + pqih->addService(_plugins[i].plugin->rs_pqi_service(), true) ; std::cerr << " Added pqi service for plugin " << _plugins[i].plugin->getPluginName() << std::endl; } } @@ -534,7 +534,7 @@ RsCacheService::RsCacheService(uint16_t service_type,uint32_t config_type,uint32 } RsPQIService::RsPQIService(uint16_t service_type,uint32_t config_type,uint32_t /*tick_delay_in_seconds*/, RsPluginHandler* /*pgHandler*/) - : p3Service(service_type),p3Config(config_type) + : p3Service(),p3Config(config_type) { } diff --git a/libretroshare/src/pqi/p3servicecontrol.cc b/libretroshare/src/pqi/p3servicecontrol.cc new file mode 100644 index 000000000..29c2991f6 --- /dev/null +++ b/libretroshare/src/pqi/p3servicecontrol.cc @@ -0,0 +1,920 @@ +/* + * libretroshare/src/pqi: p3servicecontrol.cc + * + * 3P/PQI network interface for RetroShare. + * + * Copyright 2014 by Robert Fernie. + * + * 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.1 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 "retroshare@lunamutt.com". + * + */ + + +#include "p3servicecontrol.h" +#include "serialiser/rsserviceids.h" +#include "serialiser/rsserial.h" + +RsServiceControl *rsServiceControl = NULL; + +p3ServiceControl::p3ServiceControl(uint32_t configId) + :RsServiceControl(), /* p3Config(configId), pqiMonitor(), */ + mCtrlMtx("p3ServiceControl") +{ +} + +/* Interface for Services */ +bool p3ServiceControl::registerService(const RsServiceInfo &info, bool defaultOn) +{ + RsStackMutex stack(mCtrlMtx); /***** LOCK STACK MUTEX ****/ + + std::map::iterator it; + it = mOwnServices.find(info.mServiceType); + if (it != mOwnServices.end()) + { + std::cerr << "p3ServiceControl::registerService() ERROR Duplicate Service ID"; + std::cerr << std::endl; + return false; + } + + /* sanity check ServiceInfo */ + mOwnServices[info.mServiceType] = info; + + std::cerr << "p3ServiceControl::registerService() Registered ServiceID: " << info.mServiceType; + std::cerr << std::endl; + std::cerr << "p3ServiceControl::registerService() ServiceName: " << info.mServiceName; + std::cerr << std::endl; + + + /* create default permissions for this service + * this will be overwritten by configuration (if it exists). + */ + + createDefaultPermissions_locked(info.mServiceType, info.mServiceName, defaultOn); + return true; +} + +bool p3ServiceControl::deregisterService(uint32_t serviceId) +{ + RsStackMutex stack(mCtrlMtx); /***** LOCK STACK MUTEX ****/ + + std::map::iterator it; + it = mOwnServices.find(serviceId); + if (it == mOwnServices.end()) + { + std::cerr << "p3ServiceControl::deregisterService() ERROR No matching Service ID"; + std::cerr << std::endl; + return false; + } + + std::cerr << "p3ServiceControl::deregisterService() Removed ServiceID: " << serviceId; + std::cerr << std::endl; + mOwnServices.erase(it); + return true; +} + + +/* Interface for Services */ +bool p3ServiceControl::registerServiceMonitor(pqiServiceMonitor *monitor, uint32_t serviceId) +{ + RsStackMutex stack(mCtrlMtx); /***** LOCK STACK MUTEX ****/ + + std::cerr << "p3ServiceControl::registerServiceMonitor() for ServiceId: "; + std::cerr << serviceId; + std::cerr << std::endl; + + mMonitors.insert(std::make_pair(serviceId, monitor)); + return true; +} + + +bool p3ServiceControl::deregisterServiceMonitor(pqiServiceMonitor *monitor) +{ + RsStackMutex stack(mCtrlMtx); /***** LOCK STACK MUTEX ****/ + + std::cerr << "p3ServiceControl::deregisterServiceMonitor()"; + std::cerr << std::endl; + + std::multimap::iterator it; + for(it = mMonitors.begin(); it != mMonitors.end(); ) + { + if (it->second == monitor) + { + mMonitors.erase(it++); + } + else + { + ++it; + } + } + return true; +} + +/* Interface to p3ServiceInfo */ +void p3ServiceControl::getServiceChanges(std::set &updateSet) +{ + RsStackMutex stack(mCtrlMtx); /***** LOCK STACK MUTEX ****/ + + std::cerr << "p3ServiceControl::getServiceChanges()"; + std::cerr << std::endl; + + std::set::iterator it; + for (it = mUpdatedSet.begin(); it != mUpdatedSet.end(); it++) + { + updateSet.insert(*it); + } + + mUpdatedSet.clear(); +} + + +bool p3ServiceControl::getServicesAllowed(const RsPeerId &peerId, RsPeerServiceInfo &info) +{ + std::cerr << "p3ServiceControl::getServicesAllowed(" << peerId.toStdString() << ")"; + std::cerr << std::endl; + + RsStackMutex stack(mCtrlMtx); /***** LOCK STACK MUTEX ****/ + + info.mPeerId = peerId; + + // For each registered Service.. check if peer has permissions. + std::map::iterator it; + for(it = mOwnServices.begin(); it != mOwnServices.end(); it++) + { + if (peerHasPermissionForService_locked(peerId, it->first)) + { + info.mServiceList[it->first] = it->second; + } + } + return true; +} + +bool p3ServiceControl::peerHasPermissionForService_locked(const RsPeerId &peerId, uint32_t serviceId) +{ + std::cerr << "p3ServiceControl::peerHasPermissionForService_locked()"; + std::cerr << std::endl; + + std::map::iterator it; + it = mServicePermissionMap.find(serviceId); + if (it == mServicePermissionMap.end()) + { + return false; + } + return it->second.peerHasPermission(peerId); +} + +// This is used by both RsServiceControl and p3ServiceInfo. +bool p3ServiceControl::getServicesProvided(const RsPeerId &peerId, RsPeerServiceInfo &info) +{ + RsStackMutex stack(mCtrlMtx); /***** LOCK STACK MUTEX ****/ + + std::cerr << "p3ServiceControl::getServicesProvided()"; + std::cerr << std::endl; + + std::map::iterator it; + it = mServicesProvided.find(peerId); + if (it == mServicesProvided.end()) + { + return false; + } + + info = it->second; + return true; +} + +bool p3ServiceControl::updateServicesProvided(const RsPeerId &peerId, const RsPeerServiceInfo &info) +{ + RsStackMutex stack(mCtrlMtx); /***** LOCK STACK MUTEX ****/ + + std::cerr << "p3ServiceControl::updateServicesProvided() from: " << peerId.toStdString(); + std::cerr << std::endl; + + std::cerr << info; + std::cerr << std::endl; + + mServicesProvided[peerId] = info; + updateFilterByPeer_locked(peerId); + return true; +} + +/* External Interface to RsServiceControl */ +bool p3ServiceControl::getServicePermissions(uint32_t serviceId, RsServicePermissions &permissions) +{ + RsStackMutex stack(mCtrlMtx); /***** LOCK STACK MUTEX ****/ + + std::cerr << "p3ServiceControl::getServicePermissions()"; + std::cerr << std::endl; + + std::map::iterator it; + + it = mServicePermissionMap.find(serviceId); + if (it == mServicePermissionMap.end()) + { + return false; + } + permissions = it->second; + return true; +} + +bool p3ServiceControl::createDefaultPermissions_locked(uint32_t serviceId, std::string serviceName, bool defaultOn) +{ + std::map::iterator it; + it = mServicePermissionMap.find(serviceId); + if (it == mServicePermissionMap.end()) + { + RsServicePermissions perms; + perms.mServiceId = serviceId; + perms.mServiceName = serviceName; + perms.mDefaultAllowed = defaultOn; + + mServicePermissionMap[serviceId] = perms; + return true; + } + return false; +} + + +bool p3ServiceControl::updateServicePermissions(uint32_t serviceId, const RsServicePermissions &permissions) +{ + RsStackMutex stack(mCtrlMtx); /***** LOCK STACK MUTEX ****/ + + std::cerr << "p3ServiceControl::updateServicePermissions()"; + std::cerr << std::endl; + + std::map::iterator it; + it = mServicePermissionMap.find(serviceId); + + + /* here we have to check which peers - permissions have changed for, + * and flag for updates. + * + * This is far more complex. + * need to check if versions are compatible and peers are providing service. + */ +#if 0 + std::list onlinePeers; + std::list::const_iterator pit; + if (it != mServicePermissionMap.end()) + { + for(pit = onlinePeers.begin(); pit != onlinePeers.end(); pit++) + { + if (it->second.peerHasPermission(*pit) != + permissions.peerHasPermission(*pit)) + { + mUpdatedSet.insert(*pit); + } + } + } + else + { + // ERROR! + it = mServicePermissionMap.find[serviceId]; + for(pit = onlinePeers.begin(); pit != onlinePeers.end(); pit++) + { + mUpdatedSet.insert(*pit); + } + } +#endif + + it->second = permissions; + it->second.mServiceId = serviceId; // just to make sure! + return true; +} + + +/****************************************************************************/ +/****************************************************************************/ +/****************************************************************************/ +/****************************************************************************/ + +// This is the basic system... +// which will be a little slow (2x maps). +// +// Potential improvement is to push the RsPeerFilter +// to the pqiStreamer, (when items have been sorted by peers already!). +// but we will do this later. + +bool p3ServiceControl::checkFilter(uint32_t serviceId, const RsPeerId &peerId) +{ + RsStackMutex stack(mCtrlMtx); /***** LOCK STACK MUTEX ****/ + + std::cerr << "p3ServiceControl::checkFilter() "; + std::cerr << " ServiceId: " << serviceId; + + std::map::iterator it; + it = mOwnServices.find(serviceId); + if (it != mOwnServices.end()) + { + std::cerr << " ServiceName: " << it->second.mServiceName; + } + else + { + std::cerr << " ServiceName: Unknown! "; + } + + std::cerr << " PeerId: " << peerId.toStdString(); + std::cerr << std::endl; + + // must allow ServiceInfo through, or we have nothing! +#define FULLID_SERVICEINFO ((((uint32_t) RS_PKT_VERSION_SERVICE) << 24) + ((RS_SERVICE_TYPE_SERVICEINFO) << 8)) + + //if (serviceId == RS_SERVICE_TYPE_SERVICEINFO) + if (serviceId == FULLID_SERVICEINFO) + { + std::cerr << "p3ServiceControl::checkFilter() Allowed SERVICEINFO"; + std::cerr << std::endl; + return true; + } + + + std::map::const_iterator pit; + pit = mPeerFilterMap.find(peerId); + if (pit == mPeerFilterMap.end()) + { + std::cerr << "p3ServiceControl::checkFilter() Denied No PeerId"; + std::cerr << std::endl; + return false; + } + + if (pit->second.mDenyAll) + { + std::cerr << "p3ServiceControl::checkFilter() Denied Peer.DenyAll"; + std::cerr << std::endl; + return false; + } + + if (pit->second.mAllowAll) + { + std::cerr << "p3ServiceControl::checkFilter() Allowed Peer.AllowAll"; + std::cerr << std::endl; + return true; + } + + std::set::const_iterator sit; + sit = pit->second.mAllowedServices.find(serviceId); + if (sit == pit->second.mAllowedServices.end()) + { + std::cerr << "p3ServiceControl::checkFilter() Denied !Peer.find(serviceId)"; + std::cerr << std::endl; + return false; + } + std::cerr << "p3ServiceControl::checkFilter() Allowed Peer.find(serviceId)"; + std::cerr << std::endl; + return true; +} + +bool versionOkay(uint16_t version_major, uint16_t version_minor, + uint16_t min_version_major, uint16_t min_version_minor) +{ + if (version_major > min_version_major) + { + return true; + } + if (version_major == min_version_major) + { + return (version_minor >= min_version_minor); + } + return false; +} + + +bool servicesCompatible(const RsServiceInfo &info1, const RsServiceInfo &info2) +{ + // Id, or Name mismatch. + if ((info1.mServiceType != info2.mServiceType) || + (info1.mServiceName != info2.mServiceName)) + { + std::cerr << "servicesCompatible: Type/Name mismatch"; + std::cerr << std::endl; + std::cerr << "Info1 ID: " << info1.mServiceType; + std::cerr << " " << info1.mServiceName; + std::cerr << std::endl; + std::cerr << "Info2 ID: " << info2.mServiceType; + std::cerr << " " << info2.mServiceName; + std::cerr << std::endl; + return false; + } + + // ensure that info1 meets minimum requirements for info2 + if (!versionOkay(info1.mVersionMajor, info1.mVersionMinor, + info2.mMinVersionMajor, info2.mMinVersionMinor)) + { + return false; + } + + // ensure that info2 meets minimum requirements for info1 + if (!versionOkay(info2.mVersionMajor, info2.mVersionMinor, + info1.mMinVersionMajor, info1.mMinVersionMinor)) + { + return false; + } + return true; +} + + +bool p3ServiceControl::updateFilterByPeer(const RsPeerId &peerId) +{ + std::cerr << "p3ServiceControl::updateFilterByPeer()"; + std::cerr << std::endl; + + RsStackMutex stack(mCtrlMtx); /***** LOCK STACK MUTEX ****/ + return updateFilterByPeer_locked(peerId); +} + + +bool p3ServiceControl::updateAllFilters() +{ + std::cerr << "p3ServiceControl::updateAllFilters()"; + std::cerr << std::endl; + + RsStackMutex stack(mCtrlMtx); /***** LOCK STACK MUTEX ****/ + + // Create a peerSet from ServicesProvided + PeerFilters. + // This will completely refresh the Filters. + std::set peerSet; + std::set::const_iterator pit; + + std::map::const_iterator it; + for(it = mServicesProvided.begin(); it != mServicesProvided.end(); it++) + { + peerSet.insert(it->first); + } + + std::map::const_iterator fit; + for(fit = mPeerFilterMap.begin(); fit != mPeerFilterMap.end(); fit++) + { + peerSet.insert(fit->first); + } + + for(pit = peerSet.begin(); pit != peerSet.end(); pit++) + { + updateFilterByPeer_locked(*pit); + } + return true; +} + + +// create filter. (the easy way). +bool p3ServiceControl::updateFilterByPeer_locked(const RsPeerId &peerId) +{ + std::cerr << "p3ServiceControl::updateFilterByPeer_locked() : " << peerId.toStdString(); + std::cerr << std::endl; + + ServicePeerFilter originalFilter; + ServicePeerFilter peerFilter; + + std::map::iterator fit; + fit = mPeerFilterMap.find(peerId); + if (fit != mPeerFilterMap.end()) + { + originalFilter = fit->second; + } + + std::map::iterator it; + it = mServicesProvided.find(peerId); + if (it == mServicesProvided.end()) + { + std::cerr << "p3ServiceControl::updateFilterByPeer_locked() Empty ... Clearing"; + std::cerr << std::endl; + + // empty, remove... + recordFilterChanges_locked(peerId, originalFilter, peerFilter); + if (fit != mPeerFilterMap.end()) + { + std::cerr << std::endl; + mPeerFilterMap.erase(fit); + } + return true; + } + + // For each registered Service.. check if services compatible. + // then check for permissions. + + // similar maps, can iterate through in parallel. + std::map::const_iterator oit = mOwnServices.begin(); + std::map::const_iterator eoit = mOwnServices.end(); + std::map::const_iterator tit = it->second.mServiceList.begin(); + std::map::const_iterator etit = it->second.mServiceList.end(); + + std::cerr << "p3ServiceControl::updateFilterByPeer_locked() Comparing lists"; + std::cerr << std::endl; + + + while((oit != eoit) && (tit != etit)) + { + if (oit->first == tit->first) + { + std::cerr << "\tChecking Matching Service ID: " << oit->first; + std::cerr << std::endl; + /* match of service IDs */ + /* check if compatible */ + if (servicesCompatible(oit->second, tit->second)) + { + if (peerHasPermissionForService_locked(peerId, oit->first)) + { + std::cerr << "\t\tMatched Service ID: " << oit->first; + std::cerr << std::endl; + peerFilter.mAllowedServices.insert(oit->first); + } + } + oit++; + tit++; + } + else + { + if (oit->first < tit->first) + { + std::cerr << "\tSkipping Only Own Service ID: " << oit->first; + std::cerr << std::endl; + oit++; + } + else + { + std::cerr << "\tSkipping Only Peer Service ID: " << tit->first; + std::cerr << std::endl; + tit++; + } + } + } + + // small optimisations. + if (peerFilter.mAllowedServices.empty()) + { + peerFilter.mDenyAll = true; + } + else + { + peerFilter.mDenyAll = false; + if (peerFilter.mAllowedServices.size() == mOwnServices.size()) + { + peerFilter.mAllowAll = true; + } + } + + // update or remove. + if (peerFilter.mDenyAll) + { + std::cerr << "p3ServiceControl::updateFilterByPeer_locked() Empty(2) ... Clearing"; + std::cerr << std::endl; + + if (fit != mPeerFilterMap.end()) + { + mPeerFilterMap.erase(fit); + } + } + else + { + std::cerr << "p3ServiceControl::updateFilterByPeer_locked() Installing PeerFilter"; + std::cerr << std::endl; + mPeerFilterMap[peerId] = peerFilter; + } + recordFilterChanges_locked(peerId, originalFilter, peerFilter); + return true; +} + +void p3ServiceControl::recordFilterChanges_locked(const RsPeerId &peerId, + ServicePeerFilter &originalFilter, ServicePeerFilter &updatedFilter) +{ + std::cerr << "p3ServiceControl::recordFilterChanges_locked()"; + std::cerr << std::endl; + std::cerr << "PeerId: " << peerId.toStdString(); + std::cerr << std::endl; + std::cerr << "OriginalFilter: " << originalFilter; + std::cerr << std::endl; + std::cerr << "UpdatedFilter: " << updatedFilter; + std::cerr << std::endl; + + /* find differences */ + std::map changes; + std::set::const_iterator it1, it2, eit1, eit2; + it1 = originalFilter.mAllowedServices.begin(); + eit1 = originalFilter.mAllowedServices.end(); + it2 = updatedFilter.mAllowedServices.begin(); + eit2 = updatedFilter.mAllowedServices.end(); + + while((it1 != eit1) && (it2 != eit2)) + { + if (*it1 < *it2) + { + std::cerr << "Removed Service: " << *it1; + std::cerr << std::endl; + // removal + changes[*it1] = false; + ++it1; + } + else if (*it2 < *it1) + { + std::cerr << "Added Service: " << *it2; + std::cerr << std::endl; + // addition. + changes[*it2] = true; + ++it2; + } + else + { + ++it1; + ++it2; + } + } + + // Handle the unfinished Set. + for(; it1 != eit1; it1++) + { + std::cerr << "Removed Service: " << *it1; + std::cerr << std::endl; + // removal + changes[*it1] = false; + } + + for(; it2 != eit2; it2++) + { + std::cerr << "Added Service: " << *it2; + std::cerr << std::endl; + // addition. + changes[*it2] = true; + } + + // now we to store for later notifications. + std::map::const_iterator cit; + for(cit = changes.begin(); cit != changes.end(); cit++) + { + ServiceNotifications ¬es = mNotifications[cit->first]; + if (cit->second) + { + notes.mAdded.insert(peerId); + } + else + { + notes.mRemoved.insert(peerId); + } + } +} + + +// when they go offline, etc. +void p3ServiceControl::removePeer(const RsPeerId &peerId) +{ + RsStackMutex stack(mCtrlMtx); /***** LOCK STACK MUTEX ****/ + + std::cerr << "p3ServiceControl::removePeer()"; + std::cerr << std::endl; + + ServicePeerFilter originalFilter; + bool hadFilter = false; + { + std::map::iterator fit; + fit = mPeerFilterMap.find(peerId); + if (fit != mPeerFilterMap.end()) + { + hadFilter = true; + originalFilter = fit->second; + mPeerFilterMap.erase(fit); + } + } + + { + std::map::iterator sit; + sit = mServicesProvided.find(peerId); + if (sit != mServicesProvided.end()) + { + mServicesProvided.erase(sit); + } + } + + if (hadFilter) + { + ServicePeerFilter emptyFilter; + recordFilterChanges_locked(peerId, originalFilter, emptyFilter); + } +} + + +/****************************************************************************/ +/****************************************************************************/ + +void p3ServiceControl::tick() +{ + std::cerr << "p3ServiceControl::tick()"; + std::cerr << std::endl; +} + +// configuration. +bool p3ServiceControl::saveList(bool &cleanup, std::list &saveList) +{ + std::cerr << "p3ServiceControl::saveList()"; + std::cerr << std::endl; + + return true; +} + +bool p3ServiceControl::loadList(std::list& loadList) +{ + std::cerr << "p3ServiceControl::loadList()"; + std::cerr << std::endl; + + return true; +} + + +/****************************************************************************/ +/****************************************************************************/ + + // pqiMonitor. +void p3ServiceControl::statusChange(const std::list &plist) +{ + std::cerr << "p3ServiceControl::statusChange()"; + std::cerr << std::endl; + + std::list::const_iterator pit; + for(pit = plist.begin(); pit != plist.end(); pit++) + { + if (pit->state & RS_PEER_S_FRIEND) + { + if (pit->actions & RS_PEER_CONNECTED) + { + updatePeerConnect(pit->id); + } + else if (pit->actions & RS_PEER_DISCONNECTED) + { + updatePeerDisconnect(pit->id); + } + } + } + return; +} + +// Update Peer status. +void p3ServiceControl::updatePeerConnect(const RsPeerId &peerId) +{ + std::cerr << "p3ServiceControl::updatePeerConnect(): " << peerId.toStdString(); + std::cerr << std::endl; + return; +} + +void p3ServiceControl::updatePeerDisconnect(const RsPeerId &peerId) +{ + std::cerr << "p3ServiceControl::updatePeerDisconnect(): " << peerId.toStdString(); + std::cerr << std::endl; + + removePeer(peerId); + return; +} + +/****************************************************************************/ +/****************************************************************************/ + +void p3ServiceControl::notifyServices() +{ + RsStackMutex stack(mCtrlMtx); /***** LOCK STACK MUTEX ****/ + + std::map::const_iterator it; + std::multimap::const_iterator sit, eit; + for(it = mNotifications.begin(); it != mNotifications.end(); it++) + { + sit = mMonitors.lower_bound(it->first); + eit = mMonitors.upper_bound(it->first); + if (sit == eit) + { + /* nothing to notify - skip */ + continue; + } + + std::list peers; + std::set::const_iterator pit; + for(pit = it->second.mAdded.begin(); + pit != it->second.mAdded.end(); pit++) + { + pqiServicePeer peer; + peer.id = *pit; + peer.actions = RS_SERVICE_PEER_CONNECTED; + + peers.push_back(peer); + } + + for(pit = it->second.mRemoved.begin(); + pit != it->second.mRemoved.end(); pit++) + { + pqiServicePeer peer; + peer.id = *pit; + peer.actions = RS_SERVICE_PEER_REMOVED; + + peers.push_back(peer); + } + + for(; sit != eit; sit++) + { + sit->second->statusChange(peers); + } + } + mNotifications.clear(); +} + + +/****************************************************************************/ +/****************************************************************************/ + + +RsServicePermissions::RsServicePermissions() +:mServiceId(0), mServiceName(), mDefaultAllowed(false) +{ + return; +} + +bool RsServicePermissions::peerHasPermission(const RsPeerId &peerId) const +{ + std::cerr << "RsServicePermissions::peerHasPermission()"; + std::cerr << std::endl; + + std::set::const_iterator it; + if (mDefaultAllowed) + { + it = mPeersDenied.find(peerId); + return (it == mPeersDenied.end()); + } + else + { + it = mPeersAllowed.find(peerId); + return (it != mPeersAllowed.end()); + } +} + +RsServiceInfo::RsServiceInfo( + const uint16_t service_type, + const std::string service_name, + const uint16_t version_major, + const uint16_t version_minor, + const uint16_t min_version_major, + const uint16_t min_version_minor) + :mServiceName(service_name), + mServiceType((((uint32_t) RS_PKT_VERSION_SERVICE) << 24) + (((uint32_t) service_type) << 8)), + mVersionMajor(version_major), + mVersionMinor(version_minor), + mMinVersionMajor(min_version_major), + mMinVersionMinor(min_version_minor) +{ + return; +} + + +RsServiceInfo::RsServiceInfo() + :mServiceName("unknown"), + mServiceType(0), + mVersionMajor(0), + mVersionMinor(0), + mMinVersionMajor(0), + mMinVersionMinor(0) +{ + return; +} + +std::ostream &operator<<(std::ostream &out, const RsPeerServiceInfo &info) +{ + out << "RsPeerServiceInfo(" << info.mPeerId << ")"; + out << std::endl; + std::map::const_iterator it; + for(it = info.mServiceList.begin(); it != info.mServiceList.end(); it++) + { + out << "\t Service:" << it->first << " : "; + out << it->second; + out << std::endl; + } + return out; +} + + +std::ostream &operator<<(std::ostream &out, const RsServiceInfo &info) +{ + out << "RsServiceInfo(" << info.mServiceType << "): " << info.mServiceName; + out << " Version(" << info.mVersionMajor << "," << info.mVersionMinor << ")"; + out << " MinVersion(" << info.mMinVersionMajor << "," << info.mMinVersionMinor << ")"; + return out; +} + +std::ostream &operator<<(std::ostream &out, const ServicePeerFilter &filter) +{ + out << "ServicePeerFilter DenyAll: " << filter.mDenyAll; + out << " AllowAll: " << filter.mAllowAll; + out << " Matched Services: "; + std::set::const_iterator it; + for(it = filter.mAllowedServices.begin(); it != filter.mAllowedServices.end(); it++) + { + out << *it << " "; + } + out << std::endl; + return out; +} + + diff --git a/libretroshare/src/pqi/p3servicecontrol.h b/libretroshare/src/pqi/p3servicecontrol.h new file mode 100644 index 000000000..068fa9518 --- /dev/null +++ b/libretroshare/src/pqi/p3servicecontrol.h @@ -0,0 +1,163 @@ +/* + * libretroshare/src/pqi: p3servicecontrol.h + * + * 3P/PQI network interface for RetroShare. + * + * Copyright 2014 by Robert Fernie. + * + * 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.1 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 "retroshare@lunamutt.com". + * + */ + + +#ifndef P3_SERVICE_CONTROL_HEADER +#define P3_SERVICE_CONTROL_HEADER + +#include +#include + +#include "retroshare/rsservicecontrol.h" +#include "pqi/p3cfgmgr.h" +#include "pqi/pqimonitor.h" +#include "pqi/pqiservicemonitor.h" + +class ServiceNotifications +{ + public: + std::set mAdded; + std::set mRemoved; +}; + +class ServicePeerFilter +{ + public: + ServicePeerFilter() + :mDenyAll(true), mAllowAll(false) {} + + bool mDenyAll; + bool mAllowAll; + std::set mAllowedServices; +}; + +std::ostream &operator<<(std::ostream &out, const ServicePeerFilter &filter); + +class p3ServiceControl: public RsServiceControl /* , public p3Config, public pqiMonitor */ +{ +public: + + /** + */ + p3ServiceControl(uint32_t configId); + + /** + * checks and update all added configurations + * @see rsserver + */ + void tick(); + + /** + * External Interface (RsServiceControl). + */ + + // This is what is passed to peers, can be displayed by GUI too. +virtual bool getServicesAllowed(const RsPeerId &peerId, RsPeerServiceInfo &info); + + // Information provided by peer. +virtual bool getServicesProvided(const RsPeerId &peerId, RsPeerServiceInfo &info); + + // Main Permission Interface. +virtual bool getServicePermissions(uint32_t serviceId, RsServicePermissions &permissions); +virtual bool updateServicePermissions(uint32_t serviceId, const RsServicePermissions &permissions); + + /** + * Registration for all Services. + */ + +virtual bool registerService(const RsServiceInfo &info, bool defaultOn); +virtual bool deregisterService(uint32_t serviceId); + +virtual bool registerServiceMonitor(pqiServiceMonitor *monitor, uint32_t serviceId); +virtual bool deregisterServiceMonitor(pqiServiceMonitor *monitor); + + /** + * + */ + + + // Filter for services. +virtual bool checkFilter(uint32_t serviceId, const RsPeerId &peerId); + + /** + * Interface for ServiceInfo service. + */ + + // ServicesAllowed have changed for these peers. +virtual void getServiceChanges(std::set &updateSet); + + // Input from peers. +virtual bool updateServicesProvided(const RsPeerId &peerId, const RsPeerServiceInfo &info); + + // pqiMonitor. +virtual void statusChange(const std::list &plist); + +protected: + // configuration. +virtual bool saveList(bool &cleanup, std::list&); +virtual bool loadList(std::list& load); + +private: + +void notifyServices(); + +bool createDefaultPermissions_locked(uint32_t serviceId, std::string serviceName, bool defaultOn); + +bool updateAllFilters(); +bool updateFilterByPeer(const RsPeerId &peerId); +bool updateFilterByPeer_locked(const RsPeerId &peerId); + +void removePeer(const RsPeerId &peerId); + +void recordFilterChanges_locked(const RsPeerId &peerId, + ServicePeerFilter &originalFilter, ServicePeerFilter &updatedFilter); + +void updatePeerConnect(const RsPeerId &peerId); +void updatePeerDisconnect(const RsPeerId &peerId); + + +bool peerHasPermissionForService_locked(const RsPeerId &peerId, uint32_t serviceId); + + + RsMutex mCtrlMtx; /* below is protected */ + + std::set mUpdatedSet; + + // From registration / deregistration. + std::map mOwnServices; + // From peers. + std::map mServicesProvided; + // derived from all the others. + std::map mPeerFilterMap; + + // Below here is saved in Configuration. + std::map mServicePermissionMap; + + std::multimap mMonitors; + std::map mNotifications; +}; + + +#endif // P3_SERVICE_CONTROL_HEADER diff --git a/libretroshare/src/pqi/pqihandler.cc b/libretroshare/src/pqi/pqihandler.cc index 0269f1954..527131883 100644 --- a/libretroshare/src/pqi/pqihandler.cc +++ b/libretroshare/src/pqi/pqihandler.cc @@ -300,6 +300,12 @@ int pqihandler::SendRsRawItem(RsRawItem *ns) // system that is completely biased and slow... // someone please fix. +///////////////////////////////////////////////////////////////////////// +///////////////////////////////////////////////////////////////////////// +// THIS CODE SHOULD BE ABLE TO BE REMOVED! +///////////////////////////////////////////////////////////////////////// +///////////////////////////////////////////////////////////////////////// + int pqihandler::locked_GetItems() { std::map::iterator it; @@ -319,6 +325,11 @@ int pqihandler::locked_GetItems() // if yes... attempt to read. while((item = (mod -> pqi) -> GetItem()) != NULL) { + + std::cerr << "pqihandler::locked_GetItems() pqi->GetItem()"; + std::cerr << " should never happen anymore!"; + std::cerr << std::endl; + #ifdef RSITEM_DEBUG std::string out; rs_sprintf(out, "pqihandler::GetItems() Incoming Item from: %p\n", mod -> pqi); @@ -407,6 +418,13 @@ RsRawItem *pqihandler::GetRsRawItem() return NULL; } +///////////////////////////////////////////////////////////////////////// +///////////////////////////////////////////////////////////////////////// +// ABOVE CODE SHOULD BE ABLE TO BE REMOVED! +///////////////////////////////////////////////////////////////////////// +///////////////////////////////////////////////////////////////////////// + + static const float MIN_RATE = 0.01; // 10 B/s // NEW extern fn to extract rates. diff --git a/libretroshare/src/pqi/pqipersongrp.cc b/libretroshare/src/pqi/pqipersongrp.cc index 7ec84d100..3d61d09d2 100644 --- a/libretroshare/src/pqi/pqipersongrp.cc +++ b/libretroshare/src/pqi/pqipersongrp.cc @@ -83,6 +83,10 @@ int pqipersongrp::tickServiceRecv() while(NULL != (pqi = GetRsRawItem())) { + std::cerr << "pqipersongrp::tickServiceRecv() GetRsRawItem()"; + std::cerr << " should never happen anymore!"; + std::cerr << std::endl; + ++i; pqioutput(PQL_DEBUG_BASIC, pqipersongrpzone, "pqipersongrp::tickServiceRecv() Incoming TunnelItem"); @@ -130,8 +134,8 @@ int pqipersongrp::tickServiceSend() // init -pqipersongrp::pqipersongrp(SecurityPolicy *glob, unsigned long flags) - :pqihandler(glob), p3ServiceServer(this), pqil(NULL), initFlags(flags) +pqipersongrp::pqipersongrp(p3ServiceControl *ctrl, SecurityPolicy *glob, unsigned long flags) + :pqihandler(glob), p3ServiceServer(this, ctrl), pqil(NULL), initFlags(flags) { } diff --git a/libretroshare/src/pqi/pqipersongrp.h b/libretroshare/src/pqi/pqipersongrp.h index 1b7f50df3..0af97de80 100644 --- a/libretroshare/src/pqi/pqipersongrp.h +++ b/libretroshare/src/pqi/pqipersongrp.h @@ -50,7 +50,7 @@ class RsPeerCryptoParams ; class pqipersongrp: public pqihandler, public pqiMonitor, public p3ServiceServer, public pqiNetListener { public: - pqipersongrp(SecurityPolicy *, unsigned long flags); + pqipersongrp(p3ServiceControl *ctrl, SecurityPolicy *, unsigned long flags); /*************************** Setup *************************/ /* pqilistener */ @@ -129,8 +129,8 @@ virtual int checkOutgoingRsItem(RsItem *item, int global) class pqipersongrpDummy: public pqipersongrp { public: - pqipersongrpDummy(SecurityPolicy *pol, unsigned long flags) - :pqipersongrp(pol, flags) { return; } + pqipersongrpDummy(p3ServiceControl *ctrl, SecurityPolicy *pol, unsigned long flags) + :pqipersongrp(ctrl, pol, flags) { return; } protected: diff --git a/libretroshare/src/pqi/pqiservice.cc b/libretroshare/src/pqi/pqiservice.cc index 360ba900f..7360e8271 100644 --- a/libretroshare/src/pqi/pqiservice.cc +++ b/libretroshare/src/pqi/pqiservice.cc @@ -44,7 +44,7 @@ bool pqiService::send(RsRawItem *item) } -p3ServiceServer::p3ServiceServer(pqiPublisher *pub) : mPublisher(pub), srvMtx("p3ServiceServer") +p3ServiceServer::p3ServiceServer(pqiPublisher *pub, p3ServiceControl *ctrl) : mPublisher(pub), mServiceControl(ctrl), srvMtx("p3ServiceServer") { RsStackMutex stack(srvMtx); /********* LOCKED *********/ @@ -56,7 +56,7 @@ p3ServiceServer::p3ServiceServer(pqiPublisher *pub) : mPublisher(pub), srvMtx("p return; } -int p3ServiceServer::addService(pqiService *ts) +int p3ServiceServer::addService(pqiService *ts, bool defaultOn) { RsStackMutex stack(srvMtx); /********* LOCKED *********/ @@ -65,18 +65,21 @@ int p3ServiceServer::addService(pqiService *ts) "p3ServiceServer::addService()"); #endif - + RsServiceInfo info = ts->getServiceInfo(); std::map::iterator it; - it = services.find(ts -> getType()); + it = services.find(info.mServiceType); if (it != services.end()) { - std::cerr << "p3ServiceServer::addService(): Service already added with id " << ts->getType() << "!" << std::endl; + std::cerr << "p3ServiceServer::addService(): Service already added with id " << info.mServiceType << "!" << std::endl; // it exists already! return -1; } ts->setServiceServer(this); - services[ts -> getType()] = ts; + services[info.mServiceType] = ts; + + // This doesn't need to be in Mutex. + mServiceControl->registerService(info, defaultOn); return 1; } @@ -97,6 +100,16 @@ bool p3ServiceServer::recvItem(RsRawItem *item) } #endif + // Packet Filtering. + // This doesn't need to be in Mutex. + if (!mServiceControl->checkFilter(item->PacketId() & 0xffffff00, item->PeerId())) + { + std::cerr << "p3ServiceServer::recvItem() Fails Filtering"; + delete item; + return false; + } + + std::map::iterator it; it = services.find(item -> PacketId() & 0xffffff00); if (it == services.end()) @@ -133,8 +146,20 @@ bool p3ServiceServer::sendItem(RsRawItem *item) item -> print_string(out); std::cerr << std::endl; #endif + if (!item) + { + std::cerr << "p3ServiceServer::sendItem() Caught Null item"; + std::cerr << std::endl; + return false; + } - /* any filtering ??? */ + // Packet Filtering. + if (!mServiceControl->checkFilter(item->PacketId() & 0xffffff00, item->PeerId())) + { + std::cerr << "p3ServiceServer::sendItem() Fails Filtering"; + delete item; + return false; + } mPublisher->sendItem(item); return true; diff --git a/libretroshare/src/pqi/pqiservice.h b/libretroshare/src/pqi/pqiservice.h index 90dced84b..0514e749d 100644 --- a/libretroshare/src/pqi/pqiservice.h +++ b/libretroshare/src/pqi/pqiservice.h @@ -31,6 +31,9 @@ #include "pqi/pqi_base.h" #include "util/rsthreads.h" +#include "retroshare/rsservicecontrol.h" +#include "pqi/p3servicecontrol.h" + // PQI Service, is a generic lower layer on which services can run on. // // these packets get passed through the @@ -59,8 +62,8 @@ class pqiService { protected: - pqiService(uint32_t t) // our type of packets. - :type(t), mServiceServer(NULL) { return; } + pqiService() // our type of packets. + :mServiceServer(NULL) { return; } virtual ~pqiService() { return; } @@ -70,29 +73,28 @@ void setServiceServer(p3ServiceServer *server); virtual bool recv(RsRawItem *) = 0; virtual bool send(RsRawItem *item); -uint32_t getType() { return type; } +virtual RsServiceInfo getServiceInfo() = 0; virtual int tick() { return 0; } private: - uint32_t type; p3ServiceServer *mServiceServer; // const, no need for mutex. }; #include -/* We are pushing the packets back through p3ServiceServer2, +/* We are pushing the packets back through p3ServiceServer, * so that we can filter services at this level later... - * if we decide not to do this, pqiService2 can call through + * if we decide not to do this, pqiService can call through * to the base level pqiPublisher instead. */ class p3ServiceServer { public: - p3ServiceServer(pqiPublisher *pub); + p3ServiceServer(pqiPublisher *pub, p3ServiceControl *ctrl); -int addService(pqiService *); +int addService(pqiService *, bool defaultOn); bool recvItem(RsRawItem *); bool sendItem(RsRawItem *); @@ -102,9 +104,10 @@ int tick(); private: pqiPublisher *mPublisher; // constant no need for mutex. + p3ServiceControl *mServiceControl; RsMutex srvMtx; -std::map services; + std::map services; }; diff --git a/libretroshare/src/pqi/pqiservicemonitor.h b/libretroshare/src/pqi/pqiservicemonitor.h new file mode 100644 index 000000000..a7e1c87a5 --- /dev/null +++ b/libretroshare/src/pqi/pqiservicemonitor.h @@ -0,0 +1,64 @@ +/* + * libretroshare/src/pqi: pqiservicemonitor.h + * + * 3P/PQI network interface for RetroShare. + * + * Copyright 2014 by Robert Fernie. + * + * 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.1 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 "retroshare@lunamutt.com". + * + */ + +#ifndef PQI_SERVICE_MONITOR_H +#define PQI_SERVICE_MONITOR_H + +#include +#include +#include +#include + +/* ACTIONS */ +const uint32_t RS_SERVICE_PEER_NEW = 0x0001; /* new Peer */ +const uint32_t RS_SERVICE_PEER_CONNECTED = 0x0002; /* service connected */ +const uint32_t RS_SERVICE_PEER_DISCONNECTED = 0x0010; +const uint32_t RS_SERVICE_PEER_REMOVED = 0x0020; + +class pqiServicePeer +{ + public: + RsPeerId id; + uint32_t actions; +}; + + +class pqiServiceMonitor +{ + public: + pqiServiceMonitor() { return; } +virtual ~pqiServiceMonitor() { return; } + + /*! + * this serves as a call back function for server which has + * a handle on the subclass and updates this subclass on the + * action of peer's of the client (state and action information) + * + *@param plist contains list of states and actions of the client's peers + */ +virtual void statusChange(const std::list &plist) = 0; +}; + +#endif // PQI_SERVICE_MONITOR_H diff --git a/libretroshare/src/pqi/pqisslpersongrp.h b/libretroshare/src/pqi/pqisslpersongrp.h index 7807fdf02..ec90d3036 100644 --- a/libretroshare/src/pqi/pqisslpersongrp.h +++ b/libretroshare/src/pqi/pqisslpersongrp.h @@ -37,8 +37,8 @@ class pqissl ; class pqisslpersongrp: public pqipersongrp { public: - pqisslpersongrp(SecurityPolicy *pol, unsigned long flags, p3PeerMgr *pm) - :pqipersongrp(pol, flags), mPeerMgr(pm) { return; } + pqisslpersongrp(p3ServiceControl *ctrl, SecurityPolicy *pol, unsigned long flags, p3PeerMgr *pm) + :pqipersongrp(ctrl, pol, flags), mPeerMgr(pm) { return; } protected: diff --git a/libretroshare/src/retroshare/rsservicecontrol.h b/libretroshare/src/retroshare/rsservicecontrol.h new file mode 100644 index 000000000..ff3ff17c1 --- /dev/null +++ b/libretroshare/src/retroshare/rsservicecontrol.h @@ -0,0 +1,110 @@ +#ifndef RETROSHARE_SERVICE_CONTROL_GUI_INTERFACE_H +#define RETROSHARE_SERVICE_CONTROL_GUI_INTERFACE_H + +/* + * libretroshare/src/rsiface: rsservicecontrol.h + * + * RetroShare C++ Interface. + * + * Copyright 2014 by Robert Fernie. + * + * 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.1 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 "retroshare@lunamutt.com". + * + */ + +#include +#include +#include +#include +#include +#include + +/* The Main Interface Class - for information about your Peers */ +class RsServiceControl; +extern RsServiceControl *rsServiceControl; + +class RsServiceInfo +{ + public: + RsServiceInfo(); + RsServiceInfo( + const uint16_t service_type, + const std::string service_name, + const uint16_t version_major, + const uint16_t version_minor, + const uint16_t min_version_major, + const uint16_t min_version_minor); + + std::string mServiceName; + uint32_t mServiceType; + // current version, we running. + uint16_t mVersionMajor; + uint16_t mVersionMinor; + // minimum version can communicate with. + uint16_t mMinVersionMajor; + uint16_t mMinVersionMinor; +}; + + +/* this is what is transmitted to peers */ +class RsPeerServiceInfo +{ + public: + RsPeerServiceInfo() + :mPeerId(), mServiceList() { return; } + + RsPeerId mPeerId; + std::map mServiceList; +}; + +std::ostream &operator<<(std::ostream &out, const RsPeerServiceInfo &info); +std::ostream &operator<<(std::ostream &out, const RsServiceInfo &info); + + +class RsServicePermissions +{ + public: + RsServicePermissions(); + + bool peerHasPermission(const RsPeerId &peerId) const; + + uint32_t mServiceId; + std::string mServiceName; + + bool mDefaultAllowed; + // note only one of these is checked. + // if DefaultAllowed = true, then only PeersDenied is checked. + // if DefaultAllowed = false, then only PeersAllowed is checked. + std::set mPeersAllowed; + std::set mPeersDenied; +}; + +class RsServiceControl +{ + public: + + RsServiceControl() { return; } +virtual ~RsServiceControl() { return; } + +virtual bool getServicesAllowed(const RsPeerId &peerId, RsPeerServiceInfo &info) = 0; +virtual bool getServicesProvided(const RsPeerId &peerId, RsPeerServiceInfo &info) = 0; +virtual bool getServicePermissions(uint32_t serviceId, RsServicePermissions &permissions) = 0; +virtual bool updateServicePermissions(uint32_t serviceId, const RsServicePermissions &permissions) = 0; + +}; + +#endif diff --git a/libretroshare/src/rsserver/rsinit.cc b/libretroshare/src/rsserver/rsinit.cc index 66bcc5b3f..79617c960 100644 --- a/libretroshare/src/rsserver/rsinit.cc +++ b/libretroshare/src/rsserver/rsinit.cc @@ -867,6 +867,7 @@ RsGRouter *rsGRouter = NULL ; #endif #endif +#include "services/p3serviceinfo.h" #include "services/p3heartbeat.h" #include "services/p3discovery2.h" #include "services/p3msgservice.h" @@ -1221,9 +1222,10 @@ int RsServer::StartupRetroShare() /**************************** BITDHT ***********************************/ + p3ServiceControl *serviceCtrl = new p3ServiceControl(0); SecurityPolicy *none = secpolicy_create(); - pqih = new pqisslpersongrp(none, flags, mPeerMgr); + pqih = new pqisslpersongrp(serviceCtrl, none, flags, mPeerMgr); //pqih = new pqipersongrpDummy(none, flags); /****** New Ft Server **** !!! */ @@ -1293,6 +1295,7 @@ int RsServer::StartupRetroShare() mPluginsManager->loadPlugins(programatically_inserted_plugins) ; /* create Services */ + p3ServiceInfo *serviceInfo = new p3ServiceInfo(serviceCtrl); mDisc = new p3discovery2(mPeerMgr, mLinkMgr, mNetMgr); mHeart = new p3heartbeat(mLinkMgr, pqih); msgSrv = new p3MsgService(mLinkMgr); @@ -1302,13 +1305,13 @@ int RsServer::StartupRetroShare() #ifdef GROUTER p3GRouter *gr = new p3GRouter(mLinkMgr) ; rsGRouter = gr ; - pqih->addService(gr) ; + pqih->addService(gr, true) ; #endif p3turtle *tr = new p3turtle(mLinkMgr) ; rsTurtle = tr ; - pqih -> addService(tr); - pqih -> addService(ftserver); + pqih -> addService(tr, true); + pqih -> addService(ftserver, true); rsDisc = mDisc; rsMsgs = new p3Msgs(msgSrv, chatSrv); @@ -1322,11 +1325,12 @@ int RsServer::StartupRetroShare() #endif msgSrv->connectToTurtleRouter(tr) ; - pqih -> addService(mHeart); - pqih -> addService(mDisc); - pqih -> addService(msgSrv); - pqih -> addService(chatSrv); - pqih ->addService(mStatusSrv); + pqih -> addService(serviceInfo, true); + pqih -> addService(mHeart, true); + pqih -> addService(mDisc, true); + pqih -> addService(msgSrv, true); + pqih -> addService(chatSrv, true); + pqih ->addService(mStatusSrv, true); // set interfaces for plugins @@ -1400,15 +1404,14 @@ int RsServer::StartupRetroShare() // create GXS ID service RsGxsNetService* gxsid_ns = new RsGxsNetService( RS_SERVICE_GXSV2_TYPE_GXSID, gxsid_ds, nxsMgr, - mGxsIdService, mGxsIdService, mGxsCircles, - true); // don't synchronise group automatic (need explicit group request) + mGxsIdService, mGxsIdService->getServiceInfo(), + mGxsIdService, mGxsCircles, + false); // don't synchronise group automatic (need explicit group request) mGxsIdService->setNes(gxsid_ns); /**** GxsCircle service ****/ - - #ifndef GXS_DEV_TESTNET // NO RESET, OR DUMMYDATA for TESTNET gxscircles_ds->resetDataStore(); #endif @@ -1419,7 +1422,8 @@ int RsServer::StartupRetroShare() // create GXS Circle service RsGxsNetService* gxscircles_ns = new RsGxsNetService( RS_SERVICE_GXSV2_TYPE_GXSCIRCLE, gxscircles_ds, nxsMgr, - mGxsCircles, mGxsIdService, mGxsCircles); + mGxsCircles, mGxsCircles->getServiceInfo(), + mGxsIdService, mGxsCircles); /**** Photo service ****/ @@ -1435,14 +1439,17 @@ int RsServer::StartupRetroShare() // create GXS photo service RsGxsNetService* photo_ns = new RsGxsNetService( - RS_SERVICE_GXSV2_TYPE_PHOTO, photo_ds, nxsMgr, mPhoto, mGxsIdService, mGxsCircles); + RS_SERVICE_GXSV2_TYPE_PHOTO, photo_ds, nxsMgr, + mPhoto, mPhoto->getServiceInfo(), + mGxsIdService, mGxsCircles); /**** Posted GXS service ****/ RsGeneralDataService* posted_ds = new RsDataService(currGxsDir + "/", "posted_db", - RS_SERVICE_GXSV2_TYPE_POSTED, NULL, RsInitConfig::gxs_passwd); + RS_SERVICE_GXSV2_TYPE_POSTED, + NULL, RsInitConfig::gxs_passwd); #ifndef GXS_DEV_TESTNET // NO RESET, OR DUMMYDATA for TESTNET posted_ds->resetDataStore(); //TODO: remove, new service data per RS session, for testing @@ -1452,16 +1459,16 @@ int RsServer::StartupRetroShare() // create GXS photo service RsGxsNetService* posted_ns = new RsGxsNetService( - RS_SERVICE_GXSV2_TYPE_POSTED, posted_ds, nxsMgr, mPosted, mGxsIdService, mGxsCircles); - + RS_SERVICE_GXSV2_TYPE_POSTED, posted_ds, nxsMgr, + mPosted, mPosted->getServiceInfo(), + mGxsIdService, mGxsCircles); /**** Wiki GXS service ****/ - RsGeneralDataService* wiki_ds = new RsDataService(currGxsDir + "/", "wiki_db", - RS_SERVICE_GXSV2_TYPE_WIKI, - NULL, RsInitConfig::gxs_passwd); + RS_SERVICE_GXSV2_TYPE_WIKI, + NULL, RsInitConfig::gxs_passwd); #ifndef GXS_DEV_TESTNET // NO RESET, OR DUMMYDATA for TESTNET wiki_ds->resetDataStore(); //TODO: remove, new service data per RS session, for testing @@ -1471,14 +1478,17 @@ int RsServer::StartupRetroShare() // create GXS photo service RsGxsNetService* wiki_ns = new RsGxsNetService( - RS_SERVICE_GXSV2_TYPE_WIKI, wiki_ds, nxsMgr, mWiki, mGxsIdService, mGxsCircles); + RS_SERVICE_GXSV2_TYPE_WIKI, wiki_ds, nxsMgr, + mWiki, mWiki->getServiceInfo(), + mGxsIdService, mGxsCircles); /**** Wire GXS service ****/ RsGeneralDataService* wire_ds = new RsDataService(currGxsDir + "/", "wire_db", - RS_SERVICE_GXSV2_TYPE_WIRE, NULL, RsInitConfig::gxs_passwd); + RS_SERVICE_GXSV2_TYPE_WIRE, + NULL, RsInitConfig::gxs_passwd); #ifndef GXS_DEV_TESTNET // NO RESET, OR DUMMYDATA for TESTNET wire_ds->resetDataStore(); //TODO: remove, new service data per RS session, for testing @@ -1488,7 +1498,9 @@ int RsServer::StartupRetroShare() // create GXS photo service RsGxsNetService* wire_ns = new RsGxsNetService( - RS_SERVICE_GXSV2_TYPE_WIRE, wire_ds, nxsMgr, mWire, mGxsIdService, mGxsCircles); + RS_SERVICE_GXSV2_TYPE_WIRE, wire_ds, nxsMgr, + mWire, mWire->getServiceInfo(), + mGxsIdService, mGxsCircles); /**** Forum GXS service ****/ @@ -1505,7 +1517,8 @@ int RsServer::StartupRetroShare() // create GXS photo service RsGxsNetService* gxsforums_ns = new RsGxsNetService( RS_SERVICE_GXSV2_TYPE_FORUMS, gxsforums_ds, nxsMgr, - mGxsForums, mGxsIdService, mGxsCircles); + mGxsForums, mGxsForums->getServiceInfo(), + mGxsIdService, mGxsCircles); /**** Channel GXS service ****/ @@ -1522,16 +1535,17 @@ int RsServer::StartupRetroShare() // create GXS photo service RsGxsNetService* gxschannels_ns = new RsGxsNetService( RS_SERVICE_GXSV2_TYPE_CHANNELS, gxschannels_ds, nxsMgr, - mGxsChannels, mGxsIdService, mGxsCircles); + mGxsChannels, mGxsChannels->getServiceInfo(), + mGxsIdService, mGxsCircles); // now add to p3service - pqih->addService(gxsid_ns); - pqih->addService(gxscircles_ns); - pqih->addService(photo_ns); - pqih->addService(posted_ns); - pqih->addService(wiki_ns); - pqih->addService(gxsforums_ns); - pqih->addService(gxschannels_ns); + pqih->addService(gxsid_ns, true); + pqih->addService(gxscircles_ns, true); + pqih->addService(photo_ns, true); + pqih->addService(posted_ns, true); + pqih->addService(wiki_ns, true); + pqih->addService(gxsforums_ns, true); + pqih->addService(gxschannels_ns, true); // remove pword from memory RsInitConfig::gxs_passwd = ""; @@ -1541,21 +1555,21 @@ int RsServer::StartupRetroShare() #ifdef RS_RTT p3rtt *mRtt = new p3rtt(mLinkMgr); - pqih -> addService(mRtt); + pqih -> addService(mRtt, true); rsRtt = mRtt; #endif // new services to test. p3BanList *mBanList = new p3BanList(mLinkMgr, mNetMgr); - pqih -> addService(mBanList); + pqih -> addService(mBanList, true); mBitDht->setupPeerSharer(mBanList); p3BandwidthControl *mBwCtrl = new p3BandwidthControl(pqih); - pqih -> addService(mBwCtrl); + pqih -> addService(mBwCtrl, true); #ifdef SERVICES_DSDV p3Dsdv *mDsdv = new p3Dsdv(mLinkMgr); - pqih -> addService(mDsdv); + pqih -> addService(mDsdv, true); rsDsdv = mDsdv; mDsdv->addTestService(); #endif @@ -1589,6 +1603,7 @@ int RsServer::StartupRetroShare() /**************************************************************************/ /* need to Monitor too! */ + mLinkMgr->addMonitor(serviceInfo); mLinkMgr->addMonitor(pqih); mLinkMgr->addMonitor(mCacheStrapper); mLinkMgr->addMonitor(mDisc); diff --git a/libretroshare/src/serialiser/itempriorities.h b/libretroshare/src/serialiser/itempriorities.h index 31ce1e60b..efecc7a9a 100644 --- a/libretroshare/src/serialiser/itempriorities.h +++ b/libretroshare/src/serialiser/itempriorities.h @@ -109,3 +109,7 @@ const uint8_t QOS_PRIORITY_RS_DSDV_DATA = 2 ; const uint8_t QOS_PRIORITY_RS_GXS_NET = 3 ; // GXS Reputation. const uint8_t QOS_PRIORITY_RS_GXSREPUTATION_ITEM = 2; + +// Service Info / Control. +const uint8_t QOS_PRIORITY_RS_SERVICE_INFO_ITEM = 7; + diff --git a/libretroshare/src/serialiser/rsbaseserial.cc b/libretroshare/src/serialiser/rsbaseserial.cc index 1eae710ea..fd19461f1 100644 --- a/libretroshare/src/serialiser/rsbaseserial.cc +++ b/libretroshare/src/serialiser/rsbaseserial.cc @@ -215,6 +215,12 @@ bool setRawUFloat32(void *data,uint32_t size,uint32_t *offset,float f) return setRawUInt32(data, size, offset, n); } + +uint32_t getRawStringSize(const std::string &outStr) +{ + return outStr.length() + 4; +} + bool getRawString(void *data, uint32_t size, uint32_t *offset, std::string &outStr) { uint32_t len = 0; diff --git a/libretroshare/src/serialiser/rsbaseserial.h b/libretroshare/src/serialiser/rsbaseserial.h index 33f182cf4..25e0f57cc 100644 --- a/libretroshare/src/serialiser/rsbaseserial.h +++ b/libretroshare/src/serialiser/rsbaseserial.h @@ -63,6 +63,7 @@ bool setRawUInt64(void *data, uint32_t size, uint32_t *offset, uint64_t in); bool getRawUFloat32(void *data, uint32_t size, uint32_t *offset, float& out); bool setRawUFloat32(void *data, uint32_t size, uint32_t *offset, float in); +uint32_t getRawStringSize(const std::string &outStr); bool getRawString(void *data, uint32_t size, uint32_t *offset, std::string &outStr); bool setRawString(void *data, uint32_t size, uint32_t *offset, const std::string &inStr); diff --git a/libretroshare/src/serialiser/rsserviceids.h b/libretroshare/src/serialiser/rsserviceids.h index e2feefbe5..3d545489f 100644 --- a/libretroshare/src/serialiser/rsserviceids.h +++ b/libretroshare/src/serialiser/rsserviceids.h @@ -52,6 +52,8 @@ const uint16_t RS_SERVICE_TYPE_FILE_TRANSFER = 0x0017; /* BanList Still Testing at the moment - Service Only */ const uint16_t RS_SERVICE_TYPE_BANLIST = 0x0101; +const uint16_t RS_SERVICE_TYPE_SERVICEINFO = 0x0201; + /* Caches based on p3distrib (Cache Only) * Unfortunately, noone changed the DUMMY IDS... so we are stuck with them! */ diff --git a/libretroshare/src/serialiser/rsserviceinfoitems.cc b/libretroshare/src/serialiser/rsserviceinfoitems.cc new file mode 100644 index 000000000..b3d6ce09c --- /dev/null +++ b/libretroshare/src/serialiser/rsserviceinfoitems.cc @@ -0,0 +1,445 @@ +/* + * libretroshare/src/serialiser: rsserviceinfoitems.cc + * + * RetroShare Serialiser. + * + * Copyright 2014 by Robert Fernie. + * + * 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.1 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 "retroshare@lunamutt.com". + * + */ + +#include "serialiser/rsbaseserial.h" +#include "serialiser/rsserviceinfoitems.h" + +/*** +#define RSSERIAL_DEBUG 1 +***/ + +#include + +/*************************************************************************/ +/***** RsServiceInfo ****/ + +template<> +std::ostream &RsTlvParamRef::print(std::ostream &out, uint16_t indent) +{ + out << "RsServiceInfo: " << mParam.mServiceType << " name " << mParam.mServiceName; + out << std::endl; + out << "Version(" << mParam.mVersionMajor << "," << mParam.mVersionMinor << ")"; + out << " MinVersion(" << mParam.mMinVersionMajor << "," << mParam.mMinVersionMinor << ")"; + out << std::endl; + return out; +} + +template<> +uint32_t RsTlvParamRef::TlvSize() +{ + uint32_t s = TLV_HEADER_SIZE; /* header + 4 for size */ + + s += getRawStringSize(mParam.mServiceName); + s += 4; // type. + s += 4; // version. + s += 4; // min version. + return s; +} + +template<> +void RsTlvParamRef::TlvClear() +{ + mParam = RsServiceInfo(); + mParam.mServiceName.clear(); +} + +template<> +bool RsTlvParamRef::SetTlv(void *data, uint32_t size, uint32_t *offset) +{ + /* must check sizes */ + uint32_t tlvsize = TlvSize(); + uint32_t tlvend = *offset + tlvsize; + + if (size < tlvend) + { + return false; /* not enough space */ + } + + bool ok = true; + + ok &= SetTlvBase(data, tlvend, offset, mParamType, tlvsize); + ok &= setRawString(data, tlvend, offset, mParam.mServiceName); + ok &= setRawUInt32(data, tlvend, offset, mParam.mServiceType); + ok &= setRawUInt16(data, tlvend, offset, mParam.mVersionMajor); + ok &= setRawUInt16(data, tlvend, offset, mParam.mVersionMinor); + ok &= setRawUInt16(data, tlvend, offset, mParam.mMinVersionMajor); + ok &= setRawUInt16(data, tlvend, offset, mParam.mMinVersionMinor); + + if (!ok) + { + std::cerr << "RsTlvParamRef::SetTlv() Failed"; + std::cerr << std::endl; + } + + return ok; +} + +template<> +bool RsTlvParamRef::GetTlv(void *data, uint32_t size, uint32_t *offset) +{ + if (size < *offset + TLV_HEADER_SIZE) + return false; + + uint16_t tlvtype = GetTlvType( &(((uint8_t *) data)[*offset]) ); + uint32_t tlvsize = GetTlvSize( &(((uint8_t *) data)[*offset]) ); + uint32_t tlvend = *offset + tlvsize; + + if (size < tlvend) /* check size */ + { + return false; /* not enough space */ + } + + if (tlvtype != mParamType) /* check type */ + { + return false; + } + + bool ok = true; + + /* ready to load */ + TlvClear(); + + /* skip the header */ + (*offset) += TLV_HEADER_SIZE; + + ok &= getRawString(data, tlvend, offset, mParam.mServiceName); + ok &= getRawUInt32(data, tlvend, offset, &(mParam.mServiceType)); + ok &= getRawUInt16(data, tlvend, offset, &(mParam.mVersionMajor)); + ok &= getRawUInt16(data, tlvend, offset, &(mParam.mVersionMinor)); + ok &= getRawUInt16(data, tlvend, offset, &(mParam.mMinVersionMajor)); + ok &= getRawUInt16(data, tlvend, offset, &(mParam.mMinVersionMinor)); + + return ok; +} + +template class RsTlvParamRef; + +/*************************************************************************/ + +RsServiceInfoListItem::~RsServiceInfoListItem() +{ + return; +} + +void RsServiceInfoListItem::clear() +{ + mServiceInfo.clear(); +} + +std::ostream &RsServiceInfoListItem::print(std::ostream &out, uint16_t indent) +{ + printRsItemBase(out, "RsServiceInfoListItem", indent); + uint16_t int_Indent = indent + 2; + RsTlvServiceInfoMapRef map(mServiceInfo); + map.print(out, int_Indent); + out << std::endl; + + printRsItemEnd(out, "RsServiceInfoListItem", indent); + return out; +} + + +uint32_t RsServiceInfoSerialiser::sizeInfo(RsServiceInfoListItem *item) +{ + uint32_t s = 8; /* header */ + RsTlvServiceInfoMapRef map(item->mServiceInfo); + s += map.TlvSize(); + + return s; +} + +/* serialise the data to the buffer */ +bool RsServiceInfoSerialiser::serialiseInfo(RsServiceInfoListItem *item, void *data, uint32_t *pktsize) +{ + uint32_t tlvsize = sizeInfo(item); + uint32_t offset = 0; + + if (*pktsize < tlvsize) + return false; /* not enough space */ + + *pktsize = tlvsize; + + bool ok = true; + + ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize); + +#ifdef RSSERIAL_DEBUG + std::cerr << "RsServiceInfoSerialiser::serialiseInfo() Header: " << ok << std::endl; + std::cerr << "RsServiceInfoSerialiser::serialiseInfo() Size: " << tlvsize << std::endl; +#endif + + /* skip the header */ + offset += 8; + + /* add mandatory parts first */ + RsTlvServiceInfoMapRef map(item->mServiceInfo); + ok &= map.SetTlv(data, tlvsize, &offset); + + if (offset != tlvsize) + { + ok = false; +#ifdef RSSERIAL_DEBUG + std::cerr << "RsServiceInfoSerialiser::serialiseInfo() Size Error! " << std::endl; +#endif + } + return ok; +} + +RsServiceInfoListItem *RsServiceInfoSerialiser::deserialiseInfo(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_SERVICEINFO != getRsItemService(rstype)) || + (RS_PKT_SUBTYPE_SERVICELIST_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 */ + RsServiceInfoListItem *item = new RsServiceInfoListItem(); + item->clear(); + + /* skip the header */ + offset += 8; + + /* get mandatory parts first */ + RsTlvServiceInfoMapRef map(item->mServiceInfo); + ok &= map.GetTlv(data, tlvsize, &offset); + + if (offset != tlvsize) + { + /* error */ + delete item; + return NULL; + } + + if (!ok) + { + delete item; + return NULL; + } + + return item; +} + +/*************************************************************************/ +/*************************************************************************/ + +RsServiceInfoPermissionsItem::~RsServiceInfoPermissionsItem() +{ + return; +} + +void RsServiceInfoPermissionsItem::clear() +{ + allowedBw = 0; +} + +std::ostream &RsServiceInfoPermissionsItem::print(std::ostream &out, uint16_t indent) +{ + printRsItemBase(out, "RsServiceInfoPermissionsItem", indent); + uint16_t int_Indent = indent + 2; + printIndent(out, int_Indent); + out << "AllowedBw: " << allowedBw; + out << std::endl; + + printRsItemEnd(out, "RsServiceInfoPermissionsItem", indent); + return out; +} + + +uint32_t RsServiceInfoSerialiser::sizePermissions(RsServiceInfoPermissionsItem * /*item*/) +{ + uint32_t s = 8; /* header */ + s += GetTlvUInt32Size(); + + return s; +} + +/* serialise the data to the buffer */ +bool RsServiceInfoSerialiser::serialisePermissions(RsServiceInfoPermissionsItem *item, void *data, uint32_t *pktsize) +{ + uint32_t tlvsize = sizePermissions(item); + uint32_t offset = 0; + + if (*pktsize < tlvsize) + return false; /* not enough space */ + + *pktsize = tlvsize; + + bool ok = true; + + ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize); + +#ifdef RSSERIAL_DEBUG + std::cerr << "RsServiceInfoSerialiser::serialisePermissions() Header: " << ok << std::endl; + std::cerr << "RsServiceInfoSerialiser::serialisePermissions() Size: " << tlvsize << std::endl; +#endif + + /* skip the header */ + offset += 8; + + /* add mandatory parts first */ + ok &= SetTlvUInt32(data, tlvsize, &offset, TLV_TYPE_UINT32_BW, item->allowedBw); + + if (offset != tlvsize) + { + ok = false; +#ifdef RSSERIAL_DEBUG + std::cerr << "RsServiceInfoSerialiser::serialisePermissions() Size Error! " << std::endl; +#endif + } + + return ok; +} + +RsServiceInfoPermissionsItem *RsServiceInfoSerialiser::deserialisePermissions(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_SERVICEINFO != getRsItemService(rstype)) || + (RS_PKT_SUBTYPE_SERVICEPERMISSIONS_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 */ + RsServiceInfoPermissionsItem *item = new RsServiceInfoPermissionsItem(); + item->clear(); + + /* skip the header */ + offset += 8; + + /* get mandatory parts first */ + ok &= GetTlvUInt32(data, tlvsize, &offset, TLV_TYPE_UINT32_BW, &(item->allowedBw)); + + + if (offset != tlvsize) + { + /* error */ + delete item; + return NULL; + } + + if (!ok) + { + delete item; + return NULL; + } + + return item; +} + +/*************************************************************************/ + +uint32_t RsServiceInfoSerialiser::size(RsItem *i) +{ + RsServiceInfoListItem *sli; + RsServiceInfoPermissionsItem *spi; + + if (NULL != (sli = dynamic_cast(i))) + { + return sizeInfo(sli); + } + if (NULL != (spi = dynamic_cast(i))) + { + return sizePermissions(spi); + } + return 0; +} + +bool RsServiceInfoSerialiser::serialise(RsItem *i, void *data, uint32_t *pktsize) +{ + RsServiceInfoListItem *sli; + RsServiceInfoPermissionsItem *spi; + + if (NULL != (sli = dynamic_cast(i))) + { + return serialiseInfo(sli, data, pktsize); + } + if (NULL != (spi = dynamic_cast(i))) + { + return serialisePermissions(spi, data, pktsize); + } + return false; +} + +RsItem *RsServiceInfoSerialiser::deserialise(void *data, uint32_t *pktsize) +{ + /* get the type and size */ + uint32_t rstype = getRsItemId(data); + + if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || + (RS_SERVICE_TYPE_SERVICEINFO != getRsItemService(rstype))) + { + return NULL; /* wrong type */ + } + + switch(getRsItemSubType(rstype)) + { + case RS_PKT_SUBTYPE_SERVICELIST_ITEM: + return deserialiseInfo(data, pktsize); + break; + case RS_PKT_SUBTYPE_SERVICEPERMISSIONS_ITEM: + return deserialisePermissions(data, pktsize); + break; + default: + return NULL; + break; + } +} + +/*************************************************************************/ + + + diff --git a/libretroshare/src/serialiser/rsserviceinfoitems.h b/libretroshare/src/serialiser/rsserviceinfoitems.h new file mode 100644 index 000000000..295ca4f6b --- /dev/null +++ b/libretroshare/src/serialiser/rsserviceinfoitems.h @@ -0,0 +1,133 @@ +#ifndef RS_SERVICE_INFO_ITEMS_H +#define RS_SERVICE_INFO_ITEMS_H + +/* + * libretroshare/src/serialiser: rsserviceinfoitems.h + * + * RetroShare Serialiser. + * + * Copyright 2012 by Robert Fernie. + * + * 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.1 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 "retroshare@lunamutt.com". + * + */ + +// Provides serialiser for p3ServiceControl & p3ServiceInfo. + +#include + +#include "serialiser/rsserviceids.h" +#include "serialiser/rsserial.h" +#include "serialiser/rstlvbase.h" +#include "serialiser/rstlvgenericmap.h" +#include "retroshare/rsservicecontrol.h" + +#define RS_PKT_SUBTYPE_SERVICELIST_ITEM 0x01 +#define RS_PKT_SUBTYPE_SERVICEPERMISSIONS_ITEM 0x02 + +/**************************************************************************/ +#define SERVICE_INFO_MAP 0x01 +#define SERVICE_INFO_KEY 0x01 +#define SERVICE_ID 0x01 +#define SERVICE_INFO 0x01 + +class RsTlvServiceInfoMapRef: public RsTlvGenericMapRef +{ +public: + RsTlvServiceInfoMapRef(std::map &refmap) + :RsTlvGenericMapRef( + SERVICE_INFO_MAP, + SERVICE_INFO_KEY, + SERVICE_ID, + SERVICE_INFO, + refmap) + { + return; + } +}; + + + +class RsServiceInfoListItem: public RsItem +{ + public: + RsServiceInfoListItem() + :RsItem(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_SERVICEINFO, + RS_PKT_SUBTYPE_SERVICELIST_ITEM) + { + setPriorityLevel(QOS_PRIORITY_RS_SERVICE_INFO_ITEM); + return; + } + +virtual ~RsServiceInfoListItem(); +virtual void clear(); +std::ostream &print(std::ostream &out, uint16_t indent = 0); + + std::map mServiceInfo; +}; + + +class RsServiceInfoPermissionsItem: public RsItem +{ + public: + RsServiceInfoPermissionsItem() + :RsItem(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_SERVICEINFO, + RS_PKT_SUBTYPE_SERVICEPERMISSIONS_ITEM) + { + setPriorityLevel(QOS_PRIORITY_RS_SERVICE_INFO_ITEM); + return; + } + +virtual ~RsServiceInfoPermissionsItem(); +virtual void clear(); +std::ostream &print(std::ostream &out, uint16_t indent = 0); + + uint32_t allowedBw; // Units are bytes/sec => 4Gb/s; + +}; + + +class RsServiceInfoSerialiser: public RsSerialType +{ + public: + RsServiceInfoSerialiser() + :RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_SERVICEINFO) + { return; } +virtual ~RsServiceInfoSerialiser() + { 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 uint32_t sizeInfo(RsServiceInfoListItem *); +virtual bool serialiseInfo(RsServiceInfoListItem *item, void *data, uint32_t *size); +virtual RsServiceInfoListItem *deserialiseInfo(void *data, uint32_t *size); + + +virtual uint32_t sizePermissions(RsServiceInfoPermissionsItem *); +virtual bool serialisePermissions(RsServiceInfoPermissionsItem *item, void *data, uint32_t *size); +virtual RsServiceInfoPermissionsItem *deserialisePermissions(void *data, uint32_t *size); + + +}; + +/**************************************************************************/ + +#endif /* RS_SERVICE_INFO_ITEMS_H */ diff --git a/libretroshare/src/serialiser/rstlvbase.cc b/libretroshare/src/serialiser/rstlvbase.cc index ec9e71955..e02ab5631 100644 --- a/libretroshare/src/serialiser/rstlvbase.cc +++ b/libretroshare/src/serialiser/rstlvbase.cc @@ -259,6 +259,98 @@ bool GetTlvUInt32(void *data, uint32_t size, uint32_t *offset, return ok; } +// UInt16 +bool SetTlvUInt16(void *data, uint32_t size, uint32_t *offset, uint16_t type, + uint16_t out) +{ + if (!data) + return false; + uint32_t tlvsize = GetTlvUInt16Size(); /* this will always be 8 bytes */ + uint32_t tlvend = *offset + tlvsize; /* where the data will extend to */ + if (size < tlvend) + { +#ifdef TLV_BASE_DEBUG + std::cerr << "SetTlvUInt16() FAILED - not enough space. (or earlier)" << std::endl; + std::cerr << "SetTlvUInt16() size: " << size << std::endl; + std::cerr << "SetTlvUInt16() tlvsize: " << tlvsize << std::endl; + std::cerr << "SetTlvUInt16() tlvend: " << tlvend << std::endl; +#endif + return false; + } + + bool ok = true; + + /* Now use the function we got to set the TlvHeader */ + /* function shifts offset to the new start for the next data */ + ok &= SetTlvBase(data, tlvend, offset, type, tlvsize); + +#ifdef TLV_BASE_DEBUG + if (!ok) + { + std::cerr << "SetTlvUInt16() SetTlvBase FAILED (or earlier)" << std::endl; + } +#endif + + /* now set the UInt16 ( in rsbaseserial.h???) */ + ok &= setRawUInt16(data, tlvend, offset, out); + +#ifdef TLV_BASE_DEBUG + if (!ok) + { + std::cerr << "SetTlvUInt16() setRawUInt16 FAILED (or earlier)" << std::endl; + } +#endif + + + return ok; + +} + +bool GetTlvUInt16(void *data, uint32_t size, uint32_t *offset, + uint16_t type, uint16_t *in) +{ + if (!data) + return false; + + if (size < *offset + TLV_HEADER_SIZE) + return false; + + /* extract the type and size */ + void *tlvstart = right_shift_void_pointer(data, *offset); + uint16_t tlvtype = GetTlvType(tlvstart); + uint32_t tlvsize = GetTlvSize(tlvstart); + + /* check that there is size */ + uint32_t tlvend = *offset + tlvsize; + if (size < tlvend) + { +#ifdef TLV_BASE_DEBUG + std::cerr << "GetTlvUInt16() FAILED - not enough space." << std::endl; + std::cerr << "GetTlvUInt16() size: " << size << std::endl; + std::cerr << "GetTlvUInt16() tlvsize: " << tlvsize << std::endl; + std::cerr << "GetTlvUInt16() tlvend: " << tlvend << std::endl; +#endif + return false; + } + + if (type != tlvtype) + { +#ifdef TLV_BASE_DEBUG + std::cerr << "GetTlvUInt16() FAILED - Type mismatch" << std::endl; + std::cerr << "GetTlvUInt16() type: " << type << std::endl; + std::cerr << "GetTlvUInt16() tlvtype: " << tlvtype << std::endl; +#endif + return false; + } + + *offset += TLV_HEADER_SIZE; /* step past header */ + + bool ok = true; + ok &= getRawUInt16(data, tlvend, offset, in); + + return ok; +} + uint32_t GetTlvUInt64Size() { return TLV_HEADER_SIZE + 8; diff --git a/libretroshare/src/serialiser/rstlvgenericmap.h b/libretroshare/src/serialiser/rstlvgenericmap.h index 3304494f6..5713fdc3d 100644 --- a/libretroshare/src/serialiser/rstlvgenericmap.h +++ b/libretroshare/src/serialiser/rstlvgenericmap.h @@ -32,28 +32,7 @@ #include #include - -/**** TLV ***** - * Generic Parameters / Maps. - */ - - -template -class RsTlvParamRef: public RsTlvItem -{ - public: - RsTlvParamRef(uint16_t param_type, T &p): mParamType(param_type), mParam(p) {} -virtual ~RsTlvParamRef() { return; } -virtual uint32_t TlvSize(); -virtual void TlvClear(); -virtual bool SetTlv(void *data, uint32_t size, uint32_t *offset); /* serialise */ -virtual bool GetTlv(void *data, uint32_t size, uint32_t *offset); /* deserialise */ -virtual std::ostream &print(std::ostream &out, uint16_t indent); - - uint16_t mParamType; - T &mParam; -}; - +#include "serialiser/rstlvgenericparam.h" /*********************************** RsTlvGenericPairRef ***********************************/ @@ -107,5 +86,7 @@ virtual std::ostream &print(std::ostream &out, uint16_t indent); }; +#include "rstlvgenericmap.inl" + #endif diff --git a/libretroshare/src/serialiser/rstlvgenericmap.cc b/libretroshare/src/serialiser/rstlvgenericmap.inl similarity index 74% rename from libretroshare/src/serialiser/rstlvgenericmap.cc rename to libretroshare/src/serialiser/rstlvgenericmap.inl index 2145a2cd6..88792ff44 100644 --- a/libretroshare/src/serialiser/rstlvgenericmap.cc +++ b/libretroshare/src/serialiser/rstlvgenericmap.inl @@ -1,6 +1,6 @@ /* - * libretroshare/src/serialiser: rstlvgenericmap.cc + * libretroshare/src/serialiser: rstlvgenericmap.inl * * RetroShare Serialiser. * @@ -36,89 +36,6 @@ #define TLV_DEBUG 1 -/* generic print */ -template -std::ostream & RsTlvParamRef::print(std::ostream &out, uint16_t indent) -{ - printIndent(out, indent); - out << "Type: " << mParamType << "Param: " << mParam; - return out; -} - - -template<> -uint32_t RsTlvParamRef::TlvSize() -{ - return GetTlvUInt32Size(); -} - -template<> -void RsTlvParamRef::TlvClear() -{ - mParam = 0; -} - -template<> -bool RsTlvParamRef::SetTlv(void *data, uint32_t size, uint32_t *offset) -{ - return SetTlvUInt32(data, size, offset, mParamType, mParam); -} - -template<> -bool RsTlvParamRef::GetTlv(void *data, uint32_t size, uint32_t *offset) -{ - return GetTlvUInt32(data, size, offset, mParamType, &mParam); -} - -#if 0 -template<> -std::ostream & RsTlvParamRef::print(std::ostream &out, uint16_t indent) -{ - printIndent(out, indent); - out << mParam; - return out; -} -#endif - -/***** std::string ****/ -template<> -uint32_t RsTlvParamRef::TlvSize() -{ - return GetTlvStringSize(mParam); -} - -template<> -void RsTlvParamRef::TlvClear() -{ - mParam.clear(); -} - -template<> -bool RsTlvParamRef::SetTlv(void *data, uint32_t size, uint32_t *offset) -{ - return SetTlvString(data, size, offset, mParamType, mParam); -} - -template<> -bool RsTlvParamRef::GetTlv(void *data, uint32_t size, uint32_t *offset) -{ - return GetTlvString(data, size, offset, mParamType, mParam); -} - -#if 0 -template<> -std::ostream & RsTlvParamRef::print(std::ostream &out, uint16_t indent) -{ - printIndent(out, indent); - out << "Type: " << mParamType << "Param: " << mParam; - return out; -} -#endif - -// declare likely combinations. -template class RsTlvParamRef; -template class RsTlvParamRef; - /*********************************** RsTlvGenericPairRef ***********************************/ template @@ -163,6 +80,16 @@ bool RsTlvGenericPairRef::SetTlv(void *data, uint32_t size, uint32_t *off ok &= key.SetTlv(data, tlvend, offset); ok &= value.SetTlv(data, tlvend, offset); + if (!ok) + { + std::cerr << "RsTlvGenericPairRef<>::SetTlv() Failed"; + std::cerr << std::endl; + } + else + { + std::cerr << "RsTlvGenericPairRef<>::SetTlv() Ok"; + std::cerr << std::endl; + } return ok; } @@ -187,6 +114,9 @@ bool RsTlvGenericPairRef::GetTlv(void *data, uint32_t size, uint32_t *off /* ready to load */ TlvClear(); + /* skip the header */ + (*offset) += TLV_HEADER_SIZE; + RsTlvParamRef key(mKeyType, mKey); RsTlvParamRef value(mValueType, mValue); ok &= key.GetTlv(data, tlvend, offset); @@ -213,7 +143,7 @@ bool RsTlvGenericPairRef::GetTlv(void *data, uint32_t size, uint32_t *off template std::ostream &RsTlvGenericPairRef::print(std::ostream &out, uint16_t indent) { - printBase(out, "RsTlvGenericPairRef", indent); + //printBase(out, "RsTlvGenericPairRef", indent); uint16_t int_Indent = indent + 2; RsTlvParamRef key(mKeyType, mKey); @@ -229,7 +159,7 @@ std::ostream &RsTlvGenericPairRef::print(std::ostream &out, uint16_t inden value.print(out, 0); out << std::endl; - printEnd(out, "RsTlvGenericPairRef", indent); + //printEnd(out, "RsTlvGenericPairRef", indent); return out; } @@ -285,6 +215,12 @@ bool RsTlvGenericMapRef::SetTlv(void *data, uint32_t size, uint32_t *offs ok &= pair.SetTlv(data, size, offset); } + if (!ok) + { + std::cerr << "RsTlvGenericMapRef<>::SetTlv() Failed"; + std::cerr << std::endl; + } + return ok; } @@ -322,7 +258,7 @@ bool RsTlvGenericMapRef::GetTlv(void *data, uint32_t size, uint32_t *offs { K k; V v; - RsTlvGenericPairRef pair(mPairType, mKeyType, mValueType, k, v); + RsTlvGenericPairRef pair(mPairType, mKeyType, mValueType, k, v); ok &= pair.GetTlv(data, size, offset); if (ok) { @@ -360,7 +296,7 @@ bool RsTlvGenericMapRef::GetTlv(void *data, uint32_t size, uint32_t *offs template std::ostream &RsTlvGenericMapRef::print(std::ostream &out, uint16_t indent) { - printBase(out, "RsTlvGenericMapRef", indent); + //printBase(out, "RsTlvGenericMapRef", indent); uint16_t int_Indent = indent + 2; printIndent(out, int_Indent); @@ -373,15 +309,15 @@ std::ostream &RsTlvGenericMapRef::print(std::ostream &out, uint16_t indent pair.print(out, int_Indent); } - printEnd(out, "RsTlvGenericMapRef", indent); + //printEnd(out, "RsTlvGenericMapRef", indent); return out; } // declare likely combinations. -template class RsTlvGenericMapRef; -template class RsTlvGenericMapRef; -template class RsTlvGenericMapRef; -template class RsTlvGenericMapRef; +//template class RsTlvGenericMapRef; +//template class RsTlvGenericMapRef; +//template class RsTlvGenericMapRef; +//template class RsTlvGenericMapRef; diff --git a/libretroshare/src/serialiser/rstlvgenericparam.cc b/libretroshare/src/serialiser/rstlvgenericparam.cc new file mode 100644 index 000000000..ec8452237 --- /dev/null +++ b/libretroshare/src/serialiser/rstlvgenericparam.cc @@ -0,0 +1,235 @@ + +/* + * libretroshare/src/serialiser: rstlvgenericparam.cc + * + * RetroShare Serialiser. + * + * Copyright 2014 by Robert Fernie + * + * 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.1 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 "retroshare@lunamutt.com". + * + */ + +#include "rstlvbase.h" +#include "rstlvtypes.h" +#include "rstlvgenericmap.h" +#include "rsbaseserial.h" +#include "util/rsprint.h" +#include +#include +#include +#include + +#define TLV_DEBUG 1 + +/* generic print */ +template +std::ostream & RsTlvParamRef::print(std::ostream &out, uint16_t indent) +{ + printIndent(out, indent); + out << "Type: " << mParamType << " Param: " << mParam; + return out; +} + + +/***** uint16_t ****/ +template<> +uint32_t RsTlvParamRef::TlvSize() +{ + return GetTlvUInt16Size(); +} + +template<> +void RsTlvParamRef::TlvClear() +{ + mParam = 0; +} + +template<> +bool RsTlvParamRef::SetTlv(void *data, uint32_t size, uint32_t *offset) +{ + uint16_t param = mParam; + return SetTlvUInt16(data, size, offset, mParamType, mParam); +} + +template<> +bool RsTlvParamRef::GetTlv(void *data, uint32_t size, uint32_t *offset) +{ + uint16_t param; + bool retval = GetTlvUInt16(data, size, offset, mParamType, ¶m); + mParam = param; + return retval; +} + +template<> +std::ostream & RsTlvParamRef::print(std::ostream &out, uint16_t indent) +{ + printIndent(out, indent); + out << "Type: " << mParamType << "Param: " << mParam; + return out; +} + + +/***** const uint16_t ****/ + +template<> +uint32_t RsTlvParamRef::TlvSize() +{ + return GetTlvUInt16Size(); +} + +template<> +void RsTlvParamRef::TlvClear() +{ + //mParam = 0; +} + + +template<> +bool RsTlvParamRef::SetTlv(void *data, uint32_t size, uint32_t *offset) +{ + return SetTlvUInt16(data, size, offset, mParamType, mParam); +} + +template<> +bool RsTlvParamRef::GetTlv(void *data, uint32_t size, uint32_t *offset) +{ + return false; //GetTlvUInt16(data, size, offset, mParamType, &mParam); +} + + +template<> +std::ostream & RsTlvParamRef::print(std::ostream &out, uint16_t indent) +{ + printIndent(out, indent); + out << "Type: " << mParamType << "Param: " << mParam; + return out; +} + + +/***** uint32_t ****/ +template<> +uint32_t RsTlvParamRef::TlvSize() +{ + return GetTlvUInt32Size(); +} + +template<> +void RsTlvParamRef::TlvClear() +{ + mParam = 0; +} + +template<> +bool RsTlvParamRef::SetTlv(void *data, uint32_t size, uint32_t *offset) +{ + return SetTlvUInt32(data, size, offset, mParamType, mParam); +} + +template<> +bool RsTlvParamRef::GetTlv(void *data, uint32_t size, uint32_t *offset) +{ + return GetTlvUInt32(data, size, offset, mParamType, &mParam); +} + +template<> +std::ostream & RsTlvParamRef::print(std::ostream &out, uint16_t indent) +{ + printIndent(out, indent); + out << "Type: " << mParamType << "Param: " << mParam; + return out; +} + + + +/***** const uint32_t ****/ +template<> +uint32_t RsTlvParamRef::TlvSize() +{ + return GetTlvUInt32Size(); +} + +template<> +void RsTlvParamRef::TlvClear() +{ + //mParam = 0; +} + +template<> +bool RsTlvParamRef::SetTlv(void *data, uint32_t size, uint32_t *offset) +{ + return SetTlvUInt32(data, size, offset, mParamType, mParam); +} + +template<> +bool RsTlvParamRef::GetTlv(void *data, uint32_t size, uint32_t *offset) +{ + return false; + //GetTlvUInt32(data, size, offset, mParamType, &mParam); +} + +template<> +std::ostream & RsTlvParamRef::print(std::ostream &out, uint16_t indent) +{ + printIndent(out, indent); + out << "Type: " << mParamType << "Param: " << mParam; + return out; +} + + +/***** std::string ****/ +template<> +uint32_t RsTlvParamRef::TlvSize() +{ + return GetTlvStringSize(mParam); +} + +template<> +void RsTlvParamRef::TlvClear() +{ + mParam.clear(); +} + +template<> +bool RsTlvParamRef::SetTlv(void *data, uint32_t size, uint32_t *offset) +{ + return SetTlvString(data, size, offset, mParamType, mParam); +} + +template<> +bool RsTlvParamRef::GetTlv(void *data, uint32_t size, uint32_t *offset) +{ + return GetTlvString(data, size, offset, mParamType, mParam); +} + +template<> +std::ostream & RsTlvParamRef::print(std::ostream &out, uint16_t indent) +{ + printIndent(out, indent); + out << "Type: " << mParamType << "Param: " << mParam; + return out; +} + +// declare likely combinations. +//template class RsTlvParamRef; +//template class RsTlvParamRef; +//template class RsTlvParamRef; + +//template class RsTlvParamRef; +//template class RsTlvParamRef; +//template class RsTlvParamRef; + diff --git a/libretroshare/src/serialiser/rstlvgenericparam.h b/libretroshare/src/serialiser/rstlvgenericparam.h new file mode 100644 index 000000000..6c929ed8f --- /dev/null +++ b/libretroshare/src/serialiser/rstlvgenericparam.h @@ -0,0 +1,59 @@ +#ifndef RS_TLV_GENERIC_PARAM_H +#define RS_TLV_GENERIC_PARAM_H + +/* + * libretroshare/src/serialiser: rstlvgenericparam.h + * + * RetroShare Serialiser. + * + * Copyright 2014 by Robert Fernie + * + * 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.1 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 "retroshare@lunamutt.com". + * + */ + +#include "serialiser/rstlvtypes.h" +#include + +#include +#include + + +/**** TLV ***** + * Generic Parameters / Maps. + */ + + +template +class RsTlvParamRef: public RsTlvItem +{ + public: + RsTlvParamRef(uint16_t param_type, T &p): mParamType(param_type), mParam(p) {} +virtual ~RsTlvParamRef() { return; } +virtual uint32_t TlvSize(); +virtual void TlvClear(); +virtual bool SetTlv(void *data, uint32_t size, uint32_t *offset); /* serialise */ +virtual bool GetTlv(void *data, uint32_t size, uint32_t *offset); /* deserialise */ +virtual std::ostream &print(std::ostream &out, uint16_t indent); + + uint16_t mParamType; + T &mParam; +}; + + +#endif + diff --git a/libretroshare/src/serialiser/rstlvtypes.h b/libretroshare/src/serialiser/rstlvtypes.h index 78fbcb0e8..8bf3414a6 100644 --- a/libretroshare/src/serialiser/rstlvtypes.h +++ b/libretroshare/src/serialiser/rstlvtypes.h @@ -64,6 +64,7 @@ std::ostream &printEnd(std::ostream &out, std::string clsName, uint16_t indent); std::ostream &printIndent(std::ostream &out, uint16_t indent); + //! GENERIC Binary Data TLV /*! Use to serialise and deserialise binary data, usually included in other compound tlvs */ diff --git a/libretroshare/src/services/p3banlist.cc b/libretroshare/src/services/p3banlist.cc index 7f7bc183f..889b77ff8 100644 --- a/libretroshare/src/services/p3banlist.cc +++ b/libretroshare/src/services/p3banlist.cc @@ -58,7 +58,7 @@ p3BanList::p3BanList(p3LinkMgr *lm, p3NetMgr *nm) - :p3Service(RS_SERVICE_TYPE_BANLIST), mBanMtx("p3BanList"), mLinkMgr(lm), mNetMgr(nm) + :p3Service(), mBanMtx("p3BanList"), mLinkMgr(lm), mNetMgr(nm) { addSerialType(new RsBanListSerialiser()); @@ -66,6 +66,24 @@ p3BanList::p3BanList(p3LinkMgr *lm, p3NetMgr *nm) } +const std::string BANLIST_APP_NAME = "banlist"; +const uint16_t BANLIST_APP_MAJOR_VERSION = 1; +const uint16_t BANLIST_APP_MINOR_VERSION = 0; +const uint16_t BANLIST_MIN_MAJOR_VERSION = 1; +const uint16_t BANLIST_MIN_MINOR_VERSION = 0; + +RsServiceInfo p3BanList::getServiceInfo() +{ + return RsServiceInfo(RS_SERVICE_TYPE_BANLIST, + BANLIST_APP_NAME, + BANLIST_APP_MAJOR_VERSION, + BANLIST_APP_MINOR_VERSION, + BANLIST_MIN_MAJOR_VERSION, + BANLIST_MIN_MINOR_VERSION); +} + + + int p3BanList::tick() { processIncoming(); diff --git a/libretroshare/src/services/p3banlist.h b/libretroshare/src/services/p3banlist.h index a5f74aab9..eb08eb064 100644 --- a/libretroshare/src/services/p3banlist.h +++ b/libretroshare/src/services/p3banlist.h @@ -69,6 +69,7 @@ class p3BanList: /* public RsBanList, */ public p3Service, public pqiNetAssistPe { public: p3BanList(p3LinkMgr *lm, p3NetMgr *nm); + virtual RsServiceInfo getServiceInfo(); /***** overloaded from RsBanList *****/ diff --git a/libretroshare/src/services/p3bwctrl.cc b/libretroshare/src/services/p3bwctrl.cc index 02344a701..520c3e381 100644 --- a/libretroshare/src/services/p3bwctrl.cc +++ b/libretroshare/src/services/p3bwctrl.cc @@ -46,7 +46,7 @@ p3BandwidthControl *rsBandwidthControl; p3BandwidthControl::p3BandwidthControl(pqipersongrp *pg) - :p3Service(RS_SERVICE_TYPE_BWCTRL), mPg(pg), mBwMtx("p3BwCtrl") + :p3Service(), mPg(pg), mBwMtx("p3BwCtrl") { addSerialType(new RsBwCtrlSerialiser()); @@ -54,6 +54,24 @@ p3BandwidthControl::p3BandwidthControl(pqipersongrp *pg) } +const std::string BANDWIDTH_CTRL_APP_NAME = "bandwidth_ctrl"; +const uint16_t BANDWIDTH_CTRL_APP_MAJOR_VERSION = 1; +const uint16_t BANDWIDTH_CTRL_APP_MINOR_VERSION = 0; +const uint16_t BANDWIDTH_CTRL_MIN_MAJOR_VERSION = 1; +const uint16_t BANDWIDTH_CTRL_MIN_MINOR_VERSION = 0; + +RsServiceInfo p3BandwidthControl::getServiceInfo() +{ + return RsServiceInfo(RS_SERVICE_TYPE_BWCTRL, + BANDWIDTH_CTRL_APP_NAME, + BANDWIDTH_CTRL_APP_MAJOR_VERSION, + BANDWIDTH_CTRL_APP_MINOR_VERSION, + BANDWIDTH_CTRL_MIN_MAJOR_VERSION, + BANDWIDTH_CTRL_MIN_MINOR_VERSION); +} + + + int p3BandwidthControl::tick() { processIncoming(); diff --git a/libretroshare/src/services/p3bwctrl.h b/libretroshare/src/services/p3bwctrl.h index 305c29f52..b75cf52bf 100644 --- a/libretroshare/src/services/p3bwctrl.h +++ b/libretroshare/src/services/p3bwctrl.h @@ -73,6 +73,7 @@ class p3BandwidthControl: public p3Service, public pqiMonitor { public: p3BandwidthControl(pqipersongrp *pg); + virtual RsServiceInfo getServiceInfo(); /***** overloaded from RsBanList *****/ diff --git a/libretroshare/src/services/p3chatservice.cc b/libretroshare/src/services/p3chatservice.cc index 15e83d6b3..4b8f25bb5 100644 --- a/libretroshare/src/services/p3chatservice.cc +++ b/libretroshare/src/services/p3chatservice.cc @@ -76,7 +76,7 @@ static const uint32_t MAX_MESSAGES_PER_SECONDS_NUMBER = 5 ; // max number o static const uint32_t MAX_MESSAGES_PER_SECONDS_PERIOD = 10 ; // duration window for max number of messages before messages get dropped. p3ChatService::p3ChatService(p3LinkMgr *lm, p3HistoryMgr *historyMgr) - :p3Service(RS_SERVICE_TYPE_CHAT), p3Config(CONFIG_TYPE_CHAT), mChatMtx("p3ChatService"), mLinkMgr(lm) , mHistoryMgr(historyMgr) + :p3Service(), p3Config(CONFIG_TYPE_CHAT), mChatMtx("p3ChatService"), mLinkMgr(lm) , mHistoryMgr(historyMgr) { _serializer = new RsChatSerialiser() ; _own_avatar = NULL ; @@ -91,6 +91,23 @@ p3ChatService::p3ChatService(p3LinkMgr *lm, p3HistoryMgr *historyMgr) addSerialType(_serializer) ; } +const std::string CHAT_APP_NAME = "chat"; +const uint16_t CHAT_APP_MAJOR_VERSION = 1; +const uint16_t CHAT_APP_MINOR_VERSION = 0; +const uint16_t CHAT_MIN_MAJOR_VERSION = 1; +const uint16_t CHAT_MIN_MINOR_VERSION = 0; + +RsServiceInfo p3ChatService::getServiceInfo() +{ + return RsServiceInfo(RS_SERVICE_TYPE_CHAT, + CHAT_APP_NAME, + CHAT_APP_MAJOR_VERSION, + CHAT_APP_MINOR_VERSION, + CHAT_MIN_MAJOR_VERSION, + CHAT_MIN_MINOR_VERSION); +} + + void p3ChatService::connectToTurtleRouter(p3turtle *tr) { mTurtle = tr ; diff --git a/libretroshare/src/services/p3chatservice.h b/libretroshare/src/services/p3chatservice.h index 1c5a1155b..0fba7cdad 100644 --- a/libretroshare/src/services/p3chatservice.h +++ b/libretroshare/src/services/p3chatservice.h @@ -55,6 +55,8 @@ class p3ChatService: public p3Service, public p3Config, public pqiMonitor, publi public: p3ChatService(p3LinkMgr *cm, p3HistoryMgr *historyMgr); + virtual RsServiceInfo getServiceInfo(); + /***** overloaded from p3Service *****/ /*! * This retrieves all chat msg items and also (important!) diff --git a/libretroshare/src/services/p3discovery2.cc b/libretroshare/src/services/p3discovery2.cc index 554ae26fe..7493f799c 100644 --- a/libretroshare/src/services/p3discovery2.cc +++ b/libretroshare/src/services/p3discovery2.cc @@ -85,7 +85,7 @@ void DiscPgpInfo::mergeFriendList(const std::list &friends) p3discovery2::p3discovery2(p3PeerMgr *peerMgr, p3LinkMgr *linkMgr, p3NetMgr *netMgr) -:p3Service(RS_SERVICE_TYPE_DISC), mPeerMgr(peerMgr), mLinkMgr(linkMgr), mNetMgr(netMgr), +:p3Service(), mPeerMgr(peerMgr), mLinkMgr(linkMgr), mNetMgr(netMgr), mDiscMtx("p3discovery2") { RsStackMutex stack(mDiscMtx); /********** STACK LOCKED MTX ******/ @@ -105,6 +105,28 @@ p3discovery2::p3discovery2(p3PeerMgr *peerMgr, p3LinkMgr *linkMgr, p3NetMgr *net return; } + +const std::string DISCOVERY_APP_NAME = "disc"; +const uint16_t DISCOVERY_APP_MAJOR_VERSION = 1; +const uint16_t DISCOVERY_APP_MINOR_VERSION = 0; +const uint16_t DISCOVERY_MIN_MAJOR_VERSION = 1; +const uint16_t DISCOVERY_MIN_MINOR_VERSION = 0; + +RsServiceInfo p3discovery2::getServiceInfo() +{ + return RsServiceInfo(RS_SERVICE_TYPE_DISC, + DISCOVERY_APP_NAME, + DISCOVERY_APP_MAJOR_VERSION, + DISCOVERY_APP_MINOR_VERSION, + DISCOVERY_MIN_MAJOR_VERSION, + DISCOVERY_MIN_MINOR_VERSION); +} + + + + + + p3discovery2::~p3discovery2() { return; diff --git a/libretroshare/src/services/p3discovery2.h b/libretroshare/src/services/p3discovery2.h index 8b8bf96a8..c29347fcc 100644 --- a/libretroshare/src/services/p3discovery2.h +++ b/libretroshare/src/services/p3discovery2.h @@ -81,6 +81,8 @@ class p3discovery2: public RsDisc, public p3Service, public pqiMonitor, public A p3discovery2(p3PeerMgr *peerMgr, p3LinkMgr *linkMgr, p3NetMgr *netMgr); virtual ~p3discovery2(); +virtual RsServiceInfo getServiceInfo(); + /************* from pqiMonitor *******************/ virtual void statusChange(const std::list &plist); /************* from pqiMonitor *******************/ diff --git a/libretroshare/src/services/p3dsdv.cc b/libretroshare/src/services/p3dsdv.cc index 613e0b8a9..56420829a 100644 --- a/libretroshare/src/services/p3dsdv.cc +++ b/libretroshare/src/services/p3dsdv.cc @@ -64,7 +64,7 @@ RsDsdv *rsDsdv = NULL; ****/ p3Dsdv::p3Dsdv(p3LinkMgr *lm) - :p3Service(RS_SERVICE_TYPE_DSDV), /* p3Config(CONFIG_TYPE_DSDV), */ mDsdvMtx("p3Dsdv"), mLinkMgr(lm) + :p3Service(), /* p3Config(CONFIG_TYPE_DSDV), */ mDsdvMtx("p3Dsdv"), mLinkMgr(lm) { addSerialType(new RsDsdvSerialiser()); @@ -72,6 +72,24 @@ p3Dsdv::p3Dsdv(p3LinkMgr *lm) mSentIncrementTime = 0; } +const std::string DSDV_APP_NAME = "dsdv"; +const uint16_t DSDV_APP_MAJOR_VERSION = 1; +const uint16_t DSDV_APP_MINOR_VERSION = 0; +const uint16_t DSDV_MIN_MAJOR_VERSION = 1; +const uint16_t DSDV_MIN_MINOR_VERSION = 0; + +RsServiceInfo p3Dsdv::getServiceInfo() +{ + return RsServiceInfo(RS_SERVICE_TYPE_DSDV, + DSDV_APP_NAME, + DSDV_APP_MAJOR_VERSION, + DSDV_APP_MINOR_VERSION, + DSDV_MIN_MAJOR_VERSION, + DSDV_MIN_MINOR_VERSION); +} + + + int p3Dsdv::tick() { processIncoming(); diff --git a/libretroshare/src/services/p3dsdv.h b/libretroshare/src/services/p3dsdv.h index ccd248712..e11464c3f 100644 --- a/libretroshare/src/services/p3dsdv.h +++ b/libretroshare/src/services/p3dsdv.h @@ -53,6 +53,7 @@ class p3Dsdv: public RsDsdv, public p3Service /* , public p3Config */, public pq { public: p3Dsdv(p3LinkMgr *cm); +virtual RsServiceInfo getServiceInfo(); /*** internal librs interface ****/ diff --git a/libretroshare/src/services/p3gxschannels.cc b/libretroshare/src/services/p3gxschannels.cc index d303e3aa3..3d51dee84 100644 --- a/libretroshare/src/services/p3gxschannels.cc +++ b/libretroshare/src/services/p3gxschannels.cc @@ -78,6 +78,24 @@ p3GxsChannels::p3GxsChannels(RsGeneralDataService *gds, RsNetworkExchangeService } + +const std::string GXS_CHANNELS_APP_NAME = "gxschannels"; +const uint16_t GXS_CHANNELS_APP_MAJOR_VERSION = 1; +const uint16_t GXS_CHANNELS_APP_MINOR_VERSION = 0; +const uint16_t GXS_CHANNELS_MIN_MAJOR_VERSION = 1; +const uint16_t GXS_CHANNELS_MIN_MINOR_VERSION = 0; + +RsServiceInfo p3GxsChannels::getServiceInfo() +{ + return RsServiceInfo(RS_SERVICE_GXSV2_TYPE_CHANNELS, + GXS_CHANNELS_APP_NAME, + GXS_CHANNELS_APP_MAJOR_VERSION, + GXS_CHANNELS_APP_MINOR_VERSION, + GXS_CHANNELS_MIN_MAJOR_VERSION, + GXS_CHANNELS_MIN_MINOR_VERSION); +} + + uint32_t p3GxsChannels::channelsAuthenPolicy() { uint32_t policy = 0; diff --git a/libretroshare/src/services/p3gxschannels.h b/libretroshare/src/services/p3gxschannels.h index ec5b23223..0a5e5be41 100644 --- a/libretroshare/src/services/p3gxschannels.h +++ b/libretroshare/src/services/p3gxschannels.h @@ -60,6 +60,7 @@ class p3GxsChannels: public RsGenExchange, public RsGxsChannels, public: p3GxsChannels(RsGeneralDataService* gds, RsNetworkExchangeService* nes, RsGixs* gixs); +virtual RsServiceInfo getServiceInfo(); virtual void service_tick(); diff --git a/libretroshare/src/services/p3gxscircles.cc b/libretroshare/src/services/p3gxscircles.cc index e8916dfa4..2bf3cbff3 100644 --- a/libretroshare/src/services/p3gxscircles.cc +++ b/libretroshare/src/services/p3gxscircles.cc @@ -130,6 +130,24 @@ p3GxsCircles::p3GxsCircles(RsGeneralDataService *gds, RsNetworkExchangeService * } +const std::string GXS_CIRCLES_APP_NAME = "gxscircle"; +const uint16_t GXS_CIRCLES_APP_MAJOR_VERSION = 1; +const uint16_t GXS_CIRCLES_APP_MINOR_VERSION = 0; +const uint16_t GXS_CIRCLES_MIN_MAJOR_VERSION = 1; +const uint16_t GXS_CIRCLES_MIN_MINOR_VERSION = 0; + +RsServiceInfo p3GxsCircles::getServiceInfo() +{ + return RsServiceInfo(RS_SERVICE_GXSV2_TYPE_GXSCIRCLE, + GXS_CIRCLES_APP_NAME, + GXS_CIRCLES_APP_MAJOR_VERSION, + GXS_CIRCLES_APP_MINOR_VERSION, + GXS_CIRCLES_MIN_MAJOR_VERSION, + GXS_CIRCLES_MIN_MINOR_VERSION); +} + + + uint32_t p3GxsCircles::circleAuthenPolicy() { diff --git a/libretroshare/src/services/p3gxscircles.h b/libretroshare/src/services/p3gxscircles.h index 4fc79e774..56d794670 100644 --- a/libretroshare/src/services/p3gxscircles.h +++ b/libretroshare/src/services/p3gxscircles.h @@ -135,6 +135,8 @@ class p3GxsCircles: public RsGxsCircleExchange, public RsGxsCircles, p3GxsCircles(RsGeneralDataService* gds, RsNetworkExchangeService* nes, p3IdService *identities); +virtual RsServiceInfo getServiceInfo(); + /*********** External Interface ***************/ virtual bool getCircleDetails(const RsGxsCircleId &id, RsGxsCircleDetails &details); diff --git a/libretroshare/src/services/p3gxsforums.cc b/libretroshare/src/services/p3gxsforums.cc index 0a0aaf84b..7559f6a31 100644 --- a/libretroshare/src/services/p3gxsforums.cc +++ b/libretroshare/src/services/p3gxsforums.cc @@ -61,6 +61,24 @@ p3GxsForums::p3GxsForums(RsGeneralDataService *gds, RsNetworkExchangeService *ne } + +const std::string GXS_FORUMS_APP_NAME = "gxsforums"; +const uint16_t GXS_FORUMS_APP_MAJOR_VERSION = 1; +const uint16_t GXS_FORUMS_APP_MINOR_VERSION = 0; +const uint16_t GXS_FORUMS_MIN_MAJOR_VERSION = 1; +const uint16_t GXS_FORUMS_MIN_MINOR_VERSION = 0; + +RsServiceInfo p3GxsForums::getServiceInfo() +{ + return RsServiceInfo(RS_SERVICE_GXSV2_TYPE_FORUMS, + GXS_FORUMS_APP_NAME, + GXS_FORUMS_APP_MAJOR_VERSION, + GXS_FORUMS_APP_MINOR_VERSION, + GXS_FORUMS_MIN_MAJOR_VERSION, + GXS_FORUMS_MIN_MINOR_VERSION); +} + + uint32_t p3GxsForums::forumsAuthenPolicy() { uint32_t policy = 0; diff --git a/libretroshare/src/services/p3gxsforums.h b/libretroshare/src/services/p3gxsforums.h index 2dc11c361..884ad3820 100644 --- a/libretroshare/src/services/p3gxsforums.h +++ b/libretroshare/src/services/p3gxsforums.h @@ -46,6 +46,8 @@ class p3GxsForums: public RsGenExchange, public RsGxsForums, p3GxsForums(RsGeneralDataService* gds, RsNetworkExchangeService* nes, RsGixs* gixs); +virtual RsServiceInfo getServiceInfo(); + virtual void service_tick(); protected: diff --git a/libretroshare/src/services/p3gxsreputation.cc b/libretroshare/src/services/p3gxsreputation.cc index 1e536d82b..e89aaa00f 100644 --- a/libretroshare/src/services/p3gxsreputation.cc +++ b/libretroshare/src/services/p3gxsreputation.cc @@ -123,7 +123,7 @@ uint32_t ConvertToSerialised(int32_t value, bool limit) p3GxsReputation::p3GxsReputation(p3LinkMgr *lm) - :p3Service(RS_SERVICE_GXSV2_TYPE_REPUTATION), p3Config(CONFIG_TYPE_GXS_REPUTATION), + :p3Service(), p3Config(CONFIG_TYPE_GXS_REPUTATION), mReputationMtx("p3GxsReputation"), mLinkMgr(lm) { addSerialType(new RsGxsReputationSerialiser()); @@ -134,6 +134,24 @@ p3GxsReputation::p3GxsReputation(p3LinkMgr *lm) } +const std::string GXS_REPUTATION_APP_NAME = "gxsreputation"; +const uint16_t GXS_REPUTATION_APP_MAJOR_VERSION = 1; +const uint16_t GXS_REPUTATION_APP_MINOR_VERSION = 0; +const uint16_t GXS_REPUTATION_MIN_MAJOR_VERSION = 1; +const uint16_t GXS_REPUTATION_MIN_MINOR_VERSION = 0; + +RsServiceInfo p3GxsReputation::getServiceInfo() +{ + return RsServiceInfo(RS_SERVICE_GXSV2_TYPE_REPUTATION, + GXS_REPUTATION_APP_NAME, + GXS_REPUTATION_APP_MAJOR_VERSION, + GXS_REPUTATION_APP_MINOR_VERSION, + GXS_REPUTATION_MIN_MAJOR_VERSION, + GXS_REPUTATION_MIN_MINOR_VERSION); +} + + + int p3GxsReputation::tick() { processIncoming(); diff --git a/libretroshare/src/services/p3gxsreputation.h b/libretroshare/src/services/p3gxsreputation.h index 1761941f8..9c6622e38 100644 --- a/libretroshare/src/services/p3gxsreputation.h +++ b/libretroshare/src/services/p3gxsreputation.h @@ -84,6 +84,7 @@ class p3GxsReputation: public p3Service, public p3Config /* , public pqiMonitor { public: p3GxsReputation(p3LinkMgr *lm); + virtual RsServiceInfo getServiceInfo(); /***** Interface for p3idservice *****/ diff --git a/libretroshare/src/services/p3heartbeat.cc b/libretroshare/src/services/p3heartbeat.cc index a70e1e000..72128fd4a 100644 --- a/libretroshare/src/services/p3heartbeat.cc +++ b/libretroshare/src/services/p3heartbeat.cc @@ -32,7 +32,7 @@ p3heartbeat::p3heartbeat(p3LinkMgr *linkMgr, pqipersongrp *pqipg) -:p3Service(RS_SERVICE_TYPE_HEARTBEAT), mLinkMgr(linkMgr), mPqiPersonGrp(pqipg), +:p3Service(), mLinkMgr(linkMgr), mPqiPersonGrp(pqipg), mHeartMtx("p3heartbeat") { RsStackMutex stack(mHeartMtx); /********** STACK LOCKED MTX ******/ @@ -55,6 +55,24 @@ p3heartbeat::~p3heartbeat() } + +const std::string HEARTBEAT_APP_NAME = "heartbeat"; +const uint16_t HEARTBEAT_APP_MAJOR_VERSION = 1; +const uint16_t HEARTBEAT_APP_MINOR_VERSION = 0; +const uint16_t HEARTBEAT_MIN_MAJOR_VERSION = 1; +const uint16_t HEARTBEAT_MIN_MINOR_VERSION = 0; + +RsServiceInfo p3heartbeat::getServiceInfo() +{ + return RsServiceInfo(RS_SERVICE_TYPE_HEARTBEAT, + HEARTBEAT_APP_NAME, + HEARTBEAT_APP_MAJOR_VERSION, + HEARTBEAT_APP_MINOR_VERSION, + HEARTBEAT_MIN_MAJOR_VERSION, + HEARTBEAT_MIN_MINOR_VERSION); +} + + int p3heartbeat::tick() { //send a heartbeat to all connected peers diff --git a/libretroshare/src/services/p3heartbeat.h b/libretroshare/src/services/p3heartbeat.h index 7d15a3518..5291f3963 100644 --- a/libretroshare/src/services/p3heartbeat.h +++ b/libretroshare/src/services/p3heartbeat.h @@ -40,6 +40,8 @@ class p3heartbeat: public p3Service p3heartbeat(p3LinkMgr *linkMgr, pqipersongrp *pqipg); virtual ~p3heartbeat(); +virtual RsServiceInfo getServiceInfo(); + int tick(); private: diff --git a/libretroshare/src/services/p3idservice.cc b/libretroshare/src/services/p3idservice.cc index 56b399db0..58f6de61b 100644 --- a/libretroshare/src/services/p3idservice.cc +++ b/libretroshare/src/services/p3idservice.cc @@ -165,6 +165,24 @@ p3IdService::p3IdService(RsGeneralDataService *gds, RsNetworkExchangeService *ne loadRecognKeys(); } +const std::string GXSID_APP_NAME = "gxsid"; +const uint16_t GXSID_APP_MAJOR_VERSION = 1; +const uint16_t GXSID_APP_MINOR_VERSION = 0; +const uint16_t GXSID_MIN_MAJOR_VERSION = 1; +const uint16_t GXSID_MIN_MINOR_VERSION = 0; + +RsServiceInfo p3IdService::getServiceInfo() +{ + return RsServiceInfo(RS_SERVICE_GXSV2_TYPE_GXSID, + GXSID_APP_NAME, + GXSID_APP_MAJOR_VERSION, + GXSID_APP_MINOR_VERSION, + GXSID_MIN_MAJOR_VERSION, + GXSID_MIN_MINOR_VERSION); +} + + + void p3IdService::setNes(RsNetworkExchangeService *nes) { RsStackMutex stack(mIdMtx); diff --git a/libretroshare/src/services/p3idservice.h b/libretroshare/src/services/p3idservice.h index e66c2b57e..21ab9270f 100644 --- a/libretroshare/src/services/p3idservice.h +++ b/libretroshare/src/services/p3idservice.h @@ -216,6 +216,8 @@ class p3IdService: public RsGxsIdExchange, public RsIdentity, { public: p3IdService(RsGeneralDataService* gds, RsNetworkExchangeService* nes); + +virtual RsServiceInfo getServiceInfo(); static uint32_t idAuthenPolicy(); virtual void service_tick(); // needed for background processing. diff --git a/libretroshare/src/services/p3msgservice.cc b/libretroshare/src/services/p3msgservice.cc index 1af330494..dd28f8563 100644 --- a/libretroshare/src/services/p3msgservice.cc +++ b/libretroshare/src/services/p3msgservice.cc @@ -76,7 +76,7 @@ static const uint8_t ENCRYPTED_MSG_PROTOCOL_VERSION_01 = 0x37 ; p3MsgService::p3MsgService(p3LinkMgr *lm) - :p3Service(RS_SERVICE_TYPE_MSG), p3Config(CONFIG_TYPE_MSGS), + :p3Service(), p3Config(CONFIG_TYPE_MSGS), mLinkMgr(lm), mMsgMtx("p3MsgService"), mMsgUniqueId(time(NULL)) { _serialiser = new RsMsgSerialiser(); @@ -108,6 +108,23 @@ p3MsgService::p3MsgService(p3LinkMgr *lm) #endif } +const std::string MSG_APP_NAME = "msg"; +const uint16_t MSG_APP_MAJOR_VERSION = 1; +const uint16_t MSG_APP_MINOR_VERSION = 0; +const uint16_t MSG_MIN_MAJOR_VERSION = 1; +const uint16_t MSG_MIN_MINOR_VERSION = 0; + +RsServiceInfo p3MsgService::getServiceInfo() +{ + return RsServiceInfo(RS_SERVICE_TYPE_MSG, + MSG_APP_NAME, + MSG_APP_MAJOR_VERSION, + MSG_APP_MINOR_VERSION, + MSG_MIN_MAJOR_VERSION, + MSG_MIN_MINOR_VERSION); +} + + uint32_t p3MsgService::getNewUniqueMsgId() { RsStackMutex stack(mMsgMtx); /********** STACK LOCKED MTX ******/ diff --git a/libretroshare/src/services/p3msgservice.h b/libretroshare/src/services/p3msgservice.h index 91c050fa4..0a6cd2d9d 100644 --- a/libretroshare/src/services/p3msgservice.h +++ b/libretroshare/src/services/p3msgservice.h @@ -60,6 +60,7 @@ class p3MsgService: public p3Service, public p3Config, public pqiMonitor, public { public: p3MsgService(p3LinkMgr *lm); +virtual RsServiceInfo getServiceInfo(); /* External Interface */ bool getMessageSummaries(std::list &msgList); diff --git a/libretroshare/src/services/p3photoservice.cc b/libretroshare/src/services/p3photoservice.cc index d1138c6bb..2a69a0eff 100644 --- a/libretroshare/src/services/p3photoservice.cc +++ b/libretroshare/src/services/p3photoservice.cc @@ -92,6 +92,23 @@ p3PhotoService::p3PhotoService(RsGeneralDataService* gds, RsNetworkExchangeServi { } +const std::string GXS_PHOTO_APP_NAME = "gxsphoto"; +const uint16_t GXS_PHOTO_APP_MAJOR_VERSION = 1; +const uint16_t GXS_PHOTO_APP_MINOR_VERSION = 0; +const uint16_t GXS_PHOTO_MIN_MAJOR_VERSION = 1; +const uint16_t GXS_PHOTO_MIN_MINOR_VERSION = 0; + +RsServiceInfo p3PhotoService::getServiceInfo() +{ + return RsServiceInfo(RS_SERVICE_GXSV2_TYPE_PHOTO, + GXS_PHOTO_APP_NAME, + GXS_PHOTO_APP_MAJOR_VERSION, + GXS_PHOTO_APP_MINOR_VERSION, + GXS_PHOTO_MIN_MAJOR_VERSION, + GXS_PHOTO_MIN_MINOR_VERSION); +} + + uint32_t p3PhotoService::photoAuthenPolicy() { diff --git a/libretroshare/src/services/p3photoservice.h b/libretroshare/src/services/p3photoservice.h index 5140fdac0..236687301 100644 --- a/libretroshare/src/services/p3photoservice.h +++ b/libretroshare/src/services/p3photoservice.h @@ -34,6 +34,7 @@ class p3PhotoService : public RsPhoto, public RsGenExchange public: p3PhotoService(RsGeneralDataService* gds, RsNetworkExchangeService* nes, RsGixs* gixs); +virtual RsServiceInfo getServiceInfo(); static uint32_t photoAuthenPolicy(); diff --git a/libretroshare/src/services/p3posted.cc b/libretroshare/src/services/p3posted.cc index edc4f408d..ca3a17cf2 100644 --- a/libretroshare/src/services/p3posted.cc +++ b/libretroshare/src/services/p3posted.cc @@ -46,6 +46,24 @@ p3Posted::p3Posted(RsGeneralDataService *gds, RsNetworkExchangeService *nes, RsG } +const std::string GXS_POSTED_APP_NAME = "gxsposted"; +const uint16_t GXS_POSTED_APP_MAJOR_VERSION = 1; +const uint16_t GXS_POSTED_APP_MINOR_VERSION = 0; +const uint16_t GXS_POSTED_MIN_MAJOR_VERSION = 1; +const uint16_t GXS_POSTED_MIN_MINOR_VERSION = 0; + +RsServiceInfo p3Posted::getServiceInfo() +{ + return RsServiceInfo(RS_SERVICE_GXSV2_TYPE_POSTED, + GXS_POSTED_APP_NAME, + GXS_POSTED_APP_MAJOR_VERSION, + GXS_POSTED_APP_MINOR_VERSION, + GXS_POSTED_MIN_MAJOR_VERSION, + GXS_POSTED_MIN_MINOR_VERSION); +} + + + bool p3Posted::getGroupData(const uint32_t &token, std::vector &groups) { std::vector grpData; diff --git a/libretroshare/src/services/p3posted.h b/libretroshare/src/services/p3posted.h index 19ee22915..f9590dc69 100644 --- a/libretroshare/src/services/p3posted.h +++ b/libretroshare/src/services/p3posted.h @@ -45,6 +45,7 @@ class p3Posted: public p3PostBase, public RsPosted public: p3Posted(RsGeneralDataService* gds, RsNetworkExchangeService* nes, RsGixs* gixs); +virtual RsServiceInfo getServiceInfo(); protected: diff --git a/libretroshare/src/services/p3rtt.cc b/libretroshare/src/services/p3rtt.cc index 616f6a0f5..c203b83fc 100644 --- a/libretroshare/src/services/p3rtt.cc +++ b/libretroshare/src/services/p3rtt.cc @@ -117,7 +117,7 @@ static double convert64bitsToTs(uint64_t bits) p3rtt::p3rtt(p3LinkMgr *lm) - :p3FastService(RS_SERVICE_TYPE_RTT), mRttMtx("p3rtt"), mLinkMgr(lm) + :p3FastService(), mRttMtx("p3rtt"), mLinkMgr(lm) { addSerialType(new RsRttSerialiser()); @@ -127,6 +127,24 @@ p3rtt::p3rtt(p3LinkMgr *lm) } +const std::string RTT_APP_NAME = "rtt"; +const uint16_t RTT_APP_MAJOR_VERSION = 1; +const uint16_t RTT_APP_MINOR_VERSION = 0; +const uint16_t RTT_MIN_MAJOR_VERSION = 1; +const uint16_t RTT_MIN_MINOR_VERSION = 0; + +RsServiceInfo p3rtt::getServiceInfo() +{ + return RsServiceInfo(RS_SERVICE_TYPE_RTT, + RTT_APP_NAME, + RTT_APP_MAJOR_VERSION, + RTT_APP_MINOR_VERSION, + RTT_MIN_MAJOR_VERSION, + RTT_MIN_MINOR_VERSION); +} + + + int p3rtt::tick() { sendPackets(); diff --git a/libretroshare/src/services/p3rtt.h b/libretroshare/src/services/p3rtt.h index 5d28b905c..b62c21ceb 100644 --- a/libretroshare/src/services/p3rtt.h +++ b/libretroshare/src/services/p3rtt.h @@ -64,6 +64,7 @@ class p3rtt: public RsRtt, public p3FastService { public: p3rtt(p3LinkMgr *cm); +virtual RsServiceInfo getServiceInfo(); /***** overloaded from rsRtt *****/ diff --git a/libretroshare/src/services/p3service.h b/libretroshare/src/services/p3service.h index 9d527ccb2..c5a204471 100644 --- a/libretroshare/src/services/p3service.h +++ b/libretroshare/src/services/p3service.h @@ -53,12 +53,16 @@ std::string generateRandomServiceId(); //TODO : encryption and upload / download rate implementation +// p3FastService(uint16_t type) +// :pqiService((((uint32_t) RS_PKT_VERSION_SERVICE) << 24) + (((uint32_t) type) << 8)), + + class p3FastService: public pqiService { protected: - p3FastService(uint16_t type) - :pqiService((((uint32_t) RS_PKT_VERSION_SERVICE) << 24) + (((uint32_t) type) << 8)), + p3FastService() + :pqiService(), srvMtx("p3FastService"), rsSerialiser(NULL) { rsSerialiser = new RsSerialiser(); @@ -95,8 +99,8 @@ class p3Service: public p3FastService { protected: - p3Service(uint16_t type) - :p3FastService(type) + p3Service() + :p3FastService() { return; } @@ -127,8 +131,8 @@ class nullService: public pqiService { protected: - nullService(uint16_t type) - :pqiService((((uint32_t) RS_PKT_VERSION_SERVICE) << 24) + (((uint32_t) type) << 8)) + nullService() + :pqiService() { return; } @@ -157,8 +161,8 @@ class p3ThreadedService: public p3Service, public RsThread { protected: - p3ThreadedService(uint16_t type) - :p3Service(type) { return; } + p3ThreadedService() + :p3Service() { return; } public: diff --git a/libretroshare/src/services/p3serviceinfo.cc b/libretroshare/src/services/p3serviceinfo.cc new file mode 100644 index 000000000..25cd332e7 --- /dev/null +++ b/libretroshare/src/services/p3serviceinfo.cc @@ -0,0 +1,254 @@ +/* + * libretroshare/src/services p3serviceinfo.cc + * + * ServiceInfo Service for RetroShare. + * + * Copyright 2014 by Robert Fernie. + * + * 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.1 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 "retroshare@lunamutt.com". + * + */ + +#include "pqi/p3linkmgr.h" +#include "pqi/p3netmgr.h" + +#include "util/rsnet.h" + +#include "services/p3serviceinfo.h" +#include "serialiser/rsbanlistitems.h" + +#include + +/**** + * #define DEBUG_INFO 1 + ****/ + +/************ IMPLEMENTATION NOTES ********************************* + * + * Send Info to peers about services we are providing. + */ + +p3ServiceInfo::p3ServiceInfo(p3ServiceControl *serviceControl) + :p3Service(), mInfoMtx("p3ServiceInfo"), + mServiceControl(serviceControl) +{ + addSerialType(new RsServiceInfoSerialiser()); +} + +const std::string SERVICE_INFO_APP_NAME = "serviceinfo"; +const uint16_t SERVICE_INFO_APP_MAJOR_VERSION = 1; +const uint16_t SERVICE_INFO_APP_MINOR_VERSION = 0; +const uint16_t SERVICE_INFO_MIN_MAJOR_VERSION = 1; +const uint16_t SERVICE_INFO_MIN_MINOR_VERSION = 0; + +RsServiceInfo p3ServiceInfo::getServiceInfo() +{ + return RsServiceInfo(RS_SERVICE_TYPE_SERVICEINFO, + SERVICE_INFO_APP_NAME, + SERVICE_INFO_APP_MAJOR_VERSION, + SERVICE_INFO_APP_MINOR_VERSION, + SERVICE_INFO_MIN_MAJOR_VERSION, + SERVICE_INFO_MIN_MINOR_VERSION); +} + + + +int p3ServiceInfo::tick() +{ + processIncoming(); + sendPackets(); + return 0; +} + +int p3ServiceInfo::status() +{ + return 1; +} + + +/***** Implementation ******/ + +bool p3ServiceInfo::processIncoming() +{ + /* for each packet - pass to specific handler */ + RsItem *item = NULL; + while(NULL != (item = recvItem())) + { +#ifdef DEBUG_INFO + std::cerr << "p3ServiceInfo::processingIncoming() Received Item:"; + std::cerr << std::endl; + item->print(std::cerr); + std::cerr << std::endl; +#endif + switch(item->PacketSubType()) + { + default: + break; + case RS_PKT_SUBTYPE_SERVICELIST_ITEM: + { + // Order is important!. + RsServiceInfoListItem *listItem = dynamic_cast(item); + if (listItem) + { + recvServiceInfoList(listItem); + } + else + { + // error. + std::cerr << "p3ServiceInfo::processingIncoming() Error with Received Item:"; + std::cerr << std::endl; + item->print(std::cerr); + std::cerr << std::endl; + } + } + break; + } + + /* clean up */ + delete item; + } + return true ; +} + + +bool convertServiceInfoToItem( + const RsPeerServiceInfo &info, + RsServiceInfoListItem *item) +{ + item->mServiceInfo = info.mServiceList; + item->PeerId(info.mPeerId); + return true; +} + +bool convertServiceItemToInfo( + const RsServiceInfoListItem *item, + RsPeerServiceInfo &info) +{ + info.mServiceList = item->mServiceInfo; + info.mPeerId = item->PeerId(); + return true; +} + + +bool p3ServiceInfo::recvServiceInfoList(RsServiceInfoListItem *item) +{ + RsPeerId peerId = item->PeerId(); + + std::cerr << "p3ServiceInfo::recvServiceInfoList() from: " << peerId.toStdString(); + std::cerr << std::endl; + + RsPeerServiceInfo info; + if (convertServiceItemToInfo(item, info)) + { + +#ifdef DEBUG_INFO + std::cerr << "p3ServiceInfo::recvServiceInfoList() Info: "; + std::cerr << std::endl; + std::cerr << info; + std::cerr << std::endl; +#endif + + /* update service control */ + mServiceControl->updateServicesProvided(peerId, info); + return true; + } + return false; +} + + +bool p3ServiceInfo::sendPackets() +{ + std::set updateSet; + + { + RsStackMutex stack(mInfoMtx); /****** LOCKED MUTEX *******/ + updateSet = mPeersToUpdate; + mPeersToUpdate.clear(); + } + + mServiceControl->getServiceChanges(updateSet); + + RsStackMutex stack(mInfoMtx); /****** LOCKED MUTEX *******/ + std::set::iterator it; + for(it = updateSet.begin(); it != updateSet.end(); it++) + { + sendServiceInfoList(*it); + } + + return (!updateSet.empty()); +} + + +int p3ServiceInfo::sendServiceInfoList(const RsPeerId &peerId) +{ + std::cerr << "p3ServiceInfo::sendServiceInfoList() to " << peerId.toStdString(); + std::cerr << std::endl; + + RsServiceInfoListItem *item = new RsServiceInfoListItem(); + + RsPeerServiceInfo info; + bool sent = false; + if (mServiceControl->getServicesAllowed(peerId, info)) + { + std::cerr << "p3ServiceInfo::sendServiceInfoList() Info: "; + std::cerr << std::endl; + std::cerr << info; + std::cerr << std::endl; + + if (convertServiceInfoToItem(info, item)) + { + item->PeerId(peerId); + + sent = true; + sendItem(item); + } + } + + if (!sent) + { + delete item; + } + + return sent; +} + +void p3ServiceInfo::statusChange(const std::list &plist) +{ + std::cerr << "p3ServiceInfo::statusChange()"; + std::cerr << std::endl; + + std::list::const_iterator it; + for (it = plist.begin(); it != plist.end(); it++) + { + if (it->state & RS_PEER_S_FRIEND) + { + if (it->actions & RS_PEER_CONNECTED) + { + std::cerr << "p3ServiceInfo::statusChange()"; + std::cerr << "Peer: " << it->id; + std::cerr << " Connected"; + std::cerr << std::endl; + + RsStackMutex stack(mInfoMtx); /****** LOCKED MUTEX *******/ + mPeersToUpdate.insert(it->id); + } + } + } +} + + + diff --git a/libretroshare/src/services/p3serviceinfo.h b/libretroshare/src/services/p3serviceinfo.h new file mode 100644 index 000000000..4d776e44e --- /dev/null +++ b/libretroshare/src/services/p3serviceinfo.h @@ -0,0 +1,75 @@ +/* + * libretroshare/src/services/p3serviceinfo.h + * + * Exchange list of Service Information. + * + * Copyright 2014 by Robert Fernie. + * + * 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.1 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 "retroshare@lunamutt.com". + * + */ + + +#ifndef SERVICE_RSSERVICEINFO_HEADER +#define SERVICE_RSSERVICEINFO_HEADER + +#include +#include +#include + +#include "pqi/p3servicecontrol.h" +#include "pqi/pqimonitor.h" + +#include "services/p3service.h" + +#include "serialiser/rsserviceinfoitems.h" + +//!The ServiceInfo service. + /** + * + * Exchange list of Available Services with peers. + */ + +class p3ServiceInfo: public p3Service, public pqiMonitor +{ + public: + p3ServiceInfo(p3ServiceControl *serviceControl); + virtual RsServiceInfo getServiceInfo(); + + virtual int tick(); + virtual int status(); + + /*************** pqiMonitor callback ***********************/ + virtual void statusChange(const std::list &plist); + + private: + + bool sendPackets(); + bool processIncoming(); + + bool recvServiceInfoList(RsServiceInfoListItem *item); + int sendServiceInfoList(const RsPeerId &peerid); + + private: + RsMutex mInfoMtx; + + std::set mPeersToUpdate; + p3ServiceControl *mServiceControl; +}; + +#endif // SERVICE_RSSERVICEINFO_HEADER + diff --git a/libretroshare/src/services/p3statusservice.cc b/libretroshare/src/services/p3statusservice.cc index 89fd69f9d..bcc324858 100644 --- a/libretroshare/src/services/p3statusservice.cc +++ b/libretroshare/src/services/p3statusservice.cc @@ -48,7 +48,7 @@ std::ostream& operator<<(std::ostream& out, const StatusInfo& si) RsStatus *rsStatus = NULL; p3StatusService::p3StatusService(p3LinkMgr *cm) - :p3Service(RS_SERVICE_TYPE_STATUS), p3Config(CONFIG_TYPE_STATUS), mLinkMgr(cm), mStatusMtx("p3StatusService") + :p3Service(), p3Config(CONFIG_TYPE_STATUS), mLinkMgr(cm), mStatusMtx("p3StatusService") { addSerialType(new RsStatusSerialiser()); @@ -58,6 +58,24 @@ p3StatusService::~p3StatusService() { } + +const std::string STATUS_APP_NAME = "status"; +const uint16_t STATUS_APP_MAJOR_VERSION = 1; +const uint16_t STATUS_APP_MINOR_VERSION = 0; +const uint16_t STATUS_MIN_MAJOR_VERSION = 1; +const uint16_t STATUS_MIN_MINOR_VERSION = 0; + +RsServiceInfo p3StatusService::getServiceInfo() +{ + return RsServiceInfo(RS_SERVICE_TYPE_STATUS, + STATUS_APP_NAME, + STATUS_APP_MAJOR_VERSION, + STATUS_APP_MINOR_VERSION, + STATUS_MIN_MAJOR_VERSION, + STATUS_MIN_MINOR_VERSION); +} + + bool p3StatusService::getOwnStatus(StatusInfo& statusInfo) { #ifdef STATUS_DEBUG diff --git a/libretroshare/src/services/p3statusservice.h b/libretroshare/src/services/p3statusservice.h index fb43f03e9..d96f687ba 100644 --- a/libretroshare/src/services/p3statusservice.h +++ b/libretroshare/src/services/p3statusservice.h @@ -51,6 +51,8 @@ class p3StatusService: public p3Service, public p3Config, public pqiMonitor p3StatusService(p3LinkMgr *lm); virtual ~p3StatusService(); +virtual RsServiceInfo getServiceInfo(); + /***** overloaded from p3Service *****/ virtual int tick(); virtual int status(); diff --git a/libretroshare/src/services/p3wiki.cc b/libretroshare/src/services/p3wiki.cc index 983f18d11..c4a66f43b 100644 --- a/libretroshare/src/services/p3wiki.cc +++ b/libretroshare/src/services/p3wiki.cc @@ -56,6 +56,24 @@ p3Wiki::p3Wiki(RsGeneralDataService* gds, RsNetworkExchangeService* nes, RsGixs } + +const std::string GXS_WIKI_APP_NAME = "gxswiki"; +const uint16_t GXS_WIKI_APP_MAJOR_VERSION = 1; +const uint16_t GXS_WIKI_APP_MINOR_VERSION = 0; +const uint16_t GXS_WIKI_MIN_MAJOR_VERSION = 1; +const uint16_t GXS_WIKI_MIN_MINOR_VERSION = 0; + +RsServiceInfo p3Wiki::getServiceInfo() +{ + return RsServiceInfo(RS_SERVICE_GXSV2_TYPE_WIKI, + GXS_WIKI_APP_NAME, + GXS_WIKI_APP_MAJOR_VERSION, + GXS_WIKI_APP_MINOR_VERSION, + GXS_WIKI_MIN_MAJOR_VERSION, + GXS_WIKI_MIN_MINOR_VERSION); +} + + uint32_t p3Wiki::wikiAuthenPolicy() { uint32_t policy = 0; diff --git a/libretroshare/src/services/p3wiki.h b/libretroshare/src/services/p3wiki.h index 769fad53f..bd53fd6b7 100644 --- a/libretroshare/src/services/p3wiki.h +++ b/libretroshare/src/services/p3wiki.h @@ -45,6 +45,7 @@ class p3Wiki: public RsGenExchange, public RsWiki, { public: p3Wiki(RsGeneralDataService* gds, RsNetworkExchangeService* nes, RsGixs *gixs); +virtual RsServiceInfo getServiceInfo(); static uint32_t wikiAuthenPolicy(); protected: diff --git a/libretroshare/src/services/p3wire.cc b/libretroshare/src/services/p3wire.cc index 48c889fbc..9a62288fd 100644 --- a/libretroshare/src/services/p3wire.cc +++ b/libretroshare/src/services/p3wire.cc @@ -43,6 +43,24 @@ p3Wire::p3Wire(RsGeneralDataService* gds, RsNetworkExchangeService* nes, RsGixs } +const std::string WIRE_APP_NAME = "gxswire"; +const uint16_t WIRE_APP_MAJOR_VERSION = 1; +const uint16_t WIRE_APP_MINOR_VERSION = 0; +const uint16_t WIRE_MIN_MAJOR_VERSION = 1; +const uint16_t WIRE_MIN_MINOR_VERSION = 0; + +RsServiceInfo p3Wire::getServiceInfo() +{ + return RsServiceInfo(RS_SERVICE_GXSV2_TYPE_WIRE, + WIRE_APP_NAME, + WIRE_APP_MAJOR_VERSION, + WIRE_APP_MINOR_VERSION, + WIRE_MIN_MAJOR_VERSION, + WIRE_MIN_MINOR_VERSION); +} + + + uint32_t p3Wire::wireAuthenPolicy() { uint32_t policy = 0; diff --git a/libretroshare/src/services/p3wire.h b/libretroshare/src/services/p3wire.h index 051d3d6c5..24c0f26e7 100644 --- a/libretroshare/src/services/p3wire.h +++ b/libretroshare/src/services/p3wire.h @@ -43,6 +43,7 @@ class p3Wire: public RsGenExchange, public RsWire { public: p3Wire(RsGeneralDataService* gds, RsNetworkExchangeService* nes, RsGixs *gixs); +virtual RsServiceInfo getServiceInfo(); static uint32_t wireAuthenPolicy(); protected: diff --git a/libretroshare/src/turtle/p3turtle.cc b/libretroshare/src/turtle/p3turtle.cc index 05e5d1984..f5d734116 100644 --- a/libretroshare/src/turtle/p3turtle.cc +++ b/libretroshare/src/turtle/p3turtle.cc @@ -99,7 +99,7 @@ static const int MAX_TR_FORWARD_PER_SEC_LOWER_LIMIT = 10 ; static const int DISTANCE_SQUEEZING_POWER = 8 ; p3turtle::p3turtle(p3LinkMgr *lm) - :p3Service(RS_SERVICE_TYPE_TURTLE), p3Config(CONFIG_TYPE_TURTLE), mLinkMgr(lm), mTurtleMtx("p3turtle") + :p3Service(), p3Config(CONFIG_TYPE_TURTLE), mLinkMgr(lm), mTurtleMtx("p3turtle") { RsStackMutex stack(mTurtleMtx); /********** STACK LOCKED MTX ******/ @@ -120,6 +120,23 @@ p3turtle::p3turtle(p3LinkMgr *lm) _max_tr_up_rate = MAX_TR_FORWARD_PER_SEC ; } +const std::string TURTLE_APP_NAME = "turtle"; +const uint16_t TURTLE_APP_MAJOR_VERSION = 1; +const uint16_t TURTLE_APP_MINOR_VERSION = 0; +const uint16_t TURTLE_MIN_MAJOR_VERSION = 1; +const uint16_t TURTLE_MIN_MINOR_VERSION = 0; + +RsServiceInfo p3turtle::getServiceInfo() +{ + return RsServiceInfo(RS_SERVICE_TYPE_TURTLE, + TURTLE_APP_NAME, + TURTLE_APP_MAJOR_VERSION, + TURTLE_APP_MINOR_VERSION, + TURTLE_MIN_MAJOR_VERSION, + TURTLE_MIN_MINOR_VERSION); +} + + void p3turtle::setEnabled(bool b) { RsStackMutex stack(mTurtleMtx); /********** STACK LOCKED MTX ******/ diff --git a/libretroshare/src/turtle/p3turtle.h b/libretroshare/src/turtle/p3turtle.h index ca366781b..786cb78f8 100644 --- a/libretroshare/src/turtle/p3turtle.h +++ b/libretroshare/src/turtle/p3turtle.h @@ -217,6 +217,7 @@ class p3turtle: public p3Service, public RsTurtle, public p3Config { public: p3turtle(p3LinkMgr *lm) ; + virtual RsServiceInfo getServiceInfo(); // Enables/disable the service. Still ticks, but does nothing. Default is true. //