* 2004-12-21 0.4.2.5 released

2004-12-21  jrandom
    * Track a new stat for expired client leases (client.leaseSetExpired).

apps/i2ptunnel/java/src/net/i2p/i2ptunnel/I2PTunnel.java

@@ -229,6 +229,8 @@ public class I2PTunnel implements Logging, EventDispatcher {
             runClientOptions(args, l);
         } else if ("server".equals(cmdname)) {
             runServer(args, l);
+        } else if ("httpserver".equals(cmdname)) {
+            runHttpServer(args, l);
         } else if ("textserver".equals(cmdname)) {
             runTextServer(args, l);
         } else if ("client".equals(cmdname)) {
@@ -281,6 +283,7 @@ public class I2PTunnel implements Logging, EventDispatcher {
         l.log("owndest yes|no");
         l.log("ping <args>");
         l.log("server <host> <port> <privkeyfile>");
+        l.log("httpserver <host> <port> <spoofedhost> <privkeyfile>");
         l.log("textserver <host> <port> <privkey>");
         l.log("genkeys <privkeyfile> [<pubkeyfile>]");
         l.log("gentextkeys");
@@ -370,6 +373,65 @@ public class I2PTunnel implements Logging, EventDispatcher {
         }
     }
 
+    /**
+     * Run the HTTP server pointing at the host and port specified using the private i2p
+     * destination loaded from the specified file, replacing the HTTP headers
+     * so that the Host: specified is the one spoofed. <p />
+     *
+     * Sets the event "serverTaskId" = Integer(taskId) after the tunnel has been started (or -1 on error)
+     * Also sets the event "openServerResult" = "ok" or "error" (displaying "Ready!" on the logger after
+     * 'ok').  So, success = serverTaskId != -1 and openServerResult = ok.
+     *
+     * @param args {hostname, portNumber, spoofedHost, privKeyFilename}
+     * @param l logger to receive events and output
+     */
+    public void runHttpServer(String args[], Logging l) {
+        if (args.length == 4) {
+            InetAddress serverHost = null;
+            int portNum = -1;
+            File privKeyFile = null;
+            try {
+                serverHost = InetAddress.getByName(args[0]);
+            } catch (UnknownHostException uhe) {
+                l.log("unknown host");
+                _log.error(getPrefix() + "Error resolving " + args[0], uhe);
+                notifyEvent("serverTaskId", new Integer(-1));
+                return;
+            }
+
+            try {
+                portNum = Integer.parseInt(args[1]);
+            } catch (NumberFormatException nfe) {
+                l.log("invalid port");
+                _log.error(getPrefix() + "Port specified is not valid: " + args[1], nfe);
+                notifyEvent("serverTaskId", new Integer(-1));
+                return;
+            }
+
+            String spoofedHost = args[2];
+            
+            privKeyFile = new File(args[3]);
+            if (!privKeyFile.canRead()) {
+                l.log("private key file does not exist");
+                _log.error(getPrefix() + "Private key file does not exist or is not readable: " + args[3]);
+                notifyEvent("serverTaskId", new Integer(-1));
+                return;
+            }
+            I2PTunnelHTTPServer serv = new I2PTunnelHTTPServer(serverHost, portNum, privKeyFile, args[3], spoofedHost, l, (EventDispatcher) this, this);
+            serv.setReadTimeout(readTimeout);
+            serv.startRunning();
+            addtask(serv);
+            notifyEvent("serverTaskId", new Integer(serv.getId()));
+            return;
+        } else {
+            l.log("httpserver <host> <port> <spoofedhost> <privkeyfile>");
+            l.log("  creates an HTTP server that sends all incoming data\n" 
+                  + "  of its destination to host:port., filtering the HTTP\n" 
+                  + "  headers so it looks like the request is to the spoofed host.");
+            notifyEvent("serverTaskId", new Integer(-1));
+        }
+    }
+
     /**
      * Run the server pointing at the host and port specified using the private i2p
      * destination loaded from the given base64 stream. <p />

apps/i2ptunnel/java/src/net/i2p/i2ptunnel/I2PTunnelHTTPClient.java

@@ -407,7 +407,8 @@ public class I2PTunnelHTTPClient extends I2PTunnelClientBase implements Runnable
             opts.setProperty("i2p.streaming.inactivityTimeoutAction", ""+1);
             I2PSocket i2ps = createI2PSocket(dest, getDefaultOptions(opts));
             byte[] data = newRequest.toString().getBytes("ISO-8859-1");
-            I2PTunnelRunner runner = new I2PTunnelRunner(s, i2ps, sockLock, data, mySockets);
+            Runnable onTimeout = new OnTimeout(s, s.getOutputStream(), targetRequest, usingWWWProxy, currentProxy, requestId);
+            I2PTunnelRunner runner = new I2PTunnelRunner(s, i2ps, sockLock, data, mySockets, onTimeout);
         } catch (SocketException ex) {
             _log.info(getPrefix(requestId) + "Error trying to connect", ex);
             l.log(ex.getMessage());
@@ -437,6 +438,30 @@ public class I2PTunnelHTTPClient extends I2PTunnelClientBase implements Runnable
         }
     }
 
+    private class OnTimeout implements Runnable {
+        private Socket _socket;
+        private OutputStream _out;
+        private String _target;
+        private boolean _usingProxy;
+        private String _wwwProxy;
+        private long _requestId;
+        public OnTimeout(Socket s, OutputStream out, String target, boolean usingProxy, String wwwProxy, long id) {
+            _socket = s;
+            _out = out;
+            _target = target;
+            _usingProxy = usingProxy;
+            _wwwProxy = wwwProxy;
+            _requestId = id;
+        }
+        public void run() {
+            if (_log.shouldLog(Log.DEBUG))
+                _log.debug("Timeout occured requesting " + _target);
+            handleHTTPClientException(new RuntimeException("Timeout"), _out, 
+                                      _target, _usingProxy, _wwwProxy, _requestId);
+            closeSocket(_socket);
+        }
+    }
+    
     private static void writeErrorMessage(byte[] errMessage, OutputStream out, String targetRequest,
                                           boolean usingWWWProxy, String wwwProxy) throws IOException {
         if (out != null) {

apps/i2ptunnel/java/src/net/i2p/i2ptunnel/I2PTunnelHTTPServer.java

@@ -0,0 +1,162 @@
+/* I2PTunnel is GPL'ed (with the exception mentioned in I2PTunnel.java)
+ * (c) 2003 - 2004 mihi
+ */
+package net.i2p.i2ptunnel;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.InetAddress;
+import java.net.Socket;
+import java.net.SocketException;
+import java.util.Iterator;
+import java.util.Properties;
+
+import net.i2p.I2PAppContext;
+import net.i2p.I2PException;
+import net.i2p.client.streaming.I2PServerSocket;
+import net.i2p.client.streaming.I2PSocket;
+import net.i2p.client.streaming.I2PSocketManager;
+import net.i2p.data.DataHelper;
+import net.i2p.util.EventDispatcher;
+import net.i2p.util.I2PThread;
+import net.i2p.util.Log;
+
+/**
+ * Simple extension to the I2PTunnelServer that filters the HTTP
+ * headers sent from the client to the server, replacing the Host
+ * header with whatever this instance has been configured with.
+ *
+ */
+public class I2PTunnelHTTPServer extends I2PTunnelServer {
+    private final static Log _log = new Log(I2PTunnelHTTPServer.class);
+    /** what Host: should we seem to be to the webserver? */
+    private String _spoofHost;
+
+    public I2PTunnelHTTPServer(InetAddress host, int port, String privData, String spoofHost, Logging l, EventDispatcher notifyThis, I2PTunnel tunnel) {
+        super(host, port, privData, l, notifyThis, tunnel);
+        _spoofHost = spoofHost;
+    }
+
+    public I2PTunnelHTTPServer(InetAddress host, int port, File privkey, String privkeyname, String spoofHost, Logging l, EventDispatcher notifyThis, I2PTunnel tunnel) {
+        super(host, port, privkey, privkeyname, l, notifyThis, tunnel);
+        _spoofHost = spoofHost;
+    }
+
+    public I2PTunnelHTTPServer(InetAddress host, int port, InputStream privData, String privkeyname, String spoofHost, Logging l, EventDispatcher notifyThis, I2PTunnel tunnel) {
+        super(host, port, privData, privkeyname, l, notifyThis, tunnel);
+        _spoofHost = spoofHost;
+    }
+
+    public void run() {
+        try {
+            I2PServerSocket i2pss = sockMgr.getServerSocket();
+            while (true) {
+                I2PSocket i2ps = i2pss.accept();
+                if (i2ps == null) throw new I2PException("I2PServerSocket closed");
+                I2PThread t = new I2PThread(new Handler(i2ps));
+                t.start();
+            }
+        } catch (I2PException ex) {
+            _log.error("Error while waiting for I2PConnections", ex);
+        } catch (IOException ex) {
+            _log.error("Error while waiting for I2PConnections", ex);
+        }
+    }
+    
+    /**
+     * Async handler to keep .accept() from blocking too long.  
+     * todo: replace with a thread pool so we dont get overrun by threads if/when
+     * receiving a lot of connection requests concurrently.
+     *
+     */
+    private class Handler implements Runnable { 
+        private I2PSocket _handleSocket;
+        public Handler(I2PSocket socket) {
+            _handleSocket = socket;
+        }
+        public void run() {
+            long afterAccept = I2PAppContext.getGlobalContext().clock().now();
+            long afterSocket = -1;
+            
+            //local is fast, so synchronously. Does not need that many
+            //threads.
+            try {
+                _handleSocket.setReadTimeout(readTimeout);
+                String modifiedHeader = getModifiedHeader();
+                if (_log.shouldLog(Log.DEBUG))
+                    _log.debug("Modified header: [" + modifiedHeader + "]");
+            
+                Socket s = new Socket(remoteHost, remotePort);
+                afterSocket = I2PAppContext.getGlobalContext().clock().now();
+                new I2PTunnelRunner(s, _handleSocket, slock, null, modifiedHeader.getBytes(), null);
+            } catch (SocketException ex) {
+                try {
+                    _handleSocket.close();
+                } catch (IOException ioe) {
+                    _log.error("Error while closing the received i2p con", ex);
+                }
+            } catch (IOException ex) {
+                _log.error("Error while waiting for I2PConnections", ex);
+            }
+            
+            long afterHandle = I2PAppContext.getGlobalContext().clock().now();
+            long timeToHandle = afterHandle - afterAccept;
+            if (timeToHandle > 1000)
+                _log.warn("Took a while to handle the request [" + timeToHandle + ", socket create: " 
+                          + (afterSocket-afterAccept) + "]");
+        }
+        private String getModifiedHeader() throws IOException {
+            InputStream in = _handleSocket.getInputStream();
+            
+            StringBuffer command = new StringBuffer(128);
+            Properties headers = readHeaders(in, command);
+            headers.setProperty("Host", _spoofHost);
+            headers.setProperty("Connection", "close");
+            return formatHeaders(headers, command);
+        }
+    }
+    
+    private String formatHeaders(Properties headers, StringBuffer command) {
+        StringBuffer buf = new StringBuffer(command.length() + headers.size() * 64);
+        buf.append(command.toString()).append('\n');
+        for (Iterator iter = headers.keySet().iterator(); iter.hasNext(); ) {
+            String name = (String)iter.next();
+            String val  = headers.getProperty(name);
+            buf.append(name).append(": ").append(val).append('\n');
+        }
+        buf.append('\n');
+        return buf.toString();
+    }
+    
+    private Properties readHeaders(InputStream in, StringBuffer command) throws IOException {
+        Properties headers = new Properties();
+        StringBuffer buf = new StringBuffer(128);
+        
+        boolean ok = DataHelper.readLine(in, command);
+        if (!ok) throw new IOException("EOF reached while reading the HTTP command [" + command.toString() + "]");
+        
+        if (_log.shouldLog(Log.DEBUG))
+            _log.debug("Read the http command [" + command.toString() + "]");
+        
+        while (true) {
+            buf.setLength(0);
+            ok = DataHelper.readLine(in, buf);
+            if (!ok) throw new IOException("EOF reached before the end of the headers [" + buf.toString() + "]");
+            if ( (buf.length() <= 1) && ( (buf.charAt(0) == '\n') || (buf.charAt(0) == '\r') ) ) {
+                // end of headers reached
+                return headers;
+            } else {
+                int split = buf.indexOf(": ");
+                if (split <= 0) throw new IOException("Invalid HTTP header, missing colon [" + buf.toString() + "]");
+                String name = buf.substring(0, split);
+                String value = buf.substring(split+2); // ": "
+                headers.setProperty(name, value);
+                if (_log.shouldLog(Log.DEBUG))
+                    _log.debug("Read the header [" + name + "] = [" + value + "]");
+            }
+        }
+    }
+}
+

apps/i2ptunnel/java/src/net/i2p/i2ptunnel/I2PTunnelRunner.java

@@ -40,21 +40,37 @@ public class I2PTunnelRunner extends I2PThread implements I2PSocket.SocketErrorL
     Object slock, finishLock = new Object();
     boolean finished = false;
     HashMap ostreams, sockets;
-    byte[] initialData;
+    byte[] initialI2PData;
+    byte[] initialSocketData;
     /** when the last data was sent/received (or -1 if never) */
     private long lastActivityOn;
     /** when the runner started up */
     private long startedOn;
     private List sockList;
+    /** if we die before receiving any data, run this job */
+    private Runnable onTimeout;
+    private long totalSent;
+    private long totalReceived;
 
     private volatile long __forwarderId;
     
-    public I2PTunnelRunner(Socket s, I2PSocket i2ps, Object slock, byte[] initialData, List sockList) {
+    public I2PTunnelRunner(Socket s, I2PSocket i2ps, Object slock, byte[] initialI2PData, List sockList) {
+        this(s, i2ps, slock, initialI2PData, null, sockList, null);
+    }
+    public I2PTunnelRunner(Socket s, I2PSocket i2ps, Object slock, byte[] initialI2PData, byte[] initialSocketData, List sockList) {
+        this(s, i2ps, slock, initialI2PData, initialSocketData, sockList, null);
+    }
+    public I2PTunnelRunner(Socket s, I2PSocket i2ps, Object slock, byte[] initialI2PData, List sockList, Runnable onTimeout) {
+        this(s, i2ps, slock, initialI2PData, null, sockList, onTimeout);
+    }
+    public I2PTunnelRunner(Socket s, I2PSocket i2ps, Object slock, byte[] initialI2PData, byte[] initialSocketData, List sockList, Runnable onTimeout) {
         this.sockList = sockList;
         this.s = s;
         this.i2ps = i2ps;
         this.slock = slock;
-        this.initialData = initialData;
+        this.initialI2PData = initialI2PData;
+        this.initialSocketData = initialSocketData;
+        this.onTimeout = onTimeout;
         lastActivityOn = -1;
         startedOn = Clock.getInstance().now();
         if (_log.shouldLog(Log.INFO))
@@ -97,24 +113,27 @@ public class I2PTunnelRunner extends I2PThread implements I2PSocket.SocketErrorL
     }
 
     public void run() {
-        boolean closedCleanly = false;
         try {
             InputStream in = s.getInputStream();
             OutputStream out = s.getOutputStream(); // = new BufferedOutputStream(s.getOutputStream(), NETWORK_BUFFER_SIZE);
             i2ps.setSocketErrorListener(this);
             InputStream i2pin = i2ps.getInputStream();
             OutputStream i2pout = i2ps.getOutputStream(); //new BufferedOutputStream(i2ps.getOutputStream(), MAX_PACKET_SIZE);
-            if (initialData != null) {
+            if (initialI2PData != null) {
                 synchronized (slock) {
-                    i2pout.write(initialData);
+                    i2pout.write(initialI2PData);
                     //i2pout.flush();
                 }
             }
+            if (initialSocketData != null) {
+                out.write(initialSocketData);
+            }
             if (_log.shouldLog(Log.DEBUG))
-                _log.debug("Initial data " + (initialData != null ? initialData.length : 0) 
-                           + " written, starting forwarders");
-            Thread t1 = new StreamForwarder(in, i2pout, "toI2P");
-            Thread t2 = new StreamForwarder(i2pin, out, "fromI2P");
+                _log.debug("Initial data " + (initialI2PData != null ? initialI2PData.length : 0) 
+                           + " written to I2P, " + (initialSocketData != null ? initialSocketData.length : 0)
+                           + " written to the socket, starting forwarders");
+            Thread t1 = new StreamForwarder(in, i2pout, true);
+            Thread t2 = new StreamForwarder(i2pin, out, false);
             synchronized (finishLock) {
                 while (!finished) {
                     finishLock.wait();
@@ -122,12 +141,21 @@ public class I2PTunnelRunner extends I2PThread implements I2PSocket.SocketErrorL
             }
             if (_log.shouldLog(Log.DEBUG))
                 _log.debug("At least one forwarder completed, closing and joining");
+            
+            // this task is useful for the httpclient
+            if (onTimeout != null) {
+                if (_log.shouldLog(Log.DEBUG))
+                    _log.debug("runner has a timeout job, totalReceived = " + totalReceived
+                               + " totalSent = " + totalSent + " job = " + onTimeout);
+                if ( (totalSent <= 0) && (totalReceived <= 0) )
+                    onTimeout.run();
+            }
+            
             // now one connection is dead - kill the other as well.
             s.close();
             i2ps.close();
             t1.join(30*1000);
             t2.join(30*1000);
-            closedCleanly = true;
         } catch (InterruptedException ex) {
             if (_log.shouldLog(Log.ERROR))
                 _log.error("Interrupted", ex);
@@ -140,21 +168,20 @@ public class I2PTunnelRunner extends I2PThread implements I2PSocket.SocketErrorL
         } finally {
             removeRef();
             try {
-                if ( (s != null) && (!closedCleanly) )
+                if (s != null)
                     s.close();
             } catch (IOException ex) {
                 if (_log.shouldLog(Log.ERROR))
                     _log.error("Could not close java socket", ex);
             }
-            try {
-                if (i2ps != null) {
-                    if (!closedCleanly)
-                        i2ps.close();
-                    i2ps.setSocketErrorListener(null);
+            if (i2ps != null) {
+                try {
+                    i2ps.close();
+                } catch (IOException ex) {
+                    if (_log.shouldLog(Log.ERROR))
+                        _log.error("Could not close I2PSocket", ex);
                 }
-            } catch (IOException ex) {
-                if (_log.shouldLog(Log.ERROR))
-                    _log.error("Could not close I2PSocket", ex);
+                i2ps.setSocketErrorListener(null);
             }
         }
     }
@@ -181,12 +208,14 @@ public class I2PTunnelRunner extends I2PThread implements I2PSocket.SocketErrorL
         InputStream in;
         OutputStream out;
         String direction;
+        private boolean _toI2P;
         private ByteCache _cache;
 
-        private StreamForwarder(InputStream in, OutputStream out, String dir) {
+        private StreamForwarder(InputStream in, OutputStream out, boolean toI2P) {
             this.in = in;
             this.out = out;
-            direction = dir;
+            _toI2P = toI2P;
+            direction = (toI2P ? "toI2P" : "fromI2P");
             _cache = ByteCache.getInstance(256, NETWORK_BUFFER_SIZE);
             setName("StreamForwarder " + _runnerId + "." + (++__forwarderId));
             start();
@@ -207,6 +236,10 @@ public class I2PTunnelRunner extends I2PThread implements I2PSocket.SocketErrorL
                 int len;
                 while ((len = in.read(buffer)) != -1) {
                     out.write(buffer, 0, len);
+                    if (_toI2P)
+                        totalSent += len;
+                    else
+                        totalReceived += len;
 
                     if (len > 0) updateActivity();
 
@@ -259,10 +292,10 @@ public class I2PTunnelRunner extends I2PThread implements I2PSocket.SocketErrorL
                         _log.warn(direction + ": Error closing input stream", ex);
                 }
                 try {
-                    out.close();
-                } catch (IOException ex) {
+                    out.flush();
+                } catch (IOException ioe) {
                     if (_log.shouldLog(Log.WARN))
-                        _log.warn(direction + ": Error closing output stream", ex);
+                        _log.warn(direction + ": Error flushing to close", ioe);
                 }
                 synchronized (finishLock) {
                     finished = true;

apps/i2ptunnel/java/src/net/i2p/i2ptunnel/I2PTunnelServer.java

@@ -31,19 +31,20 @@ public class I2PTunnelServer extends I2PTunnelTask implements Runnable {
 
     private final static Log _log = new Log(I2PTunnelServer.class);
 
-    private I2PSocketManager sockMgr;
-    private I2PServerSocket i2pss;
+    protected I2PSocketManager sockMgr;
+    protected I2PServerSocket i2pss;
 
-    private Object lock = new Object(), slock = new Object();
+    private Object lock = new Object();
+    protected Object slock = new Object();
 
-    private InetAddress remoteHost;
-    private int remotePort;
+    protected InetAddress remoteHost;
+    protected int remotePort;
 
     private Logging l;
 
     private static final long DEFAULT_READ_TIMEOUT = -1; // 3*60*1000;
     /** default timeout to 3 minutes - override if desired */
-    private long readTimeout = DEFAULT_READ_TIMEOUT;
+    protected long readTimeout = DEFAULT_READ_TIMEOUT;
 
     public I2PTunnelServer(InetAddress host, int port, String privData, Logging l, EventDispatcher notifyThis, I2PTunnel tunnel) {
         super(host + ":" + port + " <- " + privData, notifyThis, tunnel);

apps/i2ptunnel/java/src/net/i2p/i2ptunnel/TunnelController.java

@@ -57,7 +57,7 @@ public class TunnelController implements Logging {
         setConfig(config, prefix);
         _messages = new ArrayList(4);
         _running = false;
-        if (createKey && ("server".equals(getType())) )
+        if (createKey && ("server".equals(getType()) || "httpserver".equals(getType())) )
             createPrivateKey();
         _starting = getStartOnLoad();
     }
@@ -132,6 +132,8 @@ public class TunnelController implements Logging {
             startClient();
         } else if ("server".equals(type)) {
             startServer();
+        } else if ("httpserver".equals(type)) {
+            startHttpServer();
         } else {
             if (_log.shouldLog(Log.ERROR))
                 _log.error("Cannot start tunnel - unknown type [" + type + "]");
@@ -206,6 +208,18 @@ public class TunnelController implements Logging {
         _running = true;
     }
     
+    private void startHttpServer() {
+        setI2CPOptions();
+        setSessionOptions();
+        String targetHost = getTargetHost(); 
+        String targetPort = getTargetPort(); 
+        String spoofedHost = getSpoofedHost(); 
+        String privKeyFile = getPrivKeyFile(); 
+        _tunnel.runHttpServer(new String[] { targetHost, targetPort, spoofedHost, privKeyFile }, this);
+        acquire();
+        _running = true;
+    }
+    
     private void setListenOn() {
         String listenOn = getListenOnInterface();
         if ( (listenOn != null) && (listenOn.length() > 0) ) {
@@ -233,6 +247,9 @@ public class TunnelController implements Logging {
         String host = getI2CPHost();
         if ( (host != null) && (host.length() > 0) ) 
             _tunnel.host = host;
+        // woohah, special casing for people with ipv6/etc
+        if ("localhost".equals(_tunnel.host)) 
+            _tunnel.host = "127.0.0.1";
         String port = getI2CPPort();
         if ( (port != null) && (port.length() > 0) ) 
             _tunnel.port = port;
@@ -294,6 +311,7 @@ public class TunnelController implements Logging {
     public String getListenOnInterface() { return _config.getProperty("interface"); }
     public String getTargetHost() { return _config.getProperty("targetHost"); }
     public String getTargetPort() { return _config.getProperty("targetPort"); }
+    public String getSpoofedHost() { return _config.getProperty("spoofedHost"); }
     public String getPrivKeyFile() { return _config.getProperty("privKeyFile"); }
     public String getListenPort() { return _config.getProperty("listenPort"); }
     public String getTargetDestination() { return _config.getProperty("targetDestination"); }
@@ -311,6 +329,8 @@ public class TunnelController implements Logging {
             getClientSummary(buf);
         else if ("server".equals(type))
             getServerSummary(buf);
+        else if ("httpserver".equals(type))
+            getHttpServerSummary(buf);
         else
             buf.append("Unknown type ").append(type);
     }
@@ -364,6 +384,18 @@ public class TunnelController implements Logging {
         getOptionSummary(buf);
     }
     
+    private void getHttpServerSummary(StringBuffer buf) {
+        String description = getDescription();
+        if ( (description != null) && (description.trim().length() > 0) )
+            buf.append("<i>").append(description).append("</i><br />\n");
+        buf.append("Server tunnel pointing at port ").append(getTargetPort());
+        buf.append(" on ").append(getTargetHost());
+        buf.append(" for the site ").append(getSpoofedHost());
+        buf.append("<br />\n");
+        buf.append("Private destination loaded from ").append(getPrivKeyFile()).append("<br />\n");
+        getOptionSummary(buf);
+    }
+    
     private void getOptionSummary(StringBuffer buf) {
         String opts = getClientOptions();
         if ( (opts != null) && (opts.length() > 0) )
@@ -375,7 +407,7 @@ public class TunnelController implements Logging {
                 Destination dest = session.getMyDestination();
                 if (dest != null) {
                     buf.append("Destination hash: ").append(dest.calculateHash().toBase64()).append("<br />\n");
-                    if ("server".equals(getType())) {
+                    if ( ("server".equals(getType())) || ("httpserver".equals(getType())) ) {
                         buf.append("Full destination: ");
                         buf.append("<input type=\"text\" size=\"10\" onclick=\"this.select();\" ");
                         buf.append("value=\"").append(dest.toBase64()).append("\" />\n");

apps/i2ptunnel/java/src/net/i2p/i2ptunnel/WebEditPageFormGenerator.java

@@ -18,6 +18,7 @@ class WebEditPageFormGenerator {
       "<option value=\"httpclient\">HTTP proxy</option>" +
       "<option value=\"client\">Client tunnel</option>" +
       "<option value=\"server\">Server tunnel</option>" +
+      "<option value=\"httpserver\">HTTP server tunnel</option>" +
       "</select> <input type=\"submit\" value=\"GO\" />" +
       "</form>\n";
     
@@ -42,6 +43,8 @@ class WebEditPageFormGenerator {
             return getEditClientForm(controller, id);
         else if ("server".equals(type))
             return getEditServerForm(controller, id);
+        else if ("httpserver".equals(type))
+            return getEditHttpServerForm(controller, id);
         else
             return "WTF, unknown type [" + type + "]";
     }
@@ -103,7 +106,7 @@ class WebEditPageFormGenerator {
         if ( (controller != null) && (controller.getTargetHost() != null) )
             buf.append("value=\"").append(controller.getTargetHost()).append("\" ");
         else
-            buf.append("value=\"localhost\" ");
+            buf.append("value=\"127.0.0.1\" ");
         buf.append(" /><br />\n");
         
         buf.append("<b>Target port:</b> <input type=\"text\" size=\"4\" name=\"targetPort\" ");
@@ -129,6 +132,48 @@ class WebEditPageFormGenerator {
         return buf.toString();
     }
     
+    private static String getEditHttpServerForm(TunnelController controller, String id) {
+        StringBuffer buf = new StringBuffer(1024);
+        addGeneral(buf, controller, id);
+        buf.append("<b>Type:</b> <i>HTTP server tunnel</i><input type=\"hidden\" name=\"type\" value=\"httpserver\" /><br />\n");
+        
+        buf.append("<b>Target host:</b> <input type=\"text\" size=\"40\" name=\"targetHost\" ");
+        if ( (controller != null) && (controller.getTargetHost() != null) )
+            buf.append("value=\"").append(controller.getTargetHost()).append("\" ");
+        else
+            buf.append("value=\"127.0.0.1\" ");
+        buf.append(" /><br />\n");
+        
+        buf.append("<b>Target port:</b> <input type=\"text\" size=\"4\" name=\"targetPort\" ");
+        if ( (controller != null) && (controller.getTargetPort() != null) )
+            buf.append("value=\"").append(controller.getTargetPort()).append("\" ");
+        else
+            buf.append("value=\"80\" ");
+        buf.append(" /><br />\n");
+        
+        buf.append("<b>Website hostname:</b> <input type=\"text\" size=\"16\" name=\"spoofedHost\" ");
+        if ( (controller != null) && (controller.getSpoofedHost() != null) )
+            buf.append("value=\"").append(controller.getSpoofedHost()).append("\" ");
+        else
+            buf.append("value=\"mysite.i2p\" ");
+        buf.append(" /><br />\n");
+        
+        buf.append("<b>Private key file:</b> <input type=\"text\" name=\"privKeyFile\" value=\"");
+        if ( (controller != null) && (controller.getPrivKeyFile() != null) ) {
+            buf.append(controller.getPrivKeyFile()).append("\" /><br />");
+        } else {
+            buf.append("myServer.privKey\" /><br />");
+            buf.append("<input type=\"hidden\" name=\"privKeyGenerate\" value=\"true\" />");
+        }
+        
+        addOptions(buf, controller);
+        buf.append("<input type=\"submit\" name=\"action\" value=\"Save\">\n");
+        buf.append("<input type=\"submit\" name=\"action\" value=\"Remove\">\n");
+        buf.append(" <i>confirm removal:</i> <input type=\"checkbox\" name=\"removeConfirm\" value=\"true\" />\n");
+        buf.append("</form>\n");
+        return buf.toString();
+    }
+    
     /**
      * Start off the form and add some common fields (name, num, description)
      *
@@ -285,7 +330,7 @@ class WebEditPageFormGenerator {
         if ( (controller != null) && (controller.getI2CPHost() != null) )
             buf.append(controller.getI2CPHost());
         else
-            buf.append("localhost");
+            buf.append("127.0.0.1");
         buf.append("\" /><br />\n");
         buf.append("<b>I2CP port:</b> ");
         buf.append("<input type=\"text\" name=\"clientPort\" size=\"20\" value=\"");

apps/i2ptunnel/java/src/net/i2p/i2ptunnel/WebEditPageHelper.java

@@ -38,6 +38,7 @@ public class WebEditPageHelper {
     private String _targetDestination;
     private String _targetHost;
     private String _targetPort;
+    private String _spoofedHost;
     private String _privKeyFile;
     private boolean _startOnLoad;
     private boolean _privKeyGenerate;
@@ -139,6 +140,10 @@ public class WebEditPageHelper {
     public void setTargetPort(String port) { 
         _targetPort = (port != null ? port.trim() : null);
     }
+    /** What host does this http server tunnel spoof */
+    public void setSpoofedHost(String host) { 
+        _spoofedHost = (host != null ? host.trim() : null);
+    }
     /** What filename is this server tunnel's private keys stored in */
     public void setPrivKeyFile(String file) { 
         _privKeyFile = (file != null ? file.trim() : null);
@@ -320,6 +325,15 @@ public class WebEditPageHelper {
                 config.setProperty("targetPort", _targetPort);
             if (_privKeyFile != null)
                 config.setProperty("privKeyFile", _privKeyFile);
+        } else if ("httpserver".equals(_type)) {
+            if (_targetHost != null)
+                config.setProperty("targetHost", _targetHost);
+            if (_targetPort != null)
+                config.setProperty("targetPort", _targetPort);
+            if (_privKeyFile != null)
+                config.setProperty("privKeyFile", _privKeyFile);
+            if (_spoofedHost != null)
+                config.setProperty("spoofedHost", _spoofedHost);
         } else {
             return null;
         }

apps/i2ptunnel/jsp/index.jsp

@@ -25,6 +25,7 @@
   <option value="httpclient">HTTP proxy</option>
   <option value="client">Client tunnel</option>
   <option value="server">Server tunnel</option>
+  <option value="httpserver">HTTP server tunnel</option>
  </select> <input type="submit" value="GO" />
 </form>
 

apps/ministreaming/java/src/net/i2p/client/streaming/I2PSocketManagerFactory.java

@@ -102,7 +102,8 @@ public class I2PSocketManagerFactory {
 
         if (i2cpHost != null)
             opts.setProperty(I2PClient.PROP_TCP_HOST, i2cpHost);
-        opts.setProperty(I2PClient.PROP_TCP_PORT, "" + i2cpPort);
+        if (i2cpPort > 0)
+            opts.setProperty(I2PClient.PROP_TCP_PORT, "" + i2cpPort);
         
         try {
             I2PSession session = client.createSession(myPrivateKeyStream, opts);

apps/ministreaming/java/src/net/i2p/client/streaming/TestSwarm.java

@@ -72,7 +72,7 @@ public class TestSwarm {
             }
         }
         try {
-            _manager = I2PSocketManagerFactory.createManager(new FileInputStream(_destFile), "localhost", 10001, null);
+            _manager = I2PSocketManagerFactory.createManager(new FileInputStream(_destFile), null, -1, null);
         } catch (Exception e) {
             _log.error("Error creatign the manager", e);
             return;

apps/routerconsole/java/src/net/i2p/router/web/StatHelper.java

@@ -0,0 +1,42 @@
+package net.i2p.router.web;
+
+import java.util.Iterator;
+import java.util.Set;
+
+import java.io.ByteArrayOutputStream;
+import java.io.Writer;
+
+import net.i2p.data.Hash;
+import net.i2p.router.RouterContext;
+
+/**
+ * uuuugly.  dump the peer profile data if given a peer.
+ *
+ */
+public class StatHelper {
+    private String _peer;
+    private Writer _writer;
+    
+    public void setPeer(String peer) { _peer = peer; }
+    public void setWriter(Writer writer) { _writer = writer; }
+    
+    public String getProfile() { 
+        RouterContext ctx = (RouterContext)net.i2p.router.RouterContext.listContexts().get(0);
+        Set peers = ctx.profileOrganizer().selectAllPeers();
+        for (Iterator iter = peers.iterator(); iter.hasNext(); ) {
+            Hash peer = (Hash)iter.next();
+            if (peer.toBase64().startsWith(_peer)) {
+                try {
+                    WriterOutputStream wos = new WriterOutputStream(_writer);
+                    ctx.profileOrganizer().exportProfile(peer, wos);
+                    wos.flush();
+                    _writer.flush();
+                    return "";
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+        return "Unknown";
+    }
+}

apps/routerconsole/java/src/net/i2p/router/web/WriterOutputStream.java

@@ -0,0 +1,17 @@
+package net.i2p.router.web;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.Writer;
+
+/**
+ * Treat a writer as an output stream. Quick 'n dirty, none
+ * of that "intarnasheeonaleyzayshun" stuff.  So we can treat
+ * the jsp's PrintWriter as an OutputStream
+ */
+public class WriterOutputStream extends OutputStream {
+    private Writer _writer;
+    
+    public WriterOutputStream(Writer writer) { _writer = writer; }
+    public void write(int b) throws IOException { _writer.write(b); }
+}

apps/routerconsole/jsp/dumpprofile.jsp

@@ -0,0 +1,5 @@
+<%@page contentType="text/plain" 
+%><jsp:useBean id="helper" class="net.i2p.router.web.StatHelper" 
+/><jsp:setProperty name="helper" property="peer" value="<%=request.getParameter("peer")%>" 
+/><jsp:setProperty name="helper" property="writer" value="<%=out%>" 
+/><jsp:getProperty name="helper" property="profile" />

apps/sam/c/Makefile.mingw

@@ -21,9 +21,9 @@ SRCDIR = src
 # Programs
 #
 
-AR = C:\Dev-Cpp\bin\ar
-CC = C:\Dev-Cpp\bin\gcc
-RM = C:\Dev-Cpp\bin\rm
+AR = C:\MinGW\bin\ar
+CC = C:\MinGW\bin\gcc
+RM = C:\MinGW\bin\rm
 
 #
 # Flags

apps/sam/c/examples/warhammer/Makefile.mingw

@@ -6,8 +6,8 @@
 # Programs
 #
 
-CC = C:\Dev-Cpp\bin\gcc
-RM = C:\Dev-Cpp\bin\rm
+CC = C:\MinGW\bin\gcc
+RM = C:\MinGW\bin\rm
 
 #
 # Flags

apps/sam/c/inc/sam.h

@@ -87,6 +87,7 @@ typedef struct {
 	int sock;  /* the socket used for communications with SAM */
 	bool connected;  /* whether the socket is connected */
 	sam_sid_t prev_id;  /* the last stream id number we used */
+	void *child;  /* whatever you want it to be */
 } sam_sess_t;  /* a SAM session */
 
 typedef enum {  /* see sam_strerror() for detailed descriptions of these */

apps/sam/c/src/sam.c

@@ -937,6 +937,7 @@ sam_sess_t *sam_session_init(sam_sess_t *session)
 			SAMLOGS("Out of memory");
 			abort();
 		}
+		session->child = NULL;
 	}
 	session->connected = false;
 	session->prev_id = 0;

apps/sam/java/src/net/i2p/sam/SAMv1Handler.java

@@ -547,7 +547,8 @@ public class SAMv1Handler extends SAMHandler implements SAMRawReceiver, SAMDatag
 
         try {
             if (!streamSession.sendBytes(id, getClientSocketInputStream(), size)) { // data)) {
-                _log.error("STREAM SEND [" + size + "] failed");
+                if (_log.shouldLog(Log.WARN))
+                    _log.warn("STREAM SEND [" + size + "] failed");
                 boolean rv = writeString("STREAM CLOSED RESULT=CANT_REACH_PEER ID=" + id + " MESSAGE=\"Send of " + size + " bytes failed\"\n");
                 streamSession.closeConnection(id);
                 return rv;
@@ -698,7 +699,8 @@ public class SAMv1Handler extends SAMHandler implements SAMRawReceiver, SAMDatag
         try {
             closeClientSocket();
         } catch (IOException e) {
-            _log.error("Error closing socket: " + e.getMessage());
+            if (_log.shouldLog(Log.WARN))
+                _log.warn("Error closing socket", e);
         }
     }
 
@@ -733,7 +735,8 @@ public class SAMv1Handler extends SAMHandler implements SAMRawReceiver, SAMDatag
         try {
             closeClientSocket();
         } catch (IOException e) {
-            _log.error("Error closing socket: " + e.getMessage());
+            if (_log.shouldLog(Log.WARN))
+                _log.warn("Error closing socket", e);
         }
     }
 
@@ -802,7 +805,8 @@ public class SAMv1Handler extends SAMHandler implements SAMRawReceiver, SAMDatag
         try {
             closeClientSocket();
         } catch (IOException e) {
-            _log.error("Error closing socket: " + e.getMessage());
+            if (_log.shouldLog(Log.WARN))
+                _log.warn("Error closing socket", e);
         }
     }
 }

apps/streaming/java/src/net/i2p/client/streaming/Connection.java

@@ -32,7 +32,9 @@ public class Connection {
     private long _lastSendTime;
     private long _lastSendId;
     private boolean _resetReceived;
+    private boolean _resetSent;
     private boolean _connected;
+    private boolean _hardDisconnected;
     private MessageInputStream _inputStream;
     private MessageOutputStream _outputStream;
     private SchedulerChooser _chooser;
@@ -171,6 +173,23 @@ public class Connection {
     void ackImmediately() {
         _receiver.send(null, 0, 0);
     }
+
+    /**
+     * got a packet we shouldn't have, send 'em a reset
+     *
+     */
+    void sendReset() {
+        _resetSent = true;
+        if ( (_remotePeer == null) || (_sendStreamId == null) ) return;
+        PacketLocal reply = new PacketLocal(_context, _remotePeer);
+        reply.setFlag(Packet.FLAG_RESET);
+        reply.setFlag(Packet.FLAG_SIGNATURE_INCLUDED);
+        reply.setSendStreamId(_sendStreamId);
+        reply.setReceiveStreamId(_receiveStreamId);
+        reply.setOptionalFrom(_connectionManager.getSession().getMyDestination());
+        // this just sends the packet - no retries or whatnot
+        _outboundQueue.enqueue(reply);
+    }
     
     /**
      * Flush any data that we can
@@ -304,8 +323,8 @@ public class Connection {
                     _ackedPackets++;
                     if (p.getNumSends() > 1) {
                         _activeResends--;
-                        if (_log.shouldLog(Log.WARN))
-                            _log.warn("Active resend of " + p + " successful, # active left: " + _activeResends);
+                        if (_log.shouldLog(Log.INFO))
+                            _log.info("Active resend of " + p + " successful, # active left: " + _activeResends);
                     }
                 }
             }
@@ -362,6 +381,8 @@ public class Connection {
     public boolean getResetReceived() { return _resetReceived; }
     
     public boolean getIsConnected() { return _connected; }
+    public boolean getHardDisconnected() { return _hardDisconnected; }
+    public boolean getResetSent() { return _resetSent; }
 
     void disconnect(boolean cleanDisconnect) {
         disconnect(cleanDisconnect, true);
@@ -371,6 +392,13 @@ public class Connection {
         if (_log.shouldLog(Log.DEBUG))
             _log.debug("Disconnecting " + toString(), new Exception("discon"));
         
+        if (!cleanDisconnect) {
+            _hardDisconnected = true;
+            if (_log.shouldLog(Log.WARN))
+                _log.warn("Hard disconnecting and sending a reset on " + toString(), new Exception("cause"));
+            sendReset();
+        }
+        
         if (cleanDisconnect && _connected) {
             // send close packets and schedule stuff...
             _outputStream.closeInternal();
@@ -693,6 +721,9 @@ public class Connection {
         buf.append(" wsize: ").append(_options.getWindowSize());
         buf.append(" cwin: ").append(_congestionWindowEnd - _highestAckedThrough);
         buf.append(" rtt: ").append(_options.getRTT());
+        // not synchronized to avoid some kooky races
+        buf.append(" unacked outbound: ").append(_outboundPackets.size()).append(" ");
+        /*
         buf.append(" unacked outbound: ");
         synchronized (_outboundPackets) {
             buf.append(_outboundPackets.size()).append(" [");
@@ -701,6 +732,7 @@ public class Connection {
             }
             buf.append("] ");
         }
+         */
         buf.append("unacked inbound? ").append(getUnackedPacketsReceived());
         if (_inputStream != null) {
             buf.append(" [high ");

apps/streaming/java/src/net/i2p/client/streaming/ConnectionDataReceiver.java

@@ -17,17 +17,20 @@ class ConnectionDataReceiver implements MessageOutputStream.DataReceiver {
     private I2PAppContext _context;
     private Log _log;
     private Connection _connection;
-    private MessageOutputStream.WriteStatus _dummyStatus;
+    private static final MessageOutputStream.WriteStatus _dummyStatus = new DummyStatus();
     
     public ConnectionDataReceiver(I2PAppContext ctx, Connection con) {
         _context = ctx;
         _log = ctx.logManager().getLog(ConnectionDataReceiver.class);
         _connection = con;
-        _dummyStatus = new DummyStatus();
     }
     
     public boolean writeInProcess() {
-        return _connection.getUnackedPacketsSent() > 0;
+        Connection con = _connection;
+        if (con != null)
+            return con.getUnackedPacketsSent() > 0;
+        else
+            return false;
     }
     
     /**
@@ -42,10 +45,12 @@ class ConnectionDataReceiver implements MessageOutputStream.DataReceiver {
      *         delivery.
      */
     public MessageOutputStream.WriteStatus writeData(byte[] buf, int off, int size) {
+        Connection con = _connection;
+        if (con == null) return _dummyStatus;
         boolean doSend = true;
-        if ( (size <= 0) && (_connection.getLastSendId() >= 0) ) {
-            if (_connection.getOutputStream().getClosed()) {
-                if (_connection.getCloseSentOn() < 0) {
+        if ( (size <= 0) && (con.getLastSendId() >= 0) ) {
+            if (con.getOutputStream().getClosed()) {
+                if (con.getCloseSentOn() < 0) {
                     doSend = true;
                 } else {
                     // closed, no new data, and we've already sent a close packet
@@ -57,16 +62,18 @@ class ConnectionDataReceiver implements MessageOutputStream.DataReceiver {
             }
         }
         
-        if (_connection.getUnackedPacketsReceived() > 0)
+        if (con.getUnackedPacketsReceived() > 0)
             doSend = true;
         
         if (_log.shouldLog(Log.INFO) && !doSend)
             _log.info("writeData called: size="+size + " doSend=" + doSend 
-                       + " unackedReceived: " + _connection.getUnackedPacketsReceived()
-                       + " con: " + _connection, new Exception("write called by"));
+                       + " unackedReceived: " + con.getUnackedPacketsReceived()
+                       + " con: " + con, new Exception("write called by"));
 
         if (doSend) {
             PacketLocal packet = send(buf, off, size);
+            if (packet == null) return _dummyStatus;
+            
             //dont wait for non-acks
             if ( (packet.getSequenceNum() > 0) || (packet.isFlagSet(Packet.FLAG_SYNCHRONIZE)) )
                 return packet;
@@ -85,7 +92,7 @@ class ConnectionDataReceiver implements MessageOutputStream.DataReceiver {
      * @param buf data to be sent - may be null
      * @param off offset into the buffer to start writing from
      * @param size how many bytes of the buffer to write (may be 0)
-     * @return the packet sent
+     * @return the packet sent, or null if the connection died
      */
     public PacketLocal send(byte buf[], int off, int size) {
         return send(buf, off, size, false);
@@ -99,10 +106,12 @@ class ConnectionDataReceiver implements MessageOutputStream.DataReceiver {
      * @return the packet sent
      */
     public PacketLocal send(byte buf[], int off, int size, boolean forceIncrement) {
+        Connection con = _connection;
+        if (con == null) return null;
         long before = System.currentTimeMillis();
-        PacketLocal packet = buildPacket(buf, off, size, forceIncrement);
+        PacketLocal packet = buildPacket(con, buf, off, size, forceIncrement);
         long built = System.currentTimeMillis();
-        _connection.sendPacket(packet);
+        con.sendPacket(packet);
         long sent = System.currentTimeMillis();
         
         if ( (built-before > 1000) && (_log.shouldLog(Log.WARN)) )
@@ -112,18 +121,18 @@ class ConnectionDataReceiver implements MessageOutputStream.DataReceiver {
         return packet;
     }
     
-    private boolean isAckOnly(int size) {
+    private boolean isAckOnly(Connection con, int size) {
         boolean ackOnly = ( (size <= 0) && // no data
-                            (_connection.getLastSendId() >= 0) && // not a SYN
-                            ( (!_connection.getOutputStream().getClosed()) || // not a CLOSE
-                            (_connection.getOutputStream().getClosed() && 
-                             _connection.getCloseSentOn() > 0) )); // or it is a dup CLOSE
+                            (con.getLastSendId() >= 0) && // not a SYN
+                            ( (!con.getOutputStream().getClosed()) || // not a CLOSE
+                            (con.getOutputStream().getClosed() && 
+                             con.getCloseSentOn() > 0) )); // or it is a dup CLOSE
         return ackOnly;
     }
     
-    private PacketLocal buildPacket(byte buf[], int off, int size, boolean forceIncrement) {
-        boolean ackOnly = isAckOnly(size);
-        PacketLocal packet = new PacketLocal(_context, _connection.getRemotePeer(), _connection);
+    private PacketLocal buildPacket(Connection con, byte buf[], int off, int size, boolean forceIncrement) {
+        boolean ackOnly = isAckOnly(con, size);
+        PacketLocal packet = new PacketLocal(_context, con.getRemotePeer(), con);
         byte data[] = new byte[size];
         if (size > 0)
             System.arraycopy(buf, off, data, 0, size);
@@ -131,36 +140,36 @@ class ConnectionDataReceiver implements MessageOutputStream.DataReceiver {
 		if (ackOnly && !forceIncrement)
 			packet.setSequenceNum(0);
         else
-            packet.setSequenceNum(_connection.getNextOutboundPacketNum());
-        packet.setSendStreamId(_connection.getSendStreamId());
-        packet.setReceiveStreamId(_connection.getReceiveStreamId());
+            packet.setSequenceNum(con.getNextOutboundPacketNum());
+        packet.setSendStreamId(con.getSendStreamId());
+        packet.setReceiveStreamId(con.getReceiveStreamId());
         
-        _connection.getInputStream().updateAcks(packet);
-        packet.setOptionalDelay(_connection.getOptions().getChoke());
-        packet.setOptionalMaxSize(_connection.getOptions().getMaxMessageSize());
-        packet.setResendDelay(_connection.getOptions().getResendDelay());
+        con.getInputStream().updateAcks(packet);
+        packet.setOptionalDelay(con.getOptions().getChoke());
+        packet.setOptionalMaxSize(con.getOptions().getMaxMessageSize());
+        packet.setResendDelay(con.getOptions().getResendDelay());
         
-        if (_connection.getOptions().getProfile() == ConnectionOptions.PROFILE_INTERACTIVE)
+        if (con.getOptions().getProfile() == ConnectionOptions.PROFILE_INTERACTIVE)
             packet.setFlag(Packet.FLAG_PROFILE_INTERACTIVE, true);
         else
             packet.setFlag(Packet.FLAG_PROFILE_INTERACTIVE, false);
         
-        packet.setFlag(Packet.FLAG_SIGNATURE_REQUESTED, _connection.getOptions().getRequireFullySigned());
+        packet.setFlag(Packet.FLAG_SIGNATURE_REQUESTED, con.getOptions().getRequireFullySigned());
         
         if ( (!ackOnly) && (packet.getSequenceNum() <= 0) ) {
             packet.setFlag(Packet.FLAG_SYNCHRONIZE);
-            packet.setOptionalFrom(_connection.getSession().getMyDestination());
+            packet.setOptionalFrom(con.getSession().getMyDestination());
         }
         
         // don't set the closed flag if this is a plain ACK and there are outstanding
         // packets sent, otherwise the other side could receive the CLOSE prematurely,
         // since this ACK could arrive before the unacked payload message.
-        if (_connection.getOutputStream().getClosed() && 
-            ( (size > 0) || (_connection.getUnackedPacketsSent() <= 0) ) ) {
+        if (con.getOutputStream().getClosed() && 
+            ( (size > 0) || (con.getUnackedPacketsSent() <= 0) ) ) {
             packet.setFlag(Packet.FLAG_CLOSE);
-            _connection.setCloseSentOn(_context.clock().now());
+            con.setCloseSentOn(_context.clock().now());
             if (_log.shouldLog(Log.DEBUG))
-                _log.debug("Closed is set for a new packet on " + _connection + ": " + packet);
+                _log.debug("Closed is set for a new packet on " + con + ": " + packet);
         } else {
             //if (_log.shouldLog(Log.DEBUG))
             //    _log.debug("Closed is not set for a new packet on " + _connection + ": " + packet);

apps/streaming/java/src/net/i2p/client/streaming/ConnectionManager.java

@@ -366,7 +366,8 @@ public class ConnectionManager {
             if (removed) {
                 if (_notifier != null)
                     _notifier.pingComplete(false);
-                _log.error("Ping failed");
+                if (_log.shouldLog(Log.INFO))
+                    _log.info("Ping failed");
             }
         }
     }

apps/streaming/java/src/net/i2p/client/streaming/ConnectionOptions.java

@@ -89,6 +89,8 @@ public class ConnectionOptions extends I2PSocketOptionsImpl {
         setInactivityTimeout(getInt(opts, PROP_INACTIVITY_TIMEOUT, 5*60*1000));
         setInactivityAction(getInt(opts, PROP_INACTIVITY_ACTION, INACTIVITY_ACTION_DISCONNECT));
         setInboundBufferSize((getMaxMessageSize() + 2) * Connection.MAX_WINDOW_SIZE);
+        
+        setConnectTimeout(getInt(opts, PROP_CONNECT_TIMEOUT, Connection.DISCONNECT_TIMEOUT));
     }
     
     /** 

apps/streaming/java/src/net/i2p/client/streaming/ConnectionPacketHandler.java

@@ -25,6 +25,7 @@ public class ConnectionPacketHandler {
         _context.statManager().createRateStat("stream.con.receiveDuplicateSize", "Size of a duplicate message received on a connection", "Stream", new long[] { 60*1000, 10*60*1000, 60*60*1000 });
         _context.statManager().createRateStat("stream.con.packetsAckedPerMessageReceived", "Size of a duplicate message received on a connection", "Stream", new long[] { 60*1000, 10*60*1000, 60*60*1000 });
         _context.statManager().createRateStat("stream.sendsBeforeAck", "How many times a message was sent before it was ACKed?", "Stream", new long[] { 10*60*1000, 60*60*1000 });
+        _context.statManager().createRateStat("stream.resetReceived", "How many messages had we sent successfully before receiving a RESET?", "Stream", new long[] { 60*60*1000, 24*60*60*1000 });
     }
     
     /** distribute a packet to the connection specified */
@@ -35,6 +36,21 @@ public class ConnectionPacketHandler {
                 _log.error("Packet does NOT verify: " + packet);
             return;
         }
+
+        if (con.getHardDisconnected()) {
+            if ( (packet.getSequenceNum() > 0) || (packet.getPayloadSize() > 0) || 
+                 (packet.isFlagSet(Packet.FLAG_SYNCHRONIZE)) || (packet.isFlagSet(Packet.FLAG_CLOSE)) ) {
+                if (_log.shouldLog(Log.WARN))
+                    _log.warn("Received a data packet after hard disconnect: " + packet + " on " + con);
+                con.sendReset();
+            } else {
+                if (_log.shouldLog(Log.WARN))
+                    _log.warn("Received a packet after hard disconnect, ignoring: " + packet + " on " + con);
+            }
+            return;
+        }
+        
+
         con.packetReceived();
         
         long ready = con.getInputStream().getHighestReadyBockId();
@@ -65,6 +81,8 @@ public class ConnectionPacketHandler {
         if (packet.isFlagSet(Packet.FLAG_CLOSE) && packet.isFlagSet(Packet.FLAG_SIGNATURE_INCLUDED))
             con.closeReceived();
         
+        boolean fastAck = false;
+        
         if (isNew) {
             con.incrementUnackedPacketsReceived();
             con.incrementBytesReceived(packet.getPayloadSize());
@@ -82,7 +100,8 @@ public class ConnectionPacketHandler {
                     _log.debug("Scheduling ack in " + delay + "ms for received packet " + packet);
             }
         } else {
-            if ( (packet.getSequenceNum() > 0) || (packet.getPayloadSize() > 0) ) {
+            if ( (packet.getSequenceNum() > 0) || (packet.getPayloadSize() > 0) || 
+                 (packet.isFlagSet(Packet.FLAG_SYNCHRONIZE)) ) {
                 _context.statManager().addRateData("stream.con.receiveDuplicateSize", packet.getPayloadSize(), 0);
                 con.incrementDupMessagesReceived(1);
         
@@ -93,7 +112,8 @@ public class ConnectionPacketHandler {
                     _log.warn("congestion.. dup " + packet);
                 SimpleTimer.getInstance().addEvent(new AckDup(con), con.getOptions().getSendAckDelay());
                 //con.incrementUnackedPacketsReceived();
-                con.setNextSendTime(_context.clock().now() + con.getOptions().getSendAckDelay());
+                //con.setNextSendTime(_context.clock().now() + con.getOptions().getSendAckDelay());
+                fastAck = true;
             } else {
                 if (packet.isFlagSet(Packet.FLAG_SYNCHRONIZE)) {
                     //con.incrementUnackedPacketsReceived();
@@ -105,10 +125,10 @@ public class ConnectionPacketHandler {
             }
         }
         
-        boolean fastAck = ack(con, packet.getAckThrough(), packet.getNacks(), packet, isNew);
+        fastAck = fastAck || ack(con, packet.getAckThrough(), packet.getNacks(), packet, isNew);
         con.eventOccurred();
         if (fastAck) {
-            if (con.getLastSendTime() + con.getOptions().getRTT() < _context.clock().now()) {
+            if (con.getLastSendTime() + 1000 < _context.clock().now()) {
                 if (_log.shouldLog(Log.DEBUG))
                     _log.debug("Fast ack for dup " + packet);
                 con.ackImmediately();
@@ -264,6 +284,8 @@ public class ConnectionPacketHandler {
                 con.resetReceived();
                 con.eventOccurred();
 
+                _context.statManager().addRateData("stream.resetReceived", con.getHighestAckedThrough(), con.getLifetime());
+                
                 // no further processing
                 return;
             }

apps/streaming/java/src/net/i2p/client/streaming/I2PSocketFull.java

@@ -32,6 +32,8 @@ public class I2PSocketFull implements I2PSocket {
         destroy();
     }
     
+    Connection getConnection() { return _connection; }
+    
     public InputStream getInputStream() {
         return _connection.getInputStream();
     }

apps/streaming/java/src/net/i2p/client/streaming/PacketHandler.java

@@ -152,16 +152,28 @@ public class PacketHandler {
                     }
                 } else {
                     if (_log.shouldLog(Log.WARN))
-                        _log.warn("Receive a syn packet with the wrong IDs: " + packet);
+                        _log.warn("Receive a syn packet with the wrong IDs, sending reset: " + packet);
+                    sendReset(packet);
                 }
             } else {
                 // someone is sending us a packet on the wrong stream 
                 if (_log.shouldLog(Log.WARN))
-                    _log.warn("Received a packet on the wrong stream: " + packet);
+                    _log.warn("Received a packet on the wrong stream: " + packet + " connection: " + con);
             }
         }
     }
     
+    private void sendReset(Packet packet) {
+        PacketLocal reply = new PacketLocal(_context, packet.getOptionalFrom());
+        reply.setFlag(Packet.FLAG_RESET);
+        reply.setFlag(Packet.FLAG_SIGNATURE_INCLUDED);
+        reply.setSendStreamId(packet.getReceiveStreamId());
+        reply.setReceiveStreamId(packet.getSendStreamId());
+        reply.setOptionalFrom(_manager.getSession().getMyDestination());
+        // this just sends the packet - no retries or whatnot
+        _manager.getPacketQueue().enqueue(reply);
+    }
+    
     private void receiveUnknownCon(Packet packet, byte sendId[]) {
         if (packet.isFlagSet(Packet.FLAG_ECHO)) {
             if (packet.getSendStreamId() != null) {

apps/streaming/java/src/net/i2p/client/streaming/SchedulerChooser.java

@@ -38,6 +38,7 @@ class SchedulerChooser {
     
     private List createSchedulers() {
         List rv = new ArrayList(8);
+        rv.add(new SchedulerHardDisconnected(_context));
         rv.add(new SchedulerPreconnect(_context));
         rv.add(new SchedulerConnecting(_context));
         rv.add(new SchedulerReceived(_context));
@@ -54,8 +55,7 @@ class SchedulerChooser {
         }
         
         public void eventOccurred(Connection con) {
-            if (_log.shouldLog(Log.DEBUG))
-                _log.debug("Event occurred on " + con, new Exception("source"));
+            _log.log(Log.CRIT, "Yell at jrandom: Event occurred on " + con, new Exception("source"));
         }
         public boolean accept(Connection con) { return true; }
     };

apps/streaming/java/src/net/i2p/client/streaming/SchedulerConnecting.java

@@ -37,7 +37,7 @@ class SchedulerConnecting extends SchedulerImpl {
     public boolean accept(Connection con) {
         if (con == null) return false;
         boolean notYetConnected = (con.getIsConnected()) &&
-                                  (con.getSendStreamId() == null) &&
+                                  //(con.getSendStreamId() == null) && // not null on recv
                                   (con.getLastSendId() >= 0) &&
                                   (con.getAckedPackets() <= 0) && 
                                   (!con.getResetReceived());
@@ -55,6 +55,7 @@ class SchedulerConnecting extends SchedulerImpl {
                 _log.debug("waited too long: " + waited);
             return;
         } else {
+            // should we be doing a con.sendAvailable here?
             if (con.getOptions().getConnectTimeout() > 0)
                 reschedule(con.getOptions().getConnectTimeout(), con);
         }

apps/streaming/java/src/net/i2p/client/streaming/SchedulerHardDisconnected.java

@@ -0,0 +1,45 @@
+package net.i2p.client.streaming;
+
+import net.i2p.I2PAppContext;
+import net.i2p.util.Log;
+
+/**
+ * <p>Scheduler used after we've locally done a hard disconnect, 
+ * but the final timeout hasn't passed.</p>
+ *
+ * <h2>Entry conditions:</h2><ul>
+ * <li>Locally disconnected hard.</li>
+ * <li>Less than the final timeout period has passed since the last ACK.</li>
+ * </ul>
+ *
+ * <h2>Events:</h2><ul>
+ * <li>Packets received</li>
+ * <li>RESET received</li>
+ * <li>Message sending fails (error talking to the session)</li>
+ * </ul>
+ *
+ * <h2>Next states:</h2>
+ * <li>{@link SchedulerDead dead} - after the final timeout passes</li>
+ * </ul>
+ *
+ *
+ */
+class SchedulerHardDisconnected extends SchedulerImpl {
+    private Log _log;
+    public SchedulerHardDisconnected(I2PAppContext ctx) {
+        super(ctx);
+        _log = ctx.logManager().getLog(SchedulerHardDisconnected.class);
+    }
+    
+    public boolean accept(Connection con) {
+        if (con == null) return false;
+        long timeSinceClose = _context.clock().now() - con.getCloseSentOn();
+        boolean ok = (con.getHardDisconnected() || con.getResetSent()) && 
+                     (timeSinceClose < Connection.DISCONNECT_TIMEOUT);
+        return ok;
+    }
+    
+    public void eventOccurred(Connection con) {
+        // noop.  we do the timeout through the simpleTimer anyway
+    }
+}

apps/streaming/java/test/net/i2p/client/streaming/ConnectCloseTest.java

@@ -0,0 +1,138 @@
+package net.i2p.client.streaming;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.InputStream;
+import java.util.Properties;
+
+import net.i2p.I2PAppContext;
+import net.i2p.client.I2PClient;
+import net.i2p.client.I2PClientFactory;
+import net.i2p.client.I2PSession;
+import net.i2p.data.Destination;
+import net.i2p.util.Log;
+
+/**
+ * Have a client connect to a server, where the server waits 5
+ * seconds and closes the socket and the client detect that 
+ * EOF.
+ *
+ */
+public class ConnectCloseTest {
+    private Log _log;
+    private I2PSession _server;
+    public void test() {
+        try {
+            I2PAppContext context = I2PAppContext.getGlobalContext();
+            _log = context.logManager().getLog(ConnectCloseTest.class);
+            _log.debug("creating server session");
+            _server = createSession();
+            _log.debug("running server");
+            runServer(context, _server);
+            _log.debug("running client");
+            runClient(context, createSession());
+        } catch (Exception e) {
+            _log.error("error running", e);
+        }
+        try { Thread.sleep(10*60*1000); } catch (Exception e) {}
+    }
+    
+    private void runClient(I2PAppContext ctx, I2PSession session) {
+        Thread t = new Thread(new ClientRunner(ctx, session));
+        t.setName("client");
+        t.setDaemon(true);
+        t.start();
+    }
+    
+    private void runServer(I2PAppContext ctx, I2PSession session) {
+        Thread t = new Thread(new ServerRunner(ctx, session));
+        t.setName("server");
+        t.setDaemon(true);
+        t.start();
+    }
+    
+    private class ServerRunner implements Runnable {
+        private I2PAppContext _context;
+        private I2PSession _session;
+        private Log _log;
+        public ServerRunner(I2PAppContext ctx, I2PSession session) {
+            _context = ctx;
+            _session = session;
+            _log = ctx.logManager().getLog(ServerRunner.class);
+        }
+        
+        public void run() {
+            try {
+                Properties opts = new Properties();
+                I2PSocketManager mgr = new I2PSocketManagerFull(_context, _session, opts, "client");
+                _log.debug("* manager created");
+                I2PServerSocket ssocket = mgr.getServerSocket();
+                _log.debug("* server socket created");
+                while (true) {
+                    I2PSocket socket = ssocket.accept();
+                    _log.debug("* socket accepted: " + socket);
+                    try { Thread.sleep(5*1000); } catch (InterruptedException ie) {}
+                    socket.close();
+                    _log.debug("* socket closed: " + socket);
+                }
+            } catch (Exception e) {
+                _log.error("error running", e);
+            }
+        }
+        
+    }
+    
+    private class ClientRunner implements Runnable {
+        private I2PAppContext _context;
+        private I2PSession _session;
+        private Log _log;
+        public ClientRunner(I2PAppContext ctx, I2PSession session) {
+            _context = ctx;
+            _session = session;
+            _log = ctx.logManager().getLog(ClientRunner.class);
+        }
+        
+        public void run() {
+            try {
+                Properties opts = new Properties();
+                I2PSocketManager mgr = new I2PSocketManagerFull(_context, _session, opts, "client");
+                _log.debug("* manager created");
+                I2PSocket socket = mgr.connect(_server.getMyDestination());
+                _log.debug("* socket created");
+                InputStream in = socket.getInputStream();
+                int c = in.read();
+                if (c != -1)
+                    throw new RuntimeException("hrm, we got data?  [" + c + "]");
+                socket.close();
+                _log.debug("* socket closed");
+                mgr.destroySocketManager();
+                mgr = null;
+                socket = null;
+            } catch (Exception e) {
+                _log.error("error running", e);
+            }
+            try { Thread.sleep(5*1000); } catch (InterruptedException ie) {}
+            System.exit(0);
+        }
+        
+    }
+    
+    private I2PSession createSession() {
+        try {
+            I2PClient client = I2PClientFactory.createClient();
+            ByteArrayOutputStream baos = new ByteArrayOutputStream(512);
+            Destination dest = client.createDestination(baos);
+            I2PSession sess = client.createSession(new ByteArrayInputStream(baos.toByteArray()), System.getProperties());
+            sess.connect();
+            return sess;
+        } catch (Exception e) {
+            _log.error("error running", e);
+            throw new RuntimeException("b0rk b0rk b0rk");
+        }
+    }
+    
+    public static void main(String args[]) {
+        ConnectCloseTest ct = new ConnectCloseTest();
+        ct.test();
+    }
+}

core/c/README

@@ -1,5 +1,5 @@
 Prior to building the jbigi library, you will need to fetch the GMP source
-from http://www.swox.com/gmp/, saving it to jbigi/gmp-4.1.3.tar.bz2 (it will
+from http://www.swox.com/gmp/, saving it to jbigi/gmp-4.1.4.tar.bz2 (it will
 be unpacked and built as necessary).
 
 To build the native jbigi and jcpuid libraries for the current host CPU,

core/c/build.sh

@@ -7,7 +7,6 @@ mkdir -p t/freenet/support/CPUInformation/
 cp jcpuid/lib/freenet/support/CPUInformation/*jcpuid* t/freenet/support/CPUInformation/
 
 mkdir -p t/net/i2p/util/
-cp jbigi/lib/net/i2p/util/*jbigi* t/net/i2p/util/
 cp jbigi/lib/*jbigi* t/
 
 (cd t ; jar cf ../jbigi.jar . ; cd ..)

core/c/jbigi/build-all.sh

@@ -13,7 +13,7 @@ FreeBSD*)
 esac
 
 echo "Extracting GMP..."
-tar -xjf gmp-4.1.3.tar.bz2
+tar -xjf gmp-4.1.4.tar.bz2
 echo "Building..."
 mkdir bin
 mkdir lib
@@ -24,7 +24,7 @@ for x in none pentium pentiummmx pentium2 pentium3 pentium4 k6 k62 k63 athlon
 do
 	mkdir bin/$x
 	cd bin/$x
-	../../gmp-4.1.3/configure --build=$x
+	../../gmp-4.1.4/configure --build=$x
 	make
 	sh ../../build_jbigi.sh static
 	case `uname -sr` in

core/c/jbigi/build.sh

@@ -1,41 +1,15 @@
 #/bin/sh
 
-case `uname -sr` in
-MINGW*)
-	echo "Building windows .dll's";;
-CYGWIN*)
-	echo "Building windows .dll's";;
-Linux*)
-	echo "Building linux .so's";;
-FreeBSD*)
-	echo "Building freebsd .so's";;
-*)
-	echo "Unsupported build environment"
-	exit;;
-esac
+echo "Building the jbigi library with GMP"
 
 echo "Extracting GMP..."
-tar -xjf gmp-4.1.3.tar.bz2
+tar -xjf gmp-4.1.4.tar.bz2
 echo "Building..."
-mkdir bin
-mkdir lib
-mkdir lib/net
-mkdir lib/net/i2p
-mkdir lib/net/i2p/util
-mkdir bin/local
+mkdir -p lib/
+mkdir -p bin/local
 cd bin/local
-../../gmp-4.1.3/configure
+../../gmp-4.1.4/configure
 make
 sh ../../build_jbigi.sh static
-case `uname -sr` in
-MINGW*)
-	cp jbigi.dll ../../lib/jbigi;;
-CYGWIN*)
-	cp jbigi.dll ../../lib/jbigi;;
-Linux*)
-	cp libjbigi.so ../../lib/jbigi;;
-FreeBSD*)
-	cp libjbigi.so ../../lib/jbigi;;
-esac
-cd ..
-cd ..
+cp *jbigi???* ../../lib/
+cd ../..

core/c/jcpuid/build.sh

@@ -20,7 +20,7 @@ mkdir lib/freenet
 mkdir lib/freenet/support
 mkdir lib/freenet/support/CPUInformation
 
-CPP="g++"
+CC="gcc"
 
 case `uname -sr` in
 MINGW*)
@@ -43,7 +43,7 @@ esac
 
 echo "Compiling C code..."
 rm -f $LIBFILE
-$CPP $LINKFLAGS $INCLUDES src/*.cpp -o $LIBFILE
+$CC $LINKFLAGS $INCLUDES src/*.c -o $LIBFILE
 strip $LIBFILE
 echo Built $LIBFILE
 

core/c/jcpuid/src/jcpuid.c

@@ -5,8 +5,8 @@ JNIEXPORT jobject JNICALL Java_freenet_support_CPUInformation_CPUID_doCPUID
   (JNIEnv * env, jclass cls, jint iFunction)
 {
 	int a,b,c,d;
-	jclass clsResult = env->FindClass ("freenet/support/CPUInformation/CPUID$CPUIDResult");
-	jmethodID constructor = env->GetMethodID(clsResult,"<init>","(IIII)V" );
+	jclass clsResult = (*env)->FindClass(env, "freenet/support/CPUInformation/CPUID$CPUIDResult");
+	jmethodID constructor = (*env)->GetMethodID(env, clsResult,"<init>","(IIII)V" );
 	#ifdef _MSC_VER
 		//Use MSVC assembler notation
 		_asm 
@@ -30,6 +30,6 @@ JNIEXPORT jobject JNICALL Java_freenet_support_CPUInformation_CPUID_doCPUID
 			:"a"(iFunction)
 		);
 	#endif
-	return env->NewObject(clsResult,constructor,a,b,c,d);
+	return (*env)->NewObject(env, clsResult,constructor,a,b,c,d);
 }
 

core/java/src/net/i2p/client/naming/NamingService.java

@@ -22,7 +22,8 @@ public abstract class NamingService {
     private final static Log _log = new Log(NamingService.class);
     protected I2PAppContext _context;
 
-    private static final String PROP_IMPL = "i2p.naming.impl";
+    /** what classname should be used as the naming service impl? */
+    public static final String PROP_IMPL = "i2p.naming.impl";
     private static final String DEFAULT_IMPL = "net.i2p.client.naming.HostsTxtNamingService";
 
     

core/java/src/net/i2p/data/DataHelper.java

@@ -680,7 +680,19 @@ public class DataHelper {
      */
     public static String readLine(InputStream in) throws IOException {
         StringBuffer buf = new StringBuffer(128);
-
+        boolean ok = readLine(in, buf);
+        if (ok)
+            return buf.toString();
+        else
+            return null;
+    }
+    /**
+     * Read in a line, placing it into the buffer (excluding the newline).
+     *
+     * @return true if the line was read, false if eof was reached before a 
+     *              newline was found
+     */
+    public static boolean readLine(InputStream in, StringBuffer buf) throws IOException {
         int c = -1;
         while ( (c = in.read()) != -1) {
             if (c == '\n')
@@ -688,9 +700,9 @@ public class DataHelper {
             buf.append((char)c);
         }
         if (c == -1) 
-            return null;
+            return false;
         else
-            return buf.toString();
+            return true;
     }
     
 

core/java/src/net/i2p/time/Timestamper.java

@@ -124,7 +124,8 @@ public class Timestamper implements Runnable {
                         alreadyBitched = true;
                     }
                 }
-                try { Thread.sleep(_queryFrequency); } catch (InterruptedException ie) {}
+                long sleepTime = _context.random().nextInt(_queryFrequency) + _queryFrequency;
+                try { Thread.sleep(sleepTime); } catch (InterruptedException ie) {}
             }
         } catch (Throwable t) {
             _log.log(Log.CRIT, "Timestamper died!", t);

core/java/src/net/i2p/util/Clock.java

@@ -42,8 +42,8 @@ public class Clock implements Timestamper.UpdateListener {
 
     /** if the clock is skewed by 3+ days, fuck 'em */
     public final static long MAX_OFFSET = 3 * 24 * 60 * 60 * 1000;
-    /** after we've started up and shifted the clock, don't allow shifts of more than a minute */
-    public final static long MAX_LIVE_OFFSET = 60 * 1000;
+    /** after we've started up and shifted the clock, don't allow shifts of more than 10 minutes */
+    public final static long MAX_LIVE_OFFSET = 10 * 60 * 1000;
     /** if the clock skewed changes by less than 1s, ignore the update (so we don't slide all over the place) */
     public final static long MIN_OFFSET_CHANGE = 10 * 1000;
 

core/java/test/net/i2p/crypto/ElGamalVerify.java

@@ -0,0 +1,206 @@
+package net.i2p.crypto;
+
+import net.i2p.I2PAppContext;
+import net.i2p.data.Base64;
+import net.i2p.data.DataHelper;
+import net.i2p.data.PrivateKey;
+import net.i2p.data.PublicKey;
+
+/**
+ * Unit test verifying the ElGamal encryption/decryption with some test
+ * data.  The keys generated & data stored were generated by jrandom on
+ * a pentium4 w/ an optimized jbigi installed and verified with pure java.
+ *
+ */
+public class ElGamalVerify {
+    private I2PAppContext _context;
+
+    private static final String UNENCRYPTED[] = new String[] { 
+        "", 
+        "hello world",
+        "1234567890123456789012345678901234567890123456789012345678901234567890" +
+        "1234567890123456789012345678901234567890123456789012345678901234567890" +
+        "1234567890123456789012345678901234567890123456789012345678901234567890" +
+        "123456789012",
+        "\0x00",
+        "\0x00\0x00\0x00",
+        "\0x00\0x01\0x02\0x00",
+    };
+    private static final String PUBLIC_KEY = new String(
+        "pOvBUMrSUUeN5awynzbPbCAwe3MqWprhSpp3OR7pvdfm9PhWaNbPoKRLeEmDoUwyNDoHE0" +
+	"E6mcZSG8qPQ8XUZFlczpilOl0MJBvsI9u9SMyi~bEqzSgzh9FNfS-NcGji3q2wI~Ux~q5B" +
+	"KOjGlyMLgd1nxl5R5wIYL4uHKZNaYuArsRYmtV~MgMQPGvDtIbdGTV6aL6UbOYryzQSUMY" +
+	"OuO3S~YoBjA6Nmi0SeJM3tyTxlI6U1EYjR6oQcI4SOFUW4L~8pfYWijcncCODAqpXVN6ZI" +
+	"AJ3a6vjxGu56IDp4xCcKlOEHgdXvqmEC67dR5qf2btH6dtWoB3-Z6QPsS6tPTQ=="
+    );
+    private static final String PRIVATE_KEY = new String(
+        "gMlIhURVXU8uPube20Xr8E1K11g-3qZxOj1riThHqt-rBx72MPq5ivT1rr28cE9mzOmsXi" +
+	"bbsuBuQKYDvF7hGICRB3ROSPePYhcupV3j7XiXUIYjWNw9hvylHXK~nTT7jkpIBazBJZfr" +
+	"LJPcDZTDB0YnCOHOL-KFn4N1R5B22g0iYRABN~O10AUjQmf1epklAXPqYlzmOYeJSfTPBI" +
+	"E44nEccWJp0M0KynhKVbDI0v9VYm6sPFK7WrzRyWwHL~r735wiRkwywuMmKJtA7-PuJjcW" +
+	"NLkJwx6WScH2msMzhzYPi8JSZJBl~PosX934l-L0T-KNV4jg1Ih6yoCnm1748A=="
+    );
+    private static final String ENCRYPTED[] = new String[] {
+        "AMfISa8KvTpaC7KXZzSvC2axyiSk0xPexBAf29yU~IKq21DzaU19wQcGJg-ktpG4hjGSg7" +
+        "u-mJ07b61yo-EGmVGZsv3nYuQYW-GjvsZQa9nm98VljlMtWrxu7TsRXw~SQlWQxMvthqJB" +
+        "1A7Y7Qa~C7-UlRytkD-cpVdgUfM-esuMWmjGs6Vc33N5U-tce5Fywa-9y7PSn3ukBO8KGR" +
+        "wm7T12~H2gvhgxrVeK2roOzsV7f5dGkvBQRZJ309Vg3j0kjaxWutgI3vli0pzDbSK9d5NR" +
+        "-GUDtdOb6IIfLiOckBegcv6I-wlSXjYJe8mIoaK45Ok3rEpHwWKVKS2MeuI7AmsAWgkQmW" +
+        "f8irmZaKc9X910VWSO5GYu6006hSc~r2TL3O7vwtW-Z9Oq~sAam9av1PPVJzAx8A4g~m~1" +
+        "avtNnncwlChsGo6mZHXqz-QMdMJXXP57f4bx36ZomkvpM-ZLlFAn-a~42KQJAApo4LfEyk" +
+        "7DPY2aTXL9ArOCNQIQB4f8QLyjvAvu6M3jzCoGo0wVX6oePfdiokGflriYOcD8rL4NbnCP" +
+        "~MSnVzC8LKyRzQVN1tDYj8~njuFqekls6En8KFJ-qgtL4PiYxbnBQDUPoW6y61m-S9r9e9" +
+        "y8qWd6~YtdAHAxVlw287~HEp9r7kqI-cjdo1337b7~5dm83KK45g5Nfw==",
+
+        "AIrd65mG1FJ~9J-DDSyhryVejJBSIjYOqV3GYmHDWgwLchTwq-bJS7dub3ENk9MZ-C6FIN" +
+        "gjUFRaLBtfwJnySmNf8pIf1srmgdfqGV2h77ufG5Gs0jggKPmPV~7Z1kTcgsqpL8MyrfXr" +
+        "Gi86X5ey-T0SZSFc0X1EhaE-47WlyWaGf-~xth6VOR~KG7clOxaOBpks-7WKZNQf7mpQRE" +
+        "4IsPJyj5p1Rf-MeDbVKbK~52IfXSuUZQ8uZr34KMoy4chjn6e-jBhM4XuaQWhsM~a3Q-zE" +
+        "pV-ea6t0bQTYfsbG9ch7pJuDPHM64o5mF9FS5-JGr7MOtfP7KDNHiYM2~-uC6BIAbiqBN8" +
+        "WSLX1mrHVuhiM-hiJ7U4oq~HYB6N~U980sCIW0dgFBbhalzzQhJQSrC1DFDqGfL5-L25mj" +
+        "ArP8dtvN0JY3LSnbcsm-pT9ttFHCPGomLfaAuP7ohknBoXK0j9e6~splg5sUA9TfLeBfqc" +
+        "Lr0Sf8b3l~PvmrVkbVcaE8yUqSS6JFdt3pavjyyAQSmSlb2jVNKGPlrov5QLzlbH7G~AUv" +
+        "IehsbGQX5ptRROtSojN~iYx3WQTOa-JLEC-AL7RbRu6B62p9I0pD0JgbUfCc4C4l9E9W~s" +
+        "MuaJLAXxh0b2miF7C5bzZHxbt~MtZ7Ho5qpZMitXyoE3icb43B6Y1sbA==", 
+
+        "ACjb0FkTIQbnEzCZlYXGxekznfJad5uW~F5Mbu~0wtsI1O2veqdr7Mb0N754xdIz7929Ti" +
+        "1Kz-CxVEAkb3RBbVNcYHLfjy23oQ4BCioDKQaJcdkJqXa~Orm7Ta2tbkhM1Mx05MDrQaVF" +
+        "gCVXtwTsPSLVK8VwScjPIFLXgQqqZ5osq~WhaMcYe2I2RCQLOx2VzaKbT21MMbtF70a-nK" +
+        "WovkRUNfJEPeJosFwF2duAD0BHHrPiryK9BPDhyOiyN82ahOi2uim1Nt5yhlP3xo7cLV2p" +
+        "6kTlR1BNC5pYjtsvetZf6wk-solNUrJWIzcuc18uRDNH5K90GTL6FXPMSulM~E4ATRQfhZ" +
+        "fkW9xCrBIaIQM49ms2wONsp7fvI07b1r0rt7ZwCFOFit1HSAKl8UpsAYu-EsIO1qAK7vvO" +
+        "UV~0OuBXkMZEyJT-uIVfbE~xrwPE0zPYE~parSVQgi~yNQBxukUM1smAM5xXVvJu8GjmE-" +
+        "kJZw1cxaYLGsJjDHDk4HfEsyQVVPZ0V3bQvhB1tg5cCsTH~VNjts4taDTPWfDZmjtVaxxr" +
+        "PRII4NEDKqEzg3JBevM~yft-RDfMc8RVlm-gCGANrRQORFii7uD3o9~y~4P2tLnO7Fy3m5" +
+        "rdjRsOsWnCQZzw37mcBoT9rEZPrVpD8pjebJ1~HNc764xIpXDWVt8CbA==", 
+
+        "AHDZBKiWeaIYQS9R1l70IlRnoplwKTkLP2dLlXmVh1gB33kx65uX8OMb3hdZEO0Bbzxkkx" +
+        "quqlNn5w166nJO4nPbpEzVfgtY4ClUuv~W4H4CXBr0FcZM1COAkd6rtp6~lUp7cZ8FAkpH" +
+        "spl95IxlFM-F1HwiPcbmTjRO1AwCal4sH8S5WmJCvBU6jH6pBPo~9B9vAtP7vX1EwsG2Jf" +
+        "CQXkVkfvbWpSicbsWn77aECedS3HkIMrXrxojp7gAiPgQhX4NR387rcUPFsMHGeUraTUPZ" +
+        "D7ctk5tpUuYYwRQc5cRKHa4zOq~AQyljx5w5~FByLda--6yCe7qDcILyTygudJ4AHRs1pJ" +
+        "RU3uuRTHZx0XJQo~cPsoQ2piAOohITX9~yMCimCgv2EIhY3Z-mAgo8qQ4iMbItoE1cl93I" +
+        "u2YV2n4wMq9laBx0shuKOJqO3rjRnszzCbqMuFAXfc3KgGDEaCpI7049s3i2yIcv4vT9uU" +
+        "AlrM-dsrdw0JgJiFYl0JXh~TO0IyrcVcLpgZYgRhEvTAdkDNwTs-2GK4tzdPEd34os4a2c" +
+        "DPL8joh3jhp~eGoRzrpcdRekxENdzheL4w3wD1fJ9W2-leil1FH6EPc3FSL6e~nqbw69gN" +
+        "bsuXAMQ6CobukJdJEy37uKmEw4v6WPyfYMUUacchv1JoNfkHLpnAWifQ==", 
+
+        "AGwvKAMJcPAliP-n7F0Rrj0JMRaFGjww~zvBjyzc~SPJrBF831cMqZFRmMHotgA7S5BrH2" +
+        "6CL8okI2N-7as0F2l7OPx50dFEwSVSjqBjVV6SGRFC8oS-ii1FURMz2SCHSaj6kazAYq4s" +
+        "DwyqR7vnUrOtPnZujHSU~a02jinyn-QOaHkxRiUp-Oo0jlZiU5xomXgLdkhtuz6725WUDj" +
+        "3uVlMtIYfeKQsTdasujHe1oQhUmp58jfg5vgZ8g87cY8rn4p9DRwDBBuo6vi5on7T13sGx" +
+        "tY9wz6HTpwzDhEqpNrj~h4JibElfi0Jo8ZllmNTO1ZCNpUQgASoTtyFLD5rk6cIAMK0R7A" +
+        "7hjB0aelKM-V7AHkj-Fhrcm8xIgWhKaLn2wKbVNpAkllkiLALyfWJ9dhJ804RWQTMPE-GD" +
+        "kBMIFOOJ9MhpEN533OBQDwUKcoxMjl0zOMNCLx8IdCE6cLtUDKJXLB0atnDpLkBer6FwXP" +
+        "81EvKDYhtp1GsbiKvZDt8LSPJQnm2EdA3Pr9fpAisJ5Ocaxlfa6~uQCuqGA9nJ9n6w03u-" +
+        "ZpSMhSh4zm2s1MqijmaJRc-QNKmN~u1hh3R2hwWNi7FoStMA87sutEBXMdFI8un7StHNSE" +
+        "iCYwmmW2Nu3djkM-X8gGjSsdrphTU7uOXbwazmguobFGxI0JujYruM5Q==", 
+
+        "ALFYtPSwEEW3eTO4hLw6PZNlBKoSIseQNBi034gq6FwYEZsJOAo-1VXcvMviKw2MCP9ZkH" +
+        "lTNBfzc79ms2TU8kXxc7zwUc-l2HJLWh6dj2tIQLR8bbWM7U0iUx4XB1B-FEvdhbjz7dsu" +
+        "6SBXVhxo2ulrk7Q7vX3kPrePhZZldcNZcS0t65DHYYwL~E~ROjQwOO4Cb~8FgiIUjb8CCN" +
+        "w5zxJpBaEt7UvZffkVwj-EWTzFy3DIjWIRizxnsI~mUI-VspPE~xlmFX~TwPS9UbwJDpm8" +
+        "-WzINFcehSzF3y9rzSMX-KbU8m4YZj07itZOiIbWgLeulTUB-UgwEkfJBG0xiSUAspZf2~" +
+        "t~NthBlpcdrBLADXTJ7Jmkk4MIfysV~JpDB7IVg0v4WcUUwF3sYMmBCdPCwyYf0hTrl2Yb" +
+        "L6kmm4u97WgQqf0TyzXtVZYwjct4LzZlyH591y6O6AQ4Fydqos9ABInzu-SbXq6S1Hi6vr" +
+        "aNWU3mcy2myie32EEXtkX7P8eXWY35GCv9ThPEYHG5g1qKOk95ZCTYYwlpgeyaMKsnN3C~" +
+        "x9TJA8K8T44v7vE6--Nw4Z4zjepwkIOht9iQsA6D6wRUQpeYX8bjIyYDPC7GUHq0WhXR6E" +
+        "6Ojc9k8V5uh0SZ-rCQX6sccdk3JbyRhjGP4rSKr6MmvxVVsqBjcbpxsg=="
+    };
+    
+    public static void main(String args[]) {
+        ElGamalVerify verify = new ElGamalVerify();
+        verify.verifySelf();
+        verify.verifyCompatability();
+        if (args.length > 0)
+            verify.generateEncrypted();
+    }
+    
+    public ElGamalVerify() {
+        _context = new I2PAppContext();
+    }
+    
+    /** verify that we can decrypt what we encrypt */
+    private void verifySelf() {
+        try {
+            Object keypair[] = _context.keyGenerator().generatePKIKeypair();
+            PublicKey pub = (PublicKey)keypair[0];
+            PrivateKey priv = (PrivateKey)keypair[1];
+
+            for (int i = 0; i < UNENCRYPTED.length; i++) { 
+                byte orig[] = UNENCRYPTED[i].getBytes();
+
+                byte encrypted[] = _context.elGamalEngine().encrypt(orig, pub);
+                byte decrypted[] = _context.elGamalEngine().decrypt(encrypted, priv);
+
+                if (DataHelper.eq(decrypted, orig))
+                    log("OK   : verifySelf[" + i + "] passed");
+                else
+                    log("ERROR: verifySelf[" + i + "] failed");
+            }
+        } catch (Exception e) {
+            log("ERROR: verifySelf blew up: " + e.getMessage());
+            e.printStackTrace();
+        }
+    }
+    
+    /** verify that we can decrypt what other people encrypt */
+    private void verifyCompatability() {
+        verifyDecrypt();
+    }
+    
+    private void verifyDecrypt() {
+        try {
+            PublicKey pub = new PublicKey();
+            PrivateKey priv = new PrivateKey();
+            pub.fromBase64(PUBLIC_KEY);
+            priv.fromBase64(PRIVATE_KEY);
+
+            for (int i = 0; i < ENCRYPTED.length; i++) {
+                byte enc[] = Base64.decode(ENCRYPTED[i]);
+                byte decrypted[] = _context.elGamalEngine().decrypt(enc, priv);
+
+                if (DataHelper.eq(decrypted, UNENCRYPTED[i].getBytes()))
+                    log("OK   : verifyDecrypt[" + i + "] passed");
+                else
+                    log("ERROR: verifyDecrypt[" + i + "] failed");
+            }
+        } catch (Exception e) {
+            log("ERROR: generateEncrypted blew up: " + e.getMessage());
+            e.printStackTrace();
+        }
+    }
+    private void generateEncrypted() {
+        try {
+            Object keypair[] = _context.keyGenerator().generatePKIKeypair();
+            PublicKey pub = (PublicKey)keypair[0];
+            PrivateKey priv = (PrivateKey)keypair[1];
+            
+            log("PUBLIC : " + pub.toBase64());
+            log("PRIVATE: " + priv.toBase64());
+
+            for (int i = 0; i < UNENCRYPTED.length; i++) { 
+                byte orig[] = UNENCRYPTED[i].getBytes();
+
+                byte encrypted[] = _context.elGamalEngine().encrypt(orig, pub);
+
+                System.out.println("Encrypted [" + i + "]: ");
+                String enc = Base64.encode(encrypted);
+                for (int j = 0; j < enc.length(); j++) {
+                    int remaining = enc.length() - j*70;
+                    if (remaining > 0) {
+                        String cur = enc.substring(j * 70, remaining > 70 ? (j+1)*70 : enc.length());
+                        System.out.println(cur);
+                    }
+                }
+            }
+        } catch (Exception e) {
+            log("ERROR: generateEncrypted blew up: " + e.getMessage());
+            e.printStackTrace();
+        }
+    }
+    
+    private void log(String msg) {
+        System.out.println(msg);
+    }
+}

history.txt

@@ -1,4 +1,134 @@
-$Id: history.txt,v 1.101 2004/12/08 12:16:17 jrandom Exp $
+$Id: history.txt,v 1.117 2004/12/21 11:32:50 jrandom Exp $
+
+* 2004-12-21  0.4.2.5 released
+
+2004-12-21  jrandom
+    * Track a new stat for expired client leases (client.leaseSetExpired).
+
+2004-12-21  jrandom
+    * Cleaned up the postinstall/startup scripts a bit more to handle winME,
+      and added windows info to the headless docs. (thanks ardvark!)
+    * Fixed a harmless (yet NPE inspiring) race during the final shutdown of 
+      a stream (thanks frosk!)
+    * Add a pair of new stats for monitoring tunnel participation - 
+      tunnel.participatingBytesProcessed (total # bytes transferred) and
+      tunnel.participatingBytesProcessedActive (total # bytes transferred for
+      tunnels whose byte count exceed the 10m average).  This should help 
+      further monitor congestion issues.
+    * Made the NamingService factory property public (thanks susi!)
+
+2004-12-20  jrandom
+    * No longer do a blocking DNS lookup within the jobqueue (thanks mule!)
+    * Set a 60s dns cache TTL, instead of 0s.  Most users who used to use
+      dyndns/etc now just use IP autodetection, so the old "we need ttl=0"
+      reasoning is gone.
+
+2004-12-19  jrandom
+    * Fix for a race on startup wrt the new stats (thanks susi!)
+
+2004-12-19  jrandom
+    * Added three new stats - router.activePeers, router.fastPeers, and 
+      router.highCapacityPeers, updated every minute
+
+2004-12-19  jrandom
+    * Added a new i2ptunnel type: 'httpserver', allowing you to specify what
+      hostname should be sent to the webserver.  By default, new installs will
+      have an httpserver pointing at their jetty instance with the spoofed 
+      name 'mysite.i2p' (editable on the /i2ptunnel/edit.jsp page).
+
+2004-12-19  scintilla
+    * Convert native jcpuid code from C++ to C. This should alleviate build
+      problems experienced by some users.
+
+* 2004-12-18  0.4.2.4 released
+
+2004-12-16  jrandom
+    * Catch another oddball case for a reset connection in the streaming lib.
+    * Add a dumpprofile.jsp page, called with ?peer=base64OfPeerHash, which
+      dumps the current state of that peer's profile.  Instead of the full 
+      base64, you can pass in however many characters you have and it will
+      return the first match found.
+
+2004-12-16  jrandom
+    * Remove the randomized factor in the tunnel rejection by bandwidth -
+      we now accept the request if we've allocated less than our limit
+      and reject it if we've allocated more.
+    * Stick to the standard capacity scale on tunnel rejection, even for 
+      the 10m period.
+    * Build the time message at the very last possible moment
+
+2004-12-15  jrandom
+    * Handle hard disconnects more gracefully within the streaming lib, and
+      log unmonitored events more aggressively.
+    * If we drop a peer after connection due to clock skew, log it to the
+      /logs.jsp#connectionlogs with relevent info.  In addition, toss it in
+      the stat 'tcp.disconnectAfterSkew'.
+    * Fixed the formatting in the skew display
+    * Added an ERROR message that is fired once after we run out of 
+      routerInfo files (thanks susi!)
+    * Set the connect timeout equal to the streaming lib's disconnect timeout
+      if not already specified (the I2PTunnel httpclient already enforces a
+      60s connect timeout)
+    * Fix for another connection startup problem in the streaming lib.
+    * Fix for a stupid error in the probabalistic drop (rand <= P, not > P)
+    * Adjust the capacity calculations so that tunnel failures alone in the 
+      last 10m will not trigger a 0 capacity rank.
+
+2004-12-14  jrandom
+    * Periodically send a message along all I2NP connections with the router's
+      current time, allowing the receiving peer to determine that the clock 
+      has skewed too much, and hence, disconnect.  For backwards compatability
+      reasons, this is being kludged into a DeliveryStatusMessage (ewww).  The
+      next time we have a backwards compatability break, we can put in a proper
+      message setup for it.
+
+2004-12-14  jrandom
+    * Reenable the probabalistic drop on the TCP queues to deal with good old
+      fashioned bandwidth limiting.  However, by default the probability is
+      rigged to reserve 0% of the queue free - meaning we just aggressively
+      fail messages in the queue if we're transferring too slowly.  That
+      reservation factor can be increased with 'tcp.queueFreeFactor=0.25'
+      (or whatever) and the drop code can be disabled with the parameter
+      'tcp.dropProbabalistically=false'.
+    * Still penalize a peer on tunnel failure, but don't immediately drop 
+      their capacity to 0.
+    * More aggressively ACK duplicates
+    * Randomize the timestamper period
+    * Display the clock skew on the connection logs when a peer sends it.
+    * Allow the timestamper to fix skews of up to 10 minutes
+    * Logging
+
+2004-12-13  jrandom
+    * Added some error checking on the new client send job (thanks duck!)
+    * Implemented tunnel rejection based on bandwidth usage (rejecting tunnels
+      proportional to the bytes allocated in existing tunnels vs the bytes 
+      allowed through the bandwidth limiter).
+    * Enable a new configuration parameter for triggering a tunnel rebuild 
+      (tunnel.maxTunnelFailures), where that is the max allowed test failures
+      before killing the tunnel (default 0).
+    * Gather more data that we rank capacity by (now we monitor and balance the
+      data from 10m/30m/60m/1d instead of just 10m/60m/1d).
+    * Fix a truncation/type conversion problem on the long term capacity 
+      values (we were ignoring the daily stats outright)
+
+2004-12-11  jrandom
+    * Fix the missing HTTP timeout, which was caused by the deferred syn used
+      by default.  This, in turn, meant the I2PSocket creation doesn't fail
+      on .connect, but is unable to transfer any data in any direction.  We now
+      detect that condition for the I2PTunnelHTTPClient and throw up the right
+      error page.
+    * Logging
+
+2004-12-11  jrandom
+    * Use a simpler and less memory intensive job for processing outbound 
+      client messages when the session is in mode=bestEffort.  We can 
+      immediately discard the data as soon as its sent the first time, 
+      rather than wait for an ack, since we will never internally resend.
+    * Reduce some synchronization to avoid a rare deadlock
+    * Replaced 'localhost' with 127.0.0.1 in the i2ptunnel config, and special
+      case it within the tunnel controller.
+    * Script cleanup for building jbigi/jcpuid
+    * Logging
 
 * 2004-12-08  0.4.2.3 released
 

hosts.txt

@@ -1,6 +1,16 @@
 ; TC's hosts.txt guaranteed freshness
-; $Id: hosts.txt,v 1.88 2004/12/06 17:13:41 jrandom Exp $
+; $Id: hosts.txt,v 1.98 2004/12/18 01:31:22 jrandom Exp $
 ; changelog:
+; (1.121) added up.i2p
+; (1.120) added dm.i2p
+; (1.119) added piespy.i2p
+; (1.118) added sciencebooks.i2p
+; (1.117) added forum.fr.i2p, fedo.i2p, and pastebin.i2p
+; (1.116) added frosk.i2p
+; (1.115) added theland.i2p
+; (1.114) added dox.i2p
+; (1.113) added amiga.i2p
+; (1.112) added frooze.i2p
 ; (1.111) aliased gott.i2p as jrandom.i2p (ed. note: no, i am not gott)
 ; (1.110) added sonax.i2p
 ; (1.109) added 1.fcp.freenet.i2p and copied fcp.i2p to 2.fcp.freenet.i2p
@@ -248,4 +258,16 @@ asciiwhite.i2p=kJJmuP~sE0SrQFX-nyV2cEFDffnqv3D4-vBNJX6wqEq7vbTjQzZVn3jtt5kYlv4Fp
 2.fcp.freenet.i2p=yY8ahms44MDj2cdI6o7Fc2ozz-jM4ACEp8t4YJiRsKgEYx6XNB7QrNK8jZQoKIQ8G6GMmKMYsgRGmbwWFt60au5HFNv56NWsB4Nd80G9iSRLiEHOHhaUSFnR~ZnSdzL-nbMqA8-vzteaqZ8HNnC2NNjJXsMyULFdkBsIKYS0jsS5hl7ddf0v69X7sCSp1CCy5H28rmZSEtKA4aYXGcBHJ8bXFomV5ovy~Mh2xZzWdeVmjdmJACG~ekDBcMkm7G5mlYoTN2aEBghxiHv~plGlHFqERB3lgISlomYIwYwPqxcmpxwbg9OSEo53t45P9~dat8XMvabzXiUdm0UgVnFsNBAIyNgyTEktw38~5v2XHhqpn8RSoMUeNOqp~k740v9fYH7xxHYCrfN7y3rKg~~GlWekbNmX5g0UvKjV-QWHIvrdOVZmII9qNTTwm3Uf2Tyi2aFll7TF9CvKUJCI0Mt1BpQEmPQdY~FgFXNd0p-~DvlRrwaI4jorbn4eUUEJqgzFAAAA
 sonax.i2p=s~FYxHeR1n0aN0kuilNtJU9IbXRX~jWI6vGz4TUf6oZyjZBYYmY9OpgDa3sr-8AERqsuG6EKA~UBn4KiQdkI-LU16DwEHvbgfZXAdwY73G6SkHOgwVAnT2SIOuh90v1QevYtxiGpA7IVm6icoz5V4I6V29hPlUNJxBFF~Qn2cY6zj0d6wBk6ulYc0vbyOwu8Lfc8T8bTnBLut3SZWgKHYLbxabcXJtcQpoN7k815N1MEUi0APD45o5TwPhvpHLt8fF10aNcMScpL01RR~tKHgC6jPX~HKM~Ld4l0z0lvLeq9197Qp6zHRvRD3YUQxyvgHi2ANkYprvJof1Abgs8TD1JWkZUAzlfqFPyjO~f3pJSDd5eM7E0Fk69ym1Y4Rltih~Y2N1IVtJPfo9Tx9a3RQWOJZ0MN12xfiZjyF92gDRgfKW5RDpwCoTVmP79u~WUr8lQ-qQbKhsMQQqMn8Uy8DeXvKLRpHaECtevjohL4lWBBR0ezXlBLCXKqaVXKcMTjAAAA
 jrandom.i2p=BxciUZkGQwi6Sj1Ucg5GGagDdwujlj8ClePa4~3d-1nnRJsBhTNJtvs-UuQYY77gPGNlpNk9dt02mxeS7f~pEC4E1KxJH9mhnf0OlIGB4hOOhDlXokAaKE2u1E-vVCDJlZCq32r~Ne53w-L2m5h5FAq5Bx7NXrTzWAEPgAlC8A2wASJWIF-EKOX5kfkkYoF6sKZqam5CxAAAMAUwmnbD--7wo8d2mz0C-c~oE7hzuHsg2J8yME5Zd~-FOZUxkoNCBJdfrVlVRn9~6685zqpaotL-SIqFK6~28ZCNMNCtnZcZZLeG2gZxq2pe8HtgzDrMMSx45vs3JLUp8Bap6~D9oFX0o7k2DQm-5R9D5NWhsJgol5Ny~8ABTXBpW~WQQOuKxE5xJauXM5rQia2yyXgldfOyGjxYnkrTGu6LaxlLmhyAva3ZbOO0mtLvrKLZebLKCYUxP7~TtNmSWEAzPKFYbjdZ~NjE0q4TanLFBaWotefPmy3IuAc8Mr7PbCvi4GmdAAAA
+frooze.i2p=kyjnpna6HHapU~tLQXRCHrX6Dpb2YCMEtFTloKF298480axGCZFY-WtpjW2Mo1ci5FlE7dkmEQ1PU0GfHZ6s0O~Hert5AcZpKh5nxRIMtS7uc~oErYCiX0yQp2P9D47B9VU5D2UmjYKWovqbrbKEAS1F0NDxXh65Ppnv-oBHVksLp7IrKLU3IOesdYtGcc9cSYJB6~mdbtqXxgHNNLTkyouSJKgSlJoe-tk1T3eYEsOJ6vzpeS6pNa6Px2dknejT~aVeNKLhjsXy706g22Mbl1-zCL87OE1bL2qWQbQN43qpLwCSv0LbRovO3r6iXRWWWrKhYj5nti~EQEWapJ2OL26~ElrpD9V9gbUVLZoxeYuu~-GKKwg6CvZYKtdf6YBYTZ0Ef4PUcv9faSqp7S4emcGOLQnSW9LezXhGhn0OPaAO~85nhdY~OfXDZ2Dg2tYYF-D70SzKycfHFLgKBQ9fkCxpOP0MHhhgGmKHabPvDHyQRFppcKLN6AYmUH1Lke-jAAAA
+amiga.i2p=-lqgoqA5KcJCuGilYz~cOBK3X7MI5VFBK7UwpSEwqbiQgSe340wABmE8V-tX7xH7rjc4Z2rGxqas5NKuOL3pCJozeKF4Z61d05nCemSXbLrqZvJUkGuZJfUz9lzeZ5OGO8L32o-I6DIGIUgFk6zRpiRW0lqO4lzV~fbiHacDhUXPLBM5gYjvZ319MLoVPp-YWG-STJFhjmAnzvj~8h-jJXHowM72YsWPo-B~oD1YtcAcXkpxVJOaLlqQq2yfjJv7YgIde3tqQ6drH7xmHdG~nF~dsu2dacqqt~HjDiUnPd12vJEhR18DDkVJVhDUbnUCcI83bt5RDdsMK8mSKRTie3h1sUam~1fLr8~gnEGTFp-yivGV1JkeleElR-rTJC7PsrlPCWzW2N4l1IMzRGOedJNAyqeXbkfjHtDBd58iZPugS5BZZ~u5MGqXgfu9TYFnLnTIGuMc3a2wSpe3miMvf2PKFnM~1nzStN0zEjFwhn4tZhOWA1TfTH5HMutqrxGxAAAA
+dox.i2p=ygf2mdGRnU12BNXXF-26OFhfPpAMigwasf93JEHVYEICVmz6Fk2BBKiGBWL4YNFUtcFo7y1iG3ms8BdmTBBkgCgEasuFZNzphEMgcNYi0eYAg1QLNgmbr5HEDpBNuXIV7fOpxYn6iij76oA09e5opPNdOLUk80kWrgrlJTel61n90uzEzz46fWIbFEw5K8xR-8aqLgC2sJDzGj8vEBY2NDKmCtjRK7aNBUayh~8vFfJyo5oN0gw8b5cOCrfSoxzqdpzI5CJ7070GjznWbWh~pueKWF4CpHn92ll3jvyd86KvUwdQh1qr1B-8fk6Oh~M9l5HRzqdUsSzp8SiG7WvLQoXrNdVX2Sjw22xOZDr7kOfEHZWYUdmrcYyqNLuIT2vgMFXdvCZnLhhGSaihkzuFqZv-34oGSqGDVlCanAPC4v6492IRRK7RiYnUo-JPhuWgpg9CdFTZtULa~drZbWNCZvAekn44D42wDx5V5vAJxuRoyir1s4gAnXHL7n9r7xdiAAAA
+theland.i2p=Lf52G95rF1kjlRu29NMpPQ46Ivd2Nz-sdIhvx5D4qU3Y3MPs50GNTjg81yJmUgbg95Q90Eyf~SHsgbzdlnjr-qQEZOXIgLQErq2UhUFGwUX6muqkCYYDIAZ-f7EI-yJiU-3~KDwWu77z-8XDjaJIf78tNV6kN3MvRwUSbBRLD7pAa3HtdhNnNyO-PPBJJVMxorQ-~AgEhmdgLj39WfgetETiRm4ew0NsN6IOHWn~~vh26FJ4awhLpJ0fCBD-fPve~jTbCovjsszKMBumTslvQS~p-dfjfQSTMRZAE3fs262NjdEwoVZP-k~~0HmzOmV9M-Oe8yez6ORDKm8sDyeDoQ~e21b77SiE2tNrgHeB3siITcZoTNyICX~ZSG~Qnb4k4kXdllVkqmXaf7k0pYE1yTKXM3sKphP~VJFMBgdSzZPprhp6RGjWibKy~94Ns8IyCA6c08810yodEdoeU53acQPp~wk0FP1HgcF3tVggk-wHg65cD09ncjOmly5Gc7uZAAAA
+frosk.i2p=Dez-OBQLhsI7Wq~O8YmYYJjl~IPvqUCZbLIFVMnyyqOCG9TEO~kGUVpWVD5nF0B5fE8kEWq8CuGKeYbVfqt0Vuz6Uvvo4gCdGnthohthbolIOZ9ZCci9MTNE6t29mJ2thHqc9Nw5TvYJGcvCVNi569~o5PDtYhZjVsOtrv8r3f9fUcUV-wKokD-y0fdF3Dzw4I7tJ6pfohj4avzDwwndAHXnNjB9mDgQsfjPF2KtvWLzXyAsCmfCoanV65tkc09ZX4x5QkekdVgTbD0BcHDP-o71MVufRsm4~ojRkbdSLw-VlbEcYFyeHTPBTpM68gTjueJlRwmvpXyP46w~Xnl9IEDfWu92CV9xjRt8qDxiyQ9jXR6dbWLptTF2UCznkBWvWph7P2wliTiawt~1bWGw2YvkfB6EaENYvDNY2cGn0GxpPhL4K19slEwJqX9f~EzLKYx4xaB5I8~W9syJAJSX8PsJbUlk6OhbbRoYOndd6OCRqHRUyh1w7dM~LvbY0W8hAAAA
+forum.fr.i2p=glvyM8eKBTYnlwEl3hVWDRBvfIfe-utzjGAlvDM-rwB4tb4CaM49Aeb5k0lxm7IaFjkp0u9t~1a2KIxwrU~Mj-JTJPKf0TrElVfOT6P0sVFOD3U1wllFwne5e7~0d8MeuylMrBe3dlz5KSPQ69stpDTbJgxcynoKiPMWcbmq~yQjnIvtDIpAPaB1JVYNo8mDhqMqg8GLrk9ttTHO90dYUpdI5lgxB6vR1nuPPwyFczOjVn8GvmT1DXGNoc6yAW0gCLuk7Hq-jNcNtXkNRC5TTdNiBLdLpsNMD3kKWDM04fODM5N~qp-nww-lEqfuZ3f1RT3gpjDwpMMAtKbd~VsRaCEINL5iBaAlZupW6fYTiuGUUdOZ739JK9GpQDsPXBOy~VSoM~cLXJCih12v-GDODDN0i8sSkqZ7CXDGg~jkg0ab2Y-Y2JnpYFLsgYziPtNRij1~rMCcC~-huiSfQio15gxczb~RRS-lpBQgyfaZ5JgIR2uVjWWe-uwKD-WquuIPAAAA
+fedo.i2p=pklxM9~hpluoCoiPgzMBpTHXMpwEdCMMNEatVc4gnQDOXsKkW5FbUMQ9y0vj6EUs2vUZLkwp3FP3-PuJEHMCLCTBdkVlE5JErwhZU6V3S5lOZ2jTrSuYAhcph~ML~ntjDzc-IZWgAax98ChzCpwxhEk4eP4B9vEhMG7njoxbJLfwAYu1qgq0A-Whm08rAhAcDwl8a-21Kqj8~iGq0XytMqyJU5XArq4aArWEwZFFLKJD9uR9bKeMaHIkJLNAyKIvfpgwRjYIMlIf6ekN3cpBU3B6c8NgDNPNqNBI6DQ1XGfKOEqX6d31mTOSzyjs-zgIJkt5zg-MH1pnMSVAI-vQbiAaPJc3Rjeqarv5Z89ZX~dghQFNQX1Wd7ezJy0WltaY6V7lLxd6QPTosDCDawT7ZoNhmLUNtFXI7oGS4Cm4ZTZAjZV-ZFMUXWUKFTZGyh4s2WbYqJq1Sackk8JmCvZ7JHazJ9ghnrQQ2bpzWeeGgtCPIcTnaUMPOZdsU96ehme7AAAA
+pastebin.i2p=mUDz9K6KmWe2zE4wj~YjqwD5f8pCjEbze-DuafzjtXOaj9SnRBrLNqgOTt063y9foZett484g9PFm~3ibqFZfUk3LsJi6YhZje-V~RZndBElRJ1cX~MBOG5wdHA2BYpBt7jX-N5J9ww7POtcPFDjyYlJLhRrY5FuRfxdsWJ4BOUHOwvbTq7IWvqHReayte6vKavpyvNcAotcFHAhOGpR6Ua3RncS~b6NA5k2CQIeS4mR6~iNCh0sx1gj4cWWWqXSa6pN19io82L2fcNEcxE-UETj4HkG5fTdBlB4I2cNAm1KnxQw9ntRf19p5EzYkOFYST5ra~RWmy0bWzJMBFlK9QcogVi97gmszuNPyfIpJIE1ssZ6BNHKMkPJ-fjxtSAseTBV-Fa51TIBwNyXC6VxMsixKIBX4Cg64oipoGpm~-7SdRgabHbB0vWwiV6RYEQ88oNcV2ycDqjyfQymT0T5S9b0aVd2Ey1ZWly-PR44~uC3mCctcMqfZVfNFs3NoY3ZAAAA
+sciencebooks.i2p=Rrqf6EmeuqckygNrim-ZcZ97uEIL9Ykkr8cj1RSGbeih33~UUpjAp0x2fxrpbibXwuGufWMNoaMkZH8FxOxZr1hvBeV4Mvjrn05kKWyPpBB1x7rAcVCCoD~bl6CUU2k4NtFrO9~BCCZdoIvMxXYWRy4nj18RVaIlOS3qE6~F04pU7Fy0sj7xtd02wgeyKkJ6pXYGfETMr6phVusHSSQfCumDBpnqEt7EcXTIsPz58y9Zim4u1wp6xj~OvGWFIP8fKIxpH~zf6o0qYytXrf6SJbIEvwITKGIXZTM5KxQ0LbEydSgPn4q5PttQlKg~7hxuGG5RYqP2IMg-f9z4-1SfYTbz~EixEq8gv0R30c60tqsyAaw9o37R3k9inkT5WylYwBKM0pzfcAVjejcoPYnFF1iithGl0AYkP~~isxCErCNwLs39NyE688C5amDIpXl7AgB~IvbwZfONbd2cwMOB2RFzTShYZlwcILB7EzgMvEt2l8GBkstP3CzNrjQ2gAL0AAAA
+piespy.i2p=jTCW8w04d~Sucb7OXFBZtq7tEOxeFBNm5T4uVZW3xNapThxk0Tie8OAIQMmz4lzDUaHoc97DN1s6k3rTprRrhbr7Idyls5I-r6jAQnrljqUveIMA-lbzXDYTgo8TqBR4~fpSL4RM5u4~sM4ZRKdwufnEjCSlYtTe8qmrofFx3cIuIKhfypsYcu-BEdrw7P~cRpmqJqBV~igulwfIxeABa8ygX~Uk~i68NELte55J70z~kijYGMAgUJVhtQxD~jZD5l3FrGkND9lVaam0lHseujNyy~ZB-ma5IKqJWKLEo19e224EVhIK4jcKYdnr7bE86mZiWg36GvWFhjJOkEvCJ3BWxaMjcDXyk-9vCY7MA403OCMGGHoKlzB2AKq1PEc1teMtoqMG~a42DTKevUbbiALtauxCe-BOxEtxpYTvvql-RVumrUh3hckh0wqAd1Gqr2uqRx4VaCF3X3duOxdoKV6Kgf~icfVIFq5HR7AhN63BGFhAeQLcudp3oA828a06AAAA
+dm.i2p=ZPCnBTv~~EZTvbq4D4Lscn4AL~VMwbmKSLEF4Aq8bzynQm~kGnkSLhrDpNaJyAvO0F9wX-7bxyu3KLmpE~0KZt-6-J2spfBqkRTOd39j1YjJ1HHXivWiI8yl4uoHXZun6UW~QdwKQPzAMBnl2W4rXpQekGxwh7HlnQT22FyI-ELtzh8FE8JJ6DxfYsDKd49QnsePM3r2dB6hWb0lPEf-DwSD8JtsRmXMmDfa16-yWt5Wa0K-xrWbKh~oQ8K1aXhHoUxsfJ~LQnklt~QGld9Cbk7q1hJKXFUSqCoLaADZEmvzuNlzE53ChK~W6IanEZ4WeNT7dMJaMtta2Ot5Ym9dXGygFp2XE5zGsOpq38XGNHHI3iKNCexIh0eTL3jwwkUQXl7UPWxrykRff8uRSgBq6s669lOzUbZfdmAbkTG6NvwU0RboQQ-OYs7APDn5ovXHI3zl0bRljZWBxNVswz34fQ~jkA5aHUcgV~sNgwjjz5um7K9V-QEVUBi68AhJbmvRAAAA
+up.i2p=D7MtDuWfl9XOkSDC~hCH7QBrnDhg2KdxFq2dyq0e2jJypmXPFSw0Hl6HOMdI3myFTtweKZObHaPzy4c3-hk9ZwBsqzT8XquTVoa~z7OAtoj0QQDdIGXaHpDvVWkj9wAilpJfypqThVho08F0cq9~yChBh2s02JoQersRQ4l9oMQaOSVS85wGudFYSeWUhRPJyb0FN4ic7KPRvFlOBnESCtQUxMa0HV28UDyc9kGUN8AmgaV2qi-LcdrxHsYwzbYKZVa6Tg3mHEqksuzH5AK~9KYHlzLz2QRDesL0jkf7WdVRlKSiqkrYQVSG7MAqHfHNhQbb9oIpqDARyAqUaPJyEVQRAphJ9qv-K54QW1T2Js5tF5XVJoZcU04d9aHyxaUKqWJwIMrRlfeKVGAPlE7pcUjQrTKe6-22-46CzKpHsG8j4kwSyvrwlpGdsbN7-q9tq3KH4b9hJiv5nsQ4lSBQ9Um6YCEmUdwffnfbbfVGPCmj9XcMSrnHfvCD2rf4-V9sAAAA
 

install-headless.txt

@@ -1,4 +1,4 @@
-$Id: install-headless.txt,v 1.2 2004/09/02 01:54:37 jrandom Exp $
+$Id: install-headless.txt,v 1.3 2004/09/29 14:38:15 jrandom Exp $
 Headless I2P installation instructions
 
 1) tar xjf i2p.tar.bz2                     (you've already done this)
@@ -10,7 +10,8 @@ If you're having trouble, swing by http://forum.i2p.net/, check the
 website at http://www.i2p.net/, or get on irc://irc.freenode.net/#i2p
 
 To run I2P explicitly:
-   sh i2prouter start
+   (*nix): sh i2prouter start
+   (win*): I2Psvc.exe -c wrapper.config
 
 To stop the router (gracefully):
    lynx http://localhost:7657/configservice.jsp ("Shutdown gracefully")
@@ -26,4 +27,4 @@ Supported JVMs:
   Linux:   Latest available from http://java.sun.com/ (1.3+ supported)
   FreeBSD: /usr/ports/java/linux-sun-jdk1.4
   various: http://www.kaffe.org/ using CVS HEAD as of Sept 1, 2004
-           (or any subsequent releases)
+           (or any subsequent releases)

install.txt

@@ -0,0 +1,26 @@
+$Id$
+I2P source installation instructions
+
+To build and install I2P from source, you must first build
+and package up the appropriate installer by running:
+
+  ant dist
+
+This will produce a few key files:
+* i2p.tar.bz2:   the headless installation
+* install.jar:   the GUI installer
+* i2pupdate.zip: the update package
+
+From there, you can follow the headless installation instructions
+with the headless installer, run the GUI installer, or deploy
+the update into an existing installation.
+
+You will need to have ant installed from http://ant.apache.org/
+(1.5 or newer)
+
+Supported JVMs:
+  Windows: Latest available from http://java.sun.com/ (1.3+ supported)
+  Linux:   Latest available from http://java.sun.com/ (1.3+ supported)
+  FreeBSD: /usr/ports/java/linux-sun-jdk1.4
+  various: http://www.kaffe.org/ using CVS HEAD as of Sept 1, 2004
+           (or any subsequent releases) 

installer/install.xml

@@ -4,7 +4,7 @@
 
     <info>
         <appname>i2p</appname>
-        <appversion>0.4.2.3</appversion>
+        <appversion>0.4.2.5</appversion>
         <authors>
             <author name="I2P" email="support@i2p.net"/>
         </authors>

installer/resources/i2prouter.bat

@@ -1,39 +1,14 @@
 @echo off
 setlocal
+set INSTALL_PATH="%1"
 
 rem
 rem Java Service Wrapper general startup script
 rem
 
-rem
-rem Resolve the real path of the Wrapper.exe
-rem  For non NT systems, the _REALPATH and _WRAPPER_CONF values
-rem  can be hard-coded below and the following test removed.
-rem
-if "%OS%"=="Windows_NT" goto nt
-echo This script only works with NT-based versions of Windows.
-goto :eof
+set _WRAPPER_EXE=%INSTALL_PATH%I2Psvc.exe
+set _WRAPPER_CONF="%INSTALL_PATH%wrapper.config"
 
-:nt
-rem
-rem Find the application home.
-rem
-rem %~dp0 is location of current script under NT
-set _REALPATH=%~dp0
-set _WRAPPER_EXE=%_REALPATH%I2Psvc.exe
-
-rem
-rem Find the wrapper.conf
-rem
-:conf
-set _WRAPPER_CONF="%~f1"
-if not %_WRAPPER_CONF%=="" goto startup
-set _WRAPPER_CONF="%_REALPATH%wrapper.config"
-
-rem
-rem Start the Wrapper
-rem
-:startup
 "%_WRAPPER_EXE%" -c %_WRAPPER_CONF%
 if not errorlevel 1 goto :eof
 pause

installer/resources/i2ptunnel.config

@@ -5,7 +5,7 @@ tunnel.0.type=httpclient
 tunnel.0.interface=127.0.0.1
 tunnel.0.listenPort=4444
 tunnel.0.proxyList=squid.i2p,www1.squid.i2p
-tunnel.0.i2cpHost=localhost
+tunnel.0.i2cpHost=127.0.0.1
 tunnel.0.i2cpPort=7654
 tunnel.0.option.tunnels.depthInbound=2
 tunnel.0.option.tunnels.numInbound=2
@@ -19,7 +19,7 @@ tunnel.1.type=client
 tunnel.1.interface=127.0.0.1
 tunnel.1.listenPort=6668
 tunnel.1.targetDestination=irc.duck.i2p,irc.baffled.i2p
-tunnel.1.i2cpHost=localhost
+tunnel.1.i2cpHost=127.0.0.1
 tunnel.1.i2cpPort=7654
 tunnel.1.option.tunnels.depthInbound=2
 tunnel.1.option.tunnels.numInbound=2
@@ -33,7 +33,7 @@ tunnel.2.type=client
 tunnel.2.interface=127.0.0.1
 tunnel.2.listenPort=2401
 tunnel.2.targetDestination=cvs.i2p
-tunnel.2.i2cpHost=localhost
+tunnel.2.i2cpHost=127.0.0.1
 tunnel.2.i2cpPort=7654
 tunnel.2.option.tunnels.depthInbound=2
 tunnel.2.option.tunnels.numInbound=2
@@ -42,11 +42,12 @@ tunnel.2.startOnLoad=false
 # local eepserver
 tunnel.3.name=eepsite
 tunnel.3.description=My eepsite
-tunnel.3.type=server
-tunnel.3.targetHost=localhost
+tunnel.3.type=httpserver
+tunnel.3.targetHost=127.0.0.1
 tunnel.3.targetPort=7658
+tunnel.3.spoofedHost=mysite.i2p
 tunnel.3.privKeyFile=eepsite/eepPriv.dat
-tunnel.3.i2cpHost=localhost
+tunnel.3.i2cpHost=127.0.0.1
 tunnel.3.i2cpPort=7654
 tunnel.3.option.tunnels.depthInbound=2
 tunnel.3.option.tunnels.numInbound=2
@@ -54,7 +55,7 @@ tunnel.3.startOnLoad=true
 
 # postman's SMTP server - see www.postman.i2p
 tunnel.4.description=smtp server
-tunnel.4.i2cpHost=localhost
+tunnel.4.i2cpHost=127.0.0.1
 tunnel.4.i2cpPort=7654
 tunnel.4.interface=127.0.0.1
 tunnel.4.listenPort=7659
@@ -69,7 +70,7 @@ tunnel.4.type=client
 # postman's POP3 server - see www.postman.i2p
 tunnel.5.name=pop3.postman.i2p
 tunnel.5.description=pop3 server
-tunnel.5.i2cpHost=localhost
+tunnel.5.i2cpHost=127.0.0.1
 tunnel.5.i2cpPort=7654
 tunnel.5.interface=127.0.0.1
 tunnel.5.listenPort=7660
@@ -78,4 +79,4 @@ tunnel.5.option.tunnels.numInbound=2
 tunnel.5.option.i2p.streaming.connectDelay=1000
 tunnel.5.startOnLoad=false
 tunnel.5.targetDestination=pop.postman.i2p
-tunnel.5.type=client
+tunnel.5.type=client

installer/resources/postinstall.bat

@@ -33,7 +33,7 @@ del /f /q "%INSTALL_PATH%postinstall.sh"
 :: del /f /q "%INSTALL_PATH%uninstall_i2p_service_unix"
 del /f /q "%INSTALL_PATH%icons\*.xpm"
 rmdir /q /s "%INSTALL_PATH%lib\wrapper"
-start /b /i /d"%INSTALL_PATH%" i2prouter.bat
+start /b /i /d"%INSTALL_PATH%" i2prouter.bat %INSTALL_PATH%
 
 ) else (
 
@@ -47,6 +47,6 @@ del "%INSTALL_PATH%postinstall.sh"
 del "%INSTALL_PATH%uninstall_i2p_service_winnt.bat"
 del "%INSTALL_PATH%icons\*.xpm"
 deltree /Y "%INSTALL_PATH%lib\wrapper"
-start /M "%INSTALL_PATH%i2prouter.bat"
+start /M "%INSTALL_PATH%i2prouter.bat" %INSTALL_PATH%
 
 )

router/java/src/net/i2p/router/ClientMessagePool.java

@@ -8,8 +8,12 @@ package net.i2p.router;
  *
  */
 
-//import net.i2p.router.message.ProcessOutboundClientMessageJob;
+import java.util.Properties;
+
+import net.i2p.client.I2PClient;
+
 import net.i2p.router.message.OutboundClientMessageJob;
+import net.i2p.router.message.OutboundClientMessageOneShotJob;
 import net.i2p.util.Log;
 
 /**
@@ -55,7 +59,22 @@ public class ClientMessagePool {
         } else {
             if (_log.shouldLog(Log.DEBUG))
                 _log.debug("Adding message for remote delivery");
-            _context.jobQueue().addJob(new OutboundClientMessageJob(_context, msg));
+            if (isGuaranteed(msg))
+                _context.jobQueue().addJob(new OutboundClientMessageJob(_context, msg));
+            else
+                _context.jobQueue().addJob(new OutboundClientMessageOneShotJob(_context, msg));
+        }
+    }
+    
+    private boolean isGuaranteed(ClientMessage msg) {
+        Properties opts = null;
+        if (msg.getSenderConfig() != null)
+            opts = msg.getSenderConfig().getOptions();
+        if (opts != null) {
+            String val = opts.getProperty(I2PClient.PROP_RELIABILITY, I2PClient.PROP_RELIABILITY_BEST_EFFORT);
+            return val.equals(I2PClient.PROP_RELIABILITY_GUARANTEED);
+        } else {
+            return false;
         }
     }
 }

router/java/src/net/i2p/router/Router.java

@@ -75,9 +75,13 @@ public class Router {
     public final static String PROP_SHUTDOWN_IN_PROGRESS = "__shutdownInProgress";
         
     static {
-        // grumble about sun's java caching DNS entries *forever*
-        System.setProperty("sun.net.inetaddr.ttl", "0");
-        System.setProperty("networkaddress.cache.ttl", "0");
+        // grumble about sun's java caching DNS entries *forever* by default
+        // so lets just keep 'em for a minute
+        System.setProperty("sun.net.inetaddr.ttl", "60");
+        System.setProperty("networkaddress.cache.ttl", "60");
+        // until we handle restricted routes and/or all peers support v6, try v4 first
+        System.setProperty("java.net.preferIPv4Stack", "true");
+        System.setProperty("http.agent", "I2P");
         // (no need for keepalive)
         System.setProperty("http.keepAlive", "false");
         System.setProperty("user.timezone", "GMT");
@@ -272,6 +276,9 @@ public class Router {
             super(Router.this._context); 
             Router.this._context.statManager().createRateStat("bw.receiveBps", "How fast we receive data", "Bandwidth", new long[] { 60*1000, 5*60*1000, 60*60*1000 });
             Router.this._context.statManager().createRateStat("bw.sendBps", "How fast we send data", "Bandwidth", new long[] { 60*1000, 5*60*1000, 60*60*1000 });
+            Router.this._context.statManager().createRateStat("router.activePeers", "How many peers we are actively talking with", "Throttle", new long[] { 5*60*1000, 60*60*1000 });
+            Router.this._context.statManager().createRateStat("router.highCapacityPeers", "How many high capacity peers we know", "Throttle", new long[] { 5*60*1000, 60*60*1000 });
+            Router.this._context.statManager().createRateStat("router.fastPeers", "How many fast peers we know", "Throttle", new long[] { 5*60*1000, 60*60*1000 });
         }
         public String getName() { return "Coalesce stats"; }
         public void runJob() {
@@ -296,6 +303,15 @@ public class Router {
                     Router.this._context.statManager().addRateData("bw.sendBps", (long)bps, 60*1000);
                 }
             }
+            
+            int active = Router.this._context.commSystem().countActivePeers();
+            Router.this._context.statManager().addRateData("router.activePeers", active, 60*1000);
+            
+            int fast = Router.this._context.profileOrganizer().countFastPeers();
+            Router.this._context.statManager().addRateData("router.fastPeers", fast, 60*1000);
+            
+            int highCap = Router.this._context.profileOrganizer().countHighCapacityPeers();
+            Router.this._context.statManager().addRateData("router.highCapacityPeers", highCap, 60*1000);
 
             requeue(60*1000);
         }

router/java/src/net/i2p/router/RouterThrottleImpl.java

@@ -30,6 +30,8 @@ class RouterThrottleImpl implements RouterThrottle {
     private static int THROTTLE_EVENT_LIMIT = 300;
     
     private static final String PROP_MAX_TUNNELS = "router.maxParticipatingTunnels";
+    private static final String PROP_DEFAULT_KBPS_THROTTLE = "router.defaultKBpsThrottle";
+    private static final String PROP_BANDWIDTH_SHARE_PERCENTAGE = "router.sharePercentage";
     
     public RouterThrottleImpl(RouterContext context) {
         _context = context;
@@ -43,6 +45,7 @@ class RouterThrottleImpl implements RouterThrottle {
         _context.statManager().createRateStat("router.throttleTunnelMaxExceeded", "How many tunnels we are participating in when we refuse one due to excees?", "Throttle", new long[] { 10*60*1000, 60*60*1000, 24*60*60*1000 });
         _context.statManager().createRateStat("router.throttleTunnelProbTooFast", "How many tunnels beyond the previous 1h average are we participating in when we throttle?", "Throttle", new long[] { 10*60*1000, 60*60*1000, 24*60*60*1000 });
         _context.statManager().createRateStat("router.throttleTunnelProbTestSlow", "How slow are our tunnel tests when our average exceeds the old average and we throttle?", "Throttle", new long[] { 10*60*1000, 60*60*1000, 24*60*60*1000 });
+        _context.statManager().createRateStat("router.throttleTunnelBandwidthExceeded", "How much bandwidth is allocated when we refuse due to bandwidth allocation?", "Throttle", new long[] { 10*60*1000, 60*60*1000, 24*60*60*1000 });
     }
     
     public boolean acceptNetworkMessage() {
@@ -107,22 +110,7 @@ class RouterThrottleImpl implements RouterThrottle {
             return false;
         }
         
-        // ok, we're not hosed, but can we handle the bandwidth requirements 
-        // of another tunnel?
-        rs = _context.statManager().getRate("tunnel.participatingMessagesProcessed");
-        r = null;
-        if (rs != null)
-            r = rs.getRate(10*60*1000);
-        double msgsPerTunnel = (r != null ? r.getAverageValue() : 0);
-        r = null;
-        rs = _context.statManager().getRate("tunnel.relayMessageSize");
-        if (rs != null)
-            r = rs.getRate(10*60*1000);
-        double bytesPerMsg = (r != null ? r.getAverageValue() : 0);
-        double bytesPerTunnel = msgsPerTunnel * bytesPerMsg;
-
         int numTunnels = _context.tunnelManager().getParticipatingCount();
-        double bytesAllocated =  (numTunnels + 1) * bytesPerTunnel;
 
         if (_context.getProperty(Router.PROP_SHUTDOWN_IN_PROGRESS) != null) {
             if (_log.shouldLog(Log.WARN))
@@ -206,10 +194,21 @@ class RouterThrottleImpl implements RouterThrottle {
                 // no default, ignore it
             }
         }
+
+        // ok, we're not hosed, but can we handle the bandwidth requirements 
+        // of another tunnel?
+        rs = _context.statManager().getRate("tunnel.participatingBytesProcessed");
+        r = null;
+        if (rs != null)
+            r = rs.getRate(10*60*1000);
+        double bytesAllocated = r.getCurrentTotalValue();
         
+        if (!allowTunnel(bytesAllocated, numTunnels)) {
+            _context.statManager().addRateData("router.throttleTunnelBandwidthExceeded", (long)bytesAllocated, 0);
+            return false;
+        }
         _context.statManager().addRateData("tunnel.bytesAllocatedAtAccept", (long)bytesAllocated, msg.getTunnelDurationSeconds()*1000);
-        // todo: um, throttle (include bw usage of the netDb, our own tunnels, the clients,
-        // and check to see that they are less than the bandwidth limits
+        
 
         if (_log.shouldLog(Log.DEBUG))
             _log.debug("Accepting a new tunnel request (now allocating " + bytesAllocated + " bytes across " + numTunnels 
@@ -217,6 +216,99 @@ class RouterThrottleImpl implements RouterThrottle {
         return true;
     }
     
+    /**
+     * with bytesAllocated already accounted for across the numTunnels existing
+     * tunnels we have agreed to, can we handle another tunnel with our existing
+     * bandwidth?
+     *
+     */
+    private boolean allowTunnel(double bytesAllocated, int numTunnels) {
+        long bytesAllowed = getBytesAllowed();
+        
+        bytesAllowed *= getSharePercentage();
+        
+        double bytesPerTunnel = (numTunnels > 0 ? bytesAllocated / numTunnels : 0);
+        double toAllocate = (numTunnels > 0 ? bytesPerTunnel * (numTunnels + 1) : 0);
+        
+        double pctFull = toAllocate / bytesAllowed;
+        
+        double allocatedKBps = toAllocate / (10 * 60 * 1024);
+        
+        if (pctFull < 1.0) { // (_context.random().nextInt(100) > 100 * pctFull) {
+            if (_log.shouldLog(Log.DEBUG))
+                _log.debug("Probabalistically allowing the tunnel w/ " + pctFull + " of our " + bytesAllowed
+                           + "bytes/" + allocatedKBps + "KBps allocated through " + numTunnels + " tunnels");
+            return true;
+        } else {
+            if (_log.shouldLog(Log.DEBUG))
+                _log.debug("Rejecting the tunnel w/ " + pctFull + " of our " + bytesAllowed 
+                           + "bytes allowed (" + toAllocate + "bytes / " + allocatedKBps 
+                           + "KBps) through " + numTunnels + " tunnels");
+            return false;
+        }
+    }
+    
+    /** 
+     * What fraction of the bandwidth specified in our bandwidth limits should
+     * we allow to be consumed by participating tunnels?
+     *
+     */
+    private double getSharePercentage() {
+        String pct = _context.getProperty(PROP_BANDWIDTH_SHARE_PERCENTAGE, "0.8");
+        if (pct != null) {
+            try {
+                return Double.parseDouble(pct);
+            } catch (NumberFormatException nfe) {
+                if (_log.shouldLog(Log.INFO))
+                    _log.info("Unable to get the share percentage");
+            }
+        }
+        return 0.8;
+    }
+        
+    /** 
+     * BytesPerSecond that we can pass along data
+     */
+    private long getBytesAllowed() {
+        String kbpsOutStr = _context.getProperty("i2np.bandwidth.outboundKBytesPerSecond");
+        long kbpsOut = -1;
+        if (kbpsOutStr != null) {
+            try {
+                kbpsOut = Integer.parseInt(kbpsOutStr);
+            } catch (NumberFormatException nfe) {
+                if (_log.shouldLog(Log.INFO))
+                    _log.info("Unable to get the bytes allowed (outbound)");
+            }
+        }
+        
+        String kbpsInStr = _context.getProperty("i2np.bandwidth.inboundKBytesPerSecond");
+        long kbpsIn = -1;
+        if (kbpsInStr != null) {
+            try {
+                kbpsIn = Integer.parseInt(kbpsInStr);
+            } catch (NumberFormatException nfe) {
+                if (_log.shouldLog(Log.INFO))
+                    _log.info("Unable to get the bytes allowed (inbound)");
+            }
+        }
+        
+        // whats our choke?
+        long kbps = (kbpsOut > kbpsIn ? kbpsIn : kbpsOut);
+        
+        if (kbps <= 0) {
+            try {
+                kbps = Integer.parseInt(_context.getProperty(PROP_DEFAULT_KBPS_THROTTLE, "64")); // absurd
+            } catch (NumberFormatException nfe) {
+                kbps = 64;
+            }
+        }
+        
+        return kbps
+               * 60 // per minute
+               * 10 // per 10 minute period
+               * 1024; // bytes;
+    }
+    
     /** dont ever probabalistically throttle tunnels if we have less than this many */
     private int getMinThrottleTunnels() { 
         try {

router/java/src/net/i2p/router/RouterVersion.java

@@ -15,8 +15,8 @@ import net.i2p.CoreVersion;
  *
  */
 public class RouterVersion {
-    public final static String ID = "$Revision: 1.106 $ $Date: 2004/12/08 12:16:17 $";
-    public final static String VERSION = "0.4.2.3";
+    public final static String ID = "$Revision: 1.122 $ $Date: 2004/12/21 11:32:50 $";
+    public final static String VERSION = "0.4.2.5";
     public final static long BUILD = 0;
     public static void main(String args[]) {
         System.out.println("I2P Router version: " + VERSION);

router/java/src/net/i2p/router/StatisticsManager.java

@@ -103,6 +103,7 @@ public class StatisticsManager implements Service {
 
             includeThroughput(stats);
             includeRate("transport.sendProcessingTime", stats, new long[] { 60*60*1000 });
+            includeRate("tcp.probabalisticDropQueueSize", stats, new long[] { 60*1000l, 60*60*1000l });
             //includeRate("tcp.queueSize", stats);
             //includeRate("jobQueue.jobLag", stats, new long[] { 60*1000, 60*60*1000 });
             //includeRate("jobQueue.jobRun", stats, new long[] { 60*1000, 60*60*1000 });
@@ -114,6 +115,8 @@ public class StatisticsManager implements Service {
             //includeRate("jobQueue.droppedJobs", stats, new long[] { 60*60*1000, 24*60*60*1000 });
             //includeRate("inNetPool.dropped", stats, new long[] { 60*60*1000, 24*60*60*1000 });
             includeRate("tunnel.participatingTunnels", stats, new long[] { 5*60*1000, 60*60*1000 });
+            includeRate("tunnel.participatingBytesProcessed", stats, new long[] { 10*60*1000 });
+            includeRate("tunnel.participatingBytesProcessedActive", stats, new long[] { 10*60*1000 });
             includeRate("tunnel.testSuccessTime", stats, new long[] { 60*60*1000l, 24*60*60*1000l });
             //includeRate("tunnel.outboundMessagesProcessed", stats, new long[] { 10*60*1000, 60*60*1000 });
             //includeRate("tunnel.inboundMessagesProcessed", stats, new long[] { 10*60*1000, 60*60*1000 });

router/java/src/net/i2p/router/TunnelInfo.java

@@ -56,6 +56,7 @@ public class TunnelInfo extends DataStructureImpl {
     private boolean _wasEverReady;
     private int _messagesProcessed;
     private int _tunnelFailures;
+    private long _bytesProcessed;
     
     public TunnelInfo(I2PAppContext context) {
         _context = context;
@@ -79,6 +80,7 @@ public class TunnelInfo extends DataStructureImpl {
         _lastTested = -1;
         _messagesProcessed = 0;
         _tunnelFailures = 0;
+        _bytesProcessed = 0;
     }
     
     public TunnelId getTunnelId() { return _id; }
@@ -182,7 +184,12 @@ public class TunnelInfo extends DataStructureImpl {
         return _messagesProcessed; 
     }
     /** we have just processed a message for this tunnel */
-    public void messageProcessed() { _messagesProcessed++; }
+    public void messageProcessed(int size) { 
+        _messagesProcessed++; 
+        _bytesProcessed += size;
+    }
+    /** how many bytes have been pumped through this tunnel in its lifetime? */
+    public long getBytesProcessed() { return _bytesProcessed; }
     
     /** 
      * the tunnel was (potentially) unable to pass a message through.

router/java/src/net/i2p/router/client/ClientWriterRunner.java

@@ -83,6 +83,9 @@ class ClientWriterRunner implements Runnable {
                 for (int i = 0; i < messages.size(); i++) {
                     I2CPMessage msg = (I2CPMessage)messages.get(i);
                     Long when = (Long)messageTimes.get(i);
+                    if (_log.shouldLog(Log.DEBUG))
+                        _log.debug("["+_id+"] writeMessage before writing " 
+                                   + msg.getClass().getName());
                     _runner.writeMessage(msg);
                     if (_log.shouldLog(Log.DEBUG))
                         _log.debug("["+_id+"] writeMessage time since addMessage(): " 

router/java/src/net/i2p/router/message/HandleTunnelMessageJob.java

@@ -240,7 +240,7 @@ public class HandleTunnelMessageJob extends JobImpl {
         if (info == null) 
             return;
         
-        info.messageProcessed();
+        info.messageProcessed(_message.getMessageSize());
         
         //if ( (_message.getVerificationStructure() == null) && (info.getSigningKey() != null) ) {
         if (_message.getVerificationStructure() == null) {

router/java/src/net/i2p/router/message/OutboundClientMessageOneShotJob.java

@@ -0,0 +1,490 @@
+package net.i2p.router.message;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Properties;
+import java.util.Set;
+import java.util.TreeMap;
+
+import net.i2p.data.Certificate;
+import net.i2p.data.Destination;
+import net.i2p.data.Hash;
+import net.i2p.data.Lease;
+import net.i2p.data.LeaseSet;
+import net.i2p.data.PublicKey;
+import net.i2p.data.SessionTag;
+import net.i2p.data.SessionKey;
+import net.i2p.data.TunnelId;
+
+import net.i2p.data.i2cp.MessageId;
+
+import net.i2p.data.i2np.DataMessage;
+import net.i2p.data.i2np.DeliveryStatusMessage;
+import net.i2p.data.i2np.I2NPMessage;
+import net.i2p.data.i2np.GarlicMessage;
+import net.i2p.data.i2np.DeliveryInstructions;
+
+import net.i2p.router.message.PayloadGarlicConfig;
+
+import net.i2p.router.ClientMessage;
+import net.i2p.router.JobImpl;
+import net.i2p.router.ReplyJob;
+import net.i2p.router.Router;
+import net.i2p.router.RouterContext;
+import net.i2p.router.TunnelSelectionCriteria;
+import net.i2p.router.MessageSelector;
+
+import net.i2p.util.Log;
+
+/**
+ * Send a client message out a random outbound tunnel and into a random inbound
+ * tunnel on the target leaseSet.  This also bundles the sender's leaseSet and
+ * a DeliveryStatusMessage (for ACKing any sessionTags used in the garlic).
+ *
+ */
+public class OutboundClientMessageOneShotJob extends JobImpl {
+    private Log _log;
+    private long _overallExpiration;
+    private boolean _shouldBundle;
+    private ClientMessage _clientMessage;
+    private MessageId _clientMessageId;
+    private int _clientMessageSize;
+    private Destination _from;
+    private Destination _to;
+    /** target destination's leaseSet, if known */
+    private LeaseSet _leaseSet;
+    /** Actual lease the message is being routed through */
+    private Lease _lease;
+    private PayloadGarlicConfig _clove;
+    private long _cloveId;
+    private long _start;
+    private boolean _finished;
+    
+    /**
+     * final timeout (in milliseconds) that the outbound message will fail in.
+     * This can be overridden in the router.config or the client's session config
+     * (the client's session config takes precedence)
+     */
+    public final static String OVERALL_TIMEOUT_MS_PARAM = "clientMessageTimeout";
+    private final static long OVERALL_TIMEOUT_MS_DEFAULT = 60*1000;
+    
+    /** priority of messages, that might get honored some day... */
+    private final static int SEND_PRIORITY = 500;
+    
+    /**
+     * If the client's config specifies shouldBundleReplyInfo=true, messages sent from
+     * that client to any peers will probabalistically include the sending destination's
+     * current LeaseSet (allowing the recipient to reply without having to do a full
+     * netDb lookup).  This should improve performance during the initial negotiations,
+     * but is not necessary for communication that isn't bidirectional.
+     *
+     */
+    public static final String BUNDLE_REPLY_LEASESET = "shouldBundleReplyInfo";
+    /**
+     * Allow the override of the frequency of bundling the reply info in with a message.
+     * The client app can specify bundleReplyInfoProbability=80 (for instance) and that
+     * will cause the router to include the sender's leaseSet with 80% of the messages
+     * sent to the peer.
+     *
+     */
+    public static final String BUNDLE_PROBABILITY = "bundleReplyInfoProbability";
+    /** 
+     * How often do messages include the reply leaseSet (out of every 100 tries).  
+     * Including it each time is probably overkill, but who knows.  
+     */
+    private static final int BUNDLE_PROBABILITY_DEFAULT = 100;
+    
+    /**
+     * Send the sucker
+     */
+    public OutboundClientMessageOneShotJob(RouterContext ctx, ClientMessage msg) {
+        super(ctx);
+        _log = ctx.logManager().getLog(OutboundClientMessageOneShotJob.class);
+        
+        ctx.statManager().createFrequencyStat("client.sendMessageFailFrequency", "How often does a client fail to send a message?", "ClientMessages", new long[] { 60*1000l, 60*60*1000l, 24*60*60*1000l });
+        ctx.statManager().createRateStat("client.sendMessageSize", "How large are messages sent by the client?", "ClientMessages", new long[] { 60*1000l, 60*60*1000l, 24*60*60*1000l });
+        ctx.statManager().createRateStat("client.sendAckTime", "How long does it take to get an ACK back from a message?", "ClientMessages", new long[] { 5*60*1000l, 60*60*1000l, 24*60*60*1000l });
+        ctx.statManager().createRateStat("client.timeoutCongestionTunnel", "How lagged our tunnels are when a send times out?", "ClientMessages", new long[] { 5*60*1000l, 60*60*1000l, 24*60*60*1000l });
+        ctx.statManager().createRateStat("client.timeoutCongestionMessage", "How fast we process messages locally when a send times out?", "ClientMessages", new long[] { 5*60*1000l, 60*60*1000l, 24*60*60*1000l });
+        ctx.statManager().createRateStat("client.timeoutCongestionInbound", "How much faster we are receiving data than our average bps when a send times out?", "ClientMessages", new long[] { 5*60*1000l, 60*60*1000l, 24*60*60*1000l });
+
+        long timeoutMs = OVERALL_TIMEOUT_MS_DEFAULT;
+        _clientMessage = msg;
+        _clientMessageId = msg.getMessageId();
+        _clientMessageSize = msg.getPayload().getSize();
+        _from = msg.getFromDestination();
+        _to = msg.getDestination();
+        
+        String param = msg.getSenderConfig().getOptions().getProperty(OVERALL_TIMEOUT_MS_PARAM);
+        if (param == null)
+            param = ctx.router().getConfigSetting(OVERALL_TIMEOUT_MS_PARAM);
+        if (param != null) {
+            try {
+                timeoutMs = Long.parseLong(param);
+            } catch (NumberFormatException nfe) {
+                if (_log.shouldLog(Log.WARN))
+                    _log.warn("Invalid client message timeout specified [" + param 
+                              + "], defaulting to " + OVERALL_TIMEOUT_MS_DEFAULT, nfe);
+                timeoutMs = OVERALL_TIMEOUT_MS_DEFAULT;
+            }
+        }
+        
+        _start = getContext().clock().now();
+        _overallExpiration = timeoutMs + _start;
+        _shouldBundle = getShouldBundle();
+        _finished = false;
+    }
+    
+    public String getName() { return "Outbound client message"; }
+    
+    public void runJob() {
+        if (_log.shouldLog(Log.DEBUG))
+            _log.debug(getJobId() + ": Send outbound client message job beginning");
+        buildClove();
+        if (_log.shouldLog(Log.DEBUG))
+            _log.debug(getJobId() + ": Clove built");
+        long timeoutMs = _overallExpiration - getContext().clock().now();
+        if (_log.shouldLog(Log.DEBUG))
+            _log.debug(getJobId() + ": Send outbound client message - sending off leaseSet lookup job");
+        getContext().netDb().lookupLeaseSet(_to.calculateHash(), new SendJob(), new LookupLeaseSetFailedJob(), timeoutMs);
+    }
+    
+    private boolean getShouldBundle() {
+        Properties opts = _clientMessage.getSenderConfig().getOptions();
+        String wantBundle = opts.getProperty(BUNDLE_REPLY_LEASESET, "true");
+        if ("true".equals(wantBundle)) {
+            int probability = BUNDLE_PROBABILITY_DEFAULT;
+            String str = opts.getProperty(BUNDLE_PROBABILITY);
+            try { 
+                if (str != null) 
+                    probability = Integer.parseInt(str);
+            } catch (NumberFormatException nfe) {
+                if (_log.shouldLog(Log.WARN))
+                    _log.warn(getJobId() + ": Bundle leaseSet probability overridden incorrectly [" 
+                              + str + "]", nfe);
+            }
+            if (probability >= getContext().random().nextInt(100))
+                return true;
+            else
+                return false;
+        } else {
+            return false;
+        }
+    }
+    
+    /** send a message to a random lease */
+    private class SendJob extends JobImpl {
+        public SendJob() { 
+            super(OutboundClientMessageOneShotJob.this.getContext());
+        }
+        public String getName() { return "Send outbound client message through the lease"; }
+        public void runJob() {
+            boolean ok = getNextLease();
+            if (ok)
+                send();
+            else
+                dieFatal();
+        }
+    }
+    
+    /**
+     * fetch the next lease that we should try sending through, randomly chosen
+     * from within the sorted leaseSet (sorted by # of failures through each 
+     * lease).
+     *
+     */
+    private boolean getNextLease() {
+        _leaseSet = getContext().netDb().lookupLeaseSetLocally(_to.calculateHash());
+        if (_leaseSet == null) {
+            if (_log.shouldLog(Log.WARN))
+                _log.warn(getJobId() + ": Lookup locally didn't find the leaseSet");
+            return false;
+        } 
+        long now = getContext().clock().now();
+        
+        // get the possible leases
+        List leases = new ArrayList(_leaseSet.getLeaseCount());
+        for (int i = 0; i < _leaseSet.getLeaseCount(); i++) {
+            Lease lease = _leaseSet.getLease(i);
+            if (lease.isExpired(Router.CLOCK_FUDGE_FACTOR)) {
+                if (_log.shouldLog(Log.WARN))
+                    _log.warn(getJobId() + ": getNextLease() - expired lease! - " + lease);
+                continue;
+            } else {
+                leases.add(lease);
+            }
+        }
+        
+        if (leases.size() <= 0) {
+            if (_log.shouldLog(Log.INFO))
+                _log.info(getJobId() + ": No leases found from: " + _leaseSet);
+            return false;
+        }
+        
+        // randomize the ordering (so leases with equal # of failures per next 
+        // sort are randomly ordered)
+        Collections.shuffle(leases);
+        
+        // ordered by lease number of failures
+        TreeMap orderedLeases = new TreeMap();
+        for (Iterator iter = leases.iterator(); iter.hasNext(); ) {
+            Lease lease = (Lease)iter.next();
+            long id = lease.getNumFailure();
+            while (orderedLeases.containsKey(new Long(id)))
+                id++;
+            orderedLeases.put(new Long(id), lease);
+            if (_log.shouldLog(Log.DEBUG))
+                _log.debug(getJobId() + ": ranking lease we havent sent it down as " + id);
+        }
+        
+        _lease = (Lease)orderedLeases.get(orderedLeases.firstKey());
+        return true;
+    }
+
+    
+    /** 
+     * we couldn't even find the leaseSet, but try again (or die 
+     * if we've already tried too hard)
+     *
+     */
+    private class LookupLeaseSetFailedJob extends JobImpl {
+        public LookupLeaseSetFailedJob()  {
+            super(OutboundClientMessageOneShotJob.this.getContext());
+        }
+        public String getName() { return "Lookup for outbound client message failed"; }
+        public void runJob() { 
+            dieFatal();
+        }
+    }
+    
+    /**
+     * Send the message to the specified tunnel by creating a new garlic message containing
+     * the (already created) payload clove as well as a new delivery status message.  This garlic
+     * message is sent out one of our tunnels, destined for the lease (tunnel+router) specified, and the delivery
+     * status message is targetting one of our free inbound tunnels as well.  We use a new
+     * reply selector to keep an eye out for that delivery status message's token
+     *
+     */
+    private void send() {
+        if (_finished) return;
+        long token = getContext().random().nextLong(I2NPMessage.MAX_ID_VALUE);
+        PublicKey key = _leaseSet.getEncryptionKey();
+        SessionKey sessKey = new SessionKey();
+        Set tags = new HashSet();
+        LeaseSet replyLeaseSet = null;
+        if (_shouldBundle) {
+            replyLeaseSet = getContext().netDb().lookupLeaseSetLocally(_from.calculateHash());
+        }
+        
+        GarlicMessage msg = OutboundClientMessageJobHelper.createGarlicMessage(getContext(), token, 
+                                                                               _overallExpiration, key, 
+                                                                               _clove, 
+                                                                               _to, 
+                                                                               sessKey, tags, 
+                                                                               true, replyLeaseSet);
+        
+        if (_log.shouldLog(Log.DEBUG))
+            _log.debug(getJobId() + ": send() - token expected " + token);
+        
+        SendSuccessJob onReply = new SendSuccessJob(sessKey, tags);
+        SendTimeoutJob onFail = new SendTimeoutJob();
+        ReplySelector selector = new ReplySelector(token);
+        
+        if (_log.shouldLog(Log.DEBUG))
+            _log.debug(getJobId() + ": Placing GarlicMessage into the new tunnel message bound for " 
+                       + _lease.getTunnelId() + " on " 
+                       + _lease.getRouterIdentity().getHash().toBase64());
+        
+        TunnelId outTunnelId = selectOutboundTunnel();
+        if (outTunnelId != null) {
+            if (_log.shouldLog(Log.DEBUG))
+                _log.debug(getJobId() + ": Sending tunnel message out " + outTunnelId + " to " 
+                           + _lease.getTunnelId() + " on " 
+                           + _lease.getRouterIdentity().getHash().toBase64());
+            SendTunnelMessageJob j = new SendTunnelMessageJob(getContext(), msg, outTunnelId, 
+                                                              _lease.getRouterIdentity().getHash(), 
+                                                              _lease.getTunnelId(), null, onReply, 
+                                                              onFail, selector, 
+                                                              _overallExpiration-getContext().clock().now(), 
+                                                              SEND_PRIORITY);
+            getContext().jobQueue().addJob(j);
+        } else {
+            if (_log.shouldLog(Log.ERROR))
+                _log.error(getJobId() + ": Could not find any outbound tunnels to send the payload through... wtf?");
+            dieFatal();
+        }
+        _clientMessage = null;
+        _clove = null;
+    }
+    
+    /**
+     * Pick an arbitrary outbound tunnel to send the message through, or null if
+     * there aren't any around
+     *
+     */
+    private TunnelId selectOutboundTunnel() {
+        TunnelSelectionCriteria crit = new TunnelSelectionCriteria();
+        crit.setMaximumTunnelsRequired(1);
+        crit.setMinimumTunnelsRequired(1);
+        List tunnelIds = getContext().tunnelManager().selectOutboundTunnelIds(crit);
+        if (tunnelIds.size() <= 0)
+            return null;
+        else
+            return (TunnelId)tunnelIds.get(0);
+    }
+    
+    /**
+     * give up the ghost, this message just aint going through.  tell the client to fuck off.
+     *
+     * this is safe to call multiple times (only tells the client once)
+     */
+    private void dieFatal() {
+        if (_finished) return;
+        _finished = true;
+        
+        long sendTime = getContext().clock().now() - _start;
+        if (_log.shouldLog(Log.WARN))
+            _log.warn(getJobId() + ": Failed to send the message " + _clientMessageId + " after " 
+                       + sendTime + "ms", new Exception("Message send failure"));
+        
+        long messageDelay = getContext().throttle().getMessageDelay();
+        long tunnelLag = getContext().throttle().getTunnelLag();
+        long inboundDelta = (long)getContext().throttle().getInboundRateDelta();
+            
+        getContext().statManager().addRateData("client.timeoutCongestionTunnel", tunnelLag, 1);
+        getContext().statManager().addRateData("client.timeoutCongestionMessage", messageDelay, 1);
+        getContext().statManager().addRateData("client.timeoutCongestionInbound", inboundDelta, 1);
+    
+        getContext().messageHistory().sendPayloadMessage(_clientMessageId.getMessageId(), false, sendTime);
+        getContext().clientManager().messageDeliveryStatusUpdate(_from, _clientMessageId, false);
+        getContext().statManager().updateFrequency("client.sendMessageFailFrequency");
+        _clientMessage = null;
+        _clove = null;
+    }
+    
+    /** build the payload clove that will be used for all of the messages, placing the clove in the status structure */
+    private void buildClove() {
+        PayloadGarlicConfig clove = new PayloadGarlicConfig();
+        
+        DeliveryInstructions instructions = new DeliveryInstructions();
+        instructions.setDeliveryMode(DeliveryInstructions.DELIVERY_MODE_DESTINATION);
+        instructions.setDestination(_to.calculateHash());
+        
+        instructions.setDelayRequested(false);
+        instructions.setDelaySeconds(0);
+        instructions.setEncrypted(false);
+        
+        clove.setCertificate(new Certificate(Certificate.CERTIFICATE_TYPE_NULL, null));
+        clove.setDeliveryInstructions(instructions);
+        clove.setExpiration(_overallExpiration);
+        clove.setId(getContext().random().nextLong(I2NPMessage.MAX_ID_VALUE));
+        
+        DataMessage msg = new DataMessage(getContext());
+        msg.setData(_clientMessage.getPayload().getEncryptedData());
+        
+        clove.setPayload(msg);
+        clove.setRecipientPublicKey(null);
+        clove.setRequestAck(false);
+        
+        _clove = clove;
+        _cloveId = _clove.getId();
+        
+        if (_log.shouldLog(Log.DEBUG))
+            _log.debug(getJobId() + ": Built payload clove with id " + clove.getId());
+    }
+    
+    /**
+     * Keep an eye out for any of the delivery status message tokens that have been
+     * sent down the various tunnels to deliver this message
+     *
+     */
+    private class ReplySelector implements MessageSelector {
+        private long _pendingToken;
+        public ReplySelector(long token) {
+            _pendingToken = token;
+        }
+        
+        public boolean continueMatching() { return false; }
+        public long getExpiration() { return _overallExpiration; }
+        
+        public boolean isMatch(I2NPMessage inMsg) {
+            if (inMsg.getType() == DeliveryStatusMessage.MESSAGE_TYPE) {
+                return _pendingToken == ((DeliveryStatusMessage)inMsg).getMessageId();
+            } else {
+                return false;
+            }
+        }
+    }
+    
+    /**
+     * Called after we get a confirmation that the message was delivered safely
+     * (hoo-ray!)
+     *
+     */
+    private class SendSuccessJob extends JobImpl implements ReplyJob {
+        private SessionKey _key;
+        private Set _tags;
+        
+        /**
+         * Create a new success job that will be fired when the message encrypted with
+         * the given session key and bearing the specified tags are confirmed delivered.
+         *
+         */
+        public SendSuccessJob(SessionKey key, Set tags) {
+            super(OutboundClientMessageOneShotJob.this.getContext());
+            _key = key;
+            _tags = tags;
+        }
+        
+        public String getName() { return "Send client message successful to a lease"; }
+        public void runJob() {
+            if (_finished) return;
+            _finished = true;
+            long sendTime = getContext().clock().now() - _start;
+            if (_log.shouldLog(Log.INFO))
+                _log.info(OutboundClientMessageOneShotJob.this.getJobId() 
+                           + ": SUCCESS!  msg " + _clientMessageId
+                           + " sent after " + sendTime + "ms");
+            
+            if ( (_key != null) && (_tags != null) && (_tags.size() > 0) ) {
+                if (_leaseSet != null)
+                    getContext().sessionKeyManager().tagsDelivered(_leaseSet.getEncryptionKey(),
+                                                                   _key, _tags);
+            }
+            
+            long dataMsgId = _cloveId;
+            getContext().messageHistory().sendPayloadMessage(dataMsgId, true, sendTime);
+            getContext().clientManager().messageDeliveryStatusUpdate(_from, _clientMessageId, true);
+            _lease.setNumSuccess(_lease.getNumSuccess()+1);
+            
+            getContext().statManager().addRateData("client.sendAckTime", sendTime, 0);
+            getContext().statManager().addRateData("client.sendMessageSize", _clientMessageSize, sendTime);
+        }
+        
+        public void setMessage(I2NPMessage msg) {}
+    }
+    
+    /**
+     * Fired after the basic timeout for sending through the given tunnel has been reached.
+     * We'll accept successes later, but won't expect them
+     *
+     */
+    private class SendTimeoutJob extends JobImpl {
+        public SendTimeoutJob() {
+            super(OutboundClientMessageOneShotJob.this.getContext());
+        }
+        
+        public String getName() { return "Send client message timed out through a lease"; }
+        public void runJob() {
+            if (_log.shouldLog(Log.DEBUG))
+                _log.debug(OutboundClientMessageOneShotJob.this.getJobId()
+                           + ": Soft timeout through the lease " + _lease);
+            
+            _lease.setNumFailure(_lease.getNumFailure()+1);
+            dieFatal();
+        }
+    }
+}

router/java/src/net/i2p/router/message/SendTunnelMessageJob.java

@@ -121,7 +121,7 @@ public class SendTunnelMessageJob extends JobImpl {
             }
         }
         
-        info.messageProcessed();
+        info.messageProcessed(_message.getMessageSize());
         
         if (isEndpoint(info)) {
             if (_log.shouldLog(Log.INFO))

router/java/src/net/i2p/router/networkdb/kademlia/PersistentDataStore.java

@@ -147,8 +147,10 @@ class PersistentDataStore extends TransientDataStore {
     }
     
     private class ReadJob extends JobImpl {
+        private boolean _alreadyWarned;
         public ReadJob() {
             super(PersistentDataStore.this._context);
+            _alreadyWarned = false;
         }
         public String getName() { return "DB Read Job"; }
         public void runJob() {
@@ -158,6 +160,7 @@ class PersistentDataStore extends TransientDataStore {
         }
         
         private void readFiles() {
+            int routerCount = 0;
             try {
                 File dbDir = getDbDir();
                 File leaseSetFiles[] = dbDir.listFiles(LeaseSetFilter.getInstance());
@@ -170,6 +173,9 @@ class PersistentDataStore extends TransientDataStore {
                 }
                 File routerInfoFiles[] = dbDir.listFiles(RouterInfoFilter.getInstance());
                 if (routerInfoFiles != null) {
+                    routerCount += routerInfoFiles.length;
+                    if (routerInfoFiles.length > 5)
+                        _alreadyWarned = false;
                     for (int i = 0; i < routerInfoFiles.length; i++) {
                         Hash key = getRouterInfoHash(routerInfoFiles[i].getName());
                         if ( (key != null) && (!isKnown(key)) )
@@ -179,6 +185,11 @@ class PersistentDataStore extends TransientDataStore {
             } catch (IOException ioe) {
                 _log.error("Error reading files in the db dir", ioe);
             }
+            
+            if ( (routerCount <= 5) && (!_alreadyWarned) ) {
+                _log.error("Very few routerInfo files remaining - please reseed");
+                _alreadyWarned = true;
+            }
         }
     }
     

router/java/src/net/i2p/router/peermanager/CapacityCalculator.java

@@ -45,18 +45,25 @@ public class CapacityCalculator extends Calculator {
     private static long ESTIMATE_PERIOD = 60*60*1000;
     
     public double calc(PeerProfile profile) {
-        double capacity = 0;
-        
         RateStat acceptStat = profile.getTunnelCreateResponseTime();
         RateStat rejectStat = profile.getTunnelHistory().getRejectionRate();
         RateStat failedStat = profile.getTunnelHistory().getFailedRate();
         
-        capacity += estimatePartial(acceptStat, rejectStat, failedStat, 10*60*1000);
-        capacity += estimatePartial(acceptStat, rejectStat, failedStat, 30*60*1000);
-        capacity += estimatePartial(acceptStat, rejectStat, failedStat, 60*60*1000);
-        capacity += estimatePartial(acceptStat, rejectStat, failedStat, 24*60*60*1000);
+        double capacity10m = estimateCapacity(acceptStat, rejectStat, failedStat, 10*60*1000);
+        double capacity30m = estimateCapacity(acceptStat, rejectStat, failedStat, 30*60*1000);
+        double capacity60m = estimateCapacity(acceptStat, rejectStat, failedStat, 60*60*1000);
+        double capacity1d  = estimateCapacity(acceptStat, rejectStat, failedStat, 24*60*60*1000);
         
-        if (tooOld(profile))
+        double capacity = capacity10m * periodWeight(10*60*1000) + 
+                          capacity30m * periodWeight(30*60*1000) + 
+                          capacity60m * periodWeight(60*60*1000) + 
+                          capacity1d  * periodWeight(24*60*60*1000);
+        
+        // if we actively know they're bad, who cares if they used to be good?
+        if (capacity10m <= 0)
+            capacity = 0;
+        
+        if (tooOld(profile)) 
             capacity = 1;
         
         capacity += profile.getReliabilityBonus();
@@ -74,7 +81,7 @@ public class CapacityCalculator extends Calculator {
             return true;
     }
     
-    private double estimatePartial(RateStat acceptStat, RateStat rejectStat, RateStat failedStat, int period) {
+    private double estimateCapacity(RateStat acceptStat, RateStat rejectStat, RateStat failedStat, int period) {
         Rate curAccepted = acceptStat.getRate(period);
         Rate curRejected = rejectStat.getRate(period);
         Rate curFailed = failedStat.getRate(period);
@@ -82,27 +89,29 @@ public class CapacityCalculator extends Calculator {
         long eventCount = 0;
         if (curAccepted != null)
             eventCount = curAccepted.getCurrentEventCount() + curAccepted.getLastEventCount();
-        double stretch = ESTIMATE_PERIOD / period;
+        double stretch = ((double)ESTIMATE_PERIOD) / period;
         double val = eventCount * stretch;
         long failed = 0;
         if (curFailed != null)
             failed = curFailed.getCurrentEventCount() + curFailed.getLastEventCount();
         if (failed > 0) {
-            if ( (period == 10*60*1000) && (curFailed.getCurrentEventCount() > 0) )
-                return 0.0d; // their tunnels have failed in the last 0-10 minutes
-            else
-                val -= failed * stretch;
+            //if ( (period <= 10*60*1000) && (curFailed.getCurrentEventCount() > 0) )
+            //    return 0.0d; // their tunnels have failed in the last 0-10 minutes
+            //else
+            val -= failed * stretch;
         }
         
-        if ( (period == 10*60*1000) && (curRejected.getCurrentEventCount() + curRejected.getLastEventCount() > 0) )
-            return 0.0d;
-        else
+        //if ( (period <= 10*60*1000) && (curRejected.getCurrentEventCount() + curRejected.getLastEventCount() > 0) ) {
+        //    //System.out.println("10m period has rejected " + (curRejected.getCurrentEventCount() + curRejected.getLastEventCount()) + " times");
+        //    return 0.0d;
+        //} else
             val -= stretch * (curRejected.getCurrentEventCount() + curRejected.getLastEventCount());
         
+        val += GROWTH_FACTOR;
+        
         if (val >= 0) {
-            return (val + GROWTH_FACTOR) * periodWeight(period);
+            return val;
         } else {
-            // failed too much, don't grow
             return 0.0d;
         }
     }

router/java/src/net/i2p/router/peermanager/PeerProfile.java

@@ -248,7 +248,7 @@ public class PeerProfile {
         if (_dbResponseTime == null)
             _dbResponseTime = new RateStat("dbResponseTime", "how long it takes to get a db response from the peer (in milliseconds)", group, new long[] { 10*60*1000l, 60*60*1000l, 24*60*60*1000 } );
         if (_tunnelCreateResponseTime == null)
-            _tunnelCreateResponseTime = new RateStat("tunnelCreateResponseTime", "how long it takes to get a tunnel create response from the peer (in milliseconds)", group, new long[] { 10*60*1000l, 60*60*1000l, 24*60*60*1000 } );
+            _tunnelCreateResponseTime = new RateStat("tunnelCreateResponseTime", "how long it takes to get a tunnel create response from the peer (in milliseconds)", group, new long[] { 10*60*1000l, 30*60*1000l, 60*60*1000l, 24*60*60*1000 } );
         if (_tunnelTestResponseTime == null)
             _tunnelTestResponseTime = new RateStat("tunnelTestResponseTime", "how long it takes to successfully test a tunnel this peer participates in (in milliseconds)", group, new long[] { 10*60*1000l, 60*60*1000l, 24*60*60*1000 } );
         if (_commError == null)

router/java/src/net/i2p/router/peermanager/ProfileOrganizerRenderer.java

@@ -109,7 +109,8 @@ class ProfileOrganizerRenderer {
             buf.append("<td align=\"right\">").append(prof.getIsFailing()).append("</td>");
             //buf.append("<td><a href=\"/profile/").append(prof.getPeer().toBase64().substring(0, 32)).append("\">profile.txt</a> ");
             //buf.append("    <a href=\"#").append(prof.getPeer().toBase64().substring(0, 32)).append("\">netDb</a></td>");
-            buf.append("<td><a href=\"netdb.jsp#").append(peer.toBase64().substring(0,6)).append("\">netDb</a></td>\n");
+            buf.append("<td nowrap><a href=\"netdb.jsp#").append(peer.toBase64().substring(0,6)).append("\">netDb</a>");
+            buf.append("/<a href=\"dumpprofile.jsp?peer=").append(peer.toBase64().substring(0,6)).append("\">profile</a></td>\n");
             buf.append("</tr>");
         }
         buf.append("</table>");

router/java/src/net/i2p/router/peermanager/ProfilePersistenceHelper.java

@@ -70,9 +70,9 @@ class ProfilePersistenceHelper {
             groups = "not failing";
         } else {
             if (_context.profileOrganizer().isFast(profile.getPeer()))
-                groups = "fast and reliable";
+                groups = "fast and high capacity";
             else
-                groups = "reliable";
+                groups = "high capacity";
             
             if (_context.profileOrganizer().isWellIntegrated(profile.getPeer()))
                 groups = groups + ", well integrated";
@@ -85,6 +85,7 @@ class ProfilePersistenceHelper {
             buf.append("# as calculated by ").append(_us.toBase64()).append(NL);
         buf.append("#").append(NL);
         buf.append("# reliability: ").append(profile.getReliabilityValue()).append(NL);
+        buf.append("# capacity: ").append(profile.getCapacityValue()).append(NL);
         buf.append("# integration: ").append(profile.getIntegrationValue()).append(NL);
         buf.append("# speedValue: ").append(profile.getSpeedValue()).append(NL);
         buf.append("#").append(NL);

router/java/src/net/i2p/router/transport/CommSystemFacadeImpl.java

@@ -51,7 +51,7 @@ public class CommSystemFacadeImpl extends CommSystemFacade {
             _manager.restart();
     }
     
-    public int countActivePeers() { return _manager.countActivePeers(); }
+    public int countActivePeers() { return (_manager == null ? 0 : _manager.countActivePeers()); }
     
     public List getBids(OutNetMessage msg) {
         return _manager.getBids(msg);

router/java/src/net/i2p/router/transport/TransportImpl.java

@@ -364,5 +364,5 @@ public abstract class TransportImpl implements Transport {
     /** Make this stuff pretty (only used in the old console) */
     public String renderStatusHTML() { return null; }
     
-    protected RouterContext getContext() { return _context; }
+    public RouterContext getContext() { return _context; }
 }

router/java/src/net/i2p/router/transport/TransportManager.java

@@ -177,6 +177,8 @@ public class TransportManager implements TransportEventListener {
     }
     
     private List orderBids(HashSet bids, OutNetMessage msg) {
+        if (bids.size() <= 1)
+            return new ArrayList(bids);
         // db messages should go as fast as possible, while the others
         // should use as little bandwidth as possible.  
         I2NPMessage message = msg.getMessage();

router/java/src/net/i2p/router/transport/tcp/ConnectionBuilder.java

@@ -410,12 +410,13 @@ public class ConnectionBuilder {
             RouterInfo peer = new RouterInfo();
             peer.readBytes(_rawIn);
             int status = (int)_rawIn.read() & 0xFF;
-            boolean ok = validateStatus(status);
-            if (!ok) return false;
             
             Properties props = DataHelper.readProperties(_rawIn);
             // ignore these now
             
+            boolean ok = validateStatus(status, props);
+            if (!ok) return false;
+            
             Hash readHash = new Hash();
             readHash.readBytes(_rawIn);
             
@@ -564,12 +565,13 @@ public class ConnectionBuilder {
             RouterInfo peer = new RouterInfo();
             peer.readBytes(_rawIn);
             int status = (int)_rawIn.read() & 0xFF;
-            boolean ok = validateStatus(status);
-            if (!ok) return false;
             
             Properties props = DataHelper.readProperties(_rawIn);
             // ignore these now
             
+            boolean ok = validateStatus(status, props);
+            if (!ok) return false;
+            
             Signature sig = new Signature();
             sig.readBytes(_rawIn);
             
@@ -620,7 +622,7 @@ public class ConnectionBuilder {
      *
      * @return true if ok, false if fail()ed
      */
-    private boolean validateStatus(int status) {
+    private boolean validateStatus(int status, Properties props) {
         switch (status) {
             case -1: // EOF
                 fail("Error reading the status from " 
@@ -636,7 +638,7 @@ public class ConnectionBuilder {
             case ConnectionHandler.STATUS_SKEWED:
                 fail("According to " 
                      + _target.getIdentity().calculateHash().toBase64().substring(0,6)
-                     + ", our clock is off");
+                     + ", our clock is off (they think it is " + props.getProperty("SKEW") + ")");
                 return false;
             case ConnectionHandler.STATUS_SIGNATURE_FAILED: // (only for new sessions)
                 fail("Signature failure talking to " 

router/java/src/net/i2p/router/transport/tcp/ConnectionHandler.java

@@ -440,7 +440,7 @@ public class ConnectionHandler {
             } else if ( (clockSkew > Router.CLOCK_FUDGE_FACTOR) 
                         || (clockSkew < 0 - Router.CLOCK_FUDGE_FACTOR) ) {
                 status = STATUS_SKEWED;
-                SimpleDateFormat fmt = new SimpleDateFormat("yyyyMMddhhmmssSSS");
+                SimpleDateFormat fmt = new SimpleDateFormat("yyyyMMddHHmmssSSS");
                 props.setProperty("SKEW", fmt.format(new Date(_context.clock().now())));
             } else {
                 try {
@@ -603,7 +603,7 @@ public class ConnectionHandler {
             } else if ( (clockSkew > Router.CLOCK_FUDGE_FACTOR) 
                         || (clockSkew < 0 - Router.CLOCK_FUDGE_FACTOR) ) {
                 status = STATUS_SKEWED;
-                SimpleDateFormat fmt = new SimpleDateFormat("yyyyMMddhhmmssSSS");
+                SimpleDateFormat fmt = new SimpleDateFormat("yyyyMMddHHmmssSSS");
                 props.setProperty("SKEW", fmt.format(new Date(_context.clock().now())));
             } else if (!sigOk) {
                 status = STATUS_SIGNATURE_FAILED;

router/java/src/net/i2p/router/transport/tcp/ConnectionRunner.java

@@ -2,9 +2,11 @@ package net.i2p.router.transport.tcp;
 
 import java.io.IOException;
 import java.io.OutputStream;
+import java.util.Date;
 
 import net.i2p.data.DataFormatException;
 import net.i2p.data.i2np.I2NPMessage;
+import net.i2p.data.i2np.DeliveryStatusMessage;
 import net.i2p.router.OutNetMessage;
 import net.i2p.router.Router;
 import net.i2p.router.RouterContext;
@@ -21,6 +23,9 @@ class ConnectionRunner implements Runnable {
     private TCPConnection _con;
     private boolean _keepRunning;
     private byte _writeBuffer[];
+    private long _lastTimeSend;
+    
+    private static final long TIME_SEND_FREQUENCY = 60*1000;
     
     public ConnectionRunner(RouterContext ctx, TCPConnection con) {
         _context = ctx;
@@ -32,6 +37,7 @@ class ConnectionRunner implements Runnable {
     public void startRunning() {
         _keepRunning = true;
         _writeBuffer = new byte[38*1024]; // expansion factor 
+        _lastTimeSend = -1;
         
         String name = "TCP " + _context.routerHash().toBase64().substring(0,6) 
                       + " to " 
@@ -39,6 +45,7 @@ class ConnectionRunner implements Runnable {
         I2PThread t = new I2PThread(this, name);
         t.start();
     }
+    
     public void stopRunning() {
         _keepRunning = false;
     }
@@ -85,6 +92,10 @@ class ConnectionRunner implements Runnable {
         
         msg.timestamp("ConnectionRunner.sendMessage data");
 
+        boolean sendTime = false;
+        if (_lastTimeSend < _context.clock().now() - TIME_SEND_FREQUENCY)
+            sendTime = true;
+        
         OutputStream out = _con.getOutputStream();
         boolean ok = false;
         long before = -1;
@@ -93,6 +104,10 @@ class ConnectionRunner implements Runnable {
             synchronized (out) {
                 before = _context.clock().now();
                 out.write(buf, 0, written);
+                if (sendTime) {
+                    out.write(buildTimeMessage().toByteArray());
+                    _lastTimeSend = _context.clock().now();
+                }
                 out.flush();
                 after = _context.clock().now();
             }
@@ -110,4 +125,18 @@ class ConnectionRunner implements Runnable {
         }
         _con.sent(msg, ok, after - before);
     }
+
+    /**
+     * Build up a new message to be sent with the current router's time
+     *
+     */
+    private I2NPMessage buildTimeMessage() {
+        // holy crap this is a kludge - strapping ourselves into a 
+        // deliveryStatusMessage
+        DeliveryStatusMessage tm = new DeliveryStatusMessage(_context);
+        tm.setArrival(new Date(_context.clock().now()));
+        tm.setMessageId(0);
+        tm.setUniqueId(0);
+        return tm;
+    }
 }

router/java/src/net/i2p/router/transport/tcp/MessageHandler.java

@@ -1,9 +1,12 @@
 package net.i2p.router.transport.tcp;
 
+import net.i2p.data.DataHelper;
 import net.i2p.data.Hash;
 import net.i2p.data.RouterIdentity;
 import net.i2p.data.i2np.I2NPMessageReader;
 import net.i2p.data.i2np.I2NPMessage;
+import net.i2p.data.i2np.DeliveryStatusMessage;
+import net.i2p.router.Router;
 import net.i2p.util.Log;
 
 /**
@@ -22,7 +25,8 @@ public class MessageHandler implements I2NPMessageReader.I2NPMessageEventListene
         _con = con;
         _ident = con.getRemoteRouterIdentity();
         _identHash = _ident.calculateHash();
-        _log = con.getRouterContext().logManager().getLog(MessageHandler.class);
+        _log = con.getRouterContext().logManager().getLog(MessageHandler.class);   
+        transport.getContext().statManager().createRateStat("tcp.disconnectAfterSkew", "How skewed a connection became before we killed it?", "TCP", new long[] { 10*60*1000l, 60*60*1000l, 24*60*60*1000l } );
     }
     
     public void disconnected(I2NPMessageReader reader) {
@@ -35,9 +39,40 @@ public class MessageHandler implements I2NPMessageReader.I2NPMessageEventListene
             _log.debug("Just received message " + message.getUniqueId() + " from " 
                        + _identHash.toBase64().substring(0,6)
                        + " readTime = " + msToRead + "ms type = " + message.getClass().getName());
+        if (message instanceof DeliveryStatusMessage) {
+            DeliveryStatusMessage msg = (DeliveryStatusMessage)message;
+            if ( (msg.getMessageId() == 0) && (msg.getUniqueId() == 0) ) {
+                timeMessageReceived(msg.getArrival().getTime());
+                // dont propogate the message, its just a fake
+                return;
+            }
+        }
         _transport.messageReceived(message, _ident, _identHash, msToRead, size);
     }
     
+    private void timeMessageReceived(long remoteTime) {
+        long delta = _con.getRouterContext().clock().now() - remoteTime;
+        if ( (delta > Router.CLOCK_FUDGE_FACTOR) || (delta < 0 - Router.CLOCK_FUDGE_FACTOR) ) {
+            _con.closeConnection();
+            String msg = "Peer " + _identHash.toBase64().substring(0,6) + " is too far skewed (" 
+                         + DataHelper.formatDuration(delta) + ") after uptime of " 
+                         + DataHelper.formatDuration(_con.getLifetime());
+            if (_log.shouldLog(Log.WARN))
+                _log.warn(msg);
+            _transport.addConnectionErrorMessage(msg); 
+            _transport.getContext().statManager().addRateData("tcp.disconnectAfterSkew", delta, _con.getLifetime());
+        } else {
+            int level = Log.DEBUG;
+            if ( (delta > Router.CLOCK_FUDGE_FACTOR/2) || (delta < 0 - Router.CLOCK_FUDGE_FACTOR/2) )
+                level = Log.WARN;
+            if (_log.shouldLog(level))
+                _log.log(level, "Peer " + _identHash.toBase64().substring(0,6) + " is only skewed by (" 
+                                + DataHelper.formatDuration(delta) + ") after uptime of " 
+                                + DataHelper.formatDuration(_con.getLifetime()) );
+            _con.setOffsetReceived(delta);
+        }   
+    }
+    
     public void readError(I2NPMessageReader reader, Exception error) {
         _con.closeConnection();
     }

router/java/src/net/i2p/router/transport/tcp/TCPAddress.java

@@ -170,4 +170,12 @@ public class TCPAddress {
         } 
         return false;
     }
+    
+    public boolean equals(RouterAddress addr) {
+        if (addr == null) return false;
+        Properties opts = addr.getOptions();
+        if (opts == null) return false;
+        return ( (_host.equals(opts.getProperty(PROP_HOST))) &&
+                 (Integer.toString(_port).equals(opts.getProperty(PROP_PORT))) );
+    }
 }

router/java/src/net/i2p/router/transport/tcp/TCPConnection.java

@@ -43,6 +43,7 @@ public class TCPConnection {
     private boolean _closed;
     private long _lastRead;
     private long _lastWrite;
+    private long _offsetReceived;
     
     public TCPConnection(RouterContext ctx) {
         _context = ctx;
@@ -59,6 +60,7 @@ public class TCPConnection {
         _closed = false;
         _lastRead = 0;
         _lastWrite = 0;
+        _offsetReceived = 0;
         _runner = new ConnectionRunner(_context, this);
         _context.statManager().createRateStat("tcp.probabalisticDropQueueSize", "How many bytes were queued to be sent when a message as dropped probabalistically?", "TCP", new long[] { 60*1000l, 10*60*1000l, 60*60*1000l, 24*60*60*1000l } );
         _context.statManager().createRateStat("tcp.queueSize", "How many bytes were queued on a connection?", "TCP", new long[] { 60*1000l, 10*60*1000l, 60*60*1000l, 24*60*60*1000l } );
@@ -81,6 +83,9 @@ public class TCPConnection {
     public void setShownAddress(String ip) { _shownAddress = ip; }
     /** What address the peer said we are reachable on */
     public String getShownAddress() { return _shownAddress; } 
+    /** skew that the other peer has from our clock */
+    public long getOffsetReceived() { return _offsetReceived; }
+    public void setOffsetReceived(long ms) { _offsetReceived = ms; }
     
     /** 
      * Actually start processing the messages on the connection (and reading
@@ -185,7 +190,7 @@ public class TCPConnection {
     }
     
     private boolean shouldDropProbabalistically() {
-        return Boolean.valueOf(_context.getProperty("tcp.dropProbabalistically", "false")).booleanValue();
+        return Boolean.valueOf(_context.getProperty("tcp.dropProbabalistically", "true")).booleanValue();
     }
     
     /**
@@ -210,12 +215,34 @@ public class TCPConnection {
         long sendRate = getSendRate();
         long bytesSendableUntilFirstExpire = sendRate * (earliestExpiration - _context.clock().now()) / 1000;
         
-        // try to keep the queue less than half full
-        long excessQueued = bytesQueued - (bytesSendableUntilFirstExpire/2); 
+        // pretend that instead of being able to push bytesSendableUntilFirstExpire,
+        // that we can only push a fraction of that amount, causing us to probabalistically
+        // drop more than is necessary (leaving a fraction of the queue 'free' for bursts)
+        long excessQueued = (long)(bytesQueued - ((double)bytesSendableUntilFirstExpire * (1.0-getQueueFreeFactor()))); 
         if ( (excessQueued > 0) && (_pendingMessages.size() > 1) && (_transport != null) )
             locked_probabalisticDrop(excessQueued);
     }
     
+    /** 
+     * by default, try to keep the queue completely full, but this can be overridden
+     * with the property 'tcp.queueFreeFactor'
+     *
+     */
+    public static final double DEFAULT_QUEUE_FREE_FACTOR = 0.0;
+    
+    private double getQueueFreeFactor() {
+        String factor = _context.getProperty("tcp.queueFreeFactor");
+        if (factor != null) {
+            try {
+                return Double.parseDouble(factor); 
+            } catch (NumberFormatException nfe) {
+                if (_log.shouldLog(Log.WARN))
+                    _log.warn("Invalid tcp.queueFreeFactor [" + factor + "]", nfe);
+            }
+        }
+        return DEFAULT_QUEUE_FREE_FACTOR;
+    }
+    
     /** how many Bps we are sending data to the peer (or 2KBps if we don't know) */
     public long getSendRate() {
         if (_sendRate == null) return 2*1024;
@@ -246,7 +273,7 @@ public class TCPConnection {
         for (int i = 0; i < _pendingMessages.size() && excessBytesQueued > 0; i++) {
             OutNetMessage msg = (OutNetMessage)_pendingMessages.get(i);
             int p = getDropProbability(msg.getMessageSize(), excessBytesQueued);
-            if (_context.random().nextInt(100) > p) {
+            if (_context.random().nextInt(100) < p) {
                 _pendingMessages.remove(i);
                 i--;
                 msg.timestamp("Probabalistically dropped due to queue size " + excessBytesQueued);

router/java/src/net/i2p/router/transport/tcp/TCPTransport.java

@@ -132,8 +132,7 @@ public class TCPTransport extends TransportImpl {
         if (addr == null) 
             return null;
         
-        TCPAddress tcpAddr = new TCPAddress(addr);
-        if ( (_myAddress != null) && (tcpAddr.equals(_myAddress)) )
+        if ( (_myAddress != null) && (_myAddress.equals(addr)) ) 
             return null; // dont talk to yourself
         
         TransportBid bid = new TransportBid();
@@ -770,6 +769,7 @@ public class TCPTransport extends TransportImpl {
     public String renderStatusHTML() { 
         StringBuffer buf = new StringBuffer(1024);
         synchronized (_connectionLock) {
+            long offsetTotal = 0;
             buf.append("<b>Connections (").append(_connectionsByIdent.size()).append("):</b><ul>\n");
             for (Iterator iter = _connectionsByIdent.values().iterator(); iter.hasNext(); ) {
                 TCPConnection con = (TCPConnection)iter.next();
@@ -782,10 +782,18 @@ public class TCPTransport extends TransportImpl {
                     buf.append(bps).append("Bps");
                 else 
                     buf.append((int)(bps/1024)).append("KBps");
+                buf.append(" with a ").append(con.getOffsetReceived()).append("ms clock offset");
                 buf.append("</li>\n");
+                offsetTotal += con.getOffsetReceived();
             }
             buf.append("</ul>\n");
             
+            buf.append("<b>Average clock skew: ");
+            if (_connectionsByIdent.size() > 0)
+                buf.append(offsetTotal / _connectionsByIdent.size()).append("ms</b><br />\n");
+            else
+                buf.append("n/a</b><br />\n");
+            
             buf.append("<b>Connections being built:</b><ul>\n");
             for (Iterator iter = _pendingConnectionsByIdent.iterator(); iter.hasNext(); ) {
                 Hash peer = (Hash)iter.next();

router/java/src/net/i2p/router/tunnelmanager/ClientLeaseSetManagerJob.java

@@ -51,6 +51,8 @@ class ClientLeaseSetManagerJob extends JobImpl {
         _pool = pool;
         _currentLeaseSet = null;
         _lastCreated = -1;
+        context.statManager().createRateStat("client.leaseSetExpired", "How long ago did our leaseSet expire?", "ClientMessages", new long[] { 60*60*1000l, 24*60*60*1000l });
+
     }
     
     public void forceRequestLease() { 
@@ -106,6 +108,13 @@ class ClientLeaseSetManagerJob extends JobImpl {
             _log.warn("Insufficient safe inbound tunnels exist for the client (" + available 
                       + " available, " + _pool.getClientSettings().getNumInboundTunnels() 
                       + " required) - no leaseSet requested");
+            if (_currentLeaseSet != null) {
+                long howOld = getContext().clock().now() - _currentLeaseSet.getEarliestLeaseDate();
+                if (howOld > 0) {
+                    // expired
+                    getContext().statManager().addRateData("client.leaseSetExpired", howOld, 0);
+                }
+            }
         }
         requeue(RECHECK_DELAY);
     }

router/java/src/net/i2p/router/tunnelmanager/TunnelPool.java

@@ -68,6 +68,8 @@ class TunnelPool {
         _context.statManager().createRateStat("tunnel.outboundMessagesProcessed", "How many messages does an inbound tunnel process in its lifetime?", "Tunnels", new long[] { 10*60*1000l, 60*60*1000l, 24*60*60*1000l });
         _context.statManager().createRateStat("tunnel.participatingMessagesProcessed", "How many messages does an inbound tunnel process in its lifetime?", "Tunnels", new long[] { 10*60*1000l, 60*60*1000l, 24*60*60*1000l });
         _context.statManager().createRateStat("tunnel.participatingMessagesProcessedActive", "How many messages beyond the average were processed in a more-than-average tunnel's lifetime?", "Tunnels", new long[] { 10*60*1000l, 60*60*1000l, 24*60*60*1000l });
+        _context.statManager().createRateStat("tunnel.participatingBytesProcessed", "How many bytes does an inbound tunnel process in its lifetime?", "Tunnels", new long[] { 10*60*1000l, 60*60*1000l, 24*60*60*1000l });
+        _context.statManager().createRateStat("tunnel.participatingBytesProcessedActive", "How many bytes beyond the average were processed in a more-than-average tunnel's lifetime?", "Tunnels", new long[] { 10*60*1000l, 60*60*1000l, 24*60*60*1000l });
         
         _isLive = true;
         _persistenceHelper = new TunnelPoolPersistenceHelper(_context);
@@ -529,6 +531,20 @@ class TunnelPool {
     }
     
     private static final int MAX_FAILURES_PER_TUNNEL = 0;
+    public static final String PROP_MAX_TUNNEL_FAILURES = "tunnel.maxTunnelFailures";
+    
+    private int getMaxTunnelFailures() {
+        String max = _context.getProperty(PROP_MAX_TUNNEL_FAILURES);
+        if (max != null) {
+            try {
+                return Integer.parseInt(max);
+            } catch (NumberFormatException nfe) {
+                if (_log.shouldLog(Log.WARN))
+                    _log.warn("Max tunnel failures property is invalid [" + max + "]");
+            }
+        }
+        return MAX_FAILURES_PER_TUNNEL;
+    }
     
     public void tunnelFailed(TunnelId id) {
         if (!_isLive) return;
@@ -536,7 +552,7 @@ class TunnelPool {
         if (info == null)
             return;
         int failures = info.incrementFailures();
-        if (failures <= MAX_FAILURES_PER_TUNNEL) {
+        if (failures <= getMaxTunnelFailures()) {
             if (_log.shouldLog(Log.INFO))
                 _log.info("Tunnel " + id + " failure " + failures + ", but not fatal yet");
             return;
@@ -648,6 +664,11 @@ class TunnelPool {
                                                            numMsgs-lastAvg, 
                                                            info.getSettings().getExpiration() -
                                                            info.getSettings().getCreated());
+                    long numBytes = info.getBytesProcessed();
+                    lastAvg = (long)_context.statManager().getRate("tunnel.participatingBytesProcessed").getRate(10*60*1000l).getAverageValue();
+                    _context.statManager().addRateData("tunnel.participatingBytesProcessed", numBytes, numMsgs);
+                    if (numBytes > lastAvg)
+                        _context.statManager().addRateData("tunnel.participatingBytesProcessedActive", numBytes-lastAvg, numMsgs);
                     break;
                 case TunnelId.TYPE_UNSPECIFIED:
                 default: