TransportImpl (I2P Anonymous Network - Java Documentation

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

All Implemented Interfaces:

Transport

Direct Known Subclasses:

NTCPTransport, UDPTransport
```
public abstract class TransportImpl
extends Object
implements Transport
```
Defines a way to send a message to another peer and start listening for messages

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
`protected RouterContext`	`_context`
`protected List<RouterAddress>`	`_currentAddresses`
`protected static boolean`	`ADJUST_COST` Do we increase the advertised cost when approaching conn limits?
`protected static int`	`CONGESTION_COST_ADJUSTMENT` TODO change to 2
`protected static String`	`PROP_IPV6_FIREWALLED`

Constructor Summary

Constructors
Constructor and Description

TransportImpl(RouterContext context)
Initialize the new transport

Constructors
Constructor and Description
`TransportImpl(RouterContext context)` Initialize the new transport

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`protected String`	`_t(String s)` Translate
`protected String`	`_t(String s, Object o)` Translate
`protected void`	`afterSend(OutNetMessage msg, boolean sendSuccessful)` The transport is done sending this message
`protected void`	`afterSend(OutNetMessage msg, boolean sendSuccessful, boolean allowRequeue)` The transport is done sending this message
`protected void`	`afterSend(OutNetMessage msg, boolean sendSuccessful, boolean allowRequeue, long msToSend)` The transport is done sending this message.
`protected void`	`afterSend(OutNetMessage msg, boolean sendSuccessful, long msToSend)` The transport is done sending this message
`boolean`	`allowLocal()` Are we allowed to connect to local addresses?
`(package private) static void`	`clearCaches()`
`abstract int`	`countActivePeers()` How many peers are we currently connected to, that we have sent a message to or received a message from in the last five minutes.
`abstract int`	`countActiveSendPeers()` How many peers are we currently connected to, that we have sent a message to in the last minute.
`abstract int`	`countPeers()` How many peers are we connected to?
`abstract void`	`externalAddressReceived(Transport.AddressSource source, byte[] ip, int port)` Notify a transport of an external address change.
`void`	`externalAddressRemoved(Transport.AddressSource source, boolean ipv6)` Notify a transport of an external address change.
`void`	`forwardPortStatus(byte[] ip, int port, int externalPort, boolean success, String reason)` Notify a transport of the results of trying to forward a port.
`String`	`getAltStyle()` An alternate supported style, or null.
`List<Long>`	`getClockSkews()` Return our peer clock skews on a transport.
`RouterAddress`	`getCurrentAddress(boolean ipv6)` What address are we currently listening to? Replaces getCurrentAddress() Note: An address without a host is considered IPv4.
`List<RouterAddress>`	`getCurrentAddresses()` What addresses are we currently listening to? Replaces getCurrentAddress()
`static byte[]`	`getIP(net.i2p.data.Hash peer)` IP of the peer from the last connection (in or out, any transport).
`TransportUtil.IPv6Config`	`getIPv6Config()`
`int`	`getMaxConnections()` Per-transport connection limit
`List<String>`	`getMostRecentErrorMessages()`
`protected OutNetMessage`	`getNextMessage()` Nonblocking call to pull the next outbound message off the queue.
`abstract CommSystemFacade.Status`	`getReachabilityStatus()` Previously returned short, now enum as of 0.9.20
`int`	`getRequestedPort()` What INTERNAL port would the transport like to have forwarded by UPnP.
`protected Collection<InetAddress>`	`getSavedLocalAddresses()` Return and then clear all saved local addresses.
`protected List<RouterAddress>`	`getTargetAddresses(RouterInfo target)` Get all available address we can use, shuffled and then sorted by cost/preference.
`boolean`	`hasCurrentAddress()` Do we have any current address?
`boolean`	`haveCapacity()` Can we initiate or accept a connection to another peer, saving some margin
`boolean`	`haveCapacity(int pct)`
`boolean`	`isBacklogged(net.i2p.data.Hash peer)`
`boolean`	`isEstablished(net.i2p.data.Hash peer)`
`boolean`	`isIPv4Firewalled()` This returns true if the force-firewalled setting is configured, false otherwise.
`boolean`	`isIPv6Firewalled()` This returns true if the force-firewalled setting is configured, false otherwise.
`protected boolean`	`isPubliclyRoutable(byte[] addr)` Allows IPv6 only if the transport is configured for it.
`boolean`	`isUnreachable(net.i2p.data.Hash peer)`
`void`	`markReachable(net.i2p.data.Hash peer, boolean isInbound)` called when we establish a peer connection (outbound or inbound)
`void`	`markUnreachable(net.i2p.data.Hash peer)` called when we can't reach a peer
`void`	`mayDisconnect(net.i2p.data.Hash peer)` Tell the transport that we may disconnect from this peer.
`void`	`messageReceived(I2NPMessage inMsg, RouterIdentity remoteIdent, net.i2p.data.Hash remoteIdentHash, long msToReceive, int bytesReceived)` Message received from the I2NPMessageReader - send it to the listener
`protected String`	`ngettext(String s, String p, int n)` Translate
`protected abstract void`	`outboundMessageReady()` This message is called whenever a new message is added to the send pool, and it should not block Only used by NTCP.
`void`	`recheckReachability()` Deprecated. unused
`protected void`	`removeAddress(boolean ipv6)` Remove all existing addresses with the specified IP length (4 or 16).
`protected void`	`removeAddress(RouterAddress address)` Remove only this address.
`void`	`renderStatusHTML(Writer out)` Make this stuff pretty (only used in the old console)
`void`	`renderStatusHTML(Writer out, String urlBase, int sortFlags)`
`protected void`	`replaceAddress(RouterAddress address)` Replace any existing addresses for the current transport with the same IP length (4 or 16) with the given one.
`protected void`	`saveLocalAddress(InetAddress address)` Save a local address we were notified about before we started.
`void`	`send(OutNetMessage msg)` Asynchronously send the message as requested in the message and, if the send is successful, queue up any msg.getOnSendJob job, and register it with the OutboundMessageRegistry (if it has a reply selector).
`void`	`setIP(net.i2p.data.Hash peer, byte[] ip)` IP of the peer from the last connection (in or out, any transport).
`void`	`setListener(TransportEventListener listener)` Who to notify on message availability
`List<RouterAddress>`	`updateAddress()` Ask the transport to update its address based on current information and return it Transports should override.
`boolean`	`wasUnreachable(net.i2p.data.Hash peer)` Was the peer UNreachable (outbound only) the last time we tried it? This is NOT reset if the peer contacts us.

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

Methods inherited from interface net.i2p.router.transport.Transport
bid, forceDisconnect, getEstablished, getStyle, startListening, stopListening

- Field Detail
  - _currentAddresses
```
protected final List<RouterAddress> _currentAddresses
```
  - _context
```
protected final RouterContext _context
```
  - PROP_IPV6_FIREWALLED
```
protected static final String PROP_IPV6_FIREWALLED
```
    Since:
    
    0.9.44
    
    See Also:
    
    Constant Field Values
  - ADJUST_COST
```
protected static final boolean ADJUST_COST
```
    Do we increase the advertised cost when approaching conn limits?
    
    See Also:
    
    Constant Field Values
  - CONGESTION_COST_ADJUSTMENT
```
protected static final int CONGESTION_COST_ADJUSTMENT
```
    TODO change to 2
    
    See Also:
    
    Constant Field Values
- Constructor Detail
  - TransportImpl
```
public TransportImpl(RouterContext context)
```
    Initialize the new transport
- Method Detail
  - countPeers
```
public abstract int countPeers()
```
    How many peers are we connected to?
    
    Specified by:
    
    countPeers in interface Transport
  - countActivePeers
```
public abstract int countActivePeers()
```
    How many peers are we currently connected to, that we have sent a message to or received a message from in the last five minutes.
    
    Specified by:
    
    countActivePeers in interface Transport
  - countActiveSendPeers
```
public abstract int countActiveSendPeers()
```
    How many peers are we currently connected to, that we have sent a message to in the last minute. Unused for anything, to be removed.
    
    Specified by:
    
    countActiveSendPeers in interface Transport
  - getMaxConnections
```
public int getMaxConnections()
```
    Per-transport connection limit
  - haveCapacity
```
public boolean haveCapacity()
```
    Can we initiate or accept a connection to another peer, saving some margin
    
    Specified by:
    
    haveCapacity in interface Transport
  - haveCapacity
```
public boolean haveCapacity(int pct)
```
    Specified by:
    
    haveCapacity in interface Transport
    
    Parameters:
    
    pct - are we under x% 0-100
  - getClockSkews
```
public List<Long> getClockSkews()
```
    Return our peer clock skews on a transport. List composed of Long, each element representing a peer skew in seconds. Dummy version. Transports override it.
    
    Specified by:
    
    getClockSkews in interface Transport
  - getMostRecentErrorMessages
```
public List<String> getMostRecentErrorMessages()
```
    Specified by:
    
    getMostRecentErrorMessages in interface Transport
  - getNextMessage
```
protected OutNetMessage getNextMessage()
```
    Nonblocking call to pull the next outbound message off the queue. Only used by NTCP. SSU does not call.
    
    Returns:
    
    the next message or null if none are available
  - afterSend
```
protected void afterSend(OutNetMessage msg,
                         boolean sendSuccessful)
```
    The transport is done sending this message
    
    Parameters:
    
    msg - message in question
    
    sendSuccessful - true if the peer received it
  - afterSend
```
protected void afterSend(OutNetMessage msg,
                         boolean sendSuccessful,
                         boolean allowRequeue)
```
    The transport is done sending this message
    
    Parameters:
    
    msg - message in question
    
    sendSuccessful - true if the peer received it
    
    allowRequeue - true if we should try other transports if available
  - afterSend
```
protected void afterSend(OutNetMessage msg,
                         boolean sendSuccessful,
                         long msToSend)
```
    The transport is done sending this message
    
    Parameters:
    
    msg - message in question
    
    sendSuccessful - true if the peer received it
    
    msToSend - how long it took to transfer the data to the peer
  - afterSend
```
protected void afterSend(OutNetMessage msg,
                         boolean sendSuccessful,
                         boolean allowRequeue,
                         long msToSend)
```
    The transport is done sending this message. This is the method that actually does all of the cleanup - firing off jobs, requeueing, updating stats, etc.
    
    Parameters:
    
    msg - message in question
    
    sendSuccessful - true if the peer received it
    
    msToSend - how long it took to transfer the data to the peer
    
    allowRequeue - true if we should try other transports if available
  - send
```
public void send(OutNetMessage msg)
```
    Asynchronously send the message as requested in the message and, if the send is successful, queue up any msg.getOnSendJob job, and register it with the OutboundMessageRegistry (if it has a reply selector). If the send fails, queue up any msg.getOnFailedSendJob Only used by NTCP. SSU overrides. Note that this adds to the queue and then takes it back off in the same thread, so it actually blocks, and we don't need a big queue. TODO: Override in NTCP also and get rid of queue?
    
    Specified by:
    
    send in interface Transport
  - outboundMessageReady
```
protected abstract void outboundMessageReady()
```
    This message is called whenever a new message is added to the send pool, and it should not block Only used by NTCP. SSU throws UOE.
  - messageReceived
```
public void messageReceived(I2NPMessage inMsg,
                            RouterIdentity remoteIdent,
                            net.i2p.data.Hash remoteIdentHash,
                            long msToReceive,
                            int bytesReceived)
```
    Message received from the I2NPMessageReader - send it to the listener
    
    Parameters:
    
    inMsg - non-null
    
    remoteIdent - may be null
    
    remoteIdentHash - may be null, calculated from remoteIdent if null
  - getCurrentAddresses
```
public List<RouterAddress> getCurrentAddresses()
```
    What addresses are we currently listening to? Replaces getCurrentAddress()
    
    Specified by:
    
    getCurrentAddresses in interface Transport
    
    Returns:
    
    all addresses, non-null
    
    Since:
    
    IPv6
  - getCurrentAddress
```
public RouterAddress getCurrentAddress(boolean ipv6)
```
    What address are we currently listening to? Replaces getCurrentAddress() Note: An address without a host is considered IPv4.
    
    Parameters:
    
    ipv6 - true for IPv6 only; false for IPv4 only
    
    Returns:
    
    first matching address or null
    
    Since:
    
    IPv6
  - hasCurrentAddress
```
public boolean hasCurrentAddress()
```
    Do we have any current address?
    
    Specified by:
    
    hasCurrentAddress in interface Transport
    
    Since:
    
    IPv6
  - updateAddress
```
public List<RouterAddress> updateAddress()
```
    Ask the transport to update its address based on current information and return it Transports should override.
    
    Specified by:
    
    updateAddress in interface Transport
    
    Returns:
    
    all addresses, non-null
    
    Since:
    
    0.7.12
  - replaceAddress
```
protected void replaceAddress(RouterAddress address)
```
    Replace any existing addresses for the current transport with the same IP length (4 or 16) with the given one. TODO: Allow multiple addresses of the same length. Calls listener.transportAddressChanged() To remove all IPv4 or IPv6 addresses, use removeAddress(boolean).
    
    Parameters:
    
    address - null to remove all
  - removeAddress
```
protected void removeAddress(RouterAddress address)
```
    Remove only this address. Calls listener.transportAddressChanged(). To remove all IPv4 or IPv6 addresses, use removeAddress(boolean). To remove all IPv4 and IPv6 addresses, use replaceAddress(null).
    
    Since:
    
    0.9.20
  - removeAddress
```
protected void removeAddress(boolean ipv6)
```
    Remove all existing addresses with the specified IP length (4 or 16). Calls listener.transportAddressChanged(). To remove all IPv4 and IPv6 addresses, use replaceAddress(null).
    
    Parameters:
    
    ipv6 - true to remove all IPv6 addresses, false to remove all IPv4 addresses
    
    Since:
    
    0.9.20
  - saveLocalAddress
```
protected void saveLocalAddress(InetAddress address)
```
    Save a local address we were notified about before we started.
    
    Since:
    
    IPv6
  - getSavedLocalAddresses
```
protected Collection<InetAddress> getSavedLocalAddresses()
```
    Return and then clear all saved local addresses.
    
    Since:
    
    IPv6
  - getTargetAddresses
```
protected List<RouterAddress> getTargetAddresses(RouterInfo target)
```
    Get all available address we can use, shuffled and then sorted by cost/preference. Lowest cost (most preferred) first.
    
    Returns:
    
    non-null, possibly empty
    
    Since:
    
    IPv6
  - externalAddressReceived
```
public abstract void externalAddressReceived(Transport.AddressSource source,
                                             byte[] ip,
                                             int port)
```
    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 before startListening() to set an initial address, or after the transport is running.
    
    Specified by:
    
    externalAddressReceived in interface Transport
    
    Parameters:
    
    source - defined in Transport.java
    
    ip - typ. IPv4 or IPv6 non-local; may be null to indicate IPv4 failure or port info only
    
    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. TODO externalAddressRemoved(source, ip, port) This implementation does nothing. Transports should override if they want notification.
    
    Specified by:
    
    externalAddressRemoved in interface Transport
    
    Parameters:
    
    source - defined in Transport.java
    
    Since:
    
    0.9.20
  - forwardPortStatus
```
public void forwardPortStatus(byte[] ip,
                              int port,
                              int externalPort,
                              boolean success,
                              String reason)
```
    Notify a transport of the results of trying to forward a port. This implementation does nothing. Transports should override if they want notification.
    
    Specified by:
    
    forwardPortStatus in interface Transport
    
    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.
  - getRequestedPort
```
public int getRequestedPort()
```
    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
    
    Returns:
    
    port or -1 for none or 0 for any
  - setListener
```
public void setListener(TransportEventListener listener)
```
    Who to notify on message availability
    
    Specified by:
    
    setListener in interface Transport
  - renderStatusHTML
```
public void renderStatusHTML(Writer out)
                      throws IOException
```
    Make this stuff pretty (only used in the old console)
    
    Throws:
    
    IOException
  - renderStatusHTML
```
public void renderStatusHTML(Writer out,
                             String urlBase,
                             int sortFlags)
                      throws IOException
```
    Specified by:
    
    renderStatusHTML in interface Transport
    
    Throws:
    
    IOException
  - getReachabilityStatus
```
public abstract CommSystemFacade.Status getReachabilityStatus()
```
    Previously returned short, now enum as of 0.9.20
    
    Specified by:
    
    getReachabilityStatus in interface Transport
  - recheckReachability
```
@Deprecated
public void recheckReachability()
```
    Deprecated. unused
    
    Specified by:
    
    recheckReachability in interface Transport
  - isIPv4Firewalled
```
public boolean isIPv4Firewalled()
```
    This returns true if the force-firewalled setting is configured, false otherwise.
    
    Since:
    
    0.9.20, public since 0.9.30
  - isIPv6Firewalled
```
public boolean isIPv6Firewalled()
```
    This returns true if the force-firewalled setting is configured, false otherwise.
    
    Since:
    
    0.9.27, public since 0.9.30
  - isBacklogged
```
public boolean isBacklogged(net.i2p.data.Hash peer)
```
    Specified by:
    
    isBacklogged in interface Transport
  - isEstablished
```
public boolean isEstablished(net.i2p.data.Hash peer)
```
    Specified by:
    
    isEstablished in interface Transport
  - mayDisconnect
```
public void mayDisconnect(net.i2p.data.Hash peer)
```
    Tell the transport that we may disconnect from this peer. This is advisory only.
    
    Specified by:
    
    mayDisconnect in interface Transport
    
    Since:
    
    0.9.24
  - isUnreachable
```
public boolean isUnreachable(net.i2p.data.Hash peer)
```
    Specified by:
    
    isUnreachable in interface Transport
  - markUnreachable
```
public void markUnreachable(net.i2p.data.Hash peer)
```
    called when we can't reach a peer
  - markReachable
```
public void markReachable(net.i2p.data.Hash peer,
                          boolean isInbound)
```
    called when we establish a peer connection (outbound or inbound)
  - wasUnreachable
```
public boolean wasUnreachable(net.i2p.data.Hash peer)
```
    Was the peer UNreachable (outbound only) the last time we tried it? This is NOT reset if the peer contacts us.
    
    Specified by:
    
    wasUnreachable in interface Transport
  - allowLocal
```
public boolean allowLocal()
```
    Are we allowed to connect to local addresses?
    
    Since:
    
    0.9.28 moved from UDPTransport
  - setIP
```
public void setIP(net.i2p.data.Hash peer,
                  byte[] ip)
```
    IP of the peer from the last connection (in or out, any transport).
    
    Parameters:
    
    ip - IPv4 or IPv6, non-null
  - getIP
```
public static byte[] getIP(net.i2p.data.Hash peer)
```
    IP of the peer from the last connection (in or out, any transport).
    
    Returns:
    
    IPv4 or IPv6 or null
  - getAltStyle
```
public String getAltStyle()
```
    An alternate supported style, or null.
    
    Returns:
    
    null, override to add support
    
    Since:
    
    0.9.35
  - clearCaches
```
static void clearCaches()
```
    Since:
    
    0.9.3
  - getIPv6Config
```
public TransportUtil.IPv6Config getIPv6Config()
```
    Since:
    
    IPv6, public since 0.9.30
  - isPubliclyRoutable
```
protected boolean isPubliclyRoutable(byte[] addr)
```
    Allows IPv6 only if the transport is configured for it. Caller must check if we actually have a public IPv6 address.
    
    Parameters:
    
    addr - non-null
  - _t
```
protected String _t(String s)
```
    Translate
    
    Since:
    
    0.9.8 moved from transports
  - _t
```
protected String _t(String s,
                    Object o)
```
    Translate
    
    Since:
    
    0.9.8 moved from transports
  - ngettext
```
protected String ngettext(String s,
                          String p,
                          int n)
```
    Translate
    
    Since:
    
    0.9.8

Class TransportImpl

Nested Class Summary

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

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface net.i2p.router.transport.Transport

Field Detail

_currentAddresses

_context

PROP_IPV6_FIREWALLED

ADJUST_COST

CONGESTION_COST_ADJUSTMENT

Constructor Detail

TransportImpl

Method Detail

countPeers

countActivePeers

countActiveSendPeers

getMaxConnections

haveCapacity

haveCapacity

getClockSkews

getMostRecentErrorMessages

getNextMessage

afterSend

afterSend

afterSend

afterSend

send

outboundMessageReady

messageReceived

getCurrentAddresses

getCurrentAddress

hasCurrentAddress

updateAddress

replaceAddress

removeAddress

removeAddress

saveLocalAddress

getSavedLocalAddresses

getTargetAddresses

externalAddressReceived

externalAddressRemoved

forwardPortStatus

getRequestedPort

setListener

renderStatusHTML

renderStatusHTML

getReachabilityStatus

recheckReachability

isIPv4Firewalled

isIPv6Firewalled

isBacklogged

isEstablished

mayDisconnect

isUnreachable

markUnreachable

markReachable

wasUnreachable

allowLocal

setIP

getIP

getAltStyle

clearCaches

getIPv6Config

isPubliclyRoutable

_t

_t

ngettext