File indexing completed on 2025-01-05 04:37:17

 /*
     SPDX-FileCopyrightText: 2005 Joris Guisson <joris.guisson@gmail.com>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 #ifndef BTPEERINTERFACE_H
 #define BTPEERINTERFACE_H
 
 #include <ktorrent_export.h>
 #include <peer/peerid.h>
 #include <util/bitset.h>
 #include <util/constants.h>
 
 namespace bt
 {
 /**
  * @author Joris Guisson
  * @brief Interface for a Peer
  *
  * This is the interface for a Peer, it allows other classes to
  * get statistics about a Peer, and provides some basic functionality provided by a Peer.
  */
 class KTORRENT_EXPORT PeerInterface
 {
 public:
     /**
         Constructor, initialize the PeerID and the number of chunks
         @param peer_id The PeerID
         @param num_chunks The number of chunks
     */
     PeerInterface(const PeerID &peer_id, Uint32 num_chunks);
     virtual ~PeerInterface();
 
     struct Stats {
         /// IP address of peer (dotted notation)
         QString ip_address;
         /// Host name of the peer
         QString hostname;
         /// The client (Azureus, BitComet, ...)
         QString client;
         /// Download rate (bytes/s)
         bt::Uint32 download_rate;
         /// Upload rate (bytes/s)
         bt::Uint32 upload_rate;
         /// Choked or not
         bool choked;
         /// Snubbed or not (i.e. we haven't received a piece for a minute)
         bool snubbed;
         /// Percentage of file which the peer has
         float perc_of_file;
         /// Does this peer support DHT
         bool dht_support;
         /// Amount of data uploaded
         bt::Uint64 bytes_uploaded;
         /// Amount of data downloaded
         bt::Uint64 bytes_downloaded;
         /// Advanced choke algorithm score
         double aca_score;
         /// Flag to indicate if this peer has an upload slot
         bool has_upload_slot;
         /// Is the peer interested
         bool interested;
         /// Am I interested in the peer
         bool am_interested;
         /// Whether or not this connection is encrypted
         bool encrypted;
         /// Number of upload requests queued
         bt::Uint32 num_up_requests;
         /// Number of outstanding download requests queued
         bt::Uint32 num_down_requests;
         /// Supports the fast extensions
         bool fast_extensions;
         /// Is this a peer on the local network
         bool local;
         /// Whether or not the peer supports the extension protocol
         bool extension_protocol;
         /// Max number of outstanding requests (reqq in extended protocol handshake)
         bt::Uint32 max_request_queue;
         /// Time the peer choked us
         TimeStamp time_choked;
         /// Time the peer unchoked us
         TimeStamp time_unchoked;
         /// The transport protocol used by the peer
         bt::TransportProtocol transport_protocol;
         /// Is this a partial seed
         bool partial_seed;
 
         /// Get the address of the peer (hostname if it is valid, IP otherwise)
         QString address() const
         {
             return hostname.isEmpty() ? ip_address : hostname;
         }
     };
 
     /// Get the Peer's statistics
     const Stats &getStats() const
     {
         return stats;
     }
 
     /**
         Kill the Peer, will ensure the PeerManager closes the connection, and cleans things up.
     */
     virtual void kill() = 0;
 
     /// See if the peer has been killed.
     bool isKilled() const
     {
         return killed;
     }
 
     /**
         Get the average download speed since the last unchoke in bytes/sec
      */
     virtual bt::Uint32 averageDownloadSpeed() const = 0;
 
     /// Get the Peer's BitSet
     const BitSet &getBitSet() const
     {
         return pieces;
     }
 
     /// Get the Peer's ID
     const PeerID &getPeerID() const
     {
         return peer_id;
     }
 
     /// Is the Peer choked
     bool isChoked() const
     {
         return stats.choked;
     }
 
     /// Is the Peer interested
     bool isInterested() const
     {
         return stats.interested;
     }
 
     /// Are we interested in the Peer
     bool areWeInterested() const
     {
         return stats.am_interested;
     }
 
     /// Are we choked for the Peer
     bool areWeChoked() const
     {
         return !stats.has_upload_slot || paused;
     }
 
     /// See if the peer supports DHT
     bool isDHTSupported() const
     {
         return stats.dht_support;
     }
 
     /// Get the time when this Peer choked us
     TimeStamp getChokeTime() const
     {
         return stats.time_choked;
     }
 
     /// Get the time when this Peer unchoked us
     TimeStamp getUnchokeTime() const
     {
         return stats.time_unchoked;
     }
 
     /// See if the peer is a seeder.
     bool isSeeder() const
     {
         return pieces.allOn();
     }
 
     /// Peer is allowed to download chunk (used for superseeding)
     virtual void chunkAllowed(bt::Uint32 chunk) = 0;
 
     /// Handle a received packet
     virtual void handlePacket(const bt::Uint8 *packet, bt::Uint32 size) = 0;
 
 protected:
     mutable PeerInterface::Stats stats;
     bool paused;
     bool killed;
     PeerID peer_id;
     BitSet pieces;
 };
 
 }
 
 #endif