PeerState (Javadocs [I2P+ 2.13.0+] - API Version 0.9.70+)

java.lang.Object
- net.i2p.router.transport.udp.PeerState

Direct Known Subclasses:
PeerState2
```
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 and Description
`protected RouterContext`	`_context` The router context.
`protected boolean`	`_dead` Have we migrated away from this peer to another newer one?
`protected Object`	`_inboundLock` Lock for inbound operations
`protected ConcurrentMap<Long,InboundMessageState>`	`_inboundMessages` list of InboundMessageState for active message
`protected boolean`	`_isInbound` Is it inbound?
`protected long`	`_keyEstablishedTime` the key establishment time
`protected long`	`_lastACKSend` When did we last send ACKs to the peer?
`protected Log`	`_log` The log.
`protected int`	`_mtu` What is the largest packet we can currently send to the peer?
`protected int`	`_packetsReceivedDuplicate` How many duplicate packets were received within the last RETRANSMISSION_PERIOD_WIDTH packets.
`protected RemoteHostId`	`_remoteHostId` cached RemoteHostId, used to find the peerState by remote info
`protected byte[]`	`_remoteIP` what IP is the peer sending and receiving packets on?
`protected InetAddress`	`_remoteIPAddress` cached IP address
`protected Hash`	`_remotePeer` The peer are we talking to.
`protected int`	`_remotePort` what port is the peer sending and receiving packets on?
`protected int`	`_rtt` Current round trip time estimate.
`protected UDPTransport`	`_transport` The UDP transport.
`protected long`	`_wantACKSendSince` When did we decide we need to ACK to this peer?
`static int`	`DEFAULT_MTU` Default MTU
`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` the maximum 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
Modifier Constructor and Description
protected PeerState(RouterContext ctx, UDPTransport transport, InetSocketAddress addr, Hash remotePeer, boolean isInbound, int rtt)
For SSU2

Constructors
Modifier	Constructor and Description
`protected`	`PeerState(RouterContext ctx, UDPTransport transport, InetSocketAddress addr, Hash remotePeer, boolean isInbound, int rtt)` For SSU2

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected boolean`	`acked(PacketBuilder.Fragment f)` An ACK of a fragment was received.
`(package private) void`	`add(OutboundMessageState state)` Add an outbound message state to the queue.
`(package private) void`	`adjustClockSkew(long skew)` Update the moving-average clock skew based on the current difference.
`(package private) void`	`changePort(int newPort)` Change the remote port.
`(package private) void`	`clearWantedACKSendSince()` All acks have been sent - SSU 1 only, see override
`(package private) void`	`dataReceived()` Same as setLastReceivedTime(now)
`(package private) void`	`dropOutbound()` drop all outbound messages
`(package private) void`	`ECNReceived()` Cut our send window as a congestion/backoff response.
`(package private) int`	`expireInboundMessages()` Expire partially received inbound messages, returning how many are still pending.
`(package private) List<OutboundMessageState>`	`finishAndAllocate(long now)` Replaces the two-pass pattern of finishMessages() + allocateSend() with a single pass through _outboundMessages.
`(package private) int`	`fragmentOverhead()` Packet overhead plus room for acks
`(package private) int`	`fragmentSize()` how much payload data can we shove in there?
`static int`	`getAckFrequency()` Current ACK frequency.
`static long[]`	`getAggregateStats(Collection<PeerState> peers)` Compute aggregate transport stats across all peers for tuner visibility.
`long`	`getClockSkew()` clock skew.
`static int`	`getClockSkewFudge()` clock skew fudge factor.
`int`	`getConcurrentSends()` Concurrent sends count.
`int`	`getConcurrentSendWindow()` Concurrent send window.
`int`	`getConsecutiveFailedSends()` Consecutive failed sends count.
`int`	`getConsecutiveSendRejections()` Consecutive send rejections count.
`long`	`getInactivityTime()` Inactivity time.
`(package private) Map<Long,InboundMessageState>`	`getInboundMessages()` Fetch the internal id (Long) to InboundMessageState for incomplete inbound messages.
`static int`	`getInitConcurrentMsgs()` initial concurrent messages per peer.
`static int`	`getInitRTO()` initial RTO for new peers.
`(package private) long`	`getIntroducerTime()` Last introducer time.
`long`	`getKeyEstablishedTime()` when the cipher and MAC keys were established.
`long`	`getLastACKSend()` when we last sent an ACK.
`long`	`getLastReceiveTime()` Last receive time.
`long`	`getLastSendFullyTime()` Last send fully time.
`(package private) long`	`getLastSendOrPingTime()` latest of last sent, last ACK, last ping.
`long`	`getLastSendTime()` Last send time.
`static int`	`getMaxConcurrentMessages()` Max concurrent messages per peer.
`static int`	`getMaxRTO()` maximum RTO ceiling.
`static int`	`getMaxSendWindow()` max send window (CWIN).
`boolean`	`getMayDisconnect()` whether we may disconnect.
`int`	`getMessagesReceived()` I2NP messages received.
`int`	`getMessagesSent()` I2NP messages sent - does not include duplicates.
`static int`	`getMinConcurrentMsgs()` minimum concurrent messages per peer.
`static int`	`getMinRTO()` minimum RTO floor.
`int`	`getMTU()` Maximum transmission unit.
`(package private) int`	`getNextDelay(long now)` Uses cached oldest lifetime from the most recent finishAndAllocate() pass.
`int`	`getOutboundMessageCount()` Outbound message count.
`static long`	`getOutboundMsgExpiration()` Bridge to OutboundMessageState.getMessageExpiration for Tuner (different package).
`int`	`getPacketsReceived()` Packets received count.
`int`	`getPacketsReceivedDuplicate()` Packets received duplicate count.
`int`	`getPacketsRetransmitted()` Packets retransmitted count.
`int`	`getPacketsTransmitted()` Packets transmitted count.
`static int`	`getPostRTOWindowMTUs()` post-RTO-collapse window restart size.
`int`	`getReceiveBps(long now)` receive Bps estimate.
`int`	`getReceiveMTU()` receive MTU estimate.
`RemoteHostId`	`getRemoteHostId()` remote host ID.
`byte[]`	`getRemoteIP()` Remote IP address bytes.
`InetAddress`	`getRemoteIPAddress()` cached remote IP address.
`Hash`	`getRemotePeer()` remote peer hash.
`int`	`getRemotePort()` Remote port.
`int`	`getRTO()` retransmission timeout.
`int`	`getRTT()` round trip time.
`int`	`getRTTDeviation()` RTT deviation.
`int`	`getSendBps(long now)` The Westwood+ bandwidth estimate
`int`	`getSendWindowBytes()` send window bytes.
`int`	`getSendWindowBytesRemaining()` Send window bytes remaining.
`static long`	`getSentMessagesCleanTime()` Bridge to PeerState2.sentMessagesCleanTime for Tuner (different package).
`int`	`getSlowStartThreshold()` Slow start threshold.
`long`	`getTheyRelayToUsAs()` tag they relay to us as.
`(package private) UDPTransport`	`getTransport()` Convenience for OutboundMessageState so it can fail itself
`int`	`getVersion()` peer SSU version.
`long`	`getWeRelayToThemAs()` tag we relay to them as.
`(package private) boolean`	`hasOutbound()` After a finishAndAllocate() pass, reports whether any outbound messages remain.
`(package private) boolean`	`highestSeqNumAcked(long highest)` Enter or leave fast retransmit mode, and adjust SST and window variables accordingly.
`(package private) int`	`incrementConsecutiveFailedSends()` Increment consecutive failed sends.
`boolean`	`isBacklogged()`
`boolean`	`isInbound()` Whether this is an inbound connection.
`boolean`	`isIPv6()` Whether the connection uses IPv6.
`static void`	`loadConfig(RouterContext ctx)` Load configurable UDP transport parameters from router.config.
`(package private) void`	`loadFrom(PeerState oldPeer)` Transfer the basic activity/state from the old peer to the current peer SSU 1 or 2.
`(package private) void`	`messageFullyReceived(Long messageId, int bytes)` We received the message specified completely.
`(package private) void`	`messagePartiallyReceived()` We received a partial message, or we want to send some acks.
`protected void`	`messagePartiallyReceived(long now)` We received a partial message, or we want to send some acks.
`(package private) void`	`messageRetransmitted(int packets, int maxPktSz)` Handle a message retransmission.
`(package private) void`	`packetReceived(int size)` Record a received packet.
`(package private) void`	`packetsTransmitted(int packets)` Record that packets were transmitted.
`static void`	`setAckFrequency(int freq)` ACK frequency.
`(package private) void`	`setHisMTU(int mtu)` Remote peer's MTU.
`static void`	`setInitConcurrentMsgs(int msgs)` Initial concurrent messages per peer (called by Tuner).
`static void`	`setInitRTO(int ms)` Initial RTO for new peers (called by Tuner).
`(package private) void`	`setIntroducerTime()` Record the last time we used them as an introducer.
`(package private) void`	`setLastPingTime(long when)` Last ping time.
`(package private) void`	`setLastReceiveTime(long when)` Last receive time.
`(package private) void`	`setLastSendTime(long when)` Last send time.
`static void`	`setMaxConcurrentMessages(int max)` Max concurrent messages per peer (called by Tuner).
`static void`	`setMaxRTO(int ms)` Maximum RTO ceiling (called by Tuner).
`static void`	`setMaxSendWindow(int bytes)` Max send window / CWIN (called by Tuner).
`void`	`setMayDisconnect()` May disconnect to true.
`static void`	`setMinConcurrentMsgs(int msgs)` Minimum concurrent messages per peer (called by Tuner).
`static void`	`setMinRTO(int ms)` Minimum RTO floor (called by Tuner).
`static void`	`setOutboundMsgExpiration(long ms)` Bridge to OutboundMessageState.setMessageExpiration for Tuner (different package).
`static void`	`setPostRTOWindowMTUs(int mtus)` Send-window restart size after an RTO-timeout collapse (called by Tuner).
`static void`	`setSentMessagesCleanTime(long ms)` Bridge to PeerState2.setSentMessagesCleanTime for Tuner (different package).
`(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
`protected boolean`	`shouldRequestImmediateAck()` SSU 2 only
`String`	`toString()` String representation.

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

- Field Detail
  - _context
```
protected final RouterContext _context
```
    The router context.
  - _dead
```
protected volatile boolean _dead
```
    Have we migrated away from this peer to another newer one?
  - _inboundLock
```
protected final Object _inboundLock
```
    Lock for inbound operations
  - _inboundMessages
```
protected final ConcurrentMap<Long,InboundMessageState> _inboundMessages
```
    list of InboundMessageState for active message
  - _isInbound
```
protected final boolean _isInbound
```
    Is it inbound?
  - _keyEstablishedTime
```
protected final long _keyEstablishedTime
```
    the key establishment time
  - _lastACKSend
```
protected volatile long _lastACKSend
```
    When did we last send ACKs to the peer?
  - _log
```
protected final Log _log
```
    The log.
  - _mtu
```
protected volatile int _mtu
```
    What is the largest packet we can currently send to the peer?
  - _packetsReceivedDuplicate
```
protected volatile int _packetsReceivedDuplicate
```
    How many duplicate packets were received within the last RETRANSMISSION_PERIOD_WIDTH packets.
  - _remoteHostId
```
protected volatile RemoteHostId _remoteHostId
```
    cached RemoteHostId, used to find the peerState by remote info
  - _remoteIP
```
protected final byte[] _remoteIP
```
    what IP is the peer sending and receiving packets on?
  - _remoteIPAddress
```
protected volatile InetAddress _remoteIPAddress
```
    cached IP address
  - _remotePeer
```
protected final Hash _remotePeer
```
    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.
  - _remotePort
```
protected volatile int _remotePort
```
    what port is the peer sending and receiving packets on?
  - _rtt
```
protected volatile int _rtt
```
    Current round trip time estimate.
  - _transport
```
protected final UDPTransport _transport
```
    The UDP transport.
  - _wantACKSendSince
```
protected volatile long _wantACKSendSince
```
    When did we decide we need to ACK to this peer?
  - DEFAULT_MTU
```
public static final int DEFAULT_MTU
```
    Default 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_IPV6_MTU
```
public static final int MAX_IPV6_MTU
```
    the maximum IPv6 MTU
    See Also:
    Constant Field Values
  - MAX_MTU
```
public static final int MAX_MTU
```
    Max of IPv4 and IPv6 max MTUs
  - 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
  - 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
  - RETRANSMISSION_PERIOD_WIDTH
```
static final long RETRANSMISSION_PERIOD_WIDTH
```
    how many packets will be considered within the retransmission rate calculation
- Constructor Detail
  - PeerState
```
protected PeerState(RouterContext ctx,
                    UDPTransport transport,
                    InetSocketAddress addr,
                    Hash remotePeer,
                    boolean isInbound,
                    int rtt)
