/******************************************************************************* * libretroshare/src/retroshare: rsturtle.h * * * * libretroshare: retroshare core library * * * * Copyright 2009-2018 by Cyril Soler * * * * 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 "serialiser/rstlvbinary.h" #include "retroshare/rstypes.h" #include "retroshare/rsgxsifacetypes.h" #include "serialiser/rsserializable.h" namespace RsRegularExpression { class LinearizedExpression ; } class RsTurtleClientService ; class RsTurtle; /** * Pointer to global instance of RsTurtle service implementation */ extern RsTurtle* rsTurtle; typedef uint32_t TurtleRequestId ; typedef RsPeerId TurtleVirtualPeerId; struct TurtleFileInfo : RsSerializable { TurtleFileInfo() : size(0) {} uint64_t size; /// File size RsFileHash hash; /// File hash std::string name; /// File name /// @see RsSerializable::serial_process void serial_process( RsGenericSerializer::SerializeJob j, RsGenericSerializer::SerializeContext& ctx ) { RS_SERIAL_PROCESS(size); RS_SERIAL_PROCESS(hash); // Use String TLV serial process for retrocompatibility RsTypeSerializer::serial_process( j, ctx, TLV_TYPE_STR_NAME, name, "name" ); } } RS_DEPRECATED_FOR(TurtleFileInfoV2); struct TurtleTunnelRequestDisplayInfo { uint32_t request_id ; // Id of the request RsPeerId source_peer_id ; // Peer that relayed the request uint32_t age ; // Age in seconds uint32_t depth ; // Depth of the request. Might be altered. }; struct TurtleSearchRequestDisplayInfo { uint32_t request_id ; // Id of the request RsPeerId source_peer_id ; // Peer that relayed the request uint32_t age ; // Age in seconds uint32_t depth ; // Depth of the request. Might be altered. uint32_t hits ; std::string keywords; }; class TurtleTrafficStatisticsInfo { public: float unknown_updn_Bps ; // unknown data transit bitrate (in Bytes per sec.) float data_up_Bps ; // upload (in Bytes per sec.) float data_dn_Bps ; // download (in Bytes per sec.) float tr_up_Bps ; // tunnel requests upload bitrate (in Bytes per sec.) float tr_dn_Bps ; // tunnel requests dnload bitrate (in Bytes per sec.) float total_up_Bps ; // turtle network management bitrate (in Bytes per sec.) float total_dn_Bps ; // turtle network management bitrate (in Bytes per sec.) std::vector forward_probabilities ; // probability to forward a TR as a function of depth. }; // Interface class for turtle hopping. // // This class mainly interacts with the turtle router, that is responsible // for routing turtle packets between peers, accepting/forwarding search // requests and dowloading files. // // As seen from here, the interface is really simple. // class RsTurtle { public: RsTurtle() {} virtual ~RsTurtle() {} // This is saved permanently. virtual void setEnabled(bool) = 0 ; virtual bool enabled() const = 0 ; // This is temporary, used by Operating Mode. virtual void setSessionEnabled(bool) = 0 ; virtual bool sessionEnabled() const = 0 ; /** Lauches a search request through the pipes, and immediately returns * the request id, which will be further used by client services to * handle results as they come back. */ virtual TurtleRequestId turtleSearch( unsigned char *search_bin_data, uint32_t search_bin_data_len, RsTurtleClientService* client_service ) = 0; // Initiates tunnel handling for the given file hash. tunnels. Launches // an exception if an error occurs during the initialization process. The // turtle router itself does not initiate downloads, it only maintains // tunnels for the given hash. The download should be driven by the file // transfer module by calling ftServer::FileRequest(). // Aggressive mode causes the turtle router to regularly re-ask tunnels in addition to the ones already // available without replacing them. In non aggressive mode, we wait for all tunnels to die before asking // for new tunnels. // virtual void monitorTunnels(const RsFileHash& file_hash,RsTurtleClientService *client_service,bool use_aggressive_mode) = 0 ; // Tells the turtle router to stop handling tunnels for the given file hash. Traditionally this should // be called after calling ftServer::fileCancel(). // virtual void stopMonitoringTunnels(const RsFileHash& file_hash) = 0 ; /// Adds a client tunnel service. This means that the service will be added /// to the list of services that might respond to tunnel requests. /// Example tunnel services include: /// /// p3ChatService: tunnels correspond to private distant chatting /// ftServer : tunnels correspond to file data transfer /// virtual void registerTunnelService(RsTurtleClientService *service) = 0; virtual std::string getPeerNameForVirtualPeerId(const RsPeerId& virtual_peer_id) = 0; // Get info from the turtle router. I use std strings to hide the internal structs. // virtual void getInfo(std::vector >&,std::vector >&, std::vector&,std::vector&) const = 0; // Get info about turtle traffic. See TurtleTrafficStatisticsInfo members for details. // virtual void getTrafficStatistics(TurtleTrafficStatisticsInfo& info) const = 0; // Convenience function. virtual bool isTurtlePeer(const RsPeerId& peer_id) const = 0 ; // Hardcore handles virtual void setMaxTRForwardRate(int max_tr_up_rate) = 0 ; virtual int getMaxTRForwardRate() const = 0 ; virtual void getMaxTRForwardRateLimits(int& low,int& high) const = 0 ; };