java.lang.Object
- net.i2p.router.transport.udp.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 Summary

Fields
Modifier and Type	Field	Description
`static 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.
`static int`	`MAX_IPV6_MTU`
`static int`	`MAX_MTU`	Max of IPv4 and IPv6 max MTUs
`static int`	`MIN_IPV6_MTU`	IPv6/UDP header is 48 bytes, so we want MTU % 16 == 0.
`static 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.
`(package private) static long`	`RETRANSMISSION_PERIOD_WIDTH`	how many packets will be considered within the retransmission rate calculation

Constructor Summary

Constructors
Constructor	Description
`PeerState(RouterContext ctx, UDPTransport transport, byte[] remoteIP, int remotePort, Hash remotePeer, boolean isInbound, int rtt)`

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method	Description
`(package private) boolean`	`acked(long messageId, InboundMessageFragments.ModifiableLong highestSeqNumAcked)`	A full ACK was received.
`(package private) boolean`	`acked(ACKBitfield bitfield, InboundMessageFragments.ModifiableLong highestSeqNumAcked)`	A partial ACK was received.
`(package private) 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.
`(package private) void`	`adjustClockSkew(long skew)`	Update the moving-average clock skew based on the current difference.
`(package private) List<OutboundMessageState>`	`allocateSend(long now)`	Pick one or more messages we want to send and allocate them out of our window Adjusts the retransmit timer if necessary.
`(package private) void`	`changePort(int newPort)`	Caller should sync; UDPTransport must remove and add to peersByRemoteHost map
`(package private) void`	`dataReceived()`
`(package private) void`	`dropOutbound()`	drop all outbound messages
`(package private) void`	`ECNReceived()`	We received a backoff request, so cut our send window.
`(package private) int`	`expireInboundMessages()`	Expire partially received inbound messages, returning how many are still pending.
`(package private) void`	`fetchPartialACKs(List<ACKBitfield> rv)`
`(package private) int`	`finishMessages(long now)`	Expire / complete any outbound messages High usage - OutboundMessageFragments.getNextVolley() calls this 1st.
`(package private) int`	`fragmentOverhead()`	Packet overhead plus room for acks
`(package private) int`	`fragmentSize()`	how much payload data can we shove in there?
`long`	`getClockSkew()`	How far off is the remote peer from our clock, in milliseconds? A positive number means our clock is ahead of theirs.
`int`	`getConcurrentSends()`	2nd stat in CWND column, otherwise unused, candidate for removal
`int`	`getConcurrentSendWindow()`	3rd stat in CWND column, otherwise unused, candidate for removal
`int`	`getConsecutiveFailedSends()`	how many seconds have we sent packets without any ACKs received?
`int`	`getConsecutiveSendRejections()`	4th stat in CWND column, otherwise unused, candidate for removal
`(package private) SessionKey`	`getCurrentCipherKey()`	The AES key used to encrypt/decrypt packets, set only after the connection is established.
`(package private) 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.
`(package private) SessionKey`	`getCurrentMACKey()`	The AES key used to verify packets, set only after the connection is established.
`(package private) 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.
`long`	`getInactivityTime()`
`(package private) Map<Long,InboundMessageState>`	`getInboundMessages()`	Fetch the internal id (Long) to InboundMessageState for incomplete inbound messages.
`(package private) long`	`getIntroducerTime()`	the last time we used them as an introducer, or 0
`long`	`getKeyEstablishedTime()`	when were the current cipher and MAC keys established/rekeyed?
`long`	`getLastACKSend()`	when did we last send an ACK to the peer?
`long`	`getLastReceiveTime()`	when did we last receive a packet from them?
`long`	`getLastSendFullyTime()`	when did we last send them a message that was ACKed?
`(package private) long`	`getLastSendOrPingTime()`	Latest of last sent, last ACK, last ping
`long`	`getLastSendTime()`	when did we last send them a packet?
`boolean`	`getMayDisconnect()`
`int`	`getMessagesReceived()`	I2NP messages received.
`int`	`getMessagesSent()`	I2NP messages sent.
`int`	`getMTU()`	what is the largest packet we can send to the peer?
`(package private) 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.
`(package private) int`	`getNextDelay(long now)`	High usage - OutboundMessageFragments.getNextVolley() calls this 3rd, if allocateSend() returned null.
`(package private) 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.
`int`	`getOutboundMessageCount()`
`int`	`getPacketsReceived()`
`int`	`getPacketsReceivedDuplicate()`
`int`	`getPacketsRetransmitted()`
`int`	`getPacketsTransmitted()`
`int`	`getReceiveBps()`	An approximation, for display only
`int`	`getReceiveMTU()`	Estimate how large the other side's MTU is.
`(package private) RemoteHostId`	`getRemoteHostId()`
`byte[]`	`getRemoteIP()`	what IP is the peer sending and receiving packets on?
`InetAddress`	`getRemoteIPAddress()`
`Hash`	`getRemotePeer()`	The peer are we talking to.
`int`	`getRemotePort()`	what port is the peer sending and receiving packets on?
`int`	`getRTO()`	how soon should we retransmit an unacked packet?
`int`	`getRTT()`	how long does it usually take to get a message ACKed?
`int`	`getRTTDeviation()`	how skewed are the measured RTTs?
`int`	`getSendBps()`	The Westwood+ bandwidth estimate
`int`	`getSendWindowBytes()`	how many bytes should we send to the peer in a second 1st stat in CWND column, otherwise unused, candidate for removal
`int`	`getSendWindowBytesRemaining()`	how many bytes can we send to the peer in the current second
`int`	`getSlowStartThreshold()`	stat in SST column, otherwise unused, candidate for removal
`long`	`getTheyRelayToUsAs()`	If they have offered to serve as an introducer to us, this is the tag we can use to publish that fact.
`(package private) UDPTransport`	`getTransport()`	Convenience for OutboundMessageState so it can fail itself
`long`	`getWantedACKSendSince()`
`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
`(package private) boolean`	`highestSeqNumAcked(long highest)`	Enter or leave fast retransmit mode, and adjust SST and window variables accordingly.
`(package private) int`	`incrementConsecutiveFailedSends()`
`boolean`	`isBacklogged()`
`boolean`	`isInbound()`
`boolean`	`isIPv6()`
`(package private) void`	`loadFrom(PeerState oldPeer)`	Transfer the basic activity/state from the old peer to the current peer
`(package private) void`	`messageFullyReceived(Long messageId, int bytes)`	We received the message specified completely.
`(package private) void`	`messagePartiallyReceived()`
`(package private) void`	`messageRetransmitted(int packets)`	we are resending a packet, so lets jack up the rto
`(package private) void`	`packetReceived(int size)`
`(package private) void`	`packetsTransmitted(int packets)`
`(package private) void`	`removeACKMessage(Long messageId)`	The ack was sent.
`(package private) List<ACKBitfield>`	`retrieveACKBitfields()`	Deprecated. unused
`(package private) List<ACKBitfield>`	`retrieveACKBitfields(boolean alwaysIncludeRetransmissions)`	See above.
`(package private) void`	`setCurrentCipherKey(SessionKey key)`	The AES key used to encrypt/decrypt packets, set only after the connection is established.
`(package private) void`	`setCurrentMACKey(SessionKey key)`	The AES key used to verify packets, set only after the connection is established.
`(package private) void`	`setHisMTU(int mtu)`
`(package private) void`	`setIntroducerTime()`	set the last time we used them as an introducer to now
`void`	`setLastACKSend(long when)`	Deprecated. unused
`(package private) void`	`setLastPingTime(long when)`	Note ping sent.
`(package private) void`	`setLastReceiveTime(long when)`	when did we last receive a packet from them?
`(package private) void`	`setLastSendTime(long when)`	when did we last send them a packet?
`void`	`setMayDisconnect()`	Sets to true.
`(package private) 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.
`(package private) 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
`String`	`toString()`
`(package private) 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.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- 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
  - MAX_IPV6_MTU
```
public static final int MAX_IPV6_MTU
```
    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,
                 int rtt)
```
    Parameters:
    
    rtt - from the EstablishState, or 0 if not available
