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` fired to reschedule event notification
`(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_MAX_WINDOW
`static int`	`DEFAULT_CONNECT_TIMEOUT` DEFAULT_CONNECT_TIMEOUT
`(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` MAX_WINDOW_SIZE_DEFAULT

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)`

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()` Reusable AckDupEvent for duplicate ACK scheduling.
`long`	`getAckedPackets()` how many packets have we sent and the other side has ACKed?
`long`	`getCloseReceivedOn()`
`long`	`getCloseSentOn()`
`long`	`getCongestionWindowEnd()` Get the congestion window end sequence number.
`String`	`getConnectionError()` Get the connection error message, if any.
`ConnectionManager`	`getConnectionManager()`
`(package private) static int`	`getConnectTimeoutMultiplier()`
`long`	`getCreatedOn()` Get the timestamp when this connection was created.
`long`	`getDisconnectScheduledOn()`
`static int`	`getDisconnectTimeout()`
`static int`	`getGlobalMaxWindowSize()`
`boolean`	`getHardDisconnected()` Check if this connection has been hard-disconnected (via RESET).
`long`	`getHighestAckedThrough()`
`MessageInputStream`	`getInputStream()` Get the 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()` Get the 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()` Get the lifetime of this connection in milliseconds.
`long`	`getLifetimeBytesReceived()` Get total bytes received on this connection.
`long`	`getLifetimeBytesSent()` Get total bytes sent on this connection.
`long`	`getLifetimeDupBytesSent()` Get total duplicate bytes sent on this connection.
`long`	`getLifetimeDupMessagesReceived()` Get total duplicate messages received on this connection.
`long`	`getLifetimeDupMessagesSent()` Get total duplicate messages sent on this connection.
`int`	`getLocalPort()`
`(package private) static long`	`getMaxConnectTimeout()`
`static int`	`getMaxResendDelay()`
`static int`	`getMaxRetransmissionsStatic()`
`static int`	`getMaxSynResendsStatic()`
`static int`	`getMinResendDelay()`
`long`	`getNextOutboundPacketNum()` Get the 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()` Get the output stream that the local peer sends data to the remote peer on.
`ConnectionPacketHandler`	`getPacketHandler()` Get the 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()` who are we talking with
`SigningPublicKey`	`getRemoteSPK()` The key to verify signatures with.
`boolean`	`getResetReceived()` Check if a reset has been received on this connection.
`long`	`getResetReceivedOn()`
`boolean`	`getResetSent()` Check if a reset has been sent on this connection.
`long`	`getResetSentOn()`
`long`	`getSendStreamId()` What stream do we send data to the peer on?
`I2PSession`	`getSession()` Get the I2P session for this connection.
`I2PSocketFull`	`getSocket()` Get the socket associated with this connection.
`(package private) int`	`getSSThresh()`
`int`	`getUnackedPacketsReceived()` Get the count of unacked packets received.
`int`	`getUnackedPacketsSent()` how many packets have we sent but not yet received an ACK for?
`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)` Set or clear if we are being choked by the other side.
`void`	`setChoking(boolean on)` Set or clear if we are choking the other side.
`void`	`setCongestionWindowEnd(long endMsg)` {_congestionWindowEnd
`void`	`setConnectionError(String err)` Set the 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)` Set the ConnectionOptions.
`void`	`setReceiveStreamId(long id)`
`void`	`setRemotePeer(Destination peer)`
`void`	`setRemoteTransientSPK(SigningPublicKey transientSPK)`
`void`	`setSendStreamId(long id)`
`void`	`setSocket(I2PSocketFull socket)` Set the socket associated with this connection.
`String`	`toString()` toString.
`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_MAX_WINDOW
    See Also:
    Constant Field Values
  - DEFAULT_CONNECT_TIMEOUT
```
public static final int DEFAULT_CONNECT_TIMEOUT
```
    DEFAULT_CONNECT_TIMEOUT
    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
```
    MAX_WINDOW_SIZE_DEFAULT
- Constructor Detail
  - Connection
```
public Connection(I2PAppContext ctx,
                  ConnectionManager manager,
                  I2PSession session,
                  SchedulerChooser chooser,
                  SimpleTimer2 timer,
                  PacketQueue queue,
                  ConnectionPacketHandler handler,
                  ConnectionOptions opts,
                  boolean isInbound)