```
    For SSU2
- Method Detail
  - acked
```
protected boolean acked(PacketBuilder.Fragment f)
```
    An ACK of a fragment was received. SSU 2 only.
    Returns:
    true if this fragment of the message was acked for the first time
  - add
```
void add(OutboundMessageState state)
```
    Add an outbound message state to the queue.
    Parameters:
    state - the outbound message state to add
  - 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.
  - changePort
```
void changePort(int newPort)
```
    Change the remote port. Caller should sync; UDPTransport must remove and add to peersByRemoteHost map
    Parameters:
    newPort - the new port number
  - clearWantedACKSendSince
```
void clearWantedACKSendSince()
```
    All acks have been sent - SSU 1 only, see override
  - dataReceived
```
void dataReceived()
```
    Same as setLastReceivedTime(now)
  - dropOutbound
```
void dropOutbound()
```
    drop all outbound messages
  - ECNReceived
```
void ECNReceived()
```
    Cut our send window as a congestion/backoff response. Called during SSU2 connection migration (limitSending) to throttle the peer while the path is unverified. Despite the name, explicit ECN signalling is not implemented; this is the backoff hook.
  - 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)
  - finishAndAllocate
```
List<OutboundMessageState> finishAndAllocate(long now)
```
    Replaces the two-pass pattern of finishMessages() + allocateSend() with a single pass through _outboundMessages. Cleans up completed/expired messages and selects messages to send in one iteration. Sets _cachedOutboundCount for hasOutbound() and _cachedOldestLifetime for getNextDelay(). Does NOT scan _outboundQueue for oldest start time — the _outboundMessages iteration is sufficient for the delay heuristic, avoiding per-volley PriorityBlockingQueue iterator allocation.
    Parameters:
    now - current time
    Returns:
    messages to send, or null if none ready
  - fragmentOverhead
```
int fragmentOverhead()
```
    Packet overhead plus room for acks
    Returns:
    87 (IPv4), 107 (IPv6)
  - fragmentSize
```
int fragmentSize()
```
    how much payload data can we shove in there?
    Returns:
    MTU - 87, i.e. 533 or 1397 (IPv4), MTU - 107 (IPv6)
  - getAckFrequency
```
public static int getAckFrequency()
```
    Current ACK frequency.
    Returns:
    current ACK frequency
  - getAggregateStats
```
public static long[] getAggregateStats(Collection<PeerState> peers)
```
    Compute aggregate transport stats across all peers for tuner visibility. Called periodically from OutboundMessageFragments.
    Parameters:
    peers - collection of active peer states
    Returns:
    array: [avgSendWindow, avgRTO, avgConcurrentMsgs] or null if no peers
  - getClockSkew
```
public long getClockSkew()
```
    clock skew. How far off is the remote peer from our clock, in milliseconds? A positive number means our clock is ahead of theirs.
    Returns:
    the clock skew in ms
  - getClockSkewFudge
```
public static int getClockSkewFudge()
```
    clock skew fudge factor.
    Returns:
    clock skew fudge derived from current ACK frequency
  - getConcurrentSends
```
public int getConcurrentSends()
```
    Concurrent sends count. 2nd stat in CWND column, otherwise unused - candidate for removal
    Returns:
    the concurrent sends count
  - getConcurrentSendWindow
```
public int getConcurrentSendWindow()
```
    Concurrent send window. 3rd stat in CWND column, otherwise unused, candidate for removal
    Returns:
    the concurrent send window
  - getConsecutiveFailedSends
```
public int getConsecutiveFailedSends()
```
    Consecutive failed sends count.
  - getConsecutiveSendRejections
```
public int getConsecutiveSendRejections()
```
    Consecutive send rejections count. 4th stat in CWND column, otherwise unused - candidate for removal
    Returns:
    the consecutive send rejections count
  - getInactivityTime
```
public long getInactivityTime()
```
    Inactivity time.
    Returns:
    the inactivity time
  - getInboundMessages
```
Map<Long,InboundMessageState> getInboundMessages()
```
    Fetch the internal id (Long) to InboundMessageState for incomplete inbound messages. Access to this map must be synchronized explicitly!
    Returns:
    a map of message IDs to inbound message states
  - getInitConcurrentMsgs
```
public static int getInitConcurrentMsgs()
```
    initial concurrent messages per peer.
    Returns:
    the initial concurrent messages per peer
  - getInitRTO
```
public static int getInitRTO()
```
    initial RTO for new peers.
    Returns:
    the initial RTO for new peers in ms
  - getIntroducerTime
```
long getIntroducerTime()
```
    Last introducer time.
    Returns:
    the last time we used them as an introducer, or 0
  - getKeyEstablishedTime
```
public long getKeyEstablishedTime()
```
    when the cipher and MAC keys were established. When were the current cipher and MAC keys established/rekeyed? This is the connection uptime.
    Returns:
    the key establishment time
  - getLastACKSend
```
public long getLastACKSend()
```
    when we last sent an ACK.
    Returns:
    the last ACK send time
  - getLastReceiveTime
```
public long getLastReceiveTime()
```
    Last receive time. When did we last receive a packet from them? Updated for data, relay, and peer test, but not acks, pings, or termination
    Returns:
    the last receive time
  - getLastSendFullyTime
```
public long getLastSendFullyTime()
```
    Last send fully time.
  - getLastSendOrPingTime
```
long getLastSendOrPingTime()
```
    latest of last sent, last ACK, last ping.
    Returns:
    the latest time
  - getLastSendTime
```
public long getLastSendTime()
```
    Last send time. When did we last send them a packet? Updated for data, relay, and peer test, but not acks, pings, or termination
    Returns:
    the last send time
  - getMaxConcurrentMessages
```
public static int getMaxConcurrentMessages()
```
    Max concurrent messages per peer.
    Returns:
    the current max concurrent messages per peer
  - getMaxRTO
```
public static int getMaxRTO()
```
    maximum RTO ceiling.
    Returns:
    the maximum RTO ceiling in ms
  - getMaxSendWindow
```
public static int getMaxSendWindow()
```
    max send window (CWIN).
    Returns:
    the max send window (CWIN) in bytes
  - getMayDisconnect
```
public boolean getMayDisconnect()
```
    whether we may disconnect.
    Returns:
    true if we may disconnect
  - getMessagesReceived
```
public int getMessagesReceived()
```
    I2NP messages received. As of 0.9.24, does not include duplicates.
    Returns:
    the messages received count
  - 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.
    Returns:
    the messages sent count
  - getMinConcurrentMsgs
```
public static int getMinConcurrentMsgs()
```
    minimum concurrent messages per peer.
    Returns:
    the minimum concurrent messages per peer
  - getMinRTO
```
public static int getMinRTO()
```
    minimum RTO floor.
    Returns:
    the minimum RTO floor in ms
  - getMTU
```
public int getMTU()
```
    Maximum transmission unit.
  - getNextDelay
```
int getNextDelay(long now)
```
    Uses cached oldest lifetime from the most recent finishAndAllocate() pass.
    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.
  - getOutboundMessageCount
```
public int getOutboundMessageCount()
```
    Outbound message count.
    Returns:
    number of active outbound messages remaining (unsynchronized)
  - getOutboundMsgExpiration
```
public static long getOutboundMsgExpiration()
```
    Bridge to OutboundMessageState.getMessageExpiration for Tuner (different package).
    Returns:
    the outbound message expiration
  - getPacketsReceived
```
public int getPacketsReceived()
```
    Packets received count.
  - getPacketsReceivedDuplicate
```
public int getPacketsReceivedDuplicate()
```
    Packets received duplicate count.
  - getPacketsRetransmitted
```
public int getPacketsRetransmitted()
```
    Packets retransmitted count.
  - getPacketsTransmitted
```
public int getPacketsTransmitted()
```
    Packets transmitted count.
  - getPostRTOWindowMTUs
```
public static int getPostRTOWindowMTUs()
```
    post-RTO-collapse window restart size.
    Returns:
    the post-RTO-collapse window restart size, in MTUs
  - getReceiveBps
```
public int getReceiveBps(long now)
```
    receive Bps estimate. An approximation, for display only
    Parameters:
    now - the current time
    Returns:
    the smoothed receive transfer rate
  - getReceiveMTU
```
public int getReceiveMTU()
```
    receive MTU estimate. Estimate how large the other side's MTU is. This could be wrong. It is used only for the HTML status.
    Returns:
    the receive m t u
  - getRemoteHostId
```
public RemoteHostId getRemoteHostId()
```
    remote host ID.
    Returns:
    non-null
  - getRemoteIP
```
public byte[] getRemoteIP()
```
    Remote IP address bytes.
  - getRemoteIPAddress
```
public InetAddress getRemoteIPAddress()
```
    cached remote IP address.
    Returns:
    may be null if IP is invalid
  - getRemotePeer
```
public Hash getRemotePeer()
```
    remote peer hash. The peer are we talking to. Non-null.
    Returns:
    the remote peer hash
  - getRemotePort
```
public int getRemotePort()
```
    Remote port.
  - getRTO
```
public int getRTO()
```
    retransmission timeout.
    Returns:
    the RTO in ms
  - getRTT
```
public int getRTT()
```
    round trip time.
    Returns:
    the RTT in ms
  - getRTTDeviation
```
public int getRTTDeviation()
```
    RTT deviation.
    Returns:
    the RTT deviation in ms
  - getSendBps
```
public int getSendBps(long now)
```
    The Westwood+ bandwidth estimate
    Parameters:
    now - the current time
    Returns:
    the smoothed send transfer rate
  - getSendWindowBytes
```
public int getSendWindowBytes()
```
    send window bytes. how many bytes should we send to the peer in a second 1st stat in CWND column, otherwise unused, candidate for removal
    Returns:
    the send window bytes
  - getSendWindowBytesRemaining
```
public int getSendWindowBytesRemaining()
```
    Send window bytes remaining.
  - getSentMessagesCleanTime
```
public static long getSentMessagesCleanTime()
```
    Bridge to PeerState2.sentMessagesCleanTime for Tuner (different package).
    Returns:
    the sent messages clean time
  - getSlowStartThreshold
```
public int getSlowStartThreshold()
```
    Slow start threshold. Stat in SST column, otherwise unused - candidate for removal
    Returns:
    the slow start threshold
  - getTheyRelayToUsAs
```
public long getTheyRelayToUsAs()
```
    tag they relay to us as. 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
  - getTransport
```
UDPTransport getTransport()
```
    Convenience for OutboundMessageState so it can fail itself
  - getVersion
```
public int getVersion()
```
    peer SSU version.
    Returns:
    the version number (1 for SSU1)
  - getWeRelayToThemAs
```
public long getWeRelayToThemAs()
```
    tag we relay to them as. 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
  - hasOutbound
```
boolean hasOutbound()
```
    After a finishAndAllocate() pass, reports whether any outbound messages remain.
    Returns:
    true if there are pending outbound messages
  - 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
  - incrementConsecutiveFailedSends
```
int incrementConsecutiveFailedSends()
```
    Increment consecutive failed sends.
  - isBacklogged
```
public boolean isBacklogged()
```
    Returns:
    whether backlogged
  - isInbound
```
public boolean isInbound()
```
    Whether this is an inbound connection.
  - isIPv6
```
public boolean isIPv6()
```
    Whether the connection uses IPv6.
    Returns:
    whether the peer is using IPv6
  - loadConfig
```
public static void loadConfig(RouterContext ctx)
```
    Load configurable UDP transport parameters from router.config. Called once during UDPTransport initialization.
    Parameters:
    ctx - router context for property access
  - loadFrom
```
void loadFrom(PeerState oldPeer)
```
    Transfer the basic activity/state from the old peer to the current peer SSU 1 or 2.
    Parameters:
    oldPeer - non-null
  - messageFullyReceived
```
void messageFullyReceived(Long messageId,
                          int bytes)