- Method Detail
  - changePort
```
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
```
SessionKey getCurrentMACKey()
```
    The AES key used to verify packets, set only after the connection is established.
  - getCurrentCipherKey
```
SessionKey getCurrentCipherKey()
```
    The AES key used to encrypt/decrypt packets, set only after the connection is established.
  - getNextMACKey
```
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
```
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.
  - 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?
  - getSendWindowBytes
```
public int getSendWindowBytes()
```
    how many bytes should we send to the peer in a second 1st stat in CWND column, otherwise unused, candidate for removal
  - 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
```
void setCurrentMACKey(SessionKey key)
```
    The AES key used to verify packets, set only after the connection is established.
  - setCurrentCipherKey
```
void setCurrentCipherKey(SessionKey key)
```
    The AES key used to encrypt/decrypt packets, set only after the connection is established.
  - adjustClockSkew
```
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.
  - setLastSendTime
```
void setLastSendTime(long when)
```
    when did we last send them a packet?
  - setLastReceiveTime
```
void setLastReceiveTime(long when)
```
    when did we last receive a packet from them?
  - setLastPingTime
```
void setLastPingTime(long when)
```
    Note ping sent. Does not update last send time.
    
    Since:
    
    0.9.3
  - getLastSendOrPingTime
```
long getLastSendOrPingTime()
```
    Latest of last sent, last ACK, last ping
    
    Since:
    
    0.9.3
  - getSendBps
