* 2005-03-24 0.5.0.4 released

* Added more intelligent version checking in news.xml, in case we have a
      version newer than the one specified.

apps/addressbook/README.txt

@@ -0,0 +1,43 @@
+addressbook v2.0.2 - A simple name resolution mechanism for I2P
+
+addressbook is a simple implementation of subscribable address books for I2P.  
+Addresses are stored in userhosts.txt and a second copy of the address book is 
+placed on your eepsite as hosts.txt. 
+
+subscriptions.txt contains a list of urls to check for new addresses.
+Since the urls are checked in order, and conflicting addresses are not added,
+addressbook.subscriptions can be considered to be ranked in order of trust.
+
+The system created by addressbook is similar to the early days of DNS,
+when everyone ran a local name server.  The major difference is the lack of
+authority.  Name cannot be guaranteed to be globally unique, but in practise 
+they probably will be, for a variety of social reasons.
+
+Requirements
+************
+
+i2p with a running http proxy
+
+Installation and Usage
+**********************
+
+1. Unzip addressbook-%ver.zip into your i2p directory. 
+2. Restart your router.
+
+The addressbook daemon will automatically run while the router is up.
+
+Aside from the daemon itself, the other elements of the addressbook interface
+are the config.txt, myhosts.txt, and subscriptions.txt files found in the addressbook 
+directory. 
+
+config.txt is the configuration file for addressbook.
+
+myhosts.txt is the addressbook master address book.  Addresses placed in this file 
+take precidence over those in the router address book and in remote address books.  
+If changes are made to this file, they will be reflected in the router address book 
+and published address book after the next update. Do not make changes directly to the 
+router address book, as they could be lost during an update.
+
+subscriptions.txt is the subscription list for addressbook.  Each entry is an absolute 
+url to a file in hosts.txt format. Since the list is checked in order, url's should be 
+listed in order of trust.

apps/addressbook/build.xml

@@ -0,0 +1,47 @@
+<?xml version="1.0"?>
+<project name="addressbook" default="war" basedir=".">
+
+	<property name="src" value="java/src/addressbook"/>
+	<property name="build" value="build"/>
+	<property name="dist"  location="dist"/>
+	<property name="jar" value="addressbook.jar"/>
+	<property name="war" value="addressbook.war"/>
+	<property name="servlet" value="../jetty/jettylib/javax.servlet.jar"/>
+
+	<target name="init">
+		<mkdir dir="${build}"/>
+		<mkdir dir="${dist}"/>
+	</target>
+
+	<target name="clean">
+		<delete dir="${build}"/>
+		<delete dir="${dist}"/>
+	</target>
+
+	<target name="distclean" depends="clean" />
+
+	<target name="compile" depends="init">
+		<javac debug="true" deprecation="on" source="1.3" target="1.3" 
+                       srcdir="${src}" destdir="${build}" classpath="${servlet}"/>
+	</target>
+
+	<target name="jar" depends="compile">
+		<jar basedir="${build}" destfile="${dist}/${jar}">
+			<manifest>
+				<attribute name="Main-Class" value="addressbook.Daemon"/>
+			</manifest>
+		</jar>
+	</target>
+	
+	<target name="war" depends="compile">
+		<mkdir dir="${dist}/tmp"/>
+		<mkdir dir="${dist}/tmp/WEB-INF"/>
+		<mkdir dir="${dist}/tmp/WEB-INF/classes"/>
+		<copy todir="${dist}/tmp/WEB-INF/classes">
+			<fileset dir="${build}"/>
+		</copy>
+		<war basedir="${dist}/tmp" webxml="web.xml" destfile="${dist}/${war}"/>
+		<delete dir="${dist}/tmp"/>
+	</target>
+	
+</project>

apps/addressbook/config.txt

@@ -0,0 +1,43 @@
+# This is the configuration file for addressbook.
+#
+# Options
+# *******
+# All paths are realitive to i2p/addressbook.  Default value for
+# each option is given in parentheses.
+#
+# proxy_host                 The hostname of your I2P http proxy. 
+#                            (localhost)
+#
+# proxy_port                 The port of your I2P http proxy. (4444)
+#
+# master_addressbook         The path to your master address book, used for local
+#                            changes only. (myhosts.txt)
+#
+# router_addressbook         The path to the address book used by the router.  
+#                            Contains the addresses from your master address book
+#                            and your subscribed address books. (../userhosts.txt)
+#
+# published_addressbook      The path to the copy of your address book made 
+#                            available on i2p. (../eepsite/docroot/hosts.txt)
+#
+# log                        The path to your addressbook log. (log.txt)
+#
+# subscriptions              The path to your subscription file. (subscriptions.txt)
+#
+# etags                      The path to the etags header storage file. (etags)
+#
+# last_modified              The path to the last-modified header storage file. 
+#                            (last_modified)
+#
+# update_delay               The time (in hours) between each update. (1)
+
+proxy_host=localhost
+proxy_port=4444
+master_addressbook=myhosts.txt
+router_addressbook=../userhosts.txt
+published_addressbook=../eepsite/docroot/hosts.txt
+log=log.txt
+subscriptions=subscriptions.txt
+etags=etags
+last_modified=last_modified
+update_delay=1

apps/addressbook/java/src/addressbook/AddressBook.java

