NTCPTransport (Javadocs [I2P+ 2.13.0+]

java.lang.Object
- net.i2p.router.transport.TransportImpl
- - net.i2p.router.transport.ntcp.NTCPTransport

All Implemented Interfaces:
Transport
```
public class NTCPTransport
extends TransportImpl
```
Non-blocking TCP (NTCP) transport implementation for I2P. This class provides the primary TCP-based transport for I2P communication using Java NIO for non-blocking I/O operations. It supports both NTCP 1 and NTCP 2 protocols with advanced features like connection pooling, bandwidth management, and sophisticated peer management. Protocol Features:
- NTCP 1: Basic encrypted TCP transport
- NTCP 2: Enhanced protocol with improved efficiency
- Configurable bandwidth limits and throttling
- Connection pooling and reuse
- IPv4 and IPv6 support
- Automatic protocol negotiation
Architecture:
- Non-blocking I/O with NIO channels
- Separate reader and writer threads
- Event-driven message processing
- Connection state machines for establishment
- Peer reputation and cost-based routing
Connection Management:
- Multiple bid tiers (fast, slow, high-cost)
- Connection pooling and reuse
- Automatic failover and retry logic
- Peer blacklisting and banlist support

Nested Class Summary
- Nested classes/interfaces inherited from interface net.i2p.router.transport.Transport
  Transport.AddressSource

Field Summary

Fields
Modifier and Type	Field and Description
`(package private) static int`	`ESTABLISH_TIMEOUT` how long from initial connection attempt (accept() or connect()) until the con must be established to avoid premature close()ing.
`static String`	`MIN_SIGTYPE_VERSION` RI sigtypes supported in 0.9.16
`(package private) static int`	`NTCP2_INT_VERSION` N t c p2 i n t v e r s i o n
`(package private) static String`	`NTCP2_VERSION` "2"
`(package private) static String`	`NTCP2_VERSION_ALT` "2,"
`(package private) static int`	`PQ_INT_VERSION` 0 to disable, or 3/4/5 for enctypes 5/6/7
`(package private) static String`	`PQ_VERSION` P q v e r s i o n
`static String`	`PROP_BIND_INTERFACE` this is rarely if ever used, default is to bind to wildcard address
`static String`	`PROP_I2NP_NTCP_AUTO_IP` PROP_I2NP_NTCP_AUTO_IP.
`static String`	`PROP_I2NP_NTCP_AUTO_PORT` PROP_I2NP_NTCP_AUTO_PORT.
`static String`	`PROP_I2NP_NTCP_HOSTNAME` PROP_I2NP_NTCP_HOSTNAME.
`static String`	`PROP_I2NP_NTCP_PORT` PROP_I2NP_NTCP_PORT.
`static String`	`PROP_NTCP2_IV` b64 static IV
`static String`	`PROP_NTCP2_SP` b64 static private key
`static String`	`STYLE` STYLE.
`static String`	`STYLE2` STYLE2.

Fields inherited from class net.i2p.router.transport.TransportImpl
_context, ADJUST_COST, CAP_IPV4, CAP_IPV4_IPV6, CAP_IPV6, CONGESTION_COST_ADJUSTMENT, PROP_BOOST_CONNECTION_LIMITS, PROP_IPV6_FIREWALLED

Constructor Summary
Constructors
Constructor and Description
NTCPTransport(RouterContext ctx, X25519KeyFactory xdh)

Constructors
Constructor and Description
`NTCPTransport(RouterContext ctx, X25519KeyFactory xdh)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`adjustReaderThreads()` Adjust reader threads to match configured count.
`void`	`adjustSendFinisherThreads(int threads)` Adjusts the send finisher thread count for the running pool.
`void`	`adjustWriterThreads()` Adjust writer threads to match configured count.
`void`	`afterSend(OutNetMessage msg, boolean sendSuccessful, boolean allowRequeue, long msToSend)` afterSend.
`boolean`	`allowConnection()` allowConnection.
`TransportBid`	`bid(RouterInfo toAddress, int dataSize)` bid.
`int`	`countActivePeers()` How many peers have we talked to in the last minute? As of 0.9.20, actually returns active peer count, not total.
`int`	`countActiveSendPeers()` How many peers are we actively sending messages to (this minute)
`int`	`countPeers()` countPeers.
`(package private) void`	`establishing(NTCPConnection con)` add us to the establishment timeout process
`(package private) void`	`expireTimedOut()` called in the EventPumper no more than once a second or so, closing any unconnected/unestablished connections
`void`	`externalAddressReceived(Transport.AddressSource source, byte[] ip, int port)` UDP changed addresses, tell NTCP and (possibly) restart
`void`	`externalAddressRemoved(Transport.AddressSource source, boolean ipv6)` Notify a transport of an external address change.
`void`	`forceDisconnect(Hash peer)` Tell the transport to disconnect from this peer.
`void`	`forceDisconnect(Hash peer, String reason)` Tell the transport to disconnect from this peer with a reason for logging.
`void`	`forwardPortStatus(byte[] ip, int port, int externalPort, boolean success, String reason)` If we didn't used to be forwarded, and we have an address, and we are configured to use UPnP, update our RouterAddress Don't do anything now.
`String`	`getAltStyle()` Get the alternate supported style.
`List<Long>`	`getClockSkews()` Return our peer clock skews on this transport.
`List<Hash>`	`getEstablished()` Connected peers.
`static int`	`getEstablishTimeout()` Get the NTCP establish timeout in ms.
`static long`	`getFailsafeIterationFreq()` Get the failsafe iteration frequency in milliseconds
`(package private) byte[]`	`getNTCP2StaticIV()` The static IV
`(package private) byte[]`	`getNTCP2StaticPrivkey()` The static priv key
`(package private) byte[]`	`getNTCP2StaticPubkey()` The static priv key
`int[]`	`getPeerCounts()` Get peer counts by transport type and direction.
`Collection<NTCPConnection>`	`getPeers()` For /peers UI only.
`(package private) EventPumper`	`getPumper()` Hook for NTCPConnection
`CommSystemFacade.Status`	`getReachabilityStatus()` Maybe we should trust UPnP here and report OK if it opened the port, but for now we don't.
`(package private) Reader`	`getReader()` Hook for NTCPConnection
`double`	`getReaderUtilization()` Get reader pool utilization as a ratio (0.0-1.0).
`int`	`getRequestedPort()` What INTERNAL port would the transport like to have forwarded by UPnP.
`static long`	`getSelectorLoopDelay()` Get the selector loop delay in milliseconds
`static int`	`getSendFinisherMaxThreads()` Get the send finisher max threads
`static int`	`getSendFinisherQueueCapacity()` Get the send finisher queue capacity
`int`	`getSendFinisherQueueSize()` Returns the current send finisher queue depth.
`double`	`getSendFinisherUtilization()` Get send finisher pool utilization as a ratio (0.0-1.0).
`String`	`getStyle()` Get the transport style.
`(package private) Writer`	`getWriter()` Hook for NTCPConnection
`double`	`getWriterUtilization()` Get writer pool utilization as a ratio (0.0-1.0).
`(package private) X25519KeyFactory`	`getXDHFactory()`
`(package private) NTCPConnection`	`inboundEstablished(NTCPConnection con)` Registers a newly established inbound connection, replacing any existing connection for the same peer.
`boolean`	`isAlive()`
`boolean`	`isBacklogged(Hash dest)`
`boolean`	`isConnecting(Hash dest)` Check if a connection attempt is in progress for the given peer.
`boolean`	`isEstablished(Hash dest)`
`(package private) boolean`	`isHXHIValid(byte[] hxhi)` Incoming connection replay detection.
`void`	`mayDisconnect(Hash peer)` Tell the transport that we may disconnect from this peer.
`protected void`	`outboundMessageReady()` Processes the next outbound message by retrieving or creating a connection, preparing it for sending, and handling related failures or bans.
`(package private) NTCPConnection`	`removeCon(NTCPConnection con)`
`(package private) void`	`sendComplete(OutNetMessage msg)` queue up afterSend call, which can take some time w/ jobs, etc
`static void`	`setEstablishTimeout(int ms)` Set the NTCP establish timeout, bounded 1500-10000ms.
`static void`	`setFailsafeIterationFreq(long ms)` Set the failsafe iteration frequency, bounded by MIN-MAX
`(package private) void`	`setLastBadSkew(long skew)` A positive number means our clock is ahead of theirs.
`static void`	`setSelectorLoopDelay(long ms)` Set the selector loop delay, bounded 1-100ms
`static void`	`setSendFinisherMaxThreads(int threads)` Set the send finisher max threads
`static void`	`setSendFinisherQueueCapacity(int capacity)` Set the send finisher queue capacity
`void`	`startListening()` Starts the NTCP transport listening process, ensuring only one pumper is running by checking existing state since the caller may not stop the transport correctly.
`void`	`stopListening()` This doesn't (completely) block, caller should check isAlive() before calling startListening() or restartListening()

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

- Field Detail
  - ESTABLISH_TIMEOUT
```
static volatile int ESTABLISH_TIMEOUT
```
    how long from initial connection attempt (accept() or connect()) until the con must be established to avoid premature close()ing. Tuned to ~3-5x average establish time; the Tuner further adjusts this at runtime.
  - MIN_SIGTYPE_VERSION
```
public static final String MIN_SIGTYPE_VERSION
```
    RI sigtypes supported in 0.9.16
    See Also:
    Constant Field Values
  - NTCP2_INT_VERSION
```
static final int NTCP2_INT_VERSION
```
    N t c p2 i n t v e r s i o n
    See Also:
    Constant Field Values
  - NTCP2_VERSION
```
static final String NTCP2_VERSION
```
    "2"
  - NTCP2_VERSION_ALT
```
static final String NTCP2_VERSION_ALT
```
    "2,"
  - PQ_INT_VERSION
```
static final int PQ_INT_VERSION
```
    0 to disable, or 3/4/5 for enctypes 5/6/7
    See Also:
    Constant Field Values
  - PQ_VERSION
```
static final String PQ_VERSION
```
    P q v e r s i o n
  - PROP_BIND_INTERFACE
```
public static final String PROP_BIND_INTERFACE
```
    this is rarely if ever used, default is to bind to wildcard address
    See Also:
    Constant Field Values
  - PROP_I2NP_NTCP_AUTO_IP
```
public static final String PROP_I2NP_NTCP_AUTO_IP
```
    PROP_I2NP_NTCP_AUTO_IP.
    See Also:
    Constant Field Values
  - PROP_I2NP_NTCP_AUTO_PORT
```
public static final String PROP_I2NP_NTCP_AUTO_PORT
```
    PROP_I2NP_NTCP_AUTO_PORT.
    See Also:
    Constant Field Values
  - PROP_I2NP_NTCP_HOSTNAME
```
public static final String PROP_I2NP_NTCP_HOSTNAME
```
    PROP_I2NP_NTCP_HOSTNAME.
    See Also:
    Constant Field Values
  - PROP_I2NP_NTCP_PORT
```
public static final String PROP_I2NP_NTCP_PORT
```
    PROP_I2NP_NTCP_PORT.
    See Also:
    Constant Field Values
  - PROP_NTCP2_IV
```
public static final String PROP_NTCP2_IV
```
    b64 static IV
    See Also:
    Constant Field Values
  - PROP_NTCP2_SP
```
public static final String PROP_NTCP2_SP
```
    b64 static private key
    See Also:
    Constant Field Values
  - STYLE
```
public static final String STYLE
```
    STYLE.
    See Also:
    Constant Field Values
  - STYLE2
```
public static final String STYLE2
```
    STYLE2.
    See Also:
    Constant Field Values
- Constructor Detail
  - NTCPTransport
```
public NTCPTransport(RouterContext ctx,
                     X25519KeyFactory xdh)
```
    Parameters:
    ctx - the router context
    xdh - null to disable NTCP2
- Method Detail
  - adjustReaderThreads
```
public void adjustReaderThreads()
```
    Adjust reader threads to match configured count.
  - adjustSendFinisherThreads
```
public void adjustSendFinisherThreads(int threads)
```
    Adjusts the send finisher thread count for the running pool.
    Parameters:
    threads - new thread count (core and max)
  - adjustWriterThreads
```
public void adjustWriterThreads()
```
    Adjust writer threads to match configured count.
  - afterSend
```
public void afterSend(OutNetMessage msg,
                      boolean sendSuccessful,
                      boolean allowRequeue,
                      long msToSend)
```
    afterSend.
    Overrides:
    afterSend in class TransportImpl
    Parameters:
    msg - message in question
    sendSuccessful - true if the peer received it
    allowRequeue - true if we should try other transports if available
    msToSend - how long it took to transfer the data to the peer
  - allowConnection
```
public boolean allowConnection()
```
    allowConnection.
  - bid
```
public TransportBid bid(RouterInfo toAddress,
                        int dataSize)
```
    bid.
    Parameters:
    toAddress - the target router's contact information
    dataSize - size of message payload, assumes full 16-byte header, transports should adjust as necessary for their overhead
    Returns:
    a TransportBid containing send details, or null if unwilling to send
  - countActivePeers
```
public int countActivePeers()
```
    How many peers have we talked to in the last minute? As of 0.9.20, actually returns active peer count, not total.
    Specified by:
    countActivePeers in interface Transport
    Specified by:
    countActivePeers in class TransportImpl
    Returns:
    the value
  - countActiveSendPeers
```
public int countActiveSendPeers()
```
    How many peers are we actively sending messages to (this minute)
    Returns:
    active send peer count
  - countPeers
```
public int countPeers()
```
    countPeers.
    Specified by:
    countPeers in interface Transport
    Specified by:
    countPeers in class TransportImpl
    Returns:
    peer count
  - establishing
```
void establishing(NTCPConnection con)
```
    add us to the establishment timeout process
  - expireTimedOut
```
void expireTimedOut()
```
    called in the EventPumper no more than once a second or so, closing any unconnected/unestablished connections
  - externalAddressReceived
```
public void externalAddressReceived(Transport.AddressSource source,
                                    byte[] ip,
                                    int port)
```
    UDP changed addresses, tell NTCP and (possibly) restart
    Specified by:
    externalAddressReceived in interface Transport
    Specified by:
    externalAddressReceived in class TransportImpl
    Parameters:
    ip - typ. IPv4 or IPv6 non-local; may be null to indicate IPv4 failure or port info only
    source - defined in Transport.java
    port - 0 for unknown or unchanged
  - externalAddressRemoved
```
public void externalAddressRemoved(Transport.AddressSource source,
                                   boolean ipv6)
```
    Notify a transport of an external address change. This may be from a local interface, UPnP, a config change, etc. This should not be called if the ip didn't change (from that source's point of view), or is a local address. May be called multiple times for IPv4 or IPv6. The transport should also do its own checking on whether to accept notifications from this source. This can be called after the transport is running.
    Specified by:
    externalAddressRemoved in interface Transport
    Overrides:
    externalAddressRemoved in class TransportImpl
    Parameters:
    source - defined in Transport.java
    ipv6 - true for IPv6, false for IPv4
  - forceDisconnect
```
public void forceDisconnect(Hash peer)
```
    Tell the transport to disconnect from this peer.
    Parameters:
    peer - hash of the peer to forcefully disconnect from
  - forceDisconnect
```
public void forceDisconnect(Hash peer,
                            String reason)
```
    Tell the transport to disconnect from this peer with a reason for logging.
    Parameters:
    peer - the peer
    reason - reason for disconnection (for logging), may be null
  - forwardPortStatus
```
public void forwardPortStatus(byte[] ip,
                              int port,
                              int externalPort,
                              boolean success,
                              String reason)
```
    If we didn't used to be forwarded, and we have an address, and we are configured to use UPnP, update our RouterAddress Don't do anything now. If it fails, we don't know if it's because there is no firewall, or if the firewall rejected the request. So we just use the SSU reachability status to decide whether to enable inbound NTCP. SSU will have CSFI build a new NTCP address when it transitions to OK.
    Specified by:
    forwardPortStatus in interface Transport
    Overrides:
    forwardPortStatus in class TransportImpl
    Parameters:
    ip - may be null
    port - the internal port
    externalPort - the external port, which for now should always be the same as the internal port if the forwarding was successful.
  - getAltStyle
```
public String getAltStyle()
```
    Get the alternate supported style.
    Overrides:
    getAltStyle in class TransportImpl
    Returns:
    "NTCP2" always
  - getClockSkews
```
public List<Long> getClockSkews()
```
    Return our peer clock skews on this transport. List composed of Long, each element representing a peer skew in seconds. A positive number means our clock is ahead of theirs.
    Specified by:
    getClockSkews in interface Transport
    Overrides:
    getClockSkews in class TransportImpl
    Returns:
    the clock skews
  - getEstablished
```
public List<Hash> getEstablished()
```
    Connected peers.
    Returns:
    a copy, modifiable
  - getEstablishTimeout
```
public static int getEstablishTimeout()
```
    Get the NTCP establish timeout in ms. @since 0.9.70+
  - getFailsafeIterationFreq
```
public static long getFailsafeIterationFreq()
```
    Get the failsafe iteration frequency in milliseconds
  - getNTCP2StaticIV
```
byte[] getNTCP2StaticIV()
```
    The static IV
  - getNTCP2StaticPrivkey
```
byte[] getNTCP2StaticPrivkey()
```
    The static priv key
  - getNTCP2StaticPubkey
```
byte[] getNTCP2StaticPubkey()
```
    The static priv key
  - getPeerCounts
```
public int[] getPeerCounts()
```
    Get peer counts by transport type and direction.
    Returns:
    8 bytes: version 1 4 bytes all zeros, version 2 ipv4 in/out, ipv6 in/out
  - getPeers
```
public Collection<NTCPConnection> getPeers()
```
    For /peers UI only. Not a public API, not for external use.
    Returns:
    not a copy, do not modify
  - getPumper
```
EventPumper getPumper()
```
    Hook for NTCPConnection
  - getReachabilityStatus
```
public CommSystemFacade.Status getReachabilityStatus()
```
    Maybe we should trust UPnP here and report OK if it opened the port, but for now we don't. Just go through and if we have one inbound connection, we must be good. As we drop idle connections pretty quickly, this will be fairly accurate. We have to be careful here because much of the router console code assumes that the reachability status is really just the UDP status. This only returns OK, DISABLED, or UNKNOWN for IPv4 and IPv6. We leave the FIREWALLED status for UDP. Previously returned short, now enum as of 0.9.20
    Specified by:
    getReachabilityStatus in interface Transport
    Specified by:
    getReachabilityStatus in class TransportImpl
    Returns:
    the reachability status
  - getReader
```
Reader getReader()
```
    Hook for NTCPConnection
  - getReaderUtilization
```
public double getReaderUtilization()
```
    Get reader pool utilization as a ratio (0.0-1.0). Returns NaN if not started.
    Returns:
    the reader utilization
  - getRequestedPort
```
public int getRequestedPort()
```
    Description copied from class: TransportImpl
    What INTERNAL port would the transport like to have forwarded by UPnP. This can't be passed via getCurrentAddress(), as we have to open the port before we can publish the address, and that's the external port anyway.
    Specified by:
    getRequestedPort in interface Transport
    Overrides:
    getRequestedPort in class TransportImpl
    Returns:
    current IPv4 port, else NTCP configured port, else -1 (but not UDP port if auto)
  - getSelectorLoopDelay
```
public static long getSelectorLoopDelay()
```
    Get the selector loop delay in milliseconds
  - getSendFinisherMaxThreads
```
public static int getSendFinisherMaxThreads()
```
    Get the send finisher max threads
  - getSendFinisherQueueCapacity
```
public static int getSendFinisherQueueCapacity()
```
    Get the send finisher queue capacity
  - getSendFinisherQueueSize
```
public int getSendFinisherQueueSize()
```
    Returns the current send finisher queue depth.
    Returns:
    pending tasks count
  - getSendFinisherUtilization
```
public double getSendFinisherUtilization()
```
    Get send finisher pool utilization as a ratio (0.0-1.0). Returns NaN if pool not started.
    Returns:
    the send finisher utilization
  - getStyle
```
public String getStyle()
```
    Get the transport style.
    Returns:
    always "NTCP"
  - getWriter
```
Writer getWriter()
```
    Hook for NTCPConnection
  - getWriterUtilization
```
public double getWriterUtilization()
```
    Get writer pool utilization as a ratio (0.0-1.0). Returns NaN if not started.
    Returns:
    the writer utilization
  - getXDHFactory
```
X25519KeyFactory getXDHFactory()
```
    Returns:
    null if not configured for NTCP2
  - inboundEstablished
```
NTCPConnection inboundEstablished(NTCPConnection con)
```
    Registers a newly established inbound connection, replacing any existing connection for the same peer. Updates reachability status and connection statistics.
    Parameters:
    con - The newly established NTCPConnection.
    Returns:
    The previous NTCPConnection to the same peer if one existed, or null otherwise.
  - isAlive
```
public boolean isAlive()
```
    Returns:
    whether alive
  - isBacklogged
```
public boolean isBacklogged(Hash dest)
```
    Specified by:
    isBacklogged in interface Transport
    Overrides:
    isBacklogged in class TransportImpl
    Parameters:
    dest - peer hash
    Returns:
    whether backlogged
  - isConnecting
```
public boolean isConnecting(Hash dest)
```
    Description copied from class: TransportImpl
    Check if a connection attempt is in progress for the given peer. Default returns false. NTCP2 and SSU2 transports that have an async handshake phase should override to report in-progress connections.
    Specified by:
    isConnecting in interface Transport
    Overrides:
    isConnecting in class TransportImpl
    Parameters:
    dest - hash of the peer to check
    Returns:
    whether connecting
  - isEstablished
```
public boolean isEstablished(Hash dest)
```
    Specified by:
    isEstablished in interface Transport
    Overrides:
    isEstablished in class TransportImpl
    Parameters:
    dest - peer hash
    Returns:
    whether established
  - isHXHIValid
```
boolean isHXHIValid(byte[] hxhi)
```
    Incoming connection replay detection. As there is no timestamp in the first message, we can't detect something long-delayed. To be fixed in next version of NTCP.
    Parameters:
    hxhi - using first 8 bytes only
    Returns:
    valid
  - mayDisconnect
```
public void mayDisconnect(Hash peer)
```
    Tell the transport that we may disconnect from this peer. This is advisory only.
    Specified by:
    mayDisconnect in interface Transport
    Overrides:
    mayDisconnect in class TransportImpl
    Parameters:
    peer - hash of the peer that may be disconnected
  - outboundMessageReady
```
protected void outboundMessageReady()
```
    Processes the next outbound message by retrieving or creating a connection, preparing it for sending, and handling related failures or bans.
    Specified by:
    outboundMessageReady in class TransportImpl
  - removeCon
```
NTCPConnection removeCon(NTCPConnection con)
```
    Returns:
    usually the con passed in, but possibly a second connection with the same peer... only con or null as of 0.9.37
  - sendComplete
```
void sendComplete(OutNetMessage msg)
```
    queue up afterSend call, which can take some time w/ jobs, etc
  - setEstablishTimeout
```
public static void setEstablishTimeout(int ms)
```
    Set the NTCP establish timeout, bounded 1500-10000ms. @since 0.9.70+
  - setFailsafeIterationFreq
```
public static void setFailsafeIterationFreq(long ms)
```
    Set the failsafe iteration frequency, bounded by MIN-MAX
  - setLastBadSkew
```
void setLastBadSkew(long skew)
```
    A positive number means our clock is ahead of theirs.
    Parameters:
    skew - in seconds
  - setSelectorLoopDelay
```
public static void setSelectorLoopDelay(long ms)
```
    Set the selector loop delay, bounded 1-100ms
  - setSendFinisherMaxThreads
```
public static void setSendFinisherMaxThreads(int threads)
```
    Set the send finisher max threads
  - setSendFinisherQueueCapacity
```
public static void setSendFinisherQueueCapacity(int capacity)
```
    Set the send finisher queue capacity
  - startListening
```
public void startListening()
```
    Starts the NTCP transport listening process, ensuring only one pumper is running by checking existing state since the caller may not stop the transport correctly. It configures and binds local addresses, handles firewall and network interface settings, and sets fallback addresses as needed. This method is synchronized to prevent concurrent starts.
  - stopListening
```
public void stopListening()
```
    This doesn't (completely) block, caller should check isAlive() before calling startListening() or restartListening()

Class NTCPTransport

Nested Class Summary

Nested classes/interfaces inherited from interface net.i2p.router.transport.Transport

Field Summary

Fields inherited from class net.i2p.router.transport.TransportImpl

Constructor Summary

Method Summary

Methods inherited from class net.i2p.router.transport.TransportImpl

Methods inherited from class java.lang.Object

Field Detail

ESTABLISH_TIMEOUT

MIN_SIGTYPE_VERSION

NTCP2_INT_VERSION

NTCP2_VERSION

NTCP2_VERSION_ALT

PQ_INT_VERSION

PQ_VERSION

PROP_BIND_INTERFACE

PROP_I2NP_NTCP_AUTO_IP

PROP_I2NP_NTCP_AUTO_PORT

PROP_I2NP_NTCP_HOSTNAME

PROP_I2NP_NTCP_PORT

PROP_NTCP2_IV

PROP_NTCP2_SP

STYLE

STYLE2

Constructor Detail

NTCPTransport

Method Detail

adjustReaderThreads

adjustSendFinisherThreads

adjustWriterThreads

afterSend

allowConnection

bid

countActivePeers

countActiveSendPeers

countPeers

establishing

expireTimedOut

externalAddressReceived

externalAddressRemoved

forceDisconnect

forceDisconnect

forwardPortStatus

getAltStyle

getClockSkews

getEstablished

getEstablishTimeout

getFailsafeIterationFreq

getNTCP2StaticIV

getNTCP2StaticPrivkey

getNTCP2StaticPubkey

getPeerCounts

getPeers

getPumper

getReachabilityStatus

getReader

getReaderUtilization

getRequestedPort

getSelectorLoopDelay

getSendFinisherMaxThreads

getSendFinisherQueueCapacity

getSendFinisherQueueSize

getSendFinisherUtilization

getStyle

getWriter

getWriterUtilization

getXDHFactory

inboundEstablished

isAlive

isBacklogged

isConnecting

isEstablished

isHXHIValid

mayDisconnect

outboundMessageReady

removeCon

sendComplete

setEstablishTimeout