```
public int getSendBps()
```
    The Westwood+ bandwidth estimate
    
    Returns:
    
    the smoothed send transfer rate
  - getReceiveBps
```
public int getReceiveBps()
```
    An approximation, for display only
    
    Returns:
    
    the smoothed receive transfer rate
  - incrementConsecutiveFailedSends
```
int incrementConsecutiveFailedSends()
```
  - getInactivityTime
```
public long getInactivityTime()
```
  - setWeRelayToThemAs
```
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
```
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()
```
    stat in SST column, otherwise unused, candidate for removal
  - getConcurrentSends
```
public int getConcurrentSends()
```
    2nd stat in CWND column, otherwise unused, candidate for removal
  - getConcurrentSendWindow
```
public int getConcurrentSendWindow()
```
    3rd stat in CWND column, otherwise unused, candidate for removal
  - getConsecutiveSendRejections
```
public int getConsecutiveSendRejections()
```
    4th stat in CWND column, otherwise unused, candidate for removal
  - isInbound
```
public boolean isInbound()
```
  - isIPv6
```
public boolean isIPv6()
```
    Since:
    
    IPv6
  - getIntroducerTime
```
long getIntroducerTime()
```
    the last time we used them as an introducer, or 0
  - setIntroducerTime
```
void setIntroducerTime()
```
    set the last time we used them as an introducer to now
  - messageFullyReceived
```
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
```
void messagePartiallyReceived()
```
  - getInboundMessages
```
Map<Long,InboundMessageState> getInboundMessages()
```
    Fetch the internal id (Long) to InboundMessageState for incomplete inbound messages. Access to this map must be synchronized explicitly!
  - expireInboundMessages
```
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
```
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
```
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
```
void removeACKMessage(Long messageId)
```
    The ack was sent. Side effect - sets _lastACKSend
  - retrieveACKBitfields
```
@Deprecated
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
```
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
```
void setHisMTU(int mtu)
```
    Since:
    
    0.9.2
  - messageRetransmitted
```
void messageRetransmitted(int packets)
```
    we are resending a packet, so lets jack up the rto
  - packetsTransmitted
```
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()
```
  - getPacketsReceivedDuplicate
```
public int getPacketsReceivedDuplicate()
```
  - packetReceived
```
void packetReceived(int size)
```
    Parameters:
    
    size - not including IP header, UDP header, MAC or IV
  - ECNReceived
```
void ECNReceived()
```
    We received a backoff request, so cut our send window. NOTE: ECN sending is unimplemented, this is never called.
  - dataReceived
```
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
```
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
```
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
```
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
```
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
```
List<OutboundMessageState> allocateSend(long now)
```
    Pick one or more messages we want to send and allocate them out of our window Adjusts the retransmit timer if necessary. High usage - OutboundMessageFragments.getNextVolley() calls this 2nd, if finishMessages() returned > 0. TODO combine finishMessages() and allocateSend() so we don't iterate 2 times.
    
    Returns:
    
    allocated messages to send (never empty), or null if no messages or no resources
  - getNextDelay