```
    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()
```
    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()
```
    Returns:
    0 if not received
  - getCloseSentOn
```
public long getCloseSentOn()
```
    Returns:
    0 if not sent
  - getCongestionWindowEnd
```
public long getCongestionWindowEnd()
```
    Get the congestion window end sequence number.
    Returns:
    the congestion window end
  - getConnectionError
```
public String getConnectionError()
```
    Get the 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()
```
    Get the timestamp when this connection was created.
    Returns:
    creation timestamp
  - getDisconnectScheduledOn
```
public long getDisconnectScheduledOn()
```
    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()
```
    Returns:
    the highest outbound packet we have received an ack for
  - getInputStream
```
public MessageInputStream getInputStream()
```
    Get the 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()
```
    Get the 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()
```
    Get the lifetime of this connection in milliseconds.
    Returns:
    connection lifetime in ms
  - getLifetimeBytesReceived
```
public long getLifetimeBytesReceived()
```
    Get total bytes received on this connection.
    Returns:
    lifetime bytes received
  - getLifetimeBytesSent
```
public long getLifetimeBytesSent()
```
    Get total bytes sent on this connection.
    Returns:
    lifetime bytes sent
  - getLifetimeDupBytesSent
```
public long getLifetimeDupBytesSent()
```
    Get total duplicate bytes sent on this connection.
    Returns:
    lifetime duplicate bytes sent
  - getLifetimeDupMessagesReceived
```
public long getLifetimeDupMessagesReceived()
```
    Get total duplicate messages received on this connection.
    Returns:
    lifetime duplicate messages received
  - getLifetimeDupMessagesSent
```
public long getLifetimeDupMessagesSent()
```
    Get total duplicate messages sent on this connection.
    Returns:
    lifetime duplicate messages sent
  - getLocalPort
```
public int getLocalPort()
```
    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()
```
    Get the 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()
```
    Get the output stream that the local peer sends data to the remote peer on.
    Returns:
    the outbound message stream, non-null
  - getPacketHandler
```
public ConnectionPacketHandler getPacketHandler()
```
    Get the 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()
```
    who are we talking with
    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()
```
    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()
```
    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()
```
    Get the I2P session for this connection.
    Returns:
    the session
  - getSocket
```
public I2PSocketFull getSocket()
```
    Get the socket associated with this connection.
    Returns:
    the socket, or null if not yet set
  - getSSThresh
```
int getSSThresh()
```
  - getUnackedPacketsReceived
```
public int getUnackedPacketsReceived()
```
    Get the 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.
  - 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)
```
    Set or clear if we are being choked by the other side.
    Parameters:
    on - true for choked
  - setChoking
```
public void setChoking(boolean on)
```
    Set or clear if we are choking 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)
```
    {_congestionWindowEnd
  - setConnectionError
```
public void setConnectionError(String err)
```
    Set the 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)
```
    Set the ConnectionOptions.
    Parameters:
    opts - ConnectionOptions non-null
  - setReceiveStreamId
```
public void setReceiveStreamId(long id)
```
    Parameters:
    id - 0 to 0xffffffff
    Throws:
    IllegalStateException - if already set to nonzero
  - setRemotePeer
```
public void setRemotePeer(Destination peer)
```
    Parameters:
    peer - non-null
  - setRemoteTransientSPK
```
public void setRemoteTransientSPK(SigningPublicKey transientSPK)
```
    Parameters:
    transientSPK - null ok
  - setSendStreamId
```
public void setSendStreamId(long id)
```
    Parameters:
    id - 0 to 0xffffffff
    Throws:
    IllegalStateException - if already set to nonzero
  - setSocket
```
public void setSocket(I2PSocketFull socket)
```
    Set the socket associated with this connection.
    Parameters:
    socket - the socket
  - toString
```
public String toString()
```
    toString.
    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

incrementBytesReceived

incrementBytesSent

incrementDupBytesSent

incrementDupMessagesReceived

incrementDupMessagesSent

incrementUnackedPacketsReceived

isChoked

isInbound

newResendPacketEvent