Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## net.i2p.client.streaming
Class ConnectionOptions

    java.lang.Object
      net.i2p.client.streaming.I2PSocketOptionsImpl
          net.i2p.client.streaming.ConnectionOptions

All Implemented Interfaces:
  I2PSocketOptions

     class ConnectionOptions

extends I2PSocketOptionsImpl

Define the current options for the con (and allow custom tweaking midstream)

Field Summary
`static int` | `DEFAULT_INITIAL_ACK_DELAY`
`static int` | `DEFAULT_INITIAL_RTT`
`static int` | `DEFAULT_MAX_MESSAGE_SIZE` OK, here is the calculation on the message size to fit in a single tunnel message without fragmentation.
`(package private) static int` | `DEFAULT_MAX_SENDS`
`static int` | `INACTIVITY_ACTION_DISCONNECT` on inactivity timeout, close the connection
`static int` | `INACTIVITY_ACTION_NOOP` on inactivity timeout, do nothing
`static int` | `INACTIVITY_ACTION_SEND` on inactivity timeout, send a payload message
`(package private) static int` | `INITIAL_WINDOW_SIZE`
`static int` | `MIN_MESSAGE_SIZE`
`(package private) static int` | `MIN_WINDOW_SIZE`
`static int` | `PROFILE_BULK`
`static int` | `PROFILE_INTERACTIVE`
`static String` | `PROP_ACCESS_LIST`
`static String` | `PROP_ANSWER_PINGS`
`static String` | `PROP_CONGESTION_AVOIDANCE_GROWTH_RATE_FACTOR`
`static String` | `PROP_CONNECT_DELAY`
`static String` | `PROP_ENABLE_ACCESS_LIST` all of these are @since 0.7.13
`static String` | `PROP_ENABLE_BLACKLIST`
`static String` | `PROP_INACTIVITY_ACTION`
`static String` | `PROP_INACTIVITY_TIMEOUT`
`static String` | `PROP_INITIAL_ACK_DELAY`
`static String` | `PROP_INITIAL_RECEIVE_WINDOW` unused
`static String` | `PROP_INITIAL_RESEND_DELAY`
`static String` | `PROP_INITIAL_RTT`
`static String` | `PROP_INITIAL_WINDOW_SIZE`
`static String` | `PROP_MAX_CONNS_DAY`
`static String` | `PROP_MAX_CONNS_HOUR`
`static String` | `PROP_MAX_CONNS_MIN` all of these are @since 0.7.14
`static String` | `PROP_MAX_MESSAGE_SIZE`
`static String` | `PROP_MAX_RESENDS`
`static String` | `PROP_MAX_TOTAL_CONNS_DAY`
`static String` | `PROP_MAX_TOTAL_CONNS_HOUR`
`static String` | `PROP_MAX_TOTAL_CONNS_MIN`
`static String` | `PROP_MAX_WINDOW_SIZE`
`static String` | `PROP_PROFILE`
`static String` | `PROP_SLOW_START_GROWTH_RATE_FACTOR`

Fields inherited from class net.i2p.client.streaming.I2PSocketOptionsImpl
`DEFAULT_BUFFER_SIZE, DEFAULT_CONNECT_TIMEOUT, DEFAULT_WRITE_TIMEOUT`

Fields inherited from interface net.i2p.client.streaming.I2PSocketOptions
`PROP_BUFFER_SIZE, PROP_CONNECT_TIMEOUT, PROP_READ_TIMEOUT, PROP_WRITE_TIMEOUT`

Constructor Summary
`ConnectionOptions()`
`ConnectionOptions(ConnectionOptions opts)`
`ConnectionOptions(I2PSocketOptions opts)`
`ConnectionOptions(Properties opts)`