```
    We received the message specified completely.
    Parameters:
    messageId - the message ID
    bytes - if less than or equal to zero, message is a duplicate.
  - messagePartiallyReceived
```
void messagePartiallyReceived()
```
    We received a partial message, or we want to send some acks.
  - messagePartiallyReceived
```
protected void messagePartiallyReceived(long now)
```
    We received a partial message, or we want to send some acks.
    Parameters:
    now - the current time
  - messageRetransmitted
```
void messageRetransmitted(int packets,
                          int maxPktSz)
```
    Handle a message retransmission.
    Parameters:
    packets - the number of packets retransmitted
    maxPktSz - the maximum packet size
  - packetReceived
```
void packetReceived(int size)
```
    Record a received packet.
    Parameters:
    size - not including IP header, UDP header, MAC or IV
  - packetsTransmitted
```
void packetsTransmitted(int packets)
```
    Record that packets were transmitted.
  - setAckFrequency
```
public static void setAckFrequency(int freq)
```
    ACK frequency.
    Parameters:
    freq - new ACK frequency (bounded 50-300)
  - setHisMTU
```
void setHisMTU(int mtu)
```
    Remote peer's MTU.
    Parameters:
    mtu - the MTU to set
  - setInitConcurrentMsgs
```
public static void setInitConcurrentMsgs(int msgs)
```
    Initial concurrent messages per peer (called by Tuner).
    Parameters:
    msgs - initial concurrent messages, clamped 16-256
  - setInitRTO
```
public static void setInitRTO(int ms)
```
    Initial RTO for new peers (called by Tuner).
    Parameters:
    ms - initial RTO in ms, clamped 250-2000
  - setIntroducerTime
```
void setIntroducerTime()
```
    Record the last time we used them as an introducer.
  - setLastPingTime
```
void setLastPingTime(long when)
```
    Last ping time. Note ping sent. Does not update last send time.
    Parameters:
    when - the time to set
  - setLastReceiveTime
```
void setLastReceiveTime(long when)
```
    Last receive time. When did we last receive a packet from them? Updated for data, relay, and peer test, but not acks, pings, or termination
    Parameters:
    when - the time to set
  - setLastSendTime
```
void setLastSendTime(long when)
```
    Last send time. When did we last send them a packet? Updated for data, relay, and peer test, but not acks, pings, or termination
    Parameters:
    when - the time to set
  - setMaxConcurrentMessages
```
public static void setMaxConcurrentMessages(int max)
```
    Max concurrent messages per peer (called by Tuner). Scales with available RAM: ~1/8 of RAM in MB, clamped 256-4096.
    Parameters:
    max - the max concurrent messages to set
  - setMaxRTO
```
public static void setMaxRTO(int ms)
```
    Maximum RTO ceiling (called by Tuner).
    Parameters:
    ms - maximum RTO in ms, clamped 10000-120000
  - setMaxSendWindow
```
public static void setMaxSendWindow(int bytes)
```
    Max send window / CWIN (called by Tuner).
    Parameters:
    bytes - max send window in bytes, clamped 32KB-1MB
  - setMayDisconnect
```
public void setMayDisconnect()
```
    May disconnect to true.
  - setMinConcurrentMsgs
```
public static void setMinConcurrentMsgs(int msgs)
```
    Minimum concurrent messages per peer (called by Tuner).
    Parameters:
    msgs - minimum concurrent messages, clamped 8-128
  - setMinRTO
```
public static void setMinRTO(int ms)
```
    Minimum RTO floor (called by Tuner).
    Parameters:
    ms - minimum RTO in ms, clamped 250-2000
  - setOutboundMsgExpiration
```
public static void setOutboundMsgExpiration(long ms)
```
    Bridge to OutboundMessageState.setMessageExpiration for Tuner (different package).
    Parameters:
    ms - the expiration in ms
  - setPostRTOWindowMTUs
```
public static void setPostRTOWindowMTUs(int mtus)
```
    Send-window restart size after an RTO-timeout collapse (called by Tuner).
    Parameters:
    mtus - number of MTUs, clamped 1-4 (1 = RFC 5681 loss window)
  - setSentMessagesCleanTime
```
public static void setSentMessagesCleanTime(long ms)
```
    Bridge to PeerState2.setSentMessagesCleanTime for Tuner (different package).
    Parameters:
    ms - the clean time in ms
  - 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
  - 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
  - shouldRequestImmediateAck
```
protected boolean shouldRequestImmediateAck()
```
    SSU 2 only
    Returns:
    whether request immediate ack
  - toString
```
public String toString()
```
    String representation.
    Overrides:
    toString in class Object

Class PeerState

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

_context

_dead

_inboundLock

_inboundMessages

_isInbound

_keyEstablishedTime

_lastACKSend

_log

_mtu

_packetsReceivedDuplicate

_remoteHostId

_remoteIP

_remoteIPAddress

_remotePeer

_remotePort

_rtt

_transport

_wantACKSendSince

DEFAULT_MTU

LARGE_MTU

MAX_IPV6_MTU

MAX_MTU

MIN_IPV6_MTU

MIN_MTU

RETRANSMISSION_PERIOD_WIDTH

Constructor Detail

PeerState

Method Detail

acked

add

adjustClockSkew

changePort

clearWantedACKSendSince

dataReceived

dropOutbound

ECNReceived

expireInboundMessages

finishAndAllocate

fragmentOverhead

fragmentSize

getAckFrequency

getAggregateStats

getClockSkew

getClockSkewFudge

getConcurrentSends

getConcurrentSendWindow

getConsecutiveFailedSends

getConsecutiveSendRejections

getInactivityTime

getInboundMessages

getInitConcurrentMsgs

getInitRTO

getIntroducerTime

getKeyEstablishedTime

getLastACKSend

getLastReceiveTime

getLastSendFullyTime

getLastSendOrPingTime

getLastSendTime

getMaxConcurrentMessages

getMaxRTO

getMaxSendWindow

getMayDisconnect

getMessagesReceived

getMessagesSent

getMinConcurrentMsgs

getMinRTO

getMTU

getNextDelay

getOutboundMessageCount

getOutboundMsgExpiration

getPacketsReceived

getPacketsReceivedDuplicate

getPacketsRetransmitted