Git-Mirrors/RetroShare
1
0
Fork 0
mirror of https://github.com/RetroShare/RetroShare.git synced 2025-02-17 13:24:15 -05:00
Code Issues Actions Packages Projects Releases Wiki Activity

Removed most of the interface for RsGNP as it mostly makes calls to other components

Browse Source 
Added final comments before review

git-svn-id: http://svn.code.sf.net/p/retroshare/code/branches/v0.5-new_cache_system@4928 b45a01b8-16f6-495d-af2f-9b41ad6348cc
This commit is contained in:
chrisparker126 2012-02-12 15:18:05 +00:00
parent 3ab62f147e
commit 25fbf771a7
5 changed files with 208 additions and 194 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
libretroshare/src/gxs/rsgdp.h
View File

@ -40,6 +40,8 @@ typedef std::map<std::string, std::set<RsGxsSignedMessage*> > SignedMsgGrp;
/*!
* The main role of GDP is the preparation and handing out of messages requested from
* RsGeneralExchangeService and RsGeneralExchangeService
* It is important to note that no actual messages are passed by this interface as its is expected
* architecturally to pass messages to the service via a call back
*
* It also acts as a layer between RsGeneralStorageService and its parent RsGeneralExchangeService
* thus allowing for non-blocking requests, etc.
@ -49,6 +51,12 @@ typedef std::map<std::string, std::set<RsGxsSignedMessage*> > SignedMsgGrp;
* Caching feature:
* - A cache index should be maintained which is faster than normal message request
* - This should allow fast retrieval of message based on grp id or msg id
*
* Identity Exchange Service:
* - As this is the point where data is accessed by both the GNP and GXS the identities
* used to decrypt, encrypt and verify is handle here.
*
*
*/
class RsGeneralDataService
{
@ -59,17 +67,17 @@ public:
* @param msgGrp this contains grp and the message to retrieve
* @return request code to be redeemed later
*/
virtual int request(const MsgGrpId& msgGrp, SignedMsgGrp& result, bool decrypted) = 0;
virtual int request(const MsgGrpId& msgGrp, bool decrypted) = 0;
/*!
* allows for more complex queries specific to the service
* Service should implement method taking case
* Service should implement its own specific filter
* @param filter generally stores parameters needed for query
* @param cacheRequest set to true to cache the messages requested
* @return request code to be redeemed later
*/
virtual int request(RequestFilter* filter, SignedMsgGrp& msgs, bool cacheRequest) = 0;
virtual int request(RequestFilter* filter, bool cacheRequest) = 0;
/*!
@ -79,13 +87,14 @@ public:
virtual bool store(SignedMsgGrp& msgs) = 0;
/*!
* @param grpIds set with grpIds available from storage
* Gets group and any associated meta data
* @param grpIds set with group Ids available from storage
* @return request code to be redeemed later
*/
virtual int getGroups(std::set<std::string>& grpIds) = 0;
virtual int getGroups(const std::set<std::string>& grpIds) = 0;
/*!
*
* Gets list of message ids in storage
* @param msgIds gets message ids in storage
* @return request code to be redeemed later
*/

263
libretroshare/src/gxs/rsgixs.h
View File

@ -59,159 +59,172 @@
* 7) Data will be stored encrypted.
*/
class GixsKey
{
KeyRef mKeyId;
/// public key
EVP_PKEY *mPubKey;
/*!
* Storage class for private and public publish keys
*
*/
class GixsKey
{
KeyRef mKeyId;
/// NULL if non-existant */
EVP_PKEY *mPrivKey;
};
/// public key
EVP_PKEY *mPubKey;
class KeyRef {
/// NULL if non-existant */
EVP_PKEY *mPrivKey;
};
/*!
*
*
*/
class KeyRef {
std::string refId;
};
class KeyRefSet {
std::set<KeyRef> mKeyRefSet;
};
};
class SignatureSet {
std::set<Signature> mSignatureSet;
};
/*!
*
*
*/
class Signature {
class KeyRefSet {
std::set<KeyRef> mKeyRefSet;
};
KeyRef mKeyRef;
Signature mSignature;
};
class SignatureSet {
std::set<Signature> mSignatureSet;
};
/*!
* This is the actual identity \n
* In a sense the group description with the GixsKey the "message"
*/
class RsGixsProfile {
public:
class Signature {
KeyRef mKeyRef;
std::string name;
KeyRef mKeyRef;
Signature mSignature;
};
/// may be superseded by newer timestamps
time_t mTimeStamp;
uint32_t mProfileType;
// TODO: add permissions members
Signature mSignature;
class RsGixsProfile {
};
public:
/*!
* Retroshare general identity exchange service
*
* Purpose: \n
* Provides a means to distribute identities among peers \n
* Also provides encyption, decryption, verification, \n
* and signing functionality using any created or received identities \n
*
* This may best be implemented as a singleton like current AuthGPG? \n
*
*/
class RsIdentityExchangeService : RsGeneralExchangeService
{
public:
KeyRef mKeyRef;
std::string mPseudonym;
/// may be superseded by newer timestamps
time_t mTimeStamp;
uint32_t mProfileType;
// TODO: add permissions members
Signature mSignature;
};
RsGixs();
/*!
* Retroshare general identity exchange service
*
* Purpose: \n
* Provides a means to distribute identities among peers \n
* also provides encyption, decryption, verification, \n
* and signing functionality using any created or received identities \n
*
* This may best be implemented as a singleton like current AuthGPG? \n
* creates gixs profile and shares it
* @param profile
* @param type the type of profile to create, self signed, anonymous, and GPG signed
*/
virtual bool createKey(RsGixsProfile& profile, uint32_t type) = 0; /* fills in mKeyId, and signature */
/*!
* Use to query a whether given key is available by its key reference
* @param keyref the keyref of key that is being checked for
* @return true if available, false otherwise
*/
virtual bool haveKey(const KeyRef& keyref) = 0;
/*!
* Use to query whether private key member of the given key reference is available
* @param keyref the KeyRef of the key being checked for
* @return true if private key is held here, false otherwise
*/
virtual bool havePrivateKey(const KeyRef& keyref) = 0;
/*!
* Use to request a given key reference
* @param keyref the KeyRef of the key being requested
* @return will
*/
virtual bool requestKey(const KeyRef& keyref) = 0;
/*!
* Retrieves a key identity
* @param keyref
* @return a pointer to a valid profile if successful, otherwise NULL
*
*/
class RsIdentityExchangeService : RsGeneralExchangeService
{
public:
RsGixs();
/*!
* creates gixs profile and shares it
* @param profile
*/
virtual bool createKey(RsGixsProfile& profile) = 0; /* fills in mKeyId, and signature */
/*!
* Use to query a whether given key is available by its key reference
* @param keyref the keyref of key that is being checked for
* @return true if available, false otherwise
*/
virtual bool haveKey(const KeyRef& keyref) = 0;
/*!
* Use to query whether private key member of the given key reference is available
* @param keyref the KeyRef of the key being checked for
* @return true if private key is held here, false otherwise
*/
virtual bool havePrivateKey(const KeyRef& keyref) = 0;
/*!
* Use to request a given key reference
* @param keyref the KeyRef of the key being requested
* @return will
*/
virtual bool requestKey(const KeyRef& keyref) = 0;
/*!
* Retrieves a key identity
* @param keyref
* @return a pointer to a valid profile if successful, otherwise NULL
*
*/
virtual RsGixsProfile* getProfile(const KeyRef& keyref) = 0;
virtual RsGixsProfile* getProfile(const KeyRef& keyref) = 0;
/*** process data ***/
/*** process data ***/
/*!
* Use to sign data with a given key
* @param keyref the key to sign the data with
* @param data the data to be signed
* @param dataLen the length of the data
* @param signature is set with the signature from signing with keyref
* @return false if signing failed, true otherwise
*/
virtual bool sign(const KeyRef& keyref, unsigned char* data, uint32_t dataLen, std::string& signature) = 0;
/*!
* Use to sign data with a given key
* @param keyref the key to sign the data with
* @param data the data to be signed
* @param dataLen the length of the data
* @param signature is set with the signature from signing with keyref
* @return false if signing failed, true otherwise
*/
virtual bool sign(const KeyRef& keyref, unsigned char* data, uint32_t dataLen, std::string& signature) = 0;
/*!
* Verify that the data is signed by the key owner
* @param keyref
* @param data
* @param dataLen
* @param signature
* @return false if verification failed, false otherwise
*/
virtual bool verify(const KeyRef& keyref, unsigned char* data, int dataLen, std::string& signature) = 0;
/*!
* Verify that the data is signed by the key owner
* @param keyref
* @param data
* @param dataLen
* @param signature
* @return false if verification failed, false otherwise
*/
virtual bool verify(const KeyRef& keyref, unsigned char* data, int dataLen, std::string& signature) = 0;
/*!
* Attempt to decrypt data with a given key
* @param keyref
* @param data data to be decrypted
* @param dataLen length of data
* @param decryptedData decrypted data
* @param decryptDataLen length of decrypted data
* @return false
*/
virtual bool decrypt(const KeyRef& keyref, unsigned char* data, int dataLen,
unsigned char*& decryptedData, uint32_t& decyptDataLen) = 0;
/*!
* Attempt to decrypt data with a given key
* @param keyref
* @param data data to be decrypted
* @param dataLen length of data
* @param decryptedData decrypted data
* @param decryptDataLen length of decrypted data
* @return false
*/
virtual bool decrypt(const KeyRef& keyref, unsigned char* data, int dataLen,
unsigned char*& decryptedData, uint32_t& decyptDataLen) = 0;
/*!
* Attempt to encrypt data with a given key
* @param keyref
* @param data data to be encrypted
* @param dataLen length of data
* @param encryptedData encrypted data
* @param encryptDataLen length of encrypted data
*/
virtual bool encrypt(const KeyRef& keyref, unsigned char* data, int dataLen,
unsigned char*& encryptedData, uint32_t& encryptDataLen) = 0;
/*!
* Attempt to encrypt data with a given key
* @param keyref
* @param data data to be encrypted
* @param dataLen length of data
* @param encryptedData encrypted data
* @param encryptDataLen length of encrypted data
*/
virtual bool encrypt(const KeyRef& keyref, unsigned char* data, int dataLen,
unsigned char*& encryptedData, uint32_t& encryptDataLen) = 0;
};
};
#endif // RSGIXS_H