@@ -0,0 +1,246 @@
+/*
+ * Copyright (c) 2004 Ragnarok
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+package addressbook;
+
+import java.util.Map;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.net.URL;
+import java.net.HttpURLConnection;
+import java.io.File;
+import java.io.IOException;
+
+/**
+ * An address book for storing human readable names mapped to base64 i2p
+ * destinations. AddressBooks can be created from local and remote files, merged
+ * together, and written out to local files.
+ * 
+ * @author Ragnarok
+ *  
+ */
+public class AddressBook {
+
+    private String location;
+
+    private Map addresses;
+
+    private boolean modified;
+
+    /**
+     * Construct an AddressBook from the contents of the Map addresses.
+     * 
+     * @param addresses
+     *            A Map containing human readable addresses as keys, mapped to
+     *            base64 i2p destinations.
+     */
+    public AddressBook(Map addresses) {
+        this.addresses = addresses;
+    }
+
+    /**
+     * Construct an AddressBook from the contents of the file at url. If the
+     * remote file cannot be read, construct an empty AddressBook
+     * 
+     * @param url
+     *            A URL pointing at a file with lines in the format "key=value",
+     *            where key is a human readable name, and value is a base64 i2p
+     *            destination.
+     */
+    public AddressBook(URL url) {
+        this.location = url.getHost();
+
+        try {
+            this.addresses = ConfigParser.parse(url);
+        } catch (IOException exp) {
+            this.addresses = new HashMap();
+        }
+    }
+
+    /**
+     * Construct an AddressBook from the Subscription subscription. If the
+     * address book at subscription has not changed since the last time it was
+     * read or cannot be read, return an empty AddressBook.
+     * 
+     * @param subscription
+     *            A Subscription instance pointing at a remote address book.
+     */
+    public AddressBook(Subscription subscription) {
+        this.location = subscription.getLocation();
+
+        try {
+            URL url = new URL(subscription.getLocation());
+            HttpURLConnection connection = (HttpURLConnection) url
+                    .openConnection();
+            if (subscription.getEtag() != null) {
+                connection.addRequestProperty("If-None-Match", subscription
+                        .getEtag());
+            }
+            if (subscription.getLastModified() != null) {
+                connection.addRequestProperty("If-Modified-Since", subscription
+                        .getLastModified());
+            }
+            connection.connect();
+            if (connection.getResponseCode() == HttpURLConnection.HTTP_NOT_MODIFIED) {
+                connection.disconnect();
+                this.addresses = new HashMap();
+                return;
+            }
+            if (connection.getHeaderField("ETag") != null) {
+                subscription.setEtag(connection.getHeaderField("ETag"));
+            }
+            if (connection.getHeaderField("Last-Modified") != null) {
+                subscription.setLastModified(connection
+                        .getHeaderField("Last-Modified"));
+            }
+        } catch (IOException exp) {
+        }
+
+        try {
+            this.addresses = ConfigParser.parse(new URL(subscription
+                    .getLocation()));
+        } catch (IOException exp) {
+            this.addresses = new HashMap();
+        }
+    }
+
+    /**
+     * Construct an AddressBook from the contents of the file at file. If the
+     * file cannot be read, construct an empty AddressBook
+     * 
+     * @param file
+     *            A File pointing at a file with lines in the format
+     *            "key=value", where key is a human readable name, and value is
+     *            a base64 i2p destination.
+     */
+    public AddressBook(File file) {
+        this.location = file.toString();
+        try {
+            this.addresses = ConfigParser.parse(file);
+        } catch (IOException exp) {
+            this.addresses = new HashMap();
+        }
+    }
+
+    /**
+     * Return a Map containing the addresses in the AddressBook.
+     * 
+     * @return A Map containing the addresses in the AddressBook, where the key
+     *         is a human readable name, and the value is a base64 i2p
+     *         destination.
+     */
+    public Map getAddresses() {
+        return this.addresses;
+    }
+
+    /**
+     * Return the location of the file this AddressBook was constructed from.
+     * 
+     * @return A String representing either an abstract path, or a url,
+     *         depending on how the instance was constructed.
+     */
+    public String getLocation() {
+        return this.location;
+    }
+
+    /**
+     * Return a string representation of the contents of the AddressBook.
+     * 
+     * @return A String representing the contents of the AddressBook.
+     */
+    public String toString() {
+        return this.addresses.toString();
+    }
+
+    /**
+     * Merge this AddressBook with AddressBook other, writing messages about new
+     * addresses or conflicts to log. Addresses in AddressBook other that are
+     * not in this AddressBook are added to this AddressBook. In case of a
+     * conflict, addresses in this AddressBook take precedence
+     * 
+     * @param other
+     *            An AddressBook to merge with.
+     * @param log
+     *            The log to write messages about new addresses or conflicts to.
+     */
+    public void merge(AddressBook other, Log log) {
+        Iterator otherIter = other.addresses.keySet().iterator();
+
+        while (otherIter.hasNext()) {
+            String otherKey = (String) otherIter.next();
+            String otherValue = (String) other.addresses.get(otherKey);
+
+            if (otherKey.endsWith(".i2p") && otherValue.length() >= 516) {
+                if (this.addresses.containsKey(otherKey)) {
+                    if (!this.addresses.get(otherKey).equals(otherValue)
+                            && log != null) {
+                        log.append("Conflict for " + otherKey + " from "
+                                + other.location
+                                + ". Destination in remote address book is "
+                                + otherValue);
+                    }
+                } else {
+                    this.addresses.put(otherKey, otherValue);
+                    this.modified = true;
+                    if (log != null) {
+                        log.append("New address " + otherKey
+                                + " added to address book.");
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Merge this AddressBook with other, without logging.
+     * 
+     * @param other
+     *            An AddressBook to merge with.
+     */
+    public void merge(AddressBook other) {
+        this.merge(other, null);
+    }
+
+    /**
+     * Write the contents of this AddressBook out to the File file. If the file
+     * cannot be writen to, this method will silently fail.
+     * 
+     * @param file
+     *            The file to write the contents of this AddressBook too.
+     */
+    public void write(File file) {
+        if (this.modified) {
+            try {
+                ConfigParser.write(this.addresses, file);
+            } catch (IOException exp) {
+            }
+        }
+    }
+
+    /**
+     * Write this AddressBook out to the file it was read from. Requires that
+     * AddressBook was constructed from a file on the local filesystem. If the
+     * file cannot be writen to, this method will silently fail.
+     */
+    public void write() {
+        this.write(new File(this.location));
+    }
+}

apps/addressbook/java/src/addressbook/ConfigParser.java

@@ -0,0 +1,323 @@
+/*
+ * Copyright (c) 2004 Ragnarok
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+package addressbook;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.List;
+import java.util.LinkedList;
+import java.util.Iterator;
+import java.io.*;
+import java.net.URL;
+
+/**
+ * Utility class providing methods to parse and write files in config file
+ * format, and subscription file format.
+ * 
+ * @author Ragnarok
+ */
+public class ConfigParser {
+
+    /**
+     * Strip the comments from a String. Lines that begin with '#' and ';' are
+     * considered comments, as well as any part of a line after a '#'.
+     * 
+     * @param inputLine
+     *            A String to strip comments from.
+     * @return A String without comments, but otherwise identical to inputLine.
+     */
+    public static String stripComments(String inputLine) {
+        if (inputLine.startsWith(";")) {
+            return "";
+        }
+        if (inputLine.split("#").length > 0) {
+            return inputLine.split("#")[0];
+        } else {
+            return "";
+        }
+    }
+
+    /**
+     * Return a Map using the contents of BufferedReader input. input must have
+     * a single key, value pair on each line, in the format: key=value. Lines
+     * starting with '#' or ';' are considered comments, and ignored. Lines that
+     * are obviously not in the format key=value are also ignored.
+     * 
+     * @param input
+     *            A BufferedReader with lines in key=value format to parse into
+     *            a Map.
+     * @return A Map containing the key, value pairs from input.
+     * @throws IOException
+     *             if the BufferedReader cannot be read.
+     *  
+     */
+    public static Map parse(BufferedReader input) throws IOException {
+        Map result = new HashMap();
+        String inputLine;
+        inputLine = input.readLine();
+        while (inputLine != null) {
+            inputLine = ConfigParser.stripComments(inputLine);
+            String[] splitLine = inputLine.split("=");
+            if (splitLine.length == 2) {
+                result.put(splitLine[0].trim(), splitLine[1].trim());
+            }
+            inputLine = input.readLine();
+        }
+        input.close();
+        return result;
+    }
+
+    /**
+     * Return a Map using the contents of the file at url. See
+     * parseBufferedReader for details of the input format.
+     * 
+     * @param url
+     *            A url pointing to a file to parse.
+     * @return A Map containing the key, value pairs from url.
+     * @throws IOException
+     *             if url cannot be read.
+     */
+    public static Map parse(URL url) throws IOException {
+        InputStream urlStream;
+        urlStream = url.openConnection().getInputStream();
+        BufferedReader input = new BufferedReader(new InputStreamReader(
+                urlStream));
+        return ConfigParser.parse(input);
+    }
+
+    /**
+     * Return a Map using the contents of the File file. See parseBufferedReader
+     * for details of the input format.
+     * 
+     * @param file
+     *            A File to parse.
+     * @return A Map containing the key, value pairs from file.
+     * @throws IOException
+     *             if file cannot be read.
+     */
+    public static Map parse(File file) throws IOException {
+        FileInputStream fileStream = new FileInputStream(file);
+        BufferedReader input = new BufferedReader(new InputStreamReader(
+                fileStream));
+        return ConfigParser.parse(input);
+    }
+
+    /**
+     * Return a Map using the contents of the String string. See
+     * parseBufferedReader for details of the input format.
+     * 
+     * @param string
+     *            A String to parse.
+     * @return A Map containing the key, value pairs from string.
+     * @throws IOException
+     *             if file cannot be read.
+     */
+    public static Map parse(String string) throws IOException {
+        StringReader stringReader = new StringReader(string);
+        BufferedReader input = new BufferedReader(stringReader);
+        return ConfigParser.parse(input);
+    }
+    
+    /**
+     * Return a Map using the contents of the File file. If file cannot be read,
+     * use map instead, and write the result to where file should have been.
+     * 
+     * @param file
+     *            A File to attempt to parse.
+     * @param map
+     *            A Map to use as the default, if file fails.
+     * @return A Map containing the key, value pairs from file, or if file
+     *         cannot be read, map.
+     */
+    public static Map parse(File file, Map map) {
+        Map result = new HashMap();
+        try {
+            result = ConfigParser.parse(file);
+        } catch (IOException exp) {
+            result = map;
+            try {
+                ConfigParser.write(result, file);
+            } catch (IOException exp2) {
+            }
+        }
+        return result;
+    }
+
+    /**
+     * Return a List where each element is a line from the BufferedReader input.
+     * 
+     * @param input
+     *            A BufferedReader to parse.
+     * @return A List consisting of one element for each line in input.
+     * @throws IOException
+     *             if input cannot be read.
+     */
+    public static List parseSubscriptions(BufferedReader input)
+            throws IOException {
+        List result = new LinkedList();
+        String inputLine = input.readLine();
+        while (inputLine != null) {
+            inputLine = ConfigParser.stripComments(inputLine).trim();
+            if (inputLine.length() > 0) {
+                result.add(inputLine);
+            }
+            inputLine = input.readLine();
+        }
+        input.close();
+        return result;
+    }
+
+    /**
+     * Return a List where each element is a line from the File file.
+     * 
+     * @param file
+     *            A File to parse.
+     * @return A List consisting of one element for each line in file.
+     * @throws IOException
+     *             if file cannot be read.
+     */
+    public static List parseSubscriptions(File file) throws IOException {
+        FileInputStream fileStream = new FileInputStream(file);
+        BufferedReader input = new BufferedReader(new InputStreamReader(
+                fileStream));
+        return ConfigParser.parseSubscriptions(input);
+    }
+
+    /**
+     * Return a List where each element is a line from the String string.
+     * 
+     * @param string
+     *            A String to parse.
+     * @return A List consisting of one element for each line in string.
+     * @throws IOException
+     *             if string cannot be read.
+     */
+    public static List parseSubscriptions(String string) throws IOException {
+        StringReader stringReader = new StringReader(string);
+        BufferedReader input = new BufferedReader(stringReader);
+        return ConfigParser.parseSubscriptions(input);
+    }
+    
+    /**
+     * Return a List using the contents of the File file. If file cannot be
+     * read, use list instead, and write the result to where file should have
+     * been.
+     * 
+     * @param file
+     *            A File to attempt to parse.
+     * @param string
+     *            A List to use as the default, if file fails.
+     * @return A List consisting of one element for each line in file, or if
+     *         file cannot be read, list.
+     */
+    public static List parseSubscriptions(File file, List list) {
+        List result = new LinkedList();
+        try {
+            result = ConfigParser.parseSubscriptions(file);
+        } catch (IOException exp) {
+            result = list;
+            try {
+                ConfigParser.writeSubscriptions(result, file);
+            } catch (IOException exp2) {
+            }
+        }
+        return result;
+    }
+
+    /**
+     * Write contents of Map map to BufferedWriter output. Output is written
+     * with one key, value pair on each line, in the format: key=value.
+     * 
+     * @param map
+     *            A Map to write to output.
+     * @param output
+     *            A BufferedWriter to write the Map to.
+     * @throws IOException
+     *             if the BufferedWriter cannot be written to.
+     */
+    public static void write(Map map, BufferedWriter output) throws IOException {
+        Iterator keyIter = map.keySet().iterator();
+
+        while (keyIter.hasNext()) {
+            String key = (String) keyIter.next();
+            output.write(key + "=" + (String) map.get(key));
+            output.newLine();
+        }
+        output.close();
+    }
+
+    /**
+     * Write contents of Map map to the File file. Output is written
+     * with one key, value pair on each line, in the format: key=value.
+     * 
+     * @param map
+     *            A Map to write to file.
+     * @param file
+     *            A File to write the Map to.
+     * @throws IOException
+     *             if file cannot be written to.
+     */
+    public static void write(Map map, File file) throws IOException {
+        ConfigParser
+                .write(map, new BufferedWriter(new FileWriter(file, false)));
+    }
+
+    /**
+     * Write contents of List list to BufferedReader output. Output is written
+     * with each element of list on a new line.
+     * 
+     * @param list
+     *            A List to write to file.
+     * @param output
+     *            A BufferedReader to write list to.
+     * @throws IOException
+     *             if output cannot be written to.
+     */
+    public static void writeSubscriptions(List list, BufferedWriter output)
+            throws IOException {
+        Iterator iter = list.iterator();
+
+        while (iter.hasNext()) {
+            output.write((String) iter.next());
+            output.newLine();
+        }
+        output.close();
+    }
+    
+    /**
+     * Write contents of List list to File file. Output is written with each
+     * element of list on a new line.
+     * 
+     * @param list
+     *            A List to write to file.
+     * @param file
+     *            A File to write list to.
+     * @throws IOException
+     *             if output cannot be written to.
+     */
+    public static void writeSubscriptions(List list, File file)
+            throws IOException {
+        ConfigParser.writeSubscriptions(list, new BufferedWriter(
+                new FileWriter(file, false)));
+    }
+
+}

apps/addressbook/java/src/addressbook/Daemon.java

@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) 2004 Ragnarok
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+package addressbook;
+
+import java.util.Iterator;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.List;
+import java.util.LinkedList;
+import java.io.File;
+
+/**
+ * Main class of addressbook.  Performs updates, and runs the main loop.
+ * 
+ * @author Ragnarok
+ *
+ */
+public class Daemon {
+    public static final String VERSION = "2.0.3";
+    
+    /**
+     * Update the router and published address books using remote data from the
+     * subscribed address books listed in subscriptions.
+     * 
+     * @param master
+     *            The master AddressBook. This address book is never
+     *            overwritten, so it is safe for the user to write to.
+     * @param router
+     *            The router AddressBook. This is the address book read by
+     *            client applications.
+     * @param published
+     *            The published AddressBook. This address book is published on
+     *            the user's eepsite so that others may subscribe to it.
+     * @param subscriptions
+     *            A SubscriptionList listing the remote address books to update
+     *            from.
+     * @param log
+     *            The log to write changes and conflicts to.
+     */
+    public static void update(AddressBook master, AddressBook router,
+            File published, SubscriptionList subscriptions, Log log) {
+        String routerLocation = router.getLocation();
+        master.merge(router);
+        Iterator iter = subscriptions.iterator();
+        while (iter.hasNext()) {
+            master.merge((AddressBook) iter.next(), log);
+        }
+        master.write(new File(routerLocation));
+        if (published != null)
+            master.write(published);
+        subscriptions.write();
+    }
+
+    /**
+     * Run an update, using the Map settings to provide the parameters.
+     * 
+     * @param settings
+     *            A Map containg the parameters needed by update.
+     * @param home
+     *            The directory containing addressbook's configuration files.
+     */
+    public static void update(Map settings, String home) {
+        File masterFile = new File(home, (String) settings
+                .get("master_addressbook"));
+        File routerFile = new File(home, (String) settings
+                .get("router_addressbook"));
+        File published = null;
+        if ("true".equals(settings.get("should_publish"))) 
+            published = new File(home, (String) settings
+                .get("published_addressbook"));
+        File subscriptionFile = new File(home, (String) settings
+                .get("subscriptions"));
+        File logFile = new File(home, (String) settings.get("log"));
+        File etagsFile = new File(home, (String) settings.get("etags"));
+        File lastModifiedFile = new File(home, (String) settings
+                .get("last_modified"));
+
+        AddressBook master = new AddressBook(masterFile);
+        AddressBook router = new AddressBook(routerFile);
+        
+        List defaultSubs = new LinkedList();
+        defaultSubs.add("http://i2p/NF2RLVUxVulR3IqK0sGJR0dHQcGXAzwa6rEO4WAWYXOHw-DoZhKnlbf1nzHXwMEJoex5nFTyiNMqxJMWlY54cvU~UenZdkyQQeUSBZXyuSweflUXFqKN-y8xIoK2w9Ylq1k8IcrAFDsITyOzjUKoOPfVq34rKNDo7fYyis4kT5bAHy~2N1EVMs34pi2RFabATIOBk38Qhab57Umpa6yEoE~rbyR~suDRvD7gjBvBiIKFqhFueXsR2uSrPB-yzwAGofTXuklofK3DdKspciclTVzqbDjsk5UXfu2nTrC1agkhLyqlOfjhyqC~t1IXm-Vs2o7911k7KKLGjB4lmH508YJ7G9fLAUyjuB-wwwhejoWqvg7oWvqo4oIok8LG6ECR71C3dzCvIjY2QcrhoaazA9G4zcGMm6NKND-H4XY6tUWhpB~5GefB3YczOqMbHq4wi0O9MzBFrOJEOs3X4hwboKWANf7DT5PZKJZ5KorQPsYRSq0E3wSOsFCSsdVCKUGsAAAA/i2p/hosts.txt");
+        
+        SubscriptionList subscriptions = new SubscriptionList(subscriptionFile,
+                etagsFile, lastModifiedFile, defaultSubs);
+        Log log = new Log(logFile);
+
+        Daemon.update(master, router, published, subscriptions, log);
+    }
+
+    /**
+     * Load the settings, set the proxy, then enter into the main loop. The main
+     * loop performs an immediate update, and then an update every number of
+     * hours, as configured in the settings file.
+     * 
+     * @param args
+     *            Command line arguments. If there are any arguments provided,
+     *            the first is taken as addressbook's home directory, and the
+     *            others are ignored.
+     */
+    public static void main(String[] args) {
+        String settingsLocation = "config.txt";
+        Map settings = new HashMap();
+        String home;
+        if (args.length > 0) {
+            home = args[0];
+        } else {
+            home = ".";
+        }
+        
+        Map defaultSettings = new HashMap();
+        defaultSettings.put("proxy_host", "localhost");
+        defaultSettings.put("proxy_port", "4444");
+        defaultSettings.put("master_addressbook", "../userhosts.txt");
+        defaultSettings.put("router_addressbook", "../hosts.txt");
+        defaultSettings.put("published_addressbook", "../eepsite/docroot/hosts.txt");
+        defaultSettings.put("should_publish", "false");
+        defaultSettings.put("log", "log.txt");
+        defaultSettings.put("subscriptions", "subscriptions.txt");
+        defaultSettings.put("etags", "etags");
+        defaultSettings.put("last_modified", "last_modified");
+        defaultSettings.put("update_delay", "1");
+        
+        File homeFile = new File(home);
+        if (!homeFile.exists()) {
+            boolean created = homeFile.mkdirs();
+            if (created)
+                System.out.println("INFO:  Addressbook directory " + homeFile.getName() + " created");
+            else
+                System.out.println("ERROR: Addressbook directory " + homeFile.getName() + " could not be created");
+        }
+        
+        File settingsFile = new File(homeFile, settingsLocation);
+        
+        while (true) {
+            settings = ConfigParser.parse(settingsFile, defaultSettings);
+
+            System.setProperty("proxySet", "true");
+            System.setProperty("http.proxyHost", (String) settings
+                    .get("proxy_host"));
+            System.setProperty("http.proxyPort", (String) settings
+                    .get("proxy_port"));
+            long delay = Long.parseLong((String) settings.get("update_delay"));
+            if (delay < 1) {
+                delay = 1;
+            }
+            
+            Daemon.update(settings, home);
+            try {
+                Thread.sleep(delay * 60 * 60 * 1000);
+            } catch (InterruptedException exp) {
+            }
+        }
+    }
+}

apps/addressbook/java/src/addressbook/DaemonThread.java

@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2004 Ragnarok
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+package addressbook;
+
+/**
+ * A thread that waits five minutes, then runs the addressbook daemon.  
+ * 
+ * @author Ragnarok
+ *
+ */
+public class DaemonThread extends Thread {
+
+    private String[] args;
+
+    /**
+     * Construct a DaemonThread with the command line arguments args.
+     * @param args
+     * A String array to pass to Daemon.main().
+     */
+    public DaemonThread(String[] args) {
+        this.args = args;
+    }
+
+    /* (non-Javadoc)
+     * @see java.lang.Runnable#run()
+     */
+    public void run() {
+        try {
+            Thread.sleep(5 * 60 * 1000);
+        } catch (InterruptedException exp) {
+        }
+        Daemon.main(this.args);
+    }
+}

apps/addressbook/java/src/addressbook/Log.java

@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2004 Ragnarok
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+package addressbook;
+
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.Date;
+
+/**
+ * A simple log with automatic time stamping.
+ * 
+ * @author Ragnarok
+ *  
+ */
+public class Log {
+
+    private File file;
+
+    /**
+     * Construct a Log instance that writes to the File file.
+     * 
+     * @param file
+     *            A File for the log to write to.
+     */
+    public Log(File file) {
+        this.file = file;
+    }
+
+    /**
+     * Write entry to a new line in the log, with appropriate time stamp.
+     * 
+     * @param entry
+     *            A String containing a message to append to the log.
+     */
+    public void append(String entry) {
+        try {
+            BufferedWriter bw = new BufferedWriter(new FileWriter(this.file,
+                    true));
+            String timestamp = new Date().toString();
+            bw.write(timestamp + " -- " + entry);
+            bw.newLine();
+            bw.close();
+        } catch (IOException exp) {
+        }
+    }
+
+    /**
+     * Return the File that the Log is writing to.
+     * 
+     * @return The File that the log is writing to.
+     */
+    public File getFile() {
+        return this.file;
+    }
+}

apps/addressbook/java/src/addressbook/Servlet.java

@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2004 Ragnarok
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+package addressbook;
+
+import javax.servlet.GenericServlet;
+import javax.servlet.ServletRequest;
+import javax.servlet.ServletResponse;
+import javax.servlet.ServletConfig;
+import javax.servlet.ServletException;
+
+/**
+ * A wrapper for addressbook to allow it to be started as a web application.
+ * 
+ * @author Ragnarok
+ *
+ */
+public class Servlet extends GenericServlet {
+
+    /* (non-Javadoc)
+     * @see javax.servlet.Servlet#service(javax.servlet.ServletRequest, javax.servlet.ServletResponse)
+     */
+    public void service(ServletRequest request, ServletResponse response) {
+    }
+
+    /* (non-Javadoc)
+     * @see javax.servlet.Servlet#init(javax.servlet.ServletConfig)
+     */
+    public void init(ServletConfig config) {
+        try {
+            super.init(config);
+        } catch (ServletException exp) {
+        }
+        String[] args = new String[1];
+        args[0] = config.getInitParameter("home");
+        DaemonThread thread = new DaemonThread(args);
+        thread.setDaemon(true);
+        thread.start();
+        System.out.println("INFO: Starting Addressbook " + Daemon.VERSION);
+        System.out.println("INFO: config root under " + args[0]);
+    }
+
+}

apps/addressbook/java/src/addressbook/Subscription.java

@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) 2004 Ragnarok
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+package addressbook;
+
+/**
+ * A subscription to a remote address book.
+ * 
+ * @author Ragnarok
+ *  
+ */
+public class Subscription {
+
+    private String location;
+
+    private String etag;
+
+    private String lastModified;
+
+    /**
+     * Construct a Subscription pointing to the address book at location, that
+     * was last read at the time represented by etag and lastModified.
+     * 
+     * @param location
+     *            A String representing a url to a remote address book.
+     * @param etag
+     *            The etag header that we recieved the last time we read this
+     *            subscription.
+     * @param lastModified
+     *            the last-modified header we recieved the last time we read
+     *            this subscription.
+     */
+    public Subscription(String location, String etag, String lastModified) {
+        this.location = location;
+        this.etag = etag;
+        this.lastModified = lastModified;
+    }
+
+    /**
+     * Return the location this Subscription points at.
+     * 
+     * @return A String representing a url to a remote address book.
+     */
+    public String getLocation() {
+        return this.location;
+    }
+
+    /**
+     * Return the etag header that we recieved the last time we read this
+     * subscription.
+     * 
+     * @return A String containing the etag header.
+     */
+    public String getEtag() {
+        return this.etag;
+    }
+
+    /**
+     * Set the etag header.
+     * 
+     * @param etag
+     *            A String containing the etag header.
+     */
+    public void setEtag(String etag) {
+        this.etag = etag;
+    }
+
+    /**
+     * Return the last-modified header that we recieved the last time we read
+     * this subscription.
+     * 
+     * @return A String containing the last-modified header.
+     */
+    public String getLastModified() {
+        return this.lastModified;
+    }
+
+    /**
+     * Set the last-modified header.
+     * 
+     * @param lastModified
+     *            A String containing the last-modified header.
+     */
+    public void setLastModified(String lastModified) {
+        this.lastModified = lastModified;
+    }
+}

apps/addressbook/java/src/addressbook/SubscriptionIterator.java

@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2004 Ragnarok
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+package addressbook;
+
+import java.util.Iterator;
+import java.util.List;
+
+/**
+ * An iterator over the subscriptions in a SubscriptionList.  Note that this iterator
+ * returns AddressBook objects, and not Subscription objects.
+ * 
+ * @author Ragnarok
+ */
+public class SubscriptionIterator implements Iterator {
+
+    private Iterator subIterator;
+
+    /**
+     * Construct a SubscriptionIterator using the Subscriprions in List subscriptions.
+     * 
+     * @param subscriptions
+     *            List of Subscription objects that represent address books.
+     */
+    public SubscriptionIterator(List subscriptions) {
+        this.subIterator = subscriptions.iterator();
+    }
+
+    
+    /* (non-Javadoc)
+     * @see java.util.Iterator#hasNext()
+     */
+    public boolean hasNext() {
+        return subIterator.hasNext();
+    }
+
+    /* (non-Javadoc)
+     * @see java.util.Iterator#next()
+     */
+    public Object next() {
+        Subscription sub = (Subscription) subIterator.next();
+        return new AddressBook(sub);
+    }
+
+    /* (non-Javadoc)
+     * @see java.util.Iterator#remove()
+     */
+    public void remove() {
+        throw new UnsupportedOperationException();
+    }
+}

apps/addressbook/java/src/addressbook/SubscriptionList.java

@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) 2004 Ragnarok
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+package addressbook;
+
+import java.util.List;
+import java.util.LinkedList;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.io.File;
+import java.io.IOException;
+
+/**
+ * A list of Subscriptions loaded from a file.
+ * 
+ * @author Ragnarok
+ *  
+ */
+public class SubscriptionList {
+
+    private List subscriptions;
+
+    private File etagsFile;
+
+    private File lastModifiedFile;
+
+    /**
+     * Construct a SubscriptionList using the urls from locationsFile and, if
+     * available, the etags and last-modified headers loaded from etagsFile and
+     * lastModifiedFile.
+     * 
+     * @param locationsFile
+     *            A file containing one url on each line.
+     * @param etagsFile
+     *            A file containg the etag headers used for conditional GET. The
+     *            file is in the format "url=etag".
+     * @param lastModifiedFile
+     *            A file containg the last-modified headers used for conditional
+     *            GET. The file is in the format "url=leastmodified".
+     */
+    public SubscriptionList(File locationsFile, File etagsFile,
+            File lastModifiedFile, List defaultSubs) {
+        this.subscriptions = new LinkedList();
+        this.etagsFile = etagsFile;
+        this.lastModifiedFile = lastModifiedFile;
+        List locations;
+        Map etags;
+        Map lastModified;
+        String location;
+        locations = ConfigParser.parseSubscriptions(locationsFile, defaultSubs);
+        try {
+            etags = ConfigParser.parse(etagsFile);
+        } catch (IOException exp) {
+            etags = new HashMap();
+        }
+        try {
+            lastModified = ConfigParser.parse(lastModifiedFile);
+        } catch (IOException exp) {
+            lastModified = new HashMap();
+        }
+        Iterator iter = locations.iterator();
+        while (iter.hasNext()) {
+            location = (String) iter.next();
+            subscriptions.add(new Subscription(location, (String) etags
+                    .get(location), (String) lastModified.get(location)));
+        }
+
+        iter = this.iterator();
+    }
+    
+    /**
+     * Return an iterator over the AddressBooks represented by the Subscriptions
+     * in this SubscriptionList.
+     * 
+     * @return A SubscriptionIterator.
+     */
+    public SubscriptionIterator iterator() {
+        return new SubscriptionIterator(this.subscriptions);
+    }
+
+    /**
+     * Write the etag and last-modified headers for each Subscription to files.
+     */
+    public void write() {
+        Iterator iter = this.subscriptions.iterator();
+        Subscription sub;
+        Map etags = new HashMap();
+        Map lastModified = new HashMap();
+        while (iter.hasNext()) {
+            sub = (Subscription) iter.next();
+            if (sub.getEtag() != null) {
+                etags.put(sub.getLocation(), sub.getEtag());
+            }
+            if (sub.getLastModified() != null) {
+                lastModified.put(sub.getLocation(), sub.getLastModified());
+            }
+        }
+        try {
+            ConfigParser.write(etags, this.etagsFile);
+            ConfigParser.write(lastModified, this.lastModifiedFile);
+        } catch (IOException exp) {
+        }
+    }
+}

apps/addressbook/myhosts.txt

@@ -0,0 +1,10 @@
+# addressbook master address book.  Addresses placed in this file take precidence
+# over those in the router address book and in remote address books.  If changes
+# are made to this file, they will be reflected in the router address book and 
+# published address book after the next update.
+#
+# Do not make changes directly to the router address book, as they could be lost
+# during an update.
+#
+# This file takes addresses in the hosts.txt format, i.e.
+# example.i2p=somereallylongbase64thingAAAA

apps/addressbook/subscriptions.txt

@@ -0,0 +1,7 @@
+# Subscription list for addressbook
+#
+# Each entry is an absolute url to a file in hosts.txt format.
+# Since the list is checked in order, url's should be listed in order of trust.
+#
+http://dev.i2p/i2p/hosts.txt
+http://duck.i2p/hosts.txt

apps/addressbook/web.xml

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE web-app
+    PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.2//EN"
+    "http://java.sun.com/j2ee/dtds/web-app_2.2.dtd">
+
+<web-app>
+	<servlet>
+		<servlet-name>addressbook</servlet-name>
+		<servlet-class>addressbook.Servlet</servlet-class>
+		<init-param>
+		    <param-name>home</param-name>
+		    <param-value>./addressbook</param-value>
+		</init-param>
+		<load-on-startup>1</load-on-startup>
+	</servlet>
+</web-app>

apps/fortuna/build.xml

@@ -0,0 +1,106 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project basedir="." default="all" name="fortuna">
+
+	<property name="cvs.base.dir" value="java/gnu-crypto" />
+	<property name="cvs.etc.dir" value="${cvs.base.dir}/etc" />
+	<property name="cvs.lib.dir" value="${cvs.base.dir}/lib" />
+	<property name="cvs.object.dir" value="${cvs.base.dir}/classes" />
+	<property name="cvs.base.crypto.object.dir" value="${cvs.object.dir}/gnu/crypto" />
+	<property name="cvs.cipher.object.dir" value="${cvs.base.crypto.object.dir}/cipher" />
+	<property name="cvs.hash.object.dir" value="${cvs.base.crypto.object.dir}/hash" />
+	<property name="cvs.prng.object.dir" value="${cvs.base.crypto.object.dir}/prng" />
+
+	<patternset id="fortuna.files">
+		<include name="${cvs.base.crypto.object.dir}/Registry.class"/>
+		<include name="${cvs.prng.object.dir}/Fortuna*.class"/>
+		<include name="${cvs.prng.object.dir}/BasePRNG.class"/>
+		<include name="${cvs.prng.object.dir}/RandomEventListener.class"/>
+		<include name="${cvs.prng.object.dir}/IRandom.class"/>
+		<include name="${cvs.cipher.object.dir}/CipherFactory.class"/>
+		<include name="${cvs.cipher.object.dir}/IBlockCipher.class"/>
+		<include name="${cvs.hash.object.dir}/HashFactory.class"/>
+		<include name="${cvs.hash.object.dir}/IMessageDigest.class"/>
+	</patternset>
+
+	<target name="all" depends="build,jar" 
+		description="Create and test the custom Fortuna library" />
+
+	<target name="build" depends="-init,checkout"
+		description="Build the source and tests">
+		<ant dir="${cvs.base.dir}" target="jar" />
+	</target>
+
+	<target name="builddep" />
+
+	<target name="checkout" depends="-init" unless="cvs.source.available"
+		description="Check out GNU Crypto sources from CVS HEAD">
+		<cvs cvsRoot=":ext:anoncvs@savannah.gnu.org:/cvsroot/gnu-crypto"
+			cvsRsh="ssh"
+			dest="java"
+			package="gnu-crypto" />
+	</target>
+
+	<target name="clean"
+		description="Remove generated tests and object files">
+		<ant dir="${cvs.base.dir}" target="clean" />
+	</target>
+
+	<target name="cleandep" />
+
+	<target name="compile" />
+
+	<target name="distclean" depends="clean"
+		description="Remove all generated files">
+		<delete dir="build" />
+		<delete dir="jartemp" />
+		<!--
+			Annoyingly the GNU Crypto distclean task called here doesn't clean
+			*all* derived files from java/gnu-crypto/lib like it should.....
+		-->
+		<ant dir="${cvs.base.dir}" target="distclean" />
+		<!--
+			.....and so we mop up the rest ourselves.
+		-->
+		<delete dir="${cvs.lib.dir}" />
+	</target>
+
+	<target name="-init">
+		<available property="cvs.source.available" file="${cvs.base.dir}" />
+	</target>
+
+	<target name="jar" depends="build"
+		description="Create the custom Fortuna jar library">
+		<delete dir="build" />
+		<delete dir="jartemp" />
+		<mkdir dir="build" />
+		<mkdir dir="jartemp/${cvs.object.dir}" />
+		<copy todir="jartemp">
+			<fileset dir=".">
+				<patternset refid="fortuna.files" />
+			</fileset>
+		</copy>
+		<jar basedir="jartemp/${cvs.object.dir}" jarfile="build/fortuna.jar">
+			<manifest>
+				<section name="fortuna">
+					<attribute name="Implementation-Title" value="I2P Custom GNU Crypto Fortuna Library" />
+					<attribute name="Implementation-Version" value="CVS HEAD" /> 
+					<attribute name="Implementation-Vendor" value="Free Software Foundation" />
+					<attribute name="Implementation-Vendor-Id" value="FSF" />
+					<attribute name="Implementation-URL" value="http://www.gnu.org/software/gnu-crypto" />
+				</section>
+			</manifest>
+		</jar>
+		<delete dir="jartemp" />
+	</target>
+
+	<target name="test" depends="jar"
+		description="Perform crypto tests on custom Fortuna jar library" />
+		<!--
+			Add this when Fortuna tests are added to GNU Crypto, else write some
+		-->
+
+	<target name="update" depends="checkout"
+		description="Update GNU Crypto sources to latest CVS HEAD">
+		<cvs command="update -d" cvsRsh="ssh" dest="java/gnu-crypto" />
+	</target>
+</project>

apps/i2ptunnel/java/build.xml

@@ -31,6 +31,9 @@
         </war>
     </target>
     <target name="precompilejsp">
+        <delete dir="../jsp/WEB-INF/" />
+        <delete file="../jsp/web-fragment.xml" />
+        <delete file="../jsp/web-out.xml" />
         <mkdir dir="../jsp/WEB-INF/" />
         <mkdir dir="../jsp/WEB-INF/classes" />
         <!-- there are various jspc ant tasks, but they all seem a bit flakey -->
@@ -39,12 +42,13 @@
                 <pathelement location="../../jetty/jettylib/jasper-compiler.jar" />
                 <pathelement location="../../jetty/jettylib/jasper-runtime.jar" />
                 <pathelement location="../../jetty/jettylib/javax.servlet.jar" />
+                <pathelement location="../../jetty/jettylib/commons-logging.jar" />
+                <pathelement location="../../jetty/jettylib/commons-el.jar" />
                 <pathelement location="../../jetty/jettylib/ant.jar" />
                 <pathelement location="build/i2ptunnel.jar" />
             </classpath>
             <arg value="-d" />
             <arg value="../jsp/WEB-INF/classes" />
-            <arg value="-v9" />
             <arg value="-p" />
             <arg value="net.i2p.i2ptunnel.jsp" />
             <arg value="-webinc" />
@@ -52,10 +56,13 @@
             <arg value="-webapp" />
             <arg value="../jsp/" />
         </java>
-        <javac destdir="../jsp/WEB-INF/classes/" srcdir="../jsp/WEB-INF/classes" includes="*.java">
+        <javac debug="true" deprecation="on" source="1.3" target="1.3" 
+               destdir="../jsp/WEB-INF/classes/" srcdir="../jsp/WEB-INF/classes" includes="**/*.java">
             <classpath>
                 <pathelement location="../../jetty/jettylib/jasper-runtime.jar" />
                 <pathelement location="../../jetty/jettylib/javax.servlet.jar" />
+                <pathelement location="../../jetty/jettylib/commons-logging.jar" />
+                <pathelement location="../../jetty/jettylib/commons-el.jar" />
                 <pathelement location="build/i2ptunnel.jar" />
             </classpath>
         </javac>

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

@@ -0,0 +1,242 @@
+package net.i2p.i2ptunnel;
+/*
+ * free (adj.): unencumbered; not under the control of others
+ * Written by jrandom in 2005 and released into the public domain 
+ * with no warranty of any kind, either expressed or implied.  
+ * It probably won't make your computer catch on fire, or eat 
+ * your children, but it might.  Use at your own risk.
+ *
+ */
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.FilterOutputStream;
+import java.io.OutputStream;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import net.i2p.data.ByteArray;
+import net.i2p.util.ByteCache;
+import net.i2p.util.Log;
+
+/**
+ * Simple stream for delivering an HTTP response to
+ * the client, trivially filtered to make sure "Connection: close"
+ * is always in the response.
+ *
+ */
+class HTTPResponseOutputStream extends FilterOutputStream {
+    private static final Log _log = new Log(HTTPResponseOutputStream.class);
+    private ByteCache _cache;
+    protected ByteArray _headerBuffer;
+    private boolean _headerWritten;
+    private byte _buf1[];
+    private static final int CACHE_SIZE = 8*1024;
+    
+    public HTTPResponseOutputStream(OutputStream raw) {
+        super(raw);
+        _cache = ByteCache.getInstance(8, CACHE_SIZE);
+        _headerBuffer = _cache.acquire();
+        _headerWritten = false;
+        _buf1 = new byte[1];
+    }
+
+    public void write(int c) throws IOException {
+        _buf1[0] = (byte)c;
+        write(_buf1, 0, 1);
+    }
+    public void write(byte buf[]) throws IOException { 
+        write(buf, 0, buf.length); 
+    }
+    public void write(byte buf[], int off, int len) throws IOException {
+        if (_headerWritten) {
+            out.write(buf, off, len);
+            return;
+        }
+
+        for (int i = 0; i < len; i++) {
+            ensureCapacity();
+            _headerBuffer.getData()[_headerBuffer.getValid()] = buf[off+i];
+            _headerBuffer.setValid(_headerBuffer.getValid()+1);
+
+            if (headerReceived()) {
+                writeHeader();
+                _headerWritten = true;
+                if (i + 1 < len) // write out the remaining
+                    out.write(buf, off+i+1, len-i-1);
+                return;
+            }
+        }
+    }
+    
+    /** grow (and free) the buffer as necessary */
+    private void ensureCapacity() {
+        if (_headerBuffer.getValid() + 1 >= _headerBuffer.getData().length) {
+            int newSize = (int)(_headerBuffer.getData().length * 1.5);
+            ByteArray newBuf = new ByteArray(new byte[newSize]);
+            System.arraycopy(_headerBuffer.getData(), 0, newBuf.getData(), 0, _headerBuffer.getValid());
+            newBuf.setValid(_headerBuffer.getValid());
+            newBuf.setOffset(0);
+            if (_headerBuffer.getData().length == CACHE_SIZE)
+                _cache.release(_headerBuffer);
+            _headerBuffer = newBuf;
+        }
+    }
+    
+    /** are the headers finished? */
+    private boolean headerReceived() {
+        if (_headerBuffer.getValid() < 3) return false;
+        byte first = _headerBuffer.getData()[_headerBuffer.getValid()-3];
+        byte second = _headerBuffer.getData()[_headerBuffer.getValid()-2];
+        byte third = _headerBuffer.getData()[_headerBuffer.getValid()-1];
+        return (isNL(second) && isNL(third)) || //   \n\n
+               (isNL(first) && isNL(third));    // \n\r\n
+    }
+    
+    /**
+     * Tweak that first HTTP response line (HTTP 200 OK, etc)
+     *
+     */
+    protected String filterResponseLine(String line) {
+        return line;
+    }
+    
+    /** we ignore any potential \r, since we trim it on write anyway */
+    private static final byte NL = '\n';
+    private boolean isNL(byte b) { return (b == NL); }
+    
+    /** ok, received, now munge & write it */
+    private void writeHeader() throws IOException {
+        String responseLine = null;
+
+        boolean connectionSent = false;
+        boolean proxyConnectionSent = false;
+        
+        int lastEnd = -1;
+        for (int i = 0; i < _headerBuffer.getValid(); i++) {
+            if (isNL(_headerBuffer.getData()[i])) {
+                if (lastEnd == -1) {
+                    responseLine = new String(_headerBuffer.getData(), 0, i+1); // includes NL
+                    responseLine = filterResponseLine(responseLine);
+                    responseLine = (responseLine.trim() + "\n");
+                    out.write(responseLine.getBytes());
+                } else {
+                    for (int j = lastEnd+1; j < i; j++) {
+                        if (_headerBuffer.getData()[j] == ':') {
+                            int keyLen = j-(lastEnd+1);
+                            int valLen = i-(j+2);
+                            if ( (keyLen <= 0) || (valLen <= 0) )
+                                throw new IOException("Invalid header @ " + j);
+                            String key = new String(_headerBuffer.getData(), lastEnd+1, keyLen);
+                            String val = new String(_headerBuffer.getData(), j+2, valLen);
+                            
+                            if ("Connection".equalsIgnoreCase(key)) {
+                                out.write("Connection: close\n".getBytes());
+                                connectionSent = true;
+                            } else if ("Proxy-Connection".equalsIgnoreCase(key)) {
+                                out.write("Proxy-Connection: close\n".getBytes());
+                                proxyConnectionSent = true;
+                            } else {
+                                out.write((key.trim() + ": " + val.trim() + "\n").getBytes());
+                            }
+                            break;
+                        }
+                    }
+                }
+                lastEnd = i;
+            }
+        }
+        
+        if (!connectionSent)
+            out.write("Connection: close\n".getBytes());
+        if (!proxyConnectionSent)
+            out.write("Proxy-Connection: close\n".getBytes());
+            
+        out.write("\n".getBytes()); // end of the headers
+        
+        // done, shove off
+        if (_headerBuffer.getData().length == CACHE_SIZE)
+            _cache.release(_headerBuffer);
+        else
+            _headerBuffer = null;
+    }
+    
+    public static void main(String args[]) {
+        String simple   = "HTTP/1.1 200 OK\n" +
+                          "foo: bar\n" +
+                          "baz: bat\n" +
+                          "\n" +
+                          "hi ho, this is the body";
+        String filtered = "HTTP/1.1 200 OK\n" +
+                          "Connection: keep-alive\n" +
+                          "foo: bar\n" +
+                          "baz: bat\n" +
+                          "\n" +
+                          "hi ho, this is the body";
+        String winfilter= "HTTP/1.1 200 OK\r\n" +
+                          "Connection: keep-alive\r\n" +
+                          "foo: bar\r\n" +
+                          "baz: bat\r\n" +
+                          "\r\n" +
+                          "hi ho, this is the body";
+        String minimal  = "HTTP/1.1 200 OK\n" +
+                          "\n" +
+                          "hi ho, this is the body";
+        String winmin   = "HTTP/1.1 200 OK\r\n" +
+                          "\r\n" +
+                          "hi ho, this is the body";
+        String invalid1 = "HTTP/1.1 200 OK\n";
+        String invalid2 = "HTTP/1.1 200 OK";
+        String invalid3 = "HTTP 200 OK\r\n";
+        String invalid4 = "HTTP 200 OK\r";
+        String invalid5 = "HTTP/1.1 200 OK\r\n" +
+                          "I am broken, and I smell\r\n" +
+                          "\r\n";
+        String invalid6 = "HTTP/1.1 200 OK\r\n" +
+                          ":I am broken, and I smell\r\n" +
+                          "\r\n";
+        String invalid7 = "HTTP/1.1 200 OK\n" +
+                          "I am broken, and I smell:\n" +
+                          ":asdf\n" +
+                          ":\n" +
+                          "\n";
+        String large    = "HTTP/1.1 200 OK\n" +
+                          "Last-modified: Tue, 25 Nov 2003 12:05:38 GMT\n" +
+                          "Expires: Tue, 25 Nov 2003 12:05:38 GMT\n" +
+                          "Content-length: 32\n" +
+                          "\n" +
+                          "hi ho, this is the body";
+        /* */
+        test("Simple", simple, true);
+        test("Filtered", filtered, true);
+        test("Filtered windows", winfilter, true);
+        test("Minimal", minimal, true);
+        test("Windows", winmin, true);
+        test("Large", large, true);
+        test("Invalid (short headers)", invalid1, true);
+        test("Invalid (no headers)", invalid2, true);
+        test("Invalid (windows with short headers)", invalid3, true);
+        test("Invalid (windows no headers)", invalid4, true);
+        test("Invalid (bad headers)", invalid5, true);
+        test("Invalid (bad headers2)", invalid6, false);
+        test("Invalid (bad headers3)", invalid7, false);
+        /* */
+    }
+    
+    private static void test(String name, String orig, boolean shouldPass) {
+        System.out.println("====Testing: " + name + "\n" + orig + "\n------------");
+        try {
+            ByteArrayOutputStream baos = new ByteArrayOutputStream(4096);
+            HTTPResponseOutputStream resp = new HTTPResponseOutputStream(baos);
+            resp.write(orig.getBytes());
+            resp.flush();
+            String received = new String(baos.toByteArray());
+            System.out.println(received);
+        } catch (Exception e) {
+            if (shouldPass)
+                e.printStackTrace();
+            else
+                System.out.println("Properly fails with " + e.getMessage());
+        }
+    }
+}

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

@@ -183,7 +183,8 @@ public class I2PTunnel implements Logging, EventDispatcher {
     void addSession(I2PSession session) { 
         if (session == null) return;
         synchronized (_sessions) {
-            _sessions.add(session);
+            if (!_sessions.contains(session))
+                _sessions.add(session);
         }
     }
     void removeSession(I2PSession session) { 
@@ -229,6 +230,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 +284,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 +374,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/I2PTunnelClientBase.java

@@ -18,7 +18,6 @@ import java.util.Properties;
 
 import net.i2p.I2PException;
 import net.i2p.client.I2PSession;
-import net.i2p.client.I2PSessionException;
 import net.i2p.client.streaming.I2PSocket;
 import net.i2p.client.streaming.I2PSocketManager;
 import net.i2p.client.streaming.I2PSocketManagerFactory;
@@ -26,6 +25,7 @@ import net.i2p.client.streaming.I2PSocketOptions;
 import net.i2p.data.Destination;
 import net.i2p.util.EventDispatcher;
 import net.i2p.util.I2PThread;
+import net.i2p.util.SimpleTimer;
 import net.i2p.util.Log;
 
 public abstract class I2PTunnelClientBase extends I2PTunnelTask implements Runnable {
@@ -58,7 +58,30 @@ public abstract class I2PTunnelClientBase extends I2PTunnelTask implements Runna
     private String handlerName;
 
     private Object conLock = new Object();
-    private int pendingConnections = 0;
+    
+    /** List of Socket for those accept()ed but not yet started up */
+    private List _waitingSockets;
+    /** How many connections will we allow to be in the process of being built at once? */
+    private int _numConnectionBuilders;
+    /** How long will we allow sockets to sit in the _waitingSockets map before killing them? */
+    private int _maxWaitTime;
+    
+    /**
+     * How many concurrent connections this I2PTunnel instance will allow to be 
+     * in the process of connecting (or if less than 1, there is no limit)?
+     */
+    public static final String PROP_NUM_CONNECTION_BUILDERS = "i2ptunnel.numConnectionBuilders";
+    /**
+     * How long will we let a socket wait after being accept()ed without getting
+     * pumped through a connection builder (in milliseconds).  If this time is 
+     * reached, the socket is unceremoniously closed and discarded.  If the max 
+     * wait time is less than 1, there is no limit.
+     *
+     */
+    public static final String PROP_MAX_WAIT_TIME = "i2ptunnel.maxWaitTime";
+    
+    private static final int DEFAULT_NUM_CONNECTION_BUILDERS = 5;
+    private static final int DEFAULT_MAX_WAIT_TIME = 30*1000;
     
     //public I2PTunnelClientBase(int localPort, boolean ownDest,
     //		       Logging l) {
@@ -78,11 +101,17 @@ public abstract class I2PTunnelClientBase extends I2PTunnelTask implements Runna
         this.l = l;
         this.handlerName = handlerName + _clientId;
 
-        synchronized (sockLock) {
-            if (ownDest) {
-                sockMgr = buildSocketManager();
-            } else {
-                sockMgr = getSocketManager();
+        while (sockMgr == null) {
+            synchronized (sockLock) {
+                if (ownDest) {
+                    sockMgr = buildSocketManager();
+                } else {
+                    sockMgr = getSocketManager();
+                }
+            }
+            if (sockMgr == null) {
+                _log.log(Log.CRIT, "Unable to create socket manager");
+                try { Thread.sleep(10*1000); } catch (InterruptedException ie) {}
             }
         }
         if (sockMgr == null) {
@@ -108,6 +137,8 @@ public abstract class I2PTunnelClientBase extends I2PTunnelTask implements Runna
             }
         }
 
+        configurePool(tunnel);
+        
         if (open && listenerReady) {
             l.log("Ready! Port " + getLocalPort());
             notifyEvent("openBaseClientResult", "ok");
@@ -116,6 +147,37 @@ public abstract class I2PTunnelClientBase extends I2PTunnelTask implements Runna
             notifyEvent("openBaseClientResult", "error");
         }
     }
+    
+    /** 
+     * build and configure the pool handling accept()ed but not yet 
+     * established connections 
+     *
+     */
+    private void configurePool(I2PTunnel tunnel) {
+        _waitingSockets = new ArrayList(4);
+        
+        Properties opts = tunnel.getClientOptions();
+        String maxWait = opts.getProperty(PROP_MAX_WAIT_TIME, DEFAULT_MAX_WAIT_TIME+"");
+        try { 
+            _maxWaitTime = Integer.parseInt(maxWait); 
+        } catch (NumberFormatException nfe) {
+            _maxWaitTime = DEFAULT_MAX_WAIT_TIME;
+        }
+        
+        String numBuild = opts.getProperty(PROP_NUM_CONNECTION_BUILDERS, DEFAULT_NUM_CONNECTION_BUILDERS+"");
+        try {
+            _numConnectionBuilders = Integer.parseInt(numBuild);
+        } catch (NumberFormatException nfe) {
+            _numConnectionBuilders = DEFAULT_NUM_CONNECTION_BUILDERS;
+        }
+
+        for (int i = 0; i < _numConnectionBuilders; i++) {
+            String name = "ClientBuilder" + _clientId + '.' + i;
+            I2PThread b = new I2PThread(new TunnelConnectionBuilder(), name);
+            b.setDaemon(true);
+            b.start();
+        }
+    }
 
     private static I2PSocketManager socketManager;
 
@@ -250,6 +312,7 @@ public abstract class I2PTunnelClientBase extends I2PTunnelTask implements Runna
                 synchronized (this) {
                     notifyAll();
                 }
+                synchronized (_waitingSockets) { _waitingSockets.notifyAll(); }
                 return;
             }
             ss = new ServerSocket(localPort, 0, addr);
@@ -292,6 +355,9 @@ public abstract class I2PTunnelClientBase extends I2PTunnelTask implements Runna
                 notifyAll();
             }
         }
+        synchronized (_waitingSockets) {
+            _waitingSockets.notifyAll();
+        }
     }
 
     /**
@@ -300,16 +366,52 @@ public abstract class I2PTunnelClientBase extends I2PTunnelTask implements Runna
      * @param s Socket to take care of
      */
     protected void manageConnection(Socket s) {
-        boolean useBlocking = false;
-        synchronized (conLock) {
-            pendingConnections++;
-            if (pendingConnections > 5)
-                useBlocking = true;
+        if (s == null) return;
+        if (_numConnectionBuilders <= 0) {
+            new I2PThread(new BlockingRunner(s), "Clinet run").start();
+            return;
+        }
+        
+        if (_maxWaitTime > 0)
+            SimpleTimer.getInstance().addEvent(new CloseEvent(s), _maxWaitTime);
+
+        synchronized (_waitingSockets) {
+            _waitingSockets.add(s);
+            _waitingSockets.notifyAll();
+        }
+    }
+
+    /** 
+     * Blocking runner, used during the connection establishment whenever we
+     * are not using the queued builders.
+     *
+     */
+    private class BlockingRunner implements Runnable {
+        private Socket _s;
+        public BlockingRunner(Socket s) { _s = s; }
+        public void run() {
+            clientConnectionRun(_s);
+        }
+    }
+    
+    /**
+     * Remove and close the socket from the waiting list, if it is still there.
+     *
+     */
+    private class CloseEvent implements SimpleTimer.TimedEvent {
+        private Socket _s;
+        public CloseEvent(Socket s) { _s = s; }
+        public void timeReached() {
+            boolean stillWaiting = false;
+            synchronized (_waitingSockets) {
+                stillWaiting = _waitingSockets.remove(_s);
+            }
+            if (stillWaiting) {
+                try { _s.close(); } catch (IOException ioe) {}
+                if (_log.shouldLog(Log.INFO))
+                    _log.info("Closed a waiting socket because of backlog");
+            }
         }
-        if (useBlocking)
-            clientConnectionRun(s);
-        else
-            new ClientConnectionRunner(s, handlerName);
     }
 
     public boolean close(boolean forced) {
@@ -341,8 +443,10 @@ public abstract class I2PTunnelClientBase extends I2PTunnelTask implements Runna
             }
             l.log("Client closed.");
             open = false;
-            return true;
         }
+        
+        synchronized (_waitingSockets) { _waitingSockets.notifyAll(); }
+        return true;
     }
 
     public static void closeSocket(Socket s) {
@@ -352,22 +456,29 @@ public abstract class I2PTunnelClientBase extends I2PTunnelTask implements Runna
             _log.error("Could not close socket", ex);
         }
     }
-
-    private static volatile long __runnerId = 0;
     
-    public class ClientConnectionRunner extends I2PThread {
-        private Socket s;
-
-        public ClientConnectionRunner(Socket s, String name) {
-            this.s = s;
-            setName(name + '.' + (++__runnerId));
-            start();
-        }
-
-        public void run() {
-            clientConnectionRun(s);
-            synchronized (conLock) {
-                pendingConnections--;
+    /**
+     * Pool runner pulling sockets off the waiting list and pushing them
+     * through clientConnectionRun.  This dies when the I2PTunnel instance
+     * is closed.
+     *
+     */
+    private class TunnelConnectionBuilder implements Runnable {
+        public void run() { 
+            Socket s = null;
+            while (open) {
+                try {
+                    synchronized (_waitingSockets) {
+                        if (_waitingSockets.size() <= 0)
+                            _waitingSockets.wait();
+                        else
+                            s = (Socket)_waitingSockets.remove(0);
+                    }
+                } catch (InterruptedException ie) {}
+                
+                if (s != null)
+                    clientConnectionRun(s);
+                s = null;
             }
         }
     }

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

@@ -22,9 +22,7 @@ import net.i2p.client.streaming.I2PSocket;
 import net.i2p.client.streaming.I2PSocketOptions;
 import net.i2p.data.DataFormatException;
 import net.i2p.data.Destination;
-import net.i2p.util.Clock;
 import net.i2p.util.EventDispatcher;
-import net.i2p.util.I2PThread;
 import net.i2p.util.Log;
 
 /**
@@ -147,7 +145,6 @@ public class I2PTunnelHTTPClient extends I2PTunnelClientBase implements Runnable
 
     private static final int DEFAULT_READ_TIMEOUT = 60*1000;
     
-    
     /** 
      * create the default options (using the default timeout, etc)
      *
@@ -156,8 +153,8 @@ public class I2PTunnelHTTPClient extends I2PTunnelClientBase implements Runnable
         Properties defaultOpts = getTunnel().getClientOptions();
         if (!defaultOpts.contains(I2PSocketOptions.PROP_READ_TIMEOUT))
             defaultOpts.setProperty(I2PSocketOptions.PROP_READ_TIMEOUT, ""+DEFAULT_READ_TIMEOUT);
-        if (!defaultOpts.contains("i2p.streaming.inactivityTimeout"))
-            defaultOpts.setProperty("i2p.streaming.inactivityTimeout", ""+DEFAULT_READ_TIMEOUT);
+        //if (!defaultOpts.contains("i2p.streaming.inactivityTimeout"))
+        //    defaultOpts.setProperty("i2p.streaming.inactivityTimeout", ""+DEFAULT_READ_TIMEOUT);
         I2PSocketOptions opts = sockMgr.buildOptions(defaultOpts);
         if (!defaultOpts.containsKey(I2PSocketOptions.PROP_CONNECT_TIMEOUT))
             opts.setConnectTimeout(DEFAULT_CONNECT_TIMEOUT);
@@ -197,9 +194,10 @@ public class I2PTunnelHTTPClient extends I2PTunnelClientBase implements Runnable
                 if (_log.shouldLog(Log.DEBUG))
                     _log.debug(getPrefix(requestId) + "Line=[" + line + "]");
                 
-                if (line.startsWith("Connection: ") || 
-                    line.startsWith("Keep-Alive: ") || 
-                    line.startsWith("Proxy-Connection: "))
+                String lowercaseLine = line.toLowerCase();
+                if (lowercaseLine.startsWith("connection: ") || 
+                    lowercaseLine.startsWith("keep-alive: ") || 
+                    lowercaseLine.startsWith("proxy-connection: "))
                     continue;
                 
                 if (method == null) { // first line (GET /base64/realaddr)
@@ -212,7 +210,18 @@ public class I2PTunnelHTTPClient extends I2PTunnelClientBase implements Runnable
                     String request = line.substring(pos + 1);
                     if (request.startsWith("/") && getTunnel().getClientOptions().getProperty("i2ptunnel.noproxy") != null) {
                         request = "http://i2p" + request;
+                    } else if (request.startsWith("/eepproxy/")) {
+                        // /eepproxy/foo.i2p/bar/baz.html HTTP/1.0
+                        String subRequest = request.substring("/eepproxy/".length());
+                        int protopos = subRequest.indexOf(" ");
+                        String uri = subRequest.substring(0, protopos);
+                        if (uri.indexOf("/") == -1) {
+                                uri = uri + "/";
+                        }
+                        // "http://" + "foo.i2p/bar/baz.html" + " HTTP/1.0"
+                        request = "http://" + uri + subRequest.substring(protopos);
                     }
+
                     pos = request.indexOf("//");
                     if (pos == -1) {
                         method = null;
@@ -327,29 +336,29 @@ public class I2PTunnelHTTPClient extends I2PTunnelClientBase implements Runnable
                     }
                     
                 } else {
-                    if (line.startsWith("Host: ") && !usingWWWProxy) {
+                    if (lowercaseLine.startsWith("host: ") && !usingWWWProxy) {
                         line = "Host: " + host;
                         if (_log.shouldLog(Log.INFO)) 
                             _log.info(getPrefix(requestId) + "Setting host = " + host);
-                    } else if (line.startsWith("User-Agent: ")) {
+                    } else if (lowercaseLine.startsWith("user-agent: ")) {
                         // always stripped, added back at the end
                         line = null;
                         continue;
-                    } else if (line.startsWith("Accept")) {
+                    } else if (lowercaseLine.startsWith("accept")) {
                         // strip the accept-blah headers, as they vary dramatically from
                         // browser to browser
                         line = null;
                         continue;
-                    } else if (line.startsWith("Referer: ")) {
+                    } else if (lowercaseLine.startsWith("referer: ")) {
                         // Shouldn't we be more specific, like accepting in-site referers ?
                         //line = "Referer: i2p";
                         line = null;
                         continue; // completely strip the line
-                    } else if (line.startsWith("Via: ")) {
+                    } else if (lowercaseLine.startsWith("via: ")) {
                         //line = "Via: i2p";
                         line = null;
                         continue; // completely strip the line
-                    } else if (line.startsWith("From: ")) {
+                    } else if (lowercaseLine.startsWith("from: ")) {
                         //line = "From: i2p";
                         line = null;
                         continue; // completely strip the line
@@ -407,7 +416,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 I2PTunnelHTTPClientRunner(s, i2ps, sockLock, data, mySockets, onTimeout);
         } catch (SocketException ex) {
             _log.info(getPrefix(requestId) + "Error trying to connect", ex);
             l.log(ex.getMessage());
@@ -437,6 +447,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/I2PTunnelHTTPClientRunner.java

@@ -0,0 +1,41 @@
+/* I2PTunnel is GPL'ed (with the exception mentioned in I2PTunnel.java)
+ * (c) 2003 - 2004 mihi
+ */
+package net.i2p.i2ptunnel;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.FilterOutputStream;
+import java.net.Socket;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Properties;
+
+import net.i2p.client.streaming.I2PSocket;
+import net.i2p.data.ByteArray;
+import net.i2p.data.DataHelper;
+import net.i2p.util.ByteCache;
+import net.i2p.util.Log;
+
+/**
+ * Override the response with a stream filtering the HTTP headers
+ * received.  Specifically, this makes sure we get Connection: close,
+ * so the browser knows they really shouldn't try to use persistent
+ * connections.  The HTTP server *should* already be setting this, 
+ * since the HTTP headers sent by the browser specify Connection: close,
+ * and the server should echo it.  However, both broken and malicious
+ * servers could ignore that, potentially confusing the user.
+ *
+ */
+public class I2PTunnelHTTPClientRunner extends I2PTunnelRunner {
+    public I2PTunnelHTTPClientRunner(Socket s, I2PSocket i2ps, Object slock, byte[] initialI2PData, List sockList, Runnable onTimeout) {
+        super(s, i2ps, slock, initialI2PData, sockList, onTimeout);
+    }
+
+    protected OutputStream getSocketOut() throws IOException { 
+        OutputStream raw = super.getSocketOut();
+        return new HTTPResponseOutputStream(raw);
+    }
+}

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

@@ -0,0 +1,160 @@
+/* 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.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.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

@@ -3,7 +3,6 @@
  */
 package net.i2p.i2ptunnel;
 
-import java.io.BufferedOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InterruptedIOException;
@@ -31,7 +30,7 @@ public class I2PTunnelRunner extends I2PThread implements I2PSocket.SocketErrorL
      * Sun's impl of BufferedOutputStream), but that is the streaming
      * api's job...
      */
-    static int MAX_PACKET_SIZE = 1024 * 32;
+    static int MAX_PACKET_SIZE = 1024 * 4;
 
     static final int NETWORK_BUFFER_SIZE = MAX_PACKET_SIZE;
 
@@ -40,21 +39,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))
@@ -96,25 +111,31 @@ public class I2PTunnelRunner extends I2PThread implements I2PSocket.SocketErrorL
         return startedOn;
     }
 
