/******************************************************************************* * libretroshare/src/retroshare: rsgxscircles.h * * * * libretroshare: retroshare core library * * * * Copyright (C) 2012 Robert Fernie * * Copyright (C) 2018 Gioacchino Mazzurco * * * * This program is free software: you can redistribute it and/or modify * * it under the terms of the GNU Lesser General Public License as * * published by the Free Software Foundation, either version 3 of the * * License, or (at your option) any later version. * * * * This program 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 Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public License * * along with this program. If not, see . * * * *******************************************************************************/ #pragma once #include #include #include #include #include "retroshare/rstypes.h" #include "retroshare/rstokenservice.h" #include "retroshare/rsgxsifacehelper.h" #include "retroshare/rsidentity.h" #include "serialiser/rsserializable.h" class RsGxsCircles; /** * Pointer to global instance of RsGxsCircles service implementation * @jsonapi{development} */ extern RsGxsCircles* rsGxsCircles; enum class RsGxsCircleType : uint32_t // 32 bit overkill, just for retrocompat { UNKNOWN = 0, /// Used to detect uninizialized values. PUBLIC = 1, /// Public distribution EXTERNAL = 2, /// Restricted to an external circle /** Restricted to a group of friend nodes, the administrator of the circle * behave as a hub for them */ NODES_GROUP = 3, LOCAL = 4, /// not distributed at all /** Self-restricted. Used only at creation time of self-restricted circles * when the circle id isn't known yet. Once the circle id is known the type * is set to EXTERNAL, and the external circle id is set to the id of the * circle itself. */ EXT_SELF = 5, /// distributed to nodes signed by your own PGP key only. YOUR_EYES_ONLY = 6 }; // TODO: convert to enum class static const uint32_t GXS_EXTERNAL_CIRCLE_FLAGS_IN_ADMIN_LIST = 0x0001 ;// user is validated by circle admin static const uint32_t GXS_EXTERNAL_CIRCLE_FLAGS_SUBSCRIBED = 0x0002 ;// user has subscribed the group static const uint32_t GXS_EXTERNAL_CIRCLE_FLAGS_KEY_AVAILABLE = 0x0004 ;// key is available, so we can encrypt for this circle static const uint32_t GXS_EXTERNAL_CIRCLE_FLAGS_ALLOWED = 0x0007 ;// user is allowed. Combines all flags above. struct RsGxsCircleGroup : RsSerializable { virtual ~RsGxsCircleGroup() {} RsGroupMetaData mMeta; std::set mLocalFriends; std::set mInvitedMembers; std::set mSubCircles; #ifdef V07_NON_BACKWARD_COMPATIBLE_CHANGE_UNNAMED # error "Add description, and multiple owners/administrators to circles" // or better in general to GXS groups #endif /// @see RsSerializable void serial_process( RsGenericSerializer::SerializeJob j, RsGenericSerializer::SerializeContext& ctx) override { RS_SERIAL_PROCESS(mMeta); RS_SERIAL_PROCESS(mLocalFriends); RS_SERIAL_PROCESS(mInvitedMembers); RS_SERIAL_PROCESS(mSubCircles); } }; struct RsGxsCircleMsg : RsSerializable { virtual ~RsGxsCircleMsg() {} RsMsgMetaData mMeta; #ifndef V07_NON_BACKWARD_COMPATIBLE_CHANGE_UNNAMED /* This is horrible and should be changed into yet to be defined something * reasonable in next non retrocompatible version */ std::string stuff; #endif /// @see RsSerializable void serial_process( RsGenericSerializer::SerializeJob j, RsGenericSerializer::SerializeContext& ctx) override { RS_SERIAL_PROCESS(mMeta); RS_SERIAL_PROCESS(stuff); } }; struct RsGxsCircleDetails : RsSerializable { RsGxsCircleDetails() : mCircleType(static_cast(RsGxsCircleType::EXTERNAL)), mAmIAllowed(false) {} ~RsGxsCircleDetails() override {} RsGxsCircleId mCircleId; std::string mCircleName; uint32_t mCircleType; RsGxsCircleId mRestrictedCircleId; /** true when one of load GXS ids belong to the circle allowed list (admin * list & subscribed list). */ bool mAmIAllowed; /// This crosses admin list and subscribed list std::set mAllowedGxsIds; std::set mAllowedNodes; /// subscription flags for all ids std::map mSubscriptionFlags; /// @see RsSerializable void serial_process( RsGenericSerializer::SerializeJob j, RsGenericSerializer::SerializeContext& ctx) override { RS_SERIAL_PROCESS(mCircleId); RS_SERIAL_PROCESS(mCircleName); RS_SERIAL_PROCESS(mCircleType); RS_SERIAL_PROCESS(mRestrictedCircleId); RS_SERIAL_PROCESS(mAmIAllowed); RS_SERIAL_PROCESS(mAllowedGxsIds); RS_SERIAL_PROCESS(mAllowedNodes); RS_SERIAL_PROCESS(mSubscriptionFlags); } }; class RsGxsCircles: public RsGxsIfaceHelper { public: RsGxsCircles(RsGxsIface& gxs) : RsGxsIfaceHelper(gxs) {} virtual ~RsGxsCircles() {} /** * @brief Create new circle * @jsonapi{development} * @param[inout] cData input name and flags of the circle, storage for * generated circle data id etc. * @return false if something failed, true otherwhise */ virtual bool createCircle(RsGxsCircleGroup& cData) = 0; /** * @brief Edit own existing circle * @jsonapi{development} * @param[inout] cData Circle data with modifications, storage for data * updatedad during the operation. * @return false if something failed, true otherwhise */ virtual bool editCircle(RsGxsCircleGroup& cData) = 0; /** * @brief Get circle details. Memory cached * @jsonapi{development} * @param[in] id Id of the circle * @param[out] details Storage for the circle details * @return false if something failed, true otherwhise */ virtual bool getCircleDetails( const RsGxsCircleId& id, RsGxsCircleDetails& details ) = 0; /** * @brief Get list of known external circles ids. Memory cached * @jsonapi{development} * @param[in] circleIds Storage for circles id list * @return false if something failed, true otherwhise */ virtual bool getCircleExternalIdList( std::list& circleIds ) = 0; /** * @brief Get circles summaries list. * @jsonapi{development} * @param[out] circles list where to store the circles summaries * @return false if something failed, true otherwhise */ virtual bool getCirclesSummaries(std::list& circles) = 0; /** * @brief Get circles information * @jsonapi{development} * @param[in] circlesIds ids of the circles of which to get the informations * @param[out] circlesInfo storage for the circles informations * @return false if something failed, true otherwhise */ virtual bool getCirclesInfo( const std::list& circlesIds, std::vector& circlesInfo ) = 0; /** * @brief Get circle requests * @jsonapi{development} * @param[in] circleId id of the circle of which the requests are requested * @param[out] requests storage for the circle requests * @return false if something failed, true otherwhise */ virtual bool getCircleRequests( const RsGxsGroupId& circleId, std::vector& requests ) = 0; /** * @brief Invite identities to circle * @jsonapi{development} * @param[in] identities ids of the identities to invite * @param[in] circleId Id of the circle you own and want to invite ids in * @return false if something failed, true otherwhise */ virtual bool inviteIdsToCircle( const std::set& identities, const RsGxsCircleId& circleId ) = 0; /** * @brief Request circle membership, or accept circle invitation * @jsonapi{development} * @param[in] ownGxsId Id of own identity to introduce to the circle * @param[in] circleId Id of the circle to which ask for inclusion * @return false if something failed, true otherwhise */ virtual bool requestCircleMembership( const RsGxsId& ownGxsId, const RsGxsCircleId& circleId ) = 0; /** * @brief Leave given circle * @jsonapi{development} * @param[in] ownGxsId Own id to remove from the circle * @param[in] circleId Id of the circle to leave * @return false if something failed, true otherwhise */ virtual bool cancelCircleMembership( const RsGxsId& ownGxsId, const RsGxsCircleId& circleId ) = 0; RS_DEPRECATED_FOR("getCirclesSummaries getCirclesInfo") virtual bool getGroupData( const uint32_t& token, std::vector& groups ) = 0; RS_DEPRECATED_FOR(getCirclesRequests) virtual bool getMsgData( const uint32_t& token, std::vector& msgs ) = 0; /// make new group RS_DEPRECATED_FOR(createCircle) virtual void createGroup(uint32_t& token, RsGxsCircleGroup &group) = 0; /// update an existing group RS_DEPRECATED_FOR("editCircle, inviteIdsToCircle") virtual void updateGroup(uint32_t &token, RsGxsCircleGroup &group) = 0; }; /// @deprecated Used to detect uninizialized values. RS_DEPRECATED_FOR("RsGxsCircleType::UNKNOWN") static const uint32_t GXS_CIRCLE_TYPE_UNKNOWN = 0x0000; /// @deprecated not restricted to a circle RS_DEPRECATED_FOR("RsGxsCircleType::PUBLIC") static const uint32_t GXS_CIRCLE_TYPE_PUBLIC = 0x0001; /// @deprecated restricted to an external circle, made of RsGxsId RS_DEPRECATED_FOR("RsGxsCircleType::EXTERNAL") static const uint32_t GXS_CIRCLE_TYPE_EXTERNAL = 0x0002; /// @deprecated restricted to a subset of friend nodes of a given RS node given /// by a RsPgpId list RS_DEPRECATED_FOR("RsGxsCircleType::NODES_GROUP") static const uint32_t GXS_CIRCLE_TYPE_YOUR_FRIENDS_ONLY = 0x0003; /// @deprecated not distributed at all RS_DEPRECATED_FOR("RsGxsCircleType::LOCAL") static const uint32_t GXS_CIRCLE_TYPE_LOCAL = 0x0004; /// @deprecated self-restricted. Not used, except at creation time when the /// circle ID isn't known yet. Set to EXTERNAL afterwards. RS_DEPRECATED_FOR("RsGxsCircleType::EXT_SELF") static const uint32_t GXS_CIRCLE_TYPE_EXT_SELF = 0x0005; /// @deprecated distributed to nodes signed by your own PGP key only. RS_DEPRECATED_FOR("RsGxsCircleType::YOUR_EYES_ONLY") static const uint32_t GXS_CIRCLE_TYPE_YOUR_EYES_ONLY = 0x0006;