Method Summary
`Set<Hash>` | `getAccessList()`
`boolean` | `getAnswerPings()` Do we respond to a ping?
`Set<Hash>` | `getBlacklist()`
`int` | `getChoke()` how long we want to wait before any data is transferred on the connection in either direction
`int` | `getCongestionAvoidanceGrowthRateFactor()` When we're in congestion avoidance, we grow the window size at the rate of 1/(windowSize*factor).
`int` | `getConnectDelay()` how long will we wait after instantiating a new con before actually attempting to connect.
`int` | `getInactivityAction()`
`int` | `getInactivityTimeout()` What period of inactivity qualifies as "too long"?
`int` | `getInboundBufferSize()` how much data are we willing to accept in our buffer?
`int` | `getMaxConnsPerDay()`
`int` | `getMaxConnsPerHour()`
`int` | `getMaxConnsPerMinute()` all of these are @since 0.7.14; no public setters
`int` | `getMaxMessageSize()` What is the largest message we want to send or receive?
`int` | `getMaxResends()` How many times will we try to send a message before giving up?
`int` | `getMaxTotalConnsPerDay()`
`int` | `getMaxTotalConnsPerHour()`
`int` | `getMaxTotalConnsPerMinute()`
`int` | `getMaxWindowSize()`
`int` | `getProfile()` What profile do we want to use for this connection? TODO: Only bulk is supported so far.
`int` | `getReceiveWindow()` Deprecated. This doesn't appear to be used.
`boolean` | `getRequireFullySigned()` Do we want all packets in both directions to be signed, or can we deal with signatures on the SYN and FIN packets only? There is no property name defined for this, so it's safe to say this is unused and always false.
`int` | `getResendDelay()` How long after sending a packet will we wait before resending?
`int` | `getRTO()`
`int` | `getRTT()` What to set the round trip time estimate to (in milliseconds)
`(package private) int` | `getRTTDev()` for debugging @since 0.7.13
`int` | `getRTTTrend()` If we have 3 consecutive rtt increases, we are trending upwards (1), or if we have 3 consecutive rtt decreases, we are trending downwards (-1), else we're stable.
`int` | `getSendAckDelay()` if there are packets we haven't ACKed yet and we don't receive _receiveWindow messages before (_lastSendTime+_sendAckDelay), send an ACK of what we have received so far.
`int` | `getSlowStartGrowthRateFactor()` When we're in slow start, we grow the window size at the rate of 1/(factor).
`int` | `getWindowSize()` How many messages will we send before waiting for an ACK?
`protected void` | `init(Properties opts)`
`boolean` | `isAccessListEnabled()`
`boolean` | `isBlacklistEnabled()`
`void` | `setAnswerPings(boolean yes)`
`void` | `setChoke(int ms)`
`void` | `setCongestionAvoidanceGrowthRateFactor(int factor)`
`void` | `setConnectDelay(int delayMs)`
`void` | `setInactivityAction(int action)`
`void` | `setInactivityTimeout(int timeout)`
`void` | `setInboundBufferSize(int bytes)`
`void` | `setMaxMessageSize(int bytes)`
`void` | `setMaxResends(int numSends)`
`void` | `setMaxWindowSize(int msgs)`
`void` | `setProfile(int profile)`
`void` | `setProperties(Properties opts)`
`void` | `setReceiveWindow(int numMsgs)`
`void` | `setRequireFullySigned(boolean sign)` unused, see above
`void` | `setResendDelay(int ms)`
`void` | `setRTT(int ms)`
`void` | `setSendAckDelay(int delayMs)` Unused except here, so expect the default initial delay of 2000 ms unless set by the user to remain constant.
`void` | `setSlowStartGrowthRateFactor(int factor)`
`void` | `setWindowSize(int numMsgs)`
`String` | `toString()`
`void` | `updateRTT(int measuredValue)`

Methods inherited from class net.i2p.client.streaming.I2PSocketOptionsImpl
`getConnectTimeout, getInt, getMaxBufferSize, getReadTimeout, getWriteTimeout, setConnectTimeout, setMaxBufferSize, setReadTimeout, setWriteTimeout`

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

