/* * libretroshare/src/services: p3circles.h * * Identity interface for RetroShare. * * Copyright 2012-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". * */ #ifndef P3_CIRCLES_SERVICE_HEADER #define P3_CIRCLES_SERVICE_HEADER #include "retroshare/rsgxscircles.h" // External Interfaces. #include "gxs/rsgenexchange.h" // GXS service. #include "gxs/rsgixs.h" // Internal Interfaces. #include "services/p3idservice.h" // For constructing Caches #include "gxs/gxstokenqueue.h" #include "util/rstickevent.h" #include "util/rsmemcache.h" #include #include /* * Circles Identity Service * * A collection of notes: * * We want to be able to express the following types of Circles. * * - Public * - Groups & Messages can be passed onto anyone. ( No Restrictions. ) * - GXS Notes: * - This is what we have currently. * * - External Circle * - List of Identities that can receive the Group / Messages. * - This list will be defined via a set of RsIdentities - which have PGPHashes set. * - We need the PGPHashes to be able to identify which peers can receive msgs. * - Messages are passed to the Intersection of (Identified PGPHashes & Friends) * - Distribution of Circle Definitions can be also be restricted via circles. * - You can have Public External Groups, or Groups that only the Members know about. * - Control of these External Groups is determined by Admin / Publish Keys. * - The Danger with External Groups, is your ID wll be associated with other people... * - Leaking information!!! * - GXS Notes: * - p3Circles will provide a distrib list for a given Circle Group. * * - Personal Circle or "Your Eyes Only". * - Same as an Internal Circle Definition. (What will be used for File Sharing initially) * - Each peer will have a bunch of these, Friends, Family, etc. * * - The list is not publically shared, only the originator of the message will distribute. * - You can communicate back to the originator, who will share with the other members. * but you mustn't discuss / share content with anyone else. * - This is quite a Weak / Fragile Group, as there is only one distributor. * - GXS NOTES: * - TO make this work, we need GXS or RsCircles to maintain extra info: * - GXS stores the original source, so communications can go back there. * - If Originator, GXS store a REFERENCE, Circles turn this into a distrib list of peers. * * * * Like RsIdentities are used to validation messages, * RsCircles will be used to determine if a peer can receive a group / messages. * * bool RsCircles::canSend(RsGxsCircleId, RsPeerId) * bool RsCircles::canSend(RsCircleInternalId, RsPeerId) * * or maybe just: * * bool RsCircles::recipients(GxsPermission &perms, std::list friendlist); * */ /* Permissions is part of GroupMetaData */ class RsGxsCircleCache { public: RsGxsCircleCache(); bool loadBaseCircle(const RsGxsCircleGroup &circle); bool loadSubCircle(const RsGxsCircleCache &subcircle); bool getAllowedPeersList(std::list &friendlist); bool isAllowedPeer(const RsPgpId &id); bool addAllowedPeer(const RsPgpId &pgpid, const RsGxsId &gxsId); RsGxsCircleId mCircleId; std::string mCircleName; time_t mUpdateTime; std::set mUnprocessedCircles; std::set mUnprocessedPeers; std::set mProcessedCircles; std::set mUnknownPeers; std::map > mAllowedPeers; }; class RsCircles { /* Functions to handle Local / Internal Circles == Same as for file permissions. */ public: virtual void createLocalCircle() = 0; virtual void addToLocalCircle() = 0; virtual void removeFromLocalCircle() = 0; virtual void getLocalCirclePeers() = 0; virtual void getListOfLocalCircles() = 0; /* similar functions for External Groups */ virtual bool createGroup(uint32_t& token, RsGxsCircleGroup &group) = 0; virtual bool getGroupData(const uint32_t &token, std::vector &groups) = 0; }; class p3GxsCircles: public RsGxsCircleExchange, public RsGxsCircles, public GxsTokenQueue, public RsTickEvent { public: p3GxsCircles(RsGeneralDataService* gds, RsNetworkExchangeService* nes, p3IdService *identities); /*********** External Interface ***************/ virtual bool getCircleDetails(const RsGxsCircleId &id, RsGxsCircleDetails &details); virtual bool getCircleIdList(std::list &circleIds); virtual bool isLoaded(const RsGxsCircleId &circleId); virtual bool loadCircle(const RsGxsCircleId &circleId); virtual int canSend(const RsGxsCircleId &circleId, const RsPgpId &id); virtual bool recipients(const RsGxsCircleId &circleId, std::list &friendlist); /*******/ virtual void createLocalCircle(); virtual void addToLocalCircle(); virtual void removeFromLocalCircle(); virtual void getLocalCirclePeers(); virtual void getListOfLocalCircles(); /*******/ virtual bool getGroupData(const uint32_t &token, std::vector &groups); virtual bool createGroup(uint32_t& token, RsGxsCircleGroup &group); /**********************************************/ // needed for background processing. virtual void service_tick(); protected: static uint32_t circleAuthenPolicy(); /** Notifications **/ virtual void notifyChanges(std::vector& changes); /** Overloaded to add PgpIdHash to Group Definition **/ virtual ServiceCreate_Return service_CreateGroup(RsGxsGrpItem* grpItem, RsTlvSecurityKeySet& keySet); // Overloaded from GxsTokenQueue for Request callbacks. virtual void handleResponse(uint32_t token, uint32_t req_type); // Overloaded from RsTickEvent. virtual void handle_event(uint32_t event_type, const std::string &elabel); private: // Load data. bool request_CircleIdList(); bool load_CircleIdList(uint32_t token); // Need some crazy arsed cache to store the circle info. // so we don't have to keep loading groups. int cache_tick(); bool cache_request_load(const RsGxsCircleId &id); bool cache_start_load(); bool cache_load_for_token(uint32_t token); bool cache_reloadids(const std::string &circleId); p3IdService *mIdentities; // Needed for constructing Circle Info, RsMutex mCircleMtx; /* Locked Below Here */ std::list mCircleIdList; /***** Caching Circle Info, *****/ // initial load queue std::list mCacheLoad_ToCache; // waiting for subcircle to load. (first is part of each of the second list) // TODO. //std::map > mCacheLoad_SubCircle; // Circles that are being loaded. std::map mLoadingCache; // actual cache. RsMemCache mCircleCache; private: std::string genRandomId(); void generateDummyData(); void checkDummyIdData(); void generateDummyCircle(); uint32_t mDummyIdToken; std::list mDummyPgpLinkedIds; std::list mDummyOwnIds; }; #endif // P3_CIRCLES_SERVICE_HEADER