codeCache, Log log) {
+ String[] rv = new String[search.length];
+ int idx = 0;
+ long start = System.currentTimeMillis();
+ InputStream in = null;
+ try {
+ in = new GZIPInputStream(new BufferedInputStream(new FileInputStream(geoFile)));
+ byte[] magic = new byte[MAGIC.length()];
+ DataHelper.read(in, magic);
+ if (!DataHelper.eq(magic, DataHelper.getASCII(MAGIC)))
+ throw new IOException("Not a IPv6 geoip data file");
+ // skip timestamp and comments
+ in.skip(HEADER_LEN - MAGIC.length());
+ byte[] buf = new byte[18];
+ while (DataHelper.read(in, buf) == 18 && idx < search.length) {
+ long ip1 = readLong(buf, 0);
+ long ip2 = readLong(buf, 8);
+ while (idx < search.length && search[idx].longValue() < ip1) {
+ idx++;
+ }
+ while (idx < search.length && search[idx].longValue() >= ip1 && search[idx].longValue() <= ip2) {
+ // written in lower case
+ String lc = new String(buf, 16, 2, "ISO-8859-1");
+ // replace the new string with the identical one from the cache
+ String cached = codeCache.get(lc);
+ if (cached == null)
+ cached = lc;
+ rv[idx++] = cached;
+ }
+ }
+ } catch (IOException ioe) {
+ if (log.shouldLog(Log.ERROR))
+ log.error("Error reading the geoFile", ioe);
+ } finally {
+ if (in != null) try { in.close(); } catch (IOException ioe) {}
+ }
+
+ if (log.shouldLog(Log.INFO))
+ log.info("GeoIPv6 processing finished, time: " + (System.currentTimeMillis() - start));
+ return rv;
+ }
+
+
+ /**
+ * Read in and parse multiple IPv6 geoip CSV files,
+ * merge them, and write out a gzipped binary IPv6 geoip file.
+ *
+ * Acceptable input formats (IPv6 only):
+ *
+ * #comment (# must be in column 1)
+ * "text IP", "text IP", "bigint IP", "bigint IP", "country code", "country name"
+ *
+ * Quotes and spaces optional. Sorting not required.
+ * Country code case-insensitive.
+ * Fields 1, 2, and 5 are used; fields 3, 4, and 6 are ignored.
+ * This is identical to the format of the MaxMind GeoLite IPv6 file.
+ *
+ * Example:
+ *
+ * "2001:200::", "2001:200:ffff:ffff:ffff:ffff:ffff:ffff", "42540528726795050063891204319802818560", "42540528806023212578155541913346768895", "JP", "Japan"
+ *
+ *
+ *
+ * Output format:
+ * Bytes 0-9: Magic number "I2PGeoIPv6"
+ * Bytes 10-11: version (0x0001)
+ * Bytes 12-15 flags (0)
+ * Bytes 16-23: Date (long)
+ * Bytes 24-xx: Comment (UTF-8)
+ * Bytes xx-255: null padding
+ * Bytes 256-: 18 byte records:
+ * 8 byte from (/64)
+ * 8 byte to (/64)
+ * 2 byte country code LOWER case (ASCII)
+ * Data must be sorted (SIGNED twos complement), no overlap
+ *
+ *
+ * SLOW. For preprocessing only!
+ *
+ * @return success
+ */
+ private static boolean compressGeoIPv6CSVFiles(List inFiles, File outFile) {
+ boolean DEBUG = false;
+ List entries = new ArrayList(20000);
+ for (File geoFile : inFiles) {
+ int count = 0;
+ InputStream in = null;
+ try {
+ in = new BufferedInputStream(new FileInputStream(geoFile));
+ if (geoFile.getName().endsWith(".gz"))
+ in = new GZIPInputStream(in);
+ String buf = null;
+ BufferedReader br = new BufferedReader(new InputStreamReader(in, "ISO-8859-1"));
+ while ((buf = br.readLine()) != null) {
+ try {
+ if (buf.charAt(0) == '#') {
+ continue;
+ }
+ String[] s = buf.split(",");
+ String ips1 = s[0].replace("\"", "").trim();
+ String ips2 = s[1].replace("\"", "").trim();
+ byte[] ip1 = InetAddress.getByName(ips1).getAddress();
+ byte[] ip2 = InetAddress.getByName(ips2).getAddress();
+ String country = s[4].replace("\"", "").trim().toLowerCase(Locale.US);
+ entries.add(new V6Entry(ip1, ip2, country));
+ count++;
+ } catch (UnknownHostException uhe) {
+ uhe.printStackTrace();
+ } catch (RuntimeException re) {
+ re.printStackTrace();
+ }
+ }
+ System.err.println("Read " + count + " entries from " + geoFile);
+ } catch (IOException ioe) {
+ ioe.printStackTrace();
+ //if (_log.shouldLog(Log.ERROR))
+ // _log.error("Error reading the geoFile", ioe);
+ return false;
+ } finally {
+ if (in != null) try { in.close(); } catch (IOException ioe) {}
+ }
+ }
+ Collections.sort(entries);
+ // merge
+ V6Entry old = null;
+ for (int i = 0; i < entries.size(); i++) {
+ V6Entry e = entries.get(i);
+ if (DEBUG)
+ System.out.println("proc " + e.toString());
+ if (old != null) {
+ if (e.from == old.from && e.to == old.to) {
+ // dup
+ if (DEBUG)
+ System.out.println("remove dup " + e);
+ entries.remove(i);
+ i--;
+ continue;
+ }
+ if (e.from <= old.to) {
+ // overlap
+ // truncate old
+ if (e.from < old.to) {
+ V6Entry rewrite = new V6Entry(old.from, e.from - 1, old.cc);
+ if (DEBUG)
+ System.out.println("rewrite old to " + rewrite);
+ entries.set(i - 1, rewrite);
+ }
+ if (e.to < old.to) {
+ // e inside old, add new after e
+ V6Entry insert = new V6Entry(e.to + 1, old.to, old.cc);
+ if (DEBUG)
+ System.out.println("insert " + insert);
+ int j = i + 1;
+ while (j < entries.size() && insert.compareTo(entries.get(j)) > 0) {
+ j++;
+ }
+ entries.add(j, insert);
+ }
+ }
+ }
+ old = e;
+ }
+ OutputStream out = null;
+ try {
+ out = new GZIPOutputStream(new BufferedOutputStream(new FileOutputStream(outFile)));
+ out.write(DataHelper.getASCII(MAGIC));
+ writeLong(out, System.currentTimeMillis());
+ byte[] comment = DataHelper.getUTF8(COMMENT);
+ out.write(comment);
+ out.write(new byte[256 - (16 + 8 + comment.length)]);
+ for (V6Entry e : entries) {
+ writeLong(out, e.from);
+ writeLong(out, e.to);
+ out.write(DataHelper.getASCII(e.cc));
+ }
+ System.err.println("Wrote " + entries.size() + " entries to " + outFile);
+ } catch (IOException ioe) {
+ ioe.printStackTrace();
+ //if (_log.shouldLog(Log.ERROR))
+ // _log.error("Error reading the geoFile", ioe);
+ return false;
+ } finally {
+ if (out != null) try { out.close(); } catch (IOException ioe) {}
+ }
+ return true;
+ }
+
+ /**
+ * Used to temporarily hold, sort, and merge entries before compressing
+ */
+ private static class V6Entry implements Comparable {
+ public final long from, to;
+ public final String cc;
+
+ public V6Entry(byte[] f, byte[] t, String c) {
+ if (f.length != 16 || t.length != 16 || c.length() != 2)
+ throw new IllegalArgumentException();
+ from = toLong(f);
+ to = toLong(t);
+ cc = c;
+ if (to < from)
+ throw new IllegalArgumentException(toString());
+ }
+
+ public V6Entry(long f, long t, String c) {
+ from = f;
+ to = t;
+ cc = c;
+ if (t < f)
+ throw new IllegalArgumentException(toString());
+ }
+
+ /** twos complement */
+ public int compareTo(V6Entry r) {
+ if (from < r.from) return -1;
+ if (r.from < from) return 1;
+ if (to < r.to) return -1;
+ if (r.to < to) return 1;
+ return 0;
+ }
+
+ @Override
+ public String toString() {
+ return "0x" + Long.toHexString(from) + " -> 0x" + Long.toHexString(to) + " : " + cc;
+ }
+ }
+
+ private static long toLong(byte ip[]) {
+ long rv = 0;
+ for (int i = 0; i < 8; i++)
+ rv |= (ip[i] & 0xffL) << ((7-i)*8);
+ return rv;
+ }
+
+ /** like DataHelper.writeLong(rawStream, 8, value) but allows negative values */
+ private static void writeLong(OutputStream rawStream, long value) throws IOException {
+ for (int i = 56; i >= 0; i -= 8) {
+ byte cur = (byte) (value >> i);
+ rawStream.write(cur);
+ }
+ }
+
+ /** like DataHelper.readLong(src, offset, 8) but allows negative values */
+ private static long readLong(byte[] src, int offset) throws IOException {
+ long rv = 0;
+ int limit = offset + 8;
+ for (int i = offset; i < limit; i++) {
+ rv <<= 8;
+ rv |= src[i] & 0xFF;
+ }
+ return rv;
+ }
+
+ /**
+ * Merge and compress CSV files to I2P compressed format
+ *
+ * GeoIP infile1.csv[.gz] [infile2.csv[.gz]...] outfile.dat.gz
+ *
+ * Used to create the file for distribution, do not comment out
+ */
+ public static void main(String args[]) {
+ if (args.length < 2) {
+ System.err.println("Usage: GeoIP infile1.csv [infile2.csv...] outfile.dat.gz");
+ System.exit(1);
+ }
+ List infiles = new ArrayList();
+ for (int i = 0; i < args.length - 1; i++) {
+ infiles.add(new File(args[i]));
+ }
+ File outfile = new File(args[args.length - 1]);
+ boolean success = compressGeoIPv6CSVFiles(infiles, outfile);
+ if (!success) {
+ System.err.println("Failed");
+ System.exit(1);
+ }
+ // readback for testing
+ readGeoIPFile(outfile, new Long[] { Long.MAX_VALUE }, Collections.EMPTY_MAP, new Log(GeoIPv6.class));
+ }
+}
diff --git a/router/java/src/net/i2p/router/transport/GetBidsJob.java b/router/java/src/net/i2p/router/transport/GetBidsJob.java
index 85da18c13f..676f72e163 100644
--- a/router/java/src/net/i2p/router/transport/GetBidsJob.java
+++ b/router/java/src/net/i2p/router/transport/GetBidsJob.java
@@ -23,22 +23,25 @@ import net.i2p.util.Log;
*/
class GetBidsJob extends JobImpl {
private final Log _log;
- private final CommSystemFacadeImpl _facade;
+ private final TransportManager _tmgr;
private final OutNetMessage _msg;
- public GetBidsJob(RouterContext ctx, CommSystemFacadeImpl facade, OutNetMessage msg) {
+ /**
+ * @deprecated unused, see static getBids()
+ */
+ public GetBidsJob(RouterContext ctx, TransportManager tmgr, OutNetMessage msg) {
super(ctx);
_log = ctx.logManager().getLog(GetBidsJob.class);
- _facade = facade;
+ _tmgr = tmgr;
_msg = msg;
}
public String getName() { return "Fetch bids for a message to be delivered"; }
public void runJob() {
- getBids(getContext(), _facade, _msg);
+ getBids(getContext(), _tmgr, _msg);
}
- static void getBids(RouterContext context, CommSystemFacadeImpl facade, OutNetMessage msg) {
+ static void getBids(RouterContext context, TransportManager tmgr, OutNetMessage msg) {
Log log = context.logManager().getLog(GetBidsJob.class);
Hash to = msg.getTarget().getIdentity().getHash();
msg.timestamp("bid");
@@ -61,14 +64,14 @@ class GetBidsJob extends JobImpl {
return;
}
- TransportBid bid = facade.getNextBid(msg);
+ TransportBid bid = tmgr.getNextBid(msg);
if (bid == null) {
int failedCount = msg.getFailedTransports().size();
if (failedCount == 0) {
context.statManager().addRateData("transport.bidFailNoTransports", msg.getLifetime());
// This used to be "no common transports" but it is almost always no transports at all
context.banlist().banlistRouter(to, _x("No transports (hidden or starting up?)"));
- } else if (failedCount >= facade.getTransportCount()) {
+ } else if (failedCount >= tmgr.getTransportCount()) {
context.statManager().addRateData("transport.bidFailAllTransports", msg.getLifetime());
// fail after all transports were unsuccessful
context.netDb().fail(to);
@@ -82,7 +85,7 @@ class GetBidsJob extends JobImpl {
}
- private static void fail(RouterContext context, OutNetMessage msg) {
+ static void fail(RouterContext context, OutNetMessage msg) {
if (msg.getOnFailedSendJob() != null) {
context.jobQueue().addJob(msg.getOnFailedSendJob());
}
diff --git a/router/java/src/net/i2p/router/transport/Transport.java b/router/java/src/net/i2p/router/transport/Transport.java
index 4bece170db..954b3d1d7e 100644
--- a/router/java/src/net/i2p/router/transport/Transport.java
+++ b/router/java/src/net/i2p/router/transport/Transport.java
@@ -32,17 +32,90 @@ public interface Transport {
*
*/
public void send(OutNetMessage msg);
- public RouterAddress startListening();
+ public void startListening();
public void stopListening();
- public RouterAddress getCurrentAddress();
- public RouterAddress updateAddress();
- public static final String SOURCE_UPNP = "upnp";
- public static final String SOURCE_INTERFACE = "local";
- public static final String SOURCE_CONFIG = "config"; // unused
- public void externalAddressReceived(String source, byte[] ip, int port);
- public void forwardPortStatus(int port, int externalPort, boolean success, String reason);
+
+ /**
+ * What addresses are we currently listening to?
+ * Replaces getCurrentAddress()
+ * @return all addresses, non-null
+ * @since IPv6
+ */
+ public List getCurrentAddresses();
+
+ /**
+ * Do we have any current address?
+ * @since IPv6
+ */
+ public boolean hasCurrentAddress();
+
+ /**
+ * Ask the transport to update its addresses based on current information and return them
+ * @return all addresses, non-null
+ */
+ public List updateAddress();
+
+ /**
+ * @since IPv6
+ */
+ public enum AddressSource {
+ SOURCE_UPNP("upnp"),
+ SOURCE_INTERFACE("local"),
+ /** unused */
+ SOURCE_CONFIG("config"),
+ SOURCE_SSU("ssu");
+
+ private final String cfgstr;
+
+ AddressSource(String cfgstr) {
+ this.cfgstr = cfgstr;
+ }
+
+ public String toConfigString() {
+ return cfgstr;
+ }
+ }
+
+ /**
+ * 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.
+ *
+ * @param source defined in Transport.java
+ * @param ip typ. IPv4 or IPv6 non-local; may be null to indicate IPv4 failure or port info only
+ * @param port 0 for unknown or unchanged
+ */
+ public void externalAddressReceived(AddressSource source, byte[] ip, int port);
+
+ /**
+ * Notify a transport of the results of trying to forward a port.
+ *
+ * @param ip may be null
+ * @param port the internal port
+ * @param externalPort the external port, which for now should always be the same as
+ * the internal port if the forwarding was successful.
+ */
+ public void forwardPortStatus(byte[] ip, int port, int externalPort, boolean success, String reason);
+
+ /**
+ * 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.
+ *
+ * @return port or -1 for none or 0 for any
+ */
public int getRequestedPort();
+
+ /** Who to notify on message availability */
public void setListener(TransportEventListener listener);
+
public String getStyle();
public int countPeers();
@@ -51,12 +124,17 @@ public interface Transport {
public boolean haveCapacity();
public boolean haveCapacity(int pct);
public Vector getClockSkews();
- public List getMostRecentErrorMessages();
+ public List getMostRecentErrorMessages();
public void renderStatusHTML(Writer out, String urlBase, int sortFlags) throws IOException;
public short getReachabilityStatus();
public void recheckReachability();
public boolean isBacklogged(Hash dest);
+
+ /**
+ * Was the peer UNreachable (outbound only) the last time we tried it?
+ * This is NOT reset if the peer contacts us and it is never expired.
+ */
public boolean wasUnreachable(Hash dest);
public boolean isUnreachable(Hash peer);
diff --git a/router/java/src/net/i2p/router/transport/TransportImpl.java b/router/java/src/net/i2p/router/transport/TransportImpl.java
index fc24856be9..60752f1d19 100644
--- a/router/java/src/net/i2p/router/transport/TransportImpl.java
+++ b/router/java/src/net/i2p/router/transport/TransportImpl.java
@@ -10,8 +10,11 @@ package net.i2p.router.transport;
import java.io.IOException;
import java.io.Writer;
+import java.net.InetAddress;
import java.util.ArrayList;
+import java.util.Collection;
import java.util.Collections;
+import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
@@ -23,6 +26,7 @@ import java.util.Vector;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.CopyOnWriteArrayList;
import net.i2p.data.DataHelper;
import net.i2p.data.Hash;
@@ -36,7 +40,6 @@ import net.i2p.router.MessageSelector;
import net.i2p.router.OutNetMessage;
import net.i2p.router.Router;
import net.i2p.router.RouterContext;
-import net.i2p.router.networkdb.kademlia.FloodfillNetworkDatabaseFacade;
import net.i2p.util.ConcurrentHashSet;
import net.i2p.util.LHMCache;
import net.i2p.util.Log;
@@ -51,13 +54,14 @@ import net.i2p.util.SystemVersion;
public abstract class TransportImpl implements Transport {
private final Log _log;
private TransportEventListener _listener;
- private RouterAddress _currentAddress;
+ protected final List _currentAddresses;
// Only used by NTCP. SSU does not use. See send() below.
private final BlockingQueue _sendPool;
protected final RouterContext _context;
/** map from routerIdentHash to timestamp (Long) that the peer was last unreachable */
private final Map _unreachableEntries;
private final Set _wasUnreachableEntries;
+ private final Set _localAddresses;
/** global router ident -> IP */
private static final Map _IPMap;
@@ -88,12 +92,15 @@ public abstract class TransportImpl implements Transport {
_context.statManager().createRequiredRateStat("transport.sendProcessingTime", "Time to process and send a message (ms)", "Transport", new long[] { 60*1000l, 10*60*1000l, 60*60*1000l, 24*60*60*1000l });
//_context.statManager().createRateStat("transport.sendProcessingTime." + getStyle(), "Time to process and send a message (ms)", "Transport", new long[] { 60*1000l });
_context.statManager().createRateStat("transport.expiredOnQueueLifetime", "How long a message that expires on our outbound queue is processed", "Transport", new long[] { 60*1000l, 10*60*1000l, 60*60*1000l, 24*60*60*1000l } );
+
+ _currentAddresses = new CopyOnWriteArrayList();
if (getStyle().equals("NTCP"))
_sendPool = new ArrayBlockingQueue(8);
else
_sendPool = null;
_unreachableEntries = new HashMap(16);
_wasUnreachableEntries = new ConcurrentHashSet(16);
+ _localAddresses = new ConcurrentHashSet(4);
_context.simpleScheduler().addPeriodicEvent(new CleanupUnreachable(), 2 * UNREACHABLE_PERIOD, UNREACHABLE_PERIOD / 2);
}
@@ -119,6 +126,9 @@ public abstract class TransportImpl implements Transport {
/** Per-transport connection limit */
public int getMaxConnections() {
+ if (_context.commSystem().isDummy())
+ // testing
+ return 0;
String style = getStyle();
// object churn
String maxProp;
@@ -135,7 +145,7 @@ public abstract class TransportImpl implements Transport {
if (bw > Router.CAPABILITY_BW12 && bw <= Router.CAPABILITY_BW256)
def *= (1 + bw - Router.CAPABILITY_BW12);
}
- if (((FloodfillNetworkDatabaseFacade)_context.netDb()).floodfillEnabled()) {
+ if (_context.netDb().floodfillEnabled()) {
// && !SystemVersion.isWindows()) {
def *= 17; def /= 10; // 425 for Class O ff
}
@@ -167,7 +177,7 @@ public abstract class TransportImpl implements Transport {
*/
public Vector getClockSkews() { return new Vector(); }
- public List getMostRecentErrorMessages() { return Collections.EMPTY_LIST; }
+ public List getMostRecentErrorMessages() { return Collections.EMPTY_LIST; }
/**
* Nonblocking call to pull the next outbound message
@@ -463,63 +473,200 @@ public abstract class TransportImpl implements Transport {
}
/** Do we increase the advertised cost when approaching conn limits? */
- public static final boolean ADJUST_COST = true;
+ protected static final boolean ADJUST_COST = true;
+ protected static final int CONGESTION_COST_ADJUSTMENT = 2;
- /** What addresses are we currently listening to? */
- public RouterAddress getCurrentAddress() {
- return _currentAddress;
+ /**
+ * What addresses are we currently listening to?
+ * Replaces getCurrentAddress()
+ * @return all addresses, non-null
+ * @since IPv6
+ */
+ public List getCurrentAddresses() {
+ return _currentAddresses;
+ }
+
+ /**
+ * What address are we currently listening to?
+ * Replaces getCurrentAddress()
+ * @param ipv6 true for IPv6 only; false for IPv4 only
+ * @return first matching address or null
+ * @since IPv6
+ */
+ public RouterAddress getCurrentAddress(boolean ipv6) {
+ for (RouterAddress ra : _currentAddresses) {
+ if (ipv6 == TransportUtil.isIPv6(ra))
+ return ra;
+ }
+ return null;
+ }
+
+ /**
+ * Do we have any current address?
+ * @since IPv6
+ */
+ public boolean hasCurrentAddress() {
+ return !_currentAddresses.isEmpty();
}
/**
* Ask the transport to update its address based on current information and return it
* Transports should override.
+ * @return all addresses, non-null
* @since 0.7.12
*/
- public RouterAddress updateAddress() {
- return _currentAddress;
+ public List updateAddress() {
+ return _currentAddresses;
}
/**
- * Replace any existing addresses for the current transport with the given
- * one.
+ * 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()
+ *
+ * @param address null to remove all
*/
protected void replaceAddress(RouterAddress address) {
- // _log.error("Replacing address for " + getStyle() + " was " + _currentAddress + " now " + address);
- _currentAddress = address;
+ if (_log.shouldLog(Log.WARN))
+ _log.warn("Replacing address with " + address, new Exception());
+ if (address == null) {
+ _currentAddresses.clear();
+ } else {
+ boolean isIPv6 = TransportUtil.isIPv6(address);
+ for (RouterAddress ra : _currentAddresses) {
+ if (isIPv6 == TransportUtil.isIPv6(ra))
+ _currentAddresses.remove(ra);
+ }
+ _currentAddresses.add(address);
+ }
+ if (_log.shouldLog(Log.WARN))
+ _log.warn(getStyle() + " now has " + _currentAddresses.size() + " addresses");
if (_listener != null)
_listener.transportAddressChanged();
}
+ /**
+ * Save a local address we were notified about before we started.
+ *
+ * @since IPv6
+ */
+ protected void saveLocalAddress(InetAddress address) {
+ _localAddresses.add(address);
+ }
+
+ /**
+ * Return and then clear all saved local addresses.
+ *
+ * @since IPv6
+ */
+ protected Collection getSavedLocalAddresses() {
+ List rv = new ArrayList(_localAddresses);
+ _localAddresses.clear();
+ return rv;
+ }
+
+ /**
+ * Get all available address we can use,
+ * shuffled and then sorted by cost/preference.
+ * Lowest cost (most preferred) first.
+ * @return non-null, possibly empty
+ * @since IPv6
+ */
+ protected List getTargetAddresses(RouterInfo target) {
+ List rv = target.getTargetAddresses(getStyle());
+ // Shuffle so everybody doesn't use the first one
+ if (rv.size() > 1) {
+ Collections.shuffle(rv, _context.random());
+ TransportUtil.IPv6Config config = getIPv6Config();
+ int adj;
+ switch (config) {
+ case IPV6_DISABLED:
+ adj = 10; break;
+ case IPV6_NOT_PREFERRED:
+ adj = 1; break;
+ default:
+ case IPV6_ENABLED:
+ adj = 0; break;
+ case IPV6_PREFERRED:
+ adj = -1; break;
+ case IPV6_ONLY:
+ adj = -10; break;
+ }
+ Collections.sort(rv, new AddrComparator(adj));
+ }
+ return rv;
+ }
+
+ /**
+ * Compare based on published cost, adjusting for our IPv6 preference.
+ * Lowest cost (most preferred) first.
+ * @since IPv6
+ */
+ private static class AddrComparator implements Comparator {
+ private final int adj;
+
+ public AddrComparator(int ipv6Adjustment) {
+ adj = ipv6Adjustment;
+ }
+
+ public int compare(RouterAddress l, RouterAddress r) {
+ int lc = l.getCost();
+ int rc = r.getCost();
+ byte[] lip = l.getIP();
+ byte[] rip = r.getIP();
+ if (lip == null)
+ lc += 20;
+ else if (lip.length == 16)
+ lc += adj;
+ if (rip == null)
+ rc += 20;
+ else if (rip.length == 16)
+ rc += adj;
+ if (lc > rc)
+ return 1;
+ if (lc < rc)
+ return -1;
+ return 0;
+ }
+ }
+
/**
* 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,
- * or if the ip is IPv6, but the transport should check anyway.
+ * (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.
*
+ * This implementation does nothing. Transports should override if they want notification.
+ *
* @param source defined in Transport.java
- * @param ip typ. IPv4 non-local
+ * @param ip typ. IPv4 or IPv6 non-local; may be null to indicate IPv4 failure or port info only
* @param port 0 for unknown or unchanged
*/
- public void externalAddressReceived(String source, byte[] ip, int port) {}
+ public void externalAddressReceived(AddressSource source, byte[] ip, int port) {}
/**
* Notify a transport of the results of trying to forward a port.
+ *
+ * This implementation does nothing. Transports should override if they want notification.
+ *
+ * @param ip may be null
* @param port the internal port
* @param externalPort the external port, which for now should always be the same as
* the internal port if the forwarding was successful.
*/
- public void forwardPortStatus(int port, int externalPort, boolean success, String reason) {}
+ public void forwardPortStatus(byte[] ip, int port, int externalPort, boolean success, String reason) {}
/**
- * What port would the transport like to have forwarded by UPnP.
+ * 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.
+ * before we can publish the address, and that's the external port anyway.
*
* @return port or -1 for none or 0 for any
*/
@@ -531,13 +678,13 @@ public abstract class TransportImpl implements Transport {
public void renderStatusHTML(Writer out) throws IOException {}
public void renderStatusHTML(Writer out, String urlBase, int sortFlags) throws IOException { renderStatusHTML(out); }
- public RouterContext getContext() { return _context; }
public short getReachabilityStatus() { return CommSystemFacade.STATUS_UNKNOWN; }
public void recheckReachability() {}
public boolean isBacklogged(Hash dest) { return false; }
public boolean isEstablished(Hash dest) { return false; }
private static final long UNREACHABLE_PERIOD = 5*60*1000;
+
public boolean isUnreachable(Hash peer) {
long now = _context.clock().now();
synchronized (_unreachableEntries) {
@@ -551,6 +698,7 @@ public abstract class TransportImpl implements Transport {
}
}
}
+
/** called when we can't reach a peer */
/** This isn't very useful since it is cleared when they contact us */
public void markUnreachable(Hash peer) {
@@ -560,6 +708,7 @@ public abstract class TransportImpl implements Transport {
}
markWasUnreachable(peer, true);
}
+
/** called when we establish a peer connection (outbound or inbound) */
public void markReachable(Hash peer, boolean isInbound) {
// if *some* transport can reach them, then we shouldn't banlist 'em
@@ -605,9 +754,15 @@ public abstract class TransportImpl implements Transport {
else
_wasUnreachableEntries.remove(peer);
if (_log.shouldLog(Log.INFO))
- _log.info(this.getStyle() + " setting wasUnreachable to " + yes + " for " + peer);
+ _log.info(this.getStyle() + " setting wasUnreachable to " + yes + " for " + peer,
+ yes ? new Exception() : null);
}
+ /**
+ * IP of the peer from the last connection (in or out, any transport).
+ *
+ * @param IPv4 or IPv6, non-null
+ */
public void setIP(Hash peer, byte[] ip) {
byte[] old;
synchronized (_IPMap) {
@@ -617,6 +772,11 @@ public abstract class TransportImpl implements Transport {
_context.commSystem().queueLookup(ip);
}
+ /**
+ * IP of the peer from the last connection (in or out, any transport).
+ *
+ * @return IPv4 or IPv6 or null
+ */
public static byte[] getIP(Hash peer) {
synchronized (_IPMap) {
return _IPMap.get(peer);
@@ -632,26 +792,20 @@ public abstract class TransportImpl implements Transport {
}
}
- /** @param addr non-null */
- public static boolean isPubliclyRoutable(byte addr[]) {
- if (addr.length == 4) {
- int a0 = addr[0] & 0xFF;
- if (a0 == 127) return false;
- if (a0 == 10) return false;
- int a1 = addr[1] & 0xFF;
- if (a0 == 172 && a1 >= 16 && a1 <= 31) return false;
- if (a0 == 192 && a1 == 168) return false;
- if (a0 >= 224) return false; // no multicast
- if (a0 == 0) return false;
- if (a0 == 169 && a1 == 254) return false;
- // 5/8 allocated to RIPE (30 November 2010)
- //if ((addr[0]&0xFF) == 5) return false; // Hamachi
- return true; // or at least possible to be true
- } else if (addr.length == 16) {
- return false;
- } else {
- // ipv?
- return false;
- }
+ /**
+ * @since IPv6
+ */
+ protected TransportUtil.IPv6Config getIPv6Config() {
+ return TransportUtil.getIPv6Config(_context, getStyle());
+ }
+
+ /**
+ * Allows IPv6 only if the transport is configured for it.
+ * Caller must check if we actually have a public IPv6 address.
+ * @param addr non-null
+ */
+ protected boolean isPubliclyRoutable(byte addr[]) {
+ return TransportUtil.isPubliclyRoutable(addr,
+ getIPv6Config() != TransportUtil.IPv6Config.IPV6_DISABLED);
}
}
diff --git a/router/java/src/net/i2p/router/transport/TransportManager.java b/router/java/src/net/i2p/router/transport/TransportManager.java
index f6a7c71f80..974b75696a 100644
--- a/router/java/src/net/i2p/router/transport/TransportManager.java
+++ b/router/java/src/net/i2p/router/transport/TransportManager.java
@@ -14,6 +14,7 @@ import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.HashMap;
+import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
@@ -29,6 +30,7 @@ import net.i2p.data.i2np.I2NPMessage;
import net.i2p.router.CommSystemFacade;
import net.i2p.router.OutNetMessage;
import net.i2p.router.RouterContext;
+import static net.i2p.router.transport.Transport.AddressSource.*;
import net.i2p.router.transport.crypto.DHSessionKeyBuilder;
import net.i2p.router.transport.ntcp.NTCPTransport;
import net.i2p.router.transport.udp.UDPTransport;
@@ -85,13 +87,24 @@ public class TransportManager implements TransportEventListener {
private void configTransports() {
boolean enableUDP = _context.getBooleanPropertyDefaultTrue(PROP_ENABLE_UDP);
+ Transport udp = null;
if (enableUDP) {
- UDPTransport udp = new UDPTransport(_context, _dhThread);
+ udp = new UDPTransport(_context, _dhThread);
addTransport(udp);
initializeAddress(udp);
}
- if (isNTCPEnabled(_context))
- addTransport(new NTCPTransport(_context, _dhThread));
+ if (isNTCPEnabled(_context)) {
+ Transport ntcp = new NTCPTransport(_context, _dhThread);
+ addTransport(ntcp);
+ initializeAddress(ntcp);
+ if (udp != null) {
+ // pass along the port SSU is probably going to use
+ // so that NTCP may bind early
+ int port = udp.getRequestedPort();
+ if (port > 0)
+ ntcp.externalAddressReceived(SOURCE_CONFIG, null, port);
+ }
+ }
if (_transports.isEmpty())
_log.log(Log.CRIT, "No transports are enabled");
}
@@ -100,40 +113,44 @@ public class TransportManager implements TransportEventListener {
return ctx.getBooleanPropertyDefaultTrue(PROP_ENABLE_NTCP);
}
+ /**
+ * Notify transport of ALL routable interface addresses, including IPv6.
+ * It's the transport's job to ignore what it can't handle.
+ */
private void initializeAddress(Transport t) {
- String ips = Addresses.getAnyAddress();
- if (ips == null)
- return;
- InetAddress ia;
- try {
- ia = InetAddress.getByName(ips);
- } catch (UnknownHostException e) {
- _log.error("UDP failed to bind to local address", e);
- return;
+ Set ipset = Addresses.getAddresses(false, true); // non-local, include IPv6
+ for (String ips : ipset) {
+ try {
+ InetAddress ia = InetAddress.getByName(ips);
+ byte[] ip = ia.getAddress();
+ t.externalAddressReceived(SOURCE_INTERFACE, ip, 0);
+ } catch (UnknownHostException e) {
+ _log.error("UDP failed to bind to local address", e);
+ }
}
- byte[] ip = ia.getAddress();
- t.externalAddressReceived(Transport.SOURCE_INTERFACE, ip, 0);
}
/**
- * callback from UPnP
- * Only tell SSU, it will tell NTCP
+ * Initialize from interfaces, and callback from UPnP or SSU.
+ * Tell all transports... but don't loop
*
*/
- public void externalAddressReceived(String source, byte[] ip, int port) {
- Transport t = getTransport(UDPTransport.STYLE);
- if (t != null)
- t.externalAddressReceived(source, ip, port);
+ public void externalAddressReceived(Transport.AddressSource source, byte[] ip, int port) {
+ for (Transport t : _transports.values()) {
+ // don't loop
+ if (!(source == SOURCE_SSU && t.getStyle().equals(UDPTransport.STYLE)))
+ t.externalAddressReceived(source, ip, port);
+ }
}
/**
* callback from UPnP
*
*/
- public void forwardPortStatus(String style, int port, int externalPort, boolean success, String reason) {
+ public void forwardPortStatus(String style, byte[] ip, int port, int externalPort, boolean success, String reason) {
Transport t = getTransport(style);
if (t != null)
- t.forwardPortStatus(port, externalPort, success, reason);
+ t.forwardPortStatus(ip, port, externalPort, success, reason);
}
public synchronized void startListening() {
@@ -148,7 +165,17 @@ public class TransportManager implements TransportEventListener {
_upnpManager.start();
configTransports();
_log.debug("Starting up the transport manager");
- for (Transport t : _transports.values()) {
+ // Let's do this in a predictable order to make testing easier
+ // Start NTCP first so it can get notified from SSU
+ List tps = new ArrayList();
+ Transport tp = getTransport(NTCPTransport.STYLE);
+ if (tp != null)
+ tps.add(tp);
+ tp = getTransport(UDPTransport.STYLE);
+ if (tp != null)
+ tps.add(tp);
+ //for (Transport t : _transports.values()) {
+ for (Transport t : tps) {
t.startListening();
if (_log.shouldLog(Log.DEBUG))
_log.debug("Transport " + t.getStyle() + " started");
@@ -248,7 +275,7 @@ public class TransportManager implements TransportEventListener {
*/
public boolean haveInboundCapacity(int pct) {
for (Transport t : _transports.values()) {
- if (t.getCurrentAddress() != null && t.haveCapacity(pct))
+ if (t.hasCurrentAddress() && t.haveCapacity(pct))
return true;
}
return false;
@@ -266,8 +293,8 @@ public class TransportManager implements TransportEventListener {
if ((tempSkews == null) || (tempSkews.isEmpty())) continue;
skews.addAll(tempSkews);
}
- if (_log.shouldLog(Log.DEBUG))
- _log.debug("Transport manager returning " + skews.size() + " peer clock skews.");
+ //if (_log.shouldLog(Log.DEBUG))
+ // _log.debug("Transport manager returning " + skews.size() + " peer clock skews.");
return skews;
}
@@ -324,6 +351,8 @@ public class TransportManager implements TransportEventListener {
*
* For blocking purposes, etc. it's worth checking both
* the netDb addresses and this address.
+ *
+ * @return IPv4 or IPv6 or null
*/
public byte[] getIP(Hash dest) {
return TransportImpl.getIP(dest);
@@ -332,35 +361,62 @@ public class TransportManager implements TransportEventListener {
/**
* This forces a rebuild
*/
- public Map getAddresses() {
- Map rv = new HashMap(_transports.size());
+ public List getAddresses() {
+ List rv = new ArrayList(4);
// do this first since SSU may force a NTCP change
for (Transport t : _transports.values())
t.updateAddress();
for (Transport t : _transports.values()) {
- if (t.getCurrentAddress() != null)
- rv.put(t.getStyle(), t.getCurrentAddress());
+ rv.addAll(t.getCurrentAddresses());
}
return rv;
}
/**
- * The actual or requested INTERNAL ports, for each transport,
- * which we will pass along to UPnP to be forwarded.
+ * @since IPv6
*/
- private Map getPorts() {
- Map rv = new HashMap(_transports.size());
+ static class Port {
+ public final String style;
+ public final int port;
+
+ public Port(String style, int port) {
+ this.style = style;
+ this.port = port;
+ }
+
+ @Override
+ public int hashCode() {
+ return style.hashCode() ^ port;
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (o == null)
+ return false;
+ if (! (o instanceof Port))
+ return false;
+ Port p = (Port) o;
+ return port == p.port && style.equals(p.style);
+ }
+ }
+
+ /**
+ * Include the published port, or the requested port, for each transport
+ * which we will pass along to UPnP
+ */
+ private Set getPorts() {
+ Set rv = new HashSet(4);
for (Transport t : _transports.values()) {
int port = t.getRequestedPort();
// Use UDP port for NTCP too - see comment in NTCPTransport.getRequestedPort() for why this is here
if (t.getStyle().equals(NTCPTransport.STYLE) && port <= 0 &&
- _context.getBooleanProperty(CommSystemFacadeImpl.PROP_I2NP_NTCP_AUTO_PORT)) {
+ _context.getBooleanProperty(NTCPTransport.PROP_I2NP_NTCP_AUTO_PORT)) {
Transport udp = getTransport(UDPTransport.STYLE);
if (udp != null)
port = t.getRequestedPort();
}
if (port > 0)
- rv.put(t.getStyle(), Integer.valueOf(port));
+ rv.add(new Port(t.getStyle(), port));
}
return rv;
}
@@ -461,11 +517,11 @@ public class TransportManager implements TransportEventListener {
*/
public void messageReceived(I2NPMessage message, RouterIdentity fromRouter, Hash fromRouterHash) {
if (_log.shouldLog(Log.DEBUG))
- _log.debug("I2NPMessage received: " + message.getClass().getName(), new Exception("Where did I come from again?"));
+ _log.debug("I2NPMessage received: " + message.getClass().getSimpleName() /*, new Exception("Where did I come from again?") */ );
try {
_context.inNetMessagePool().add(message, fromRouter, fromRouterHash);
- if (_log.shouldLog(Log.DEBUG))
- _log.debug("Added to in pool");
+ //if (_log.shouldLog(Log.DEBUG))
+ // _log.debug("Added to in pool");
} catch (IllegalArgumentException iae) {
if (_log.shouldLog(Log.WARN))
_log.warn("Error receiving message", iae);
@@ -477,8 +533,8 @@ public class TransportManager implements TransportEventListener {
_upnpManager.update(getPorts());
}
- public List getMostRecentErrorMessages() {
- List rv = new ArrayList(16);
+ public List getMostRecentErrorMessages() {
+ List rv = new ArrayList(16);
for (Transport t : _transports.values()) {
rv.addAll(t.getMostRecentErrorMessages());
}
@@ -502,11 +558,15 @@ public class TransportManager implements TransportEventListener {
StringBuilder buf = new StringBuilder(4*1024);
buf.append("").append(_("Router Transport Addresses")).append("
\n");
for (Transport t : _transports.values()) {
- if (t.getCurrentAddress() != null)
- buf.append(t.getCurrentAddress());
- else
+ if (t.hasCurrentAddress()) {
+ for (RouterAddress ra : t.getCurrentAddresses()) {
+ buf.append(ra.toString());
+ buf.append("\n\n");
+ }
+ } else {
buf.append(_("{0} is used for outbound connections only", t.getStyle()));
- buf.append("\n\n");
+ buf.append("\n\n");
+ }
}
buf.append("\n");
out.write(buf.toString());
diff --git a/router/java/src/net/i2p/router/transport/TransportUtil.java b/router/java/src/net/i2p/router/transport/TransportUtil.java
new file mode 100644
index 0000000000..b41a72e0e5
--- /dev/null
+++ b/router/java/src/net/i2p/router/transport/TransportUtil.java
@@ -0,0 +1,131 @@
+package net.i2p.router.transport;
+/*
+ * free (adj.): unencumbered; not under the control of others
+ * Written by jrandom in 2003 and released into the public domain
+ * with no warranty of any kind { either expressed or implied.
+ * It probably won't make your computer catch on fire { or eat
+ * your children { but it might. Use at your own risk.
+ *
+ */
+
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.util.HashMap;
+import java.util.Map;
+
+import net.i2p.data.RouterAddress;
+import net.i2p.router.RouterContext;
+
+/**
+ * @since IPv6
+ */
+public abstract class TransportUtil {
+
+ public static final String NTCP_IPV6_CONFIG = "i2np.ntcp.ipv6";
+ public static final String SSU_IPV6_CONFIG = "i2np.udp.ipv6";
+
+ public enum IPv6Config {
+ /** IPv6 disabled */
+ IPV6_DISABLED("false"),
+
+ /** lower priority than IPv4 */
+ IPV6_NOT_PREFERRED("preferIPv4"),
+
+ /** equal priority to IPv4 */
+ IPV6_ENABLED("enable"),
+
+ /** higher priority than IPv4 */
+ IPV6_PREFERRED("preferIPv6"),
+
+ /** IPv4 disabled */
+ IPV6_ONLY("only");
+
+ private final String cfgstr;
+
+ IPv6Config(String cfgstr) {
+ this.cfgstr = cfgstr;
+ }
+
+ public String toConfigString() {
+ return cfgstr;
+ }
+ }
+
+ private static final Map BY_NAME = new HashMap();
+ private static final IPv6Config DEFAULT_IPV6_CONFIG = IPv6Config.IPV6_DISABLED;
+
+ static {
+ for (IPv6Config cfg : IPv6Config.values()) {
+ BY_NAME.put(cfg.toConfigString(), cfg);
+ }
+ // alias
+ BY_NAME.put("true", IPv6Config.IPV6_ENABLED);
+ }
+
+ public static IPv6Config getIPv6Config(RouterContext ctx, String transportStyle) {
+ String cfg;
+ if (transportStyle.equals("NTCP"))
+ cfg = ctx.getProperty(NTCP_IPV6_CONFIG);
+ else if (transportStyle.equals("SSU"))
+ cfg = ctx.getProperty(SSU_IPV6_CONFIG);
+ else
+ return DEFAULT_IPV6_CONFIG;
+ return getIPv6Config(cfg);
+ }
+
+ public static IPv6Config getIPv6Config(String cfg) {
+ if (cfg == null)
+ return DEFAULT_IPV6_CONFIG;
+ IPv6Config c = BY_NAME.get(cfg);
+ if (c != null)
+ return c;
+ return DEFAULT_IPV6_CONFIG;
+ }
+
+ /**
+ * Addresses without a host (i.e. w/introducers)
+ * are assumed to be IPv4
+ */
+ public static boolean isIPv6(RouterAddress addr) {
+ // do this the fast way, without calling getIP() to parse the host string
+ String host = addr.getOption(RouterAddress.PROP_HOST);
+ return host != null && host.contains(":");
+ }
+
+ /**
+ * @param addr non-null
+ * @since IPv6 moved from TransportImpl
+ */
+ public static boolean isPubliclyRoutable(byte addr[], boolean allowIPv6) {
+ if (addr.length == 4) {
+ int a0 = addr[0] & 0xFF;
+ if (a0 == 127) return false;
+ if (a0 == 10) return false;
+ int a1 = addr[1] & 0xFF;
+ if (a0 == 172 && a1 >= 16 && a1 <= 31) return false;
+ if (a0 == 192 && a1 == 168) return false;
+ if (a0 >= 224) return false; // no multicast
+ if (a0 == 0) return false;
+ if (a0 == 169 && a1 == 254) return false;
+ // 5/8 allocated to RIPE (30 November 2010)
+ //if ((addr[0]&0xFF) == 5) return false; // Hamachi
+ return true; // or at least possible to be true
+ } else if (addr.length == 16) {
+ if (allowIPv6) {
+ // disallow 2002::/16 (6to4 RFC 3056)
+ if (addr[0] == 0x20 && addr[1] == 0x02)
+ return false;
+ try {
+ InetAddress ia = InetAddress.getByAddress(addr);
+ return
+ (!ia.isLinkLocalAddress()) &&
+ (!ia.isMulticastAddress()) &&
+ (!ia.isAnyLocalAddress()) &&
+ (!ia.isLoopbackAddress()) &&
+ (!ia.isSiteLocalAddress());
+ } catch (UnknownHostException uhe) {}
+ }
+ }
+ return false;
+ }
+}
diff --git a/router/java/src/net/i2p/router/transport/UPnP.java b/router/java/src/net/i2p/router/transport/UPnP.java
index 8d4dd1a6bc..40c5efbbd1 100644
--- a/router/java/src/net/i2p/router/transport/UPnP.java
+++ b/router/java/src/net/i2p/router/transport/UPnP.java
@@ -52,6 +52,7 @@ import org.freenetproject.ForwardPortStatus;
*
* @see "http://www.upnp.org/"
* @see "http://en.wikipedia.org/wiki/Universal_Plug_and_Play"
+ * @since 0.7.4
*/
/*
@@ -147,7 +148,7 @@ class UPnP extends ControlPoint implements DeviceChangeListener, EventListener {
InetAddress detectedIP = InetAddress.getByName(natAddress);
short status = DetectedIP.NOT_SUPPORTED;
- thinksWeAreDoubleNatted = !TransportImpl.isPubliclyRoutable(detectedIP.getAddress());
+ thinksWeAreDoubleNatted = !TransportUtil.isPubliclyRoutable(detectedIP.getAddress(), false);
// If we have forwarded a port AND we don't have a private address
if (_log.shouldLog(Log.WARN))
_log.warn("NATAddress: \"" + natAddress + "\" detectedIP: " + detectedIP + " double? " + thinksWeAreDoubleNatted);
@@ -843,7 +844,11 @@ class UPnP extends ControlPoint implements DeviceChangeListener, EventListener {
fps = new ForwardPortStatus(ForwardPortStatus.PROBABLE_FAILURE, "UPnP port forwarding apparently failed", port.portNumber);
}
Map map = Collections.singletonMap(port, fps);
- forwardCallback.portForwardStatus(map);
+ try {
+ forwardCallback.portForwardStatus(map);
+ } catch (Exception e) {
+ _log.error("UPnP RPT error", e);
+ }
}
}
}
diff --git a/router/java/src/net/i2p/router/transport/UPnPManager.java b/router/java/src/net/i2p/router/transport/UPnPManager.java
index 63acc65c09..b3fb90cc2b 100644
--- a/router/java/src/net/i2p/router/transport/UPnPManager.java
+++ b/router/java/src/net/i2p/router/transport/UPnPManager.java
@@ -11,6 +11,7 @@ import java.util.Map;
import java.util.Set;
import net.i2p.router.RouterContext;
+import static net.i2p.router.transport.Transport.AddressSource.SOURCE_UPNP;
import net.i2p.util.Addresses;
import net.i2p.util.Log;
import net.i2p.util.Translate;
@@ -25,6 +26,7 @@ import org.freenetproject.ForwardPortStatus;
* Bridge from the I2P RouterAddress data structure to
* the freenet data structures
*
+ * @since 0.7.4
* @author zzz
*/
class UPnPManager {
@@ -106,7 +108,7 @@ class UPnPManager {
* which can have multiple UPnP threads running at once, but
* that should be ok.
*/
- public void update(Map ports) {
+ public void update(Set ports) {
if (_log.shouldLog(Log.DEBUG))
_log.debug("UPnP Update with " + ports.size() + " ports");
@@ -121,9 +123,9 @@ class UPnPManager {
//}
Set forwards = new HashSet(ports.size());
- for (Map.Entry entry : ports.entrySet()) {
- String style = entry.getKey();
- int port = entry.getValue().intValue();
+ for (TransportManager.Port entry : ports) {
+ String style = entry.style;
+ int port = entry.port;
int protocol = -1;
if ("SSU".equals(style))
protocol = ForwardPort.PROTOCOL_UDP_IPV4;
@@ -151,17 +153,19 @@ class UPnPManager {
if (_log.shouldLog(Log.DEBUG))
_log.debug("UPnP Callback:");
+ byte[] ipaddr = null;
DetectedIP[] ips = _upnp.getAddress();
if (ips != null) {
for (DetectedIP ip : ips) {
// store the first public one and tell the transport manager if it changed
- if (TransportImpl.isPubliclyRoutable(ip.publicAddress.getAddress())) {
+ if (TransportUtil.isPubliclyRoutable(ip.publicAddress.getAddress(), false)) {
if (_log.shouldLog(Log.DEBUG))
_log.debug("External address: " + ip.publicAddress + " type: " + ip.natType);
if (!ip.publicAddress.equals(_detectedAddress)) {
_detectedAddress = ip.publicAddress;
- _manager.externalAddressReceived(Transport.SOURCE_UPNP, _detectedAddress.getAddress(), 0);
+ _manager.externalAddressReceived(SOURCE_UPNP, _detectedAddress.getAddress(), 0);
}
+ ipaddr = ip.publicAddress.getAddress();
break;
}
}
@@ -184,7 +188,7 @@ class UPnPManager {
else
continue;
boolean success = fps.status >= ForwardPortStatus.MAYBE_SUCCESS;
- _manager.forwardPortStatus(style, fp.portNumber, fps.externalPort, success, fps.reasonString);
+ _manager.forwardPortStatus(style, ipaddr, fp.portNumber, fps.externalPort, success, fps.reasonString);
}
}
}
diff --git a/router/java/src/net/i2p/router/transport/ntcp/EstablishState.java b/router/java/src/net/i2p/router/transport/ntcp/EstablishState.java
index 04da0506b4..9955268e98 100644
--- a/router/java/src/net/i2p/router/transport/ntcp/EstablishState.java
+++ b/router/java/src/net/i2p/router/transport/ntcp/EstablishState.java
@@ -261,8 +261,8 @@ class EstablishState {
// ok, we are onto the encrypted area
while (src.hasRemaining() && !_corrupt) {
- if (_log.shouldLog(Log.DEBUG))
- _log.debug(prefix()+"Encrypted bytes available (" + src.hasRemaining() + ")");
+ //if (_log.shouldLog(Log.DEBUG))
+ // _log.debug(prefix()+"Encrypted bytes available (" + src.hasRemaining() + ")");
while (_curEncryptedOffset < _curEncrypted.length && src.hasRemaining()) {
_curEncrypted[_curEncryptedOffset++] = src.get();
_received++;
@@ -299,8 +299,8 @@ class EstablishState {
} catch (IOException ioe) {
if (_log.shouldLog(Log.ERROR)) _log.error(prefix()+"Error writing to the baos?", ioe);
}
- if (_log.shouldLog(Log.DEBUG))
- _log.debug(prefix()+"subsequent block decrypted (" + _sz_aliceIdent_tsA_padding_aliceSig.size() + ")");
+ //if (_log.shouldLog(Log.DEBUG))
+ // _log.debug(prefix()+"subsequent block decrypted (" + _sz_aliceIdent_tsA_padding_aliceSig.size() + ")");
if (_sz_aliceIdent_tsA_padding_aliceSig.size() >= _sz_aliceIdent_tsA_padding_aliceSigSize) {
verifyInbound();
diff --git a/router/java/src/net/i2p/router/transport/ntcp/EventPumper.java b/router/java/src/net/i2p/router/transport/ntcp/EventPumper.java
index d3fa785651..fdc00de340 100644
--- a/router/java/src/net/i2p/router/transport/ntcp/EventPumper.java
+++ b/router/java/src/net/i2p/router/transport/ntcp/EventPumper.java
@@ -20,6 +20,7 @@ import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.LinkedBlockingQueue;
import net.i2p.I2PAppContext;
+import net.i2p.data.RouterAddress;
import net.i2p.data.RouterIdentity;
import net.i2p.router.CommSystemFacade;
import net.i2p.router.RouterContext;
@@ -779,9 +780,9 @@ class EventPumper implements Runnable {
key.attach(con);
con.setKey(key);
try {
- NTCPAddress naddr = con.getRemoteAddress();
- if (naddr.getPort() <= 0)
- throw new IOException("Invalid NTCP address: " + naddr);
+ RouterAddress naddr = con.getRemoteAddress();
+ if (naddr.getPort() <= 0)
+ throw new IOException("Invalid NTCP address: " + naddr);
InetSocketAddress saddr = new InetSocketAddress(naddr.getHost(), naddr.getPort());
boolean connected = con.getChannel().connect(saddr);
if (connected) {
diff --git a/router/java/src/net/i2p/router/transport/ntcp/NTCPAddress.java b/router/java/src/net/i2p/router/transport/ntcp/NTCPAddress.java
deleted file mode 100644
index b37d23cc11..0000000000
--- a/router/java/src/net/i2p/router/transport/ntcp/NTCPAddress.java
+++ /dev/null
@@ -1,134 +0,0 @@
-package net.i2p.router.transport.ntcp;
-/*
- * free (adj.): unencumbered; not under the control of others
- * Written by jrandom in 2003 and released into the public domain
- * with no warranty of any kind, either expressed or implied.
- * It probably won't make your computer catch on fire, or eat
- * your children, but it might. Use at your own risk.
- *
- */
-
-import java.util.Properties;
-
-import net.i2p.I2PAppContext;
-import net.i2p.data.DataHelper;
-import net.i2p.data.RouterAddress;
-import net.i2p.router.transport.TransportImpl;
-import net.i2p.util.Addresses;
-import net.i2p.util.Log;
-
-/**
- * Wrap up an address
- */
-public class NTCPAddress {
- private final int _port;
- private final String _host;
- //private InetAddress _addr;
- /** Port number used in RouterAddress definitions */
- public final static String PROP_PORT = RouterAddress.PROP_PORT;
- /** Host name used in RouterAddress definitions */
- public final static String PROP_HOST = RouterAddress.PROP_HOST;
- public static final int DEFAULT_COST = 10;
-
- public NTCPAddress(String host, int port) {
- if (host != null)
- _host = host.trim();
- else
- _host = null;
- _port = port;
- }
-
- /*
- public NTCPAddress() {
- _host = null;
- _port = -1;
- // _addr = null;
- }
-
- public NTCPAddress(InetAddress addr, int port) {
- if (addr != null)
- _host = addr.getHostAddress();
- _addr = addr;
- _port = port;
- }
- */
-
- public NTCPAddress(RouterAddress addr) {
- if (addr == null) {
- _host = null;
- _port = -1;
- return;
- }
- _host = addr.getOption(PROP_HOST);
- _port = addr.getPort();
- }
-
- public RouterAddress toRouterAddress() {
- if ( (_host == null) || (_port <= 0) )
- return null;
-
- RouterAddress addr = new RouterAddress();
-
- addr.setCost(DEFAULT_COST);
- //addr.setExpiration(null);
-
- Properties props = new Properties();
- props.setProperty(PROP_HOST, _host);
- props.setProperty(PROP_PORT, ""+_port);
-
- addr.setOptions(props);
- addr.setTransportStyle(NTCPTransport.STYLE);
- return addr;
- }
-
- public String getHost() { return _host; }
- //public void setHost(String host) { _host = host; }
- //public InetAddress getAddress() { return _addr; }
- //public void setAddress(InetAddress addr) { _addr = addr; }
- public int getPort() { return _port; }
- //public void setPort(int port) { _port = port; }
-
- public boolean isPubliclyRoutable() {
- return isPubliclyRoutable(_host);
- }
-
- public static boolean isPubliclyRoutable(String host) {
- if (host == null) return false;
- byte quad[] = Addresses.getIP(host);
- return TransportImpl.isPubliclyRoutable(quad);
- }
-
- @Override
- public String toString() { return _host + ":" + _port; }
-
- @Override
- public int hashCode() {
- int rv = _port;
- //if (_addr != null)
- // rv += _addr.getHostAddress().hashCode();
- //else
- if (_host != null) rv ^= _host.hashCode();
- return rv;
- }
-
- @Override
- public boolean equals(Object val) {
- if ( (val != null) && (val instanceof NTCPAddress) ) {
- NTCPAddress addr = (NTCPAddress)val;
- String hostname = null;
- if (addr.getHost() != null)
- hostname = addr.getHost().trim();
- String ourHost = getHost();
- if (ourHost != null)
- ourHost = ourHost.trim();
- return DataHelper.eq(hostname, ourHost) && getPort() == addr.getPort();
- }
- return false;
- }
-
- public boolean equals(RouterAddress addr) {
- if (addr == null) return false;
- return ( (_host.equals(addr.getOption(PROP_HOST))) &&
- (Integer.toString(_port).equals(addr.getOption(PROP_PORT))) );
- }
-}
diff --git a/router/java/src/net/i2p/router/transport/ntcp/NTCPConnection.java b/router/java/src/net/i2p/router/transport/ntcp/NTCPConnection.java
index 96951cc5f3..e18933cc99 100644
--- a/router/java/src/net/i2p/router/transport/ntcp/NTCPConnection.java
+++ b/router/java/src/net/i2p/router/transport/ntcp/NTCPConnection.java
@@ -1,6 +1,7 @@
package net.i2p.router.transport.ntcp;
import java.io.IOException;
+import java.net.Inet6Address;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.SocketChannel;
@@ -16,6 +17,7 @@ import java.util.zip.Adler32;
import net.i2p.data.Base64;
import net.i2p.data.ByteArray;
import net.i2p.data.DataHelper;
+import net.i2p.data.RouterAddress;
import net.i2p.data.RouterIdentity;
import net.i2p.data.RouterInfo;
import net.i2p.data.SessionKey;
@@ -86,7 +88,7 @@ class NTCPConnection {
private final NTCPTransport _transport;
private final boolean _isInbound;
private volatile boolean _closed;
- private NTCPAddress _remAddr;
+ private final RouterAddress _remAddr;
private RouterIdentity _remotePeer;
private long _clockSkew; // in seconds
/**
@@ -160,6 +162,7 @@ class NTCPConnection {
_log = ctx.logManager().getLog(getClass());
_created = System.currentTimeMillis();
_transport = transport;
+ _remAddr = null;
_chan = chan;
_readBufs = new ConcurrentLinkedQueue();
_writeBufs = new ConcurrentLinkedQueue();
@@ -182,7 +185,7 @@ class NTCPConnection {
* Create an outbound unconnected NTCP connection
*
*/
- public NTCPConnection(RouterContext ctx, NTCPTransport transport, RouterIdentity remotePeer, NTCPAddress remAddr) {
+ public NTCPConnection(RouterContext ctx, NTCPTransport transport, RouterIdentity remotePeer, RouterAddress remAddr) {
_context = ctx;
_log = ctx.logManager().getLog(getClass());
_created = System.currentTimeMillis();
@@ -211,15 +214,42 @@ class NTCPConnection {
_prevReadBlock = new byte[BLOCK_SIZE];
_transport.establishing(this);
}
-
+
+ /**
+ * Valid for inbound; valid for outbound shortly after creation
+ */
public SocketChannel getChannel() { return _chan; }
+
+ /**
+ * Valid for inbound; valid for outbound shortly after creation
+ */
public SelectionKey getKey() { return _conKey; }
public void setChannel(SocketChannel chan) { _chan = chan; }
public void setKey(SelectionKey key) { _conKey = key; }
public boolean isInbound() { return _isInbound; }
public boolean isEstablished() { return _established; }
+
+ /**
+ * @since IPv6
+ */
+ public boolean isIPv6() {
+ return _chan != null &&
+ _chan.socket().getInetAddress() instanceof Inet6Address;
+ }
+
+ /**
+ * Only valid during establishment; null later
+ */
public EstablishState getEstablishState() { return _establishState; }
- public NTCPAddress getRemoteAddress() { return _remAddr; }
+
+ /**
+ * Only valid for outbound; null for inbound
+ */
+ public RouterAddress getRemoteAddress() { return _remAddr; }
+
+ /**
+ * Valid for outbound; valid for inbound after handshake
+ */
public RouterIdentity getRemotePeer() { return _remotePeer; }
public void setRemotePeer(RouterIdentity ident) { _remotePeer = ident; }
diff --git a/router/java/src/net/i2p/router/transport/ntcp/NTCPTransport.java b/router/java/src/net/i2p/router/transport/ntcp/NTCPTransport.java
index 343ee5f0b0..2d808c5bbc 100644
--- a/router/java/src/net/i2p/router/transport/ntcp/NTCPTransport.java
+++ b/router/java/src/net/i2p/router/transport/ntcp/NTCPTransport.java
@@ -3,14 +3,17 @@ package net.i2p.router.transport.ntcp;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.InetAddress;
+import java.net.Inet6Address;
import java.net.UnknownHostException;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.text.DecimalFormat;
import java.text.NumberFormat;
+import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
+import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
@@ -30,12 +33,17 @@ import net.i2p.router.OutNetMessage;
import net.i2p.router.RouterContext;
import net.i2p.router.transport.CommSystemFacadeImpl;
import net.i2p.router.transport.Transport;
+import static net.i2p.router.transport.Transport.AddressSource.*;
import net.i2p.router.transport.TransportBid;
import net.i2p.router.transport.TransportImpl;
+import net.i2p.router.transport.TransportUtil;
+import static net.i2p.router.transport.TransportUtil.IPv6Config.*;
import net.i2p.router.transport.crypto.DHSessionKeyBuilder;
+import net.i2p.router.transport.udp.UDPTransport;
import net.i2p.util.Addresses;
import net.i2p.util.ConcurrentHashSet;
import net.i2p.util.Log;
+import net.i2p.util.OrderedProperties;
import net.i2p.util.Translate;
/**
@@ -52,16 +60,25 @@ public class NTCPTransport extends TransportImpl {
private final SharedBid _transientFail;
private final Object _conLock;
private final Map _conByIdent;
- private NTCPAddress _myAddress;
private final EventPumper _pumper;
private final Reader _reader;
private net.i2p.router.transport.ntcp.Writer _writer;
+ private int _ssuPort;
+ /** synch on this */
+ private final Set _endpoints;
+
/**
* list of NTCPConnection of connections not yet established that we
* want to remove on establishment or close on timeout
*/
private final Set _establishing;
+ public final static String PROP_I2NP_NTCP_HOSTNAME = "i2np.ntcp.hostname";
+ public final static String PROP_I2NP_NTCP_PORT = "i2np.ntcp.port";
+ public final static String PROP_I2NP_NTCP_AUTO_PORT = "i2np.ntcp.autoport";
+ public final static String PROP_I2NP_NTCP_AUTO_IP = "i2np.ntcp.autoip";
+ public static final int DEFAULT_COST = 10;
+
/** this is rarely if ever used, default is to bind to wildcard address */
public static final String PROP_BIND_INTERFACE = "i2np.ntcp.bindInterface";
@@ -147,6 +164,7 @@ public class NTCPTransport extends TransportImpl {
_context.statManager().createRateStat("ntcp.wantsQueuedWrite", "", "ntcp", RATES);
//_context.statManager().createRateStat("ntcp.write", "", "ntcp", RATES);
_context.statManager().createRateStat("ntcp.writeError", "", "ntcp", RATES);
+ _endpoints = new HashSet(4);
_establishing = new ConcurrentHashSet(16);
_conLock = new Object();
_conByIdent = new ConcurrentHashMap(64);
@@ -195,10 +213,9 @@ public class NTCPTransport extends TransportImpl {
isNew = true;
RouterAddress addr = getTargetAddress(target);
if (addr != null) {
- NTCPAddress naddr = new NTCPAddress(addr);
- con = new NTCPConnection(_context, this, ident, naddr);
+ con = new NTCPConnection(_context, this, ident, addr);
if (_log.shouldLog(Log.DEBUG))
- _log.debug("Send on a new con: " + con + " at " + addr + " for " + ih.toBase64());
+ _log.debug("Send on a new con: " + con + " at " + addr + " for " + ih);
_conByIdent.put(ih, con);
} else {
_log.error("we bid on a peer who doesn't have an ntcp address? " + target);
@@ -318,12 +335,12 @@ public class NTCPTransport extends TransportImpl {
if (_log.shouldLog(Log.DEBUG))
_log.debug("slow bid when trying to send to " + peer);
if (haveCapacity()) {
- if (addr.getCost() > NTCPAddress.DEFAULT_COST)
+ if (addr.getCost() > DEFAULT_COST)
return _slowCostBid;
else
return _slowBid;
} else {
- if (addr.getCost() > NTCPAddress.DEFAULT_COST)
+ if (addr.getCost() > DEFAULT_COST)
return _nearCapacityCostBid;
else
return _nearCapacityBid;
@@ -336,7 +353,7 @@ public class NTCPTransport extends TransportImpl {
* @since 0.9.6
*/
private RouterAddress getTargetAddress(RouterInfo target) {
- List addrs = target.getTargetAddresses(STYLE);
+ List addrs = getTargetAddresses(target);
for (int i = 0; i < addrs.size(); i++) {
RouterAddress addr = addrs.get(i);
byte[] ip = addr.getIP();
@@ -458,38 +475,62 @@ public class NTCPTransport extends TransportImpl {
* verify stopped with isAlive()
* Unfortunately TransportManager doesn't do that, so we
* check here to prevent two pumpers.
- * @return appears to be ignored by caller
*/
- public synchronized RouterAddress startListening() {
+ public synchronized void startListening() {
// try once again to prevent two pumpers which is fatal
if (_pumper.isAlive())
- return _myAddress != null ? _myAddress.toRouterAddress() : null;
+ return;
if (_log.shouldLog(Log.WARN)) _log.warn("Starting ntcp transport listening");
startIt();
- configureLocalAddress();
- return bindAddress();
+ RouterAddress addr = configureLocalAddress();
+ int port;
+ if (addr != null)
+ // probably not set
+ port = addr.getPort();
+ else
+ // received by externalAddressReceived() from TransportManager
+ port = _ssuPort;
+ RouterAddress myAddress = bindAddress(port);
+ if (myAddress != null) {
+ // fixed interface, or bound to the specified host
+ replaceAddress(myAddress);
+ } else if (addr != null) {
+ // specified host, bound to wildcard
+ replaceAddress(addr);
+ } else if (port > 0) {
+ // all detected interfaces
+ for (InetAddress ia : getSavedLocalAddresses()) {
+ OrderedProperties props = new OrderedProperties();
+ props.setProperty(RouterAddress.PROP_HOST, ia.getHostAddress());
+ props.setProperty(RouterAddress.PROP_PORT, Integer.toString(port));
+ int cost = getDefaultCost(ia instanceof Inet6Address);
+ myAddress = new RouterAddress(STYLE, props, cost);
+ replaceAddress(myAddress);
+ }
+ }
+ // TransportManager.startListening() calls router.rebuildRouterInfo()
}
/**
- * Only called by CSFI.
- * Caller should stop the transport first, then
- * verify stopped with isAlive()
- * @return appears to be ignored by caller
+ * Only called by externalAddressReceived().
+ *
+ * Doesn't actually restart unless addr is non-null and
+ * the port is different from the current listen port.
+ *
+ * If we had interface addresses before, we lost them.
+ *
+ * @param addr may be null
*/
- public synchronized RouterAddress restartListening(RouterAddress addr) {
- // try once again to prevent two pumpers which is fatal
- // we could just return null since the return value is ignored
- if (_pumper.isAlive())
- return _myAddress != null ? _myAddress.toRouterAddress() : null;
- if (_log.shouldLog(Log.WARN)) _log.warn("Restarting ntcp transport listening");
-
- startIt();
- if (addr == null)
- _myAddress = null;
- else
- _myAddress = new NTCPAddress(addr);
- return bindAddress();
+ private synchronized void restartListening(RouterAddress addr) {
+ if (addr != null) {
+ RouterAddress myAddress = bindAddress(addr.getPort());
+ if (myAddress != null)
+ replaceAddress(myAddress);
+ else
+ replaceAddress(addr);
+ // UDPTransport.rebuildExternalAddress() calls router.rebuildRouterInfo()
+ }
}
/**
@@ -520,9 +561,19 @@ public class NTCPTransport extends TransportImpl {
return _pumper.isAlive();
}
- /** call from synchronized method */
- private RouterAddress bindAddress() {
- if (_myAddress != null) {
+ /**
+ * Only does something if myPort > 0 and myPort != current bound port
+ * (or there's no current port, or the configured interface or hostname changed).
+ * If we are changing the bound port, this restarts everything, which takes a long time.
+ *
+ * call from synchronized method
+ *
+ * @param myPort does nothing if <= 0
+ * @return new address ONLY if bound to specific address, otherwise null
+ */
+ private RouterAddress bindAddress(int port) {
+ RouterAddress myAddress = null;
+ if (port > 0) {
InetAddress bindToAddr = null;
String bindTo = _context.getProperty(PROP_BIND_INTERFACE);
@@ -530,70 +581,122 @@ public class NTCPTransport extends TransportImpl {
// If we are configured with a fixed IP address,
// AND it's one of our local interfaces,
// bind only to that.
- boolean isFixed = _context.getProperty(CommSystemFacadeImpl.PROP_I2NP_NTCP_AUTO_IP, "true")
- .toLowerCase(Locale.US).equals("false");
- String fixedHost = _context.getProperty(CommSystemFacadeImpl.PROP_I2NP_NTCP_HOSTNAME);
- if (isFixed && fixedHost != null) {
- try {
- String testAddr = InetAddress.getByName(fixedHost).getHostAddress();
- if (Addresses.getAddresses().contains(testAddr))
- bindTo = testAddr;
- } catch (UnknownHostException uhe) {}
- }
+ bindTo = getFixedHost();
}
if (bindTo != null) {
try {
bindToAddr = InetAddress.getByName(bindTo);
} catch (UnknownHostException uhe) {
- _log.log(Log.CRIT, "Invalid NTCP bind interface specified [" + bindTo + "]", uhe);
+ _log.error("Invalid NTCP bind interface specified [" + bindTo + "]", uhe);
// this can be implemented later, just updates some stats
// see udp/UDPTransport.java
//setReachabilityStatus(CommSystemFacade.STATUS_HOSED);
- return null;
+ //return null;
+ // fall thru
}
}
try {
- ServerSocketChannel chan = ServerSocketChannel.open();
- chan.configureBlocking(false);
-
- int port = _myAddress.getPort();
- if (port > 0 && port < 1024)
- _log.logAlways(Log.WARN, "Specified NTCP port is " + port + ", ports lower than 1024 not recommended");
- InetSocketAddress addr = null;
- if(bindToAddr==null) {
+ InetSocketAddress addr;
+ if (bindToAddr == null) {
addr = new InetSocketAddress(port);
} else {
addr = new InetSocketAddress(bindToAddr, port);
if (_log.shouldLog(Log.WARN))
_log.warn("Binding only to " + bindToAddr);
+ OrderedProperties props = new OrderedProperties();
+ props.setProperty(RouterAddress.PROP_HOST, bindTo);
+ props.setProperty(RouterAddress.PROP_PORT, Integer.toString(port));
+ int cost = getDefaultCost(false);
+ myAddress = new RouterAddress(STYLE, props, cost);
}
+ if (!_endpoints.isEmpty()) {
+ // If we are already bound to the new address, OR
+ // if the host is specified and we are bound to the wildcard on the same port,
+ // do nothing. Changing config from wildcard to a specified host will
+ // require a restart.
+ if (_endpoints.contains(addr) ||
+ (bindToAddr != null && _endpoints.contains(new InetSocketAddress(port)))) {
+ if (_log.shouldLog(Log.WARN))
+ _log.warn("Already listening on " + addr);
+ return null;
+ }
+ // FIXME support multiple binds
+ // FIXME just close and unregister
+ stopWaitAndRestart();
+ }
+ if (port < 1024)
+ _log.logAlways(Log.WARN, "Specified NTCP port is " + port + ", ports lower than 1024 not recommended");
+ ServerSocketChannel chan = ServerSocketChannel.open();
+ chan.configureBlocking(false);
chan.socket().bind(addr);
+ _endpoints.add(addr);
if (_log.shouldLog(Log.INFO))
_log.info("Listening on " + addr);
_pumper.register(chan);
} catch (IOException ioe) {
_log.error("Error listening", ioe);
+ myAddress = null;
}
} else {
if (_log.shouldLog(Log.INFO))
_log.info("Outbound NTCP connections only - no listener configured");
}
-
- if (_myAddress != null) {
- RouterAddress rv = _myAddress.toRouterAddress();
- if (rv != null)
- replaceAddress(rv);
- return rv;
- } else {
- return null;
- }
+ return myAddress;
}
+ /**
+ * @return configured host or null. Must be one of our local interfaces.
+ * @since IPv6 moved from bindAddress()
+ */
+ private String getFixedHost() {
+ boolean isFixed = _context.getProperty(PROP_I2NP_NTCP_AUTO_IP, "true")
+ .toLowerCase(Locale.US).equals("false");
+ String fixedHost = _context.getProperty(PROP_I2NP_NTCP_HOSTNAME);
+ if (isFixed && fixedHost != null) {
+ try {
+ String testAddr = InetAddress.getByName(fixedHost).getHostAddress();
+ // FIXME range of IPv6 addresses
+ if (Addresses.getAddresses().contains(testAddr))
+ return testAddr;
+ } catch (UnknownHostException uhe) {}
+ }
+ return null;
+ }
+
+ /**
+ * Caller must sync
+ * @since IPv6 moved from externalAddressReceived()
+ */
+ private void stopWaitAndRestart() {
+ if (_log.shouldLog(Log.WARN))
+ _log.warn("Halting NTCP to change address");
+ stopListening();
+ // Wait for NTCP Pumper to stop so we don't end up with two...
+ while (isAlive()) {
+ try { Thread.sleep(5*1000); } catch (InterruptedException ie) {}
+ }
+ if (_log.shouldLog(Log.WARN))
+ _log.warn("Restarting NTCP transport listening");
+ startIt();
+ }
+
+ /**
+ * Hook for NTCPConnection
+ */
Reader getReader() { return _reader; }
+
+ /**
+ * Hook for NTCPConnection
+ */
net.i2p.router.transport.ntcp.Writer getWriter() { return _writer; }
+
public String getStyle() { return STYLE; }
+
+ /**
+ * Hook for NTCPConnection
+ */
EventPumper getPumper() { return _pumper; }
/**
@@ -638,33 +741,255 @@ public class NTCPTransport extends TransportImpl {
//private boolean bindAllInterfaces() { return true; }
- /** caller must synch on this */
- private void configureLocalAddress() {
- RouterContext ctx = getContext();
- if (ctx == null) {
- System.err.println("NIO transport has no context?");
- } else {
+ /**
+ * Generally returns null
+ * caller must synch on this
+ */
+ private RouterAddress configureLocalAddress() {
// this generally returns null -- see javadoc
- RouterAddress ra = CommSystemFacadeImpl.createNTCPAddress(ctx);
- if (ra != null) {
- NTCPAddress addr = new NTCPAddress(ra);
+ RouterAddress addr = createNTCPAddress();
+ if (addr != null) {
if (addr.getPort() <= 0) {
- _myAddress = null;
+ addr = null;
if (_log.shouldLog(Log.ERROR))
_log.error("NTCP address is outbound only, since the NTCP configuration is invalid");
} else {
- _myAddress = addr;
- replaceAddress(ra);
if (_log.shouldLog(Log.INFO))
- _log.info("NTCP address configured: " + _myAddress);
+ _log.info("NTCP address configured: " + addr);
}
} else {
if (_log.shouldLog(Log.INFO))
_log.info("NTCP address is outbound only");
}
- }
+ return addr;
}
+ /**
+ * This only creates an address if the hostname AND port are set in router.config,
+ * which should be rare.
+ * Otherwise, notifyReplaceAddress() below takes care of it.
+ * Note this is called both from above and from NTCPTransport.startListening()
+ *
+ * @since IPv6 moved from CSFI
+ */
+ private RouterAddress createNTCPAddress() {
+ // Fixme doesn't check PROP_BIND_INTERFACE
+ String name = _context.getProperty(PROP_I2NP_NTCP_HOSTNAME);
+ if ( (name == null) || (name.trim().length() <= 0) || ("null".equals(name)) )
+ return null;
+ int p = _context.getProperty(PROP_I2NP_NTCP_PORT, -1);
+ if (p <= 0 || p >= 64*1024)
+ return null;
+ OrderedProperties props = new OrderedProperties();
+ props.setProperty(RouterAddress.PROP_HOST, name);
+ props.setProperty(RouterAddress.PROP_PORT, Integer.toString(p));
+ int cost = getDefaultCost(false);
+ RouterAddress addr = new RouterAddress(STYLE, props, cost);
+ return addr;
+ }
+
+ private int getDefaultCost(boolean isIPv6) {
+ int rv = DEFAULT_COST;
+ if (isIPv6) {
+ TransportUtil.IPv6Config config = getIPv6Config();
+ if (config == IPV6_PREFERRED)
+ rv--;
+ else if (config == IPV6_NOT_PREFERRED)
+ rv++;
+ }
+ return rv;
+ }
+
+ /**
+ * UDP changed addresses, tell NTCP and (possibly) restart
+ *
+ * @since IPv6 moved from CSFI.notifyReplaceAddress()
+ */
+ @Override
+ public void externalAddressReceived(AddressSource source, byte[] ip, int port) {
+ if (_log.shouldLog(Log.WARN))
+ _log.warn("Received address: " + Addresses.toString(ip, port) + " from: " + source);
+ if (ip != null && !isPubliclyRoutable(ip)) {
+ if (_log.shouldLog(Log.WARN))
+ _log.warn("Invalid address: " + Addresses.toString(ip, port) + " from: " + source);
+ return;
+ }
+ if (!isAlive()) {
+ if (source == SOURCE_INTERFACE || source == SOURCE_UPNP) {
+ try {
+ InetAddress ia = InetAddress.getByAddress(ip);
+ saveLocalAddress(ia);
+ } catch (UnknownHostException uhe) {}
+ } else if (source == SOURCE_CONFIG) {
+ // save for startListening()
+ _ssuPort = port;
+ }
+ return;
+ }
+ // ignore UPnP for now, get everything from SSU
+ if (source != SOURCE_SSU)
+ return;
+ externalAddressReceived(ip, port);
+ }
+
+ /**
+ * UDP changed addresses, tell NTCP and restart.
+ * Port may be set to indicate requested port even if ip is null.
+ *
+ * @param ip previously validated
+ * @since IPv6 moved from CSFI.notifyReplaceAddress()
+ */
+ private synchronized void externalAddressReceived(byte[] ip, int port) {
+ // FIXME just take first IPv4 address for now
+ // FIXME if SSU set to hostname, NTCP will be set to IP
+ RouterAddress oldAddr = getCurrentAddress(false);
+ if (_log.shouldLog(Log.INFO))
+ _log.info("Changing NTCP Address? was " + oldAddr);
+
+ OrderedProperties newProps = new OrderedProperties();
+ int cost;
+ if (oldAddr == null) {
+ cost = getDefaultCost(ip != null && ip.length == 16);
+ } else {
+ cost = oldAddr.getCost();
+ newProps.putAll(oldAddr.getOptionsMap());
+ }
+ RouterAddress newAddr = new RouterAddress(STYLE, newProps, cost);
+
+ boolean changed = false;
+
+ // Auto Port Setting
+ // old behavior (<= 0.7.3): auto-port defaults to false, and true trumps explicit setting
+ // new behavior (>= 0.7.4): auto-port defaults to true, but explicit setting trumps auto
+ // TODO rewrite this to operate on ints instead of strings
+ String oport = newProps.getProperty(RouterAddress.PROP_PORT);
+ String nport = null;
+ String cport = _context.getProperty(PROP_I2NP_NTCP_PORT);
+ if (cport != null && cport.length() > 0) {
+ nport = cport;
+ } else if (_context.getBooleanPropertyDefaultTrue(PROP_I2NP_NTCP_AUTO_PORT)) {
+ // 0.9.6 change
+ // This wasn't quite right, as udpAddr is the EXTERNAL port and we really
+ // want NTCP to bind to the INTERNAL port the first time,
+ // because if they are different, the NAT is changing them, and
+ // it probably isn't mapping UDP and TCP the same.
+ if (port > 0)
+ // should always be true
+ nport = Integer.toString(port);
+ }
+ if (_log.shouldLog(Log.INFO))
+ _log.info("old: " + oport + " config: " + cport + " new: " + nport);
+ if (nport == null || nport.length() <= 0)
+ return;
+ // 0.9.6 change
+ // Don't have NTCP "chase" SSU's external port,
+ // as it may change, possibly frequently.
+ //if (oport == null || ! oport.equals(nport)) {
+ if (oport == null) {
+ newProps.setProperty(RouterAddress.PROP_PORT, nport);
+ changed = true;
+ }
+
+ // Auto IP Setting
+ // old behavior (<= 0.7.3): auto-ip defaults to false, and trumps configured hostname,
+ // and ignores reachability status - leading to
+ // "firewalled with inbound TCP enabled" warnings.
+ // new behavior (>= 0.7.4): auto-ip defaults to true, and explicit setting trumps auto,
+ // and only takes effect if reachability is OK.
+ // And new "always" setting ignores reachability status, like
+ // "true" was in 0.7.3
+ String ohost = newProps.getProperty(RouterAddress.PROP_HOST);
+ String enabled = _context.getProperty(PROP_I2NP_NTCP_AUTO_IP, "true").toLowerCase(Locale.US);
+ String name = _context.getProperty(PROP_I2NP_NTCP_HOSTNAME);
+ // hostname config trumps auto config
+ if (name != null && name.length() > 0)
+ enabled = "false";
+
+ // assume SSU is happy if the address is non-null
+ // TODO is this sufficient?
+ boolean ssuOK = ip != null;
+ if (_log.shouldLog(Log.INFO))
+ _log.info("old: " + ohost + " config: " + name + " auto: " + enabled + " ssuOK? " + ssuOK);
+ if (enabled.equals("always") ||
+ (Boolean.parseBoolean(enabled) && ssuOK)) {
+ // ip non-null
+ String nhost = Addresses.toString(ip);
+ if (_log.shouldLog(Log.INFO))
+ _log.info("old: " + ohost + " config: " + name + " new: " + nhost);
+ if (nhost == null || nhost.length() <= 0)
+ return;
+ if (ohost == null || ! ohost.equalsIgnoreCase(nhost)) {
+ newProps.setProperty(RouterAddress.PROP_HOST, nhost);
+ changed = true;
+ }
+ } else if (enabled.equals("false") &&
+ name != null && name.length() > 0 &&
+ !name.equals(ohost) &&
+ nport != null) {
+ // Host name is configured, and we have a port (either auto or configured)
+ // but we probably only get here if the port is auto,
+ // otherwise createNTCPAddress() would have done it already
+ if (_log.shouldLog(Log.INFO))
+ _log.info("old: " + ohost + " config: " + name + " new: " + name);
+ newProps.setProperty(RouterAddress.PROP_HOST, name);
+ changed = true;
+ } else if (ohost == null || ohost.length() <= 0) {
+ return;
+ } else if (Boolean.parseBoolean(enabled) && !ssuOK) {
+ // UDP transitioned to not-OK, turn off NTCP address
+ // This will commonly happen at startup if we were initially OK
+ // because UPnP was successful, but a subsequent SSU Peer Test determines
+ // we are still firewalled (SW firewall, bad UPnP indication, etc.)
+ if (_log.shouldLog(Log.INFO))
+ _log.info("old: " + ohost + " config: " + name + " new: null");
+ newAddr = null;
+ changed = true;
+ }
+
+ if (!changed) {
+ if (oldAddr != null) {
+ // change cost only?
+ int oldCost = oldAddr.getCost();
+ int newCost = getDefaultCost(ohost != null && ohost.contains(":"));
+ if (ADJUST_COST && !haveCapacity())
+ newCost += CONGESTION_COST_ADJUSTMENT;
+ if (newCost != oldCost) {
+ newAddr.setCost(newCost);
+ if (_log.shouldLog(Log.WARN))
+ _log.warn("Changing NTCP cost from " + oldCost + " to " + newCost);
+ // fall thru and republish
+ } else {
+ _log.info("No change to NTCP Address");
+ return;
+ }
+ } else {
+ _log.info("No change to NTCP Address");
+ return;
+ }
+ }
+
+ // stopListening stops the pumper, readers, and writers, so required even if
+ // oldAddr == null since startListening starts them all again
+ //
+ // really need to fix this so that we can change or create an inbound address
+ // without tearing down everything
+ // Especially on disabling the address, we shouldn't tear everything down.
+ //
+ //if (_log.shouldLog(Log.WARN))
+ // _log.warn("Halting NTCP to change address");
+ //stopListening();
+ // Wait for NTCP Pumper to stop so we don't end up with two...
+ //while (isAlive()) {
+ // try { Thread.sleep(5*1000); } catch (InterruptedException ie) {}
+ //}
+ restartListening(newAddr);
+ if (_log.shouldLog(Log.WARN))
+ _log.warn("Updating NTCP Address with " + newAddr);
+ return;
+ }
+
+
+
/**
* If we didn't used to be forwarded, and we have an address,
* and we are configured to use UPnP, update our RouterAddress
@@ -676,21 +1001,21 @@ public class NTCPTransport extends TransportImpl {
* NTCP address when it transitions to OK.
*/
@Override
- public void forwardPortStatus(int port, int externalPort, boolean success, String reason) {
+ public void forwardPortStatus(byte[] ip, int port, int externalPort, boolean success, String reason) {
if (_log.shouldLog(Log.WARN)) {
if (success)
- _log.warn("UPnP has opened the NTCP port: " + port);
+ _log.warn("UPnP has opened the NTCP port: " + port + " via " + Addresses.toString(ip, externalPort));
else
_log.warn("UPnP has failed to open the NTCP port: " + port + " reason: " + reason);
}
}
/**
- * @return current port, else NTCP configured port, else -1 (but not UDP port if auto)
+ * @return current IPv4 port, else NTCP configured port, else -1 (but not UDP port if auto)
*/
@Override
public int getRequestedPort() {
- NTCPAddress addr = _myAddress;
+ RouterAddress addr = getCurrentAddress(false);
if (addr != null) {
int port = addr.getPort();
if (port > 0)
@@ -700,7 +1025,7 @@ public class NTCPTransport extends TransportImpl {
// from here, so we do it in TransportManager.
// if (Boolean.valueOf(_context.getProperty(CommSystemFacadeImpl.PROP_I2NP_NTCP_AUTO_PORT)).booleanValue())
// return foo;
- return _context.getProperty(CommSystemFacadeImpl.PROP_I2NP_NTCP_PORT, -1);
+ return _context.getProperty(PROP_I2NP_NTCP_PORT, -1);
}
/**
@@ -714,7 +1039,8 @@ public class NTCPTransport extends TransportImpl {
*/
@Override
public short getReachabilityStatus() {
- if (isAlive() && _myAddress != null) {
+ // If we have an IPv4 address
+ if (isAlive() && getCurrentAddress(false) != null) {
for (NTCPConnection con : _conByIdent.values()) {
if (con.isInbound())
return CommSystemFacade.STATUS_OK;
@@ -733,18 +1059,17 @@ public class NTCPTransport extends TransportImpl {
_writer.stopWriting();
_reader.stopReading();
_finisher.stop();
- Map cons = null;
+ List cons;
synchronized (_conLock) {
- cons = new HashMap(_conByIdent);
+ cons = new ArrayList(_conByIdent.values());
_conByIdent.clear();
}
- for (Iterator iter = cons.values().iterator(); iter.hasNext(); ) {
- NTCPConnection con = (NTCPConnection)iter.next();
+ for (NTCPConnection con : cons) {
con.close();
}
NTCPConnection.releaseResources();
- // will this work?
replaceAddress(null);
+ _endpoints.clear();
}
public static final String STYLE = "NTCP";
@@ -753,7 +1078,7 @@ public class NTCPTransport extends TransportImpl {
@Override
public void renderStatusHTML(java.io.Writer out, String urlBase, int sortFlags) throws IOException {
- TreeSet peers = new TreeSet(getComparator(sortFlags));
+ TreeSet peers = new TreeSet(getComparator(sortFlags));
peers.addAll(_conByIdent.values());
long offsetTotal = 0;
@@ -771,6 +1096,7 @@ public class NTCPTransport extends TransportImpl {
"\n" +
"| ").append(_("Peer")).append(" | " +
"").append(_("Dir")).append(" | " +
+ "").append(_("IPv6")).append(" | " +
"").append(_("Idle")).append(" | " +
"").append(_("In/Out")).append(" | " +
"").append(_("Up")).append(" | " +
@@ -783,8 +1109,7 @@ public class NTCPTransport extends TransportImpl {
"
|---|
\n");
out.write(buf.toString());
buf.setLength(0);
- for (Iterator iter = peers.iterator(); iter.hasNext(); ) {
- NTCPConnection con = (NTCPConnection)iter.next();
+ for (NTCPConnection con : peers) {
buf.append("");
buf.append(_context.commSystem().renderPeerHTML(con.getRemotePeer().calculateHash()));
//byte[] ip = getIP(con.getRemotePeer().calculateHash());
@@ -795,6 +1120,11 @@ public class NTCPTransport extends TransportImpl {
buf.append("![\"Inbound\"](\"/themes/console/images/inbound.png\" "\\"\").append(_(\"Inbound\")).append(\"\\"/") ");
else
buf.append("![\"Outbound\"](\"/themes/console/images/outbound.png\" "\\"\").append(_(\"Outbound\")).append(\"\\"/") ");
+ buf.append(" | ");
+ if (con.isIPv6())
+ buf.append("✓");
+ else
+ buf.append(" ");
buf.append(" | ");
buf.append(DataHelper.formatDuration2(con.getTimeSinceReceive()));
buf.append(THINSP).append(DataHelper.formatDuration2(con.getTimeSinceSend()));
@@ -843,7 +1173,8 @@ public class NTCPTransport extends TransportImpl {
if (!peers.isEmpty()) {
// buf.append(" |
|
\n");
- buf.append("
|
\n");
- buf.append("");
}
+ } // numPeers > 0
buf.append("
\n");
/*****
@@ -2533,7 +2833,8 @@ public class UDPTransport extends TransportImpl implements TimedWeightedPriority
long pingCutoff = now - (2 * 60*60*1000);
long pingFirewallCutoff = now - PING_FIREWALL_CUTOFF;
boolean shouldPingFirewall = _reachabilityStatus != CommSystemFacade.STATUS_OK;
- boolean pingOneOnly = shouldPingFirewall && _externalListenPort == _endpoint.getListenPort();
+ int currentListenPort = getListenPort(false);
+ boolean pingOneOnly = shouldPingFirewall && getExternalPort(false) == currentListenPort;
boolean shortLoop = shouldPingFirewall;
_expireBuffer.clear();
_runCount++;
@@ -2666,27 +2967,53 @@ public class UDPTransport extends TransportImpl implements TimedWeightedPriority
return _reachabilityStatus;
}
+
@Override
public void recheckReachability() {
_testEvent.runTest();
}
- PeerState pickTestPeer(RemoteHostId dontInclude) {
+ /**
+ * Pick a Bob (if we are Alice) or a Charlie (if we are Bob).
+ *
+ * For Bob (as called from PeerTestEvent below), returns an established IPv4 peer.
+ * While the protocol allows Alice to select an unestablished Bob, we don't support that.
+ *
+ * For Charlie (as called from PeerTestManager), returns an established IPv4 or IPv6 peer.
+ * (doesn't matter how Bob and Charlie communicate)
+ *
+ * Any returned peer must advertise an IPv4 address to prove it is IPv4-capable.
+ *
+ * @param peerRole BOB or CHARLIE only
+ * @param dontInclude may be null
+ * @return IPv4 peer or null
+ */
+ PeerState pickTestPeer(PeerTestState.Role peerRole, RemoteHostId dontInclude) {
+ if (peerRole == ALICE)
+ throw new IllegalArgumentException();
List peers = new ArrayList(_peersByIdent.values());
for (Iterator iter = new RandomIterator(peers); iter.hasNext(); ) {
PeerState peer = iter.next();
if ( (dontInclude != null) && (dontInclude.equals(peer.getRemoteHostId())) )
continue;
+ // enforce IPv4 connection for BOB
+ byte[] ip = peer.getRemoteIP();
+ if (peerRole == BOB && ip.length != 4)
+ continue;
+ // enforce IPv4 advertised for all
RouterInfo peerInfo = _context.netDb().lookupRouterInfoLocally(peer.getRemotePeer());
if (peerInfo == null)
continue;
- RouterAddress addr = peerInfo.getTargetAddress(STYLE);
- if (addr == null)
- continue;
- byte[] ip = addr.getIP();
+ ip = null;
+ List addrs = getTargetAddresses(peerInfo);
+ for (RouterAddress addr : addrs) {
+ ip = addr.getIP();
+ if (ip != null && ip.length == 4)
+ break;
+ }
if (ip == null)
continue;
- if (DataHelper.eq(ip, 0, getExternalIP(), 0, 2))
+ if (isTooClose(ip))
continue;
return peer;
}
@@ -2699,6 +3026,9 @@ public class UDPTransport extends TransportImpl implements TimedWeightedPriority
//return ( (val != null) && ("true".equals(val)) );
}
+ /**
+ * Initiate a test (we are Alice)
+ */
private class PeerTestEvent extends SimpleTimer2.TimedEvent {
private volatile boolean _alive;
/** when did we last test our reachability */
@@ -2725,7 +3055,7 @@ public class UDPTransport extends TransportImpl implements TimedWeightedPriority
}
private void runTest() {
- PeerState bob = pickTestPeer(null);
+ PeerState bob = pickTestPeer(BOB, null);
if (bob != null) {
if (_log.shouldLog(Log.INFO))
_log.info("Running periodic test with bob = " + bob);
diff --git a/router/java/src/net/i2p/router/tunnel/TunnelGatewayPumper.java b/router/java/src/net/i2p/router/tunnel/TunnelGatewayPumper.java
index 7dfe8dc764..680a23966e 100644
--- a/router/java/src/net/i2p/router/tunnel/TunnelGatewayPumper.java
+++ b/router/java/src/net/i2p/router/tunnel/TunnelGatewayPumper.java
@@ -42,10 +42,14 @@ class TunnelGatewayPumper implements Runnable {
_context = ctx;
_wantsPumping = new LinkedHashSet(16);
_backlogged = new HashSet(16);
- long maxMemory = Runtime.getRuntime().maxMemory();
- if (maxMemory == Long.MAX_VALUE)
- maxMemory = 96*1024*1024l;
- _pumpers = (int) Math.max(MIN_PUMPERS, Math.min(MAX_PUMPERS, 1 + (maxMemory / (32*1024*1024))));
+ if (ctx.getBooleanProperty("i2p.dummyTunnelManager")) {
+ _pumpers = 1;
+ } else {
+ long maxMemory = Runtime.getRuntime().maxMemory();
+ if (maxMemory == Long.MAX_VALUE)
+ maxMemory = 96*1024*1024l;
+ _pumpers = (int) Math.max(MIN_PUMPERS, Math.min(MAX_PUMPERS, 1 + (maxMemory / (32*1024*1024))));
+ }
for (int i = 0; i < _pumpers; i++)
new I2PThread(this, "Tunnel GW pumper " + (i+1) + '/' + _pumpers, true).start();
}
diff --git a/router/java/test/junit/net/i2p/router/SSUDemo.java b/router/java/test/junit/net/i2p/router/SSUDemo.java
index 30db9d1736..fb622294c0 100644
--- a/router/java/test/junit/net/i2p/router/SSUDemo.java
+++ b/router/java/test/junit/net/i2p/router/SSUDemo.java
@@ -27,14 +27,16 @@ public class SSUDemo {
RouterContext _us;
public static void main(String args[]) {
+ boolean testNTCP = args.length > 0 && args[0].equals("ntcp");
SSUDemo demo = new SSUDemo();
- demo.run();
+ demo.run(testNTCP);
}
public SSUDemo() {}
- public void run() {
+
+ public void run(boolean testNTCP) {
String cfgFile = "router.config";
- Properties envProps = getEnv();
+ Properties envProps = getEnv(testNTCP);
Router r = new Router(cfgFile, envProps);
r.runRouter();
_us = r.getContext();
@@ -50,21 +52,36 @@ public class SSUDemo {
loadPeers();
}
- private Properties getEnv() {
- Properties envProps = System.getProperties();
- // disable the TCP transport, as its deprecated
- envProps.setProperty("i2np.tcp.disable", "true");
+ private static Properties getEnv(boolean testNTCP) {
+ Properties envProps = new Properties();
+ // disable one of the transports and UPnP
+ if (testNTCP)
+ envProps.setProperty("i2np.udp.enable", "false");
+ else
+ envProps.setProperty("i2np.ntcp.enable", "false");
+ envProps.setProperty("i2np.upnp.enable", "false");
// we want SNTP synchronization for replay prevention
envProps.setProperty("time.disabled", "false");
// allow 127.0.0.1/10.0.0.1/etc (useful for testing). If this is false,
// peers who say they're on an invalid IP are banlisted
envProps.setProperty("i2np.udp.allowLocal", "true");
+ envProps.setProperty("i2np.ntcp.allowLocal", "true");
+ // IPv6
+ envProps.setProperty("i2np.udp.ipv6", "enable");
+ envProps.setProperty("i2np.ntcp.ipv6", "enable");
// explicit IP+port. at least one router on the net has to have their IP+port
// set, since there has to be someone to detect one's IP off. most don't need
// to set these though
- envProps.setProperty("i2np.udp.host", "127.0.0.1");
- envProps.setProperty("i2np.udp.internalPort", "12000");
- envProps.setProperty("i2np.udp.port", "12000");
+ //envProps.setProperty("i2np.udp.host", "127.0.0.1");
+ envProps.setProperty("i2np.udp.host", "::1");
+ envProps.setProperty("i2np.ntcp.autoip", "false");
+ envProps.setProperty("i2np.ntcp.hostname", "::1");
+ // we don't have a context yet to use its random
+ String port = Integer.toString(44000 + (((int) System.currentTimeMillis()) & (16384 - 1)));
+ envProps.setProperty("i2np.udp.internalPort", port);
+ envProps.setProperty("i2np.udp.port", port);
+ envProps.setProperty("i2np.ntcp.autoport", "false");
+ envProps.setProperty("i2np.ntcp.port", port);
// disable I2CP, the netDb, peer testing/profile persistence, and tunnel
// creation/management
envProps.setProperty("i2p.dummyClientFacade", "true");
@@ -73,18 +90,28 @@ public class SSUDemo {
envProps.setProperty("i2p.dummyTunnelManager", "true");
// set to false if you want to use HMAC-SHA256-128 instead of HMAC-MD5-128 as
// the SSU MAC
- envProps.setProperty("i2p.HMACMD5", "true");
+ //envProps.setProperty("i2p.HMACMD5", "true");
// if you're using the HMAC MD5, by default it will use a 32 byte MAC field,
// which is a bug, as it doesn't generate the same values as a 16 byte MAC field.
// set this to false if you don't want the bug
- envProps.setProperty("i2p.HMACBrokenSize", "false");
+ //envProps.setProperty("i2p.HMACBrokenSize", "false");
// no need to include any stats in the routerInfo we send to people on SSU
// session establishment
envProps.setProperty("router.publishPeerRankings", "false");
// write the logs to ./logs/log-router-*.txt (logger configured with the file
// ./logger.config, or another config file specified as
// -Dlogger.configLocation=blah)
- envProps.setProperty("loggerFilenameOverride", "logs/log-router-@.txt");
+ // avoid conflicts over log
+ envProps.setProperty("loggerFilenameOverride", "logs/log-router-" + port + "-@.txt");
+ System.setProperty("wrapper.logfile", "wrapper-" + port + ".log");
+ // avoid conflicts over key backup etc. so we don't all use the same keys
+ envProps.setProperty("router.keyBackupDir", "keyBackup/router-" + port);
+ envProps.setProperty("router.info.location", "router-" + port + ".info");
+ envProps.setProperty("router.keys.location", "router-" + port + ".keys");
+ envProps.setProperty("router.configLocation", "router-" + port + ".config");
+ envProps.setProperty("router.pingFile", "router-" + port + ".ping");
+ // avoid conflicts over blockfile
+ envProps.setProperty("i2p.naming.impl", "net.i2p.client.naming.HostsTxtNamingService");
return envProps;
}
@@ -98,14 +125,15 @@ public class SSUDemo {
}
/** random place for storing router info files - written as $dir/base64(SHA256(info.getIdentity)) */
- private File getInfoDir() { return new File("/tmp/ssuDemoInfo/"); }
+ private static File getInfoDir() { return new File("/tmp/ssuDemoInfo/"); }
- private void storeMyInfo(RouterInfo info) {
+ private static void storeMyInfo(RouterInfo info) {
File infoDir = getInfoDir();
if (!infoDir.exists())
infoDir.mkdirs();
FileOutputStream fos = null;
File infoFile = new File(infoDir, info.getIdentity().calculateHash().toBase64());
+ infoFile.deleteOnExit();
try {
fos = new FileOutputStream(infoFile);
info.writeBytes(fos);
@@ -165,7 +193,8 @@ public class SSUDemo {
out.setPriority(100);
out.setTarget(ri);
FooMessage data = new FooMessage(_us, new byte[] { 0x0, 0x1, 0x2, 0x3 });
- System.out.println("SEND: " + Base64.encode(data.getData()));
+ System.out.println("SEND: " + Base64.encode(data.getData()) + " to " +
+ ri.getIdentity().calculateHash());
out.setMessage(data);
// job fired if we can't contact them, or if it takes too long to get an ACK
out.setOnFailedSendJob(null);
@@ -198,45 +227,57 @@ public class SSUDemo {
public FooJobBuilder() {
I2NPMessageImpl.registerBuilder(new FooBuilder(), FooMessage.MESSAGE_TYPE);
}
+
public Job createJob(I2NPMessage receivedMessage, RouterIdentity from, Hash fromHash) {
return new FooHandleJob(_us, receivedMessage, from, fromHash);
}
}
- private class FooHandleJob extends JobImpl {
- private I2NPMessage _msg;
+
+ private static class FooHandleJob extends JobImpl {
+ private final I2NPMessage _msg;
+ private final Hash _from;
+
public FooHandleJob(RouterContext ctx, I2NPMessage receivedMessage, RouterIdentity from, Hash fromHash) {
super(ctx);
_msg = receivedMessage;
+ _from = fromHash;
}
+
public void runJob() {
// we know its a FooMessage, since thats the type of message that the handler
// is registered as
FooMessage m = (FooMessage)_msg;
- System.out.println("RECV: " + Base64.encode(m.getData()));
+ System.out.println("RECV FooMessage: " + Base64.encode(m.getData()) + " from " + _from);
}
public String getName() { return "Handle Foo message"; }
}
- private class FooBuilder implements I2NPMessageImpl.Builder {
+
+ private static class FooBuilder implements I2NPMessageImpl.Builder {
public I2NPMessage build(I2PAppContext ctx) { return new FooMessage(ctx, null); }
}
/**
* Just carry some data...
*/
- class FooMessage extends I2NPMessageImpl {
+ private static class FooMessage extends I2NPMessageImpl {
private byte[] _data;
public static final int MESSAGE_TYPE = 17;
+
public FooMessage(I2PAppContext ctx, byte data[]) {
super(ctx);
_data = data;
}
+
/** pull the read data off */
public byte[] getData() { return _data; }
+
/** specify the payload to be sent */
public void setData(byte data[]) { _data = data; }
public int getType() { return MESSAGE_TYPE; }
+
protected int calculateWrittenLength() { return _data.length; }
+
public void readMessage(byte[] data, int offset, int dataSize, int type) throws I2NPMessageException {
_data = new byte[dataSize];
System.arraycopy(data, offset, _data, 0, dataSize);
@@ -260,22 +301,27 @@ public class SSUDemo {
return new HandleJob(_us, receivedMessage, from, fromHash);
}
}
+
private class HandleJob extends JobImpl {
- private I2NPMessage _msg;
+ private final I2NPMessage _msg;
+
public HandleJob(RouterContext ctx, I2NPMessage receivedMessage, RouterIdentity from, Hash fromHash) {
super(ctx);
_msg = receivedMessage;
}
+
public void runJob() {
// we know its a DatabaseStoreMessage, since thats the type of message that the handler
// is registered as
DatabaseStoreMessage m = (DatabaseStoreMessage)_msg;
+ System.out.println("RECV: " + m);
try {
_us.netDb().store(m.getKey(), (RouterInfo) m.getEntry());
} catch (IllegalArgumentException iae) {
iae.printStackTrace();
}
}
+
public String getName() { return "Handle netDb store"; }
}
}
diff --git a/router/java/test/junit/net/i2p/router/transport/udp/UDPEndpointTestStandalone.java b/router/java/test/junit/net/i2p/router/transport/udp/UDPEndpointTestStandalone.java
index 5b9d3de59c..5e304f5602 100644
--- a/router/java/test/junit/net/i2p/router/transport/udp/UDPEndpointTestStandalone.java
+++ b/router/java/test/junit/net/i2p/router/transport/udp/UDPEndpointTestStandalone.java
@@ -1,6 +1,8 @@
package net.i2p.router.transport.udp;
+import java.net.InetAddress;
import java.net.SocketException;
+import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
@@ -18,11 +20,11 @@ import net.i2p.util.Log;
* --zab
*/
public class UDPEndpointTestStandalone {
- private RouterContext _context;
- private Log _log;
+ private final RouterContext _context;
+ private final Log _log;
private UDPEndpoint _endpoints[];
- private boolean _beginTest;
- private List _sentNotReceived;
+ private volatile boolean _beginTest;
+ private final List _sentNotReceived;
public UDPEndpointTestStandalone(RouterContext ctx) {
_context = ctx;
@@ -33,12 +35,17 @@ public class UDPEndpointTestStandalone {
public void runTest(int numPeers) {
_log.debug("Run test("+numPeers+")");
_endpoints = new UDPEndpoint[numPeers];
- int base = 2000 + _context.random().nextInt(10000);
+ int base = 44000 + _context.random().nextInt(10000);
for (int i = 0; i < numPeers; i++) {
_log.debug("Building " + i);
UDPEndpoint endpoint = new UDPEndpoint(_context, null, base + i, null);
_endpoints[i] = endpoint;
- endpoint.startup();
+ try {
+ endpoint.startup();
+ } catch (SocketException se) {
+ _log.error("die", se);
+ throw new RuntimeException(se);
+ }
I2PThread read = new I2PThread(new TestRead(endpoint), "Test read " + i);
I2PThread write = new I2PThread(new TestWrite(endpoint), "Test write " + i);
//read.setDaemon(true);
@@ -51,7 +58,7 @@ public class UDPEndpointTestStandalone {
}
private class TestRead implements Runnable {
- private UDPEndpoint _endpoint;
+ private final UDPEndpoint _endpoint;
public TestRead(UDPEndpoint peer) {
_endpoint = peer;
}
@@ -83,7 +90,7 @@ public class UDPEndpointTestStandalone {
}
private class TestWrite implements Runnable {
- private UDPEndpoint _endpoint;
+ private final UDPEndpoint _endpoint;
public TestWrite(UDPEndpoint peer) {
_endpoint = peer;
}
@@ -92,8 +99,16 @@ public class UDPEndpointTestStandalone {
try { Thread.sleep(2000); } catch (InterruptedException ie) {}
}
try { Thread.sleep(2000); } catch (InterruptedException ie) {}
+ PacketBuilder builder = new PacketBuilder(_context, null);
+ InetAddress localhost = null;
+ try {
+ localhost = InetAddress.getLocalHost();
+ } catch (UnknownHostException uhe) {
+ _log.error("die", uhe);
+ System.exit(0);
+ }
_log.debug("Beginning to write");
- for (int curPacket = 0; curPacket < 10000; curPacket++) {
+ for (int curPacket = 0; curPacket < 2000; curPacket++) {
byte data[] = new byte[1024];
_context.random().nextBytes(data);
int curPeer = (curPacket % _endpoints.length);
@@ -101,27 +116,21 @@ public class UDPEndpointTestStandalone {
curPeer++;
if (curPeer >= _endpoints.length)
curPeer = 0;
- short priority = 1;
- long expiration = -1;
- UDPPacket packet = UDPPacket.acquire(_context, true);
- //try {
- if (true) throw new RuntimeException("fixme");
- //packet.initialize(priority, expiration, InetAddress.getLocalHost(), _endpoints[curPeer].getListenPort());
- // Following method is commented out in UDPPacket
- //packet.writeData(data, 0, 1024);
- packet.getPacket().setLength(1024);
+ UDPPacket packet = builder.buildPacket(data, localhost, _endpoints[curPeer].getListenPort());
int outstanding = _sentNotReceived.size() + 1;
_sentNotReceived.add(new ByteArray(data, 0, 1024));
_log.debug("Sending packet " + curPacket + " with outstanding " + outstanding);
+ try {
_endpoint.send(packet);
- //try { Thread.sleep(10); } catch (InterruptedException ie) {}
- //} catch (UnknownHostException uhe) {
- // _log.error("foo!", uhe);
- //}
- //if (_log.shouldLog(Log.DEBUG)) {
+ } catch (Exception e) {
+ _log.error("die", e);
+ break;
+ }
+ try { Thread.sleep(3); } catch (InterruptedException ie) {}
+ //if (_log.shouldLog(Log.DEBUG))
// _log.debug("Sent to " + _endpoints[curPeer].getListenPort() + " from " + _endpoint.getListenPort());
- //}
}
+ _log.debug("Done sending packets");
try { Thread.sleep(10*1000); } catch (InterruptedException e) {}
System.exit(0);
}
@@ -133,7 +142,16 @@ public class UDPEndpointTestStandalone {
Properties props = new Properties();
props.setProperty("stat.logFile", "udpEndpointTest.stats");
props.setProperty("stat.logFilters", "*");
- UDPEndpointTestStandalone test = new UDPEndpointTestStandalone(new RouterContext(null, props));
+ props.setProperty("i2p.dummyClientFacade", "true");
+ props.setProperty("i2p.dummyNetDb", "true");
+ props.setProperty("i2p.dummyPeerManager", "true");
+ props.setProperty("i2p.dummyTunnelManager", "true");
+ props.setProperty("i2p.vmCommSystem", "true");
+ props.setProperty("i2np.bandwidth.inboundKBytesPerSecond", "9999");
+ props.setProperty("i2np.bandwidth.outboundKBytesPerSecond", "9999");
+ RouterContext ctx = new RouterContext(null, props);
+ ctx.initAll();
+ UDPEndpointTestStandalone test = new UDPEndpointTestStandalone(ctx);
test.runTest(2);
}
}