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

    • tagMutationCounter

      private AtomicLong tagMutationCounter

    • 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

    • 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
      Parameters:
      pieceNumber -
      pieceOffset -
      pieceLength -
      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
      Parameters:
      enable -

    • 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
      Parameters:
      listener -

    • removeListener

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

    • 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
      Parameters:
      piece_number -
      offset -
      length -
      life -
      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

    • getTagMutationCount

      public long getTagMutationCount()
      Specified by:
      getTagMutationCount in interface Taggable

    • updateTagMutationCount

      public void updateTagMutationCount()
      Specified by:
      updateTagMutationCount 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

    • getDescriptor

      public PeerDescriptor getDescriptor()
      Specified by:
      getDescriptor in interface PEPeer

    • generateEvidence

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