Connection (Javadocs [I2P+ 2.13.0+]

java.lang.Object
- net.i2p.client.streaming.impl.Connection

```
class Connection
extends Object
```
Maintain the state controlling a streaming connection between two destinations.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`(package private) class`	`Connection.AckDupEvent` Reusable event to send an ACK for a duplicate packet after a short delay.
`(package private) class`	`Connection.ConEvent` Notify waiters to reschedule the connection event.
`(package private) class`	`Connection.ResendPacketEvent` This is not normally scheduled.
`(package private) class`	`Connection.RetransmitEvent` A single retransmit timer for all packets.

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`ABSOLUTE_MAX_WINDOW` Absolute ceiling on in-flight packets regardless of BDP estimate.
`static int`	`DEFAULT_CONNECT_TIMEOUT` Default connect timeout in milliseconds.
`(package private) static int`	`FAST_RETRANSMIT_THRESHOLD` If we have been explicitly NACKed three times, retransmit the packet even if there are other packets in flight.
`static int`	`MAX_WINDOW_SIZE_DEFAULT` Default window size cap used when no per-connection or global override is set.

Constructor Summary

Constructors
Constructor and Description
`Connection(I2PAppContext ctx, ConnectionManager manager, I2PSession session, SchedulerChooser chooser, SimpleTimer2 timer, PacketQueue queue, ConnectionPacketHandler handler, ConnectionOptions opts, boolean isInbound)` Constructor for this connection.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`(package private) void`	`ackImmediately()` Ack immediately.
`List<PacketLocal>`	`ackPackets(long ackThrough, long[] nacks)` Process the acks and nacks received in a packet.
`void`	`closeReceived()` Notify that a close was received.
`void`	`disconnect(boolean cleanDisconnect)` Must be called when we are done with this connection.
`void`	`disconnect(boolean cleanDisconnect, boolean removeFromConMgr)` Must be called when we are done with this connection.
`void`	`disconnectComplete()` Must be called when we are done with this connection.
`(package private) void`	`eventOccurred()` Notify the scheduler that an event occurred on this connection.
`(package private) Connection.AckDupEvent`	`getAckDupEvent()` Schedule an event on our timer.
`long`	`getAckedPackets()` How many packets have we sent and the other side has ACKed?
`long`	`getCloseReceivedOn()` Timestamp when a close was received.
`long`	`getCloseSentOn()` Timestamp when a close was sent.
`long`	`getCongestionWindowEnd()` Congestion window end sequence number.
`String`	`getConnectionError()` Connection error message, if any.
`ConnectionManager`	`getConnectionManager()`
`(package private) static int`	`getConnectTimeoutMultiplier()`
`long`	`getCreatedOn()` Timestamp when this connection was created.
`long`	`getDisconnectScheduledOn()` Timestamp when the disconnect was scheduled.
`static int`	`getDisconnectTimeout()`
`static int`	`getGlobalMaxWindowSize()`
`boolean`	`getHardDisconnected()` Check if this connection has been hard-disconnected (via RESET).
`long`	`getHighestAckedThrough()` Highest outbound packet we have received an ack for.
`MessageInputStream`	`getInputStream()` Input stream that the local peer receives data on.
`boolean`	`getIsConnected()` Always true at the start, even if we haven't gotten a reply on an outbound connection.
`long`	`getLastActivityOn()` Timestamp of the last send or receive activity.
`long`	`getLastSendId()` What was the last packet Id sent to the peer?
`long`	`getLastSendTime()` When did we last send anything to the peer?
`long`	`getLifetime()` Lifetime of this connection in milliseconds.
`long`	`getLifetimeBytesReceived()` Total bytes received on this connection.
`long`	`getLifetimeBytesSent()` Total bytes sent on this connection.
`long`	`getLifetimeDupBytesSent()` Total duplicate bytes sent on this connection.
`long`	`getLifetimeDupMessagesReceived()` Total duplicate messages received on this connection.
`long`	`getLifetimeDupMessagesSent()` Total duplicate messages sent on this connection.
`int`	`getLocalPort()` Local port of this connection.
`(package private) static long`	`getMaxConnectTimeout()`
`static int`	`getMaxResendDelay()`
`static int`	`getMaxRetransmissionsStatic()`
`static int`	`getMaxSynResendsStatic()`
`static int`	`getMinResendDelay()`
`long`	`getNextOutboundPacketNum()` Next outbound packet sequence number.
`long`	`getNextSendTime()` Time when the scheduler next want to send a packet, or -1 if never.
`ConnectionOptions`	`getOptions()` Retrieve the current ConnectionOptions.
`MessageOutputStream`	`getOutputStream()` Output stream that the local peer sends data to the remote peer on.
`ConnectionPacketHandler`	`getPacketHandler()` Packet handler for this connection.
`int`	`getPort()` The remote port.
`long`	`getReceiveStreamId()` The stream ID of a peer connection that sends data to us, or zero if unknown.
`Destination`	`getRemotePeer()` Destination of the remote peer.
`SigningPublicKey`	`getRemoteSPK()` The key to verify signatures with.
`boolean`	`getResetReceived()` Check if a reset has been received on this connection.
`long`	`getResetReceivedOn()` Timestamp when a reset was received.
`boolean`	`getResetSent()` Check if a reset has been sent on this connection.
`long`	`getResetSentOn()` Timestamp when a reset was sent.
`long`	`getSendStreamId()` What stream do we send data to the peer on?
`I2PSession`	`getSession()` I2P session for this connection.
`I2PSocketFull`	`getSocket()` Socket associated with this connection.
`(package private) int`	`getSSThresh()`
`int`	`getUnackedPacketsReceived()` Count of unacked packets received.
`int`	`getUnackedPacketsSent()` How many packets have we sent but not yet received an ACK for?
`Object`	`getWindowLock()` For ConnectionPacketHandler.adjustWindow()
`void`	`incrementBytesReceived(int bytes)` Increment the lifetime bytes received counter.
`void`	`incrementBytesSent(int bytes)` Increment the lifetime bytes sent counter.
`void`	`incrementDupBytesSent(int bytes)` Increment the lifetime duplicate bytes sent counter.
`void`	`incrementDupMessagesReceived(int msgs)` Increment the lifetime duplicate messages received counter.
`void`	`incrementDupMessagesSent(int msgs)` Increment the lifetime duplicate messages sent counter.
`void`	`incrementUnackedPacketsReceived()` Increment the count of unacked packets received.
`boolean`	`isChoked()` Is the other side choking us?
`boolean`	`isInbound()` Check if this is an inbound connection.
`(package private) Connection.ResendPacketEvent`	`newResendPacketEvent(PacketLocal packet)` A new ResendPacketEvent.
`void`	`notifyCloseSent()` Called by CPH when a CLOSE packet is sent.
`void`	`notifyLastPacketAcked()` Notify that a close that we sent, and all previous packets, were acked.
`(package private) void`	`packetReceived()` Called when a packet is received on this connection.
`boolean`	`packetSendChoke(long timeoutMs)` This doesn't "send a choke".
`void`	`resetReceived()` Notify that a reset was received.
`void`	`scheduleConnectionEvent(long msToWait)` Called from SchedulerImpl
`(package private) void`	`scheduleSoftFailureRetransmit()` Trigger immediate retransmission of unacked packets after a soft failure (e.g., tunnel expiry, no tunnels).
`(package private) void`	`sendAvailable()` Flush any data that we can.
`(package private) void`	`sendPacket(PacketLocal packet)` This sends all 'normal' packets (acks and data) for the first time.
`void`	`setChoked(boolean on)` Choked state set by the other side.
`void`	`setChoking(boolean on)` Choking state toward the other side.
`void`	`setCongestionWindowEnd(long endMsg)` Congestion window end sequence number.
`void`	`setConnectionError(String err)` Connection error message.
`(package private) static void`	`setConnectTimeoutMultiplier(int pct)`
`static void`	`setGlobalMaxWindowSize(int val)`
`static void`	`setMaxRetransmissions(int val)`
`static void`	`setMaxSynResends(int val)`
`void`	`setNextSendTime(long when)` If the next send time is currently >= 0 (i.e.
`void`	`setOptions(ConnectionOptions opts)` ConnectionOptions for this connection.
`void`	`setReceiveStreamId(long id)` Stream ID that the peer sends data on.
`void`	`setRemotePeer(Destination peer)` Remote peer of this connection, non-null.
`void`	`setRemoteTransientSPK(SigningPublicKey transientSPK)` Transient signing public key of the remote peer.
`void`	`setSendStreamId(long id)` Stream ID that we send data on.
`void`	`setSocket(I2PSocketFull socket)` Socket associated with this connection.
`String`	`toString()` Human-readable summary of this connection.
`void`	`updateShareOpts()` Update shared options from the TCB cache.
`(package private) void`	`waitForConnect()` Wait for the connection to be established, with the option's connectTimeout.
`(package private) void`	`waitForConnect(int timeoutMs)` Wait for the connection to be established, but no longer than timeoutMs.
`(package private) void`	`windowAdjusted()` Notify all threads waiting in packetSendChoke().

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

- Field Detail
  - ABSOLUTE_MAX_WINDOW
```
public static final int ABSOLUTE_MAX_WINDOW
```
    Absolute ceiling on in-flight packets regardless of BDP estimate. Prevents runaway window growth from estimator noise or bugs. Set to accommodate high-BDP paths (e.g. 50Mbps @ 1s RTT ~ 6250 packets @ 1KB).
    See Also:
    Constant Field Values
  - DEFAULT_CONNECT_TIMEOUT
```
public static final int DEFAULT_CONNECT_TIMEOUT
```
    Default connect timeout in milliseconds.
    See Also:
    Constant Field Values
  - FAST_RETRANSMIT_THRESHOLD
```
static final int FAST_RETRANSMIT_THRESHOLD
```
    If we have been explicitly NACKed three times, retransmit the packet even if there are other packets in flight.
    See Also:
    Constant Field Values
  - MAX_WINDOW_SIZE_DEFAULT
```
public static final int MAX_WINDOW_SIZE_DEFAULT
```
    Default window size cap used when no per-connection or global override is set. The effective ceiling is managed by getGlobalMaxWindowSize(), which the Tuner adjusts based on observed RTT, bandwidth, and loss.
- Constructor Detail
  - Connection
```
public Connection(I2PAppContext ctx,
                  ConnectionManager manager,
                  I2PSession session,
                  SchedulerChooser chooser,
                  SimpleTimer2 timer,
                  PacketQueue queue,
                  ConnectionPacketHandler handler,
                  ConnectionOptions opts,
                  boolean isInbound)
```
    Constructor for this connection.
    Parameters:
    opts - may be null
- Method Detail
  - ackImmediately
```
void ackImmediately()
```
    Ack immediately.
  - ackPackets
```
public List<PacketLocal> ackPackets(long ackThrough,
                                    long[] nacks)
```
    Process the acks and nacks received in a packet.
    Note: the returned list is a reused, internally-owned buffer (_ackedList) that is cleared at the start of the next ackPackets() call. Callers MUST fully consume it before the next ack is processed. This is safe because acks are serialized on the receive thread; do not retain a reference across calls.
    Returns:
    List of packets acked for the first time (empty if none); a shared mutable buffer, not a fresh copy
  - closeReceived
```
public void closeReceived()
```
    Notify that a close was received. Called by CPH. May be called multiple times.
  - disconnect
```
public void disconnect(boolean cleanDisconnect)
```
    Must be called when we are done with this connection. Enters TIME-WAIT if necessary, and removes from connection manager. May be called multiple times. This closes the socket side. In normal operation, this is called when a CLOSE has been received, AND a CLOSE has been sent, AND EITHER: received close before sent close AND our CLOSE has been acked OR received close after sent close.
    Parameters:
    cleanDisconnect - if true, normal close; if false, send a RESET
  - disconnect
```
public void disconnect(boolean cleanDisconnect,
                       boolean removeFromConMgr)
```
    Must be called when we are done with this connection. May be called multiple times. This closes the socket side. In normal operation, this is called when a CLOSE has been received, AND a CLOSE has been sent, AND EITHER: received close before sent close AND our CLOSE has been acked OR received close after sent close.
    Parameters:
    cleanDisconnect - if true, normal close; if false, send a RESET
    removeFromConMgr - if true, enters TIME-WAIT if necessary. if false, MUST call disconnectComplete() later. Should always be true unless called from ConnectionManager.
  - disconnectComplete
```
public void disconnectComplete()
```
    Must be called when we are done with this connection. Final disconnect. Remove from conn manager. May be called multiple times.
  - eventOccurred
```
void eventOccurred()
```
    Notify the scheduler that an event occurred on this connection.
  - getAckDupEvent
```
Connection.AckDupEvent getAckDupEvent()
```
    Schedule an event on our timer. The event should use the no-arg constructor; the pool is set here.
    Returns:
    the reusable AckDupEvent for duplicate ACK scheduling
  - getAckedPackets
```
public long getAckedPackets()
```
    How many packets have we sent and the other side has ACKed?
    Returns:
    Count of how many packets ACKed.
  - getCloseReceivedOn
```
public long getCloseReceivedOn()
```
    Timestamp when a close was received.
    Returns:
    0 if not received
  - getCloseSentOn
```
public long getCloseSentOn()
```
    Timestamp when a close was sent.
    Returns:
    0 if not sent
  - getCongestionWindowEnd
```
public long getCongestionWindowEnd()
```
    Congestion window end sequence number.
    Returns:
    the congestion window end
  - getConnectionError
```
public String getConnectionError()
```
    Connection error message, if any.
    Returns:
    error message, or null if no error
  - getConnectionManager
```
public ConnectionManager getConnectionManager()
```
  - getConnectTimeoutMultiplier
```
static int getConnectTimeoutMultiplier()
```
  - getCreatedOn
```
public long getCreatedOn()
```
    Timestamp when this connection was created.
    Returns:
    creation timestamp
  - getDisconnectScheduledOn
```
public long getDisconnectScheduledOn()
```
    Timestamp when the disconnect was scheduled.
    Returns:
    0 if not scheduled
  - getDisconnectTimeout
```
public static int getDisconnectTimeout()
```
  - getGlobalMaxWindowSize
```
public static int getGlobalMaxWindowSize()
```
  - getHardDisconnected
```
public boolean getHardDisconnected()
```
    Check if this connection has been hard-disconnected (via RESET).
    Returns:
    true if hard-disconnected
  - getHighestAckedThrough
```
public long getHighestAckedThrough()
```
    Highest outbound packet we have received an ack for.
    Returns:
    the highest outbound packet we have received an ack for
  - getInputStream
```
public MessageInputStream getInputStream()
```
    Input stream that the local peer receives data on.
    Returns:
    the inbound message stream, non-null
  - getIsConnected
```
public boolean getIsConnected()
```
    Always true at the start, even if we haven't gotten a reply on an outbound connection. Only set to false on disconnect. For outbound, use getHighestAckedThrough() >= 0 also, to determine if the connection is up. In general, this is true until either: - CLOSE received and CLOSE sent and our CLOSE is acked - RESET received or sent - closed on the socket side
    Returns:
    the is connected
  - getLastActivityOn
```
public long getLastActivityOn()
```
    Timestamp of the last send or receive activity.
    Returns:
    the later of last send time and last receive time
  - getLastSendId
```
public long getLastSendId()
```
    What was the last packet Id sent to the peer?
    Returns:
    The last sent packet ID
  - getLastSendTime
```
public long getLastSendTime()
```
    When did we last send anything to the peer?
    Returns:
    Last time we sent data
  - getLifetime
```
public long getLifetime()
```
    Lifetime of this connection in milliseconds.
    Returns:
    connection lifetime in ms
  - getLifetimeBytesReceived
```
public long getLifetimeBytesReceived()
```
    Total bytes received on this connection.
    Returns:
    lifetime bytes received
  - getLifetimeBytesSent
```
public long getLifetimeBytesSent()
```
    Total bytes sent on this connection.
    Returns:
    lifetime bytes sent
  - getLifetimeDupBytesSent
```
public long getLifetimeDupBytesSent()
```
    Total duplicate bytes sent on this connection.
    Returns:
    lifetime duplicate bytes sent
  - getLifetimeDupMessagesReceived
```
public long getLifetimeDupMessagesReceived()
```
    Total duplicate messages received on this connection.
    Returns:
    lifetime duplicate messages received
  - getLifetimeDupMessagesSent
```
public long getLifetimeDupMessagesSent()
```
    Total duplicate messages sent on this connection.
    Returns:
    lifetime duplicate messages sent
  - getLocalPort
```
public int getLocalPort()
```
    Local port of this connection.
    Returns:
    Default I2PSession.PORT_UNSPECIFIED (0) or PORT_ANY (0)
  - getMaxConnectTimeout
```
static long getMaxConnectTimeout()
```
  - getMaxResendDelay
```
public static int getMaxResendDelay()
```
  - getMaxRetransmissionsStatic
```
public static int getMaxRetransmissionsStatic()
```
  - getMaxSynResendsStatic
```
public static int getMaxSynResendsStatic()
```
  - getMinResendDelay
```
public static int getMinResendDelay()
```
  - getNextOutboundPacketNum
```
public long getNextOutboundPacketNum()
```
    Next outbound packet sequence number.
    Returns:
    the next sequence number
  - getNextSendTime
```
public long getNextSendTime()
```
    Time when the scheduler next want to send a packet, or -1 if never. This should be set when we want to send on timeout, for instance, or want to delay an ACK.
    Returns:
    the next time the scheduler will want to send a packet, or -1 if never.
  - getOptions
```
public ConnectionOptions getOptions()
```
    Retrieve the current ConnectionOptions.
    Returns:
    the current ConnectionOptions, non-null
  - getOutputStream
```
public MessageOutputStream getOutputStream()
```
    Output stream that the local peer sends data to the remote peer on.
    Returns:
    the outbound message stream, non-null
  - getPacketHandler
```
public ConnectionPacketHandler getPacketHandler()
```
    Packet handler for this connection.
    Returns:
    the packet handler
  - getPort
```
public int getPort()
```
    The remote port.
    Returns:
    Default I2PSession.PORT_UNSPECIFIED (0) or PORT_ANY (0)
  - getReceiveStreamId
```
public long getReceiveStreamId()
```
    The stream ID of a peer connection that sends data to us, or zero if unknown.
    Returns:
    receive stream ID, or 0 if unknown
  - getRemotePeer
```
public Destination getRemotePeer()
```
    Destination of the remote peer.
    Returns:
    peer Destination or null if unset
  - getRemoteSPK
```
public SigningPublicKey getRemoteSPK()
```
    The key to verify signatures with. The transient SPK if previously received, else getRemotePeer().getSigningPublicKey() if previously received, else null.
    Returns:
    peer Destination or null if unset
  - getResetReceived
```
public boolean getResetReceived()
```
    Check if a reset has been received on this connection.
    Returns:
    true if a reset was received
  - getResetReceivedOn
```
public long getResetReceivedOn()
```
    Timestamp when a reset was received.
    Returns:
    0 if not received
  - getResetSent
```
public boolean getResetSent()
```
    Check if a reset has been sent on this connection.
    Returns:
    true if a reset was sent
  - getResetSentOn
```
public long getResetSentOn()
```
    Timestamp when a reset was sent.
    Returns:
    0 if not sent
  - getSendStreamId
```
public long getSendStreamId()
```
    What stream do we send data to the peer on?
    Returns:
    non-global stream sending ID, or 0 if unknown
  - getSession
```
public I2PSession getSession()
```
    I2P session for this connection.
    Returns:
    the session
  - getSocket
```
public I2PSocketFull getSocket()
```
    Socket associated with this connection.
    Returns:
    the socket, or null if not yet set
  - getSSThresh
```
int getSSThresh()
```
  - getUnackedPacketsReceived
```
public int getUnackedPacketsReceived()
```
    Count of unacked packets received.
    Returns:
    number of unacked packets received
  - getUnackedPacketsSent
```
public int getUnackedPacketsSent()
```
    How many packets have we sent but not yet received an ACK for?
    Returns:
    Count of packets in-flight.
  - getWindowLock
```
public Object getWindowLock()
```
    For ConnectionPacketHandler.adjustWindow()
  - incrementBytesReceived
```
public void incrementBytesReceived(int bytes)
```
    Increment the lifetime bytes received counter.
    Parameters:
    bytes - number of bytes to add
  - incrementBytesSent
```
public void incrementBytesSent(int bytes)
```
    Increment the lifetime bytes sent counter.
    Parameters:
    bytes - number of bytes to add
  - incrementDupBytesSent
```
public void incrementDupBytesSent(int bytes)
```
    Increment the lifetime duplicate bytes sent counter.
    Parameters:
    bytes - number of duplicate bytes to add
  - incrementDupMessagesReceived
```
public void incrementDupMessagesReceived(int msgs)
```
    Increment the lifetime duplicate messages received counter.
    Parameters:
    msgs - number of duplicate messages to add
  - incrementDupMessagesSent
```
public void incrementDupMessagesSent(int msgs)
```
    Increment the lifetime duplicate messages sent counter.
    Parameters:
    msgs - number of duplicate messages to add
  - incrementUnackedPacketsReceived
```
public void incrementUnackedPacketsReceived()
```
    Increment the count of unacked packets received.
  - isChoked
```
public boolean isChoked()
```
    Is the other side choking us?
    Returns:
    if choked
  - isInbound
```
public boolean isInbound()
```
    Check if this is an inbound connection.
    Returns:
    true if inbound
  - newResendPacketEvent
```
Connection.ResendPacketEvent newResendPacketEvent(PacketLocal packet)
```
    A new ResendPacketEvent.
  - notifyCloseSent
```
public void notifyCloseSent()
```
    Called by CPH when a CLOSE packet is sent. Idempotent: only the first call sets the timestamp.
  - notifyLastPacketAcked
```
public void notifyLastPacketAcked()
```
    Notify that a close that we sent, and all previous packets, were acked. Called by CPH. Only call this once.
  - packetReceived
```
void packetReceived()
```
    Called when a packet is received on this connection. Updates the last received timestamp and resets the activity timer.
  - packetSendChoke
```
public boolean packetSendChoke(long timeoutMs)
                        throws IOException,
                               InterruptedException
```
    This doesn't "send a choke". Rather, it blocks if the outbound window is full, thus choking the sender that calls this. Block until there is an open outbound packet slot or the write timeout expires. PacketLocal is the only caller, generally with -1. A persist timer prevents deadlock when the remote chokes us (window=1) and then never sends an unchoke signal. After RTO (min 5s), we auto-unchoke and allow the retransmission mechanism to restore the window, with exponential backoff so a persistently choked peer does not cause a tight probe loop.
    The wait loop polls every 50ms (instead of 250ms) to reduce latency when an ACK arrives to free a window slot.
    Parameters:
    timeoutMs - 0 or negative means wait forever, 5 minutes max
    Returns:
    true if the packet should be sent, false for a fatal error will return false after 5 minutes even if timeoutMs is <= 0.
    Throws:
    IOException
    InterruptedException
  - resetReceived
```
public void resetReceived()
```
    Notify that a reset was received. May be called multiple times.
  - scheduleConnectionEvent
```
public void scheduleConnectionEvent(long msToWait)
```
    Called from SchedulerImpl
  - scheduleSoftFailureRetransmit
```
void scheduleSoftFailureRetransmit()
```
    Trigger immediate retransmission of unacked packets after a soft failure (e.g., tunnel expiry, no tunnels). This schedules the retransmit event with zero delay to retry sending on a new tunnel without waiting for RTO.
  - sendAvailable
```
void sendAvailable()
```
    Flush any data that we can. Non-blocking.
  - sendPacket
```
void sendPacket(PacketLocal packet)
```
    This sends all 'normal' packets (acks and data) for the first time. Retransmits are done in ResendPacketEvent below. Resets, pings, and pongs are done elsewhere in this class, or in ConnectionManager or ConnectionHandler.
  - setChoked
```
public void setChoked(boolean on)
```
    Choked state set by the other side.
    Parameters:
    on - true for choked
  - setChoking
```
public void setChoking(boolean on)
```
    Choking state toward the other side. If on is true or the value has changed, this will call ackImmediately().
    Parameters:
    on - true for choking
  - setCongestionWindowEnd
```
public void setCongestionWindowEnd(long endMsg)
```
    Congestion window end sequence number.
    Parameters:
    endMsg - the new congestion window end
  - setConnectionError
```
public void setConnectionError(String err)
```
    Connection error message.
    Parameters:
    err - the error message
  - setConnectTimeoutMultiplier
```
static void setConnectTimeoutMultiplier(int pct)
```
  - setGlobalMaxWindowSize
```
public static void setGlobalMaxWindowSize(int val)
```
  - setMaxRetransmissions
```
public static void setMaxRetransmissions(int val)
```
  - setMaxSynResends
```
public static void setMaxSynResends(int val)
```
  - setNextSendTime
```
public void setNextSendTime(long when)
```
    If the next send time is currently >= 0 (i.e. not "never"), this may make the next time sooner but will not make it later. If the next send time is currently < 0 (i.e. "never"), this will set it to the time specified, but not later than options.getSendAckDelay() from now (1000 ms)
  - setOptions
```
public void setOptions(ConnectionOptions opts)
```
    ConnectionOptions for this connection.
    Parameters:
    opts - ConnectionOptions non-null
  - setReceiveStreamId
```
public void setReceiveStreamId(long id)
```
    Stream ID that the peer sends data on.
    Parameters:
    id - 0 to 0xffffffff
    Throws:
    IllegalStateException - if already set to nonzero
  - setRemotePeer
```
public void setRemotePeer(Destination peer)
```
    Remote peer of this connection, non-null.
    Parameters:
    peer - non-null
  - setRemoteTransientSPK
```
public void setRemoteTransientSPK(SigningPublicKey transientSPK)
```
    Transient signing public key of the remote peer.
    Parameters:
    transientSPK - null ok
  - setSendStreamId
```
public void setSendStreamId(long id)
```
    Stream ID that we send data on.
    Parameters:
    id - 0 to 0xffffffff
    Throws:
    IllegalStateException - if already set to nonzero
  - setSocket
```
public void setSocket(I2PSocketFull socket)
```
    Socket associated with this connection.
    Parameters:
    socket - the socket
  - toString
```
public String toString()
```
    Human-readable summary of this connection.
    Overrides:
    toString in class Object
  - updateShareOpts
```
public void updateShareOpts()
```
    Update shared options from the TCB cache.
  - waitForConnect
```
void waitForConnect()
```
    Wait for the connection to be established, with the option's connectTimeout.
  - waitForConnect
```
void waitForConnect(int timeoutMs)
```
    Wait for the connection to be established, but no longer than timeoutMs. If the connection fails or the timeout is exceeded, sets _connectionError.
    Parameters:
    timeoutMs - max wait in ms; if <= 0 uses the connection option's connectTimeout
  - windowAdjusted
```
void windowAdjusted()
```
    Notify all threads waiting in packetSendChoke(). Also update pacing rate since window size may have changed.

Class Connection

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

ABSOLUTE_MAX_WINDOW

DEFAULT_CONNECT_TIMEOUT

FAST_RETRANSMIT_THRESHOLD

MAX_WINDOW_SIZE_DEFAULT

Constructor Detail

Connection

Method Detail

ackImmediately

ackPackets

closeReceived

disconnect

disconnect

disconnectComplete

eventOccurred

getAckDupEvent

getAckedPackets

getCloseReceivedOn

getCloseSentOn

getCongestionWindowEnd

getConnectionError

getConnectionManager

getConnectTimeoutMultiplier

getCreatedOn

getDisconnectScheduledOn

getDisconnectTimeout

getGlobalMaxWindowSize

getHardDisconnected

getHighestAckedThrough

getInputStream

getIsConnected

getLastActivityOn

getLastSendId

getLastSendTime

getLifetime

getLifetimeBytesReceived

getLifetimeBytesSent

getLifetimeDupBytesSent

getLifetimeDupMessagesReceived

getLifetimeDupMessagesSent

getLocalPort

getMaxConnectTimeout

getMaxResendDelay

getMaxRetransmissionsStatic

getMaxSynResendsStatic

getMinResendDelay

getNextOutboundPacketNum

getNextSendTime

getOptions

getOutputStream

getPacketHandler

getPort

getReceiveStreamId

getRemotePeer

getRemoteSPK

getResetReceived

getResetReceivedOn

getResetSent

getResetSentOn

getSendStreamId

getSession

getSocket

getSSThresh

getUnackedPacketsReceived

getUnackedPacketsSent

getWindowLock

incrementBytesReceived

incrementBytesSent

incrementDupBytesSent

incrementDupMessagesReceived

incrementDupMessagesSent

incrementUnackedPacketsReceived

isChoked

isInbound