Class PEPeerTransportProtocol

java.lang.Object
com.biglybt.core.logging.LogRelation
com.biglybt.core.peer.impl.transport.PEPeerTransportProtocol
All Implemented Interfaces:
PEPeerTransport, PEPeer, Taggable, Taggable

public class PEPeerTransportProtocol extends LogRelation implements PEPeerTransport
  • Field Details

    • LOGID

      protected static final LogIDs LOGID
    • ip_filter

      private static final IpFilter ip_filter
    • _lastPiece

      private volatile int _lastPiece
    • manager

      protected final PEPeerControl manager
    • diskManager

      protected final DiskManager diskManager
    • piecePicker

      protected final PiecePicker piecePicker
    • nbPieces

      protected final int nbPieces
    • peer_source

      private final String peer_source
    • peer_id

      private byte[] peer_id
    • ip

      private String ip
    • network

      private final String network
    • ip_resolved

      protected String ip_resolved
    • ip_resolver_request

      private IPToHostNameResolverRequest ip_resolver_request
    • port

      private final int port
    • peer_item_identity

      private PeerItem peer_item_identity
    • tcp_listen_port

      private int tcp_listen_port
    • udp_listen_port

      private int udp_listen_port
    • udp_non_data_port

      private int udp_non_data_port
    • alternativeAddress

      private InetAddress alternativeAddress
    • crypto_level

      private byte crypto_level
    • peer_stats

      protected PEPeerStats peer_stats
    • requested

      private final ArrayList<DiskManagerReadRequest> requested
    • data

      private Map data
    • lastNeededUndonePieceChange

      private long lastNeededUndonePieceChange
    • really_choked_by_other_peer

      private boolean really_choked_by_other_peer
    • effectively_choked_by_other_peer

      private boolean effectively_choked_by_other_peer
    • effectively_unchoked_time

      private long effectively_unchoked_time
    • choking_other_peer

      protected boolean choking_other_peer
    • interested_in_other_peer

      private boolean interested_in_other_peer
    • other_peer_interested_in_me

      private boolean other_peer_interested_in_me
    • peerHavePieces

      private volatile BitFlags peerHavePieces
      lazy allocation; null until needed
    • availabilityAdded

      private volatile boolean availabilityAdded
    • received_bitfield

      private volatile boolean received_bitfield
    • piece_priority_offsets

      private int[] piece_priority_offsets
    • handshake_sent

      private boolean handshake_sent
    • seeding

      private boolean seeding
    • RELATIVE_SEEDING_NONE

      private static final byte RELATIVE_SEEDING_NONE
      See Also:
    • RELATIVE_SEEDING_UPLOAD_ONLY_INDICATED

      private static final byte RELATIVE_SEEDING_UPLOAD_ONLY_INDICATED
      See Also:
    • RELATIVE_SEEDING_UPLOAD_ONLY_SEED

      private static final byte RELATIVE_SEEDING_UPLOAD_ONLY_SEED
      See Also:
    • relativeSeeding

      private byte relativeSeeding
    • incoming_raw

      private final boolean incoming_raw
    • incoming_effective

      private boolean incoming_effective
    • closing

      protected volatile boolean closing
    • current_peer_state

      private volatile int current_peer_state
    • connection

      private final NetworkConnection connection
    • outgoing_piece_message_handler

      private OutgoingBTPieceMessageHandler outgoing_piece_message_handler
    • outgoing_have_message_aggregator

      private OutgoingBTHaveMessageAggregator outgoing_have_message_aggregator
    • plugin_connection

      private Connection plugin_connection
    • identityAdded

      private boolean identityAdded
    • connection_state

      private int connection_state
    • outbound_connection_start

      private long outbound_connection_start
    • outbound_connection_progress

      private int outbound_connection_progress
    • client

      private String client
    • client_peer_id

      private String client_peer_id
    • client_handshake

      private String client_handshake
    • client_handshake_version

      private String client_handshake_version
    • uniquePiece

      private int uniquePiece
    • reserved_pieces

      private int[] reserved_pieces
    • spreadTimeHint

      private int spreadTimeHint
    • snubbed_time_mono

      private long snubbed_time_mono
    • last_message_sent_time_mono

      private long last_message_sent_time_mono
    • last_message_received_time_mono

      private long last_message_received_time_mono
    • last_data_message_received_time_mono

      private long last_data_message_received_time_mono
    • last_good_data_time_mono

      private long last_good_data_time_mono
    • last_data_message_sent_time_mono

      private long last_data_message_sent_time_mono
    • connection_established_time_mono

      private long connection_established_time_mono
    • consecutive_no_request_count

      private int consecutive_no_request_count
    • messaging_mode

      private int messaging_mode
    • supported_messages

      private Message[] supported_messages
    • other_peer_bitfield_version

      private byte other_peer_bitfield_version
    • other_peer_cancel_version

      private byte other_peer_cancel_version
    • other_peer_choke_version

      private byte other_peer_choke_version
    • other_peer_handshake_version

      private byte other_peer_handshake_version
    • other_peer_bt_have_version

      private byte other_peer_bt_have_version
    • other_peer_az_have_version

      private byte other_peer_az_have_version
    • other_peer_interested_version

      private byte other_peer_interested_version
    • other_peer_keep_alive_version

      private byte other_peer_keep_alive_version
    • other_peer_pex_version

      private byte other_peer_pex_version
    • other_peer_piece_version

      private byte other_peer_piece_version
    • other_peer_unchoke_version

      private byte other_peer_unchoke_version
    • other_peer_uninterested_version

      private byte other_peer_uninterested_version
    • other_peer_request_version

      private byte other_peer_request_version
    • other_peer_suggest_piece_version

      private byte other_peer_suggest_piece_version
    • other_peer_have_all_version

      private byte other_peer_have_all_version
    • other_peer_have_none_version

      private byte other_peer_have_none_version
    • other_peer_reject_request_version

      private byte other_peer_reject_request_version
    • other_peer_allowed_fast_version

      private byte other_peer_allowed_fast_version
    • other_peer_bt_lt_ext_version

      private final byte other_peer_bt_lt_ext_version
      See Also:
    • other_peer_hash_request_version

      private byte other_peer_hash_request_version
    • other_peer_hashes_version

      private byte other_peer_hashes_version
    • other_peer_hash_reject_version

      private byte other_peer_hash_reject_version
    • other_peer_az_request_hint_version

      private byte other_peer_az_request_hint_version
    • other_peer_az_bad_piece_version

      private byte other_peer_az_bad_piece_version
    • other_peer_az_stats_request_version

      private byte other_peer_az_stats_request_version
    • other_peer_az_stats_reply_version

      private byte other_peer_az_stats_reply_version
    • other_peer_az_metadata_version

      private byte other_peer_az_metadata_version
    • DEBUG_FAST

      private static final boolean DEBUG_FAST
      See Also:
    • ut_pex_enabled

      private boolean ut_pex_enabled
    • ut_holepunch_enabled

      private boolean ut_holepunch_enabled
    • fast_extension_enabled

      private boolean fast_extension_enabled
    • ml_dht_enabled

      private boolean ml_dht_enabled
    • ALLOWED_FAST_PIECE_OFFERED_NUM

      private static final int ALLOWED_FAST_PIECE_OFFERED_NUM
      See Also:
    • ALLOWED_FAST_OTHER_PEER_PIECE_MAX

      private static final int ALLOWED_FAST_OTHER_PEER_PIECE_MAX
      See Also:
    • KEY_ALLOWED_FAST_RECEIVED

      private static final Object KEY_ALLOWED_FAST_RECEIVED
    • KEY_ALLOWED_FAST_SENT

      private static final Object KEY_ALLOWED_FAST_SENT
    • closing_mon

      private final AEMonitor closing_mon
    • general_mon

      private final AEMonitor general_mon
    • handshake_reserved_bytes

      private byte[] handshake_reserved_bytes
    • recent_outgoing_requests

      private LinkedHashMap recent_outgoing_requests
    • recent_outgoing_requests_mon

      private AEMonitor recent_outgoing_requests_mon
    • has_received_initial_pex

      private boolean has_received_initial_pex
    • SHOW_DISCARD_RATE_STATS

      private static final boolean SHOW_DISCARD_RATE_STATS
    • requests_discarded

      private static int requests_discarded
    • requests_discarded_endgame

      private static int requests_discarded_endgame
    • requests_recovered

      private static int requests_recovered
    • requests_completed

      private static int requests_completed
    • REQUEST_HINT_MAX_LIFE

      private static final int REQUEST_HINT_MAX_LIFE
      See Also:
    • request_hint

      private int[] request_hint
    • peer_listeners_cow

      private List peer_listeners_cow
    • peer_listeners_mon

      private final AEMonitor peer_listeners_mon
    • ENABLE_LAZY_BITFIELD

      protected static boolean ENABLE_LAZY_BITFIELD
    • priority_connection

      private boolean priority_connection
    • upload_priority_auto

      private int upload_priority_auto
    • recentlyDisconnected

      private static final PEPeerTransportProtocol.DisconnectedTransportQueue recentlyDisconnected
    • fast_unchoke_new_peers

      private static boolean fast_unchoke_new_peers
    • rnd

      private static final Random rnd
    • sessionSecret

      private static final byte[] sessionSecret
    • enable_upload_bias

      private static boolean enable_upload_bias
    • enable_public_tcp_peers

      private static boolean enable_public_tcp_peers
    • enable_public_udp_peers

      private static boolean enable_public_udp_peers
    • prefer_ipv6

      private static boolean prefer_ipv6
    • peerSessionID

      private HashWrapper peerSessionID
    • mySessionID

      private HashWrapper mySessionID
    • allowReconnect

      private boolean allowReconnect
    • isReconnect

      private boolean isReconnect
    • upload_disabled_set

      private Set<Object> upload_disabled_set
    • download_disabled_set

      private Set<Object> download_disabled_set
    • is_upload_disabled

      private boolean is_upload_disabled
    • is_download_disabled

      private boolean is_download_disabled
    • is_optimistic_unchoke

      private boolean is_optimistic_unchoke
    • peer_exchange_item

      private PeerExchangerItem peer_exchange_item
    • peer_exchange_supported

      private boolean peer_exchange_supported
    • message_limiter

      protected PeerMessageLimiter message_limiter
    • request_hint_supported

      private boolean request_hint_supported
    • bad_piece_supported

      private boolean bad_piece_supported
    • stats_request_supported

      private boolean stats_request_supported
    • stats_reply_supported

      private boolean stats_reply_supported
    • az_metadata_supported

      private boolean az_metadata_supported
    • have_aggregation_disabled

      private boolean have_aggregation_disabled
    • manual_lazy_bitfield_control

      private volatile boolean manual_lazy_bitfield_control
    • manual_lazy_haves

      private volatile int[] manual_lazy_haves
    • is_metadata_download

      private final boolean is_metadata_download
    • request_latency

      private long request_latency
    • hp_last_send

      private volatile long hp_last_send
    • hp_last_address

      private volatile InetAddress hp_last_address
  • Constructor Details

    • PEPeerTransportProtocol

      public PEPeerTransportProtocol(PEPeerControl _manager, String _peer_source, NetworkConnection _connection, Map _initial_user_data)
    • PEPeerTransportProtocol

      public PEPeerTransportProtocol(PEPeerControl _manager, String _peer_source, String _ip, int _tcp_port, int _udp_port, boolean _use_tcp, boolean _require_crypto_handshake, byte _crypto_level, Map _initial_user_data)
  • Method Details

    • start

      public void start()
      Description copied from interface: PEPeerTransport
      Start message processing for the peer
      Specified by:
      start in interface PEPeerTransport
    • initializeConnection

      protected void initializeConnection()
    • isMyPeer

      public boolean isMyPeer()
      Description copied from interface: PEPeer
      Whether or not this is a 'dummy' peer that represents our presence in a swarm
      Specified by:
      isMyPeer in interface PEPeer
      Returns:
    • getPeerSource

      public String getPeerSource()
      Specified by:
      getPeerSource in interface PEPeer
    • getOutboundConnectionProgress

      public int getOutboundConnectionProgress()
      Specified by:
      getOutboundConnectionProgress in interface PEPeerTransport
    • closeConnectionInternally

      protected void closeConnectionInternally(String reason, int reason_code, boolean connect_failed, boolean network_failure)
      Close the peer connection from within the PEPeerTransport object.
      Parameters:
      reason -
    • closeConnectionInternally

      protected void closeConnectionInternally(String reason, int reason_code)
    • closeConnection

      public void closeConnection(String reason, int reason_code)
      Close the peer connection from the PEPeerControl manager side. NOTE: This method assumes PEPeerControl already knows about the close. This method is intended to be only invoked by select administrative methods. You probably should not invoke this directly.
      Specified by:
      closeConnection in interface PEPeerTransport
      Parameters:
      reason - for closure
    • performClose

      private void performClose(String reason, int close_reason_out, boolean connect_failed, boolean externally_closed, boolean network_failure)
    • isClosed

      public boolean isClosed()
      Specified by:
      isClosed in interface PEPeer
    • reconnect

      public PEPeerTransport reconnect(boolean tryUDP, boolean tryIPv6, Map userData)
      Description copied from interface: PEPeerTransport
      Attempts to reconnect to the same peer
      Specified by:
      reconnect in interface PEPeerTransport
      Parameters:
      tryUDP - try to initiate a UDP connection if true, just reestablish the previous state otherwise
      tryIPv6 - TODO
      Returns:
      null if reconnect not possible, reconnected peer otherwise
    • isSafeForReconnect

      public boolean isSafeForReconnect()
      Description copied from interface: PEPeerTransport
      This method is called to check if it is safe to reconnect to a peer, i.e. avoid hammering exchanging data with a peer should work as it takes time to setup the connection and negotiate things before that happens
      Specified by:
      isSafeForReconnect in interface PEPeerTransport
      Returns:
      true if we exchanged payload data with the peer during the current connection
    • isReconnect

      public boolean isReconnect()
      Specified by:
      isReconnect in interface PEPeerTransport
    • checkForReconnect

      private void checkForReconnect(HashWrapper oldID)
    • generateSessionId

      private void generateSessionId()
    • addAvailability

      private void addAvailability()
    • removeAvailability

      private void removeAvailability()
    • sendBTHandshake

      protected void sendBTHandshake()
    • sendLTHandshake

      private void sendLTHandshake()
    • sendAZHandshake

      private void sendAZHandshake()
    • getPeerState

      public int getPeerState()
      Specified by:
      getPeerState in interface PEPeer
    • isDownloadPossible

      public boolean isDownloadPossible()
      Description copied from interface: PEPeer
      checks several factors within the object so the caller wouldn't need to for convenience and speed.
      Specified by:
      isDownloadPossible in interface PEPeer
      Returns:
      true if none of several criteria indicate a request can't be made of the peer
    • getPercentDoneInThousandNotation

      public int getPercentDoneInThousandNotation()
      Description copied from interface: PEPeer
      Get the peer's torrent completion percentage in thousand-notation, i.e. 53.7% is returned as the value 0537.
      Specified by:
      getPercentDoneInThousandNotation in interface PEPeer
      Returns:
      the percentage the peer has complete
    • transferAvailable

      public boolean transferAvailable()
      Specified by:
      transferAvailable in interface PEPeer
      Specified by:
      transferAvailable in interface PEPeerTransport
    • printRequestStats

      private void printRequestStats()
    • checkSeed

      private void checkSeed()
      Checks if this peer is a seed or not by trivially checking if their Have bitflags exists and shows a number of bits set equal to the torrent # of pieces (and the torrent # of pieces is >0)
    • request

      public DiskManagerReadRequest request(int pieceNumber, int pieceOffset, int pieceLength, boolean return_duplicates)
      Specified by:
      request in interface PEPeerTransport
      return_duplicates - - if true and request already exists it will be returned, if false -> null
      Returns:
      request if actually requested, null otherwise
    • getRequestIndex

      public int getRequestIndex(DiskManagerReadRequest request)
      Description copied from interface: PEPeerTransport
      Returns the index of this request in the peer's queue or -1 if not found
      Specified by:
      getRequestIndex in interface PEPeerTransport
      Returns:
    • sendCancel

      public void sendCancel(DiskManagerReadRequest request)
      Specified by:
      sendCancel in interface PEPeerTransport
    • sendHaveNone

      private void sendHaveNone()
    • sendHave

      public void sendHave(int pieceNumber)
      Specified by:
      sendHave in interface PEPeerTransport
    • sendChoke

      public void sendChoke()
      Specified by:
      sendChoke in interface PEPeer
      Specified by:
      sendChoke in interface PEPeerTransport
    • sendUnChoke

      public void sendUnChoke()
      Specified by:
      sendUnChoke in interface PEPeer
      Specified by:
      sendUnChoke in interface PEPeerTransport
    • createPieceMessageHandler

      private void createPieceMessageHandler()
    • destroyPieceMessageHandler

      private void destroyPieceMessageHandler()
    • sendKeepAlive

      private void sendKeepAlive()
    • sendMainlineDHTPort

      private void sendMainlineDHTPort()
    • checkInterested

      public void checkInterested()
      Global checkInterested method. Early-out scan of pieces to determine if the peer is interesting or not. They're interesting if they have a piece that we Need and isn't Done
      Specified by:
      checkInterested in interface PEPeerTransport
    • sendBitField

      private void sendBitField()
      Private method to send the bitfield.
    • sendLazyHaves

      protected void sendLazyHaves(int[] lazy_haves, boolean immediate)
    • getId

      public byte[] getId()
      Specified by:
      getId in interface PEPeer
    • getIp

      public String getIp()
      Specified by:
      getIp in interface PEPeer
    • getAlternativeIPv6

      public InetAddress getAlternativeIPv6()
      Specified by:
      getAlternativeIPv6 in interface PEPeer
      Returns:
      an ipv6 address under which the peer should be connectable if it announced one, null otherwise
    • getPort

      public int getPort()
      Description copied from interface: PEPeer
      Get the peer's local TCP connection port.
      Specified by:
      getPort in interface PEPeer
      Returns:
      local port
    • getTCPListenPort

      public int getTCPListenPort()
      Description copied from interface: PEPeer
      Get the TCP port this peer is listening for incoming connections on.
      Specified by:
      getTCPListenPort in interface PEPeer
      Returns:
      TCP port, or 0 if port is unknown
    • getUDPListenPort

      public int getUDPListenPort()
      Description copied from interface: PEPeer
      Get the UDP port this peer is listening for incoming connections on.
      Specified by:
      getUDPListenPort in interface PEPeer
      Returns:
      UDP port, or 0 if port is unknown
    • getUDPNonDataListenPort

      public int getUDPNonDataListenPort()
      Description copied from interface: PEPeer
      Get the UDP port this peer is listening on for non-data connections
      Specified by:
      getUDPNonDataListenPort in interface PEPeer
      Returns:
    • getClient

      public String getClient()
      Specified by:
      getClient in interface PEPeer
    • isIncoming

      public boolean isIncoming()
      Specified by:
      isIncoming in interface PEPeer
    • isOptimisticUnchoke

      public boolean isOptimisticUnchoke()
      Specified by:
      isOptimisticUnchoke in interface PEPeer
    • setOptimisticUnchoke

      public void setOptimisticUnchoke(boolean is_optimistic)
      Specified by:
      setOptimisticUnchoke in interface PEPeer
    • getControl

      public PEPeerControl getControl()
      Specified by:
      getControl in interface PEPeerTransport
    • getManager

      public PEPeerManager getManager()
      Specified by:
      getManager in interface PEPeer
    • getStats

      public PEPeerStats getStats()
      Specified by:
      getStats in interface PEPeer
    • getPriorityOffsets

      public int[] getPriorityOffsets()
      Description copied from interface: PEPeerTransport
      Any priority offsets this peer has, or null if none
      Specified by:
      getPriorityOffsets in interface PEPeerTransport
      Returns:
    • requestAllocationStarts

      public boolean requestAllocationStarts(int[] base_priorities)
      Description copied from interface: PEPeerTransport
      Two methods that allow a peer to aggregate the individual requests generated during an allocation cycle if so desired
      Specified by:
      requestAllocationStarts in interface PEPeerTransport
      Returns:
      true if the peer is managing request priorities and doesn't want end-game random allocation behaviour
    • requestAllocationComplete

      public void requestAllocationComplete()
      Specified by:
      requestAllocationComplete in interface PEPeerTransport
    • getAvailable

      public BitFlags getAvailable()
      Specified by:
      getAvailable in interface PEPeer
      Returns:
      null if no bitfield has been received yet else returns BitFlags indicating what pieces the peer has
    • isPieceAvailable

      public boolean isPieceAvailable(int pieceNumber)
      Specified by:
      isPieceAvailable in interface PEPeer
      Parameters:
      pieceNumber - int
      Returns:
      true if this peers makes this piece available
    • isChokingMe

      public boolean isChokingMe()
      Description copied from interface: PEPeer
      Is the peer choking me.
      Specified by:
      isChokingMe in interface PEPeer
      Returns:
      true if I am choked by the peer, false if not
    • isUnchokeOverride

      public boolean isUnchokeOverride()
      Specified by:
      isUnchokeOverride in interface PEPeer
    • isChokedByMe

      public boolean isChokedByMe()
      Description copied from interface: PEPeer
      Am I choking the peer.
      Specified by:
      isChokedByMe in interface PEPeer
      Returns:
      true if the peer is choked, false if not
    • isInteresting

      public boolean isInteresting()
      Description copied from interface: PEPeer
      Am I Interested in the peer.
      Specified by:
      isInteresting in interface PEPeer
      Returns:
      true if the peer is interesting to us
    • isInterested

      public boolean isInterested()
      Description copied from interface: PEPeer
      Is the peer Interested in me.
      Specified by:
      isInterested in interface PEPeer
      Returns:
      true if the peer is interested in what we're offering
    • isSeed

      public boolean isSeed()
      Specified by:
      isSeed in interface PEPeer
    • isRelativeSeed

      public boolean isRelativeSeed()
      Specified by:
      isRelativeSeed in interface PEPeer
      Returns:
      true if the peer is only uploading and can't use the data we have to offer (we're seeding) or we can't use the data he has to offer (we're downloading)
    • setSeed

      private void setSeed(boolean s)
    • isSnubbed

      public boolean isSnubbed()
      Specified by:
      isSnubbed in interface PEPeer
    • getSnubbedTime

      public long getSnubbedTime()
      Specified by:
      getSnubbedTime in interface PEPeer
    • setSnubbed

      public void setSnubbed(boolean b)
      Specified by:
      setSnubbed in interface PEPeer
    • setUploadHint

      public void setUploadHint(int spreadTime)
      Specified by:
      setUploadHint in interface PEPeer
    • getUploadHint

      public int getUploadHint()
      Specified by:
      getUploadHint in interface PEPeer
    • setUniqueAnnounce

      public void setUniqueAnnounce(int _uniquePiece)
      Specified by:
      setUniqueAnnounce in interface PEPeer
    • getUniqueAnnounce

      public int getUniqueAnnounce()
      Specified by:
      getUniqueAnnounce in interface PEPeer
    • getData

      public Object getData(String key)
      Description copied from interface: PEPeer
      To retreive arbitrary objects against a peer.
      Specified by:
      getData in interface PEPeer
    • setData

      public void setData(String key, Object value)
      Description copied from interface: PEPeer
      To store arbitrary objects against a peer.
      Specified by:
      setData in interface PEPeer
    • getUserData

      public Object getUserData(Object key)
      To retreive arbitrary objects against a peer.
      Specified by:
      getUserData in interface PEPeer
    • setUserData

      public void setUserData(Object key, Object value)
      To store arbitrary objects against a peer.
      Specified by:
      setUserData in interface PEPeer
    • getIPHostName

      public String getIPHostName()
      Description copied from interface: PEPeer
      Gets the host name for the IP, if possible, IP as string otherwise
      Specified by:
      getIPHostName in interface PEPeer
      Returns:
      hostname or IP
    • cancelRequests

      private void cancelRequests()
    • getMaxNbRequests

      public int getMaxNbRequests()
      Description copied from interface: PEPeerTransport
      peer-specific request max. return -1 to use the default piece-picker allocation method
      Specified by:
      getMaxNbRequests in interface PEPeerTransport
      Returns:
    • getNbRequests

      public int getNbRequests()
      Specified by:
      getNbRequests in interface PEPeerTransport
    • getExpiredRequests

      public List getExpiredRequests()
      Specified by:
      getExpiredRequests in interface PEPeerTransport
      Returns:
      may be null for performance purposes
    • lookupRequest

      private DiskManagerReadRequest lookupRequest(int piece_number, int piece_offset, int length)
    • hasBeenRequested

      private boolean hasBeenRequested(DiskManagerReadRequest request)
    • removeRequest

      protected void removeRequest(DiskManagerReadRequest request)
    • resetRequestsTimeMono

      private void resetRequestsTimeMono(long mono_now)
    • toString

      public String toString()
      Overrides:
      toString in class Object
    • getString

      public String getString()
    • doKeepAliveCheck

      public void doKeepAliveCheck()
      Description copied from interface: PEPeerTransport
      Check if we need to send a keep-alive message. A keep-alive is sent if no other message has been sent within the last 2min.
      Specified by:
      doKeepAliveCheck in interface PEPeerTransport
    • updateAutoUploadPriority

      public void updateAutoUploadPriority(Object key, boolean inc)
      Specified by:
      updateAutoUploadPriority in interface PEPeer
    • doTimeoutChecks

      public boolean doTimeoutChecks()
      Description copied from interface: PEPeerTransport
      Check for possible connection timeouts.
      Specified by:
      doTimeoutChecks in interface PEPeerTransport
      Returns:
      true if the connection has been timed-out, false if not
    • doPerformanceTuningCheck

      public void doPerformanceTuningCheck()
      Description copied from interface: PEPeerTransport
      Perform checks related to performance optimizations, i.e. tune buffering related to send/receive speed.
      Specified by:
      doPerformanceTuningCheck in interface PEPeerTransport
    • getConnectionState

      public int getConnectionState()
      Description copied from interface: PEPeerTransport
      Get the specific peer connection state.
      Specified by:
      getConnectionState in interface PEPeerTransport
      Returns:
      connection state
    • getTimeSinceLastDataMessageReceived

      public long getTimeSinceLastDataMessageReceived()
      Description copied from interface: PEPeerTransport
      Get the time since the last (most-recent) data (payload) message was received.
      Specified by:
      getTimeSinceLastDataMessageReceived in interface PEPeerTransport
      Returns:
      time count in ms, or -1 if we've never received a data message from them
    • getTimeSinceGoodDataReceived

      public long getTimeSinceGoodDataReceived()
      Description copied from interface: PEPeerTransport
      Get the time since the most-recent data that was actually written to disk was received.
      Specified by:
      getTimeSinceGoodDataReceived in interface PEPeerTransport
      Returns:
      time count in ms, or -1 if we've never received useful data from them
    • getTimeSinceLastDataMessageSent

      public long getTimeSinceLastDataMessageSent()
      Description copied from interface: PEPeerTransport
      Get the time since the last (most-recent) data (payload) message was sent.
      Specified by:
      getTimeSinceLastDataMessageSent in interface PEPeerTransport
      Returns:
      time count in ms, or -1 if we've never sent them a data message
    • getConnectionEstablishedMonoTime

      public long getConnectionEstablishedMonoTime()
      Description copied from interface: PEPeer
      Get the time this connection was first established. NOTE: This method will always return -1 at any time before the underlying transport is fully connected, i.e. before handshaking begins.
      Specified by:
      getConnectionEstablishedMonoTime in interface PEPeer
      Returns:
      mono time in ms
    • getConsecutiveNoRequestCount

      public int getConsecutiveNoRequestCount()
      Specified by:
      getConsecutiveNoRequestCount in interface PEPeer
    • setConsecutiveNoRequestCount

      public void setConsecutiveNoRequestCount(int num)
      Specified by:
      setConsecutiveNoRequestCount in interface PEPeer
    • decodeBTHandshake

      protected void decodeBTHandshake(BTHandshake handshake)
    • decideExtensionProtocol

      private int decideExtensionProtocol(BTHandshake handshake)
    • decodeLTHandshake

      protected void decodeLTHandshake(LTHandshake handshake)
    • decodeAZHandshake

      protected void decodeAZHandshake(AZHandshake handshake)
    • spoofMDAvailability

      private void spoofMDAvailability(int mds)
    • initPostConnection

      private void initPostConnection(Message handshake)
    • decodeHaveAll

      protected void decodeHaveAll(BTHaveAll have_all)
    • decodeHaveNone

      protected void decodeHaveNone(BTHaveNone have_none)
    • decodeBitfield

      protected void decodeBitfield(BTBitfield bitfield)
    • setSuspendedLazyBitFieldEnabled

      public void setSuspendedLazyBitFieldEnabled(boolean enable)
      Description copied from interface: PEPeer
      Enable suspended lazy bitfield for this peer - we will appear incomplete until this is disabled, at which point (well, fairly soon after) the bitfield will be completed
      Specified by:
      setSuspendedLazyBitFieldEnabled in interface PEPeer
    • decodeMainlineDHTPort

      protected void decodeMainlineDHTPort(BTDHTPort port)
    • decodeChoke

      protected void decodeChoke(BTChoke choke)
    • decodeUnchoke

      protected void decodeUnchoke(BTUnchoke unchoke)
    • decodeInterested

      protected void decodeInterested(BTInterested interested)
    • decodeUninterested

      protected void decodeUninterested(BTUninterested uninterested)
    • decodeHave

      protected void decodeHave(BTHave have)
    • decodeAZHave

      protected void decodeAZHave(AZHave have)
    • getBytesDownloaded

      protected long getBytesDownloaded()
    • getBytesRemaining

      public long getBytesRemaining()
      Specified by:
      getBytesRemaining in interface PEPeer
    • sendBadPiece

      public void sendBadPiece(int piece_number)
      Specified by:
      sendBadPiece in interface PEPeerTransport
    • decodeAZBadPiece

      protected void decodeAZBadPiece(AZBadPiece bad_piece)
    • sendStatsRequest

      public void sendStatsRequest(Map request)
      Specified by:
      sendStatsRequest in interface PEPeer
      Specified by:
      sendStatsRequest in interface PEPeerTransport
    • decodeAZStatsRequest

      protected void decodeAZStatsRequest(AZStatRequest request)
    • sendStatsReply

      public void sendStatsReply(Map reply)
      Specified by:
      sendStatsReply in interface PEPeerTransport
    • decodeAZStatsReply

      protected void decodeAZStatsReply(AZStatReply reply)
    • decodeRequest

      protected void decodeRequest(BTRequest request)
    • sendRejectRequest

      public void sendRejectRequest(DiskManagerReadRequest request)
      Specified by:
      sendRejectRequest in interface PEPeer
    • sendRejectRequest

      private void sendRejectRequest(int number, int offset, int length)
    • decodePiece

      protected void decodePiece(BTPiece piece)
    • decodeCancel

      protected void decodeCancel(BTCancel cancel)
    • decodeRejectRequest

      protected void decodeRejectRequest(BTRejectRequest reject)
    • sendHashRequest

      public void sendHashRequest(TOTorrentFileHashTree.HashRequest req)
      Specified by:
      sendHashRequest in interface PEPeerTransport
    • decodeHashRequest

      private void decodeHashRequest(BTHashRequest request)
    • decodeHashes

      private void decodeHashes(BTHashes hashes)
    • decodeHashReject

      private void decodeHashReject(BTHashReject reject)
    • decodeAllowedFast

      private void decodeAllowedFast(BTAllowedFast allowed)
    • sendAllowFast

      private void sendAllowFast(int number)
    • calculatePiecePriorities

      protected void calculatePiecePriorities()
    • checkFast

      protected void checkFast(BitFlags flags)
    • checkAllowedFast

      private void checkAllowedFast()
    • registerForMessageHandling

      private void registerForMessageHandling()
    • addRateLimiter

      public void addRateLimiter(LimitedRateGroup limiter, boolean upload)
      Specified by:
      addRateLimiter in interface PEPeer
    • getRateLimiters

      public LimitedRateGroup[] getRateLimiters(boolean upload)
      Specified by:
      getRateLimiters in interface PEPeer
    • removeRateLimiter

      public void removeRateLimiter(LimitedRateGroup limiter, boolean upload)
      Specified by:
      removeRateLimiter in interface PEPeer
    • setUploadDisabled

      public void setUploadDisabled(Object key, boolean disabled)
      Specified by:
      setUploadDisabled in interface PEPeer
    • setDownloadDisabled

      public void setDownloadDisabled(Object key, boolean disabled)
      Specified by:
      setDownloadDisabled in interface PEPeer
    • isUploadDisabled

      public boolean isUploadDisabled()
      Specified by:
      isUploadDisabled in interface PEPeer
    • isUploadDisabled

      public boolean isUploadDisabled(Object key)
    • isDownloadDisabled

      public boolean isDownloadDisabled()
      Specified by:
      isDownloadDisabled in interface PEPeer
    • isDownloadDisabled

      public boolean isDownloadDisabled(Object key)
    • getNetworkConnection

      public NetworkConnectionBase getNetworkConnection()
      Specified by:
      getNetworkConnection in interface PEPeer
    • getPluginConnection

      public Connection getPluginConnection()
      Description copied from interface: PEPeer
      Get the connection that backs this peer.
      Specified by:
      getPluginConnection in interface PEPeer
      Returns:
      connection
    • getSupportedMessages

      public Message[] getSupportedMessages()
      Description copied from interface: PEPeer
      Get the list of messages that this peer and us both understand.
      Specified by:
      getSupportedMessages in interface PEPeer
      Returns:
      messages available for use, or null of supported is yet unknown or unavailable
    • supportsMessaging

      public boolean supportsMessaging()
      Description copied from interface: PEPeer
      Whether or not this peer supports the advanced messaging API.
      Specified by:
      supportsMessaging in interface PEPeer
      Returns:
      true if extended messaging is supported, false if not
    • getMessagingMode

      public int getMessagingMode()
      Specified by:
      getMessagingMode in interface PEPeer
    • getHandshakeReservedBytes

      public byte[] getHandshakeReservedBytes()
      Specified by:
      getHandshakeReservedBytes in interface PEPeer
    • setHaveAggregationEnabled

      public void setHaveAggregationEnabled(boolean enabled)
      Specified by:
      setHaveAggregationEnabled in interface PEPeer
    • hasReceivedBitField

      public boolean hasReceivedBitField()
      Specified by:
      hasReceivedBitField in interface PEPeer
    • getUnchokedForMillis

      public long getUnchokedForMillis()
      Specified by:
      getUnchokedForMillis in interface PEPeerTransport
    • getLatency

      public long getLatency()
      Specified by:
      getLatency in interface PEPeerTransport
    • getEncryption

      public String getEncryption()
      Description copied from interface: PEPeer
      Returns name of encryption used by the peer
      Specified by:
      getEncryption in interface PEPeer
      Returns:
    • getProtocol

      public String getProtocol()
      Specified by:
      getProtocol in interface PEPeer
    • getProtocolQualifier

      public String getProtocolQualifier()
      Specified by:
      getProtocolQualifier in interface PEPeer
    • addListener

      public void addListener(PEPeerListener listener)
      Description copied from interface: PEPeer
      Add peer listener.
      Specified by:
      addListener in interface PEPeer
    • removeListener

      public void removeListener(PEPeerListener listener)
      Description copied from interface: PEPeer
      Remove peer listener.
      Specified by:
      removeListener in interface PEPeer
    • changePeerState

      private void changePeerState(int new_state)
    • doPostHandshakeProcessing

      private void doPostHandshakeProcessing()
      this method might be called repeatedly since LTEP allows headers to be sent more than once make sure that multiple invokations do not have unintended consequences
    • canBePeerExchanged

      private boolean canBePeerExchanged()
    • peerSupportsMessageType

      private boolean peerSupportsMessageType(String message_id)
    • updatePeerExchange

      public void updatePeerExchange()
      Description copied from interface: PEPeerTransport
      Do any peer exchange processing/updating.
      Specified by:
      updatePeerExchange in interface PEPeerTransport
    • decodePeerExchange

      protected void decodePeerExchange(AZStylePeerExchange exchange)
    • decodeMetaData

      protected void decodeMetaData(AZUTMetaData metadata)
    • decodeUploadOnly

      protected void decodeUploadOnly(UTUploadOnly message)
    • isHolePunchSupported

      private boolean isHolePunchSupported()
    • canSendHolePunch

      public boolean canSendHolePunch()
      Specified by:
      canSendHolePunch in interface PEPeerTransport
    • sendHolePunch

      public void sendHolePunch(InetAddress address, int port)
      Specified by:
      sendHolePunch in interface PEPeerTransport
    • decodeHolePunch

      protected void decodeHolePunch(UTHolePunch message)
    • sendRequestHint

      public boolean sendRequestHint(int piece_number, int offset, int length, int life)
      Description copied from interface: PEPeer
      Send a request hint to the peer.
      Specified by:
      sendRequestHint in interface PEPeer
      Returns:
      true if sent, false otherwise
    • decodeSuggestPiece

      protected void decodeSuggestPiece(BTSuggestPiece hint)
    • decodeAZRequestHint

      protected void decodeAZRequestHint(AZRequestHint hint)
    • getRequestHint

      public int[] getRequestHint()
      Description copied from interface: PEPeer
      Get current request hint for a given piece for this peer.
      Specified by:
      getRequestHint in interface PEPeer
      Returns:
      null if no hint int[]{ piece_number, offset, length } if hint found
    • clearRequestHint

      public void clearRequestHint()
      Specified by:
      clearRequestHint in interface PEPeer
    • getPeerItemIdentity

      public PeerItem getPeerItemIdentity()
      Description copied from interface: PEPeerTransport
      Get the peer's address + port identification item.
      Specified by:
      getPeerItemIdentity in interface PEPeerTransport
      Returns:
      id
    • getReservedPieceNumbers

      public int[] getReservedPieceNumbers()
      Description copied from interface: PEPeer
      Get the reserved pieces for piece picking by this peer
      Specified by:
      getReservedPieceNumbers in interface PEPeer
    • addReservedPieceNumber

      public void addReservedPieceNumber(int piece_number)
      Description copied from interface: PEPeer
      adds the reserved piece for piece picking by this peer
      Specified by:
      addReservedPieceNumber in interface PEPeer
    • removeReservedPieceNumber

      public void removeReservedPieceNumber(int piece_number)
      Specified by:
      removeReservedPieceNumber in interface PEPeer
    • getIncomingRequestCount

      public int getIncomingRequestCount()
      Specified by:
      getIncomingRequestCount in interface PEPeer
    • getOutgoingRequestCount

      public int getOutgoingRequestCount()
      Specified by:
      getOutgoingRequestCount in interface PEPeer
    • isStalledPendingLoad

      public boolean isStalledPendingLoad()
      Description copied from interface: PEPeerTransport
      is peer waiting for a disk read with no network writes queued
      Specified by:
      isStalledPendingLoad in interface PEPeerTransport
      Returns:
    • getIncomingRequestedPieceNumbers

      public int[] getIncomingRequestedPieceNumbers()
      Description copied from interface: PEPeer
      get a list of piece numbers the peer has requested
      Specified by:
      getIncomingRequestedPieceNumbers in interface PEPeer
      Returns:
      list of Long() representing the piece number requested, in order
    • getIncomingRequestedPieceNumberCount

      public int getIncomingRequestedPieceNumberCount()
      Specified by:
      getIncomingRequestedPieceNumberCount in interface PEPeerTransport
    • getRecentPiecesSent

      public DiskManagerReadRequest[] getRecentPiecesSent()
      Specified by:
      getRecentPiecesSent in interface PEPeer
    • getOutgoingRequestedPieceNumbers

      public int[] getOutgoingRequestedPieceNumbers()
      Description copied from interface: PEPeer
      get a list of piece numbers the we have requested from peer
      Specified by:
      getOutgoingRequestedPieceNumbers in interface PEPeer
      Returns:
      list of Long() representing the piece number requested, oldest to newest
    • getCurrentIncomingRequestProgress

      public int[] getCurrentIncomingRequestProgress()
      Specified by:
      getCurrentIncomingRequestProgress in interface PEPeer
      Returns:
      null or { size, done }
    • getCurrentOutgoingRequestProgress

      public int[] getCurrentOutgoingRequestProgress()
      Specified by:
      getCurrentOutgoingRequestProgress in interface PEPeer
    • getLastMessageSentTimeMono

      public long getLastMessageSentTimeMono()
      Specified by:
      getLastMessageSentTimeMono in interface PEPeerTransport
    • getRelationText

      public String getRelationText()
      Description copied from class: LogRelation
      A short description of what your class holds that can be printed by the logger
      Overrides:
      getRelationText in class LogRelation
      Returns:
    • getQueryableInterfaces

      public Object[] getQueryableInterfaces()
      Description copied from class: LogRelation
      Query this class for a reference to another class that it may hold
      Overrides:
      getQueryableInterfaces in class LogRelation
      Returns:
      If found, the class desired. Otherwise, null.
    • getLastPiece

      public int getLastPiece()
      Specified by:
      getLastPiece in interface PEPeer
    • setLastPiece

      public void setLastPiece(int pieceNumber)
      Specified by:
      setLastPiece in interface PEPeer
    • isLANLocal

      public boolean isLANLocal()
      Description copied from interface: PEPeerTransport
      Is the connection within the local LAN network.
      Specified by:
      isLANLocal in interface PEPeer
      Specified by:
      isLANLocal in interface PEPeerTransport
      Returns:
      true if within LAN, false of outside the LAN segment
    • resetLANLocalStatus

      public void resetLANLocalStatus()
      Specified by:
      resetLANLocalStatus in interface PEPeer
    • isTCP

      public boolean isTCP()
      Specified by:
      isTCP in interface PEPeerTransport
    • getNetwork

      public String getNetwork()
      Specified by:
      getNetwork in interface PEPeerTransport
    • setUploadRateLimitBytesPerSecond

      public void setUploadRateLimitBytesPerSecond(int bytes)
      Specified by:
      setUploadRateLimitBytesPerSecond in interface PEPeer
    • getUploadRateLimitBytesPerSecond

      public int getUploadRateLimitBytesPerSecond()
      Specified by:
      getUploadRateLimitBytesPerSecond in interface PEPeer
    • setDownloadRateLimitBytesPerSecond

      public void setDownloadRateLimitBytesPerSecond(int bytes)
      Specified by:
      setDownloadRateLimitBytesPerSecond in interface PEPeer
    • getDownloadRateLimitBytesPerSecond

      public int getDownloadRateLimitBytesPerSecond()
      Specified by:
      getDownloadRateLimitBytesPerSecond in interface PEPeer
    • getClientNameFromPeerID

      public String getClientNameFromPeerID()
      Specified by:
      getClientNameFromPeerID in interface PEPeer
    • getClientNameFromExtensionHandshake

      public String getClientNameFromExtensionHandshake()
      Specified by:
      getClientNameFromExtensionHandshake in interface PEPeer
    • getDHTProvider

      private static MainlineDHTProvider getDHTProvider()
    • setPriorityConnection

      public void setPriorityConnection(boolean is_priority)
      Specified by:
      setPriorityConnection in interface PEPeer
    • isPriorityConnection

      public boolean isPriorityConnection()
      Specified by:
      isPriorityConnection in interface PEPeer
    • generateFastSet

      protected List<Integer> generateFastSet(byte[] hash, String ip, int num_pieces, int num_required)
    • generateFastSet

      protected List<Integer> generateFastSet(int num)
    • getTaggableType

      public int getTaggableType()
      Specified by:
      getTaggableType in interface Taggable
    • getTaggableID

      public String getTaggableID()
      Specified by:
      getTaggableID in interface Taggable
    • getTaggableName

      public String getTaggableName()
      Specified by:
      getTaggableName in interface Taggable
    • getTaggableResolver

      public TaggableResolver getTaggableResolver()
      Specified by:
      getTaggableResolver in interface Taggable
    • getTaggableTransientProperty

      public Object getTaggableTransientProperty(String key)
      Specified by:
      getTaggableTransientProperty in interface Taggable
    • setTaggableTransientProperty

      public void setTaggableTransientProperty(String key, Object value)
      Specified by:
      setTaggableTransientProperty in interface Taggable
    • generateEvidence

      public void generateEvidence(IndentWriter writer)
      Specified by:
      generateEvidence in interface PEPeerTransport