Method Details

• tryAcquireConnPermit

  private static boolean tryAcquireConnPermit(Hash dest)

  Try to acquire a concurrent-connection permit for dest. The acquire is a per-key atomic remap on _activeConns: on rejection the map value is left untouched at the limit (never a sentinel), so the count can never be corrupted by writes of -1/0 and over-admission is impossible even under heavy parallel load.

  Parameters:

  dest - the destination to take a permit for, null always acquires

  Returns:

  true if the permit was acquired, false if the destination is at its connection limit

• releaseConnPermit

  private static void releaseConnPermit(Hash dest)

  Release a concurrent-connection permit for dest. Per-key atomic remap: the entry is removed from _activeConns exactly when the count reaches zero, so the map cannot grow without bound over the lifetime of the process. Safe to call with null or when the count is already zero (underflow-guarded).

  Parameters:

  dest - the destination to release one permit for, null does nothing

• executeTask

  private void executeTask(Thread task)

  Execute a runnable task inline.

  Parameters:

  task - Thread task to execute

• getDefaultOptions

  protected I2PSocketOptions getDefaultOptions()

  Create the default options (using the default timeout, etc). Warning, this does not make a copy of I2PTunnel's client options, it modifies them directly.

  Overrides:

  getDefaultOptions in class I2PTunnelClientBase

  Returns:

  the default options

• getDefaultOptions

  protected I2PSocketOptions getDefaultOptions(Properties overrides)

  Create the default options (using the default timeout, etc). Warning, this does not make a copy of I2PTunnel's client options, it modifies them directly. Do not use overrides for per-socket options.

  Overrides:

  getDefaultOptions in class I2PTunnelClientBase

  Parameters:

  overrides - the properties to override

  Returns:

  the default options

• startRunning

  public void startRunning()

  Actually start working on incoming connections. Overridden to start an internal socket too.

  Overrides:

  startRunning in class I2PTunnelClientBase

• close

  public boolean close(boolean forced)

  Overridden to close internal socket too.

  Overrides:

  close in class I2PTunnelClientBase

  Parameters:

  forced - true to interrupt an in-progress build, false to close gracefully

  Returns:

  true if the tunnel is closed, or false if connections were still active and the close was refused

• getRealm

  protected String getRealm()

  Authentication realm for the proxy.

  Specified by:

  getRealm in class I2PTunnelHTTPClientBase

  Returns:

  realm string

• writeErrorPage

  private void writeErrorPage(OutputStream out, I2PTunnelHTTPClient.InputReader reader, String page, String body)

  Write an error page and drain any remaining request data.

  Parameters:

  out - the output stream

  reader - reads the browser's request data

  page - the error page type

  body - the error body

• clientConnectionRun

  protected void clientConnectionRun(Socket s)

  Note: This does not handle RFC 2616 header line splitting, which is obsoleted in RFC 7230.

  Specified by:

  clientConnectionRun in class I2PTunnelClientBase

  Parameters:

  s - the socket to manage

• writeServiceUnavailable

  static void writeServiceUnavailable(OutputStream out, String message)

  Write a minimal 503 response and close the connection. The socket close in the caller's finally block flushes the response.

  Parameters:

  out - the output stream for the error response

  message - the reason, or null

• isBrowserPeerClosed

  static boolean isBrowserPeerClosed(Socket s, I2PTunnelHTTPClient.InputReader reader, String method)

  Probe whether the browser peer has closed while we wait on I2P connect. Only meaningful for GET/HEAD (no request body still unread). A timed read returns -1 on FIN (peer closed), times out when still open, or yields a pipelined byte which is pushed back so it is not lost.

  Parameters:

  s - the browser-facing socket, which may be null

  reader - the request reader wrapping a PushbackInputStream

  method - HTTP method, or null

  Returns:

  true if the peer has closed (or the socket is unusable)

• cancelWarmSlot

  static void cancelWarmSlot(I2PTunnelHTTPClient.WarmSlot slot)

  Retire a request's warm slot: closes an installed socket, releases the permit the slot still holds, and rejects an attempt still in flight (its thread releases the lease when the install is refused). Idempotent and null-safe. Called from per-iteration cleanup and the request's finally block, where either may already have run.

  Parameters:

  slot - the warm slot to retire, or null