+    protected InputStream getSocketIn() throws IOException { return s.getInputStream(); }
+    protected OutputStream getSocketOut() throws IOException { return s.getOutputStream(); }
+    
     public void run() {
-        boolean closedCleanly = false;
         try {
-            InputStream in = s.getInputStream();
-            OutputStream out = s.getOutputStream(); // = new BufferedOutputStream(s.getOutputStream(), NETWORK_BUFFER_SIZE);
+            InputStream in = getSocketIn();
+            OutputStream out = getSocketOut(); // = 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 +143,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 +170,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,13 +210,15 @@ 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;
-            _cache = ByteCache.getInstance(256, NETWORK_BUFFER_SIZE);
+            _toI2P = toI2P;
+            direction = (toI2P ? "toI2P" : "fromI2P");
+            _cache = ByteCache.getInstance(32, NETWORK_BUFFER_SIZE);
             setName("StreamForwarder " + _runnerId + "." + (++__forwarderId));
             start();
         }
@@ -207,6 +238,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();
 
@@ -242,12 +277,13 @@ public class I2PTunnelRunner extends I2PThread implements I2PSocket.SocketErrorL
                               + ex.getMessage() + "\")");
             } catch (IOException ex) {
                 if (!finished) {
-                    if (_log.shouldLog(Log.ERROR))
-                        _log.error(direction + ": Error forwarding", ex);
+                    if (_log.shouldLog(Log.WARN))
+                        _log.warn(direction + ": Error forwarding", ex);
                 }
                 //else
                 //    _log.warn("You may ignore this", ex);
             } finally {
+                _cache.release(ba);
                 if (_log.shouldLog(Log.INFO)) {
                     _log.info(direction + ": done forwarding between " 
                               + from + " and " + to);
@@ -259,17 +295,16 @@ 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;
                     finishLock.notifyAll();
                     // the main thread will close sockets etc. now
                 }
-                _cache.release(ba);
             }
         }
     }

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);
@@ -74,10 +75,16 @@ public class I2PTunnelServer extends I2PTunnelTask implements Runnable {
         I2PClient client = I2PClientFactory.createClient();
         Properties props = new Properties();
         props.putAll(getTunnel().getClientOptions());
-        synchronized (slock) {
-            sockMgr = I2PSocketManagerFactory.createManager(privData, getTunnel().host, Integer.parseInt(getTunnel().port),
-                                                            props);
+        while (sockMgr == null) {
+            synchronized (slock) {
+                sockMgr = I2PSocketManagerFactory.createManager(privData, getTunnel().host, Integer.parseInt(getTunnel().port),
+                                                                props);
 
+            }
+            if (sockMgr == null) {
+                _log.log(Log.CRIT, "Unable to create socket manager");
+                try { Thread.sleep(10*1000); } catch (InterruptedException ie) {}
+            }
         }
         sockMgr.setName("Server");
         getTunnel().addSession(sockMgr.getSession());

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

@@ -16,6 +16,7 @@ import net.i2p.client.I2PClient;
 import net.i2p.client.I2PClientFactory;
 import net.i2p.client.I2PSession;
 import net.i2p.data.Destination;
+import net.i2p.util.I2PThread;
 import net.i2p.util.Log;
 
 /**
@@ -57,7 +58,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();
     }
@@ -99,6 +100,12 @@ public class TunnelController implements Logging {
         }
     }
     
+    public void startTunnelBackground() {
+        if (_running) return;
+        _starting = true;
+        new I2PThread(new Runnable() { public void run() { startTunnel(); } }).start();
+    }
+    
     /**
      * Start up the tunnel (if it isn't already running)
      *
@@ -132,6 +139,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 +215,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 +254,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 +318,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 +336,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 +391,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 +414,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/TunnelControllerGroup.java

@@ -1,12 +1,8 @@
 package net.i2p.i2ptunnel;
 
-import java.io.BufferedReader;
 import java.io.File;
-import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
-import java.io.InputStreamReader;
-
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
@@ -180,7 +176,7 @@ public class TunnelControllerGroup {
         List msgs = new ArrayList();
         for (int i = 0; i < _controllers.size(); i++) {
             TunnelController controller = (TunnelController)_controllers.get(i);
-            controller.startTunnel();
+            controller.startTunnelBackground();
             msgs.addAll(controller.clearMessages());
         }
 

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

@@ -1,7 +1,5 @@
 package net.i2p.i2ptunnel;
 
-import java.io.File;
-
 import java.util.Iterator;
 import java.util.Properties;
 import java.util.Random;
@@ -18,6 +16,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 +41,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 + "]";
     }
@@ -60,6 +61,8 @@ class WebEditPageFormGenerator {
             buf.append("value=\"squid.i2p\" ");
         buf.append("/><br />\n");
         
+        addStreamingOptions(buf, controller);
+        
         buf.append("<hr />Note: the following options are shared across all client tunnels and");
         buf.append(" HTTP proxies<br />\n");
         
@@ -83,6 +86,8 @@ class WebEditPageFormGenerator {
             buf.append("value=\"").append(controller.getTargetDestination()).append("\" ");
         buf.append(" /> (either the hosts.txt name or the full base64 destination)<br />\n");
         
+        addStreamingOptions(buf, controller);
+        
         buf.append("<hr />Note: the following options are shared across all client tunnels and");
         buf.append(" HTTP proxies<br />\n");
         
@@ -103,7 +108,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\" ");
@@ -121,6 +126,52 @@ class WebEditPageFormGenerator {
             buf.append("<input type=\"hidden\" name=\"privKeyGenerate\" value=\"true\" />");
         }
         
+        addStreamingOptions(buf, controller);
+        
+        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();
+    }
+    
+    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\" />");
+        }
+        
+        addStreamingOptions(buf, controller);
+        
         addOptions(buf, controller);
         buf.append("<input type=\"submit\" name=\"action\" value=\"Save\">\n");
         buf.append("<input type=\"submit\" name=\"action\" value=\"Remove\">\n");
@@ -141,6 +192,9 @@ class WebEditPageFormGenerator {
         buf.append("<form action=\"edit.jsp\">");
         if (id != null)
             buf.append("<input type=\"hidden\" name=\"num\" value=\"").append(id).append("\" />");
+        long nonce = new Random().nextLong();
+        System.setProperty(WebEditPageHelper.class.getName() + ".nonce", nonce+"");
+        buf.append("<input type=\"hidden\" name=\"nonce\" value=\"").append(nonce).append("\" />");
             
         buf.append("<b>Name:</b> <input type=\"text\" name=\"name\" size=\"20\" ");
         if ( (controller != null) && (controller.getName() != null) )
@@ -158,8 +212,9 @@ class WebEditPageFormGenerator {
             buf.append(" checked=\"true\" />\n<br />\n");
         else
             buf.append(" />\n<br />\n");
+       
     }
-
+    
     /**
      * Generate the fields asking for what port and interface the tunnel should 
      * listen on.
@@ -197,6 +252,46 @@ class WebEditPageFormGenerator {
         buf.append("\"><br />\n");
     }
     
+    private static void addStreamingOptions(StringBuffer buf, TunnelController controller) {
+        int connectDelay = 0;
+        int maxWindowSize = -1;
+
+        Properties opts = getOptions(controller);
+        if (opts != null) {
+            String delay = opts.getProperty("i2p.streaming.connectDelay");
+            if (delay != null) {
+                try {
+                    connectDelay = Integer.parseInt(delay);
+                } catch (NumberFormatException nfe) {
+                    connectDelay = 0;
+                }
+            }
+            String max = opts.getProperty("i2p.streaming.maxWindowSize");
+            if (max != null) {
+                try {
+                    maxWindowSize = Integer.parseInt(max);
+                } catch (NumberFormatException nfe) {
+                    maxWindowSize = -1;
+                }
+            }
+        }
+        
+        buf.append("<b>Delay connection briefly? </b> ");
+        buf.append("<input type=\"checkbox\" name=\"connectDelay\" value=\"");
+        buf.append((connectDelay > 0 ? connectDelay : 1000)).append("\" ");
+        if (connectDelay > 0)
+            buf.append("checked=\"true\" ");
+        buf.append("/> (useful for brief request/response connections)<br />\n");
+        
+        buf.append("<b>Communication profile:</b>");
+        buf.append("<select name=\"profile\">");
+        if (maxWindowSize <= 0)
+            buf.append("<option value=\"interactive\">Interactive</option><option value=\"bulk\" selected=\"true\">Bulk</option>");
+        else
+            buf.append("<option value=\"interactive\" selected=\"true\">Interactive</option><option value=\"bulk\">Bulk</option>");
+        buf.append("</select><br />\n");
+    }
+
     /**
      * Add fields for customizing the I2PSession options, including helpers for
      * tunnel depth and count, as well as I2CP host and port.
@@ -207,10 +302,9 @@ class WebEditPageFormGenerator {
     private static void addOptions(StringBuffer buf, TunnelController controller) {
         int tunnelDepth = 2;
         int numTunnels = 2;
-        int connectDelay = 0;
         Properties opts = getOptions(controller);
         if (opts != null) {
-            String depth = opts.getProperty("tunnels.depthInbound");
+            String depth = opts.getProperty("inbound.length");
             if (depth != null) {
                 try {
                     tunnelDepth = Integer.parseInt(depth);
@@ -218,7 +312,7 @@ class WebEditPageFormGenerator {
                     tunnelDepth = 2;
                 }
             }
-            String num = opts.getProperty("tunnels.numInbound");
+            String num = opts.getProperty("inbound.quantity");
             if (num != null) {
                 try {
                     numTunnels = Integer.parseInt(num);
@@ -226,14 +320,6 @@ class WebEditPageFormGenerator {
                     numTunnels = 2;
                 }
             }
-            String delay = opts.getProperty("i2p.streaming.connectDelay");
-            if (delay != null) {
-                try {
-                    connectDelay = Integer.parseInt(delay);
-                } catch (NumberFormatException nfe) {
-                    connectDelay = 0;
-                }
-            }
         }
         
         buf.append("<b>Tunnel depth:</b> ");
@@ -273,19 +359,12 @@ class WebEditPageFormGenerator {
         }
         buf.append("</select><br />\n");
         
-        buf.append("<b>Delay connection briefly? </b> ");
-        buf.append("<input type=\"checkbox\" name=\"connectDelay\" value=\"");
-        buf.append((connectDelay > 0 ? connectDelay : 1000)).append("\" ");
-        if (connectDelay > 0)
-            buf.append("checked=\"true\" ");
-        buf.append("/> (useful for brief request/response connections)<br />\n");
-        
         buf.append("<b>I2CP host:</b> ");
         buf.append("<input type=\"text\" name=\"clientHost\" size=\"20\" value=\"");
         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=\"");
@@ -302,9 +381,14 @@ class WebEditPageFormGenerator {
             for (Iterator iter = opts.keySet().iterator(); iter.hasNext(); ) {
                 String key = (String)iter.next();
                 String val = opts.getProperty(key);
-                if ("tunnels.depthInbound".equals(key)) continue;
-                if ("tunnels.numInbound".equals(key)) continue;
+                if ("inbound.length".equals(key)) continue;
+                if ("outbound.length".equals(key)) continue;
+                if ("inbound.quantity".equals(key)) continue;
+                if ("outbound.quantity".equals(key)) continue;
+                if ("inbound.nickname".equals(key)) continue;
+                if ("outbound.nickname".equals(key)) continue;
                 if ("i2p.streaming.connectDelay".equals(key)) continue;
+                if ("i2p.streaming.maxWindowSize".equals(key)) continue;
                 if (i != 0) buf.append(' ');
                 buf.append(key).append('=').append(val);
                 i++;

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

@@ -38,10 +38,13 @@ public class WebEditPageHelper {
     private String _targetDestination;
     private String _targetHost;
     private String _targetPort;
+    private String _spoofedHost;
     private String _privKeyFile;
+    private String _profile;
     private boolean _startOnLoad;
     private boolean _privKeyGenerate;
     private boolean _removeConfirmed;
+    private long _nonce;
     
     public WebEditPageHelper() {
         _action = null;
@@ -51,6 +54,14 @@ public class WebEditPageHelper {
         _log = I2PAppContext.getGlobalContext().logManager().getLog(WebEditPageHelper.class);
     }
     
+    public void setNonce(String nonce) {
+        if (nonce != null) {
+            try { 
+                _nonce = Long.parseLong(nonce); 
+            } catch (NumberFormatException nfe) {}
+        }
+    }
+    
     /**
      * Used for form submit - either "Save" or Remove"
      */
@@ -139,6 +150,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);
@@ -168,6 +183,9 @@ public class WebEditPageHelper {
     public void setConnectDelay(String moo) {
         _connectDelay = true;
     }
+    public void setProfile(String profile) { 
+        _profile = profile; 
+    }
     
     /**
      * Process the form and display any resulting messages
@@ -219,6 +237,9 @@ public class WebEditPageHelper {
     private String processAction() {
         if ( (_action == null) || (_action.trim().length() <= 0) )
             return "";
+        String expected = System.getProperty(getClass().getName() + ".nonce");
+        if ( (expected == null) || (!expected.equals(Long.toString(_nonce))) )
+            return "<b>Invalid nonce, are you being spoofed?</b>";
         if ("Save".equals(_action))
             return save();
         else if ("Remove".equals(_action))
@@ -252,6 +273,8 @@ public class WebEditPageHelper {
             // creating new
             cur = new TunnelController(config, "", _privKeyGenerate);
             TunnelControllerGroup.getInstance().addController(cur);
+            if (cur.getStartOnLoad())
+                cur.startTunnelBackground();
         } else {
             cur.setConfig(config, "");
         }
@@ -265,14 +288,31 @@ public class WebEditPageHelper {
                 if (c == cur) continue;
                 if ("httpclient".equals(c.getType()) || "client".equals(c.getType())) {
                     Properties cOpt = c.getConfig("");
-                    if (_tunnelCount != null)
-                        cOpt.setProperty("option.tunnels.numInbound", _tunnelCount);
-                    if (_tunnelDepth != null)
-                        cOpt.setProperty("option.tunnels.depthInbound", _tunnelDepth);
+                    if (_tunnelCount != null) {
+                        cOpt.setProperty("option.inbound.quantity", _tunnelCount);
+                        cOpt.setProperty("option.outbound.quantity", _tunnelCount);
+                    }
+                    if (_tunnelDepth != null) {
+                        cOpt.setProperty("option.inbound.length", _tunnelDepth);
+                        cOpt.setProperty("option.outbound.length", _tunnelDepth);
+                    }
+                    // these are per-proxy settings, not per-session settings, and
+                    // as such don't need to be shared.  the values are propogated
+                    // to the current tunnel's settings via cur.setConfig above
+                    /*
                     if (_connectDelay)
                         cOpt.setProperty("option.i2p.streaming.connectDelay", "1000");
                     else
                         cOpt.setProperty("option.i2p.streaming.connectDelay", "0");
+                    if ("interactive".equals(_profile))
+                        cOpt.setProperty("option.i2p.streaming.maxWindowSize", "1");
+                    else
+                        cOpt.remove("option.i2p.streaming.maxWindowSize");
+                    */
+                    if (_name != null) {
+                        cOpt.setProperty("option.inbound.nickname", _name);
+                        cOpt.setProperty("option.outbound.nickname", _name);
+                    }
                     c.setConfig(cOpt, "");
                 }
             }
@@ -320,10 +360,18 @@ 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;
         }
-        
         return config;
     }
     
@@ -347,23 +395,40 @@ public class WebEditPageHelper {
                     continue;
                 String key = pair.substring(0, eq);
                 String val = pair.substring(eq+1);
-                if ("tunnels.numInbound".equals(key)) continue;
-                if ("tunnels.depthInbound".equals(key)) continue;
+                if ("inbound.length".equals(key)) continue;
+                if ("outbound.length".equals(key)) continue;
+                if ("inbound.quantity".equals(key)) continue;
+                if ("outbound.quantity".equals(key)) continue;
+                if ("inbound.nickname".equals(key)) continue;
+                if ("outbound.nickname".equals(key)) continue;
                 if ("i2p.streaming.connectDelay".equals(key)) continue;
+                if ("i2p.streaming.maxWindowSize".equals(key)) continue;
                 config.setProperty("option." + key, val);
             }
         }
 
         config.setProperty("startOnLoad", _startOnLoad + "");
         
-        if (_tunnelCount != null)
-            config.setProperty("option.tunnels.numInbound", _tunnelCount);
-        if (_tunnelDepth != null)
-            config.setProperty("option.tunnels.depthInbound", _tunnelDepth);
+        if (_tunnelCount != null) {
+            config.setProperty("option.inbound.quantity", _tunnelCount);
+            config.setProperty("option.outbound.quantity", _tunnelCount);
+        }
+        if (_tunnelDepth != null) {
+            config.setProperty("option.inbound.length", _tunnelDepth);
+            config.setProperty("option.outbound.length", _tunnelDepth);
+        }
         if (_connectDelay)
             config.setProperty("option.i2p.streaming.connectDelay", "1000");
         else
             config.setProperty("option.i2p.streaming.connectDelay", "0");
+        if (_name != null) {
+            config.setProperty("option.inbound.nickname", _name);
+            config.setProperty("option.outbound.nickname", _name);
+        }
+        if ("interactive".equals(_profile))
+            config.setProperty("option.i2p.streaming.maxWindowSize", "1");
+        else
+            config.remove("option.i2p.streaming.maxWindowSize");
     }
 
     /**

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

@@ -14,14 +14,17 @@ import net.i2p.util.Log;
  *
  */
 public class WebStatusPageHelper {
+    private I2PAppContext _context;
     private Log _log;
     private String _action;
     private int _controllerNum;
+    private long _nonce;
     
     public WebStatusPageHelper() {
+        _context = I2PAppContext.getGlobalContext();
         _action = null;
         _controllerNum = -1;
-        _log = I2PAppContext.getGlobalContext().logManager().getLog(WebStatusPageHelper.class);
+        _log = _context.logManager().getLog(WebStatusPageHelper.class);
     }
     
     public void setAction(String action) {
@@ -36,6 +39,14 @@ public class WebStatusPageHelper {
             }
         }
     }