Field Detail

### PROFILE_BULK

    public static final int PROFILE_BULK

See Also:
  Constant Field Values

### PROFILE_INTERACTIVE

    public static final int PROFILE_INTERACTIVE

See Also:
  Constant Field Values

### INACTIVITY_ACTION_NOOP

    public static final int INACTIVITY_ACTION_NOOP

  on inactivity timeout, do nothing

  See Also:
    Constant Field Values

### INACTIVITY_ACTION_DISCONNECT

    public static final int INACTIVITY_ACTION_DISCONNECT

  on inactivity timeout, close the connection

  See Also:
    Constant Field Values

### INACTIVITY_ACTION_SEND

    public static final int INACTIVITY_ACTION_SEND

  on inactivity timeout, send a payload message

  See Also:
    Constant Field Values

### PROP_CONNECT_DELAY

    public static final String PROP_CONNECT_DELAY

See Also:
  Constant Field Values

### PROP_PROFILE

    public static final String PROP_PROFILE

See Also:
  Constant Field Values

### PROP_MAX_MESSAGE_SIZE

    public static final String PROP_MAX_MESSAGE_SIZE

See Also:
  Constant Field Values

### PROP_MAX_RESENDS

    public static final String PROP_MAX_RESENDS

See Also:
  Constant Field Values

### PROP_INITIAL_RTT

    public static final String PROP_INITIAL_RTT

See Also:
  Constant Field Values

### PROP_INITIAL_RESEND_DELAY

    public static final String PROP_INITIAL_RESEND_DELAY

See Also:
  Constant Field Values

### PROP_INITIAL_ACK_DELAY

    public static final String PROP_INITIAL_ACK_DELAY

See Also:
  Constant Field Values

### PROP_INITIAL_WINDOW_SIZE

    public static final String PROP_INITIAL_WINDOW_SIZE

See Also:
  Constant Field Values

### PROP_INITIAL_RECEIVE_WINDOW

    public static final String PROP_INITIAL_RECEIVE_WINDOW

  unused

  See Also:
    Constant Field Values

### PROP_INACTIVITY_TIMEOUT

    public static final String PROP_INACTIVITY_TIMEOUT

See Also:
  Constant Field Values

### PROP_INACTIVITY_ACTION

    public static final String PROP_INACTIVITY_ACTION

See Also:
  Constant Field Values

### PROP_MAX_WINDOW_SIZE

    public static final String PROP_MAX_WINDOW_SIZE

See Also:
  Constant Field Values

### PROP_CONGESTION_AVOIDANCE_GROWTH_RATE_FACTOR

    public static final String PROP_CONGESTION_AVOIDANCE_GROWTH_RATE_FACTOR

See Also:
  Constant Field Values

### PROP_SLOW_START_GROWTH_RATE_FACTOR

    public static final String PROP_SLOW_START_GROWTH_RATE_FACTOR

See Also:
  Constant Field Values

### PROP_ANSWER_PINGS

    public static final String PROP_ANSWER_PINGS

See Also:
  Constant Field Values

### PROP_ENABLE_ACCESS_LIST

    public static final String PROP_ENABLE_ACCESS_LIST

  all of these are @since 0.7.13

  See Also:
    Constant Field Values

### PROP_ENABLE_BLACKLIST

    public static final String PROP_ENABLE_BLACKLIST

See Also:
  Constant Field Values

### PROP_ACCESS_LIST

    public static final String PROP_ACCESS_LIST

See Also:
  Constant Field Values

### PROP_MAX_CONNS_MIN

    public static final String PROP_MAX_CONNS_MIN

  all of these are @since 0.7.14

  See Also:
    Constant Field Values

### PROP_MAX_CONNS_HOUR

    public static final String PROP_MAX_CONNS_HOUR

See Also:
  Constant Field Values

### PROP_MAX_CONNS_DAY

    public static final String PROP_MAX_CONNS_DAY

See Also:
  Constant Field Values