82
libretroshare/src/gxs/rsgnp.h
View File

@ -34,7 +34,7 @@
#include <map>
#include "gxs/rsgxs.h"
#include "services/p3service.h"
/*!
@ -75,75 +75,35 @@ typedef std::map<std::string, std::set<std::string> > PeerGrp;
/*!
* Retroshare General Network Exchange Service: \n
* Interface:
* - This provides a module to service peers requests for GXS message \n
* - This provides a module to service peer's requests for GXS messages \n
* and also request GXS messages from other peers. \n
* - Users can make a general request for message under a grp id for a peer, all grp ids held \n
* by a set of peers. And can also apply to timerange to them
* - An interface is provided for the observer pattern so clients of this class
* can check if their requests have been served
* - The general mode of operation is to sychronise all messages/grps between
* peers
*
* The interface is sparse as this service is mostly making the requests to other GXS components
*
* Groups:
* - As this is where exchanges occur between peers, this is also where groups relationships
* should get resolved as far as
* - Per implemented GXS there are a set of rules which will determine whether data is transferred
* between any set of groups
*
* 1 allow transfers to any group
* 2 transfers only between group
* - the also group matrix settings which is by default everyone can transfer to each other
*/
class RsNetworktExchangeService
class RsNetworktExchangeService : public p3Service
{
public:
RsNetworkExchangeService();
/*!
* Queries peers for a set of grp ids
* @param pg a map of peer to a set of grp ids to query message from
* @param from start range of time
* @param to end range of time
* @return a request code to be kept to redeem query later
*/
virtual int requestAvailableMsgs(PeerGrp& pg, time_t from, time_t to) = 0;
/*!
* Queries peer for msgs of peer grp id pairs
* @param pg peer, grp id peers
* @param from start range of time
* @param to end range of time
* @return a request code to be kept to redeem query later
*/
virtual int requestMsgs(PeerGrp& pg, time_t from, time_t to) = 0;
/*!
* Queries peers in list for groups avaialble
*
* @param peers the peers to query
* @param from start range of time
* @param to end range of time
* @return a request code to be kept to redeem query later
*/
int requestAvailableGrps(const std::set<std::string>& peers, time_t from, time_t to) = 0;
RsNetworkExchangeService(uint16_t subtype);
/*!
* When messages are received this function should be call containing the messages
* @param msgs the messages received from peers
* Use this to set how far back synchronisation of messages should take place
* @param range how far back from current time to synchronise with other peers
*/
void messageFromPeers(std::list<RsGxsSignedMessage*>& msgs) = 0;
public:
/*!
* attempt to retrieve requested messages
* @param requestCode
* @param msgs
* @return false if not received, true is requestCode has been redeemed
* @see RsGeneralNetExchangeService::requestAvailableGrps()
*/
bool getRequested(uint32_t requestCode, std::list<RsGxsSignedMessage*>& msgs) = 0;
/*!
* Allows observer pattern for checking if a request has been satisfied
*
* @param requestCode the code returned msg request functions
* @return false if not ready, true otherwise
* @see RsGeneralNetExchangeService::requestAvailableGrps()
* @see RsGeneralNetExchangeService::requestAvailableMsgs()
*/
bool requestCodeReady(uint32_t reuqestCode);
virtual void setTimeRange(uint64_t range) = 0;
};