+    public void setNonce(long nonce) { _nonce = nonce; }
+    public void setNonce(String nonce) {
+        if (nonce != null) {
+            try { 
+                _nonce = Long.parseLong(nonce); 
+            } catch (NumberFormatException nfe) {}
+        }
+    }
     
     public String getActionResults() {
         try {
@@ -51,28 +62,44 @@ public class WebStatusPageHelper {
         if (group == null)
             return "<b>I2PTunnel instances not yet started - please be patient</b>\n";
             
+        long nonce = _context.random().nextLong();
         StringBuffer buf = new StringBuffer(4*1024);
         buf.append("<ul>");
         List tunnels = group.getControllers();
         for (int i = 0; i < tunnels.size(); i++) {
             buf.append("<li>\n");
-            getSummary(buf, i, (TunnelController)tunnels.get(i));
+            getSummary(buf, i, (TunnelController)tunnels.get(i), nonce);
             buf.append("</li>\n");
         }
         buf.append("</ul>");
+        
+        buf.append("<hr /><form action=\"index.jsp\" method=\"GET\">\n");
+        buf.append("<input type=\"hidden\" name=\"nonce\" value=\"").append(nonce).append("\" />\n");
+        buf.append("<input type=\"submit\" name=\"action\" value=\"Stop all\" />\n");
+        buf.append("<input type=\"submit\" name=\"action\" value=\"Start all\" />\n");
+        buf.append("<input type=\"submit\" name=\"action\" value=\"Restart all\" />\n");
+        buf.append("<input type=\"submit\" name=\"action\" value=\"Reload config\" />\n");        
+        buf.append("</form>\n");
+        
+        System.setProperty(getClass().getName() + ".nonce", nonce+"");
+        
         return buf.toString();
     }
     
-    private void getSummary(StringBuffer buf, int num, TunnelController controller) {
+    private void getSummary(StringBuffer buf, int num, TunnelController controller, long nonce) {
         buf.append("<b>").append(controller.getName()).append("</b>: ");
         if (controller.getIsRunning()) {
             buf.append("<i>running</i> ");
-            buf.append("<a href=\"index.jsp?num=").append(num).append("&action=stop\">stop</a> ");
+            buf.append("<a href=\"index.jsp?num=").append(num);
+            buf.append("&nonce=").append(nonce);
+            buf.append("&action=stop\">stop</a> ");
         } else if (controller.getIsStarting()) {
             buf.append("<i>startup in progress (please be patient)</i>");
         } else {
             buf.append("<i>not running</i> ");
-            buf.append("<a href=\"index.jsp?num=").append(num).append("&action=start\">start</a> ");
+            buf.append("<a href=\"index.jsp?num=").append(num);
+            buf.append("&nonce=").append(nonce);
+            buf.append("&action=start\">start</a> ");
         }
         buf.append("<a href=\"edit.jsp?num=").append(num).append("\">edit</a> ");
         buf.append("<br />\n");
@@ -82,6 +109,9 @@ public class WebStatusPageHelper {
     private String processAction() {
         if ( (_action == null) || (_action.trim().length() <= 0) )
             return getMessages();
+        String expected = System.getProperty(getClass().getName() + ".nonce");
+        if ( (expected == null) || (!expected.equals(Long.toString(_nonce))) )
+            return "<b>Invalid nonce, are you being spoofed?</b>";
         if ("Stop all".equals(_action)) 
             return stopAll();
         else if ("Start all".equals(_action))
@@ -139,7 +169,7 @@ public class WebStatusPageHelper {
         List controllers = group.getControllers();
         if (_controllerNum >= controllers.size()) return "Invalid tunnel";
         TunnelController controller = (TunnelController)controllers.get(_controllerNum);
-        controller.startTunnel();
+        controller.startTunnelBackground();
         return getMessages(controller.clearMessages());
     }
     

apps/i2ptunnel/java/src/net/i2p/i2ptunnel/socks/SOCKSServer.java

@@ -14,7 +14,6 @@ import net.i2p.I2PException;
 import net.i2p.client.streaming.I2PSocket;
 import net.i2p.client.streaming.I2PSocketManager;
 import net.i2p.client.streaming.I2PSocketManagerFactory;
-import net.i2p.client.streaming.I2PSocketOptions;
 import net.i2p.data.DataFormatException;
 import net.i2p.i2ptunnel.I2PTunnel;
 import net.i2p.util.Log;

apps/i2ptunnel/jsp/index.jsp

@@ -11,13 +11,6 @@
 <b><jsp:getProperty name="helper" property="actionResults" /></b>
  
 <jsp:getProperty name="helper" property="summaryList" />
-<hr />
-<form action="index.jsp" method="GET">
- <input type="submit" name="action" value="Stop all" />
- <input type="submit" name="action" value="Start all" />
- <input type="submit" name="action" value="Restart all" />
- <input type="submit" name="action" value="Reload config" />
-</form>
 
 <form action="edit.jsp">
 <b>Add new:</b> 
@@ -25,6 +18,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/jetty/build.xml

@@ -3,18 +3,38 @@
         
     <target name="all" depends="build" />
     <target name="fetchJettylib" >
-        <available property="jetty.available" file="jettylib" />
+        <available property="jetty.available" file="jetty-5.1.2.zip" />
         <ant target="doFetchJettylib" />
     </target>
     <target name="doFetchJettylib" unless="jetty.available" >
-        <echo message="The libraries contained within the fetched file are from Jetty's 4.2.21 " />
-        <echo message="distribution (http://jetty.mortbay.org/) which we have copied to our website since" />
-        <echo message="theirs doesn't have direct HTTP access to the libs.  These are not " />
+        <echo message="The libraries contained within the fetched file are from Jetty's 5.1.2" />
+        <echo message="distribution (http://jetty.mortbay.org/).  These are not " />
         <echo message="necessary for using I2P, but are used by some applications on top of I2P," />
         <echo message="such as the routerconsole." />
-        <get src="http://dev.i2p.net/jettylib.tar.bz2" verbose="true" dest="jettylib.tar.bz2" />
-        <untar src="jettylib.tar.bz2" compression="bzip2" dest="." />
-        <delete file="jettylib.tar.bz2" />
+        <get src="http://mesh.dl.sourceforge.net/sourceforge/jetty/jetty-5.1.2.zip" verbose="true" dest="jetty-5.1.2.zip" />
+        <ant target="doExtract" />
+    </target>
+    <target name="doExtract">
+        <unzip src="jetty-5.1.2.zip" dest="." />
+        <mkdir dir="jettylib" />
+        <copy todir="jettylib">
+            <fileset dir="jetty-5.1.2/lib">
+                <include name="*.jar" />
+            </fileset>
+        </copy>
+        <copy todir="jettylib">
+            <fileset dir="jetty-5.1.2/ext">
+                <include name="ant.jar" />
+                <include name="commons-el.jar" />
+                <include name="commons-logging.jar" />
+                <include name="jasper-compiler.jar" />
+                <include name="jasper-runtime.jar" />
+                <include name="javax.servlet.jar" />
+                <include name="org.mortbay.jetty.jar" />
+                <include name="xercesImpl.jar" />
+            </fileset>
+        </copy>
+        <delete dir="jetty-5.1.2" />
     </target>
     <target name="build" depends="fetchJettylib" />
     <target name="builddep" />

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

@@ -32,7 +32,7 @@ class I2PSocketImpl implements I2PSocket {
     private Object remoteIDWaiter = new Object();
     private I2PInputStream in;
     private I2POutputStream out;
-    private SocketErrorListener _socketErrorListener;
+    private I2PSocket.SocketErrorListener _socketErrorListener;
     private boolean outgoing;
     private long _socketId;
     private static long __socketId = 0;
@@ -284,7 +284,7 @@ class I2PSocketImpl implements I2PSocket {
         in.setReadTimeout(ms);
     }
     
-    public void setSocketErrorListener(SocketErrorListener lsnr) {
+    public void setSocketErrorListener(I2PSocket.SocketErrorListener lsnr) {
         _socketErrorListener = lsnr;
     }
     

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

@@ -4,27 +4,16 @@
  */
 package net.i2p.client.streaming;
 
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
 import java.io.InterruptedIOException;
-import java.io.UnsupportedEncodingException;
 import java.net.ConnectException;
 import java.net.NoRouteToHostException;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Iterator;
 import java.util.Properties;
 import java.util.Set;
 
 import net.i2p.I2PAppContext;
 import net.i2p.I2PException;
 import net.i2p.client.I2PSession;
-import net.i2p.client.I2PSessionException;
-import net.i2p.client.I2PSessionListener;
-import net.i2p.data.Base64;
-import net.i2p.data.DataFormatException;
 import net.i2p.data.Destination;
-import net.i2p.util.Log;
 
 
 /**
@@ -105,4 +94,11 @@ public interface I2PSocketManager {
     public void setName(String name);
 
     public void init(I2PAppContext context, I2PSession session, Properties opts, String name);
+    
+    public void addDisconnectListener(DisconnectListener lsnr);
+    public void removeDisconnectListener(DisconnectListener lsnr);
+    
+    public static interface DisconnectListener {
+        public void sessionDisconnected();
+    }
 }

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

@@ -36,18 +36,27 @@ public class I2PSocketManagerFactory {
      * @return the newly created socket manager, or null if there were errors
      */
     public static I2PSocketManager createManager() {
-        String i2cpHost = System.getProperty(I2PClient.PROP_TCP_HOST, "localhost");
-        int i2cpPort = 7654;
-        String i2cpPortStr = System.getProperty(I2PClient.PROP_TCP_PORT);
-        if (i2cpPortStr != null) {
-            try {
-                i2cpPort = Integer.parseInt(i2cpPortStr);
-            } catch (NumberFormatException nfe) {
-                // gobble gobble
-            }
-        }
+        return createManager(getHost(), getPort(), System.getProperties());
+    }
+    
+    /**
+     * Create a socket manager using a brand new destination connected to the
+     * I2CP router on the local machine on the default port (7654).
+     * 
+     * @return the newly created socket manager, or null if there were errors
+     */
+    public static I2PSocketManager createManager(Properties opts) {
+        return createManager(getHost(), getPort(), opts);
+    }
 
-        return createManager(i2cpHost, i2cpPort, System.getProperties());
+    /**
+     * Create a socket manager using a brand new destination connected to the
+     * I2CP router on the specified host and port
+     * 
+     * @return the newly created socket manager, or null if there were errors
+     */
+    public static I2PSocketManager createManager(String host, int port) {
+        return createManager(host, port, System.getProperties());
     }
 
     /**
@@ -72,6 +81,26 @@ public class I2PSocketManagerFactory {
         }
     }
 
+    /**
+     * Create a socket manager using the destination loaded from the given private key
+     * stream and connected to the default I2CP host and port.
+     *
+     * @return the newly created socket manager, or null if there were errors
+     */
+    public static I2PSocketManager createManager(InputStream myPrivateKeyStream) {
+        return createManager(myPrivateKeyStream, getHost(), getPort(), System.getProperties());
+    }
+    
+    /**
+     * Create a socket manager using the destination loaded from the given private key
+     * stream and connected to the default I2CP host and port.
+     *
+     * @return the newly created socket manager, or null if there were errors
+     */
+    public static I2PSocketManager createManager(InputStream myPrivateKeyStream, Properties opts) {
+        return createManager(myPrivateKeyStream, getHost(), getPort(), opts);
+    }
+    
     /**
      * Create a socket manager using the destination loaded from the given private key
      * stream and connected to the I2CP router on the specified machine on the given
@@ -100,8 +129,10 @@ public class I2PSocketManagerFactory {
             //p.setProperty("tunnels.depthInbound", "0");
         }
 
-        opts.setProperty(I2PClient.PROP_TCP_HOST, i2cpHost);
-        opts.setProperty(I2PClient.PROP_TCP_PORT, "" + i2cpPort);
+        if (i2cpHost != null)
+            opts.setProperty(I2PClient.PROP_TCP_HOST, i2cpHost);
+        if (i2cpPort > 0)
+            opts.setProperty(I2PClient.PROP_TCP_PORT, "" + i2cpPort);
         
         try {
             I2PSession session = client.createSession(myPrivateKeyStream, opts);
@@ -152,4 +183,20 @@ public class I2PSocketManagerFactory {
         }
         
     }
+
+    private static String getHost() {
+        return System.getProperty(I2PClient.PROP_TCP_HOST, "localhost");
+    }
+    private static int getPort() {
+        int i2cpPort = 7654;
+        String i2cpPortStr = System.getProperty(I2PClient.PROP_TCP_PORT);
+        if (i2cpPortStr != null) {
+            try {
+                i2cpPort = Integer.parseInt(i2cpPortStr);
+            } catch (NumberFormatException nfe) {
+                // gobble gobble
+            }
+        }
+        return i2cpPort;
+    }
 }

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

@@ -10,9 +10,11 @@ import java.io.InterruptedIOException;
 import java.io.UnsupportedEncodingException;
 import java.net.ConnectException;
 import java.net.NoRouteToHostException;
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
+import java.util.List;
 import java.util.Properties;
 import java.util.Set;
 
@@ -46,6 +48,7 @@ class I2PSocketManagerImpl implements I2PSocketManager, I2PSessionListener {
     private I2PSocketOptions _defaultOptions;
     private long _acceptTimeout;
     private String _name;
+    private List _listeners;
     private static int __managerId = 0;
     
     public static final short ACK = 0x51;
@@ -76,6 +79,7 @@ class I2PSocketManagerImpl implements I2PSocketManager, I2PSessionListener {
         _inSockets = new HashMap(16);
         _outSockets = new HashMap(16);
         _acceptTimeout = ACCEPT_TIMEOUT_DEFAULT;
+        _listeners = new ArrayList(1);
         setSession(session);
         setDefaultOptions(buildOptions(opts));
         _context.statManager().createRateStat("streaming.lifetime", "How long before the socket is closed?", "streaming", new long[] { 10*60*1000, 60*60*1000, 24*60*60*1000 });
@@ -109,6 +113,15 @@ class I2PSocketManagerImpl implements I2PSocketManager, I2PSessionListener {
     public void disconnected(I2PSession session) {
         _log.info(getName() + ": Disconnected from the session");
         destroySocketManager();
+        List listeners = null;
+        synchronized (_listeners) {
+            listeners = new ArrayList(_listeners);
+            _listeners.clear();
+        }
+        for (int i = 0; i < listeners.size(); i++) {
+            I2PSocketManager.DisconnectListener lsnr = (I2PSocketManager.DisconnectListener)listeners.get(i);
+            lsnr.sessionDisconnected();
+        }
     }
 
     public void errorOccurred(I2PSession session, String message, Throwable error) {
@@ -707,6 +720,17 @@ class I2PSocketManagerImpl implements I2PSocketManager, I2PSessionListener {
     public String getName() { return _name; }
     public void setName(String name) { _name = name; }
     
+    public void addDisconnectListener(I2PSocketManager.DisconnectListener lsnr) { 
+        synchronized (_listeners) {
+            _listeners.add(lsnr);
+        }
+    }
+    public void removeDisconnectListener(I2PSocketManager.DisconnectListener lsnr) {
+        synchronized (_listeners) {
+            _listeners.remove(lsnr);
+        }
+    }
+    
     public static String getReadableForm(String id) {
         if (id == null) return "(null)";
         if (id.length() != 3) return "Bogus";

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

@@ -1,7 +1,5 @@
 package net.i2p.client.streaming;
 
-import java.util.Properties;
-
 /**
  * Define the configuration for streaming and verifying data on the socket.
  *

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

@@ -1,6 +1,5 @@
 package net.i2p.client.streaming;
 
-import java.util.Iterator;
 import java.util.Properties;
 
 /**
@@ -35,6 +34,18 @@ class I2PSocketOptionsImpl implements I2PSocketOptions {
         init(opts);
     }
     
+    public void setProperties(Properties opts) {
+        if (opts == null) return;
+        if (opts.containsKey(PROP_BUFFER_SIZE))
+            _maxBufferSize = getInt(opts, PROP_BUFFER_SIZE, DEFAULT_BUFFER_SIZE);
+        if (opts.containsKey(PROP_CONNECT_TIMEOUT))
+            _connectTimeout = getInt(opts, PROP_CONNECT_TIMEOUT, DEFAULT_CONNECT_TIMEOUT);
+        if (opts.containsKey(PROP_READ_TIMEOUT))
+            _readTimeout = getInt(opts, PROP_READ_TIMEOUT, -1);
+        if (opts.containsKey(PROP_WRITE_TIMEOUT))
+            _writeTimeout = getInt(opts, PROP_WRITE_TIMEOUT, DEFAULT_WRITE_TIMEOUT);
+    }
+    
     protected void init(Properties opts) {
         _maxBufferSize = getInt(opts, PROP_BUFFER_SIZE, DEFAULT_BUFFER_SIZE);
         _connectTimeout = getInt(opts, PROP_CONNECT_TIMEOUT, DEFAULT_CONNECT_TIMEOUT);

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

@@ -8,8 +8,6 @@ import java.io.OutputStream;
 import java.net.ConnectException;
 import java.net.NoRouteToHostException;
 
-import java.util.Random;
-
 import net.i2p.I2PAppContext;
 import net.i2p.I2PException;
 import net.i2p.data.Destination;

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

@@ -115,18 +115,21 @@ public class StreamSinkServer {
         }
         public void run() {
             if (_fos == null) return;
+            long start = System.currentTimeMillis();
             try {
                 InputStream in = _sock.getInputStream();
                 byte buf[] = new byte[4096];
                 long written = 0;
                 int read = 0;
                 while ( (read = in.read(buf)) != -1) {
-                    _fos.write(buf, 0, read);
+                    //_fos.write(buf, 0, read);
                     written += read;
                     if (_log.shouldLog(Log.DEBUG))
                         _log.debug("read and wrote " + read);
                 }
-                _log.error("Got EOF from client socket [written=" + written + "]");
+                _fos.write(("written: [" + written + "]\n").getBytes());
+                long lifetime = System.currentTimeMillis() - start;
+                _log.error("Got EOF from client socket [written=" + written + " lifetime=" + lifetime + "]");
             } catch (IOException ioe) {
                 _log.error("Error writing the sink", ioe);
             } finally {
@@ -148,7 +151,7 @@ public class StreamSinkServer {
         StreamSinkServer server = null;
         switch (args.length) {
             case 0:
-                server = new StreamSinkServer("dataDir", "server.key", "localhost", 10001);
+                server = new StreamSinkServer("dataDir", "server.key", "localhost", 7654);
                 break;
             case 2:
                 server = new StreamSinkServer(args[0], args[1]);

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

@@ -0,0 +1,206 @@
+package net.i2p.client.streaming;
+
+import java.io.InputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.FileInputStream;
+import java.io.OutputStream;
+import net.i2p.I2PAppContext;
+import net.i2p.client.I2PClientFactory;
+import net.i2p.data.Destination;
+import net.i2p.util.Log;
+import net.i2p.util.I2PThread;
+
+/**
+ * Sit around on a destination, receiving lots of data and sending lots of
+ * data to whomever talks to us.
+ *
+ * Usage: TestSwarm myKeyFile [peerDestFile ]*
+ *
+ */
+public class TestSwarm {
+    private I2PAppContext _context;
+    private Log _log;
+    private String _destFile;
+    private String _peerDestFiles[];
+    private String _conOptions;
+    private I2PSocketManager _manager;
+    private boolean _dead;
+    
+    public static void main(String args[]) {
+        if (args.length < 1) {
+            System.err.println("Usage: TestSwarm myDestFile [peerDestFile ]*");
+            return;
+        }
+        I2PAppContext ctx = new I2PAppContext();
+        String files[] = new String[args.length - 1];
+        System.arraycopy(args, 1, files, 0, files.length);
+        TestSwarm swarm = new TestSwarm(ctx, args[0], files);
+        swarm.startup();
+    }
+    
+    public TestSwarm(I2PAppContext ctx, String destFile, String peerDestFiles[]) {
+        _context = ctx;
+        _log = ctx.logManager().getLog(TestSwarm.class);
+        _dead = false;
+        _destFile = destFile;
+        _peerDestFiles = peerDestFiles;
+        _conOptions = "";
+    }
+    
+    public void startup() {
+        _log.debug("Starting up");
+        File keys = new File(_destFile);
+        if (!keys.exists()) {
+            try {
+                I2PClientFactory.createClient().createDestination(new FileOutputStream(keys));
+            } catch (Exception e) {
+                _log.error("Error creating a new destination on " + keys, e);
+                return;
+            }
+        }
+        try {
+            _manager = I2PSocketManagerFactory.createManager(new FileInputStream(_destFile), null, -1, null);
+        } catch (Exception e) {
+            _log.error("Error creatign the manager", e);
+            return;
+        }
+
+        I2PThread listener = new I2PThread(new Listener(), "Listener");
+        listener.start();
+        
+        connectWithPeers();
+    }
+    
+    
+    private void connectWithPeers() {
+        if (_peerDestFiles != null) {
+            for (int i = 0; i < _peerDestFiles.length; i++) {
+                try {
+                    FileInputStream fin = new FileInputStream(_peerDestFiles[i]);
+                    Destination dest = new Destination();
+                    dest.readBytes(fin);
+                    
+                    I2PThread flooder = new I2PThread(new Flooder(dest), "Flooder+" + dest.calculateHash().toBase64().substring(0,4));
+                    flooder.start();
+                } catch (Exception e) {
+                    _log.error("Unable to read the peer from " + _peerDestFiles[i], e);
+                }
+            }
+        }
+    }
+    
+    private class Listener implements Runnable {
+        public void run() {
+            try {
+                I2PServerSocket ss = _manager.getServerSocket();
+                I2PSocket s = null;
+                while ( (s = ss.accept()) != null) {
+                    I2PThread flooder = new I2PThread(new Flooder(s), "Flooder-" + s.getPeerDestination().calculateHash().toBase64().substring(0,4));
+                    flooder.start();
+                }
+            } catch (Exception e) {
+                _log.error("Error listening", e);
+            }
+        }
+    }
+    
+    private static volatile long __conId = 0;
+    private class Flooder implements Runnable {
+        private Destination _remoteDestination;
+        private I2PSocket _socket;
+        private boolean _closed;
+        private long _started;
+        private long _totalSent;
+        private long _totalReceived;
+        private long _lastReceived;
+        private long _lastReceivedOn;
+        private long _connectionId;
+        
+        public Flooder(Destination dest) {
+            _socket = null;
+            _remoteDestination = dest;
+            _connectionId = ++__conId;
+            _closed = false;
+            _lastReceived = -1;
+            _lastReceivedOn = _context.clock().now();
+            _context.statManager().createRateStat("swarm." + _connectionId + ".totalReceived", "Data size received", "swarm", new long[] { 30*1000, 60*1000, 5*60*1000 });
+            _context.statManager().createRateStat("swarm." + _connectionId + ".totalSent", "Data size sent", "swarm", new long[] { 30*1000, 60*1000, 5*60*1000 });
+            _context.statManager().createRateStat("swarm." + _connectionId + ".started", "When we start", "swarm", new long[] { 5*60*1000 });
+            _context.statManager().createRateStat("swarm." + _connectionId + ".lifetime", "How long we talk to a peer", "swarm", new long[] { 5*60*1000 });
+        }
+        
+        public Flooder(I2PSocket socket) {
+            _socket = socket;
+            _remoteDestination = socket.getPeerDestination();
+            _connectionId = ++__conId;
+            _closed = false;
+            _lastReceived = -1;
+            _lastReceivedOn = _context.clock().now();
+            _context.statManager().createRateStat("swarm." + _connectionId + ".totalReceived", "Data size received", "swarm", new long[] { 30*1000, 60*1000, 5*60*1000 });
+            _context.statManager().createRateStat("swarm." + _connectionId + ".totalSent", "Data size sent", "swarm", new long[] { 30*1000, 60*1000, 5*60*1000 });
+            _context.statManager().createRateStat("swarm." + _connectionId + ".started", "When we start", "swarm", new long[] { 5*60*1000 });
+            _context.statManager().createRateStat("swarm." + _connectionId + ".lifetime", "How long we talk to a peer", "swarm", new long[] { 5*60*1000 });
+        }
+        
+        public long getConnectionId() { return _connectionId; }
+        public Destination getDestination() { return _remoteDestination; }
+        
+        public void run() {
+            _started = _context.clock().now();
+            _context.statManager().addRateData("swarm." + _connectionId + ".started", 1, 0);
+            byte data[] = new byte[32*1024];
+            long value = 0;
+            long lastSend = _context.clock().now();
+            if (_socket == null) {
+                try {
+                    _socket = _manager.connect(_remoteDestination);
+                } catch (Exception e) {
+                    _log.error("Error connecting to " + _remoteDestination.calculateHash().toBase64().substring(0,4));
+                    return;
+                }
+            }
+            
+            I2PThread floodListener = new I2PThread(new FloodListener(), "FloodListener" + _connectionId);
+            floodListener.start();
+            
+            try {
+                OutputStream out = _socket.getOutputStream();
+                while (!_closed) {
+                    out.write(data);
+                    // out.flush();
+                    _totalSent += data.length;
+                    _context.statManager().addRateData("swarm." + _connectionId + ".totalSent", _totalSent, 0);
+                    //try { Thread.sleep(100); } catch (InterruptedException ie) {}
+                    long now = _context.clock().now();
+                    _log.debug("Sending " + _connectionId + " after " + (now-lastSend));
+                    lastSend = now;
+                    try { Thread.sleep(20); } catch (InterruptedException ie) {}
+                }
+            } catch (Exception e) {
+                _log.error("Error sending", e);
+            }
+        }
+        
+        private class FloodListener implements Runnable {
+            public void run() {
+                long lastRead = System.currentTimeMillis();
+                long now = lastRead;
+                try {
+                    InputStream in = _socket.getInputStream();
+                    byte buf[] = new byte[32*1024];
+                    int read = 0;
+                    while ( (read = in.read(buf)) != -1) {
+                        now = System.currentTimeMillis();
+                        _totalReceived += read;
+                        _context.statManager().addRateData("swarm." + getConnectionId() + ".totalReceived", _totalReceived, 0);
+                        _log.debug("Receiving " + _connectionId + " with " + read + " after " + (now-lastRead));
+                        lastRead = now;
+                    }
+                } catch (Exception e) {
+                    _log.error("Error listening to the flood", e);
+                }
+            }
+        }
+    }
+}

apps/pants/build.xml

@@ -0,0 +1,236 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!--
+  Ports + Ant = Pants, a simple Ant-based package manager
+
+  free (adj.): unencumbered; not under the control of others
+
+  Written by smeghead in 2005 and released into the public domain with no
+  warranty of any kind, either expressed or implied.  It probably won't make
+  your computer catch on fire, or eat your children, but it might.  Use at your
+  own risk.
+-->
+
+<project basedir="." default="help" name="pants-interface">
+
+<!-- .......................... Global Properties .......................... -->
+
+
+
+<!-- ........................... Internal Tasks ............................ -->
+
+	<target name="-fetchCvs" unless="cvs.source.available" if="using.cvs">
+		<cvs compressionlevel="${cvs.compression.level}"
+			date="${cvs.date}"
+			dest="./distfiles/cvs-src/${pbuild}"
+			failonerror="true"
+			package="${cvs.package}"
+			passfile="${cvs.passfile}"
+			port="${cvs.port}"
+			cvsRoot="${cvs.root}"
+			cvsRsh="${cvs.rsh}"
+			tag="${cvs.tag}"
+		/>
+	</target>
+
+	<target name="-fetchPackage"  unless="using.cvs">
+		<get src="${package.url}"
+			verbose="true"
+			dest="./distfiles"
+		/>
+	</target>
+
+	<target name="-init">
+		<!--
+		  TODO: Create dist/ and working/ folders for each pbuild subdir in case
+		  they've been wiped.
+		-->
+		<loadproperties srcfile="world" />
+		<taskdef name="mergetypedproperties"
+			classname="net.i2p.pants.MergeTypedPropertiesTask"
+			classpath="./lib/pants.jar"
+		/>
+		<mergetypedproperties input="./pbuilds/${pbuild}/pbuild.properties"
+			output="./pbuilds/${pbuild}/merged-properties.temp"
+			booleanList="version.latest.find.regex.canonicaleq,	version.latest.find.regex.caseinsensitive, version.latest.find.regex.comments, version.latest.find.regex.dotall, version.latest.find.regex.multiline, version.latest.find.regex.unicodecase, version.latest.find.regex.unixlines"
+			stringList="cvs.compression.level, cvs.date, cvs.package, cvs.passfile, cvs.port, cvs.root, cvs.rsh, cvs.tag, package.url, version.latest, version.latest.find.url, version.latest.find.regex"
+		/>
+		<loadproperties srcfile="./pbuilds/${pbuild}/merged-properties.temp" />
+		<delete file="./pbuilds/${pbuild}/merged-properties.temp" />
+		<!--
+		  If '-Dpbuild={name}' isn't specified, the 'build', 'fetch', 'update'
+		  and 'version' commands should default to 'world' behavior.
+		-->
+		<antcall target="-setWorld" />
+		<condition property="using.cvs">
+			<or>
+				<equals arg1="CVS" arg2="${version.using.${pbuild}}" />
+				<equals arg1="cvs" arg2="${version.using.${pbuild}}" />
+			</or>
+		</condition>
+		<!--
+		  If 'version.recommended' isn't defined in pbuild.properties, default
+		  to latest available version.
+		-->
+	</target>
+
+	<target name="-setWorld" unless="pbuild">
+		<property name="pbuild" value="world" />
+	</target>
+
+	<target name="-unpackTarBz2">
+		<untar src="${pbuild.package}"
+			compression="bzip2"
+			dest="./${pbuild}/working"
+		/>
+	</target>
+
+	<target name="-unpackTarGzip">
+		<untar src="${pbuild.package}"
+			compression="gzip"
+			dest="./${pbuild}/working"
+		/>
+	</target>
+
+	<target name="-unpackZip">
+		<unzip src="${pbuild.package}" dest="./${pbuild}/working" />
+	</target>
+
+	<target name="-updateCvs" if="using.cvs">
+		<cvs command="update -d"
+			compressionlevel="${compression.level}"
+			date="${cvs.date}"
+			dest="./distfiles/cvs-src"
+			failonerror="true"
+			package="${cvs.package}"
+			passfile="${cvs.passfile}"
+			port="${cvs.port}"
+			cvsRoot="${cvs.root}"
+			cvsRsh="${cvs.rsh}"
+			tag="${cvs.tag}"
+		/>
+	</target>
+
+	<target name="-updateConfirm" if="confirm.update" unless="no.prompts">
+		<input validargs="y,Y,n,N"
+			defaultvalue="n"
+			addproperty="confirm.update.answer">
+You currently have the recommended version installed. A newer
+version will be installed if you continue and this may break some
+applications which depend on this package. Are you sure you want
+to update? [y/N]
+		</input>
+		<condition property="abort.update">
+			<or>
+				<equals arg1="n" arg2="${confirm.update.answer}" />
+				<equals arg1="N" arg2="${confirm.update.answer}" />
+			</or>
+		</condition>
+		<fail if="abort.update">Update aborted.</fail>
+	</target>
+
+	<target name="-versionLatest">
+		<get src="${version.latest.find.url}"
+			dest="version.latest.in.temp"
+			verbose="true"
+		/>
+		<taskdef name="match"
+			classname="net.i2p.pants.MatchTask"
+			classpath="./lib/pants.jar"
+		/>
+		<match input="version.latest.in.temp"
+			output="version.latest.parsed.temp"
+			regex="${version.latest.find.regex}"
+			canonicaleq="${version.latest.find.regex.canonicaleq}"
+			caseinsensitive="${version.latest.find.regex.caseinsensitive}"
+			comments="${version.latest.find.regex.comments}"
+			dotall="${version.latest.find.regex.dotall}"
+			multiline="${version.latest.find.regex.multiline}"
+			unicodecase="${version.latest.find.regex.unicodecase}"
+			unixlines="${version.latest.find.regex.unixlines}"
+		/>
+		<loadproperties srcFile="version.latest.parsed.temp" />
+		<delete file="version.latest.in.temp" />
+		<delete file="version.latest.parsed.temp" />
+		<property name="version.latest" value="${group.1}" />
+	</target>
+
+	<target name="-versionRecommended">
+		<property name="version.recommended" value="x" />
+	</target>
+
+	<target name="-versionUsing">
+		<property name="version.using" value="x" />
+	</target>
+
+<!-- .......................... Public Interface ........................... -->
+
+	<target name="build" depends="-init,fetch"
+		description="Build a pbuild and its dependencies">
+		<ant antfile="pbuild.xml" dir="./pbuilds/${pbuild}" target="clean" />
+		<ant antfile="pbuild.xml" dir="./pbuilds/${pbuild}" target="build" />
+		<!--
+		  Perform a 'clean' on the target first (but not 'distclean')
+		-->
+	</target>
+
+	<target name="fetch" depends="-init"
+		description="Get package only">
+		<antcall target="-fetchPackage" />
+		<antcall target="-fetchCvs" />
+		<copydir dest="./pbuilds/${pbuild}/working"
+			src="./distfiles/cvs-src/${pbuild}"
+		/>
+	</target>
+
+	<target name="help"
+		description="Display usage synopsis">
+		<echo>
+Pants usage:
+
+    ant [--usejikes] [-Dpbuild={name}] [-Dpbuild.version={version}]
+        [-D{property}={value}] [-Dno.prompts=true] build | fetch |
+        help | install | uninstall | update | version
+
+    build        Build a pbuild and its dependencies
+    fetch        Get package only
+    help         Display usage synopsis
+    install      Fetch, build and install a pbuild
+    uninstall    Uninstall a pbuild
+    update       Update pbuild(s) to the latest version(s)
+    version      Display pbuild version information
+		</echo>
+	</target>
+
+	<!--
+	  Install recommended version by default unless 'version' property is set.
+	  Do not install if package is already installed.
+	-->
+	<target name="install" depends="-init, build"
+		description="Install a pbuild">
+		<ant antfile="pbuild.xml" dir="./pbuilds/${pbuild}" target="dist" />
+		<ant antfile="pbuild.xml" dir="./pbuilds/${pbuild}"
+			target="distclean"
+		/>
+	</target>
+
+	<target name="uninstall" depends="-init"
+		description="Uninstall a pbuild" />
+
+	<target name="update" depends="-init"
+		description="Update pbuild(s) to the latest version(s)">
+		<condition property="${confirm.update}">
+			<equals arg1="${version.using}" arg2="${version.recommended}" />
+		</condition>
+		<antcall target="-updateConfirm" />
+	</target>
+
+	<target name="version"
+		depends="-init, -versionRecommended, -versionUsing, -versionLatest"
+		description="Display pbuild version information">
+		<echo message="Latest version: ${version.recommended}" />
+		<echo message="Latest version: ${version.using}" />
+		<echo message="Latest version: ${version.latest}" />
+	</target>
+
+</project>

apps/pants/pants/build.xml

@@ -0,0 +1,45 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project basedir="." default="build" name="build-pants">
+
+	<target name="build"
+		description="Build the source">
+		<mkdir dir="./java/build"/>
+		<javac srcdir="./java/src" source="1.3" target="1.3" deprecation="on" destdir="./java/build" />
+	</target>
+
+	<target name="clean"
+		description="Remove all object files">
+		<delete dir="./java/build" />
+		<delete dir="./java/jartemp" />
+	</target>
+
+	<target name="dist" depends="build, jar"
+		description="Create the jar and copy it to ../lib">
+		<copy todir="../lib" file="./java/build/pants.jar" />
+	</target>
+
+	<target name="distclean" depends="clean"
+		description="Remove the jar and all object files" >
+		<delete file="../lib/pants.jar" />
+	</target>
+
+	<target name="jar">
+		<delete dir="./java/jartemp" />
+		<mkdir dir="./java/jartemp" />
+		<copy todir="./java/jartemp">
+			<fileset dir="./java/build" includes="**/*.class" />
+		</copy>
+		<jar basedir="./java/jartemp" jarfile="./java/build/pants.jar">
+			<manifest>
+				<section name="net.i2p.pants">
+					<attribute name="Implementation-Title" value="Pants" />
+					<attribute name="Implementation-Version" value="0.0.1" /> 
+					<attribute name="Implementation-Vendor" value="I2P" />
+					<attribute name="Implementation-Vendor-Id" value="I2P" />
+					<attribute name="Implementation-URL" value="http://www.i2p.net" />
+				</section>
+			</manifest>
+		</jar>
+		<delete dir="./java/jartemp" />
+	</target>
+</project>

apps/pants/pants/java/src/net/i2p/pants/MatchTask.java

@@ -0,0 +1,212 @@
+/*
+ * Ports + Ant = Pants, a simple Ant-based package manager
+ * 
+ * free (adj.): unencumbered; not under the control of others
+ * 
+ * Written by smeghead in 2005 and released into the public domain with no
+ * warranty of any kind, either expressed or implied.  It probably won't make
+ * your computer catch on fire, or eat your children, but it might.  Use at your
+ * own risk.
+ */
+
+package net.i2p.pants;
+
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.apache.tools.ant.BuildException;
+import org.apache.tools.ant.Task;
+
+/**
+ * <p>Custom Ant task for matching the contents of a file against a given
+ * regular expression and writing any matching groups to a file in
+ * <code>java.util.Properties</code> format.
+ * </p>
+ * <p>Each key in the properties file is named after the number corresponding to
+ * its matching group and its value is the contents of the matching group.
+ * </p>
+ * <p>Regular expressions passed to this task must conform to the specification
+ * used by Sun's <code>java.util.regex</code> package and thus are mostly
+ * compatible with Perl 5 regular expressions.
+ * </p>
+ * <p>When calling the <code>match</code> task, the attributes
+ * <code>input</code>, <code>output</code>, and <code>regex</code> are required.
+ * </p>
+ * <p>Optional boolean attributes may be used to toggle various modes for the
+ * regular expression engine (all are set to <code>false</code> by default):
+ * </p>
+ * <table>
+ * <tr><td><code>canonicaleq</code></td><td>Enable canonical equivalence</td></tr>
+ * <tr><td><code>caseinsensitive</code></td><td>Enable case-insensitive matching</td></tr>
+ * <tr><td><code>comments</code></td><td>Permit whitespace and comments in pattern</td></tr>
+ * <tr><td><code>dotall</code></td><td>Enable dotall mode</td></tr>
+ * <tr><td><code>multiline</code></td><td>Enable multi-line mode</td></tr>
+ * <tr><td><code>unicodecase</code></td><td>Enable Unicode-aware case folding</td></tr>
+ * <tr><td><code>unixlines</code></td><td>Enable Unix lines mode</td></tr>
+ * </table>
+ * <p>There is one additional optional boolean attribute,
+ * <code>failOnNoMatch</code>. If this attribute is <code>true</code> it causes
+ * the <code>match</code> task to throw a
+ * <code>org.apache.tools.ant.BuildException</code> and fail if no matches for
+ * the regular expression are found. The default value is <code>false</code>,
+ * meaning a failed match will simply result in a warning message to
+ * <code>STDERR</code> and an empty (0 byte) <code>output</code> file being
+ * created. 
+ * </p>
+ * <p>
+ * <h4>Example</h4>
+ * </p>
+ * <p>Contents of input file <code>letter.txt</code>:
+ * <pre>
+ *      Dear Alice,
+ * 
+ *      How's about you and me gettin' together for some anonymous foo action?
+ * 
+ *      Kisses,
+ *      Bob
+ * </pre>
+ * </p>
+ * <p>Ant <code>match</code> task and a <code>taskdef</code> defining it:
+ * <pre>
+ *      &lt;taskdef name="match" classname="net.i2p.pants.MatchTask" classpath="../../lib/pants.jar" /&gt;
+ *      &lt;match input="letter.txt"
+ *             output="matches.txt"
+ *             regex="about (\S*?) and (\S*?) .+anonymous (\S*?)"
+ *             /&gt;
+ * </pre>
+ * </p>
+ * <p>Contents of properties file <code>matches.txt</code> written by this task:
+ * <pre>
+ *      group.0=about you and me gettin' together for some anonymous foo
+ *      group.1=you
+ *      group.2=me
+ *      group.3=foo
+ * </pre>
+ * </p>
+ * <p>These values can be loaded from <code>matches.txt</code> into Ant
+ * properties like so:
+ * <pre>
+ *      &lt;loadproperties srcFile="matches.txt" /&gt;
+ * </pre>
+ * </p>
+ *  
+ * @author smeghead
+ */
+public class MatchTask extends Task {
+
+	private boolean _failOnNoMatch;
+	private String  _inputFile;
+	private String  _outputFile;
+	private String  _regex;
+	private int     _regexFlags;
+
+	public void execute() throws BuildException {
+		int               charRead    = 0;
+		FileReader        fileReader  = null;
+		FileWriter        fileWriter  = null;
+		Matcher           matcher     = null;
+		Pattern           pattern     = null;
+		PrintWriter       printWriter = null;
+		StringBuffer      text        = new StringBuffer();
+
+		if (_inputFile == null)
+			throw new BuildException("Error: 'match' task requires 'input' attribute");
+
+		if (_outputFile == null)
+			throw new BuildException("Error: 'match' task requires 'output' attribute");
+
+		if (_regex == null)
+			throw new BuildException("Error: 'match' task requires 'regex' attribute");
+
+		pattern = Pattern.compile(_regex, _regexFlags);
+
+		try {
+			fileReader = new FileReader(_inputFile);
+
+			while ((charRead = fileReader.read()) != -1)
+				text.append((char) charRead);
+
+			fileReader.close();
+			matcher = pattern.matcher(text);
+
+			if (matcher.find()) {
+				printWriter = new PrintWriter(new FileWriter(_outputFile));
+
+				for (int i = 0; i <= matcher.groupCount(); i++)
+					printWriter.println("group." + Integer.toString(i) + "=" + matcher.group(i));
+
+				printWriter.flush();
+				printWriter.close();
+			} else {
+				if (_failOnNoMatch) {
+					throw new BuildException("Error: No matches found in " + _inputFile);
+				} else {
+					System.err.println("Warning: No matches found in " + _inputFile);
+					// Create 0 byte output file.
+					fileWriter = new FileWriter(_outputFile);
+					fileWriter.close();
+				}
+			}
+		} catch (FileNotFoundException fnfe) {
+			throw new BuildException("File " + _inputFile + " not found", fnfe);
+		} catch (IOException ioe) {
+			throw new BuildException(ioe);
+		}
+	}
+
+	public void setCanonicalEq(boolean enableCanonicalEq) {
+		if (enableCanonicalEq)
+			_regexFlags |= Pattern.CANON_EQ;
+	}
+
+	public void setCaseInsensitive(boolean enableCaseInsensitive) {
+		if (enableCaseInsensitive)
+			_regexFlags |= Pattern.CASE_INSENSITIVE;
+	}
+
+	public void setComments(boolean enableComments) {
+		if (enableComments)
+			_regexFlags |= Pattern.COMMENTS;
+	}
+
+	public void setDotall(boolean enableDotall) {
+		if (enableDotall)
+			_regexFlags |= Pattern.DOTALL;
+	}
+
+	public void setFailOnNoMatch(boolean failOnNoMatch) {
+		_failOnNoMatch = failOnNoMatch;
+	}
+
+	public void setInput(String inputFile) {
+		_inputFile = inputFile;
+	}
+
+	public void setMultiLine(boolean enableMultiLine) {
+		if (enableMultiLine)
+			_regexFlags |= Pattern.MULTILINE;
+	}
+
+	public void setOutput(String outputFile) {
+		_outputFile = outputFile;
+	}
+
+	public void setRegex(String regex) {
+		_regex = regex;
+	}
+
+	public void setUnicodeCase(boolean enableUnicodeCase) {
+		if (enableUnicodeCase)
+			_regexFlags |= Pattern.UNICODE_CASE;
+	}
+
+	public void setUnixLines(boolean enableUnixLines) {
+		if (enableUnixLines)
+			_regexFlags |= Pattern.UNIX_LINES;
+	}
+}

apps/pants/pants/java/src/net/i2p/pants/MergeTypedPropertiesTask.java

@@ -0,0 +1,164 @@
+/*
+ * Ports + Ant = Pants, a simple Ant-based package manager
+ * 
+ * free (adj.): unencumbered; not under the control of others
+ * 
+ * Written by smeghead in 2005 and released into the public domain with no
+ * warranty of any kind, either expressed or implied.  It probably won't make
+ * your computer catch on fire, or eat your children, but it might.  Use at your
+ * own risk.
+ */
+
+package net.i2p.pants;
+
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.Enumeration;
+import java.util.Properties;
+import java.util.StringTokenizer;
+
+import org.apache.tools.ant.BuildException;
+import org.apache.tools.ant.Task;
+
+/**
+ * <p>Custom Ant task for loading properties from a
+ * <code>java.util.Properties</code> file then merging them with lists of
+ * expected properties. When an expected property is found in the properties
+ * file it is set to the value given for it in the file. If an expected property
+ * from a list isn't found in the properties file its value will be set to "" or
+ * "false", depending on the property's data type.
+ * </p>
+ * <p>A property's data type is determined by membership in one of two lists
+ * which can be passed into an instance of this class: a string-typed list and a
+ * boolean-typed list. Values for string-typed properties may be any valid
+ * string accepted by <code>java.util.Properties</code>, and values for
+ * boolean-typed properties must be either "false" or "true".
+ * </p>
+ * <p>Lists holding more than one property must be comma-delimited.
+ * </p>
+ * <p>The output of this class is a temporary <code>java.util.Properties</code>
+ * file which is suitable for reading by the standard Ant
+ * <code>loadproperties</code> task.
+ * </p>
+ * <p>Note that if any properties in the given lists have already been defined
+ * before the <code>mergetypedproperties</code> task is called, their values
+ * cannot be changed since Ant properties are immutable.
+ * </p>
+ * <h4>Example</h4>
+ * </p>
+ * <p>Contents of a properties file <code>my.properties</code>:
+ * <pre>
+ *      some.property.exists=true
+ *      hasValue=false
+ *      some.property=this is a value
+ *      property0=bork bork
+ *      propertyX=this property wasn't passed in a list
+ * </pre>
+ * </p>
+ * <p>Ant <code>mergetypedproperties</code> task and a <code>taskdef</code>
+ * defining it:
+ * <pre>
+ *      &lt;taskdef name="mergetypedproperties" classname="net.i2p.pants.MergeTypedPropertiesTask" classpath="../../lib/pants.jar" /&gt;
+ *      &lt;mergetypedproperties input="my.properties"
+ *             output="merged-properties.temp"
+ *             booleanList="some.property.exists,is.valid,hasValue"
+ *             stringList="some.property,another.property,property0"
+ *             /&gt;
+ * </pre>
+ * </p>
+ * <p>Contents of properties file <code>merged-properties.temp</code> written by this task:
+ * <pre>
+ *      some.property.exists=true
+ *      is.valid=false
+ *      hasValue=false
+ *      some.property=this is a value
+ *      another.property=
+ *      property0=bork bork
+ *      propertyX=this property wasn't passed in a list
+ * </pre>
+ * </p>
+ * <p>If you don't want this task's output to include properties which weren't
+ * in the lists of expected properties, you can set the attribute
+ * <code>onlyExpected</code> to <code>true</code>. In the example, this would
+ * result in the file <code>merged-properties.temp</code> containing only the
+ * following properties:
+ * <pre>
+ *      some.property.exists=true
+ *      is.valid=false
+ *      hasValue=false
+ *      some.property=this is a value
+ *      another.property=
+ *      property0=bork bork
+ * </pre>
+ * </p>
+ *  
+ * @author smeghead
+ */
+public class MergeTypedPropertiesTask extends Task {
+
+	private String     _booleanList   = "";
+	private String     _inputFile;
+	private boolean    _onlyExpected;
+	private String     _outputFile;
+	private Properties _propertiesIn  = new Properties();
+	private Properties _propertiesOut = new Properties();
+	private String     _stringList    = "";
+
+	public void execute() throws BuildException {
+		StringTokenizer strtokBoolean = new StringTokenizer(_booleanList, ",");
+		StringTokenizer strtokString  = new StringTokenizer(_stringList, ",");
+		String          property      = "";
+
+		if (_inputFile == null)
+			throw new BuildException("Error: 'mergetypedproperties' task requires 'input' attribute");
+
+		if (_outputFile == null)
+			throw new BuildException("Error: 'mergetypedproperties' task requires 'output' attribute");
+
+		// Add some type-checking on the list elements
+
+		try {
+			_propertiesIn.load(new FileInputStream(_inputFile));
+
+			while (strtokBoolean.hasMoreTokens())
+				_propertiesOut.setProperty(strtokBoolean.nextToken().trim(), "false");
+
+			while (strtokString.hasMoreTokens())
+				_propertiesOut.setProperty(strtokString.nextToken().trim(), "");
+
+			for (Enumeration enum = _propertiesIn.elements(); enum.hasMoreElements(); ) {
+				property = (String) enum.nextElement();
+
+				if (_onlyExpected && !_propertiesOut.containsKey(property))
+					continue;
+				else
+					_propertiesOut.setProperty(property, _propertiesIn.getProperty(property));
+			}
+
+			_propertiesOut.store(new FileOutputStream(_inputFile), "This is a temporary file. It is safe to delete it.");
+		} catch (IOException ioe) {
+			throw new BuildException(ioe);
+		}
+	}
+
+	public void setBooleanList(String booleanList) {
+		_booleanList = booleanList;
+	}
+
+	public void setInput(String inputFile) {
+		_inputFile = inputFile;
+	}
+
+	public void setOnlyExpected(boolean onlyExpected) {
+		_onlyExpected = onlyExpected;
+	}
+
+	public void setOutput(String outputFile) {
+		_outputFile = outputFile;
+	}
+
+	public void setStringList(String stringList) {
+		_stringList = stringList;
+	}
+}

apps/pants/pants/resources/README

@@ -0,0 +1,116 @@
+What is Pants?
+--------------
+
+    Pants is an Apache Ant-based package manager for the management of 3rd party
+    dependencies in Java development projects. It's loosely modeled after
+    FreeBSD's Ports and Gentoo Linux's Portage, with two major differences:
+
+    * Pants isn't intended for system-wide package management. It's tailored for
+      per-project 3rd party package management. You will typically have one
+      Pants repository per project and each repository will be located somewhere
+      under your project's root directory. If you're familiar with Ports or
+      Portage, a Pants repository is roughly analogous to /usr/ports or
+      /usr/portage.
+
+    * Pants is extremely portable. It goes anywhere Apache Ant goes.
+
+    Pants takes a modular approach to the standard Ant buildfile, breaking it
+    into 3 files for functionality and convenience:
+
+    1. The Pants public interface, pants/build.xml, provides a single consistent
+       way to access and manipulate dependency packages and relieves some of the
+       developer's burden by providing implementations for some frequently-used
+       and complex Ant operations.
+
+    2. pbuild.xml is a specially-structured and slimmed-down Ant buildfile in
+       which you implement custom handling for a package your project depends
+       on. This is known as the "pbuild" and is roughly analogous to a FreeBSD
+       port or a Gentoo ebuild. A fairly explanatory template for pbuilds,
+       pbuild.template.xml, is provided.
+
+    3. pbuild.properties contains those properties for a specific pbuild which
+       are most likely to change over time. It uses the java.util.Properties
+       format which is more human-friendly for hand-editing than Ant/XML. A
+       fairly explanatory template, pbuild.template.properties, is provided.
+
+    There is one more file that completes the Pants system: the metadata file
+    pants/world is a database for keeping track of all packages managed by Pants
+    for your project.
+
+    Pants automatically handles versioning for your project's dependency
+    packages and keeps track of their recommended versions, currently used
+    versions, and latest available versions. This makes it extremely simple for
+    project developers to switch back and forth between different versions of a
+    dependency, and makes it just as easy to update a dependency. You can even
+    update all your project's Pants-managed packages with a single command.
+
+    Pbuilds are designed to automatically handle the downloading, building,
+    repackaging and deployment of source archives, binary archives, and CVS
+    sources, all in a manner that's completely transparent to the project
+    developer. Pbuilds currently support tar + gzip, tar + bzip2, and zip
+    archives.
+
+    Because it is based on Ant, Pants integrates very well with Ant buildfiles
+    and will fit easily into your project's Ant build framework. However, its
+    interface is simple enough to be called just as easily by more traditional
+    build systems such as GNU Make.
+
+
+Why Should I Use Pants?
+-----------------------
+
+    There are many applications for Pants, but a few use cases should best serve
+    to illustrate its usefulness:
+
+    1. You have a project that you ship with several 3rd party libraries but the
+       versions you're using are stale. With a single command, Pants can
+       automatically discover the latest release versions for all of these, then
+       download, build, and place the fresh libraries where your project's main
+       build system expects them to be at build time.
+
+    2. You want to test multiple versions of a 3rd party library against your
+       project. Pants only requires you to issue a single command to switch
+       library versions, so can spend more time testing and less time hunting
+       packages down, unpackaging them, symlinking, etc.
+
+    3. Pants is public domain. You can ship it with your project if you need to
+       without having to worry about petty intellectual property or licensing
+       issues.
+
+
+Minimum Requirements
+--------------------
+
+    * Apache Ant 1.6.2 or higher is recommended
+
+    * Any Java runtime and operating system that will run Ant
+
+
+Installation
+------------
+
+    Not finished yet.
+
+
+Why the Silly Name?
+-------------------
+
+    Ports + Ant = Pants. Any other explanation is purely a product of your
+    twisted imagination.
+
+
+Miscellaneous Pocket Fluff
+--------------------------
+
+    Author:  smeghead <smeghead@i2pmail.org> <smeghead@mail.i2p>
+
+    License: No license necessary. This work is released into the public domain.
+
+    Price:   Free! But if you really appreciate Pants, or you're just a sicko,
+             please send me a picture of your worst or most unusual pair of
+             pants so I can add it to the Whirling Hall of Pants on pants.i2p,
+             the official Pants eepsite (that's an anonymous website on I2P--see
+             http://www.i2p.net for more information).
+
+
+$Id$

apps/pants/pants/resources/pbuild.template.properties

@@ -0,0 +1,110 @@
+# The properties defined in this file can be overridden on the command line by
+# passing them in as parameters like so:
+#
+#     ant -Dpbuild=myapp -Dversion.recommended=2.0.5 install
+#
+# *** DO NOT DEFINE A PROPERTY BUT LEAVE ITS VALUE BLANK. PANTS WILL BREAK! ***
+
+
+#     Recommended Package Version
+#
+# Set this property's value to the package version you want Pants to use for the
+# pbuild by default. The version string specified must match the version
+# substring from the package's filename if the filename contains a version
+# number.
+#
+# Comment out this property to force use of the latest available version.
+#
+# If the pbuild is CVS-based rather than package-based, this property must be
+# set to 'CVS'.
+#
+# Example:
+#
+# version.recommended=2.0.4
+
+
+#     Latest Package Version
+#
+# There are currently two ways to inform Pants of the latest version number for
+# your package.
+#
+# Method 1: Manually modify the property 'version.latest' to reflect the latest
+#           version number.
+#
+# Method 2: Provide a URL for a page on the package's website and a regular
+#           expression with which to parse it in order to extract the version
+#           number of the latest available package. For this you must define the
+#           properties 'version.latest.find.url', 'version.latest.find.regex',
+#           and any regular expression engine mode flags needed. The pattern
+#           defined must have exactly one capturing group to encapsulate the
+#           version string, otherwise the operation will fail.
+#
+# You may use both methods, in which case the version number specified by Method
+# 1 will be used as the fallback value if Method 2 for some reason is
+# unsuccessful.
+#
+# If neither method is enabled here or they fail to return a valid value to
+# Pants, the 'ant update' operation for this pbuild may exit ungracefully unless
+# the pbuild is CVS-based (none of the version.latest.* properties are used by
+# CVS-based pbuilds).
+#
+# The following is a list of boolean properties for optional mode flags used by
+# the regular expression engine. Set a value of "true" for any you wish to use.
+#
+# version.latest.find.regex.canonicaleq      - Enable canonical equivalence
+# version.latest.find.regex.caseinsensitive  - Enable case-insensitive matching
+# version.latest.find.regex.comments         - Permit whitespace and comments
+# version.latest.find.regex.dotall           - Enable dotall mode
+# version.latest.find.regex.multiline        - Enable multi-line mode
+# version.latest.find.regex.unicodecase      - Enable Unicode-aware case folding
+# version.latest.find.regex.unixlines        - Enable Unix lines mode
+#
+# Examples:
+#
+# version.latest=5.1.2
+# version.latest.find.url=http://sourceforge.net/projects/jetty/
+# version.latest.find.regex=Stable.+?Jetty-(.+?)</A>
+
+
+#     Package URL
+#
+# Specify the URL pointing to the pbuild's package from here. The token
+# '${pbuild.version}' if used will automatically be expanded to the appropriate
+# version string.
+#
+# The package URL property is not used by CVS-based pbuilds.
+#
+# Examples:
+#
+# package.url=ftp://borkbork.se/bork-${pbuild.version}.tar.bz2
+# package.url=http://bork.borkbork.se/bork-${pbuild.version}-src.tar.gz
+
+
+#     CVS Repository
+#
+# The values expected for CVS properties here are the same as those expected by
+# their corresponding Apache Ant 'Cvs' task attributes. For details see:
+#
+#     http://ant.apache.org/manual/CoreTasks/cvs.html
+#
+# Not all of the 'Cvs' task's attributes have corresponding Pants properties.
+# The following is a list of all valid CVS properties for Pants (and their
+# default values if applicable):
+#
+#     cvs.compression.level
+#     cvs.date
+#     cvs.package
+#     cvs.passfile=~/.cvspass
+#     cvs.port=2401
+#     cvs.root
+#     cvs.rsh
+#     cvs.tag
+#
+# Of these, only the 'cvs.root' property is required for CVS-based pbuilds.
+#
+# Examples:
+#
+# cvs.root=:pserver:anoncvs@borkbork.se:/cvsroot/bork
+# cvs.rsh=ssh
+# cvs.package=borkbork
+

apps/pants/pants/resources/pbuild.template.xml

@@ -0,0 +1,69 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!--
+  This is a template for Pants pbuilds. Pbuilds use standard Apache Ant syntax.
+  For each target in the Public Interface section you must provide either an
+  implementation or a stub. You may also add your own custom tasks and
+  properties to this file. Be careful that none of your custom properties'
+  names clash with the properties defined in pants/build.xml.
+-->
+
+<project basedir="." default="build" name="name-of-pbuild-here">
+
+<!-- ....................... Begin Public Interface ........................ -->
+
+	<!--
+	  When this target is called, the pbuild's sources and/or binaries have
+	  already been extracted/copied by Pants into the pbuild's working/
+	  subdirectory. This target must prepare those sources and/or binaries in
+	  the working/ subdirectory into deployable form, for example by building
+	  all necessary classes and jar files.
+	  
+	  This target must not create or modify any files outside the pbuild's
+	  working/ subdirectory. (An automatic sandboxing mechanism should be added
+	  to Pants at some point.) It is however acceptable for a task called by
+	  'builddep' to modify files outside of this pbuild's working/ directory.
+	-->
+	<target name="build" depends="builddep" />
+
+	<!--
+	  Use this to call targets from other pbuilds, Ant buildfiles, Makefiles,
+	  etc. which perform tasks this pbuild's 'build' target depends on. If other
+	  pbuilds are called here, they must be called through the Pants interface
+	  or else it may leave Pants in an inconsistent state.
+	  
+	  Most pbuilds probably won't need to implement this target.
+	-->
+	<target name="builddep" />
+
+	<!--
+	  This target must undo the actions performed by the 'build' target.
+	-->
+	<target name="clean" depends="depclean" />
+
+	<!--
+	  If the 'builddep' target is implemented, this target must be implemented
+	  to undo its actions.
+	-->
+	<target name="depclean" />
+
+	<!--
+	  This target must copy all deployable files generated by the 'build' target
+	  into the pbuild's dist/ subdirectory (for use by other pbuilds or Ant
+	  processes) or to their final deployment locations outside the pants/
+	  directory hierarchy. Note that the latter may require the user to gain
+	  superuser/admin privileges.
+	-->
+	<target name="dist" depends="build" />
+
+	<!--
+	  This target must remove all files from the pbuild's dist/ subdirectory
+	  and final deployment locations, reversing the actions of the 'dist'
+	  target. Note that removal of files from their final deployment locations
+	  may require the user to gain superuser/admin privileges.
+	-->
+	<target name="distclean" depends="clean" />
+
+<!-- ........................ End Public Interface ......................... -->
+
+</project>

apps/pants/pbuilds/fortuna/pbuild.properties

@@ -0,0 +1,112 @@
+# The properties defined in this file can be overridden on the command line by
+# passing them in as parameters like so:
+#
+#     ant -Dpbuild=myapp -Dversion.recommended=2.0.5 install
+#
+# *** DO NOT DEFINE A PROPERTY BUT LEAVE ITS VALUE BLANK. PANTS WILL BREAK! ***
+
+
+#     Recommended Package Version
+#
+# Set this property's value to the package version you want Pants to use for the
+# pbuild by default. The version string specified must match the version
+# substring from the package's filename if the filename contains a version
+# number.
+#
+# Comment out this property to force use of the latest available version.
+#
+# If the pbuild is CVS-based rather than package-based, this property must be
+# set to 'CVS'.
+#
+# Example:
+#
+# version.recommended=2.0.4
+version.recommended=CVS
+
+#     Latest Package Version
+#
+# There are currently two ways to inform Pants of the latest version number for
+# your package.
+#
+# Method 1: Manually modify the property 'version.latest' to reflect the latest
+#           version number.
+#
+# Method 2: Provide a URL for a page on the package's website and a regular
+#           expression with which to parse it in order to extract the version
+#           number of the latest available package. For this you must define the
+#           properties 'version.latest.find.url', 'version.latest.find.regex',
+#           and any regular expression engine mode flags needed. The pattern
+#           defined must have exactly one capturing group to encapsulate the
+#           version string, otherwise the operation will fail.
+#
+# You may use both methods, in which case the version number specified by Method
+# 1 will be used as the fallback value if Method 2 for some reason is
+# unsuccessful.
+#
+# If neither method is enabled here or they fail to return a valid value to
+# Pants, the 'ant update' operation for this pbuild may exit ungracefully unless
+# the pbuild is CVS-based (none of the version.latest.* properties are used by
+# CVS-based pbuilds).
+#
+# The following is a list of boolean properties for optional mode flags used by
+# the regular expression engine. Set a value of "true" for any you wish to use.
+#
+# version.latest.find.regex.canonicaleq      - Enable canonical equivalence
+# version.latest.find.regex.caseinsensitive  - Enable case-insensitive matching
+# version.latest.find.regex.comments         - Permit whitespace and comments
+# version.latest.find.regex.dotall           - Enable dotall mode
+# version.latest.find.regex.multiline        - Enable multi-line mode
+# version.latest.find.regex.unicodecase      - Enable Unicode-aware case folding
+# version.latest.find.regex.unixlines        - Enable Unix lines mode
+#
+# Examples:
+#
+# version.latest=5.1.2
+# version.latest.find.url=http://sourceforge.net/projects/jetty/
+# version.latest.find.regex=Stable.+?Jetty-(.+?)</A>
+
+
+#     Package URL
+#
+# Specify the URL pointing to the pbuild's package from here. The token
+# '${pbuild.version}' if used will automatically be expanded to the appropriate
+# version string.
+#
+# The package URL property is not used by CVS-based pbuilds.
+#
+# Examples:
+#
+# package.url=ftp://borkbork.se/bork-${pbuild.version}.tar.bz2
+# package.url=http://bork.borkbork.se/bork-${pbuild.version}-src.tar.gz
+
+
+#     CVS Repository
+#
+# The values expected for CVS properties here are the same as those expected by
+# their corresponding Apache Ant 'Cvs' task attributes. For details see:
+#
+#     http://ant.apache.org/manual/CoreTasks/cvs.html
+#
+# Not all of the 'Cvs' task's attributes have corresponding Pants properties.
+# The following is a list of all valid CVS properties for Pants (and their
+# default values if applicable):
+#
+#     cvs.compression.level
+#     cvs.date
+#     cvs.package
+#     cvs.passfile=~/.cvspass
+#     cvs.port=2401
+#     cvs.root
+#     cvs.rsh
+#     cvs.tag
+#
+# Of these, only the 'cvs.root' property is required for CVS-based pbuilds.
+#
+# Examples:
+#
+# cvs.root=:pserver:anoncvs@borkbork.se:/cvsroot/bork
+# cvs.rsh=ssh
+# cvs.package=borkbork
+cvs.root=:ext:anoncvs@savannah.gnu.org:/cvsroot/gnu-crypto
+cvs.rsh=ssh
+cvs.package=gnu-crypto

apps/pants/pbuilds/fortuna/pbuild.xml

@@ -0,0 +1,127 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project basedir="." default="build" name="fortuna-pbuild">
+
+	<property name="gnucrypt.base.dir" value="./working/gnu-crypto" />
+	<property name="gnucrypt.etc.dir" value="${gnucrypt.base.dir}/etc" />
+	<property name="gnucrypt.lib.dir" value="${gnucrypt.base.dir}/lib" />
+	<property name="gnucrypt.object.dir" value="${gnucrypt.base.dir}/classes" />
+	<property name="gnucrypt.base.crypto.object.dir" value="${gnucrypt.object.dir}/gnu/crypto" />
+	<property name="gnucrypt.cipher.object.dir" value="${gnucrypt.base.crypto.object.dir}/cipher" />
+	<property name="gnucrypt.hash.object.dir" value="${gnucrypt.base.crypto.object.dir}/hash" />
+	<property name="gnucrypt.prng.object.dir" value="${gnucrypt.base.crypto.object.dir}/prng" />
+
+	<patternset id="fortuna.files">
+		<include name="${gnucrypt.base.crypto.object.dir}/Registry.class" />
+		<include name="${gnucrypt.prng.object.dir}/Fortuna*.class" />
+		<include name="${gnucrypt.prng.object.dir}/BasePRNG.class" />
+		<include name="${gnucrypt.prng.object.dir}/RandomEventListener.class" />
+		<include name="${gnucrypt.prng.object.dir}/IRandom.class" />
+		<include name="${gnucrypt.cipher.object.dir}/CipherFactory.class" />
+		<include name="${gnucrypt.cipher.object.dir}/IBlockCipher.class" />
+		<include name="${gnucrypt.hash.object.dir}/HashFactory.class" />
+		<include name="${gnucrypt.hash.object.dir}/IMessageDigest.class" />
+	</patternset>
+
+	<!--
+		Add this when Fortuna tests are added to GNU Crypto, else write some
+	-->
+	<target name="-test" />
+
+<!-- ....................... Begin Public Interface ........................ -->
+
+	<!--
+	  When this target is called, the pbuild's sources and/or binaries have
+	  already been extracted/copied by Pants into the pbuild's working/
+	  subdirectory. This target must prepare those sources and/or binaries in
+	  the working/ subdirectory into deployable form, for example by building
+	  all necessary classes and jar files.
+	  
+	  This target must not create or modify any files outside the pbuild's
+	  working/ subdirectory. (An automatic sandboxing mechanism should be added
+	  to Pants at some point.) It is however acceptable for a task called by
+	  'builddep' to modify files outside of this pbuild's working/ directory.
+	-->
+	<target name="build" depends="builddep">
+		<delete dir="./working/build" />
+		<delete dir="./working/jartemp" />
+		<mkdir dir="./working/build" />
+		<mkdir dir="./working/jartemp/${gnucrypt.object.dir}" />
+		<copy todir="./working/jartemp">
+			<fileset dir=".">
+				<patternset refid="fortuna.files" />
+			</fileset>
+		</copy>
+		<jar basedir="./working/jartemp/${gnucrypt.object.dir}" jarfile="./working/build/fortuna.jar">
+			<manifest>
+				<section name="fortuna">
+					<attribute name="Implementation-Title" value="I2P Custom GNU Crypto Fortuna Library" />
+					<attribute name="Implementation-Version" value="CVS HEAD" /> 
+					<attribute name="Implementation-Vendor" value="Free Software Foundation" />
+					<attribute name="Implementation-Vendor-Id" value="FSF" />
+					<attribute name="Implementation-URL" value="http://www.gnu.org/software/gnu-crypto" />
+				</section>
+			</manifest>
+		</jar>
+		<delete dir="./working/jartemp" />
+	</target>
+
+	<!--
+	  Use this to call targets from other pbuilds, Ant buildfiles, Makefiles,
+	  etc. which perform tasks this pbuild's 'build' target depends on. If other
+	  pbuilds are called here, they must be called through the Pants interface
+	  or else it may leave Pants in an inconsistent state.
+	  
+	  Most pbuilds probably won't need to implement this target.
+	-->
+	<target name="builddep">
+		<ant dir="${gnucrypt.base.dir}" target="jar" />
+	</target>
+
+	<!--
+	  This target must undo the actions performed by the 'build' target.
+	-->
+	<target name="clean" depends="depclean">
+		<delete dir="./working/jartemp" />
+	</target>
+
+	<!--
+	  If the 'builddep' target is implemented, this target must be implemented
+	  to undo its actions.
+	-->
+	<target name="depclean">
+		<!--
+			Annoyingly the GNU Crypto distclean task called here doesn't clean
+			*all* derived files from java/gnu-crypto/lib like it should (because
+			a couple of lines are commented out).....
+		-->
+		<ant dir="${gnucrypt.base.dir}" target="distclean" />
+		<!--
+			.....and so we mop up the rest ourselves.
+		-->
+		<delete dir="${gnucrypt.lib.dir}" />
+	</target>
+
+	<!--
+	  This target must copy all deployable files generated by the 'build' target
+	  into the pbuild's dist/ subdirectory (for use by other pbuilds or Ant
+	  processes) or to their final deployment locations outside the pants/
+	  directory hierarchy. Note that the latter may require the user to gain
+	  superuser/admin privileges.
+	-->
+	<target name="dist" depends="build">
+		<copy todir="./dist/fortuna.jar" file="./working/build/fortuna.jar" />
+	</target>
+
+	<!--
+	  This target must remove all files from the pbuild's dist/ subdirectory
+	  and final deployment locations, reversing the actions of the 'dist'
+	  target. Note that removal of files from their final deployment locations
+	  may require the user to gain superuser/admin privileges.
+	-->
+	<target name="distclean" depends="clean">
+		<delete file="./dist/fortuna.jar" />
+	</target>
+
+<!-- ........................ End Public Interface ......................... -->
+
+</project>

apps/pants/pbuilds/jetty/pbuild.properties

@@ -0,0 +1,112 @@
+# The properties defined in this file can be overridden on the command line by
+# passing them in as parameters like so:
+#
+#     ant -Dpbuild=myapp -Dversion.recommended=2.0.5 install
+#
+# *** DO NOT DEFINE A PROPERTY BUT LEAVE ITS VALUE BLANK. PANTS WILL BREAK! ***
+
+
+#     Recommended Package Version
+#
+# Set this property's value to the package version you want Pants to use for the
+# pbuild by default. The version string specified must match the version
+# substring from the package's filename if the filename contains a version
+# number.
+#
+# Comment out this property to force use of the latest available version.
+#
+# If the pbuild is CVS-based rather than package-based, this property must be
+# set to 'CVS'.
+#
+# Example:
+#
+# version.recommended=2.0.4
+version.recommended=5.1.2
+
+#     Latest Package Version
+#
+# There are currently two ways to inform Pants of the latest version number for
+# your package.
+#
+# Method 1: Manually modify the property 'version.latest' to reflect the latest
+#           version number.
+#
+# Method 2: Provide a URL for a page on the package's website and a regular
+#           expression with which to parse it in order to extract the version
+#           number of the latest available package. For this you must define the
+#           properties 'version.latest.find.url', 'version.latest.find.regex',
+#           and any regular expression engine mode flags needed. The pattern
+#           defined must have exactly one capturing group to encapsulate the
+#           version string, otherwise the operation will fail.
+#
+# You may use both methods, in which case the version number specified by Method
+# 1 will be used as the fallback value if Method 2 for some reason is
+# unsuccessful.
+#
+# If neither method is enabled here or they fail to return a valid value to
+# Pants, the 'ant update' operation for this pbuild may exit ungracefully unless
+# the pbuild is CVS-based (none of the version.latest.* properties are used by
+# CVS-based pbuilds).
+#
+# The following is a list of boolean properties for optional mode flags used by
+# the regular expression engine. Set a value of "true" for any you wish to use.
+#
+# version.latest.find.regex.canonicaleq      - Enable canonical equivalence
+# version.latest.find.regex.caseinsensitive  - Enable case-insensitive matching
+# version.latest.find.regex.comments         - Permit whitespace and comments
+# version.latest.find.regex.dotall           - Enable dotall mode
+# version.latest.find.regex.multiline        - Enable multi-line mode
+# version.latest.find.regex.unicodecase      - Enable Unicode-aware case folding
+# version.latest.find.regex.unixlines        - Enable Unix lines mode
+#
+# Examples:
+#
+# version.latest=5.1.2
+# version.latest.find.url=http://sourceforge.net/projects/jetty/
+# version.latest.find.regex=Stable.+?Jetty-(.+?)</A>
+version.latest=5.1.2
+version.latest.find.url=http://sourceforge.net/projects/jetty/
+version.latest.find.regex=Stable.+?Jetty-(.+?)</A>
+
+#     Package URL
+#
+# Specify the URL pointing to the pbuild's package from here. The token
+# '${pbuild.version}' if used will automatically be expanded to the appropriate
+# version string.
+#
+# The package URL property is not used by CVS-based pbuilds.
+#
+# Examples:
+#
+# package.url=ftp://borkbork.se/bork-${pbuild.version}.tar.bz2
+# package.url=http://bork.borkbork.se/bork-${pbuild.version}-src.tar.gz
+package.url=http://mesh.dl.sourceforge.net/sourceforge/jetty/jetty-${pbuild.version}.zip
+
+#     CVS Repository
+#
+# The values expected for CVS properties here are the same as those expected by
+# their corresponding Apache Ant 'Cvs' task attributes. For details see:
+#
+#     http://ant.apache.org/manual/CoreTasks/cvs.html
+#
+# Not all of the 'Cvs' task's attributes have corresponding Pants properties.
+# The following is a list of all valid CVS properties for Pants (and their
+# default values if applicable):
+#
+#     cvs.compression.level
+#     cvs.date
+#     cvs.package
+#     cvs.passfile=~/.cvspass
+#     cvs.port=2401
+#     cvs.root
+#     cvs.rsh
+#     cvs.tag
+#
+# Of these, only the 'cvs.root' property is required for CVS-based pbuilds.
+#
+# Examples:
+#
+# cvs.root=:pserver:anoncvs@borkbork.se:/cvsroot/bork
+# cvs.rsh=ssh
+# cvs.package=borkbork
+

apps/pants/pbuilds/jetty/pbuild.xml

@@ -0,0 +1,89 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project basedir="." default="all" name="jetty">
+
+	<!-- make this generic, place variables in properties file -->
+
+	<target name="all" depends="build"
+		description="Run the build target" />
+
+	<target name="assignProperties" if="group.0">
+		<property name="latest.jetty.version" value="${group.1}" />
+		<available property="jetty.package.available" file="jetty-${latest.jetty.version}.zip" />
+		<available property="jetty.package.unpacked.available" file="jettypkg/jetty-${latest.jetty.version}" />
+		<echo message="Properties assigned" />
+	</target>
+
+	<target name="build" depends="init, unpackJettyPackage" if="latest.jetty.version"
+		description="Download latest Jetty package and copy needed libs to jettylib/">
+		<property name="unpack.dir" value="jettypkg/jetty-${latest.jetty.version}" />
+		<copy todir="jettylib" overwrite="true" file="${unpack.dir}/ext/ant.jar" />
+		<copy todir="jettylib" overwrite="true" file="${unpack.dir}/ext/jasper-compiler.jar" />
+		<copy todir="jettylib" overwrite="true" file="${unpack.dir}/ext/jasper-runtime.jar" />
+		<copy todir="jettylib" overwrite="true" file="${unpack.dir}/ext/xercesImpl.jar" />
+		<copy todir="jettylib" overwrite="true" file="${unpack.dir}/ext/xml-apis.jar" />
+		<copy todir="jettylib" overwrite="true" file="${unpack.dir}/extra/lib/org.mortbay.jetty-jdk1.2.jar" />
+		<copy todir="jettylib" overwrite="true" file="${unpack.dir}/lib/javax.servlet.jar" />
+		<copy todir="jettylib" overwrite="true" file="${unpack.dir}/lib/org.mortbay.jetty.jar" />
+		<copy todir="jettylib" overwrite="true">
+			<fileset dir="${unpack.dir}/ext" includes="xmlParserAPIs*.jar" />
+		</copy>
+	</target>
+
+	<target name="builddep"
+		description="Build the custom helper Ant task for this buildfile">
+		<mkdir dir="java/build"/>
+		<javac srcdir="./java/src" source="1.3" target="1.3" deprecation="on" destdir="./java/build" />
+	</target>
+
+	<target name="clean"
+		description="Remove temp files and zip only; jettypkg/ requires manual deletion">
+		<echo message="Not actually deleting the Jetty package directory since it's so large" />
+		<delete>
+			<fileset dir="." includes="*.zip jettytemp.html parsed.temp" />
+		</delete>
+	</target>
+
+	<target name="cleandep"
+		description="Remove custom helper Ant task">
+		<delete dir="java/build" />
+	</target>
+
+	<target name="compile" />
+
+	<target name="distclean" depends="clean"
+		description="Remove temp files, zip and jettylib/ contents" >
+		<delete>
+			<fileset dir="jettylib" includes="*.jar"/>
+		</delete>
+	</target>
+
+	<target name="fetchJettyPackage" if="latest.jetty.version" unless="jetty.package.available">
+		<echo message="The Jetty libs are not necessary for using I2P, but are used by some" />
+		<echo message="applications on top of I2P such as the routerconsole." />
+		<get src="http://mesh.dl.sourceforge.net/sourceforge/jetty/jetty-${latest.jetty.version}.zip" verbose="true" dest="jetty-${latest.jetty.version}.zip" />
+	</target>
+
+	<target name="init" depends="builddep">
+		<echo message="Checking SourceForge for latest Jetty version....." />
+		<get src="http://sourceforge.net/projects/jetty/" dest="jettytemp.html" verbose="true" />
+		<taskdef name="match" classname="net.i2p.pants.MatchTask" classpath="../../lib/pants.jar" />
+		<match input="jettytemp.html"
+			output="parsed.temp"
+			regex="Stable.+?Jetty-(.+?)&lt;/A&gt;"
+			/>
+		<loadproperties srcFile="parsed.temp" />
+		<antcall target="assignProperties" />
+	</target>
+
+	<target name="jar" />
+
+	<target name="showlatest" depends="init"
+		description="Display latest version number for Jetty">
+		<echo message="Latest Jetty version: ${latest.jetty.version}" />
+	</target>
+
+	<target name="unpackJettyPackage" depends="fetchJettyPackage" if="latest.jetty.version" unless="jetty.package.unpacked.available">
+		<mkdir dir="jettypkg" />
+		<unzip src="jetty-${latest.jetty.version}.zip" dest="jettypkg" />
+	</target>
+</project>

apps/pants/world

@@ -0,0 +1,2 @@
+version.using.fortuna=CVS
+version.using.jetty=5.1.2

apps/routerconsole/java/build.xml

@@ -20,7 +20,7 @@
             <classpath>
                 <pathelement location="../../../core/java/build/i2p.jar" />
                 <pathelement location="../../../router/java/build/router.jar" />
-                <pathelement location="../../jetty/jettylib/org.mortbay.jetty-jdk1.2.jar" />
+                <pathelement location="../../jetty/jettylib/org.mortbay.jetty.jar" />
                 <pathelement location="../../jetty/jettylib/javax.servlet.jar" />
                 <pathelement location="../../systray/java/build/systray.jar" />
                 <pathelement location="../../systray/java/lib/systray4j.jar" />
@@ -48,20 +48,24 @@
         <mkdir dir="../jsp/WEB-INF/" />
         <mkdir dir="../jsp/WEB-INF/classes" />
         <!-- there are various jspc ant tasks, but they all seem a bit flakey -->
-        <java classname="org.apache.jasper.JspC" fork="true" >
+        <java classname="org.apache.jasper.JspC" fork="true">
             <classpath>
                 <pathelement location="../../jetty/jettylib/jasper-compiler.jar" />
                 <pathelement location="../../jetty/jettylib/jasper-runtime.jar" />
                 <pathelement location="../../jetty/jettylib/javax.servlet.jar" />
+                <pathelement location="../../jetty/jettylib/commons-logging.jar" />
+                <pathelement location="../../jetty/jettylib/commons-el.jar" />
                 <pathelement location="../../jetty/jettylib/ant.jar" />
                 <pathelement location="../../systray/java/build/obj" />
-                <pathelement location="../../systray/java/lib/systray4j.jar" /> <!-- some javacs resolve recursively... -->
-                <pathelement location="../../../installer/lib/wrapper/win32/wrapper.jar" /> <!-- we dont care if we're not on win32 -->
+                <pathelement location="../../systray/java/lib/systray4j.jar" />
+                <pathelement location="../../../installer/lib/wrapper/win32/wrapper.jar" />
                 <pathelement location="build/routerconsole.jar" />
+                <pathelement location="../../../router/java/build/router.jar" />
+                <pathelement location="../../../core/java/build/i2p.jar" />
             </classpath>
             <arg value="-d" />
             <arg value="../jsp/WEB-INF/classes" />
-            <arg value="-v9" />
+            <arg value="-v" />
             <arg value="-p" />
             <arg value="net.i2p.router.web.jsp" />
             <arg value="-webinc" />
@@ -69,10 +73,15 @@
             <arg value="-webapp" />
             <arg value="../jsp/" />
         </java>
-        <javac destdir="../jsp/WEB-INF/classes/" srcdir="../jsp/WEB-INF/classes" includes="*.java">
+        
+        <javac debug="true" deprecation="on" source="1.3" target="1.3" 
+               destdir="../jsp/WEB-INF/classes/" 
+               srcdir="../jsp/WEB-INF/classes" includes="**/*.java">
             <classpath>
                 <pathelement location="../../jetty/jettylib/jasper-runtime.jar" />
                 <pathelement location="../../jetty/jettylib/javax.servlet.jar" />
+                <pathelement location="../../jetty/jettylib/commons-logging.jar" />
+                <pathelement location="../../jetty/jettylib/commons-el.jar" />
                 <pathelement location="build/routerconsole.jar" />
             </classpath>
         </javac>

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

@@ -17,11 +17,6 @@ public class ConfigAdvancedHandler extends FormHandler {
     private boolean _shouldSave;
     private String _config;
     
-    public void ConfigNetHandler() {
-        _shouldSave = false;
-        _forceRestart = false;
-    }
-    
     protected void processForm() {
         if (_shouldSave) {
             saveChanges();

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

@@ -1,84 +0,0 @@
-package net.i2p.router.web;
-
-import net.i2p.router.ClientTunnelSettings;
-
-/**
- * Handler to deal with form submissions from the client config form and act
- * upon the values.
- *
- */
-public class ConfigClientsHandler extends FormHandler {
-    private String _numClients;
-    private String _numTunnels;
-    private String _numHops;
-    private String _numHopsOutbound;
-    private boolean _shouldSave;
-    
-    public void ConfigNetHandler() {
-        _shouldSave = false;
-    }
-    
-    protected void processForm() {
-        if (_shouldSave) {
-            saveChanges();
-        } else {
-            // noop
-        }
-    }
-    
-    public void setShouldsave(String moo) { _shouldSave = true; }
-    
-    public void setClientcount(String num) {
-        _numClients = (num != null ? num.trim(): null);
-    }
-    public void setTunnelcount(String num) {
-        _numTunnels = (num != null ? num.trim() : null);
-    }
-    public void setTunneldepth(String num) {
-        _numHops = (num != null ? num.trim() : null);
-    }
-    public void setTunneldepthoutbound(String num) {
-        _numHopsOutbound = (num != null ? num.trim() : null);
-    }
-    
-    /**
-     * The user made changes to the network config and wants to save them, so
-     * lets go ahead and do so.
-     *
-     */
-    private void saveChanges() {
-        boolean saveRequired = false;
-        
-        if ( (_numClients != null) && (_numClients.length() > 0) ) {
-            _context.router().setConfigSetting("router.targetClients", _numClients);
-            addFormNotice("Updating estimated number of clients to " + _numClients);
-            saveRequired = true;
-        }
-        
-        if ( (_numTunnels != null) && (_numTunnels.length() > 0) ) {
-            _context.router().setConfigSetting(ClientTunnelSettings.PROP_NUM_INBOUND, _numTunnels);
-            addFormNotice("Updating default number of tunnels per client to " + _numTunnels);
-            saveRequired = true;
-        }
-        
-        if ( (_numHops != null) && (_numHops.length() > 0) ) {
-            _context.router().setConfigSetting(ClientTunnelSettings.PROP_DEPTH_INBOUND, _numHops);
-            addFormNotice("Updating default tunnel length to " + _numHops);
-            saveRequired = true;
-        }
-        
-        if ( (_numHopsOutbound != null) && (_numHopsOutbound.length() > 0) ) {
-            _context.router().setConfigSetting(ClientTunnelSettings.PROP_DEPTH_OUTBOUND, _numHopsOutbound);
-            addFormNotice("Updating default outbound tunnel length to " + _numHopsOutbound);
-            saveRequired = true;
-        }
-        
-        if (saveRequired) {
-            boolean saved = _context.router().saveConfig();
-            if (saved) 
-                addFormNotice("Configuration saved successfully");
-            else
-                addFormNotice("Error saving the configuration (applied but not saved) - please see the error logs");
-        }
-    }
-}

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

@@ -1,144 +0,0 @@
-package net.i2p.router.web;
-
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.util.List;
-import java.util.Iterator;
-import java.util.TreeMap;
-
-import net.i2p.util.Log;
-
-import net.i2p.router.RouterContext;
-import net.i2p.router.ClientTunnelSettings;
-
-public class ConfigClientsHelper {
-    private RouterContext _context;
-    /**
-     * Configure this bean to query a particular router context
-     *
-     * @param contextId begging few characters of the routerHash, or null to pick
-     *                  the first one we come across.
-     */
-    public void setContextId(String contextId) {
-        try {
-            _context = ContextHelper.getContext(contextId);
-        } catch (Throwable t) {
-            t.printStackTrace();
-        }
-    }
-
-    /** copied from the package private {@link net.i2p.router.tunnelmanager.TunnelPool} */
-    public final static String TARGET_CLIENTS_PARAM = "router.targetClients";
-    /** copied from the package private {@link net.i2p.router.tunnelmanager.TunnelPool} */
-    public final static int TARGET_CLIENTS_DEFAULT = 3;
-
-    public ConfigClientsHelper() {}
-    
-    public String getClientCountSelectBox() {
-        int count = TARGET_CLIENTS_DEFAULT;
-        String val = _context.router().getConfigSetting(TARGET_CLIENTS_PARAM);
-        if (val != null) {
-            try {
-                count = Integer.parseInt(val);
-            } catch (NumberFormatException nfe) {
-                // ignore, use default from above
-            }
-        }
-        StringBuffer buf = new StringBuffer(1024);
-        buf.append("<select name=\"clientcount\">\n");
-        for (int i = 0; i < 5; i++) {
-            buf.append("<option value=\"").append(i).append("\" ");
-            if (count == i)
-                buf.append("selected=\"true\" ");
-            buf.append(">").append(i).append("</option>\n");
-        }
-        if (count >= 5) {
-            buf.append("<option value=\"").append(count);
-            buf.append("\" selected>").append(count);
-            buf.append("</option>\n");
-        }
-        buf.append("</select>\n");
-        return buf.toString();
-    }
-    
-    public String getTunnelCountSelectBox() {
-        int count = ClientTunnelSettings.DEFAULT_NUM_INBOUND;
-        String val = _context.router().getConfigSetting(ClientTunnelSettings.PROP_NUM_INBOUND);
-        if (val != null) {
-            try {
-                count = Integer.parseInt(val);
-            } catch (NumberFormatException nfe) {
-                // ignore, use default from above
-            }
-        }
-        StringBuffer buf = new StringBuffer(1024);
-        buf.append("<select name=\"tunnelcount\">\n");
-        for (int i = 0; i < 4; i++) {
-            buf.append("<option value=\"").append(i).append("\" ");
-            if (count == i)
-                buf.append("selected=\"true\" ");
-            buf.append(">").append(i).append("</option>\n");
-        }
-        if (count >= 4) {
-            buf.append("<option value=\"").append(count);
-            buf.append("\" selected>").append(count);
-            buf.append("</option>\n");
-        }
-        buf.append("</select>\n");
-        return buf.toString();
-    }
-    
-    public String getTunnelDepthSelectBox() {
-        int count = ClientTunnelSettings.DEFAULT_DEPTH_INBOUND;
-        String val = _context.router().getConfigSetting(ClientTunnelSettings.PROP_DEPTH_INBOUND);
-        if (val != null) {
-            try {
-                count = Integer.parseInt(val);
-            } catch (NumberFormatException nfe) {
-                // ignore, use default from above
-            }
-        }
-        StringBuffer buf = new StringBuffer(1024);
-        buf.append("<select name=\"tunneldepth\">\n");
-        for (int i = 0; i < 4; i++) {
-            buf.append("<option value=\"").append(i).append("\" ");
-            if (count == i)
-                buf.append("selected=\"true\" ");
-            buf.append(">").append(i).append("</option>\n");
-        }
-        if (count >= 4) {
-            buf.append("<option value=\"").append(count);
-            buf.append("\" selected>").append(count);
-            buf.append("</option>\n");
-        }
-        buf.append("</select>\n");
-        return buf.toString();
-    }
-    
-    public String getTunnelDepthOutboundSelectBox() {
-        int count = ClientTunnelSettings.DEFAULT_DEPTH_OUTBOUND;
-        String val = _context.router().getConfigSetting(ClientTunnelSettings.PROP_DEPTH_OUTBOUND);
-        if (val != null) {
-            try {
-                count = Integer.parseInt(val);
-            } catch (NumberFormatException nfe) {
-                // ignore, use default from above
-            }
-        }
-        StringBuffer buf = new StringBuffer(1024);
-        buf.append("<select name=\"tunneldepthoutbound\">\n");
-        for (int i = 0; i < 4; i++) {
-            buf.append("<option value=\"").append(i).append("\" ");
-            if (count == i)
-                buf.append("selected=\"true\" ");
-            buf.append(">").append(i).append("</option>\n");
-        }
-        if (count >= 4) {
-            buf.append("<option value=\"").append(count);
-            buf.append("\" selected>").append(count);
-            buf.append("</option>\n");
-        }
-        buf.append("</select>\n");
-        return buf.toString();
-    }
-}

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

@@ -1,11 +1,8 @@
 package net.i2p.router.web;
 
 import java.io.ByteArrayInputStream;
-import java.io.BufferedReader;
 import java.io.IOException;
-import java.io.InputStreamReader;
 import java.util.Properties;
-import net.i2p.util.Log;
 
 /**
  * Handler to deal with form submissions from the logging config form and act
@@ -21,10 +18,6 @@ public class ConfigLoggingHandler extends FormHandler {
     private String _dateFormat;
     private String _fileSize;
     
-    public void ConfigNetHandler() {
-        _shouldSave = false;
-    }
-    
     protected void processForm() {
         if (_shouldSave) {
             saveChanges();

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

@@ -1,14 +1,9 @@
 package net.i2p.router.web;
 
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
 import java.util.Iterator;
-import java.util.List;
 import java.util.Properties;
 import java.util.TreeSet;
 
-import net.i2p.util.Log;
-
 import net.i2p.router.RouterContext;
 
 public class ConfigLoggingHelper {

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

@@ -13,15 +13,10 @@ import java.net.URLConnection;
 
 import java.util.HashSet;
 import java.util.Iterator;
-import java.util.List;
 import java.util.Set;
 
-import net.i2p.util.Log;
 import net.i2p.time.Timestamper;
 
-import net.i2p.router.RouterContext;
-import net.i2p.router.ClientTunnelSettings;
-
 /**
  * Handler to deal with form submissions from the main config form and act
  * upon the values.
@@ -39,13 +34,7 @@ public class ConfigNetHandler extends FormHandler {
     private String _outboundRate;
     private String _outboundBurst;
     private String _reseedFrom;
-    
-    public void ConfigNetHandler() {
-        _guessRequested = false;
-        _reseedRequested = false;
-        _saveRequested = false;
-        _timeSyncEnabled = false;
-    }
+    private String _sharePct;
     
     protected void processForm() {
         if (_guessRequested) {
@@ -85,6 +74,9 @@ public class ConfigNetHandler extends FormHandler {
     public void setReseedfrom(String url) { 
         _reseedFrom = (url != null ? url.trim() : null); 
     }
+    public void setSharePercentage(String pct) {
+        _sharePct = (pct != null ? pct.trim() : null);
+    }
 
     private static final String IP_PREFIX = "<h1>Your IP is ";
     private static final String IP_SUFFIX = " <br></h1>";
@@ -229,6 +221,14 @@ public class ConfigNetHandler extends FormHandler {
         
         updateRates();
         
+        if (_sharePct != null) {
+            String old = _context.router().getConfigSetting(ConfigNetHelper.PROP_SHARE_PERCENTAGE);
+            if ( (old == null) || (!old.equalsIgnoreCase(_sharePct)) ) {
+                _context.router().setConfigSetting(ConfigNetHelper.PROP_SHARE_PERCENTAGE, _sharePct);
+                addFormNotice("Updating bandwidth share percentage");
+            }
+        }
+        
         if (_timeSyncEnabled) {
             // Time sync enable, means NOT disabled 
             _context.router().setConfigSetting(Timestamper.PROP_DISABLED, "false");

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

@@ -1,16 +1,7 @@
 package net.i2p.router.web;
 
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.util.List;
-import java.util.Iterator;
-import java.util.TreeMap;
-
 import net.i2p.time.Timestamper;
-import net.i2p.util.Log;
-
 import net.i2p.router.RouterContext;
-import net.i2p.router.ClientTunnelSettings;
 
 public class ConfigNetHelper {
     private RouterContext _context;
@@ -62,6 +53,8 @@ public class ConfigNetHelper {
     public static final String PROP_OUTBOUND_KBPS = "i2np.bandwidth.outboundKBytesPerSecond";
     public static final String PROP_INBOUND_BURST = "i2np.bandwidth.inboundBurstKBytes";
     public static final String PROP_OUTBOUND_BURST = "i2np.bandwidth.outboundBurstKBytes";
+    public static final String PROP_SHARE_PERCENTAGE = "router.sharePercentage";
+    public static final int DEFAULT_SHARE_PERCENTAGE = 80;
 
     public String getInboundRate() {
         String rate = _context.getProperty(PROP_INBOUND_KBPS);
@@ -135,4 +128,26 @@ public class ConfigNetHelper {
         buf.append("</select>\n");
         return buf.toString();
     }
+    
+    public String getSharePercentageBox() {
+        String pctStr = _context.getProperty(PROP_SHARE_PERCENTAGE);
+        int pct = DEFAULT_SHARE_PERCENTAGE;
+        if (pctStr != null)
+            try { pct = Integer.parseInt(pctStr); } catch (NumberFormatException nfe) {}
+        StringBuffer buf = new StringBuffer(256);
+        buf.append("<select name=\"sharePercentage\">\n");
+        boolean found = false;
+        for (int i = 30; i <= 100; i += 10) {
+            buf.append("<option value=\"").append(i).append("\" ");
+            if (pct == i) {
+                buf.append("selected=\"true\" ");
+                found = true;
+            } else if ( (i == DEFAULT_SHARE_PERCENTAGE) && (!found) ) {
+                buf.append("selected=\"true\" ");
+            }
+            buf.append(">Up to ").append(i).append("%</option>\n");
+        }
+        buf.append("</select>\n");
+        return buf.toString();
+    }
 }

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

@@ -8,7 +8,6 @@ import java.util.Properties;
 import java.util.TreeMap;
 
 import net.i2p.data.DataHelper;
-import net.i2p.router.ClientTunnelSettings;
 import net.i2p.router.Router;
 import net.i2p.apps.systray.SysTray;
 import net.i2p.apps.systray.UrlLauncher;
@@ -20,9 +19,8 @@ import org.tanukisoftware.wrapper.WrapperManager;
  *
  */
 public class ConfigServiceHandler extends FormHandler {
-    public void ConfigNetHandler() {}
     
-    private class UpdateWrapperManagerTask implements Runnable {
+    public static class UpdateWrapperManagerTask implements Runnable {
         private int _exitCode;
         public UpdateWrapperManagerTask(int exitCode) {
             _exitCode = exitCode;

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

@@ -0,0 +1,154 @@
+package net.i2p.router.web;
+
+import java.util.HashMap;
+import java.util.Map;
+import net.i2p.data.Hash;
+import net.i2p.data.DataFormatException;
+import net.i2p.util.Log;
+import net.i2p.router.TunnelPoolSettings;
+
+/**
+ * Handler to deal with form submissions from the tunnel config form and act
+ * upon the values.  Holy crap, this is UUUUGLY
+ *
+ */
+public class ConfigTunnelsHandler extends FormHandler {
+    private Log _log;
+    private Map _settings;
+    private boolean _shouldSave;
+    
+    public ConfigTunnelsHandler() {
+        _shouldSave = false;
+    }
+    
+    protected void processForm() {
+        if (_shouldSave) {
+            saveChanges();
+        } else {
+            // noop
+        }
+    }
+    
+    public void setShouldsave(String moo) { 
+        if ( (moo != null) && (moo.equals("Save changes")) )
+            _shouldSave = true; 
+    }
+    
+    public void setSettings(Map settings) { _settings = new HashMap(settings); }
+    
+    /**
+     * The user made changes to the network config and wants to save them, so
+     * lets go ahead and do so.
+     *
+     */
+    private void saveChanges() {
+        _log = _context.logManager().getLog(ConfigTunnelsHandler.class);
+        boolean saveRequired = false;
+        
+        if (_log.shouldLog(Log.DEBUG))
+            _log.debug("Saving changes, with props = " + _settings);
+        
+        int updated = 0;
+        int index = 0;
+        while (true) {
+            Object val = _settings.get("pool." + index);
+            if (val == null) break;
+            Hash client = new Hash();
+            
+            String poolName = (val instanceof String ? (String)val : ((String[])val)[0]);
+            
+            TunnelPoolSettings in = null;
+            TunnelPoolSettings out = null;
+            if ("exploratory".equals(poolName)) {
+                in = _context.tunnelManager().getInboundSettings();
+                out = _context.tunnelManager().getOutboundSettings();
+            } else {
+                try {
+                    client.fromBase64(poolName);
+                } catch (DataFormatException dfe) {
+                    addFormError("Internal error (pool name could not resolve - " + poolName + ")");
+                    index++;
+                    continue;
+                }
+                in = _context.tunnelManager().getInboundSettings(client);
+                out = _context.tunnelManager().getOutboundSettings(client);
+            }
+            
+            if ( (in == null) || (out == null) ) {
+                addFormError("Internal error (pool settings cound not be fuond for " + poolName + ")");
+                index++;
+                continue;
+            }
+            
+            in.setLength(getInt(_settings.get(index + ".depthInbound")));
+            out.setLength(getInt(_settings.get(index + ".depthOutbound")));
+            in.setLengthVariance(getInt(_settings.get(index + ".varianceInbound")));
+            out.setLengthVariance(getInt(_settings.get(index + ".varianceOutbound")));
+            in.setQuantity(getInt(_settings.get(index + ".quantityInbound")));
+            out.setQuantity(getInt(_settings.get(index + ".quantityOutbound")));
+            in.setBackupQuantity(getInt(_settings.get(index + ".backupInbound")));
+            out.setBackupQuantity(getInt(_settings.get(index + ".backupOutbound")));
+            
+            if ("exploratory".equals(poolName)) {
+                _context.router().setConfigSetting(TunnelPoolSettings.PREFIX_INBOUND_EXPLORATORY + 
+                                                   TunnelPoolSettings.PROP_LENGTH, in.getLength()+"");
+                _context.router().setConfigSetting(TunnelPoolSettings.PREFIX_OUTBOUND_EXPLORATORY + 
+                                                   TunnelPoolSettings.PROP_LENGTH, out.getLength()+"");
+                _context.router().setConfigSetting(TunnelPoolSettings.PREFIX_INBOUND_EXPLORATORY + 
+                                                   TunnelPoolSettings.PROP_LENGTH_VARIANCE, in.getLengthVariance()+"");
+                _context.router().setConfigSetting(TunnelPoolSettings.PREFIX_OUTBOUND_EXPLORATORY + 
+                                                   TunnelPoolSettings.PROP_LENGTH_VARIANCE, out.getLengthVariance()+"");
+                _context.router().setConfigSetting(TunnelPoolSettings.PREFIX_INBOUND_EXPLORATORY + 
+                                                   TunnelPoolSettings.PROP_QUANTITY, in.getQuantity()+"");
+                _context.router().setConfigSetting(TunnelPoolSettings.PREFIX_OUTBOUND_EXPLORATORY + 
+                                                   TunnelPoolSettings.PROP_QUANTITY, out.getQuantity()+"");
+                _context.router().setConfigSetting(TunnelPoolSettings.PREFIX_INBOUND_EXPLORATORY + 
+                                                   TunnelPoolSettings.PROP_BACKUP_QUANTITY, in.getBackupQuantity()+"");
+                _context.router().setConfigSetting(TunnelPoolSettings.PREFIX_OUTBOUND_EXPLORATORY + 
+                                                   TunnelPoolSettings.PROP_BACKUP_QUANTITY, out.getBackupQuantity()+"");
+            }
+            
+            if ("exploratory".equals(poolName)) {
+                if (_log.shouldLog(Log.DEBUG)) {
+                    _log.debug("Inbound exploratory settings: " + in);
+                    _log.debug("Outbound exploratory settings: " + out);
+                }
+                _context.tunnelManager().setInboundSettings(in);
+                _context.tunnelManager().setOutboundSettings(out);
+            } else {
+                if (_log.shouldLog(Log.DEBUG)) {
+                    _log.debug("Inbound settings for " + client.toBase64() + ": " + in);
+                    _log.debug("Outbound settings for " + client.toBase64() + ": " + out);
+                }
+                _context.tunnelManager().setInboundSettings(client, in);
+                _context.tunnelManager().setOutboundSettings(client, out);
+            }
+            
+            updated++;
+            saveRequired = true;
+            index++;
+        }
+        
+        if (updated > 0)
+            addFormNotice("Updated settings for " + updated + " pools");
+        
+        if (saveRequired) {
+            boolean saved = _context.router().saveConfig();
+            if (saved) 
+                addFormNotice("Configuration saved successfully");
+            else
+                addFormNotice("Error saving the configuration (applied but not saved) - please see the error logs");
+        }
+    }
+    private static final int getInt(Object val) { 
+        if (val == null) return 0;
+        String str = null;
+        if (val instanceof String)
+            str = (String)val;
+        else 
+            str = ((String[])val)[0];
+            
+        if (str.trim().length() <= 0) return 0;
+        try { return Integer.parseInt(str); } catch (NumberFormatException nfe) { return 0; }
+    }
+}

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

@@ -0,0 +1,246 @@
+package net.i2p.router.web;
+
+import java.util.Iterator;
+import java.util.Set;
+import java.util.Properties;
+import net.i2p.data.Destination;
+import net.i2p.router.RouterContext;
+import net.i2p.router.TunnelPoolSettings;
+
+public class ConfigTunnelsHelper {
+    private RouterContext _context;
+    /**
+     * Configure this bean to query a particular router context
+     *
+     * @param contextId begging few characters of the routerHash, or null to pick
+     *                  the first one we come across.
+     */
+    public void setContextId(String contextId) {
+        try {
+            _context = ContextHelper.getContext(contextId);
+        } catch (Throwable t) {
+            t.printStackTrace();
+        }
+    }
+
+    public ConfigTunnelsHelper() {}
+    
+    
+    public String getForm() {
+        StringBuffer buf = new StringBuffer(1024);
+        buf.append("<table border=\"1\">\n");
+        TunnelPoolSettings exploratoryIn = _context.tunnelManager().getInboundSettings();
+        TunnelPoolSettings exploratoryOut = _context.tunnelManager().getOutboundSettings();
+        
+        buf.append("<input type=\"hidden\" name=\"pool.0\" value=\"exploratory\" >");
+        renderForm(buf, 0, "exploratory", "Exploratory tunnels", exploratoryIn, exploratoryOut);
+        
+        int cur = 1;
+        Set clients = _context.clientManager().listClients();
+        for (Iterator iter = clients.iterator(); iter.hasNext(); ) {
+            Destination dest = (Destination)iter.next();
+            TunnelPoolSettings in = _context.tunnelManager().getInboundSettings(dest.calculateHash());
+            TunnelPoolSettings out = _context.tunnelManager().getOutboundSettings(dest.calculateHash());
+            
+            if ( (in == null) || (out == null) ) continue;
+            
+            String name = in.getDestinationNickname();
+            if (name == null)
+                name = out.getDestinationNickname();
+            if (name == null)
+                name = dest.calculateHash().toBase64().substring(0,6);
+        
+            String prefix = dest.calculateHash().toBase64().substring(0,4);
+            buf.append("<input type=\"hidden\" name=\"pool.").append(cur).append("\" value=\"");
+            buf.append(dest.calculateHash().toBase64()).append("\" >");    
+            renderForm(buf, cur, prefix, "Client tunnels for " + name, in, out);
+            cur++;
+        }
+        
+        buf.append("</table>\n");
+        return buf.toString();
+    }
+
+    private void renderForm(StringBuffer buf, int index, String prefix, String name, TunnelPoolSettings in, TunnelPoolSettings out) {
+
+        buf.append("<tr><td colspan=\"3\"><b><a name=\"").append(prefix).append("\">");
+        buf.append(name).append("</a></b></td></tr>\n");
+        buf.append("<tr><td></td><td><b>Inbound</b></td><td><b>Outbound</b></td></tr>\n");
+        
+        // tunnel depth
+        buf.append("<tr><td>Depth</td>\n");
+        buf.append("<td><select name=\"").append(index).append(".depthInbound\">\n");
+        buf.append("<option value=\"0\" ");
+        if (in.getLength() <= 0) buf.append(" selected=\"true\" ");
+        buf.append(">0 hops</option>\n");
+        buf.append("<option value=\"1\" ");
+        if (in.getLength() == 1) buf.append(" selected=\"true\" ");
+        buf.append(">1 hop</option>\n");
+        buf.append("<option value=\"2\" ");
+        if (in.getLength() == 2) buf.append(" selected=\"true\" ");
+        buf.append(">2 hops</option>\n");
+        buf.append("<option value=\"3\" ");
+        if (in.getLength() == 3) buf.append(" selected=\"true\" ");
+        buf.append(">3 hops</option>\n");
+        if (in.getLength() > 3)
+            buf.append("<option value=\"").append(in.getLength()).append("\">").append(in.getLength()).append(" hops</option>\n");
+        buf.append("</td>\n");
+
+        buf.append("<td><select name=\"").append(index).append(".depthOutbound\">\n");
+        buf.append("<option value=\"0\" ");
+        if (out.getLength() <= 0) buf.append(" selected=\"true\" ");
+        buf.append(">0 hops</option>\n");
+        buf.append("<option value=\"1\" ");
+        if (out.getLength() == 1) buf.append(" selected=\"true\" ");
+        buf.append(">1 hop</option>\n");
+        buf.append("<option value=\"2\" ");
+        if (out.getLength() == 2) buf.append(" selected=\"true\" ");
+        buf.append(">2 hops</option>\n");
+        buf.append("<option value=\"3\" ");
+        if (out.getLength() == 3) buf.append(" selected=\"true\" ");
+        buf.append(">3 hops</option>\n");
+        if (out.getLength() > 3)
+            buf.append("<option value=\"").append(out.getLength()).append("\">").append(out.getLength()).append(" hops</option>\n");
+        buf.append("</td>\n");
+        buf.append("</tr>\n");
+
+        // tunnel depth variance
+        buf.append("<tr><td>Randomization</td>\n");
+        buf.append("<td><select name=\"").append(index).append(".varianceInbound\">\n");
+        buf.append("<option value=\"0\" ");
+        if (in.getLengthVariance() == 0) buf.append(" selected=\"true\" ");
+        buf.append(">0 hops</option>\n");
+        buf.append("<option value=\"-1\" ");
+        if (in.getLengthVariance() == -1) buf.append(" selected=\"true\" ");
+        buf.append(">+/- 0-1 hops</option>\n");
+        buf.append("<option value=\"-2\" ");
+        if (in.getLengthVariance() == -2) buf.append(" selected=\"true\" ");
+        buf.append(">+/- 0-2 hops</option>\n");
+        buf.append("<option value=\"1\" ");
+        if (in.getLengthVariance() == 1) buf.append(" selected=\"true\" ");
+        buf.append(">+ 0-1 hops</option>\n");
+        buf.append("<option value=\"2\" ");
+        if (in.getLengthVariance() == 2) buf.append(" selected=\"true\" ");
+        buf.append(">+ 0-2 hops</option>\n");
+        if (in.getLengthVariance() < -2)
+            buf.append("<option value=\"").append(in.getLengthVariance()).append("\">+/- 0-").append(in.getLengthVariance()).append(" hops</option>\n");
+        if (in.getLengthVariance() > 2)
+            buf.append("<option value=\"").append(in.getLengthVariance()).append("\">+ 0-").append(in.getLengthVariance()).append(" hops</option>\n");
+        buf.append("</td>\n");
+
+        buf.append("<td><select name=\"").append(index).append(".varianceOutbound\">\n");
+        buf.append("<option value=\"0\" ");
+        if (out.getLengthVariance() == 0) buf.append(" selected=\"true\" ");
+        buf.append(">0 hops</option>\n");
+        buf.append("<option value=\"-1\" ");
+        if (out.getLengthVariance() == -1) buf.append(" selected=\"true\" ");
+        buf.append(">+/- 0-1 hops</option>\n");
+        buf.append("<option value=\"-2\" ");
+        if (out.getLengthVariance() == -2) buf.append(" selected=\"true\" ");
+        buf.append(">+/- 0-2 hops</option>\n");
+        buf.append("<option value=\"1\" ");
+        if (out.getLengthVariance() == 1) buf.append(" selected=\"true\" ");
+        buf.append(">+ 0-1 hops</option>\n");
+        buf.append("<option value=\"2\" ");
+        if (out.getLengthVariance() == 2) buf.append(" selected=\"true\" ");
+        buf.append(">+ 0-2 hops</option>\n");
+        if (out.getLengthVariance() < -2)
+            buf.append("<option value=\"").append(out.getLengthVariance()).append("\">+/- 0-").append(out.getLengthVariance()).append(" hops</option>\n");
+        if (out.getLengthVariance() > 2)
+            buf.append("<option value=\"").append(out.getLengthVariance()).append("\">+ 0-").append(out.getLengthVariance()).append(" hops</option>\n");
+        buf.append("</td>\n");
+
+        // tunnel quantity
+        buf.append("<tr><td>Quantity</td>\n");
+        buf.append("<td><select name=\"").append(index).append(".quantityInbound\">\n");
+        buf.append("<option value=\"1\" ");
+        if (in.getQuantity() <= 1) buf.append(" selected=\"true\" ");
+        buf.append(">1 tunnel</option>\n");
+        buf.append("<option value=\"2\" ");
+        if (in.getQuantity() == 2) buf.append(" selected=\"true\" ");
+        buf.append(">2 tunnels</option>\n");
+        buf.append("<option value=\"3\" ");
+        if (in.getQuantity() == 3) buf.append(" selected=\"true\" ");
+        buf.append(">3 tunnels</option>\n");
+        if (in.getQuantity() > 3)
+            buf.append("<option value=\"").append(in.getQuantity()).append("\">").append(in.getQuantity()).append(" tunnels</option>\n");
+        buf.append("</td>\n");
+
+        buf.append("<td><select name=\"").append(index).append(".quantityOutbound\">\n");
+        buf.append("<option value=\"1\" ");
+        if (out.getQuantity() <= 1) buf.append(" selected=\"true\" ");
+        buf.append(">1 tunnel</option>\n");
+        buf.append("<option value=\"2\" ");
+        if (out.getQuantity() == 2) buf.append(" selected=\"true\" ");
+        buf.append(">2 tunnels</option>\n");
+        buf.append("<option value=\"3\" ");
+        if (out.getQuantity() == 3) buf.append(" selected=\"true\" ");
+        buf.append(">3 tunnels</option>\n");
+        if (out.getQuantity() > 3)
+            buf.append("<option value=\"").append(out.getQuantity()).append("\">").append(out.getQuantity()).append(" tunnels</option>\n");
+        buf.append("</td>\n");
+        buf.append("</tr>\n");
+
+        // tunnel backup quantity
+        buf.append("<tr><td>Backup quantity</td>\n");
+        buf.append("<td><select name=\"").append(index).append(".backupInbound\">\n");
+        buf.append("<option value=\"0\" ");
+        if (in.getBackupQuantity() <= 0) buf.append(" selected=\"true\" ");
+        buf.append(">0 tunnels</option>\n");
+        buf.append("<option value=\"1\" ");
+        if (in.getBackupQuantity() == 1) buf.append(" selected=\"true\" ");
+        buf.append(">1 tunnel</option>\n");
+        buf.append("<option value=\"2\" ");
+        if (in.getBackupQuantity() == 2) buf.append(" selected=\"true\" ");
+        buf.append(">2 tunnels</option>\n");
+        buf.append("<option value=\"3\" ");
+        if (in.getBackupQuantity() == 3) buf.append(" selected=\"true\" ");
+        buf.append(">3 tunnels</option>\n");
+        if (in.getBackupQuantity() > 3)
+            buf.append("<option value=\"").append(in.getBackupQuantity()).append("\">").append(in.getBackupQuantity()).append(" tunnels</option>\n");
+        buf.append("</td>\n");
+
+        buf.append("<td><select name=\"").append(index).append(".backupOutbound\">\n");
+        buf.append("<option value=\"0\" ");
+        if (out.getBackupQuantity() <= 0) buf.append(" selected=\"true\" ");
+        buf.append(">0 tunnel</option>\n");
+        buf.append("<option value=\"1\" ");
+        if (out.getBackupQuantity() == 1) buf.append(" selected=\"true\" ");
+        buf.append(">1 tunnel</option>\n");
+        buf.append("<option value=\"2\" ");
+        if (out.getBackupQuantity() == 2) buf.append(" selected=\"true\" ");
+        buf.append(">2 tunnels</option>\n");
+        buf.append("<option value=\"3\" ");
+        if (out.getBackupQuantity() == 3) buf.append(" selected=\"true\" ");
+        buf.append(">3 tunnels</option>\n");
+        if (out.getBackupQuantity() > 3)
+            buf.append("<option value=\"").append(out.getBackupQuantity()).append("\">").append(out.getBackupQuantity()).append(" tunnels</option>\n");
+        buf.append("</td>\n");
+        buf.append("</tr>\n");
+
+        // custom options
+        buf.append("<tr><td>Inbound options:</td>\n");
+        buf.append("<td colspan=\"2\"><input name=\"").append(index);
+        buf.append(".inboundOptions\" type=\"text\" size=\"40\" ");
+        buf.append("value=\"");
+        Properties props = in.getUnknownOptions();
+        for (Iterator iter = props.keySet().iterator(); iter.hasNext(); ) {
+            String prop = (String)iter.next();
+            String val = (String)props.getProperty(prop);
+            buf.append(prop).append("=").append(val).append(" ");
+        }
+        buf.append("\"/></td></tr>\n");
+        buf.append("<tr><td>Outbound options:</td>\n");
+        buf.append("<td colspan=\"2\"><input name=\"").append(index);
+        buf.append(".outboundOptions\" type=\"text\" size=\"40\" ");
+        buf.append("value=\"");
+        props = in.getUnknownOptions();
+        for (Iterator iter = props.keySet().iterator(); iter.hasNext(); ) {
+            String prop = (String)iter.next();
+            String val = (String)props.getProperty(prop);
+            buf.append(prop).append("=").append(val).append(" ");
+        }
+        buf.append("\"/></td></tr>\n");
+        buf.append("<tr><td colspan=\"3\"><hr /></td></tr>\n");
+    }
+}

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

@@ -0,0 +1,103 @@
+package net.i2p.router.web;
+
+import net.i2p.data.DataHelper;
+
+/**
+ *
+ */
+public class ConfigUpdateHandler extends FormHandler {
+    private String _newsURL;
+    private long _refreshFrequency;
+    private String _updateURL;
+    private String _updatePolicy;
+    private String _proxyHost;
+    private String _proxyPort;
+    private boolean _updateThroughProxy;
+    private String _trustedKeys;
+
+    public static final String PROP_NEWS_URL = "router.newsURL";
+    public static final String DEFAULT_NEWS_URL = "http://dev.i2p.net/cgi-bin/cvsweb.cgi/i2p/news.xml?rev=HEAD";
+    public static final String PROP_REFRESH_FREQUENCY = "router.newsRefreshFrequency";
+    public static final String DEFAULT_REFRESH_FREQUENCY = 12*60*60*1000 + "";
+    public static final String PROP_UPDATE_URL = "router.updateURL";
+    public static final String DEFAULT_UPDATE_URL = "http://dev.i2p.net/i2p/i2pupdate.sud";
+    public static final String PROP_UPDATE_POLICY = "router.updatePolicy";
+    public static final String DEFAULT_UPDATE_POLICY = "notify";
+    public static final String PROP_SHOULD_PROXY = "router.updateThroughProxy";
+    public static final String DEFAULT_SHOULD_PROXY = Boolean.FALSE.toString();
+    public static final String PROP_PROXY_HOST = "router.updateProxyHost";
+    public static final String DEFAULT_PROXY_HOST = "localhost";
+    public static final String PROP_PROXY_PORT = "router.updateProxyPort";
+    public static final String DEFAULT_PROXY_PORT = "4444";
+    
+    protected void processForm() {
+        if ( (_newsURL != null) && (_newsURL.length() > 0) ) {
+            String oldURL = _context.router().getConfigSetting(PROP_NEWS_URL);
+            if ( (oldURL == null) || (!_newsURL.equals(oldURL)) ) {
+                _context.router().setConfigSetting(PROP_NEWS_URL, _newsURL);
+                addFormNotice("Updating news URL to " + _newsURL);
+            }
+        }
+        if ( (_updateURL != null) && (_updateURL.length() > 0) ) {
+            String oldURL = _context.router().getConfigSetting(PROP_UPDATE_URL);
+            if ( (oldURL == null) || (!_updateURL.equals(oldURL)) ) {
+                _context.router().setConfigSetting(PROP_UPDATE_URL, _updateURL);
+                addFormNotice("Updating update URL to " + _updateURL);
+            }
+        }
+        
+        if ( (_proxyHost != null) && (_proxyHost.length() > 0) ) {
+            String oldHost = _context.router().getConfigSetting(PROP_PROXY_HOST);
+            if ( (oldHost == null) || (!_proxyHost.equals(oldHost)) ) {
+                _context.router().setConfigSetting(PROP_PROXY_HOST, _proxyHost);
+                addFormNotice("Updating proxy host to " + _proxyHost);
+            }
+        }
+        
+        if ( (_proxyPort != null) && (_proxyPort.length() > 0) ) {
+            String oldPort = _context.router().getConfigSetting(PROP_PROXY_PORT);
+            if ( (oldPort == null) || (!_proxyHost.equals(oldPort)) ) {
+                _context.router().setConfigSetting(PROP_PROXY_PORT, _proxyPort);
+                addFormNotice("Updating proxy port to " + _proxyPort);
+            }
+        }
+        
+        if (_updateThroughProxy) {
+            _context.router().setConfigSetting(PROP_SHOULD_PROXY, Boolean.TRUE.toString());
+        } else {
+            _context.router().setConfigSetting(PROP_SHOULD_PROXY, Boolean.FALSE.toString());
+        }
+        
+        String oldFreqStr = _context.router().getConfigSetting(PROP_REFRESH_FREQUENCY);
+        long oldFreq = -1;
+        if (oldFreqStr != null) 
+            try { oldFreq = Long.parseLong(oldFreqStr); } catch (NumberFormatException nfe) {}
+        if (_refreshFrequency != oldFreq) {
+            _context.router().setConfigSetting(PROP_REFRESH_FREQUENCY, ""+_refreshFrequency);
+            addFormNotice("Updating refresh frequency to " + DataHelper.formatDuration(_refreshFrequency));
+        }
+
+        if ( (_updatePolicy != null) && (_updatePolicy.length() > 0) ) {
+            String oldPolicy = _context.router().getConfigSetting(PROP_UPDATE_POLICY);
+            if ( (oldPolicy == null) || (!_updatePolicy.equals(oldPolicy)) ) {
+                _context.router().setConfigSetting(PROP_UPDATE_POLICY, _updatePolicy);
+                addFormNotice("Updating update policy to " + _updatePolicy);
+            }
+        }
+        
+        // should save the keys...
+        
+        _context.router().saveConfig();
+    }
+    
+    public void setNewsURL(String url) { _newsURL = url; }
+    public void setRefreshFrequency(String freq) {
+        try { _refreshFrequency = Long.parseLong(freq); } catch (NumberFormatException nfe) {}
+    }
+    public void setUpdateURL(String url) { _updateURL = url; }
+    public void setUpdatePolicy(String policy) { _updatePolicy = policy; }
+    public void setTrustedKeys(String keys) { _trustedKeys = keys; }
+    public void setUpdateThroughProxy(String foo) { _updateThroughProxy = true; }
+    public void setProxyHost(String host) { _proxyHost = host; }
+    public void setProxyPort(String port) { _proxyPort = port; }
+}

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

@@ -0,0 +1,123 @@
+package net.i2p.router.web;
+
+import java.util.List;
+import net.i2p.data.DataHelper;
+import net.i2p.crypto.TrustedUpdate;
+import net.i2p.router.RouterContext;
+
+public class ConfigUpdateHelper {
+    private RouterContext _context;
+    /**
+     * Configure this bean to query a particular router context
+     *
+     * @param contextId begging few characters of the routerHash, or null to pick
+     *                  the first one we come across.
+     */
+    public void setContextId(String contextId) {
+        try {
+            _context = ContextHelper.getContext(contextId);
+        } catch (Throwable t) {
+            t.printStackTrace();
+        }
+    }
+
+    public ConfigUpdateHelper() {}
+    
+    public boolean updateAvailable() {
+        return true;
+    }
+    
+    public String getNewsURL() {
+        String url = _context.getProperty(ConfigUpdateHandler.PROP_NEWS_URL);
+        if (url != null)
+            return url;
+        else
+            return ConfigUpdateHandler.DEFAULT_NEWS_URL;
+    }
+    public String getUpdateURL() {
+        String url = _context.getProperty(ConfigUpdateHandler.PROP_UPDATE_URL);
+        if (url != null)
+            return url;
+        else
+            return ConfigUpdateHandler.DEFAULT_UPDATE_URL;
+    }
+    public String getProxyHost() {
+        String host = _context.getProperty(ConfigUpdateHandler.PROP_PROXY_HOST);
+        if (host != null)
+            return host;
+        else
+            return ConfigUpdateHandler.DEFAULT_PROXY_HOST;
+    }
+    public String getProxyPort() {
+        String port = _context.getProperty(ConfigUpdateHandler.PROP_PROXY_PORT);
+        if (port != null)
+            return port;
+        else
+            return ConfigUpdateHandler.DEFAULT_PROXY_PORT;
+    }
+    
+    public String getUpdateThroughProxy() {
+        String proxy = _context.getProperty(ConfigUpdateHandler.PROP_SHOULD_PROXY, ConfigUpdateHandler.DEFAULT_SHOULD_PROXY);
+        if (Boolean.valueOf(proxy).booleanValue()) 
+            return "<input type=\"checkbox\" value=\"true\" name=\"updateThroughProxy\" checked=\"true\" >";
+        else
+            
+            return "<input type=\"checkbox\" value=\"true\" name=\"updateThroughProxy\" >";
+    }
+    
+    private static final long PERIODS[] = new long[] { 12*60*60*1000l, 24*60*60*1000l, 48*60*60*1000l, -1l };
+    
+    public String getRefreshFrequencySelectBox() {
+        String freq = _context.getProperty(ConfigUpdateHandler.PROP_REFRESH_FREQUENCY);
+        if (freq == null) freq = ConfigUpdateHandler.DEFAULT_REFRESH_FREQUENCY;
+        long ms = -1;
+        try { 
+            ms = Long.parseLong(freq);
+        } catch (NumberFormatException nfe) {}
+
+        StringBuffer buf = new StringBuffer(256);
+        buf.append("<select name=\"refreshFrequency\">");
+        for (int i = 0; i < PERIODS.length; i++) {
+            buf.append("<option value=\"").append(PERIODS[i]);
+            if (PERIODS[i] == ms)
+                buf.append("\" selected=\"true\"");
+            
+            if (PERIODS[i] == -1)
+                buf.append("\">Never</option>\n");
+            else
+                buf.append("\">Every ").append(DataHelper.formatDuration(PERIODS[i])).append("</option>\n");
+        }
+        buf.append("</select>\n");
+        return buf.toString();
+    }
+    
+    public String getUpdatePolicySelectBox() {
+        String policy = _context.getProperty(ConfigUpdateHandler.PROP_UPDATE_POLICY);
+        if (policy == null) policy = ConfigUpdateHandler.DEFAULT_UPDATE_POLICY;
+        
+        StringBuffer buf = new StringBuffer(256);
+        buf.append("<select name=\"updatePolicy\">");
+        
+        if ("notify".equals(policy))
+            buf.append("<option value=\"notify\" selected=\"true\">Notify only</option>");
+        else
+            buf.append("<option value=\"notify\">Notify only</option>");
+
+        if ("install".equals(policy))
+            buf.append("<option value=\"install\" selected=\"true\">Download and install</option>");
+        else
+            buf.append("<option value=\"install\">Download and install</option>");
+        
+        buf.append("</select>\n");
+        return buf.toString();
+    }
+    
+    public String getTrustedKeys() {
+        StringBuffer buf = new StringBuffer(1024);
+        TrustedUpdate up = new TrustedUpdate(_context);
+        List keys = up.getTrustedKeys();
+        for (int i = 0; i < keys.size(); i++) 
+            buf.append((String)keys.get(i)).append('\n');
+        return buf.toString();
+    }
+}

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

@@ -1,9 +1,5 @@
 package net.i2p.router.web;
 
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.util.List;
-
 import net.i2p.router.RouterContext;
 import net.i2p.util.FileUtil;
 

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

@@ -3,10 +3,7 @@ package net.i2p.router.web;
 import java.util.List;
 import java.util.ArrayList;
 
-import net.i2p.util.Log;
-
 import net.i2p.router.RouterContext;
-import net.i2p.router.ClientTunnelSettings;
 
 /**
  * Simple form handler base class - does not depend on servlets or jsp,

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

@@ -1,7 +1,5 @@
 package net.i2p.router.web;
 
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
 import java.util.List;
 
 import net.i2p.router.RouterContext;
@@ -41,6 +39,22 @@ public class LogsHelper {
         return buf.toString();
     }
     
+    public String getCriticalLogs() {
+        List msgs = _context.logManager().getBuffer().getMostRecentCriticalMessages();
+        StringBuffer buf = new StringBuffer(16*1024); 
+        buf.append("<ul>");
+        buf.append("<code>\n");
+        for (int i = msgs.size(); i > 0; i--) { 
+            String msg = (String)msgs.get(i - 1);
+            buf.append("<li>");
+            buf.append(msg);
+            buf.append("</li>\n");
+        }
+        buf.append("</code></ul>\n");
+        
+        return buf.toString();
+    }
+    
     public String getServiceLogs() {
         String str = FileUtil.readTextFile("wrapper.log", 500, false);
         if (str == null) 

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

@@ -0,0 +1,240 @@
+package net.i2p.router.web;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.util.List;
+import java.util.StringTokenizer;
+
+import net.i2p.I2PAppContext;
+import net.i2p.data.DataHelper;
+import net.i2p.router.RouterContext;
+import net.i2p.router.RouterVersion;
+import net.i2p.util.EepGet;
+import net.i2p.util.Log;
+
+/**
+ * Task to periodically look for updates to the news.xml, and to keep
+ * track of whether that has an announcement for a new version.
+ */
+public class NewsFetcher implements Runnable, EepGet.StatusListener {
+    private I2PAppContext _context;
+    private Log _log;
+    private boolean _updateAvailable;
+    private long _lastFetch;
+    private static NewsFetcher _instance;
+    public static final NewsFetcher getInstance() { return _instance; }
+    
+    private static final String NEWS_FILE = "docs/news.xml";
+    
+    public NewsFetcher(I2PAppContext ctx) {
+        _context = ctx;
+        _log = ctx.logManager().getLog(NewsFetcher.class);
+        _instance = this;
+        File news = new File(NEWS_FILE);
+        if (news.exists())
+            _lastFetch = news.lastModified();
+        else
+            _lastFetch = 0;
+    }
+    
+    public boolean updateAvailable() { return _updateAvailable; }
+    
+    public void run() {
+        try { Thread.sleep(_context.random().nextLong(5*60*1000)); } catch (InterruptedException ie) {}
+        while (true) {
+            if (!_updateAvailable) checkForUpdates();
+            if (shouldFetchNews())
+                fetchNews();
+            try { Thread.sleep(10*60*1000); } catch (InterruptedException ie) {}
+        }
+    }
+    
+    private boolean shouldInstall() {
+        String policy = _context.getProperty(ConfigUpdateHandler.PROP_UPDATE_POLICY);
+        return ("install".equals(policy));
+    }
+    
+    private boolean shouldFetchNews() {
+        String freq = _context.getProperty(ConfigUpdateHandler.PROP_REFRESH_FREQUENCY);
+        if (freq == null)
+            freq = ConfigUpdateHandler.DEFAULT_REFRESH_FREQUENCY;
+        try {
+            long ms = Long.parseLong(freq);
+            if (ms <= 0)
+                return false;
+            
+            if (_lastFetch + ms < _context.clock().now()) {
+                return true;
+            } else {
+                if (_log.shouldLog(Log.DEBUG))
+                    _log.debug("Last fetched " + DataHelper.formatDuration(_context.clock().now() - _lastFetch) + " ago");
+                return false;
+            }
+        } catch (NumberFormatException nfe) {
+            if (_log.shouldLog(Log.ERROR))
+                _log.error("Invalid refresh frequency: " + freq);
+            return false;
+        }
+    }
+    private void fetchNews() {
+        String newsURL = _context.getProperty(ConfigUpdateHandler.PROP_NEWS_URL, ConfigUpdateHandler.DEFAULT_NEWS_URL);
+        boolean shouldProxy = Boolean.valueOf(_context.getProperty(ConfigUpdateHandler.PROP_SHOULD_PROXY, ConfigUpdateHandler.DEFAULT_SHOULD_PROXY)).booleanValue();
+        String proxyHost = _context.getProperty(ConfigUpdateHandler.PROP_PROXY_HOST, ConfigUpdateHandler.DEFAULT_PROXY_HOST);
+        String port = _context.getProperty(ConfigUpdateHandler.PROP_PROXY_PORT, ConfigUpdateHandler.DEFAULT_PROXY_PORT);
+        int proxyPort = -1;
+        try {
+            proxyPort = Integer.parseInt(port);
+            EepGet get = null;
+            if (shouldProxy)
+                get = new EepGet(_context, proxyHost, proxyPort, 10, NEWS_FILE, newsURL);
+            else
+                get = new EepGet(_context, 10, NEWS_FILE, newsURL);
+            get.addStatusListener(this);
+            get.fetch();
+        } catch (Throwable t) {
+            _log.error("Error fetching the news", t);
+        }
+
+        _lastFetch = _context.clock().now();
+    }
+    
+    private static final String VERSION_STRING = "version=\"" + RouterVersion.VERSION + "\"";
+    private static final String VERSION_PREFIX = "version=\"";
+    private void checkForUpdates() {
+        File news = new File(NEWS_FILE);
+        if (!news.exists()) return;
+        FileInputStream in = null;
+        try {
+            in = new FileInputStream(news);
+            StringBuffer buf = new StringBuffer(128);
+            while (DataHelper.readLine(in, buf)) {
+                int index = buf.indexOf(VERSION_PREFIX);
+                if (index == -1) {
+                    // skip
+                } else {
+                    int end = buf.indexOf("\"", index + VERSION_PREFIX.length());
+                    if (end > index) {
+                        String ver = buf.substring(index+VERSION_PREFIX.length(), end);
+                        if (_log.shouldLog(Log.DEBUG))
+                            _log.debug("Found version: [" + ver + "]");
+                        if (needsUpdate(ver)) {
+                            if (_log.shouldLog(Log.DEBUG))
+                                _log.debug("Our version is out of date, update!");
+                            break;
+                        } else {
+                            if (_log.shouldLog(Log.DEBUG))
+                                _log.debug("Our version is current");
+                            return;
+                        }
+                    }
+                }
+                if (buf.indexOf(VERSION_STRING) != -1) {
+                    if (_log.shouldLog(Log.DEBUG))
+                        _log.debug("Our version found, no need to update: " + buf.toString());
+                    return;
+                } else {
+                    if (_log.shouldLog(Log.DEBUG))
+                        _log.debug("No match in " + buf.toString());
+                }
+                buf.setLength(0);
+            }
+        } catch (IOException ioe) {
+            if (_log.shouldLog(Log.WARN))
+                _log.warn("Error checking the news for an update", ioe);
+            return;
+        } finally {
+            if (in != null) try { in.close(); } catch (IOException ioe) {}
+        }
+        // could not find version="0.5.0.1", so there must be an update ;)
+        
+        if (_log.shouldLog(Log.DEBUG))
+            _log.debug("Our version was NOT found (" + RouterVersion.VERSION + "), update needed");
+        _updateAvailable = true;
+        
+        if (shouldInstall()) {
+            if (_log.shouldLog(Log.DEBUG))
+                _log.debug("Policy requests update, so we update");
+            UpdateHandler handler = null;
+            if (_context instanceof RouterContext) {
+                handler = new UpdateHandler((RouterContext)_context);
+            } else {
+                List contexts = RouterContext.listContexts();
+                if (contexts.size() > 0)
+                    handler = new UpdateHandler((RouterContext)contexts.get(0));
+                else
+                    _log.log(Log.CRIT, "No router context to update with?");
+            }
+            if (handler != null)
+                handler.update();
+        } else {
+            if (_log.shouldLog(Log.DEBUG))
+                _log.debug("Policy requests manual update, so we do nothing");
+        }
+    }
+    
+    private boolean needsUpdate(String version) {
+        StringTokenizer newTok = new StringTokenizer(sanitize(version), ".");
+        StringTokenizer ourTok = new StringTokenizer(sanitize(RouterVersion.VERSION), ".");
+        
+        while (newTok.hasMoreTokens() && ourTok.hasMoreTokens()) {
+            String newVer = newTok.nextToken();
+            String oldVer = ourTok.nextToken();
+            switch (compare(newVer, oldVer)) {
+                case -1: // newVer is smaller
+                    return false;
+                case 0: // eq
+                    break;
+                case 1: // newVer is larger
+                    return true;
+            }
+        }
+        if (newTok.hasMoreTokens() && !ourTok.hasMoreTokens())
+            return true;
+        return false;
+    }
+    
+    private static final String VALID = "0123456789.";
+    private static final String sanitize(String str) {
+        StringBuffer buf = new StringBuffer(str);
+        for (int i = 0; i < buf.length(); i++) {
+            if (VALID.indexOf(buf.charAt(i)) == -1) {
+                buf.deleteCharAt(i);
+                i--;
+            }
+        }
+        return buf.toString();
+    }
+    
+    private static final int compare(String lhs, String rhs) {
+        try {
+            int left = Integer.parseInt(lhs);
+            int right = Integer.parseInt(rhs);
+            if (left < right) 
+                return -1;
+            else if (left == right)
+                return 0;
+            else
+                return 1;
+        } catch (NumberFormatException nfe) {
+            return 0;
+        }
+    }
+    
+    public void attemptFailed(String url, long bytesTransferred, long bytesRemaining, int currentAttempt, int numRetries, Exception cause) {
+        // ignore
+    }
+    public void bytesTransferred(long alreadyTransferred, int currentWrite, long bytesTransferred, long bytesRemaining, String url) {
+        // ignore
+    }
+    public void transferComplete(long alreadyTransferred, long bytesTransferred, long bytesRemaining, String url, String outputFile) {
+        if (_log.shouldLog(Log.INFO))
+            _log.info("News fetched from " + url);
+        checkForUpdates();
+    }
+    
+    public void transferFailed(String url, long bytesTransferred, long bytesRemaining, int currentAttempt) {
+        if (_log.shouldLog(Log.ERROR))
+            _log.error("Failed to fetch the news from " + url);
+    }
+}

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

@@ -4,8 +4,6 @@ import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.OutputStreamWriter;
 import java.io.Writer;
-import java.util.List;
-
 import net.i2p.router.RouterContext;
 import net.i2p.router.admin.StatsGenerator;
 

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

@@ -4,16 +4,16 @@ import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.InputStream;
+import java.io.OutputStream;
 
+import java.net.Socket;
 import java.net.URL;
-import java.net.URLConnection;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.Set;
 
 import net.i2p.I2PAppContext;
 import net.i2p.util.I2PThread;
-import net.i2p.util.Log;
 
 /**
  * Handler to deal with reseed requests.  This reseed from the URL
@@ -98,13 +98,42 @@ public class ReseedHandler {
         URL url = new URL(seedURL + (seedURL.endsWith("/") ? "" : "/") + "routerInfo-" + peer + ".dat");
 
         byte data[] = readURL(url);
+        //System.out.println("read: " + (data != null ? data.length : -1));
         writeSeed(peer, data);
     }
     
     private static byte[] readURL(URL url) throws Exception {
-        ByteArrayOutputStream baos = new ByteArrayOutputStream(1024);
-        URLConnection con = url.openConnection();
-        InputStream in = con.getInputStream();
+        ByteArrayOutputStream baos = new ByteArrayOutputStream(4*1024);
+        String hostname = url.getHost();
+        int port = url.getPort();
+        if (port < 0)
+            port = 80;
+        Socket s = new Socket(hostname, port);
+        OutputStream out = s.getOutputStream();
+        InputStream in = s.getInputStream();
+        String request = getRequest(url);
+        //System.out.println("Sending to " + hostname +":"+ port + ": " + request);
+        out.write(request.getBytes());
+        out.flush();
+        // skip the HTTP response headers
+        // (if we were smart, we'd check for HTTP 200, content-length, etc)
+        int consecutiveNL = 0;
+        while (true) {
+            int cur = in.read();
+            switch (cur) {
+                case -1: 
+                    return null;
+                case '\n':
+                case '\r':
+                    consecutiveNL++;
+                    break;
+                default:
+                    consecutiveNL = 0;
+            }
+            if (consecutiveNL == 4)
+                break;
+        }
+        // ok, past the headers, grab the goods
         byte buf[] = new byte[1024];
         while (true) {
             int read = in.read(buf);
@@ -113,9 +142,24 @@ public class ReseedHandler {
             baos.write(buf, 0, read);
         }
         in.close();
+        s.close();
         return baos.toByteArray();
     }
     
+    private static String getRequest(URL url) {
+        StringBuffer buf = new StringBuffer(512);
+        String path = url.getPath();
+        if ("".equals(path))
+            path = "/";
+        buf.append("GET ").append(path).append(" HTTP/1.0\n");
+        buf.append("Host: ").append(url.getHost());
+        int port = url.getPort();
+        if ( (port > 0) && (port != 80) )
+            buf.append(":").append(port);
+        buf.append("\nConnection: close\n\n");
+        return buf.toString();
+    }
+    
     private static void writeSeed(String name, byte data[]) throws Exception {
         String dirName = "netDb"; // _context.getProperty("router.networkDatabase.dbDir", "netDb");
         File netDbDir = new File(dirName);
@@ -126,4 +170,9 @@ public class ReseedHandler {
         fos.write(data);
         fos.close();
     }
+    
+    public static void main(String args[]) {
+        reseed();
+        //System.out.println("Done reseeding");
+    }
 }

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

@@ -4,18 +4,18 @@ import java.io.File;
 import java.io.IOException;
 import java.util.List;
 
+import net.i2p.I2PAppContext;
 import net.i2p.router.RouterContext;
 import net.i2p.apps.systray.SysTray;
 import net.i2p.util.FileUtil;
+import net.i2p.util.I2PThread;
 
 import org.mortbay.jetty.Server;
 import org.mortbay.jetty.servlet.WebApplicationContext;
 import org.mortbay.http.DigestAuthenticator;
 import org.mortbay.http.handler.SecurityHandler;
 import org.mortbay.http.HashUserRealm;
-import org.mortbay.http.HttpRequest;
 import org.mortbay.http.SecurityConstraint;
-import org.mortbay.util.MultiException;
 
 public class RouterConsoleRunner {
     private Server _server;
@@ -64,7 +64,7 @@ public class RouterConsoleRunner {
         }
         try {
             _server.start();
-        } catch (MultiException me) {
+        } catch (Exception me) {
             me.printStackTrace();
         }
         try {
@@ -72,12 +72,16 @@ public class RouterConsoleRunner {
         } catch (Throwable t) {
             t.printStackTrace();
         }
+        
+        I2PThread t = new I2PThread(new NewsFetcher(I2PAppContext.getGlobalContext()), "NewsFetcher");
+        t.setDaemon(true);
+        t.start();
     }
     
     private void initialize(WebApplicationContext context) {
         String password = getPassword();
         if (password != null) {
-            HashUserRealm realm = new HashUserRealm();
+            HashUserRealm realm = new HashUserRealm("i2prouter");
             realm.put("admin", password);
             realm.addUserToRole("admin", "routerAdmin");
             context.setRealm(realm);

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

@@ -0,0 +1,41 @@
+package net.i2p.router.web;
+
+import java.util.Iterator;
+import java.util.Set;
+
+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/SummaryHelper.java

@@ -1,16 +1,21 @@
 package net.i2p.router.web;
 
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.io.OutputStreamWriter;
+import java.text.DateFormat;
 import java.text.DecimalFormat;
+import java.util.Date;
+import java.util.Iterator;
+import java.util.Locale;
+import java.util.Set;
 
 import net.i2p.data.DataHelper;
+import net.i2p.data.Destination;
+import net.i2p.data.LeaseSet;
 import net.i2p.stat.Rate;
 import net.i2p.stat.RateStat;
 import net.i2p.router.Router;
 import net.i2p.router.RouterContext;
 import net.i2p.router.RouterVersion;
+import net.i2p.router.TunnelPoolSettings;
 
 /**
  * Simple helper to query the appropriate router for data necessary to render
@@ -65,8 +70,33 @@ public class SummaryHelper {
         else
             return DataHelper.formatDuration(router.getUptime());
     }
-
+    
+    private static final DateFormat _fmt = new java.text.SimpleDateFormat("HH:mm:ss", Locale.UK);
+    public String getTime() {
+        if (_context == null) return "";
         
+        String now = null;
+        synchronized (_fmt) {
+            now = _fmt.format(new Date(_context.clock().now()));
+        }
+        
+        long ms = _context.clock().getOffset();
+        
+        if (ms < 60 * 1000) {
+            return now + " (" + (ms / 1000) + "s)";
+        } else if (ms < 60 * 60 * 1000) {
+            return now + " (" + (ms / (60 * 1000)) + "m)";
+        } else if (ms < 24 * 60 * 60 * 1000) {
+            return now + " (" + (ms / (60 * 60 * 1000)) + "h)";
+        } else {
+            return now + " (" + (ms / (24 * 60 * 60 * 1000)) + "d)";
+        }
+    }
+    
+    public boolean allowReseed() {
+        return (_context.netDb().getKnownRouters() < 10);
+    }
+    
     /**
      * Retrieve amount of used memory.
      *
@@ -333,16 +363,39 @@ public class SummaryHelper {
      * @return html section summary
      */
     public String getDestinations() {
-        ByteArrayOutputStream baos = new ByteArrayOutputStream(1024);
-        try {
-            OutputStreamWriter osw = new OutputStreamWriter(baos);
-            _context.clientManager().renderStatusHTML(osw);
-            osw.flush();
-            return new String(baos.toByteArray());
-        } catch (IOException ioe) {
-            _context.logManager().getLog(SummaryHelper.class).error("Error rendering client info", ioe);
-            return "";
+        Set clients = _context.clientManager().listClients();
+        
+        StringBuffer buf = new StringBuffer(512);
+        buf.append("<u><b>Local destinations</b></u><br />");
+        
+        for (Iterator iter = clients.iterator(); iter.hasNext(); ) {
+            Destination client = (Destination)iter.next();
+            TunnelPoolSettings in = _context.tunnelManager().getInboundSettings(client.calculateHash());
+            TunnelPoolSettings out = _context.tunnelManager().getOutboundSettings(client.calculateHash());
+            String name = (in != null ? in.getDestinationNickname() : null);
+            if (name == null)
+                name = (out != null ? out.getDestinationNickname() : null);
+            if (name == null)
+                name = client.calculateHash().toBase64().substring(0,6);
+            
+            buf.append("<b>*</b> ").append(name).append("<br />\n");
+            LeaseSet ls = _context.netDb().lookupLeaseSetLocally(client.calculateHash());
+            if (ls != null) {
+                long timeToExpire = ls.getEarliestLeaseDate() - _context.clock().now();
+                if (timeToExpire < 0) {
+                    buf.append("<i>expired ").append(DataHelper.formatDuration(0-timeToExpire));
+                    buf.append(" ago</i><br />\n");
+                }
+            } else {
+                buf.append("<i>No leases</i><br />\n");
+            }
+            buf.append("<a href=\"tunnels.jsp#").append(client.calculateHash().toBase64().substring(0,4));
+            buf.append("\">Details</a> ");
+            buf.append("<a href=\"configtunnels.jsp#").append(client.calculateHash().toBase64().substring(0,4));
+            buf.append("\">Config</a><br />\n");
         }
+        buf.append("<hr />\n");
+        return buf.toString();
     }
     
     /**
@@ -414,4 +467,8 @@ public class SummaryHelper {
         
         return _context.throttle().getTunnelLag() + "ms";
     }
+    
+    public boolean updateAvailable() { 
+        return NewsFetcher.getInstance().updateAvailable();
+    }
 }

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

@@ -0,0 +1,46 @@
+package net.i2p.router.web;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+
+import net.i2p.router.RouterContext;
+
+public class TunnelHelper {
+    private RouterContext _context;
+    private Writer _out;
+    /**
+     * Configure this bean to query a particular router context
+     *
+     * @param contextId begging few characters of the routerHash, or null to pick
+     *                  the first one we come across.
+     */
+    public void setContextId(String contextId) {
+        try {
+            _context = ContextHelper.getContext(contextId);
+        } catch (Throwable t) {
+            t.printStackTrace();
+        }
+    }
+    
+    public TunnelHelper() {}
+    
+    public void setWriter(Writer writer) { _out = writer; }
+    
+    public String getTunnelSummary() {
+        try {
+            if (_out != null) {
+                _context.tunnelManager().renderStatusHTML(_out);
+                return "";
+            } else {
+                ByteArrayOutputStream baos = new ByteArrayOutputStream(32*1024);
+                _context.tunnelManager().renderStatusHTML(new OutputStreamWriter(baos));
+                return new String(baos.toByteArray());
+            }
+        } catch (IOException ioe) {
+            ioe.printStackTrace();
+            return "";
+        }
+    }
+}

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

@@ -0,0 +1,168 @@
+package net.i2p.router.web;
+
+import java.io.File;
+import java.text.DecimalFormat;
+import net.i2p.crypto.TrustedUpdate;
+import net.i2p.router.Router;
+import net.i2p.router.RouterContext;
+import net.i2p.util.I2PThread;
+import net.i2p.util.EepGet;
+import net.i2p.util.Log;
+
+/**
+ * Handle the request to update the router by firing off an EepGet call and
+ * displaying its status to anyone who asks.  After the download completes,
+ * it is verified with the TrustedUpdate, and if it is authentic, the router
+ * is restarted.
+ *
+ */
+public class UpdateHandler {
+    private static UpdateRunner _updateRunner;
+    private RouterContext _context;
+    private Log _log;
+    private DecimalFormat _pct = new DecimalFormat("00.0%");
+    
+    private static final String SIGNED_UPDATE_FILE = "i2pupdate.sud";
+
+    public UpdateHandler() {}
+    public UpdateHandler(RouterContext ctx) {
+        _context = ctx;
+        _log = ctx.logManager().getLog(UpdateHandler.class);
+    }
+    
+    /**
+     * Configure this bean to query a particular router context
+     *
+     * @param contextId begging few characters of the routerHash, or null to pick
+     *                  the first one we come across.
+     */
+    public void setContextId(String contextId) {
+        try {
+            _context = ContextHelper.getContext(contextId);
+            _log = _context.logManager().getLog(UpdateHandler.class);
+        } catch (Throwable t) {
+            t.printStackTrace();
+        }
+    }
+    
+    
+    public void setUpdateNonce(String nonce) { 
+        if (nonce == null) return;
+        if (nonce.equals(System.getProperty("net.i2p.router.web.UpdateHandler.nonce")) ||
+            nonce.equals(System.getProperty("net.i2p.router.web.UpdateHandler.noncePrev"))) {
+            update();
+        }
+    }
+
+    public void update() {
+        synchronized (UpdateHandler.class) {
+            if (_updateRunner == null)
+                _updateRunner = new UpdateRunner();
+            if (_updateRunner.isRunning()) {
+                return;
+            } else {
+                System.setProperty("net.i2p.router.web.UpdateHandler.updateInProgress", "true");
+                I2PThread update = new I2PThread(_updateRunner, "Update");
+                update.start();
+            }
+        }
+
+    }
+    
+    public String getStatus() {
+        return _updateRunner.getStatus();
+    }
+    
+    public class UpdateRunner implements Runnable, EepGet.StatusListener {
+        private boolean _isRunning;
+        private String _status;
+        private long _startedOn;
+        private long _written;
+        public UpdateRunner() { 
+            _isRunning = false; 
+            _status = "<b>Updating</b><br />";
+        }
+        public boolean isRunning() { return _isRunning; }
+        public String getStatus() { return _status; }
+        public void run() {
+            _isRunning = true;
+            update();
+            System.setProperty("net.i2p.router.web.ReseedHandler.updateInProgress", "false");
+            _isRunning = false;
+        }
+        private void update() {
+            _startedOn = -1;
+            _status = "<b>Updating</b><br />";
+            String updateURL = _context.getProperty(ConfigUpdateHandler.PROP_UPDATE_URL, ConfigUpdateHandler.DEFAULT_UPDATE_URL);
+            boolean shouldProxy = Boolean.valueOf(_context.getProperty(ConfigUpdateHandler.PROP_SHOULD_PROXY, ConfigUpdateHandler.DEFAULT_SHOULD_PROXY)).booleanValue();
+            String proxyHost = _context.getProperty(ConfigUpdateHandler.PROP_PROXY_HOST, ConfigUpdateHandler.DEFAULT_PROXY_HOST);
+            String port = _context.getProperty(ConfigUpdateHandler.PROP_PROXY_PORT, ConfigUpdateHandler.DEFAULT_PROXY_PORT);
+            int proxyPort = -1;
+            try {
+                proxyPort = Integer.parseInt(port);
+            } catch (NumberFormatException nfe) {
+                System.setProperty("net.i2p.router.web.UpdateHandler.updateInProgress", "false");
+                return;
+            }
+            try {
+                EepGet get = null;
+                if (shouldProxy)
+                    get = new EepGet(_context, proxyHost, proxyPort, 10, SIGNED_UPDATE_FILE, updateURL);
+                else
+                    get = new EepGet(_context, 10, SIGNED_UPDATE_FILE, updateURL);
+                get.addStatusListener(UpdateRunner.this);
+                _startedOn = _context.clock().now();
+                get.fetch();
+            } catch (Throwable t) {
+                _context.logManager().getLog(UpdateHandler.class).error("Error updating", t);
+                System.setProperty("net.i2p.router.web.UpdateHandler.updateInProgress", "false");
+            }
+        }
+        
+        public void attemptFailed(String url, long bytesTransferred, long bytesRemaining, int currentAttempt, int numRetries, Exception cause) {
+            if (_log.shouldLog(Log.DEBUG))
+                _log.debug("Attempt failed on " + url, cause);
+            _written = 0;
+            // ignored
+        }
+        public void bytesTransferred(long alreadyTransferred, int currentWrite, long bytesTransferred, long bytesRemaining, String url) {
+            _written += currentWrite;
+            StringBuffer buf = new StringBuffer(64);
+            buf.append("<b>Updating</b> ");
+            double pct = ((double)alreadyTransferred + (double)_written) / ((double)alreadyTransferred + (double)bytesRemaining);
+            synchronized (_pct) {
+                buf.append(_pct.format(pct));
+            }
+            buf.append(":<br />\n").append(_written+alreadyTransferred);
+            buf.append(" transferred<br />");
+            _status = buf.toString();
+        }
+        public void transferComplete(long alreadyTransferred, long bytesTransferred, long bytesRemaining, String url, String outputFile) {
+            _status = "<b>Update downloaded</b><br />";
+            TrustedUpdate up = new TrustedUpdate(_context);
+            boolean ok = up.migrateVerified(SIGNED_UPDATE_FILE, "i2pupdate.zip");
+            File f = new File(SIGNED_UPDATE_FILE);
+            f.delete();
+            if (ok) {
+                _log.log(Log.CRIT, "Update was VERIFIED, restarting to install it");
+                _status = "<b>Update verified</b><br />Restarting<br />";
+                restart();
+            } else {
+                _log.log(Log.CRIT, "Update was INVALID - have you changed your keys?");
+                System.setProperty("net.i2p.router.web.UpdateHandler.updateInProgress", "false");
+            }
+        }
+        public void transferFailed(String url, long bytesTransferred, long bytesRemaining, int currentAttempt) {
+            _log.log(Log.CRIT, "Update did not download completely (" + bytesTransferred + " with " 
+                               + bytesRemaining + " after " + currentAttempt + " tries)");
+
+            _status = "<b>Transfer failed</b><br />";
+            System.setProperty("net.i2p.router.web.UpdateHandler.updateInProgress", "false");
+        }
+    }
+    
+    private void restart() {
+        _context.router().addShutdownTask(new ConfigServiceHandler.UpdateWrapperManagerTask(Router.EXIT_GRACEFUL_RESTART));
+        _context.router().shutdownGracefully(Router.EXIT_GRACEFUL_RESTART);
+    }
+}

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/config.jsp

@@ -39,14 +39,17 @@
  
  <b>Bandwidth limiter</b><br />
  Inbound rate: 
-    <input name="inboundrate" type="text" size="2" value="<jsp:getProperty name="nethelper" property="inboundRate" />" /> KBytes per second<br />
- Inbound burst duration:
+    <input name="inboundrate" type="text" size="2" value="<jsp:getProperty name="nethelper" property="inboundRate" />" /> KBytes per second
+ bursting up to 
     <jsp:getProperty name="nethelper" property="inboundBurstFactorBox" /><br />
  Outbound rate:
-    <input name="outboundrate" type="text" size="2" value="<jsp:getProperty name="nethelper" property="outboundRate" />" /> KBytes per second<br />
- Outbound burst duration:
+    <input name="outboundrate" type="text" size="2" value="<jsp:getProperty name="nethelper" property="outboundRate" />" /> KBytes per second
+ bursting up to 
   <jsp:getProperty name="nethelper" property="outboundBurstFactorBox" /><br />
  <i>A negative rate means there is no limit</i><br />
+ Bandwidth share percentage:
+   <jsp:getProperty name="nethelper" property="sharePercentageBox" /><br />
+ Sharing a higher percentage will improve your anonymity and help the network
  <hr />
  Enable internal time synchronization? <input type="checkbox" <jsp:getProperty name="nethelper" property="enableTimeSyncChecked" /> name="enabletimesync" /><br />
  <i>If disabled, your machine <b>must</b> be NTP synchronized - your clock must always
@@ -61,17 +64,7 @@
  <hr />
  <b>Advanced network config:</b>
  <p>
- There are two other network settings, but no one reads this text so there's no reason
- to tell you about them.  In case you actually do read this, here's the deal: by default,
- I2P will attempt to guess your IP address by having whomever it talks to tell it what 
- address they think you are.  If and only if you have no working TCP connections and you
- have not overridden the IP address, your router will believe them.  If that doesn't sound
- ok to you, thats fine - go to the <a href="/configadvanced.jsp">advanced config</a> page
- and add "i2np.tcp.hostname=yourHostname", then go to the 
- <a href="/configservice.jsp">service</a> page and do a graceful restart.  We used to make
- people enter a hostname/IP address on this page, but too many people got it wrong ;)</p>
- 
- <p>The other advanced network option has to do with reseeding - you should never need to 
+ One advanced network option has to do with reseeding - you should never need to 
  reseed your router as long as you can find at least one other peer on the network.  However,
  when you do need to reseed, a link will show up on the left hand side which will
  fetch all of the routerInfo-* files from http://dev.i2p.net/i2pdb/.  That URL is just an

apps/routerconsole/jsp/configclients.jsp

@@ -1,45 +0,0 @@
-<%@page contentType="text/html"%>
-<%@page pageEncoding="UTF-8"%>
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-
-<html><head>
-<title>I2P Router Console - config clients</title>
-<link rel="stylesheet" href="default.css" type="text/css" />
-</head><body>
-
-<%@include file="nav.jsp" %>
-<%@include file="summary.jsp" %>
-
-<jsp:useBean class="net.i2p.router.web.ConfigClientsHelper" id="clientshelper" scope="request" />
-<jsp:setProperty name="clientshelper" property="contextId" value="<%=(String)session.getAttribute("i2p.contextId")%>" />
-
-<div class="main" id="main">
- <%@include file="confignav.jsp" %>
-  
- <jsp:useBean class="net.i2p.router.web.ConfigClientsHandler" id="formhandler" scope="request" />
- <jsp:setProperty name="formhandler" property="*" />
- <jsp:setProperty name="formhandler" property="contextId" value="<%=(String)session.getAttribute("i2p.contextId")%>" />
- <font color="red"><jsp:getProperty name="formhandler" property="errors" /></font>
- <i><jsp:getProperty name="formhandler" property="notices" /></i>
- 
- <form action="configclients.jsp" method="POST">
- <% String prev = System.getProperty("net.i2p.router.web.ConfigClientsHandler.nonce");
-    if (prev != null) System.setProperty("net.i2p.router.web.ConfigClientsHandler.noncePrev", prev);
-    System.setProperty("net.i2p.router.web.ConfigClientsHandler.nonce", new java.util.Random().nextLong()+""); %>
- <input type="hidden" name="nonce" value="<%=System.getProperty("net.i2p.router.web.ConfigClientsHandler.nonce")%>" />
- <input type="hidden" name="action" value="blah" />
- <b>Estimated number of clients/destinations:</b> 
-    <jsp:getProperty name="clientshelper" property="clientCountSelectBox" /><br />
- <b>Default number of inbound tunnels per client:</b>
-    <jsp:getProperty name="clientshelper" property="tunnelCountSelectBox" /><br />
- <b>Default number of hops per tunnel:</b>
-    <jsp:getProperty name="clientshelper" property="tunnelDepthSelectBox" /><br />
- <b>Hops per outbound tunnel:</b>
-    <jsp:getProperty name="clientshelper" property="tunnelDepthOutboundSelectBox" /><br />
- <hr />
- <input type="submit" name="shouldsave" value="Save changes" /> <input type="reset" value="Cancel" />
- </form>
-</div>
-
-</body>
-</html>

apps/routerconsole/jsp/confignav.jsp

@@ -2,9 +2,11 @@
  %>Network | <% } else { %><a href="config.jsp">Network</a> | <% }
  if (request.getRequestURI().indexOf("configservice.jsp") != -1) {
  %>Service | <% } else { %><a href="configservice.jsp">Service</a> | <% }
- if (request.getRequestURI().indexOf("configclients.jsp") != -1) {
- %>Clients | <% } else { %><a href="configclients.jsp">Clients</a> | <% }
+ if (request.getRequestURI().indexOf("configupdate.jsp") != -1) {
+ %>Update | <% } else { %><a href="configupdate.jsp">Update</a> | <% }
+ if (request.getRequestURI().indexOf("configtunnels.jsp") != -1) {
+ %>Tunnels | <% } else { %><a href="configtunnels.jsp">Tunnels</a> | <% }
  if (request.getRequestURI().indexOf("configlogging.jsp") != -1) {
  %>Logging | <% } else { %><a href="configlogging.jsp">Logging</a> | <% }
  if (request.getRequestURI().indexOf("configadvanced.jsp") != -1) {
- %>Advanced | <% } else { %><a href="configadvanced.jsp">Advanced</a> | <% } %></h4>
+ %>Advanced<% } else { %><a href="configadvanced.jsp">Advanced</a><% } %></h4>

apps/routerconsole/jsp/configtunnels.jsp

@@ -0,0 +1,41 @@
+<%@page contentType="text/html"%>
+<%@page pageEncoding="UTF-8"%>
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+
+<html><head>
+<title>I2P Router Console - config tunnels</title>
+<link rel="stylesheet" href="default.css" type="text/css" />
+</head><body>
+
+<%@include file="nav.jsp" %>
+<%@include file="summary.jsp" %>
+
+<jsp:useBean class="net.i2p.router.web.ConfigTunnelsHelper" id="tunnelshelper" scope="request" />
+<jsp:setProperty name="tunnelshelper" property="contextId" value="<%=(String)session.getAttribute("i2p.contextId")%>" />
+
+<div class="main" id="main">
+ <%@include file="confignav.jsp" %>
+  
+ <jsp:useBean class="net.i2p.router.web.ConfigTunnelsHandler" id="formhandler" scope="request" />
+ <jsp:setProperty name="formhandler" property="contextId" value="<%=(String)session.getAttribute("i2p.contextId")%>" />
+ <jsp:setProperty name="formhandler" property="shouldsave" value="<%=request.getParameter("shouldsave")%>" />
+ <jsp:setProperty name="formhandler" property="action" value="<%=request.getParameter("action")%>" />
+ <jsp:setProperty name="formhandler" property="nonce" value="<%=request.getParameter("nonce")%>" />
+ <jsp:setProperty name="formhandler" property="settings" value="<%=request.getParameterMap()%>" />
+ <font color="red"><jsp:getProperty name="formhandler" property="errors" /></font>
+ <i><jsp:getProperty name="formhandler" property="notices" /></i>
+ 
+ <form action="configtunnels.jsp" method="POST">
+ <% String prev = System.getProperty("net.i2p.router.web.ConfigTunnelsHandler.nonce");
+    if (prev != null) System.setProperty("net.i2p.router.web.ConfigTunnelsHandler.noncePrev", prev);
+    System.setProperty("net.i2p.router.web.ConfigTunnelsHandler.nonce", new java.util.Random().nextLong()+""); %>
+ <input type="hidden" name="nonce" value="<%=System.getProperty("net.i2p.router.web.ConfigTunnelsHandler.nonce")%>" />
+ <input type="hidden" name="action" value="blah" />
+ <jsp:getProperty name="tunnelshelper" property="form" />
+ <hr />
+ <input type="submit" name="shouldsave" value="Save changes" /> <input type="reset" value="Cancel" />
+ </form>
+</div>
+
+</body>
+</html>

apps/routerconsole/jsp/configupdate.jsp

@@ -0,0 +1,51 @@
+<%@page contentType="text/html"%>
+<%@page pageEncoding="UTF-8"%>
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+
+<html><head>
+<title>I2P Router Console - config update</title>
+<link rel="stylesheet" href="default.css" type="text/css" />
+</head><body>
+
+<%@include file="nav.jsp" %>
+<%@include file="summary.jsp" %>
+
+<div class="main" id="main">
+ <%@include file="confignav.jsp" %>
+  
+ <jsp:useBean class="net.i2p.router.web.ConfigUpdateHandler" id="formhandler" scope="request" />
+ <jsp:setProperty name="formhandler" property="*" />
+ <jsp:setProperty name="formhandler" property="contextId" value="<%=(String)session.getAttribute("i2p.contextId")%>" />
+ <font color="red"><jsp:getProperty name="formhandler" property="errors" /></font>
+ <i><jsp:getProperty name="formhandler" property="notices" /></i>
+ 
+ <jsp:useBean class="net.i2p.router.web.ConfigUpdateHelper" id="updatehelper" scope="request" />
+ <jsp:setProperty name="updatehelper" property="contextId" value="<%=(String)session.getAttribute("i2p.contextId")%>" />
+ 
+ <form action="configupdate.jsp" method="POST">
+ <% String prev = System.getProperty("net.i2p.router.web.ConfigUpdateHandler.nonce");
+    if (prev != null) System.setProperty("net.i2p.router.web.ConfigUpdateHandler.noncePrev", prev);
+    System.setProperty("net.i2p.router.web.ConfigUpdateHandler.nonce", new java.util.Random().nextLong()+""); %>
+ <input type="hidden" name="nonce" value="<%=System.getProperty("net.i2p.router.web.ConfigUpdateHandler.nonce")%>" />
+ <input type="hidden" name="action" value="update" />
+ News URL:
+ <input type="text" size="60" name="newsURL" value="<jsp:getProperty name="updatehelper" property="newsURL" />"><br />
+ Refresh frequency:
+ <jsp:getProperty name="updatehelper" property="refreshFrequencySelectBox" /><br />
+ Update URL:
+ <input type="text" size="60" name="updateURL" value="<jsp:getProperty name="updatehelper" property="updateURL" />"><br />
+ Update policy:
+ <jsp:getProperty name="updatehelper" property="updatePolicySelectBox" /><br />
+ Update anonymously?
+ <jsp:getProperty name="updatehelper" property="updateThroughProxy" /><br />
+ Proxy host: <input type="text" size="10" name="proxyHost" value="<jsp:getProperty name="updatehelper" property="proxyHost" />" /><br />
+ Proxy port: <input type="text" size="4" name="proxyPort" value="<jsp:getProperty name="updatehelper" property="proxyPort" />" /><br />
+ <!-- prompt for the eepproxy -->
+ Trusted keys:
+ <textarea name="trustedKeys" disabled="true" cols="60" rows="2"><jsp:getProperty name="updatehelper" property="trustedKeys" /></textarea>
+ <input type="submit" value="Save" />
+ </form>
+</div>
+
+</body>
+</html>

apps/routerconsole/jsp/default.css

@@ -60,3 +60,12 @@ div.main {
 	text-align: left;
 	color: inherit;
 }
+
+div.news {
+	margin: 0em 1em 1em 224px;
+	padding: .5em 1em;
+	background-color: #ffffc0;
+	border: medium solid #ffffd0;
+	text-align: left;
+	color: inherit;
+}

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/routerconsole/jsp/help.jsp

@@ -33,8 +33,12 @@ by their binary code license.  This product includes software developed by the A
 (http://www.apache.org/). </p>
 
 <p>Another application you can see on this webpage is <a href="http://www.i2p.net/i2ptunnel">I2PTunnel</a>
-(your <a href="/i2ptunnel/" target="_blank">web interface</a>) - a GPL'ed application written by mihi that
-lets you tunnel normal TCP/IP traffic over I2P (such as the eepproxy and the irc proxy).</p>
+(your <a href="i2ptunnel/" target="_blank">web interface</a>) - a GPL'ed application written by mihi that
+lets you tunnel normal TCP/IP traffic over I2P (such as the eepproxy and the irc proxy).  There is also a
+<a href="http://susi.i2p/">susimail</a> web based mail client <a href="susimail/susimail">available</a> on
+the console, which is a GPL'ed application written by susi23.  The addressbook application, written by 
+<a href="http://ragnarok.i2p/">Ragnarok</a> helps maintain your hosts.txt files (see ./addressbook/ for
+more information).</p>
 
 <p>The router by default also includes human's public domain <a href="http://www.i2p.net/sam">SAM</a> bridge,
 which other client applications (such the <a href="http://duck.i2p/i2p-bt/">bittorrent port</a>) can use.  

apps/routerconsole/jsp/index.jsp

@@ -10,6 +10,13 @@
 <%@include file="nav.jsp" %>
 <%@include file="summary.jsp" %>
 
+<div class="news" id="news">
+ <jsp:useBean class="net.i2p.router.web.ContentHelper" id="newshelper" scope="request" />
+ <jsp:setProperty name="newshelper" property="page" value="docs/news.xml" />
+ <jsp:setProperty name="newshelper" property="maxLines" value="300" />
+ <jsp:getProperty name="newshelper" property="content" />
+</div>
+
 <div class="main" id="main">
  <jsp:useBean class="net.i2p.router.web.ContentHelper" id="contenthelper" scope="request" />
  <jsp:setProperty name="contenthelper" property="page" value="docs/readme.html" />

apps/routerconsole/jsp/logs.jsp

@@ -19,6 +19,9 @@
  <h4>Connection logs:</h4><a name="connectionlogs"> </a>
  <jsp:getProperty name="logsHelper" property="connectionLogs" />
  <hr />
+ <h4>Critical logs:</h4><a name="criticallogs"> </a>
+ <jsp:getProperty name="logsHelper" property="criticalLogs" />
+ <hr />
  <h4>Service logs:</h4><a name="servicelogs"> </a>
  <jsp:getProperty name="logsHelper" property="serviceLogs" />
 </div>

apps/routerconsole/jsp/nav.jsp

@@ -15,12 +15,14 @@
 </div>
 
 <h4>
+ <a href="tunnels.jsp">Tunnels</a> |
  <a href="profiles.jsp">Profiles</a> |
- <a href="netdb.jsp">Network Database</a> |
+ <a href="netdb.jsp">NetDB</a> |
  <a href="logs.jsp">Logs</a> |
- <a href="oldconsole.jsp">Old console</a> |
+ <a href="oldconsole.jsp">Internals</a> |
  <a href="oldstats.jsp">Stats</a> |
- <a href="i2ptunnel/" target="_blank">I2PTunnel</a>
+ <a href="i2ptunnel/" target="_blank">I2PTunnel</a> |
+ <a href="susimail/susimail" target="_blank">Susimail</a>
  <jsp:useBean class="net.i2p.router.web.NavHelper" id="navhelper" scope="request" />
  <jsp:setProperty name="navhelper" property="contextId" value="<%=(String)session.getAttribute("i2p.contextId")%>" />
  <jsp:getProperty name="navhelper" property="clientAppLinks" />

apps/routerconsole/jsp/summary.jsp

@@ -4,14 +4,34 @@
 
 <jsp:useBean class="net.i2p.router.web.ReseedHandler" id="reseed" scope="request" />
 <jsp:setProperty name="reseed" property="*" />
+<jsp:useBean class="net.i2p.router.web.UpdateHandler" id="update" scope="request" />
+<jsp:setProperty name="update" property="*" />
+<jsp:setProperty name="update" property="contextId" value="<%=(String)session.getAttribute("i2p.contextId")%>" />
 
 <div class="routersummary">
  <u><b>General</b></u><br />
  <b>Ident:</b> <jsp:getProperty name="helper" property="ident" /><br />
  <b>Version:</b> <jsp:getProperty name="helper" property="version" /><br />
  <b>Uptime:</b> <jsp:getProperty name="helper" property="uptime" /><br />
- <b>Memory:</b> <jsp:getProperty name="helper" property="memory" /><br />
- <hr />
+ <b>Now:</b> <jsp:getProperty name="helper" property="time" /><br />
+ <b>Memory:</b> <jsp:getProperty name="helper" property="memory" /><br /><%
+    if (helper.updateAvailable()) {
+        if ("true".equals(System.getProperty("net.i2p.router.web.UpdateHandler.updateInProgress", "false"))) {
+            out.print(update.getStatus());
+        } else {
+            long nonce = new java.util.Random().nextLong();
+            String prev = System.getProperty("net.i2p.router.web.UpdateHandler.nonce");
+            if (prev != null) System.setProperty("net.i2p.router.web.UpdateHandler.noncePrev", prev);
+            System.setProperty("net.i2p.router.web.UpdateHandler.nonce", nonce+"");
+            String uri = request.getRequestURI();
+            if (uri.indexOf('?') > 0)
+                uri = uri + "&updateNonce=" + nonce;
+            else
+                uri = uri + "?updateNonce=" + nonce;
+            out.print(" <a href=\"" + uri + "\">Update available</a>");
+        }
+    }
+ %><hr />
  
  <u><b>Peers</b></u><br />
  <b>Active:</b> <jsp:getProperty name="helper" property="activePeers" />/<jsp:getProperty name="helper" property="activeProfiles" /><br />
@@ -23,7 +43,7 @@
      if (helper.getActivePeers() <= 0) {
         %><b><a href="config.jsp">check your NAT/firewall</a></b><br /><%
      }
-    if (helper.getActiveProfiles() <= 4) { // 4 is the min fallback
+    if (helper.allowReseed()) {
         if ("true".equals(System.getProperty("net.i2p.router.web.ReseedHandler.reseedInProgress", "false"))) {
             out.print(" <i>reseeding</i>");
         } else {

apps/routerconsole/jsp/tunnels.jsp

@@ -0,0 +1,21 @@
+<%@page contentType="text/html"%>
+<%@page pageEncoding="UTF-8"%>
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+
+<html><head>
+<title>I2P Router Console - tunnel summary</title>
+<link rel="stylesheet" href="default.css" type="text/css" />
+</head><body>
+
+<%@include file="nav.jsp" %>
+<%@include file="summary.jsp" %>
+
+<div class="main" id="main">
+ <jsp:useBean class="net.i2p.router.web.TunnelHelper" id="tunnelHelper" scope="request" />
+ <jsp:setProperty name="tunnelHelper" property="contextId" value="<%=(String)session.getAttribute("i2p.contextId")%>" />
+ <jsp:setProperty name="tunnelHelper" property="writer" value="<%=out%>" />
+ <jsp:getProperty name="tunnelHelper" property="tunnelSummary" />
+</div>
+
+</body>
+</html>

apps/routerconsole/jsp/verifyupdate.jsp

@@ -0,0 +1,12 @@
+<%@page contentType="text/html" %>
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+
+<html><head>
+<title>I2P Router Console - verify update file signature</title>
+</head>
+<body>
+
+<!-- net.i2p.crypto.TrustedUpdate.verify(request.getParameter("filename")) -->
+
+</body>
+</html>

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/README

@@ -1 +1 @@
-See the `docs' directory for documentation and license.
+See the `docs' directory for the documentation and license.

apps/sam/c/doc/donate.txt

@@ -1,7 +0,0 @@
-If you would like to make a donation to the author of this library, you can use
-the following methods:
-
-	* E-Gold account number 1043280
-	* Paypal email mpc@innographx.com
-
-If you want to use some other method, just ask.

apps/sam/c/doc/install.txt

@@ -0,0 +1,32 @@
+=====================
+How to Install LibSAM
+=====================
+
+1) Be sure you have GNU Make installed.
+
+2) Find the Makefile for your operating system in the LibSAM root.  For example,
+if you are on FreeBSD, you'd use Makefile.freebsd.
+
+3) Run gmake with the -f option to build LibSAM.  For example, on FreeBSD, you'd
+run "gmake -f Makefile.freebsd".  On Linux, GNU Make is just called 'make', so
+you'd run "make -f Makefile.linux".
+
+4) If that worked, you can now try to compile some of the example programs.
+They are compiled in the same way as LibSAM, but the Makefile names are
+different.
+
+I2P-Ping should compile on any Unix system using the default Makefile.  It won't
+work on Win32, however, because Win32 doesn't have the getopt() function.
+
+The Warhammer example should run on any OS.  Use the Makefile.posix for Unix
+sytems or the Makefile.mingw for Win32.
+
+*** If you have trouble ***
+
+If you have trouble compiling LibSAM, try to edit the Makefiles to fix the
+problem.  The "Makefile.common" is shared by all systems, and you shouldn't have
+to touch it.  Just copy the Makefile of the OS most similar to your own and
+start hacking on it.  Send me a patch if you get it working.
+
+I realise this build system is horrible, and in the future I will probably
+replace it entirely.

apps/sam/c/doc/todo.txt

@@ -1,10 +1,10 @@
 I need to do these things:
 
-* SAM raw support
+* SAM raw support (partially complete)
 * Write an instruction manual
 * Make dest a dynamic string
 * Change SAM parser to use a hashmap
-* Switch to GNU Autoconf (?)
+* Improve build system
 
 Anyone can help with these things:
 

apps/sam/c/doc/whatsnew.txt

@@ -1,6 +1,8 @@
 /* vi:set ts=4: */
 
 v1.30
+	* Added session to sam_namingback()
+	* Removed stdint.h dependency
 	* Improved WIRETAP to do more logging
 	* Added "pinger.sh" shell script example for using i2p-ping
 	* Added SAM_BAD_STYLE error