```
int getNextDelay(long now)
```
    High usage - OutboundMessageFragments.getNextVolley() calls this 3rd, if allocateSend() returned null. TODO combine finishMessages(), allocateSend() so we don't iterate 2 times.
    
    Parameters:
    
    now - what time it is now
    
    Returns:
    
    how long to wait before sending, or Integer.MAX_VALUE if we have nothing to send. If ready now, will return 0.
  - isBacklogged
```
public boolean isBacklogged()
```
    Since:
    
    0.9.3
  - fragmentSize
```
int fragmentSize()
```
    how much payload data can we shove in there?
    
    Returns:
    
    MTU - 87, i.e. 533 or 1397 (IPv4), MTU - 107 (IPv6)
  - fragmentOverhead
```
int fragmentOverhead()
```
    Packet overhead plus room for acks
    
    Returns:
    
    87 (IPv4), 107 (IPv6)
    
    Since:
    
    0.9.49
  - acked
```
boolean acked(long messageId,
              InboundMessageFragments.ModifiableLong highestSeqNumAcked)
```
    A full ACK was received. TODO if messages awaiting ack were a HashMap<Long, OutboundMessageState> this would be faster.
    
    Parameters:
    
    highestSeqNumAcked - in/out param, will modify if this seq. number is higher
    
    Returns:
    
    true if the message was acked for the first time
  - acked
```
boolean acked(ACKBitfield bitfield,
              InboundMessageFragments.ModifiableLong highestSeqNumAcked)
```
    A partial ACK was received. This is much less common than full ACKs.
    
    Parameters:
    
    highestSeqNumAcked - in/out param, will modify if this seq. number is higher
    
    Returns:
    
    true if any fragment of the message was completely acked for the first time
  - highestSeqNumAcked
```
boolean highestSeqNumAcked(long highest)
```
    Enter or leave fast retransmit mode, and adjust SST and window variables accordingly. See RFC 5681 sec. 2.4
    
    Parameters:
    
    highest - the highest sequence number that was acked
    
    Returns:
    
    true if we have something to fast-retransmit
    
    Since:
    
    0.9.49
  - loadFrom
```
void loadFrom(PeerState oldPeer)
```
    Transfer the basic activity/state from the old peer to the current peer
    
    Parameters:
    
    oldPeer - non-null
  - getTransport
```
UDPTransport getTransport()
```
    Convenience for OutboundMessageState so it can fail itself
    
    Since:
    
    0.9.3
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object

Class PeerState

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

RETRANSMISSION_PERIOD_WIDTH

MIN_MTU

MIN_IPV6_MTU

MAX_IPV6_MTU

LARGE_MTU

MAX_MTU

Constructor Detail

PeerState

Method Detail

changePort

getRemotePeer

getCurrentMACKey

getCurrentCipherKey

getNextMACKey

getNextCipherKey

getKeyEstablishedTime

getClockSkew

getLastSendTime

getLastSendFullyTime

getLastReceiveTime

getConsecutiveFailedSends

getSendWindowBytes

getSendWindowBytesRemaining

getRemoteIP

getRemoteIPAddress

getRemotePort

getWeRelayToThemAs

getTheyRelayToUsAs

getMTU

getReceiveMTU

setCurrentMACKey

setCurrentCipherKey

adjustClockSkew

setLastSendTime

setLastReceiveTime

setLastPingTime

getLastSendOrPingTime

getSendBps

getReceiveBps

incrementConsecutiveFailedSends

getInactivityTime

setWeRelayToThemAs

setTheyRelayToUsAs

getSlowStartThreshold

getConcurrentSends

getConcurrentSendWindow

getConsecutiveSendRejections

isInbound

isIPv6

getIntroducerTime

setIntroducerTime

messageFullyReceived

messagePartiallyReceived

getInboundMessages

expireInboundMessages

getCurrentFullACKs

getCurrentResendACKs

removeACKMessage

retrieveACKBitfields

retrieveACKBitfields

fetchPartialACKs

setHisMTU

messageRetransmitted

packetsTransmitted

getRTT

getRTO

getRTTDeviation

getMessagesSent

getMessagesReceived

getPacketsTransmitted

getPacketsRetransmitted

getPacketsReceived

getPacketsReceivedDuplicate

packetReceived