3
libretroshare/src/gxs/rsgroups.h
View File

@ -38,6 +38,9 @@
// Relay connexions:
// * allow relay connexions between people of group A and group B.
//
// General Exchange Services:
// * Allow data exchanged from one peers of one group to peers of another group
//
// We need per-group permission flags for:
//
// File download permission:

33
libretroshare/src/gxs/rsgxs.h
View File

@ -33,12 +33,16 @@
#include <string>
#include <inttypes.h>
#include <map>
#include "serialiser/rsbaseitems.h"
#include "rsgnp.h"
#include "rsgdp.h"
#include "rsgixs.h"
typedef std::map<uint32_t, std::string> requestMsgMap;
/*!
*
* Brief explanation of how RsGeneralExchange service would work \n
@ -82,18 +86,43 @@ public:
/*!
* get the RsGeneralDataService instance serving this \n
* RsGeneralExchangeService
* @see RsGeneralExchangeService
* @return data service
*/
virtual RsGeneralDataService* getDataService() = 0;
/*!
* get the RsNetworktExchangeService instance serving this \n
* RsGeneralExchangeService
* @see RsGeneralExchangeService
* @return network exchange service
*/
virtual RsNetworktExchangeService* getNetworkService() = 0;
/*!
* Requests by this service for messages can be satisfied calling \n
* this method with a map containing id to msg map
*/
virtual void receiveMessages(requestMsgMap&) = 0;
/*!
* This allows non blocking requests to be made to this service
*/
virtual void tick();
};
/*!
* Implementations of general exchange service can be added \n
* to this service runner which ticks the service's general data service \n
* and the service itself
*/
class RsGxServiceRunner : public RsThread {
public:
virtual void addGxService() = 0;
};