Class PEPeerTransportProtocol

    • Field Detail

      • LOGID

        protected static final LogIDs LOGID
      • _lastPiece

        private volatile int _lastPiece
      • nbPieces

        protected final int nbPieces
      • peer_source

        private final java.lang.String peer_source
      • peer_id

        private byte[] peer_id
      • ip

        private final java.lang.String ip
      • network

        private final java.lang.String network
      • ip_resolved

        protected java.lang.String ip_resolved
      • 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 java.net.InetAddress alternativeAddress
      • crypto_level

        private byte crypto_level
      • requested_mon

        private final AEMonitor requested_mon
      • data

        private java.util.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
      • snubbed

        private long snubbed
      • 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_UPLOAD_ONLY_INDICATED

        private static final byte RELATIVE_SEEDING_UPLOAD_ONLY_INDICATED
        See Also:
        Constant Field Values
      • RELATIVE_SEEDING_UPLOAD_ONLY_SEED

        private static final byte RELATIVE_SEEDING_UPLOAD_ONLY_SEED
        See Also:
        Constant Field Values
      • relativeSeeding

        private byte relativeSeeding
      • incoming

        private final boolean incoming
      • closing

        protected volatile boolean closing
      • current_peer_state

        private volatile int current_peer_state
      • plugin_connection

        private Connection plugin_connection
      • identityAdded

        private boolean identityAdded
      • connection_state

        private int connection_state
      • outbound_connection_progress

        private int outbound_connection_progress
      • client

        private java.lang.String client
      • client_peer_id

        private java.lang.String client_peer_id
      • client_handshake

        private java.lang.String client_handshake
      • client_handshake_version

        private java.lang.String client_handshake_version
      • uniquePiece

        private int uniquePiece
      • reserved_pieces

        private int[] reserved_pieces
      • spreadTimeHint

        private int spreadTimeHint
      • last_message_sent_time

        private long last_message_sent_time
      • last_message_received_time

        private long last_message_received_time
      • last_data_message_received_time

        private long last_data_message_received_time
      • last_good_data_time

        private long last_good_data_time
      • last_data_message_sent_time

        private long last_data_message_sent_time
      • connection_established_time

        private long connection_established_time
      • 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:
        Constant Field Values
      • 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
      • ut_pex_enabled

        private boolean ut_pex_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:
        Constant Field Values
      • ALLOWED_FAST_OTHER_PEER_PIECE_MAX

        private static final int ALLOWED_FAST_OTHER_PEER_PIECE_MAX
        See Also:
        Constant Field Values
      • KEY_ALLOWED_FAST_RECEIVED

        private static final java.lang.Object KEY_ALLOWED_FAST_RECEIVED
      • KEY_ALLOWED_FAST_SENT

        private static final java.lang.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 java.util.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

        private int[] request_hint
      • peer_listeners_cow

        private java.util.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
      • fast_unchoke_new_peers

        private static boolean fast_unchoke_new_peers
      • rnd

        private static final java.util.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
      • allowReconnect

        private boolean allowReconnect
      • upload_disabled_set

        private java.util.Set<java.lang.Object> upload_disabled_set
      • download_disabled_set

        private java.util.Set<java.lang.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_supported

        private boolean peer_exchange_supported
      • 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
    • Constructor Detail

      • PEPeerTransportProtocol

        public PEPeerTransportProtocol​(PEPeerControl _manager,
                                       java.lang.String _peer_source,
                                       NetworkConnection _connection,
                                       java.util.Map _initial_user_data)
      • PEPeerTransportProtocol

        public PEPeerTransportProtocol​(PEPeerControl _manager,
                                       java.lang.String _peer_source,
                                       java.lang.String _ip,
                                       int _tcp_port,
                                       int _udp_port,
                                       boolean _use_tcp,
                                       boolean _require_crypto_handshake,
                                       byte _crypto_level,
                                       java.util.Map _initial_user_data)
    • Method Detail

      • 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 java.lang.String getPeerSource()
        Specified by:
        getPeerSource in interface PEPeer
      • closeConnectionInternally

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

        protected void closeConnectionInternally​(java.lang.String reason)
      • closeConnection

        public void closeConnection​(java.lang.String reason)
        Close the peer connection from the PEPeerControl manager side. NOTE: This method assumes PEPeerControl already knows about the close. This method is inteded 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​(java.lang.String reason,
                                  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)
        Description copied from interface: PEPeerTransport
        Attempts to reconnect to the same peer
        Specified by:
        reconnect in interface PEPeerTransport
        Parameters:
        tryUDP - try to initate 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
      • 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 convienience 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
      • printRequestStats

        private void printRequestStats()
      • checkSeed

        private void checkSeed()
        Checks if this peer is a seed or not by trivially checking if thier Have bitflags exisits 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
      • sendHaveNone

        private void sendHaveNone()
      • 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 java.lang.String getIp()
        Specified by:
        getIp in interface PEPeer
      • getAlternativeIPv6

        public java.net.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 java.lang.String getClient()
        Specified by:
        getClient in interface PEPeer
      • isIncoming

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

        public void setOptimisticUnchoke​(boolean is_optimistic)
        Specified by:
        setOptimisticUnchoke in interface PEPeer
      • 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
      • getAvailable

        public BitFlags getAvailable()
        Specified by:
        getAvailable in interface PEPeer
        Returns:
        null if no bitfield has been recieved 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
      • 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
      • setSnubbed

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

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

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

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

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

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

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

        public java.lang.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:
      • getExpiredRequests

        public java.util.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)
      • resetRequestsTime

        private void resetRequestsTime​(long now)
      • toString

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

        public java.lang.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​(java.lang.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
      • 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 usefull 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
      • getTimeSinceConnectionEstablished

        public long getTimeSinceConnectionEstablished()
        Description copied from interface: PEPeer
        Get the time since this connection was first established. NOTE: This method will always return 0 at any time before the underlying transport is fully connected, i.e. before handshaking begins.
        Specified by:
        getTimeSinceConnectionEstablished in interface PEPeer
        Returns:
        time count in ms
      • 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()
      • decodeAZBadPiece

        protected void decodeAZBadPiece​(AZBadPiece bad_piece)
      • decodeAZStatsRequest

        protected void decodeAZStatsRequest​(AZStatRequest request)
      • decodeAZStatsReply

        protected void decodeAZStatsReply​(AZStatReply reply)
      • decodeRequest

        protected void decodeRequest​(BTRequest request)
      • 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)
      • 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()
      • setUploadDisabled

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

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

        public boolean isUploadDisabled​(java.lang.Object key)
      • isDownloadDisabled

        public boolean isDownloadDisabled​(java.lang.Object key)
      • 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
      • getEncryption

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

        public java.lang.String getProtocol()
        Specified by:
        getProtocol 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​(java.lang.String message_id)
      • decodeMetaData

        protected void decodeMetaData​(AZUTMetaData metadata)
      • decodeUploadOnly

        protected void decodeUploadOnly​(UTUploadOnly 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
      • 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
      • 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
      • 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
      • getRelationText

        public java.lang.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 java.lang.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
      • setPriorityConnection

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

        protected java.util.List<java.lang.Integer> generateFastSet​(byte[] hash,
                                                                    java.lang.String ip,
                                                                    int num_pieces,
                                                                    int num_required)
      • generateFastSet

        protected java.util.List<java.lang.Integer> generateFastSet​(int num)
      • getTaggableID

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

        public java.lang.String getTaggableName()
        Specified by:
        getTaggableName in interface Taggable
      • setTaggableTransientProperty

        public void setTaggableTransientProperty​(java.lang.String key,
                                                 java.lang.Object value)
        Specified by:
        setTaggableTransientProperty in interface Taggable