• openSpeculativeWarm

  private void openSpeculativeWarm(Destination dest, int port, int emptyBudget, long requestId, I2PTunnelHTTPClient.WarmSlot slot)

  Open one secondary I2P socket in the background while the primary is healthy. Fail-open: if the slot is not idle, the per-dest permit is unavailable, or the connect fails, no warm socket is installed and resume falls back to a cold open. Skipped when I2PTunnelClientBase.poolIsDefinitivelyDown() so a dead outbound pool does not accumulate speculative connect storms. The attempt is tagged with the slot's generation, so a completion that races teardown is refused and its permit released by this thread instead of leaking.

  Parameters:

  dest - the destination to warm; its hash keys the per-dest connection permit

  port - remote port (0 = default)

  emptyBudget - connect attempt budget for the secondary

  requestId - logging prefix id

  slot - request-scoped warm slot, or null

• openEmptyReconnect

  private I2PSocket openEmptyReconnect(Destination dest, int port, int emptyBudget, long requestId, boolean quiet)

  Open a single fresh I2P socket for an empty-response / body-resume reconnect, with the standard attempt budget and dead-pool fail-fast. Shared by the reconnect() and reconnectPair() legs of the callback so both paths get identical backoff and stop conditions.

  Parameters:

  dest - the destination to open the fresh socket to

  port - remote port (0 = default)

  emptyBudget - max connect attempts for this request

  requestId - logging prefix id

  quiet - when true, suppress per-attempt Info logs (used for the staggered first race leg so the second leg's log is the pair marker)

  Returns:

  a connected socket, or null if the budget / dead pool stopped us

• closeQuietly

  private static void closeQuietly(I2PSocket sock)

  Closes a socket, ignoring any error.

  Parameters:

  sock - the socket to close, may be null

• sleepQuietly

  static boolean sleepQuietly(long delayMs)

  Sleep for the given delay, restoring the interrupt flag if interrupted.

  Parameters:

  delayMs - the delay in ms

  Returns:

  false if the current thread was interrupted during the sleep

• parseEmptyRetries

  static int parseEmptyRetries(String value)

  Parse the empty-response retry count from a client option value.

  Clamps to >= 0; malformed or negative input falls back to 0. Pure decision — no context access, safe for unit tests.

  Parameters:

  value - the raw property value, may be null

  Returns:

  the retry count: 0 (never retry) on null, empty, or unparseable input

• scaledEmptyReconnectBudget

  static int scaledEmptyReconnectBudget(int baseBudget, long contentLength)

  Scale the reconnect attempt budget by the entity size already verified from this exchange's Content-Length header.

  Body-resume reconnects run after response headers have arrived, so the size is known and verifiable; the budget gains one attempt per I2PTunnelRunner.RETRY_RAMP_UNIT_BYTES of entity, capped at 9x the configured budget so a large file cannot pin the runner across an unbounded connect-retry marathon. The 9x cap saturates at the same entity size as the original 3x cap at 4MB granularity (8MB per base attempt). Unknown length (empty-response retry with no headers, or a sub-1MB entity) returns the base budget unchanged. Pure decision — no context access, safe for unit tests.

  Parameters:

  baseBudget - configured attempt budget for this request

  contentLength - entity Content-Length in bytes, or -1 if unknown

  Returns:

  the scaled attempt budget; never below 0

• getConnectRetryDelayMs

  static long getConnectRetryDelayMs(int attempt)

  Exponential backoff delay (in ms) before the given connect retry. The first retry waits I2P_CONNECT_RETRY_BASE_DELAY (1s), doubling per attempt up to a hard cap of 8s. During a tunnel-pool stall the capped backoff gives the pool time to recover instead of hammering it every 2s, and it still fails fast once I2PTunnelClientBase.poolIsDefinitivelyDown() trips. Pure decision — no context access, safe for unit tests.

  Parameters:

  attempt - the 1-based connect failure count (how many failures so far)

  Returns:

  the delay in ms: 0 for attempt <= 0, else 1000 << (attempt-1) bounded to 8000

• shouldStopEmptyReconnect

  static boolean shouldStopEmptyReconnect(int poolState)

  Whether the empty-response reconnect loop should stop instead of trying again. A connect attempt that just failed should not be re-driven when the client outbound pool is provably dead (poolState == -1): no further attempt can succeed, so retrying only stalls the browser for the full backoff budget (~39s at the default 9 attempts) and adds load to a mesh already failing to build replacement tunnels. Budget exhaustion is handled separately by the loop's exit condition, so this method only answers the "should we bail early on a dead pool" question.

  A poolState == -2 (unknown: standalone client, or the reflective check failed) deliberately does NOT fail fast — there is no live router pool to observe, so the budget is the only sane bound. Mirroring the initial-connect guard's <= -1 test here would make standalone clients (outproxy, no router) abort every empty-response retry because they always read -2.

  Parameters:

  poolState - the I2PTunnelClientBase.poolState() value from the last failed attempt

  Returns:

  true to stop retrying (fail to the normal empty-response error path)

• writeHelperSaveForm

  private void writeHelperSaveForm(OutputStream outs, String destination, String ahelperKey, String targetRequest, String referer) throws IOException

  Write the HTML form that prompts the user to save an address helper destination.

  Parameters:

  outs - the stream to write the page to, does nothing if null

  destination - the hostname echoed into the hidden form field, the page text, and the IDN-decoded lookup

  ahelperKey - the base64 destination from the naming service, shown and embedded in the save forms

  targetRequest - the original request URL, the action of the continue-without-saving form

  referer - the referring URL for a hidden field, null if none was sent

  Throws:

  IOException - if writing the page to the output stream fails

• writeB32SaveForm

  private void writeB32SaveForm(OutputStream outs, String destination, int code, String targetRequest) throws IOException

  Write the HTML form that prompts the user to supply decryption/authentication data.

  Parameters:

  outs - the stream to write the page to, does nothing if null

  destination - the base32 address whose lookup needs more data

  code - the lookup result code naming what is required

  targetRequest - the original request URL, the action of the supplied form

  Throws:

  IOException - if writing the page to the output stream fails

• getHostName

  private String getHostName(String host)

  The hostname of the given host.

  Parameters:

  host - the requested hostname, null yields null

  Returns:

  b32hash.b32.i2p, or "i2p" on lookup failure. Prior to 0.7.12, returned b64 key

• isSupportedAddress

  private static boolean isSupportedAddress(String protocol)

  Checks whether the tunnel type serves this protocol.

  Parameters:

  protocol - the request protocol

  Returns:

  true if the address type is supported

• fixupURI

  static URI fixupURI(String request) throws URISyntaxException

  Fix up a URI whose path or query holds characters that RFC 3986 reserves but that browsers send unescaped: '[', ']', '|', '{' and '}'.

  The scheme, host and port are left untouched, so a fixup cannot move the request to a different host.

  Parameters:

  request - the raw URI string from the request line

  Returns:

  the URI, percent-escaped if a fixup was required

  Throws:

  URISyntaxException - if the URI is invalid even after fixup

• changeURI

  private static URI changeURI(URI uri, String host, int port, String path) throws URISyntaxException

  Change various parts of the URI. String parameters are all non-encoded.

  Scheme always preserved. Userinfo always cleared. Host changed if non-null. Port changed if non-zero. Path changed if non-null. Query always preserved. Fragment always cleared.

  Parameters:

  uri - the URI to rebuild

  host - the new host, null keeps the original

  port - the new port, 0 keeps the original

  path - the new path, null keeps the original

  Returns:

  the rebuilt URI

  Throws:

  URISyntaxException - if the replaced parts do not form a valid URI

• replaceQuery

  private static URI replaceQuery(URI uri, String query) throws URISyntaxException

  Replace query in the URI. Userinfo cleared if uri contained a query. Fragment cleared if uri contained a query.

  Parameters:

  uri - the URI whose query is replaced

  query - an ENCODED query, removed if null

  Returns:

  the URI carrying the new query, the original if it had none and none is given

  Throws:

  URISyntaxException - if the URI assembled from the parts is not valid

• removeHelper

  private static String[] removeHelper(String query)

  Remove the address helper from an encoded query.

  Parameters:

  query - an ENCODED query, removed if null

  Returns:

  rv[0] is ENCODED query with helper removed, non-null but possibly empty; rv[1] is DECODED helper value, non-null but possibly empty; rv null if no helper present

• lookupWithTimeout

  private Destination lookupWithTimeout(String hostname, long timeoutMs)

  Look up a hostname with a timeout to prevent blocking the request handler. Naming service lookups can block on NetDB searches or network fetches for minutes if the destination isn't cached locally.

  Parameters:

  hostname - the name passed to the naming service; may be an IDN or b32 address

  timeoutMs - maximum time to wait

  Returns:

  resolved Destination or null if lookup failed or timed out