Class PeerState


  • public class PeerState
    extends Object
    Contain all of the state about a UDP connection to a peer. This is instantiated only after a connection is fully established. Public only for UI peers page. Not a public API, not for external use.
    • Field Detail

      • RETRANSMISSION_PERIOD_WIDTH

        static final long RETRANSMISSION_PERIOD_WIDTH
        how many packets will be considered within the retransmission rate calculation
        See Also:
        Constant Field Values
      • MIN_MTU

        public static final int MIN_MTU
        IPv4 Min MTU 596 gives us 588 IP byes, 568 UDP bytes, and with an SSU data message, 522 fragment bytes, which is enough to send a tunnel data message in 2 packets. A tunnel data message sent over the wire is 1044 bytes, meaning we need 522 fragment bytes to fit it in 2 packets - add 46 for SSU, 20 for UDP, and 8 for IP, giving us 596. round up to mod 16, giving a total of 608 Well, we really need to count the acks as well, especially 1 + (4 * MAX_RESEND_ACKS_SMALL) which can take up a significant amount of space. We reduce the max acks when using the small MTU but it may not be enough... Goal: VTBM msg fragments 2646 / (620 - 87) fits nicely. Assuming that we can enforce an MTU correctly, this % 16 should be 12, as the IP/UDP header is 28 bytes and data max should be mulitple of 16 for padding efficiency, and so PacketBuilder.buildPacket() works correctly.
        See Also:
        Constant Field Values
      • MIN_IPV6_MTU

        public static final int MIN_IPV6_MTU
        IPv6/UDP header is 48 bytes, so we want MTU % 16 == 0.
        See Also:
        Constant Field Values
      • LARGE_MTU

        public static final int LARGE_MTU
        IPv4 Max MTU based on measurements, 1350 fits nearly all reasonably small I2NP messages (larger I2NP messages may be up to 1900B-4500B, which isn't going to fit into a live network MTU anyway) TODO VTBM is 2646, it would be nice to fit in two large 2646 / 2 = 1323 1323 + 74 + 46 + 1 + (4 * 9) = 1480 So why not make it 1492 (old ethernet is 1492, new is 1500) Changed to 1492 in 0.8.9 BUT through 0.8.11, size estimate was bad, actual packet was up to 48 bytes bigger To be figured out. Curse the ACKs. Assuming that we can enforce an MTU correctly, this % 16 should be 12, as the IP/UDP header is 28 bytes and data max should be mulitple of 16 for padding efficiency, and so PacketBuilder.buildPacket() works correctly.
        See Also:
        Constant Field Values
      • MAX_MTU

        public static final int MAX_MTU
        Max of IPv4 and IPv6 max MTUs
        Since:
        0.9.28
    • Constructor Detail

      • PeerState

        public PeerState​(RouterContext ctx,
                         UDPTransport transport,
                         byte[] remoteIP,
                         int remotePort,
                         Hash remotePeer,
                         boolean isInbound)
    • Method Detail

      • changePort

        public void changePort​(int newPort)
        Caller should sync; UDPTransport must remove and add to peersByRemoteHost map
        Since:
        0.9.3
      • getRemotePeer

        public Hash getRemotePeer()
        The peer are we talking to. This should be set as soon as this state is created if we are initiating a connection, but if we are receiving the connection this will be set only after the connection is established.
      • getCurrentMACKey

        public SessionKey getCurrentMACKey()
        The AES key used to verify packets, set only after the connection is established.
      • getCurrentCipherKey

        public SessionKey getCurrentCipherKey()
        The AES key used to encrypt/decrypt packets, set only after the connection is established.
      • getNextMACKey

        public SessionKey getNextMACKey()
        The pending AES key for verifying packets if we are rekeying the connection, or null if we are not in the process of rekeying.
        Returns:
        null always, rekeying unimplemented
      • getNextCipherKey

        public SessionKey getNextCipherKey()
        The pending AES key for encrypting/decrypting packets if we are rekeying the connection, or null if we are not in the process of rekeying.
        Returns:
        null always, rekeying unimplemented
      • getKeyEstablishedTime

        public long getKeyEstablishedTime()
        when were the current cipher and MAC keys established/rekeyed?
      • getClockSkew

        public long getClockSkew()
        How far off is the remote peer from our clock, in milliseconds? A positive number means our clock is ahead of theirs.
      • getCurrentReceiveSecond

        public long getCurrentReceiveSecond()
        what is the current receive second, for congestion control?
      • getLastSendTime

        public long getLastSendTime()
        when did we last send them a packet?
      • getLastSendFullyTime

        public long getLastSendFullyTime()
        when did we last send them a message that was ACKed?
      • getLastReceiveTime

        public long getLastReceiveTime()
        when did we last receive a packet from them?
      • getConsecutiveFailedSends

        public int getConsecutiveFailedSends()
        how many seconds have we sent packets without any ACKs received?
      • getCurrentSecondECNReceived

        @Deprecated
        public boolean getCurrentSecondECNReceived()
        Deprecated.
        unused, ECNs are never sent, always returns false
        have we received a packet with the ECN bit set in the current second?
        Returns:
        false always
      • getSendWindowBytes

        public int getSendWindowBytes()
        how many bytes should we send to the peer in a second
      • getSendWindowBytesRemaining

        public int getSendWindowBytesRemaining()
        how many bytes can we send to the peer in the current second
      • getRemoteIP

        public byte[] getRemoteIP()
        what IP is the peer sending and receiving packets on?
      • getRemoteIPAddress

        public InetAddress getRemoteIPAddress()
        Returns:
        may be null if IP is invalid
      • getRemotePort

        public int getRemotePort()
        what port is the peer sending and receiving packets on?
      • getWeRelayToThemAs

        public long getWeRelayToThemAs()
        if we are serving as an introducer to them, this is the the tag that they can publish that, when presented to us, will cause us to send a relay introduction to the current peer
        Returns:
        0 (no relay) if unset previously
      • getTheyRelayToUsAs

        public long getTheyRelayToUsAs()
        If they have offered to serve as an introducer to us, this is the tag we can use to publish that fact.
        Returns:
        0 (no relay) if unset previously
      • getMTU

        public int getMTU()
        what is the largest packet we can send to the peer?
      • getReceiveMTU

        public int getReceiveMTU()
        Estimate how large the other side's MTU is. This could be wrong. It is used only for the HTML status.
      • setCurrentMACKey

        public void setCurrentMACKey​(SessionKey key)
        The AES key used to verify packets, set only after the connection is established.
      • setCurrentCipherKey

        public void setCurrentCipherKey​(SessionKey key)
        The AES key used to encrypt/decrypt packets, set only after the connection is established.
      • setNextMACKey

        @Deprecated
        public void setNextMACKey​(SessionKey key)
        Deprecated.
        unused
        The pending AES key for verifying packets if we are rekeying the connection, or null if we are not in the process of rekeying.
      • setNextCipherKey

        @Deprecated
        public void setNextCipherKey​(SessionKey key)
        Deprecated.
        unused
        The pending AES key for encrypting/decrypting packets if we are rekeying the connection, or null if we are not in the process of rekeying.
      • setKeyEstablishedTime

        @Deprecated
        public void setKeyEstablishedTime​(long when)
        Deprecated.
        unused
        when were the current cipher and MAC keys established/rekeyed?
      • adjustClockSkew

        public void adjustClockSkew​(long skew)
        Update the moving-average clock skew based on the current difference. The raw skew will be adjusted for RTT/2 here. A positive number means our clock is ahead of theirs.
        Parameters:
        skew - milliseconds, NOT adjusted for RTT.
      • setCurrentReceiveSecond

        public void setCurrentReceiveSecond​(long sec)
        what is the current receive second, for congestion control?
      • setLastSendTime

        public void setLastSendTime​(long when)
        when did we last send them a packet?
      • setLastReceiveTime

        public void setLastReceiveTime​(long when)
        when did we last receive a packet from them?
      • setLastPingTime

        public void setLastPingTime​(long when)
        Note ping sent. Does not update last send time.
        Since:
        0.9.3
      • getLastSendOrPingTime

        public long getLastSendOrPingTime()
        Latest of last sent, last ACK, last ping
        Since:
        0.9.3
      • getSendBps

        public int getSendBps()
        return the smoothed send transfer rate
      • getReceiveBps

        public int getReceiveBps()
      • incrementConsecutiveFailedSends

        public int incrementConsecutiveFailedSends()
      • getInactivityTime

        public long getInactivityTime()
      • setWeRelayToThemAs

        public void setWeRelayToThemAs​(long tag)
        if we are serving as an introducer to them, this is the the tag that they can publish that, when presented to us, will cause us to send a relay introduction to the current peer
        Parameters:
        tag - 1 to Integer.MAX_VALUE, or 0 if relaying disabled
      • setTheyRelayToUsAs

        public void setTheyRelayToUsAs​(long tag)
        If they have offered to serve as an introducer to us, this is the tag we can use to publish that fact.
        Parameters:
        tag - 1 to Integer.MAX_VALUE, or 0 if relaying disabled
      • getSlowStartThreshold

        public int getSlowStartThreshold()
        public void setMTU(int mtu) { _mtu = mtu; _mtuLastChecked = _context.clock().now(); }
      • getConcurrentSends

        public int getConcurrentSends()
      • getConcurrentSendWindow

        public int getConcurrentSendWindow()
      • getConsecutiveSendRejections

        public int getConsecutiveSendRejections()
      • isInbound

        public boolean isInbound()
      • isIPv6

        public boolean isIPv6()
        Since:
        IPv6
      • getIntroducerTime

        public long getIntroducerTime()
        the last time we used them as an introducer, or 0
      • setIntroducerTime

        public void setIntroducerTime()
        set the last time we used them as an introducer to now
      • messageFullyReceived

        public void messageFullyReceived​(Long messageId,
                                         int bytes)
        We received the message specified completely.
        Parameters:
        bytes - if less than or equal to zero, message is a duplicate.
      • messagePartiallyReceived

        public void messagePartiallyReceived()
      • getInboundMessages

        public Map<Long,​InboundMessageState> getInboundMessages()
        Fetch the internal id (Long) to InboundMessageState for incomplete inbound messages. Access to this map must be synchronized explicitly!
      • expireInboundMessages

        public int expireInboundMessages()
        Expire partially received inbound messages, returning how many are still pending. This should probably be fired periodically, in case a peer goes silent and we don't try to send them any messages (and don't receive any messages from them either)
      • getCurrentFullACKs

        public List<Long> getCurrentFullACKs()
        Grab a list of message ids (Long) that we want to send to the remote peer, regardless of the packet size, but don't remove it from our "want to send" list. If the message id is transmitted to the peer, removeACKMessage(Long) should be called. The returned list contains acks not yet sent only. The caller should NOT transmit all of them all the time, even if there is room, or the packets will have way too much overhead.
        Returns:
        a new list, do as you like with it
      • getCurrentResendACKs

        public List<Long> getCurrentResendACKs()
        Grab a list of message ids (Long) that we want to send to the remote peer, regardless of the packet size, but don't remove it from our "want to send" list. The returned list contains a random assortment of acks already sent. The caller should NOT transmit all of them all the time, even if there is room, or the packets will have way too much overhead.
        Returns:
        a new list, do as you like with it
        Since:
        0.8.12 was included in getCurrentFullACKs()
      • removeACKMessage

        public void removeACKMessage​(Long messageId)
        The ack was sent. Side effect - sets _lastACKSend
      • retrieveACKBitfields

        @Deprecated
        public List<ACKBitfield> retrieveACKBitfields()
        Deprecated.
        unused
        grab a list of ACKBitfield instances, some of which may fully ACK a message while others may only partially ACK a message. the values returned are limited in size so that they will fit within the peer's current MTU as an ACK - as such, not all messages may be ACKed with this call. Be sure to check getWantedACKSendSince() which will be unchanged if there are ACKs remaining.
        Returns:
        non-null, possibly empty
      • retrieveACKBitfields

        public List<ACKBitfield> retrieveACKBitfields​(boolean alwaysIncludeRetransmissions)
        See above. Only called by ACKSender with alwaysIncludeRetransmissions = false. So this is only for ACK-only packets, so all the size limiting is useless. FIXME. Side effect - sets _lastACKSend if rv is non-empty
        Returns:
        non-null, possibly empty
      • fetchPartialACKs

        void fetchPartialACKs​(List<ACKBitfield> rv)
        Parameters:
        rv - out parameter, populated with true partial ACKBitfields. no full bitfields are included.
      • setHisMTU

        public void setHisMTU​(int mtu)
        Since:
        0.9.2
      • messageRetransmitted

        public void messageRetransmitted​(int packets)
        we are resending a packet, so lets jack up the rto
      • packetsTransmitted

        public void packetsTransmitted​(int packets)
      • getRTT

        public int getRTT()
        how long does it usually take to get a message ACKed?
      • getRTO

        public int getRTO()
        how soon should we retransmit an unacked packet?
      • getRTTDeviation

        public int getRTTDeviation()
        how skewed are the measured RTTs?
      • getMessagesSent

        public int getMessagesSent()
        I2NP messages sent. Does not include duplicates. As of 0.9.24, incremented when bandwidth is allocated just before sending, not when acked.
      • getMessagesReceived

        public int getMessagesReceived()
        I2NP messages received. As of 0.9.24, does not include duplicates.
      • getPacketsTransmitted

        public int getPacketsTransmitted()
      • getPacketsRetransmitted

        public int getPacketsRetransmitted()
      • getPacketsReceived

        public int getPacketsReceived()
        avg number of packets retransmitted for every 100 packets
      • getPacketsReceivedDuplicate

        public int getPacketsReceivedDuplicate()
      • packetReceived

        public void packetReceived​(int size)
        Parameters:
        size - not including IP header, UDP header, MAC or IV
      • ECNReceived

        public void ECNReceived()
        We received a backoff request, so cut our send window. NOTE: ECN sending is unimplemented, this is never called.
      • dataReceived

        public void dataReceived()
      • getLastACKSend

        public long getLastACKSend()
        when did we last send an ACK to the peer?
      • setLastACKSend

        @Deprecated
        public void setLastACKSend​(long when)
        Deprecated.
        unused
      • getWantedACKSendSince

        public long getWantedACKSendSince()
      • unsentACKThresholdReached

        public boolean unsentACKThresholdReached()
        Are we out of room to send all the current unsent acks in a single packet? This is a huge threshold (134 for small MTU and 255 for large MTU) that is rarely if ever exceeded in practice. So just use a fixed threshold of half the resend acks, so that if the packet is lost the acks have a decent chance of getting retransmitted. Used only by ACKSender.
      • getRemoteHostId

        RemoteHostId getRemoteHostId()
        Returns:
        non-null
      • add

        public void add​(OutboundMessageState state)
        TODO should this use a queue, separate from the list of msgs pending an ack? TODO bring back tail drop? TODO priority queue? (we don't implement priorities in SSU now) TODO backlog / pushback / block instead of dropping? Can't really block here. TODO SSU does not support isBacklogged() now
      • dropOutbound

        public void dropOutbound()
        drop all outbound messages
      • getOutboundMessageCount

        public int getOutboundMessageCount()
        Returns:
        number of active outbound messages remaining (unsynchronized)
      • setMayDisconnect

        public void setMayDisconnect()
        Sets to true.
        Since:
        0.9.24
      • getMayDisconnect

        public boolean getMayDisconnect()
        Since:
        0.9.24
      • finishMessages

        public int finishMessages​(long now)
        Expire / complete any outbound messages High usage - OutboundMessageFragments.getNextVolley() calls this 1st. TODO combine finishMessages(), allocateSend(), and getNextDelay() so we don't iterate 3 times.
        Returns:
        number of active outbound messages remaining
      • allocateSend

        public List<OutboundMessageState> allocateSend()
        Pick one or more messages we want to send and allocate them out of our window High usage - OutboundMessageFragments.getNextVolley() calls this 2nd, if finishMessages() returned > 0. TODO combine finishMessages(), allocateSend(), and getNextDelay() so we don't iterate 3 times.
        Returns:
        allocated messages to send (never empty), or null if no messages or no resources
      • getNextDelay

        public int getNextDelay()
        High usage - OutboundMessageFragments.getNextVolley() calls this 3rd, if allocateSend() returned null. TODO combine finishMessages(), allocateSend(), and getNextDelay() so we don't iterate 3 times.
        Returns:
        how long to wait before sending, or Integer.MAX_VALUE if we have nothing to send. If ready now, will return 0 or a negative value.
      • isBacklogged

        public boolean isBacklogged()
        Since:
        0.9.3
      • fragmentSize

        public int fragmentSize()
        how much payload data can we shove in there?
        Returns:
        MTU - 87, i.e. 533 or 1397 (IPv4), MTU - 107 (IPv6)
      • acked

        public boolean acked​(long messageId)
        A full ACK was received. TODO if messages awaiting ack were a HashMap<Long, OutboundMessageState> this would be faster.
        Returns:
        true if the message was acked for the first time
      • acked

        public boolean acked​(ACKBitfield bitfield)
        A partial ACK was received. This is much less common than full ACKs.
        Returns:
        true if the message was completely acked for the first time
      • loadFrom

        public void loadFrom​(PeerState oldPeer)
        Transfer the basic activity/state from the old peer to the current peer
        Parameters:
        oldPeer - non-null
      • getTransport

        public UDPTransport getTransport()
        Convenience for OutboundMessageState so it can fail itself
        Since:
        0.9.3