### PROP_MAX_TOTAL_CONNS_MIN

    public static final String PROP_MAX_TOTAL_CONNS_MIN

See Also:
  Constant Field Values

### PROP_MAX_TOTAL_CONNS_HOUR

    public static final String PROP_MAX_TOTAL_CONNS_HOUR

See Also:
  Constant Field Values

### PROP_MAX_TOTAL_CONNS_DAY

    public static final String PROP_MAX_TOTAL_CONNS_DAY

See Also:
  Constant Field Values

### INITIAL_WINDOW_SIZE

    static final int INITIAL_WINDOW_SIZE

See Also:
  Constant Field Values

### DEFAULT_MAX_SENDS

    static final int DEFAULT_MAX_SENDS

See Also:
  Constant Field Values

### DEFAULT_INITIAL_RTT

    public static final int DEFAULT_INITIAL_RTT

See Also:
  Constant Field Values

### DEFAULT_INITIAL_ACK_DELAY

    public static final int DEFAULT_INITIAL_ACK_DELAY

See Also:
  Constant Field Values

### MIN_WINDOW_SIZE

    static final int MIN_WINDOW_SIZE

See Also:
  Constant Field Values

### DEFAULT_MAX_MESSAGE_SIZE

    public static final int DEFAULT_MAX_MESSAGE_SIZE

  OK, here is the calculation on the message size to fit in a single tunnel message without fragmentation. This is based on documentation, the code, and logging, however there are still some parts that could use more research. 1024 Tunnel Message - 21 Header (see router/tunnel/BatchedPreprocessor.java) ----- 1003 Tunnel Payload - 39 Unfragmented instructions (see router/tunnel/TrivialPreprocessor.java) ----- 964 Unfragmented I2NP Message - 20 ?? ----- 944 Garlic Message padded to 16 bytes - 0 Pad to 16 bytes (why?) ----- 944 Garlic Message (assumes no bundled leaseSet or keys) - 71 Garlic overhead ----- 873 Tunnel Data Message - 84 ?? ----- 789 Gzipped I2NP message - 23 Gzip 10 byte header, 5 byte block header, 8 byte trailer (yes we always use gzip, but it probably isn't really compressing, just adding the headers and trailer, since HTTP Server already compresses, and most P2P files aren't compressible. (see client/I2PSessionImpl2.java, util/ReusableGZipOutputStream.java, and the gzip and deflate specs) ----- 766 - 28 Streaming header (24 min, but leave room for a nack or other optional things) (See Packet.java) ----- 738 Streaming message size FOR TWO TUNNEL MESSAGES: 2048 2 Tunnel Messages - 42 2 Headers ----- 2006 Tunnel Payload - 50 Fragmented instructions (43 for first + 7 for second) ----- 1956 Unfragmented I2NP Message - 20 ?? ----- 1936 Garlic Message padded to 16 bytes 1936 - 0 Pad to 16 bytes ----- 1936 Garlic Message - 71 Garlic overhead ----- 1865 Tunnel Data Message - 84 ?? ----- 1781 Gzipped I2NP message - 23 Gzip header ----- 1758 - 28 Streaming header ----- 1730 Streaming message size to fit in 2 tunnel messages Similarly: 3 msgs: 2722 4 msgs: 3714 Before release 0.6.1.14 this was 4096. From release 0.6.1.14 through release 0.6.4, this was 960. It was claimed in the comment that this fit in a single tunnel message (and the checkin comment says the goal was to increase reliability at the expense of throughput), clearly from the math above that was not correct. (Before 0.6.2, the reply leaseSet was bundled with every message, so it didn't even fit in TWO tunnel messages - more like 2 1/3) Now, it's not clear how often we will get the ideal situation (no reply leaseSet bundling, no key bundling, and especially not having a small message ahead of you, which will then cause fragmentation for all subsequent messages until the queue is emptied - BatchedPreprocessor doesn't do reordering, and it isn't clear to me if it could). In particular the initial messages in a new stream are much larger due to the leaseSet and key bundling. But for long-lived streams (like with i2psnark) this should pay dividends. The tunnel.batch* stats should provide some data for test comparisons. As MTU and MRU are identical and are negotiated to the lowest value for the two ends, you can't do widespread testing of a higher value. Unless we change to allow MTU and MRU to be different, which would be a pain because it would mess up our buffer scheme. Both 738 and 1730 have been tested to verify that the math above is correct. So let's try 1730 for release 0.6.5. This will allow for 738 testing as well, with i2p.streaming.maxMessageSize=738 (in configadvanced.jsp, or in i2ptunnel, or i2psnark, for example). Not that an isolated single packet is very common, but in this case, 960 was 113.3% total overhead. Compared to 738 (38.8% overhead) and 1730 (18.4%).

  See Also:
    Constant Field Values

### MIN_MESSAGE_SIZE

    public static final int MIN_MESSAGE_SIZE

See Also:
  Constant Field Values

Constructor Detail

### ConnectionOptions

    public ConnectionOptions()

### ConnectionOptions

    public ConnectionOptions(Properties opts)

### ConnectionOptions

    public ConnectionOptions(I2PSocketOptions opts)

### ConnectionOptions

    public ConnectionOptions(ConnectionOptions opts)

Method Detail

### init

    protected void init(Properties opts)

  Overrides:
    `init` in class `I2PSocketOptionsImpl`

### setProperties

    public void setProperties(Properties opts)

  Overrides:
    `setProperties` in class `I2PSocketOptionsImpl`

### getConnectDelay

    public int getConnectDelay()

  how long will we wait after instantiating a new con before actually attempting to connect. If this is set to 0, connect ASAP. If it is greater than 0, wait until the output stream is flushed, the buffer fills, or that many milliseconds pass.

  Returns:
    how long to wait before actually attempting to connect

### setConnectDelay

    public void setConnectDelay(int delayMs)

### getRequireFullySigned

    public boolean getRequireFullySigned()

  Do we want all packets in both directions to be signed, or can we deal with signatures on the SYN and FIN packets only? There is no property name defined for this, so it's safe to say this is unused and always false.

  Returns:
    if we want signatures on all packets.

### setRequireFullySigned

    public void setRequireFullySigned(boolean sign)

  unused, see above

### getAnswerPings

    public boolean getAnswerPings()

  Do we respond to a ping?

  Returns:
    if we do

### setAnswerPings

    public void setAnswerPings(boolean yes)

### getWindowSize

    public int getWindowSize()

  How many messages will we send before waiting for an ACK?

  Returns:
    Maximum amount of messages that can be in-flight

### setWindowSize

    public void setWindowSize(int numMsgs)

### getReceiveWindow

    public int getReceiveWindow()

  Deprecated. This doesn't appear to be used.

  after how many consecutive messages should we ack?

  Returns:
    receive window size.

### setReceiveWindow

    public void setReceiveWindow(int numMsgs)

### getRTT

    public int getRTT()

  What to set the round trip time estimate to (in milliseconds)

  Returns:
    round trip time estimate in ms

### setRTT

    public void setRTT(int ms)

### getRTO

    public int getRTO()

### getRTTDev

    int getRTTDev()

  for debugging @since 0.7.13

### getRTTTrend

    public int getRTTTrend()

  If we have 3 consecutive rtt increases, we are trending upwards (1), or if we have 3 consecutive rtt decreases, we are trending downwards (-1), else we're stable.

  Returns:
    positive/flat/negative trend in round trip time

### updateRTT

    public void updateRTT(int measuredValue)

### getResendDelay

    public int getResendDelay()

  How long after sending a packet will we wait before resending?

  Returns:
    delay for a retransmission in ms

### setResendDelay

    public void setResendDelay(int ms)

### getSendAckDelay

    public int getSendAckDelay()

  if there are packets we haven't ACKed yet and we don't receive _receiveWindow messages before (_lastSendTime+_sendAckDelay), send an ACK of what we have received so far.

  Returns:
    ACK delay in ms

### setSendAckDelay

    public void setSendAckDelay(int delayMs)

  Unused except here, so expect the default initial delay of 2000 ms unless set by the user to remain constant.

### getMaxMessageSize

    public int getMaxMessageSize()

  What is the largest message we want to send or receive?

  Returns:
    Maximum message size (MTU/MRU)

### setMaxMessageSize

    public void setMaxMessageSize(int bytes)

### getChoke

    public int getChoke()

  how long we want to wait before any data is transferred on the connection in either direction

  Returns:
    how long to wait before any data is transferred in either direction in ms

### setChoke

    public void setChoke(int ms)

### getProfile

    public int getProfile()

  What profile do we want to use for this connection? TODO: Only bulk is supported so far.

  Returns:
    the profile of the connection.

### setProfile

    public void setProfile(int profile)

### getMaxResends

    public int getMaxResends()

  How many times will we try to send a message before giving up?

  Returns:
    Maximum retrys before failing a sent message.

### setMaxResends

    public void setMaxResends(int numSends)

### getInactivityTimeout

    public int getInactivityTimeout()

  What period of inactivity qualifies as "too long"?

  Returns:
    period of inactivity qualifies as "too long"

### setInactivityTimeout

    public void setInactivityTimeout(int timeout)

### getInactivityAction

    public int getInactivityAction()

### setInactivityAction

    public void setInactivityAction(int action)

### getMaxWindowSize

    public int getMaxWindowSize()

### setMaxWindowSize

    public void setMaxWindowSize(int msgs)

### getInboundBufferSize

    public int getInboundBufferSize()

  how much data are we willing to accept in our buffer?

  Returns:
    size of the buffer used to accept data

### setInboundBufferSize

    public void setInboundBufferSize(int bytes)

### getCongestionAvoidanceGrowthRateFactor

    public int getCongestionAvoidanceGrowthRateFactor()

  When we're in congestion avoidance, we grow the window size at the rate of 1/(windowSize*factor). In standard TCP, window sizes are in bytes, while in I2P, window sizes are in messages, so setting factor=maxMessageSize mimics TCP, but using a smaller factor helps grow a little more rapidly.

  Returns:
    window size to grow by to attempt to avoid congestion.

### setCongestionAvoidanceGrowthRateFactor

    public void setCongestionAvoidanceGrowthRateFactor(int factor)

### getSlowStartGrowthRateFactor

    public int getSlowStartGrowthRateFactor()

  When we're in slow start, we grow the window size at the rate of 1/(factor). In standard TCP, window sizes are in bytes, while in I2P, window sizes are in messages, so setting factor=maxMessageSize mimics TCP, but using a smaller factor helps grow a little more rapidly.

  Returns:
    slow start window size to grow by to attempt to avoid sending many small packets.

### setSlowStartGrowthRateFactor

    public void setSlowStartGrowthRateFactor(int factor)

### getMaxConnsPerMinute

    public int getMaxConnsPerMinute()

  all of these are @since 0.7.14; no public setters

### getMaxConnsPerHour

    public int getMaxConnsPerHour()

### getMaxConnsPerDay

    public int getMaxConnsPerDay()

### getMaxTotalConnsPerMinute

    public int getMaxTotalConnsPerMinute()

### getMaxTotalConnsPerHour

    public int getMaxTotalConnsPerHour()

### getMaxTotalConnsPerDay

    public int getMaxTotalConnsPerDay()

### isAccessListEnabled

    public boolean isAccessListEnabled()

### isBlacklistEnabled

    public boolean isBlacklistEnabled()

### getAccessList

    public Set<Hash> getAccessList()

### getBlacklist

    public Set<Hash> getBlacklist()

### toString

    public String toString()

  Overrides:
    `toString` in class `Object`

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD