* 2005-02-23 0.5.0.1 released

* Reworked the tunnel (re)building process to remove the tokens and
      provide cleaner controls on the tunnels built.
    * Fixed situations where the timestamper wanted to test more servers than
      were provided (thanks Tracker!)
    * Get rid of the dead SAM sessions by using the streaming lib's callbacks
      (thanks Tracker!)

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,46 @@
+<?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 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/bogobot/.cvsignore

@@ -1,2 +0,0 @@
-.classpath
-.project

apps/bogobot/Bogobot.java

@@ -3,12 +3,18 @@
  * 
  * Bogobot.java
  * 2004 The I2P Project
+ * http://www.i2p.net
  * This code is public domain.
  */
 
 import java.io.File;
+import java.io.FileInputStream;
 import java.io.IOException;
 
+import java.util.Timer;
+import java.util.TimerTask;
+import java.util.Properties;
+
 import org.apache.log4j.DailyRollingFileAppender;
 import org.apache.log4j.Level;
 import org.apache.log4j.Logger;
@@ -20,12 +26,10 @@ import org.jibble.pircbot.PircBot;
 import org.jibble.pircbot.User;
 
 /**
- * TODO 0.4 Implement java.util.Properties for configuration.
- * TODO 0.4 Add NickServ interface.
  * TODO 0.5 Add multi-server capability.
  * 
- * @author hypercubus
- * @version 0.3.1
+ * @author hypercubus, oOo
+ * @version 0.4
  */
 public class Bogobot extends PircBot {
 
@@ -36,32 +40,116 @@ public class Bogobot extends PircBot {
     private boolean _isIntentionalDisconnect      = false;
     private long    _lastUserlistCommandTimestamp = 0;
     private Logger  _logger                       = Logger.getLogger(Bogobot.class);
-    /*
-     * The following will soon be moved to bogo.config and loaded via
-     * java.util.Properties when I get some time.
-     */
-    private String  _botPrimaryNick           = "somebot";
-    private String  _botSecondaryNick         = "somebot_";
-    private String  _botShutdownPassword      = "take off eh";
-    private long    _commandAntiFloodInterval = 60;
-    private String  _ircChannel               = "#i2p-chat";
-    private String  _ircServer                = "irc.duck.i2p";
-    private int     _ircServerPort            = 6668;
-    private boolean _isLoggerEnabled          = true;
-    private boolean _isUserlistCommandEnabled = true;
-    private String  _logFilePrefix            = "irc.duck.i2p.i2p-chat";
-    private String  _logFileRotationInterval  = INTERVAL_DAILY;
-    private String  _ownerPrimaryNick         = "somenick";
-    private String  _ownerSecondaryNick       = "somenick_";
-    private String  _userlistCommandTrigger   = "!who";
 
-    public Bogobot() {
+    private int     _currentAutoRoundTripTag      = 0;
+    private long    _lastAutoRoundTripSentTime    = 0;
+    private Timer   _tickTimer;
+
+    private String  _configFile;
+
+    private String  _botPrimaryNick;
+    private String  _botSecondaryNick;
+    private String  _botNickservPassword;
+    private String  _botUsername;
+    private String  _ownerPrimaryNick;
+    private String  _ownerSecondaryNick;
+    private String  _botShutdownPassword;
+    private String  _ircChannel;
+    private String  _ircServer;
+    private int     _ircServerPort;
+    private boolean _isLoggerEnabled;
+    private String  _loggedHostnamePattern;
+    private boolean _isUserlistCommandEnabled;
+    private String  _logFilePrefix;
+    private String  _logFileRotationInterval;
+    private long    _commandAntiFloodInterval;
+    private String  _userlistCommandTrigger;
+    private boolean _isRoundTripDelayEnabled;
+    private int     _roundTripDelayPeriod;
+
+    class BogobotTickTask extends TimerTask {
+        private Bogobot _caller;
+
+        public BogobotTickTask(Bogobot caller) {
+            _caller = caller;
+        }
+
+        public void run() {
+          _caller.onTick();
+        }
+    }
+
+    private void loadConfigFile(String configFileName) {
+
+        _configFile = configFileName;
+
+        Properties config = new Properties();
+        FileInputStream fis = null;
+
+        try {
+            fis = new FileInputStream(configFileName);
+            config.load(fis);
+        } catch (IOException ioe) {
+            System.err.println("Error loading configuration file");
+            System.exit(2);
+
+        } finally {
+            if (fis != null) try {
+                fis.close();
+            } catch (IOException ioe) { // nop
+            }
+        }
+
+        _botPrimaryNick = config.getProperty("botPrimaryNick", "somebot");
+        _botSecondaryNick = config.getProperty("botSecondaryNick", "somebot_");
+        _botNickservPassword = config.getProperty("botNickservPassword", "");
+        _botUsername = config.getProperty("botUsername", "somebot");
+
+        _ownerPrimaryNick = config.getProperty("ownerPrimaryNick", "somenick");
+        _ownerSecondaryNick = config.getProperty("ownerSecondaryNick", "somenick_");
+
+        _botShutdownPassword = config.getProperty("botShutdownPassword", "take off eh");
+
+        _ircChannel = config.getProperty("ircChannel", "#i2p-chat");
+        _ircServer = config.getProperty("ircServer", "irc.duck.i2p");
+        _ircServerPort = Integer.parseInt(config.getProperty("ircServerPort", "6668"));
+
+        _isLoggerEnabled = Boolean.valueOf(config.getProperty("isLoggerEnabled", "true")).booleanValue();
+        _loggedHostnamePattern = config.getProperty("loggedHostnamePattern", "");
+        _logFilePrefix = config.getProperty("logFilePrefix", "irc.duck.i2p.i2p-chat");
+        _logFileRotationInterval = config.getProperty("logFileRotationInterval", INTERVAL_DAILY);
+
+        _isRoundTripDelayEnabled = Boolean.valueOf(config.getProperty("isRoundTripDelayEnabled", "false")).booleanValue();
+        _roundTripDelayPeriod = Integer.parseInt(config.getProperty("roundTripDelayPeriod", "300"));
+
+        _isUserlistCommandEnabled = Boolean.valueOf(config.getProperty("isUserlistCommandEnabled", "true")).booleanValue();
+        _userlistCommandTrigger = config.getProperty("userlistCommandTrigger", "!who");
+        _commandAntiFloodInterval = Long.parseLong(config.getProperty("commandAntiFloodInterval", "60"));
+    }
+
+    public Bogobot(String configFileName) {
+
+        loadConfigFile(configFileName);
+
         this.setName(_botPrimaryNick);
+        this.setLogin(_botUsername);
+        _tickTimer = new Timer();
+        _tickTimer.scheduleAtFixedRate(new BogobotTickTask(this), 1000, 10 * 1000);
     }
 
     public static void main(String[] args) {
 
-        Bogobot bogobot = new Bogobot();
+        Bogobot bogobot;
+
+        if (args.length > 1) {
+            System.err.println("Too many arguments, the only allowed parameter is configuration file name");
+            System.exit(3);
+        }
+        if (args.length == 1) {
+          bogobot = new Bogobot(args[0]);
+        } else {
+          bogobot = new Bogobot("bogobot.config");
+        }
 
         bogobot.setVerbose(true);
 
@@ -71,6 +159,19 @@ public class Bogobot extends PircBot {
         bogobot.connectToServer();
     }
 
+    protected void onTick() {
+        // Tick about once every ten seconds
+
+        if (this.isConnected() && _isRoundTripDelayEnabled) {
+            if( ( (System.currentTimeMillis() - _lastAutoRoundTripSentTime) >= (_roundTripDelayPeriod * 1000) ) && (this.getOutgoingQueueSize() == 0) ) {
+                // Connected, sending queue is empty and last RoundTrip is more then 5 minutes old -> Send a new one
+                _currentAutoRoundTripTag ++;
+                _lastAutoRoundTripSentTime = System.currentTimeMillis();
+                sendNotice(this.getNick(),"ROUNDTRIP " + _currentAutoRoundTripTag);
+            }
+        }
+    }
+
     protected void onDisconnect() {
 
         if (_isIntentionalDisconnect)
@@ -88,16 +189,20 @@ public class Bogobot extends PircBot {
     }
 
     protected void onJoin(String channel, String sender, String login, String hostname) {
-        if (sender.equals(this.getName())) {
 
-            if (_isLoggerEnabled)
+        if (_isLoggerEnabled) {
+            if (sender.equals(this.getName())) {
+
                 _logger.info(System.currentTimeMillis() + " joins *** " + _botPrimaryNick + " ***");
 
-        } else {
+            } else {
 
-            if (_isLoggerEnabled)
-                _logger.info(System.currentTimeMillis() + " joins " + sender);
+                String prependedHostname = "@" + hostname;
+                if (prependedHostname.endsWith(_loggedHostnamePattern)) {
+                    _logger.info(System.currentTimeMillis() + " joins " + sender);
+                }
 
+            }
         }
     }
 
@@ -121,8 +226,16 @@ public class Bogobot extends PircBot {
 
     protected void onPart(String channel, String sender, String login, String hostname) {
 
-        if (_isLoggerEnabled)
-            _logger.info(System.currentTimeMillis() + " parts " + sender);
+        if (_isLoggerEnabled) {
+            if (sender.equals(this.getName())) {
+                _logger.info(System.currentTimeMillis() + " parts *** " + _botPrimaryNick + " ***");
+            } else {
+                String prependedHostname = "@" + hostname;
+                if (prependedHostname.endsWith(_loggedHostnamePattern)) {
+                    _logger.info(System.currentTimeMillis() + " parts " + sender);
+                }
+            }
+        }
 
     }
 
@@ -142,9 +255,16 @@ public class Bogobot extends PircBot {
     }
 
     protected void onQuit(String sourceNick, String sourceLogin, String sourceHostname, String reason) {
+        String prependedHostname = "@" + sourceHostname;
 
-        if (_isLoggerEnabled)
-            _logger.info(System.currentTimeMillis() + " quits " + sourceNick + " " + reason);
+        if (sourceNick.equals(_botPrimaryNick))
+            changeNick(_botPrimaryNick);
+
+        if (_isLoggerEnabled) {
+            if (prependedHostname.endsWith(_loggedHostnamePattern)) {
+                _logger.info(System.currentTimeMillis() + " quits " + sourceNick + " " + reason);
+            }
+        }
 
     }
 
@@ -187,6 +307,20 @@ public class Bogobot extends PircBot {
         joinChannel(_ircChannel);
     }
 
+    protected void onNotice(String sourceNick, String sourceLogin, String sourceHostname, String target, String notice) {
+
+        if (sourceNick.equals("NickServ") && (notice.indexOf("/msg NickServ IDENTIFY") >= 0) && (_botNickservPassword != "")) {
+            sendRawLineViaQueue("NICKSERV IDENTIFY " + _botNickservPassword);
+        }
+
+        if (sourceNick.equals(getNick()) && notice.equals( "ROUNDTRIP " + _currentAutoRoundTripTag)) {
+            int delay = (int)((System.currentTimeMillis() - _lastAutoRoundTripSentTime) / 100);
+//            sendMessage(_ircChannel, "Round-trip delay = " + (delay / 10.0f) + " seconds");
+            if (_isLoggerEnabled)
+                _logger.info(System.currentTimeMillis() + " roundtrip " + delay);
+        }
+    }
+
     private void initLogger() {
 
         String                   logFilePath         = "logs" + File.separator + _logFilePrefix;
@@ -211,4 +345,5 @@ public class Bogobot extends PircBot {
             System.exit(1);
         }
     }
+
 }

apps/bogobot/Bogoparser.java

@@ -3,6 +3,7 @@
  * 
  * Bogoparser.java
  * 2004 The I2P Project
+ * http://www.i2p.net
  * This code is public domain.
  */
 
@@ -17,7 +18,7 @@ import java.util.regex.Pattern;
 
 /**
  * @author hypercubus
- * @version 0.3.1
+ * @version 0.4
  */
 public class Bogoparser {
 

apps/bogobot/bogobot.config

@@ -1,5 +1,5 @@
 #####
-# Bogobot user configuration (This file is not yet used.)
+# Bogobot user configuration
 #####
 
 ###
@@ -9,6 +9,17 @@
 botPrimaryNick=somebot
 botSecondaryNick=somebot_
 
+###
+# The bot's password required by Nickserv service's identify command.
+# You have to register the nickname yourself first, the bot will not.
+#
+botNickservPassword=
+
+###
+# The bot's username. Appears in the whois replies
+#
+botUsername=somebot
+
 #####
 # The bot owner's nick and backup nick. One of these must match the owner's
 # currently-used nick or else remote shutdown will not be possible. You will
@@ -36,6 +47,14 @@ ircServerPort=6668
 #
 isLoggerEnabled=true
 
+###
+# Restrict logging of joins and parts on the user hostname.
+# Leave empty to log all of them
+# Prepend with a @ for a perfect match
+# Otherwise, specify the required end of the user hostname
+#
+loggedHostnamePattern=@free.duck.i2p
+
 ###
 # The prefix to be used for the filenames of logs.
 #
@@ -47,6 +66,18 @@ logFilePrefix=irc.duck.i2p.i2p-chat
 #
 logFileRotationInterval=daily
 
+###
+# Set to "true" to enable the regular round-trip delay computation,
+# else "false" (but don't use quotation marks).
+#
+isRoundTripDelayEnabled=false
+
+###
+# How often should the round-trip delay be recorded.
+# (in seconds)
+#
+roundTripDelayPeriod=300
+
 ###
 # Set to "true" to enable the userlist command, else "false" (but don't use
 # quotation marks).

apps/bogobot/build-eclipse.xml

@@ -3,12 +3,13 @@
 <!-- ********************************************************** -->
 <!-- bogobot - A simple join/part stats logger bot for I2P IRC. -->
 <!--                                                            -->
-<!-- build_eclipse.xml                                          -->
+<!-- build-eclipse.xml                                          -->
 <!-- 2004 The I2P Project                                       -->
+<!-- http://www.i2p.net                                         -->
 <!-- This code is public domain.                                -->
 <!--                                                            -->
-<!-- author hypercubus                                          -->
-<!-- version 0.3.1                                              -->
+<!-- authors: hypercubus, oOo                                   -->
+<!-- version 0.4                                                -->
 <!-- ********************************************************** -->
 
 <project basedir="." default="dist" name="Bogobot">
@@ -27,7 +28,7 @@
     Create the binary distribution archive -->
     <target depends="init" description="Create the binary distribution archive" name="dist.bin">
         <zip destfile="dist/Bogobot_${DSTAMP}.zip">
-            <zipfileset dir="${basedir}" includes="bogobot.bat Bogobot.class bogobot.sh Bogoparser.class LICENSE_log4j.txt LICENSE_pircbot.txt log4j-1.2.8.jar pircbot.jar" />
+            <zipfileset dir="${basedir}" includes="bogobot.bat bogobot.config Bogobot.class bogobot.sh Bogoparser.class LICENSE_log4j.txt LICENSE_pircbot.txt log4j-1.2.8.jar pircbot.jar" />
         </zip>
     </target>
 
@@ -35,7 +36,7 @@
     Create the source distribution archive -->
     <target depends="init" description="Create the source distribution archive" name="dist.source">
         <zip destfile="dist/Bogobot_source_${DSTAMP}.zip">
-            <zipfileset dir="${basedir}" includes="bogobot.bat Bogobot.java bogobot.sh Bogoparser.java build.xml build_eclipse.xml LICENSE_log4j.txt LICENSE_pircbot.txt log4j-1.2.8.jar pircbot.jar" />
+            <zipfileset dir="${basedir}" includes="bogobot.bat bogobot.config Bogobot.java bogobot.sh Bogoparser.java build.xml build_eclipse.xml LICENSE_log4j.txt LICENSE_pircbot.txt log4j-1.2.8.jar pircbot.jar" />
         </zip>
     </target>
 

apps/bogobot/build.xml

@@ -5,10 +5,11 @@
 <!--                                                            -->
 <!-- build.xml                                                  -->
 <!-- 2004 The I2P Project                                       -->
+<!-- http://www.i2p.net                                         -->
 <!-- This code is public domain.                                -->
 <!--                                                            -->
-<!-- author hypercubus                                          -->
-<!-- version 0.3.1                                              -->
+<!-- authors: hypercubus, oOo                                   -->
+<!-- version 0.4                                                -->
 <!-- ********************************************************** -->
 
 <project basedir="." default="compile" name="Bogobot">
@@ -26,14 +27,14 @@
     <!-- compile:
     Compile source code -->
     <target depends="init" description="Compile source code" name="compile">
-        <javac classpath="${basedir}" source="1.4" srcdir="." />
+        <javac classpath="${basedir};log4j-1.2.8.jar;pircbot.jar" source="1.4" srcdir="." />
     </target>
 
     <!-- dist.bin:
     Create the binary distribution archive -->
     <target depends="init,compile" description="Create the binary distribution archive" name="dist.bin">
         <zip destfile="dist/Bogobot_${DSTAMP}.zip">
-            <zipfileset dir="${basedir}" includes="bogobot.bat Bogobot.class bogobot.sh Bogoparser.class LICENSE_log4j.txt LICENSE_pircbot.txt log4j-1.2.8.jar pircbot.jar" />
+            <zipfileset dir="${basedir}" includes="bogobot.bat bogobot.config Bogobot.class Bogobot$BogobotTickTask.class bogobot.sh Bogoparser.class LICENSE_log4j.txt LICENSE_pircbot.txt log4j-1.2.8.jar pircbot.jar" />
         </zip>
     </target>
 
@@ -41,7 +42,7 @@
     Create the source distribution archive -->
     <target depends="init" description="Create the source distribution archive" name="dist.source">
         <zip destfile="dist/Bogobot_source_${DSTAMP}.zip">
-            <zipfileset dir="${basedir}" includes="bogobot.bat Bogobot.java bogobot.sh Bogoparser.java build.xml build_eclipse.xml LICENSE_log4j.txt LICENSE_pircbot.txt log4j-1.2.8.jar pircbot.jar" />
+            <zipfileset dir="${basedir}" includes="bogobot.bat bogobot.config Bogobot.java bogobot.sh Bogoparser.java build.xml build_eclipse.xml LICENSE_log4j.txt LICENSE_pircbot.txt log4j-1.2.8.jar pircbot.jar" />
         </zip>
     </target>
 

apps/enclave/LICENSE

@@ -1,27 +0,0 @@
-Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-    * Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-notice, this list of conditions and the following disclaimer in the
-documentation and/or other materials provided with the distribution.
-    * Neither the name of the author nor the names of any contributors
-may be used to endorse or promote products derived from this software
-without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
-IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
-TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
-PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
-OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

apps/enclave/Makefile.cygwin

@@ -1,87 +0,0 @@
-#
-# This Makefile is compatible with GNU Make and should work on Cygwin
-#
-
-#
-# Your operating environment
-#
-
-OS = CYGWIN
-
-#
-# Directories
-#
-
-BINDIR = bin
-LOGDIR = log
-OBJDIR = obj
-SRCDIR = src
-
-SAMINCDIR = ../sam/c/inc
-SAMLIBDIR = ../sam/c/lib
-TOMCRYPTDIR = $(HOME)/libtomcrypt-0.96
-
-#
-# Programs
-#
-
-CC = g++
-
-#
-# Flags
-#
-
-CFLAGS = -g -march=i486 -pipe -Wall
-CFLAGS += -DOS=$(OS)
-
-#
-# Libraries
-#
-
-CFLAGS += -I$(SAMINCDIR) -I$(TOMCRYPTDIR)
-LDFLAGS = -L$(SAMLIBDIR) -L$(TOMCRYPTDIR)
-LIBS = -lsam -ltomcrypt -lpthread
-
-#
-# Object files
-#
-
-OBJS =	$(OBJDIR)/bigint.o \
-		$(OBJDIR)/chk.o \
-		$(OBJDIR)/config.o \
-		$(OBJDIR)/logger.o \
-		$(OBJDIR)/main.o \
-		$(OBJDIR)/mutex.o \
-		$(OBJDIR)/peers.o \
-		$(OBJDIR)/random.o \
-		$(OBJDIR)/rpc.o \
-		$(OBJDIR)/sam.o \
-		$(OBJDIR)/sha1.o \
-		$(OBJDIR)/thread.o
-
-#
-# Build rules
-#
-
-all: depend enclave
-
-depend:
-	$(CC) $(CFLAGS) -MM $(SRCDIR)/*.cpp > .depend
-
-$(OBJDIR)/%.o: $(SRCDIR)/%.cpp
-	$(CC) $(CFLAGS) -o $@ -c $<
-
-enclave: $(OBJS)
-	$(CC) $(CFLAGS) $(LDFLAGS) -o $(BINDIR)/enclave $(OBJS) $(LIBS)
-
-#
-# Cleanup rules
-#
-
-clean:
-	-rm -f $(BINDIR)/* $(OBJDIR)/* .depend
-
-clean-logs:
-	-rm -f $(LOGDIR)/*
-
-tidy: clean clean-logs

apps/enclave/Makefile.linux

@@ -1,87 +0,0 @@
-#
-# This Makefile is compatible with GNU Make and should work on Linux (generic)
-#
-
-#
-# Your operating environment
-#
-
-OS = LINUX
-
-#
-# Directories
-#
-
-BINDIR = bin
-LOGDIR = log
-OBJDIR = obj
-SRCDIR = src
-
-SAMINCDIR = ../sam/c/inc
-SAMLIBDIR = ../sam/c/lib
-TOMCRYPTDIR = $(HOME)/libtomcrypt-0.96
-
-#
-# Programs
-#
-
-CC = g++
-
-#
-# Flags
-#
-
-CFLAGS = -g -march=i486 -pipe -Wall
-CFLAGS += -DOS=$(OS)
-
-#
-# Libraries
-#
-
-CFLAGS += -I$(SAMINCDIR) -I$(TOMCRYPTDIR)
-LDFLAGS = -L$(SAMLIBDIR) -L$(TOMCRYPTDIR)
-LIBS = -lsam -ltomcrypt -lpthread
-
-#
-# Object files
-#
-
-OBJS =	$(OBJDIR)/bigint.o \
-		$(OBJDIR)/chk.o \
-		$(OBJDIR)/config.o \
-		$(OBJDIR)/logger.o \
-		$(OBJDIR)/main.o \
-		$(OBJDIR)/mutex.o \
-		$(OBJDIR)/peers.o \
-		$(OBJDIR)/random.o \
-		$(OBJDIR)/rpc.o \
-		$(OBJDIR)/sam.o \
-		$(OBJDIR)/sha1.o \
-		$(OBJDIR)/thread.o
-
-#
-# Build rules
-#
-
-all: depend enclave
-
-depend:
-	$(CC) $(CFLAGS) -MM $(SRCDIR)/*.cpp > .depend
-
-$(OBJDIR)/%.o: $(SRCDIR)/%.cpp
-	$(CC) $(CFLAGS) -o $@ -c $<
-
-enclave: $(OBJS)
-	$(CC) $(CFLAGS) $(LDFLAGS) -o $(BINDIR)/enclave $(OBJS) $(LIBS)
-
-#
-# Cleanup rules
-#
-
-clean:
-	-rm -f $(BINDIR)/* $(OBJDIR)/* .depend
-
-clean-logs:
-	-rm -f $(LOGDIR)/*
-
-tidy: clean clean-logs

apps/enclave/Makefile.mingw

@@ -1,87 +0,0 @@
-#
-# This Makefile is compatible with GNU Make and should work on Windows (Mingw)
-#
-
-#
-# Your operating environment
-#
-
-OS = MINGW
-
-#
-# Directories
-#
-
-BINDIR = bin
-LOGDIR = log
-OBJDIR = obj
-SRCDIR = src
-
-SAMINCDIR = C:\cygwin\home\Administrator\cvs\i2p\apps\sam\c\inc
-SAMLIBDIR = C:\cygwin\home\Administrator\cvs\i2p\apps\sam\c\lib
-TOMCRYPTDIR = C:\cygwin\home\Administrator\libtomcrypt-0.96
-
-#
-# Programs
-#
-
-CC = C:\Dev-Cpp\bin\g++
-
-#
-# Flags
-#
-
-CFLAGS = -g -march=i486 -pipe -Wall
-CFLAGS += -DOS=$(OS)
-
-#
-# Libraries
-#
-
-CFLAGS += -I$(SAMINCDIR) -I$(TOMCRYPTDIR)
-LDFLAGS = -L$(SAMLIBDIR) -L$(TOMCRYPTDIR)
-LIBS = -lsam -ltomcrypt
-
-#
-# Object files
-#
-
-OBJS =	$(OBJDIR)/bigint.o \
-		$(OBJDIR)/chk.o \
-		$(OBJDIR)/config.o \
-		$(OBJDIR)/logger.o \
-		$(OBJDIR)/main.o \
-		$(OBJDIR)/mutex.o \
-		$(OBJDIR)/peers.o \
-		$(OBJDIR)/random.o \
-		$(OBJDIR)/rpc.o \
-		$(OBJDIR)/sam.o \
-		$(OBJDIR)/sha1.o \
-		$(OBJDIR)/thread.o
-
-#
-# Build rules
-#
-
-all: depend enclave
-
-depend:
-	$(CC) $(CFLAGS) -MM $(SRCDIR)/*.cpp > .depend
-
-$(OBJDIR)/%.o: $(SRCDIR)/%.cpp
-	$(CC) $(CFLAGS) -o $@ -c $<
-
-enclave: $(OBJS)
-	$(CC) $(CFLAGS) $(LDFLAGS) -o $(BINDIR)/enclave $(OBJS) $(LIBS)
-
-#
-# Cleanup rules
-#
-
-clean:
-	-rm -f $(BINDIR)/* $(OBJDIR)/* .depend
-
-clean-logs:
-	-rm -f $(LOGDIR)/*
-
-tidy: clean clean-logs

apps/enclave/cfg/enclave.cfg

@@ -1,32 +0,0 @@
-#
-# This is the Enclave configuration file.  Lines starting with # and blank lines
-# are ignored.
-#
-
-# The DNS name or IP address of the SAM server you will be using
-samhost=localhost
-
-# The TCP port the SAM server is listening on
-samport=7656
-
-# The destination name of this program.  This can be anything.  If you run
-# multiple copies of Enclave off the same SAM server then each one has to have a
-# unique name.
-samname=enclave
-
-# The depth used for incoming and outgoing I2P tunnels.  Using a depth of 2 is
-# the default and a good choice.  You can set it to 0 if you don't care about
-# anonymity and just want speed.
-tunneldepth=0
-
-# The location of the peer references file.  You can use an absolute or relative
-# path, but absolute paths are safer.
-references=cfg/peers.ref
-
-# Record every log message at or above this priority level
-# debug = 0, minor = 1, info = 2, warn = 3, error = 4
-loglevel=0
-
-# The location of the Enclave log file.  You can use an absolute or relative
-# path, but absolute paths are safer.
-logfile=log/enclave.log

apps/enclave/cfg/peers.ref

@@ -1,2 +0,0 @@
-4KpEG0uUvTM~IZKuWZZifdmh5UU6evIPG0tE3ppoqy37AY2NJrsM8BU0EkT1SG-g18qSW9UHDp7qs7m~WzeWTXyYggEb6k6-e0GYC2Cj8ED8JV58-2~cFZumVNJ2d1hns-MGX7RZv2lz3Cz2ZVhfZxSIw9UnpV-kwVn7sQ7PBCvJYE4INbp5OlRQH1-3lXiUheoJfeZpegGTUSHUwIRWglX7w87YF~LCbJMYXDgMyA3SaxsZaun7Wc8ku4bqtbmG9u15XlmqimLUUmDG0cw77HJzqxnR1C1hx0wf-9zgH6u4jwTWk92w5tZJZSv1SHKejlPkIbRNAhZv5wroyZsn6T0koV~kTVCvbUEwILho-rHn4A6C2jLQifwE9aucziBTVq3YLK2urf1wI1jLh98iFNav40S~B2w-4xZFAQ49bOdWzY4KmVIjocVhfGi~RLl5bHD1TEJS7nOaDhI8qCSe7mR0XzZgQ~iROR~XowlwKXBzNPjKED7yN8GgV2pWRGNYAAAA
-WiotuvEjGpSz7q14eZGYFpD0xNt3V~nxZdDDgKc~whkW-pardZyz~wZipHXLIOvniThDL2rxJ~OW7RxgUycCph4x--NL51kEJhMWZ~bgxPioxw-T4JGQ9LSNndt9xNOf6yhEqyokqyEOEeJjw6m2e7RX7mTRffmTlCdu6uH6rVEk22o4Uu5S26p6-LS2k9lRyMWitFd~t9cnOgLTZTE~h4d-UlAd1BGxpCTlGWcaynOQzKKtljZknZMF9Qv19MxT83t18~3IURb6aOLlC4oih9pMt1pHouZuOaStKA7cGLsXUAhSB31BvK8l4R7VhgcudwJ9EQZkZQee51hcng7K1Yqmd4lnjHHuf1mDk0YXBAWDZOM0-oEwkJWumGuYl0NUtLhNlFrBjenbjACx88qhfy6mkXfo8c-c2QqEXuD2xt4OVqrWxBTIrr1pR-E1NdIxzIvOlCbrRXaqxqu-wnrrG2vCO-1zu9NHacCVjXD7AR7p3T628wPdCUzj2~rZRcCkAAAA

apps/enclave/libsockthread/LICENSE

@@ -1,27 +0,0 @@
-Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-    * Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-notice, this list of conditions and the following disclaimer in the
-documentation and/or other materials provided with the distribution.
-    * Neither the name of the author nor the names of any contributors
-may be used to endorse or promote products derived from this software
-without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
-IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
-TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
-PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
-OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

apps/enclave/libsockthread/src/logger.cpp

@@ -1,160 +0,0 @@
-/*
- * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *     * Neither the name of the author nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
- * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * $Id$
- */
-
-#include "platform.hpp"
-#include "mutex.hpp"
-#include "time.hpp"
-#include "logger.hpp"
-using namespace Libsockthread;
-
-/*
- * Closes the log file
- */
-void Logger::close()
-{
-	logf_m.lock();
-	if (logf == NULL) {
-		logf_m.unlock();
-		return;
-	}
-	if (fclose(logf) == EOF) {
-		cerr_m.lock();
-		cerr << "fclose() failed: " << strerror(errno) << '\n';
-		cerr_m.unlock();
-	}
-	logf = NULL;
-	logf_m.unlock();
-}
-
-/*
- * Sends a line to the log file.  Uses variable arguments just like printf().
- */
-void Logger::log(priority_t priority, const char* format, ...)
-{
-	if (priority < get_loglevel())
-		return;
-
-	char ll;
-	switch (priority) {
-		case Logger::DEBUG:
-			ll = 'D';
-			break;
-		case Logger::MINOR:
-			ll = 'M';
-			break;
-		case Logger::INFO:
-			ll = 'I';
-			break;
-		case Logger::WARN:
-			ll = 'W';
-			break;
-		case Logger::ERROR:
-			ll = 'E';
-			break;
-		default:
-			ll = '?';
-	}
-
-	va_list ap;
-	va_start(ap, format);
-	Time t;
-	logf_m.lock();
-
-	if (logf != NULL) {
-		/*
-		 * Remember!  If you change the format here, change it in the else too
-		 */
-		fprintf(logf, "%c %s ", ll, t.utc().c_str());
-		vfprintf(logf, format, ap);
-		fputc('\n', logf);
-		if (fflush(logf) == EOF) {
-			cerr_m.lock();
-			cerr << "fflush() failed: " << strerror(errno) << '\n';
-			cerr_m.unlock();
-		}
-	} else {
-		// if they don't have an open log file, just use stderr
-		fprintf(stderr, "%c %s ", ll, t.utc().c_str());
-		vfprintf(stderr, format, ap);
-		fputc('\n', stderr);
-	}
-
-	va_end(ap);
-	logf_m.unlock();
-
-	return;
-}
-
-/*
- * Opens a log file for appending.  If a log file is already open, then it is
- * closed and the new one is opened.
- *
- * file - file location to open
- */
-bool Logger::open(const string& file)
-{
-	close();
-	logf_m.lock();
-	logf = fopen(file.c_str(), "a");
-	if (logf != NULL) {
-		logf_m.unlock();
-		return true;
-	} else {
-		logf_m.unlock();
-		cerr_m.lock();
-		cerr << "fopen() failed (" << file << "): " << strerror(errno) << '\n';
-		cerr_m.unlock();
-		return false;
-	}
-}
-
-#ifdef UNIT_TEST
-// g++ -Wall -c thread.cpp -o thread.o
-// g++ -Wall -c mutex.cpp -o mutex.o
-// g++ -Wall -c time.cpp -o time.o
-// g++ -Wall -DUNIT_TEST -c logger.cpp -o logger.o
-// g++ -Wall -DUNIT_TEST logger.o mutex.o thread.o time.o -o logger -pthread
-int main()
-{
-	Logger logger;
-
-	logger.open("delete.me");
-	logger.set_loglevel(Logger::MINOR);
-	logger.close();
-	LWARNS("This should appear on stderr");
-	logger.open("delete.me.also");
-	LINFO("%s\n", "hey it works");
-	LDEBUGS("This shouldn't be saved in the file.");
-
-	return 0;
-}
-#endif  // UNIT_TEST

apps/enclave/libsockthread/src/logger.hpp

@@ -1,98 +0,0 @@
-/*
- * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *     * Neither the name of the author nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
- * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * $Id$
- */
-
-#ifndef LIBSOCKTHREAD_LOGGER_HPP
-#define LIBSOCKTHREAD_LOGGER_HPP
-
-/*
- * Some helpful macros:
- *
- * LDEBUG - debugging messages
- * LMINOR - unimportant messages
- * LINFO - informational messages
- * LWARN - errors we automatically recover from
- * LERROR - major, important errors
- *
- * These only work if your Logger object is called "logger"
- */
-// Prints out the file name, function name, and line number before the message
-#define LDEBUG(format, ...) logger.log(Logger::DEBUG, "%s:%s:%d:" \
-	format, __FILE__, __func__, __LINE__, __VA_ARGS__)
-// This is the same as above, except it doesn't accept varargs
-#define LDEBUGS(str) logger.log(Logger::DEBUG, "%s:%s:%d:" \
-	str, __FILE__, __func__, __LINE__);
-#define LMINOR(format, ...) logger.log(Logger::MINOR, "%s:%s:%d:" \
-	format, __FILE__, __func__, __LINE__, __VA_ARGS__)
-#define LMINORS(str) logger.log(Logger::MINOR, "%s:%s:%d:" \
-	str, __FILE__, __func__, __LINE__);
-#define LINFO(format, ...) logger.log(Logger::INFO, "%s:%s:%d:" \
-	format, __FILE__, __func__, __LINE__, __VA_ARGS__)
-#define LINFOS(str) logger.log(Logger::INFO, "%s:%s:%d:" \
-	str, __FILE__, __func__, __LINE__);
-#define LWARN(format, ...) logger.log(Logger::WARN, "%s:%s:%d:" \
-	format, __FILE__, __func__, __LINE__, __VA_ARGS__)
-#define LWARNS(str) logger.log(Logger::WARN, "%s:%s:%d:" \
-	str, __FILE__, __func__, __LINE__);
-#define LERROR(format, ...) logger.log(Logger::ERROR, "%s:%s:%d:" \
-	format, __FILE__, __func__, __LINE__, __VA_ARGS__)
-#define LERRORS(str) logger.log(Logger::ERROR, "%s:%s:%d:" \
-	str, __FILE__, __func__, __LINE__);
-
-namespace Libsockthread {
-	class Logger {
-		public:
-			enum priority_t {DEBUG = 0, MINOR = 1, INFO = 2, WARN = 3,
-				ERROR = 4};
-
-			Logger()
-				: logf(NULL), loglevel(Logger::DEBUG) { }
-			~Logger()
-				{ close(); }
-
-			void close();
-			void log(priority_t priority, const char* format, ...);
-			priority_t get_loglevel()
-				{ loglevel_m.lock(); priority_t ll = loglevel;
-					loglevel_m.unlock(); return ll; }
-			bool open(const string& file);
-			void set_loglevel(priority_t priority)
-				{ loglevel_m.lock(); loglevel = priority; loglevel_m.unlock(); }
-		private:
-			Mutex cerr_m;
-			FILE* logf;
-			Mutex logf_m;
-			priority_t loglevel;
-			Mutex loglevel_m;
-	};
-}
-
-#endif  // LIBSOCKTHREAD_LOGGER_HPP

apps/enclave/libsockthread/src/mutex.cpp

@@ -1,134 +0,0 @@
-/*
- * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *     * Neither the name of the author nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
- * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * $Id$
- */
-
-/*
- * Modelled after JThread by Jori Liesenborgs
- */
-
-#include "platform.hpp"
-#include "mutex.hpp"
-using namespace Libsockthread;
-
-/*
- * Creates a mutex
- */
-Mutex::Mutex()
-{
-#ifdef WINTHREAD
-	mutex = CreateMutex(NULL, false, NULL);
-	assert(mutex != NULL);
-#else
-	int rc = pthread_mutex_init(&mutex, NULL);
-	assert(rc == 0);
-#endif
-}
-
-/*
- * Destroys a mutex
- */
-Mutex::~Mutex()
-{
-#ifdef WINTHREAD
-	BOOL rc = CloseHandle(mutex);
-	assert(rc);
-#else
-	int rc = pthread_mutex_destroy(&mutex);
-	assert(rc == 0);
-#endif
-}
-
-/*
- * Locks the mutex
- */
-void Mutex::lock()
-{
-#ifdef WINTHREAD
-	DWORD rc = WaitForSingleObject(mutex, INFINITE);
-	assert(rc != WAIT_FAILED);
-#else
-	int rc = pthread_mutex_lock(&mutex);
-	assert(rc == 0);
-#endif
-}
-
-/*
- * Unlocks the mutex
- */
-void Mutex::unlock()
-{
-#ifdef WINTHREAD
-	BOOL rc = ReleaseMutex(mutex);
-	assert(rc);
-#else
-	int rc = pthread_mutex_unlock(&mutex);
-	assert(rc == 0);
-#endif
-}
-
-#ifdef UNIT_TEST
-// g++ -Wall -c thread.cpp -o thread.o
-// g++ -Wall -DUNIT_TEST -c mutex.cpp -o mutex.o
-// g++ -Wall -DUNIT_TEST mutex.o thread.o -o mutex -pthread
-#include "thread.hpp"
-
-Mutex widget;
-
-int main()
-{
-	class Mutex_test : public Thread
-	{
-		public:
-			Mutex_test(int n)
-				: testval(n) {}
-
-			void* thread()
-			{
-				widget.lock();
-				cout << "I got it!  thread #" << testval << '\n';
-				// If this works, only one thread should be able to lock the
-				// widget, since it is never unlocked
-				return 0;
-			}
-
-		private:
-			int testval;
-	};
-
-	Mutex_test t1(1);
-	Mutex_test t2(2);
-	Mutex_test t3(3);
-	t1.start(); t2.start(); t3.start();
-	while (true);
-
-	return 0;
-}
-#endif  // UNIT_TEST

apps/enclave/libsockthread/src/mutex.hpp

@@ -1,57 +0,0 @@
-/*
- * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *     * Neither the name of the author nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
- * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * $Id$
- */
-
-/*
- * Modelled after JThread by Jori Liesenborgs
- */
-
-#ifndef LIBSOCKTHREAD_MUTEX_HPP
-#define LIBSOCKTHREAD_MUTEX_HPP
-
-namespace Libsockthread {
-	class Mutex {
-		public:
-			Mutex();
-			~Mutex();
-
-			void lock();
-			void unlock();
-		private:
-#ifdef WINTHREAD
-			HANDLE mutex;
-#else
-			pthread_mutex_t mutex;
-#endif
-	};
-}
-
-#endif  // LIBSOCKTHREAD_MUTEX_HPP

apps/enclave/libsockthread/src/platform.hpp

@@ -1,77 +0,0 @@
-/*
- * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *     * Neither the name of the author nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
- * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * $Id: platform.hpp,v 1.5 2004/07/22 03:54:01 mpc Exp $
- */
-
-/*
- * Global includes and platform configuration.  This is used to compile the
- * library, but is not intended for use by users of the library in their
- * own programs.
- */
-
-#ifndef LIBSOCKTHREAD_PLATFORM_HPP
-#define LIBSOCKTHREAD_PLATFORM_HPP
-
-/*
- * Operating system
- */
-#define FREEBSD	0  // FreeBSD
-#define WIN32	1  // Windows
-#define LINUX	2  // Linux
-
-#if OS == WIN32
-	#define WINSOCK
-	#define WINTHREAD
-#endif
-
-#ifndef WINSOCK
-	#include <arpa/inet.h>
-#endif
-#include <cassert>
-#include <cstdarg>
-#include <cstddef>
-#include <cstdio>
-#include <ctime>
-#include <iostream>
-#ifndef WINSOCK
-	#include <netdb.h>
-#endif
-#ifndef WINTHREAD
-	#include <pthread.h>
-#endif
-#include <stdint.h>  // TODO replace with Boost's version
-#include <string>
-#if defined WINSOCK || defined WINTHREAD
-	#include <windows.h>
-#endif
-using namespace std;
-#include "types.hpp"
-
-#endif  // LIBSOCKTHREAD_PLATFORM_HPP

apps/enclave/libsockthread/src/socket.cpp

@@ -1,72 +0,0 @@
-/*
- * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *     * Neither the name of the author nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
- * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * $Id: socket.cpp,v 1.8 2004/07/22 22:08:20 mpc Exp $
- */
-
-#include "platform.hpp"
-#include "socket_error.hpp"
-#include "socket.hpp"
-using namespace Libsockthread;
-
-/*
- * Closes the socket
- */
-void Socket::close()
-{
-	if (sock != SERR) {
-		if (close(sock) == -1)
-			;  // FIXME log the error
-	}
-	sock = SERR;
-}
-
-/*
- * Changes the address associated with the socket
- */
-void Socket::set_addr(Socket_addr& addr)
-{
-	close();
-	this->addr = addr;
-	setup_socket();
-}
-
-/*
- * Prepares the socket for use
- */
-void Socket::setup_socket()
-{
-	assert(sock == SERR);  // the descriptor shouldn't be active
-	if (!addr.is_ready())
-		throw Socket_error("Couldn't create socket: address isn't ready");
-
-	sock = socket(addr.get_family(), addr.get_type(), 0);
-	if (sock == SERR)
-		throw Socket_error(strerror(errno));
-}

apps/enclave/libsockthread/src/socket.hpp

@@ -1,68 +0,0 @@
-/*
- * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *     * Neither the name of the author nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
- * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * $Id: socket.hpp,v 1.8 2004/07/22 22:08:20 mpc Exp $
- */
-
-#ifndef LIBSOCKTHREAD_SOCKET_HPP
-#define LIBSOCKTHREAD_SOCKET_HPP
-
-namespace Libsockthread {
-	class Socket {
-		public:
-			#ifdef WINSOCK
-				typedef SOCKET socket_t;
-				enum { SERR = SOCKET_ERROR };
-			#else
-				typedef int socket_t;
-				enum { SERR = -1 };
-			#endif
-
-			Socket()
-				: addr(), sock(SERR) {}
-			Socket(Socket_addr& addr)  // throws Socket_error
-				: addr(addr), sock(SERR) { setup_socket(); }
-
-			void close();
-			size_t read(vector<uchar_t>& buf, size_t max = 0);
-			size_t read_until(vector<uchar_t>& buf, uchar_t delim = '\n');
-			void set_addr(Socket_addr& addr);  // throws Socket_error
-			void set_blocking(bool blocking);
-			size_t write(vector<uchar_t>& buf);
-			void write_all(vector<uchar_t>& buf);
-			size_t write_until(vector<uchar_t& buf, uchar_t delim = '\n');
-		private:
-			void setup_socket();  // throws Socket_error
-
-			Socket_addr addr;
-			socket_t sock;
-	};
-}
-
-#endif  // LIBSOCKTHREAD_SOCKET_HPP

apps/enclave/libsockthread/src/socket_addr.cpp

@@ -1,108 +0,0 @@
-/*
- * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *     * Neither the name of the author nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
- * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * $Id: socket_addr.cpp,v 1.4 2004/07/22 19:10:59 mpc Exp $
- */
-
-#include "platform.hpp"
-#include "socket_error.hpp"
-#include "socket_addr.hpp"
-using namespace Libsockthread;
-
-Socket_addr::Socket_addr(Socket_addr& rhs)
-{
-	delete[] ip;
-	if (rhs.resolved) {
-		if (rhs.family == AF_INET) {
-			ip = new char[INET_ADDRSTRLEN];
-		else
-			ip = new char[INET6_ADDRSTRLEN];
-		strcpy(ip, rhs.ip);
-	}
-	family = rhs.family;
-	host = rhs.host;
-	port = rhs.port;
-	resolved = rhs.resolved;
-	type = rhs.type;
-}
-
-Socket_addr& Socket_addr::operator=(const Socket_addr& rhs)
-{
-	if (this == &rhs)  // check for self-assignment: a = a
-		return *this;
-
-	delete[] ip;
-	if (rhs.resolved) {
-		if (rhs.family == AF_INET)
-			ip = new char[INET_ADDRSTRLEN];
-		else
-			ip = new char[INET6_ADDRSTRLEN];
-		strcpy(ip, rhs.ip);
-	}
-	family = rhs.family;
-	host = rhs.host;
-	port = rhs.port;
-	type = rhs.type;
-
-	return *this;
-}
-
-/*
- * Performs a DNS lookup
- */
-void Socket_addr::resolve()
-{
-	resolved = false;  // in case they already had a host name but just set a
-					   // new one with set_host()
-	hostent* hent = gethostbyname(host.c_str());
-	if (hent == NULL)
-		throw Dns_error(hstrerror(h_errno));
-	assert(hent->h_addrtype == AF_INET || hent->h_addrtype == AF_INET6);
-	family = hent->h_addrtype;
-	delete[] ip;
-	if (family == AF_INET) {
-		ip = new char[INET_ADDRSTRLEN];
-	else
-		ip = new char[INET6_ADDRSTRLEN];
-	strcpy(ip, hent->h_addr_list[0]);
-	resolved = true;
-}
-
-bool Socket_addr::operator==(const Socket_addr& rhs)
-{
-	if (rhs.family == family
-			&& rhs.host == host
-			&& strcmp(rhs.ip, ip) == 0
-			&& rhs.port == port
-			&& rhs.resolved == resolved
-			&& rhs.type == type)
-		return true;
-	else
-		return false;
-}

apps/enclave/libsockthread/src/socket_addr.hpp

@@ -1,78 +0,0 @@
-/*
- * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *     * Neither the name of the author nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
- * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * $Id: socket_addr.hpp,v 1.4 2004/07/22 19:10:59 mpc Exp $
- */
-
-#ifndef LIBSOCKTHREAD_SOCKET_ADDR_HPP
-#define LIBSOCKTHREAD_SOCKET_ADDR_HPP
-
-namespace Libsockthread {
-	class Socket_addr {
-		public:
-			Socket_addr()
-				: family(AF_INET), resolved(false) { }
-			Socket_addr(Socket_addr& rhs);
-			Socket_addr(int type, string& host, uint16_t port)
-				: family(AF_INET), host(host), type(type), port(port)
-				{ resolve(); }  // throws Dns_error
-			~Socket_addr()
-				{ delete[] ip; }
-
-			int get_family() const
-				{ return family; }
-			const char* get_ip() const  // Warning!  This can be NULL!
-				{ return ip; }
-			uint16_t get_port() const
-				{ return port; }
-			int get_type() const
-				{ return type;
-			bool is_ready() const
-				{ return resolved; }
-			Socket_addr& operator=(const Socket_addr& rhs);
-			bool operator==(const Socket_addr& rhs);
-			void set_host(string& host)  // throws Dns_error
-				{ this->host = host; resolve(); }
-			void set_port(uint16_t port)
-				{ this->port = port; }
-			void set_type(int type)
-				{ this->type = type; }
-		private:
-			void resolve();  // throws Dns_error
-
-			int family;  // AF_INET or AF_INET6
-			string host;
-			char* ip;
-			uint16_t port;
-			bool resolved;
-			int type;  // SOCK_STREAM or SOCK_DGRAM
-	};
-}
-
-#endif  // LIBSOCKTHREAD_SOCKET_ADDR_HPP

apps/enclave/libsockthread/src/socket_connector.cpp

@@ -1,35 +0,0 @@
-/*
- * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *     * Neither the name of the author nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
- * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * $Id$
- */
-
-#include "platform.hpp"
-#include "socket_connector.hpp"
-using namespace Libsockthread;

apps/enclave/libsockthread/src/socket_connector.hpp

@@ -1,46 +0,0 @@
-/*
- * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *     * Neither the name of the author nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
- * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * $Id$
- */
-
-#ifndef LIBSOCKTHREAD_SOCKET_CONNECTOR_HPP
-#define LIBSOCKTHREAD_SOCKET_CONNECTOR_HPP
-
-namespace Libsockthread {
-	class Socket_connector : public Socket {
-		public:
-			Socket_connector(Socket_addr& addr)
-				: Socket(addr);
-
-			void connect();
-	};
-}
-
-#endif  // LIBSOCKTHREAD_SOCKET_CONNECTOR_HPP

apps/enclave/libsockthread/src/socket_error.hpp

@@ -1,47 +0,0 @@
-/*
- * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *     * Neither the name of the author nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
- * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef LIBSOCKTHREAD_SOCKET_ERROR_HPP
-#define LIBSOCKTHREAD_SOCKET_ERROR_HPP
-
-namespace Libsockthread {
-	class Socket_error : public runtime_error {
-		public:
-			Socket_error(const string& s)
-				: runtime_error(s) { }
-	};
-	class Dns_error : public Socket_error {
-		public:
-			Dns_error(const string& s)
-				: Socket_error(s) { }
-	};
-}
-
-#endif  // LIBSOCKTHREAD_SOCKET_ERROR_HPP

apps/enclave/libsockthread/src/socket_listener.cpp

@@ -1,35 +0,0 @@
-/*
- * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *     * Neither the name of the author nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
- * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * $Id$
- */
-
-#include "platform.hpp"
-#include "socket_listener.hpp"
-using namespace Libsockthread;

apps/enclave/libsockthread/src/socket_listener.hpp

@@ -1,47 +0,0 @@
-/*
- * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *     * Neither the name of the author nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
- * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * $Id$
- */
-
-#ifndef LIBSOCKTHREAD_SOCKET_LISTENER_HPP
-#define LIBSOCKTHREAD_SOCKET_LISTENER_HPP
-
-namespace Libsockthread {
-	class Socket_listener {
-		public:
-			Socket_listener(Socket_addr& addr)
-				: Socket(addr);
-
-			void accept();
-			void listen();
-	};
-}
-
-#endif  // LIBSOCKTHREAD_SOCKET_LISTENER_HPP

apps/enclave/libsockthread/src/strl.c

@@ -1,86 +0,0 @@
-/*
- * Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- *
- * $Id$
- */
-
-#include <stddef.h>
-#include <string.h>
-
-/*
- * Appends src to string dst of size siz (unlike strncat, siz is the
- * full size of dst, not space left).  At most siz-1 characters
- * will be copied.  Always NUL terminates (unless siz <= strlen(dst)).
- * Returns strlen(src) + MIN(siz, strlen(initial dst)).
- * If retval >= siz, truncation occurred.
- */
-size_t
-strlcat(char *dst, const char *src, size_t siz)
-{
-	register char *d = dst;
-	register const char *s = src;
-	register size_t n = siz;
-	size_t dlen;
-
-	/* Find the end of dst and adjust bytes left but don't go past end */
-	while (n-- != 0 && *d != '\0')
-		d++;
-	dlen = d - dst;
-	n = siz - dlen;
-
-	if (n == 0)
-		return(dlen + strlen(s));
-	while (*s != '\0') {
-		if (n != 1) {
-			*d++ = *s;
-			n--;
-		}
-		s++;
-	}
-	*d = '\0';
-
-	return(dlen + (s - src));	/* count does not include NUL */
-}
-
-/*
- * Copy src to string dst of size siz.  At most siz-1 characters
- * will be copied.  Always NUL terminates (unless siz == 0).
- * Returns strlen(src); if retval >= siz, truncation occurred.
- */
-size_t
-strlcpy(char *dst, const char *src, size_t siz)
-{
-	register char *d = dst;
-	register const char *s = src;
-	register size_t n = siz;
-
-	/* Copy as many bytes as will fit */
-	if (n != 0 && --n != 0) {
-		do {
-			if ((*d++ = *s++) == 0)
-				break;
-		} while (--n != 0);
-	}
-
-	/* Not enough room in dst, add NUL and traverse rest of src */
-	if (n == 0) {
-		if (siz != 0)
-			*d = '\0';		/* NUL-terminate dst */
-		while (*s++)
-			;
-	}
-
-	return(s - src - 1);	/* count does not include NUL */
-}

apps/enclave/libsockthread/src/strl.h

@@ -1,49 +0,0 @@
-/*
- * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *     * Neither the name of the author nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
- * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * $Id$
- */
-
-/*
- * Note: The strl.c file retains its original license (at the top of strl.c)
- */
-
-#ifndef LIBSOCKTHREAD_STRL_H
-#define LIBSOCKTHREAD_STRL_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-extern size_t strlcat(char *dst, const char *src, size_t siz);
-extern size_t strlcpy(char *dst, const char *src, size_t siz);
-
-#ifdef __cplusplus
-}
-#endif
-#endif  /* LIBSOCKTHREAD_STRL_H */

apps/enclave/libsockthread/src/thread.cpp

@@ -1,194 +0,0 @@
-/*
- * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *     * Neither the name of the author nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
- * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * $Id$
- */
-
-/*
- * Modelled after JThread by Jori Liesenborgs
- */
-
-#include "platform.hpp"
-#include "mutex.hpp"
-#include "thread.hpp"
-using namespace Libsockthread;
-
-/*
- * Gets the return value of a finished thread
- */
-void* Thread::get_retval()
-{
-	void* val;
-	running_m.lock();
-	if (running)
-		val = NULL;
-	else
-		val = retval;
-	running_m.unlock();
-	return val;
-}
-
-/*
- * Checks whether the thread is running
- */
-bool Thread::is_running()
-{
-	running_m.lock();
-	bool r = running;
-	running_m.unlock();
-	return r;
-}
-
-/*
- * Stops the thread
- * Generally NOT a good idea
- */
-void Thread::kill()
-{
-	running_m.lock();
-#ifndef NDEBUG
-	// make sure it as actually running first
-	if (!running) {
-		running_m.unlock();
-		assert(false);
-	}
-#endif
-#ifdef WINTHREAD
-	BOOL rc = TerminateThread(handle, NULL);
-	assert(rc);
-#else
-	int rc = pthread_cancel(id);
-	assert(rc == 0);
-#endif
-	running = false;
-	running_m.unlock();
-}
-
-/*
- * Starts the thread
- */
-void Thread::start()
-{
-#ifndef NDEBUG
-	// check whether the thread is already running
-	running_m.lock();
-	assert(!running);
-	running_m.unlock();
-#endif
-	continue_m.lock();
-#ifdef WINTHREAD
-	handle = CreateThread(NULL, 0, &the_thread, this, 0, &id);
-	assert(handle != NULL);
-#else
-	int rc = pthread_create(&id, 0, &the_thread, this);
-	assert(rc == 0);
-#endif
-	// Wait until `running' is set
-	running_m.lock();
-	while (!running) {
-		running_m.unlock();
-		running_m.lock();
-	}
-	running_m.unlock();
-	continue_m.unlock();
-}
-
-/*
- * Wrapper for the thread
- */
-void* Thread::the_thread(void *param)
-{
-	Thread* t = static_cast<Thread*>(param);
-	t->running_m.lock();
-	t->running = true;
-	t->running_m.unlock();
-	// wait until we can continue
-	t->continue_m.lock();
-	t->continue_m.unlock();
-	void* ret = t->thread();
-	t->running_m.lock();
-	t->running = false;
-	t->retval = ret;
-	t->running_m.unlock();
-	return 0;
-}
-
-#ifdef UNIT_TEST
-// g++ -Wall -c mutex.cpp -o mutex.o
-// g++ -Wall -DUNIT_TEST -c thread.cpp -o thread.o
-// g++ -Wall -DUNIT_TEST mutex.o thread.o -o thread -pthread
-int main()
-{
-	class Thread_test : public Thread
-	{
-		public:
-			Thread_test(int testval)
-				: testval(testval) { }
-
-			int get_testval()
-			{
-				testval_m.lock();
-				int rc = testval;
-				testval_m.unlock();
-				return rc;
-			}
-			void *thread()
-			{
-				// just do something
-				while (true) {
-					testval_m.lock();
-					++testval;
-					testval_m.unlock();
-				}
-				return 0;
-			}
-
-		private:
-			int testval;
-			Mutex testval_m;
-	};
-
-	Thread_test t1(1);
-	t1.start();
-	Thread_test t2(1000000);
-	t2.start();
-	Thread_test t3(-1000000);
-	t3.start();
-	while (true) {
-		if (t1.is_running())
-			cout << "t1 is running..." << t1.get_testval() << '\n';
-		if (t2.is_running())
-			cout << "t2 is running..." << t2.get_testval() << '\n';
-		if (t3.is_running())
-			cout << "t3 is running..." << t3.get_testval() << '\n';
-	}
-
-	return 0;
-}
-#endif  // UNIT_TEST

apps/enclave/libsockthread/src/thread.hpp

@@ -1,69 +0,0 @@
-/*
- * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *     * Neither the name of the author nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
- * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * $Id$
- */
-
-/*
- * Modelled after JThread by Jori Liesenborgs
- */
-
-#ifndef LIBSOCKTHREAD_THREAD_HPP
-#define LIBSOCKTHREAD_THREAD_HPP
-
-namespace Libsockthread {
-	class Thread {
-		public:
-			Thread()
-				: retval(NULL), running(false) { }
-			virtual ~Thread()
-				{ kill(); }
-
-			void* get_retval();
-			bool is_running();
-			void kill();
-			void start();
-			virtual void* thread() = 0;
-		private:
-#ifdef WINTHREAD
-			static DWORD WINAPI the_thread(void* param);
-			HANDLE handle;
-			DWORD id;
-#else
-			static void* the_thread(void* param);
-			pthread_t id;
-#endif
-			Mutex continue_m;
-			void* retval;
-			bool running;
-			Mutex running_m;
-	};
-}
-
-#endif  // LIBSOCKTHREAD_THREAD_HPP

apps/enclave/libsockthread/src/time.cpp

@@ -1,85 +0,0 @@
-/*
- * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *     * Neither the name of the author nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
- * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * $Id$
- */
-
-#include "platform.hpp"
-#include "time.hpp"
-using namespace Libsockthread;
-
-/*
- * Converts the time to an ISO 8601 standard date and time
- * Example: 2004-07-01T19:03:47Z
- */
-string& Time::utc()
-{
-	struct tm* tm = gmtime(&unixtime);
-	char t[21];
-	strftime(t, sizeof t, "%Y-%m-%dT%H:%M:%SZ", tm);
-	return formatted = t;
-}
-
-/*
- * Converts the time to an ISO 8601 standard date
- * Example: 2004-07-01Z
- */
-string& Time::utc_date()
-{
-	struct tm* tm = gmtime(&unixtime);
-	char t[12];
-	strftime(t, sizeof t, "%Y-%m-%dZ", tm);
-	return formatted = t;
-}
-
-/*
- * Converts the time to an ISO 8601 standard time
- * Example: 19:03:47Z
- */
-string& Time::utc_time()
-{
-	struct tm* tm = gmtime(&unixtime);
-	char t[10];
-	strftime(t, sizeof t, "%H:%M:%SZ", tm);
-	return formatted = t;
-}
-
-#ifdef UNIT_TEST
-// g++ -Wall -DUNIT_TEST time.cpp -o time
-int main()
-{
-	Time t;
-	cout << "Current date and time is " << t.utc() << '\n';
-	cout << "Current date is " << t.utc_date() << '\n';
-	cout << "Current time is " << t.utc_time() << '\n';
-	cout << "Formatted time is " << t.get_formatted() << " (should be the same)\n";
-
-	return 0;
-}
-#endif  // UNIT_TEST

apps/enclave/libsockthread/src/time.hpp

@@ -1,55 +0,0 @@
-/*
- * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *     * Neither the name of the author nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
- * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * $Id$
- */
-
-#ifndef LIBSOCKTHREAD_TIME_HPP
-#define LIBSOCKTHREAD_TIME_HPP
-
-namespace Libsockthread {
-	class Time {
-		public:
-			Time()
-				{ now(); }
-
-			string& get_formatted()
-				{ return formatted; }
-			void now()
-				{ unixtime = time(0); }
-			string& utc();
-			string& utc_date();
-			string& utc_time();
-		private:
-			string formatted;
-			time_t unixtime;
-	};
-}
-
-#endif  // LIBSOCKTHREAD_TIME_HPP

apps/enclave/libsockthread/src/types.hpp

@@ -1,45 +0,0 @@
-/*
- * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *     * Neither the name of the author nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
- * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * $Id$
- */
-
-#ifndef LIBSOCKTHREAD_TYPES_HPP
-#define LIBSOCKTHREAD_TYPES_HPP
-
-/*
- * Shorten some standard variable types
- */
-typedef signed char schar_t;
-typedef unsigned char uchar_t;
-typedef unsigned int uint_t;
-typedef unsigned long ulong_t;
-typedef unsigned short ushort_t;
-
-#endif  // LIBSOCKTHREAD_TYPES_HPP

apps/enclave/src/bigint.cpp

@@ -1,169 +0,0 @@
-/*
- * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *     * Neither the name of the author nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
- * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include "platform.hpp"
-#include "bigint.hpp"
-
-/******************************************************************************/
-// Note: All the const_casts below are necessary because libtomcrypt doesn't  //
-// have its arguments as const, even when they are not changed                //
-/******************************************************************************/
-
-Bigint::Bigint(const Bigint& bigint)
-{
-	init();
-	copyover_mp_int(bigint.mpi);
-}
-
-Bigint::Bigint(const uchar_t* data, size_t size)
-{
-	init();
-	import_uraw(data, size);
-}
-
-Bigint::Bigint(uint16_t i)
-{
-	init();
-	i = htons(i);
-	import_uraw(reinterpret_cast<uchar_t*>(&i), 2);
-}
-
-Bigint::Bigint(uint32_t i)
-{
-	init();
-	i = htonl(i);
-	import_uraw(reinterpret_cast<uchar_t*>(&i), 4);
-}
-
-/*
- * Replaces our current mp_int with another one
- * (just a wrapper for mp_copy)
- */
-void Bigint::copyover_mp_int(const mp_int& i)
-{
-	int rc = mp_copy(const_cast<mp_int*>(&i), &mpi);
-	assert(rc == MP_OKAY);
-}
-
-/*
- * Saves a Bigint to a raw unsigned big-endian integer
- * Note that the result must be freed with delete[]
- *
- * size - filled with the size of the output
- *
- * Returns: binary data
- */
-uchar_t* Bigint::export_uraw(size_t& size) const
-{
-	uchar_t* out;
-	size = mp_unsigned_bin_size(const_cast<mp_int*>(&mpi));
-	if (size != 0) {
-		out = new uchar_t[size];
-		int rc = mp_to_unsigned_bin(const_cast<mp_int*>(&mpi), out);
-		assert(rc == MP_OKAY);
-	} else {  // size == 0
-		size = 1;
-		out = new uchar_t[1];
-		out[0] = 0;
-	}
-	return out;
-}
-
-/*
- * Loads a raw unsigned big-endian integer into Bigint
- *
- * data - binary data
- * size - size of data
- */
-void Bigint::import_uraw(const uchar_t* data, size_t size)
-{
-	uchar_t tmp[size];				// mp_read_unsigned_bin() arg 2 is not const
-	memcpy(tmp, data, sizeof tmp);	// I'm not taking any chances
-	int rc = mp_read_unsigned_bin(&mpi, tmp, sizeof tmp);
-	assert(rc == MP_OKAY);
-}
-
-/*
- * Initialises the object
- */
-void Bigint::init(void)
-{
-	int rc = mp_init(&mpi);
-	assert(rc == MP_OKAY);
-}
-
-bool Bigint::operator<(const Bigint& rhs) const
-{
-	int rc = mp_cmp(const_cast<mp_int*>(&mpi), const_cast<mp_int*>(&rhs.mpi));
-	if (rc == MP_LT)
-		return true;
-	else
-		return false;
-}
-
-Bigint& Bigint::operator=(const Bigint& rhs)
-{
-	if (this != &rhs)  // check for self-assignment: a = a
-		copyover_mp_int(rhs.mpi);
-	return *this;
-}
-
-bool Bigint::operator==(const Bigint& rhs) const
-{
-	int rc = mp_cmp(const_cast<mp_int*>(&mpi), const_cast<mp_int*>(&rhs.mpi));
-	if (rc == MP_EQ)
-		return true;
-	else
-		return false;
-}
-
-bool Bigint::operator>(const Bigint& rhs) const
-{
-	int rc = mp_cmp(const_cast<mp_int*>(&mpi), const_cast<mp_int*>(&rhs.mpi));
-	if (rc == MP_GT)
-		return true;
-	else
-		return false;
-}
-
-/*
- * Xors another Bigint with this Bigint and puts the result in Bigint `result'.
- * We can't name it "xor" because that word is reserved in C++ (see Appendex C,
- * section 3.1 in TC++PL).
- *
- * rhs - the bigint to xor with
- * result - will be filled with the result of the xor
- */
-void Bigint::x_or(const Bigint& rhs, Bigint& result) const
-{
-	int rc = mp_xor(const_cast<mp_int*>(&mpi), const_cast<mp_int*>(&rhs.mpi),
-		&result.mpi);
-	assert(rc == MP_OKAY);
-}

apps/enclave/src/bigint.hpp

@@ -1,60 +0,0 @@
-/*
- * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *     * Neither the name of the author nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
- * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef BIGINT_HPP
-#define BIGINT_HPP
-
-class Bigint {
-	public:
-		Bigint(void) { init(); }
-		Bigint(const Bigint& bigint);
-		Bigint(const uchar_t* data, size_t size);
-		Bigint(uint16_t i);
-		Bigint(uint32_t i);
-		~Bigint(void) { mp_clear(&mpi); }
-
-		uchar_t* export_uraw(size_t& size) const;
-		const mp_int& get_mp_int(void) const { return mpi; }
-		void import_uraw(const uchar_t* data, size_t size);
-		bool operator<(const Bigint& rhs) const;
-		Bigint& operator=(const Bigint& rhs);
-		bool operator==(const Bigint& rhs) const;
-		bool operator>(const Bigint& rhs) const;
-		void x_or(const Bigint& rhs, Bigint& result) const;
-
-	protected:
-		mp_int mpi;
-
-	private:
-		void copyover_mp_int(const mp_int& i);
-		void init(void);
-};
-
-#endif  // BIGINT_HPP

apps/enclave/src/chk.cpp

@@ -1,56 +0,0 @@
-/*
- * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *     * Neither the name of the author nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
- * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include "platform.hpp"
-#include "chk.hpp"
-
-Chk::Chk(const uchar_t* plaintext, size_t size, const string& mime_type)
-	: data_size(size), mime_type(mime_type)
-{
-	encrypt(plaintext);
-}
-
-void Chk::encrypt(const uchar_t *pt)
-{
-	int rc = register_cipher(&twofish_desc);
-	assert(rc != -1);
-
-	uchar_t key[CRYPT_KEY_SIZE], iv[CRYPT_BLOCK_SIZE];
-	prng->get_bytes(key, CRYPT_KEY_SIZE);
-	prng->get_bytes(iv, CRYPT_BLOCK_SIZE);	
-
-	symmetric_CTR ctr;
-	rc = ctr_start(find_cipher("twofish"), iv, key, CRYPT_KEY_SIZE, 0, &ctr);
-	assert(rc == CRYPT_OK);
-
-	ct = new uchar_t[data_size];
-	rc = ctr_encrypt(pt, ct, data_size, &ctr);
-	assert(rc == CRYPT_OK);
-}

apps/enclave/src/chk.hpp

@@ -1,51 +0,0 @@
-/*
- * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *     * Neither the name of the author nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
- * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef CHK_HPP
-#define CHK_HPP
-
-class Chk {
-	public:
-		//Chk(const uchar_t* cypertext, size_t size);
-		Chk(const uchar_t* plaintext, size_t size, const string& mime_type);
-		~Chk(void) { delete[] ct; }
-
-	private:
-		static const size_t CRYPT_BLOCK_SIZE = 16;
-		static const size_t CRYPT_KEY_SIZE = 32;
-
-		void encrypt(const uchar_t *pt);
-
-		uchar_t* ct;  // cyphertext
-		const size_t data_size;
-		const string& mime_type;  // I hate mimes.
-};
-
-#endif  // CHK_HPP

apps/enclave/src/config.cpp

@@ -1,148 +0,0 @@
-/*
- * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *     * Neither the name of the author nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
- * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include "platform.hpp"
-#include "bigint.hpp"
-
-Config::Config(const string& file)
-	: file(file)
-{
-	set_defaults();
-	parse();
-	configf.close();
-}
-
-/*
- * Looks up a configuration option in the table and returns a constant value.
- * This is the same as get_property() except the value returned is a constant.
- *
- * key - key to lookup
- *
- * Returns the value associated with the key
- */
-const string& Config::get_cproperty(const string& key) const
-{
-	for (cfgmap_ci i = cfgmap.begin(); i != cfgmap.end(); i++) {
-		const string s = i->first;
-		if (s == key)
-			return i->second;
-	}
-	LERROR << "Tried to lookup an invalid property: " << key << '\n';
-	assert(false);
-	// this should never occur, it's just to silence a compiler warning
-	string* s = new string;
-	return *s;
-}
-
-/*
- * Gets a property as an integer (they are all stored as strings)
- *
- * key - key to lookup
- *
- * Returns an integer of the value associated with the key
- */
-int Config::get_iproperty(const string& key) const
-{
-	for (cfgmap_ci i = cfgmap.begin(); i != cfgmap.end(); i++) {
-		const string s = i->first;
-		if (s == key)
-			return atoi(i->second.c_str());
-	}
-	LERROR << "Tried to lookup an invalid property: " << key << '\n';
-	assert(false);
-	return 0;
-}
-
-/*
- * Looks up a configuration option in the table and returns the value
- *
- * key - key to lookup
- *
- * Returns the value associated with the key
- */
-string& Config::get_property(const string& key)
-{
-	for (cfgmap_i i = cfgmap.begin(); i != cfgmap.end(); i++) {
-		const string s = i->first;
-		if (s == key)
-			return i->second;
-	}
-	LERROR << "Tried to lookup an invalid property: " << key << '\n';
-	assert(false);
-	// this should never occur, it's just to silence a compiler warning
-	string* s = new string;
-	return *s;
-}
-
-/*
- * Parses the configuration file, replacing default values with user defined
- * values
- */
-void Config::parse(void)
-{
-	configf.open(file.c_str());
-	if (!configf) {
-		cerr << "Error opening configuration file (" << file.c_str() << ")\n";
-		throw runtime_error("Error opening configuration file");
-	}
-	size_t line = 0;
-	string s;
-	for (getline(configf, s); configf; getline(configf, s)) {
-		line++;
-		if (s.size() == 0 || s[0] == '#')  // blank line or comment
-			continue;
-		size_t eqpos = s.find("=");
-		if (eqpos == string::npos) {
-			cerr << "Error parsing line #" << line << " in " << file << ": "
-				<< s << '\n';
-			continue;
-		}
-		string key = s.substr(0, eqpos);
-		string value = s.substr(eqpos + 1);
-		//cout << "Inserting key = " << key << " value = " << value << '\n';
-		cfgmap.erase(key);  // erase the default value created by set_defaults()
-		cfgmap.insert(make_pair(key, value));
-	}
-}
-
-/*
- * If you (the programmer) add something to the config file you should also add
- * it here, and vice versa
- */
-void Config::set_defaults(void)
-{
-	cfgmap.insert(make_pair("samhost", "localhost"));
-	cfgmap.insert(make_pair("samport", "7656"));
-	cfgmap.insert(make_pair("samname", "enclave"));
-	cfgmap.insert(make_pair("tunneldepth", "2"));
-	cfgmap.insert(make_pair("references", "cfg/peers.ref"));
-	cfgmap.insert(make_pair("loglevel", "1"));
-	cfgmap.insert(make_pair("logfile", "log/enclave.log"));
-}

apps/enclave/src/config.hpp

@@ -1,54 +0,0 @@
-/*
- * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *     * Neither the name of the author nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
- * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef CONFIG_HPP
-#define CONFIG_HPP
-
-class Config {
-	public:
-		Config(const string& file);
-
-		const string& get_cproperty(const string& key) const;
-		int get_iproperty(const string& key) const;
-		string& get_property(const string& key);
-
-	private:
-		typedef map<const string, string>::const_iterator cfgmap_ci;
-		typedef map<const string, string>::iterator cfgmap_i;
-
-		void parse(void);
-		void set_defaults(void);
-
-		ifstream configf;
-		const string file;
-		map<const string, string> cfgmap;
-};
-
-#endif  // CONFIG_HPP

apps/enclave/src/logger.cpp

@@ -1,61 +0,0 @@
-/*
- * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *     * Neither the name of the author nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
- * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include "platform.hpp"
-#include "logger.hpp"
-
-Logger::Logger(const string& file)
-	: file(file)
-{
-	set_pri(debug);
-	set_loglevel(static_cast<priority_t>(config->get_iproperty("loglevel")));
-	logf.open(file.c_str(), ios::app);
-	if (!logf) {
-		cerr << "Error opening log file (" << file.c_str() << ")\n";
-		throw runtime_error("Error opening log file");
-	}
-}
-
-#ifdef WIN_STRERROR
-/*
- * strerror() for primitive operating systems
- */
-TCHAR* win_strerror(TCHAR* str, size_t size)
-{ 
-	LPVOID lpMsgBuf;
-	DWORD dw = GetLastError();
-	FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
-		NULL, dw, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpMsgBuf,
-		0, NULL);
-	snprintf(str, size, "%s", lpMsgBuf);
-	LocalFree(lpMsgBuf);
-	return str;
-}
-#endif

apps/enclave/src/logger.hpp

@@ -1,88 +0,0 @@
-/*
- * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *     * Neither the name of the author nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
- * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef LOGGER_HPP
-#define LOGGER_HPP
-
-/*
- * LDEBUG - debugging messages
- * LMINOR - unimportant messages
- * LINFO - informational messages
- * LWARN - errors we automatically recover from
- * LERROR - major, important errors
- */
-#if VERBOSE_LOGS
-	#define LDEBUG logger->set_pri(Logger::debug); (*logger) << "(D)" << __FILE__ << ':' << __LINE__ << ':' << __func__ << ": "
-	#define LMINOR logger->set_pri(Logger::minor); (*logger) << "(M)" << __FILE__ << ':' << __LINE__ << ':' << __func__ << ": "
-	#define LINFO  logger->set_pri(Logger::info);  (*logger) << "(I)" << __FILE__ << ':' << __LINE__ << ':' << __func__ << ": "
-	#define LWARN  logger->set_pri(Logger::warn);  (*logger) << "(W)" << __FILE__ << ':' << __LINE__ << ':' << __func__ << ": "
-	#define LERROR logger->set_pri(Logger::error); (*logger) << "(E)" << __FILE__ << ':' << __LINE__ << ':' << __func__ << ": "
-#else
-	#define LDEBUG logger->set_pri(Logger::debug); (*logger) << "(D)"
-	#define LMINOR logger->set_pri(Logger::minor); (*logger) << "(M)"
-	#define LINFO  logger->set_pri(Logger::info);  (*logger) << "(I)"
-	#define LWARN  logger->set_pri(Logger::warn);  (*logger) << "(W)"
-	#define LERROR logger->set_pri(Logger::error); (*logger) << "(E)"
-#endif
-
-class Logger {
-	public:
-		typedef enum {debug = 0, minor = 1, info = 2, warn = 3, error = 4}
-			priority_t;
-
-		Logger(const string& file);
-
-		void flush(void) { logf.flush(); }
-		priority_t get_loglevel(void) const { return loglevel; }
-		void set_loglevel(priority_t priority) { loglevel = priority; }
-		Logger& operator<<(char c)
-			{ if (priority >= loglevel) { logf << c; flush(); } return *this; }
-		Logger& operator<<(const char* c)
-			{ if (priority >= loglevel) { logf << c; flush(); } return *this; }
-		Logger& operator<<(int i)
-			{ if (priority >= loglevel) { logf << i; flush(); } return *this; }
-		Logger& operator<<(const string& s)
-			{ if (priority >= loglevel) { logf << s; flush(); } return *this; }
-		Logger& operator<<(unsigned int i)
-			{ if (priority >= loglevel) { logf << i; flush(); } return *this; }
-		void set_pri(priority_t priority) { this->priority = priority; }
-
-	private:
-		priority_t priority;  // importance of the following log message(s)
-		string file;
-		priority_t loglevel;  // write log messsages at or above this priority
-		ofstream logf;
-};
-
-#ifdef WIN_STRERROR
-TCHAR* win_strerror(TCHAR* str, size_t size);
-#endif
-
-#endif  // LOGGER_HPP

apps/enclave/src/main.cpp

@@ -1,84 +0,0 @@
-/*
- * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *     * Neither the name of the author nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
- * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include "platform.hpp"
-#include "main.hpp"
-
-Config *config;  // Configuration options
-Logger *logger;  // Logging mechanism
-Random *prng;  // Random number generator
-Sam *sam;  // SAM connection
-
-int main(int argc, char* argv[])
-{
-	if (argc != 2) {  // put some getopts stuff in here later
-		cerr << "Please specify the configuration file location.\n" \
-			"e.g. 'bin/enclave cfg/enclave.cfg'\n";
-		return 1;
-	}
-
-	try {
-		config = new Config(argv[1]);
-	} catch (const runtime_error& x) {
-		return 0;
-	}
-	logger = new Logger(config->get_cproperty("logfile"));
-	LINFO << "Enclave DHT - Built on " << __DATE__ << ' ' << __TIME__ << '\n';
-	prng = new Random;
-	try {
-		sam = new Sam(config->get_cproperty("samhost"),
-			config->get_iproperty("samport"), config->get_cproperty("samname"),
-			config->get_iproperty("tunneldepth"));
-	} catch (const Sam_error& x) {
-		LERROR << "SAM error: " << x.what() << '\n';
-		cerr << "SAM error: " << x.what() << '\n';
-		if (x.code() == SAM_SOCKET_ERROR) {
-			LERROR << "Check whether you have specified the correct SAM host " \
-				"and port number, and that I2P is running.\n";
-			cerr << "Check whether you have specified the correct SAM host " \
-				"and port number, and that\nI2P is running.\n";
-		}
-		return 1;
-	}
-	sam->naming_lookup();
-	while (sam->get_my_dest() == "")
-		sam->read_buffer();  // wait until we get our own dest back from lookup
-
-	sam->peers->advertise_self();
-
-	while (true)
-		sam->read_buffer();
-
-	delete sam;
-	delete prng;
-	delete logger;
-	delete config;
-	return 0;
-}

apps/enclave/src/main.hpp

@@ -1,36 +0,0 @@
-/*
- * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *     * Neither the name of the author nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
- * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef MAIN_HPP
-#define MAIN_HPP
-
-// intentionally left blank
-
-#endif  // MAIN_HPP

apps/enclave/src/near_peer.hpp

@@ -1,54 +0,0 @@
-/*
- * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *     * Neither the name of the author nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
- * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef NEAR_PEER_HPP
-#define NEAR_PEER_HPP
-
-//
-// Used for finding the closest peers to a sha1
-//
-
-class Near_peer {
-	public:
-		Near_peer(const Bigint& distance, Peer* peer)
-			: distance(distance), peer(peer) {}
-
-		Peer* get_peer(void) const { return peer; }
-		bool operator<(const Near_peer& rhs) const
-			{ if (distance < rhs.distance) return true; else return false; }
-
-	protected:
-		const Bigint distance;
-
-	private:
-		Peer* peer;
-};
-
-#endif  // NEAR_PEER_HPP

apps/enclave/src/peer.hpp

@@ -1,52 +0,0 @@
-/*
- * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *     * Neither the name of the author nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
- * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef PEER_HPP
-#define PEER_HPP
-
-class Peer {
-	public:
-		Peer(const string& dest, const Sha1& kaddr)
-			: dest(dest), kaddr(kaddr), lag(-1) {}
-
-		const string& get_b64kaddr(void) const { return kaddr.b64hash(); }
-		const uchar_t* get_binkaddr(void) const { return kaddr.binhash(); }
-		const string& get_dest(void) const { return dest; }
-		int get_lag(void) const { return lag; }
-		const string get_sdest(void) const { return dest.substr(0, 8); }
-		void set_lag(int lag) { this->lag = lag; }
-
-	private:
-		const string dest;
-		const Sha1 kaddr;
-		int lag;  // if -1, then it is unknown
-};
-
-#endif  // PEER_HPP

apps/enclave/src/peers.cpp

@@ -1,220 +0,0 @@
-/*
- * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *     * Neither the name of the author nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
- * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include "platform.hpp"
-#include "near_peer.hpp"
-#include "rpc.hpp"
-#include "sha1.hpp"
-#include "peers.hpp"
-
-/*
- * Inform other peers of our existence and collect the destination addresses of
- * nearby peers
- */
-void Peers::advertise_self(void)
-{
-	list<Near_peer> near_peers;
-	get_nearest(sam->get_my_sha1(), PAR_RPCS, near_peers);
-	for (list<Near_peer>::const_iterator i = near_peers.begin();
-			i != near_peers.end(); i++) {
-		Rpc rpc(i->get_peer());
-		rpc.find_peers(sam->get_my_sha1());
-	}
-}
-
-/*
- * Find the `n' nearest peers by xoring a sha1 with a kaddr
- *
- * sha1 - sha1 to find nearness to
- * n - number of peers to find
- * near_peers - a list to put the found peers in
- */
-void Peers::get_nearest(const Sha1& sha1, size_t n,	list<Near_peer>& near_peers)
-{
-	near_peers.clear();  // prevents duplicate peers in the list
-	for (peersmap_i i = peersmap.begin(); i != peersmap.end(); i++) {
-		const Sha1& kaddr = i->first;
-		Bigint distance;
-		sha1.x_or(kaddr, distance);
-		Near_peer np(distance, &(i->second));
-		near_peers.insert(near_peers.end(), np);
-	}
-	near_peers.sort();
-	while (near_peers.size() > n)
-		near_peers.pop_back();
-}
-
-Peer* Peers::get_peer_by_dest(const sam_pubkey_t dest)
-{
-	const string s = dest;
-	return get_peer_by_dest(s);
-}
-
-/*
- * Gets a peer by its base 64 destination address
- *
- * dest - destination
- *
- * Returns: pointer to peer, or 0 if the peer wasn't found
- */
-Peer* Peers::get_peer_by_dest(const string& dest)
-{
-	for (peersmap_i i = peersmap.begin(); i != peersmap.end(); i++) {
-		Peer& tmp = i->second;
-		if (tmp.get_dest() == dest)
-			return &(i->second);
-	}
-	return 0;
-}
-
-/*
- * Gets a peer by its Kademlia address
- *
- * kaddr - Kademlia adddress
- *
- * Returns: pointer to peer, or 0 if the peer wasn't found
- */
-Peer* Peers::get_peer_by_kaddr(const Sha1& kaddr)
-{
-	peersmap_i i = peersmap.find(kaddr);
-	if (i != peersmap.end())
-		return &(i->second);
-	else
-		return 0;
-}
-
-/*
- * Loads peer addresses from a file
- */
-void Peers::load(void)
-{
-	string dest;
-
-	ifstream peersf(file.c_str());
-	if (!peersf) {
-		LERROR << "Couldn't load peers reference file (" << file.c_str()
-			<< ")\n";
-		if (peersmap.size() > 0)
-			return;
-		else
-			throw runtime_error("No peer references in memory");
-	}
-
-	for (getline(peersf, dest); peersf; getline(peersf, dest))
-		new_peer(dest);
-
-	if (peersmap.size() > 0) {
-		LMINOR << peersmap.size() << " peer references in memory\n";
-	} else
-		throw runtime_error("No peer references in memory");
-}
-
-Peer* Peers::new_peer(const sam_pubkey_t dest)
-{
-	const string s = dest;
-	return new_peer(s);
-}
-
-/*
- * Adds a newly discovered peer to the peers map
- *
- * dest - destination address of the peer
- *
- * Returns: pointer to the peer
- */
-Peer* Peers::new_peer(const string& dest)
-{
-	// Check the destination address
-	if (!sam->valid_dest(dest)) {
-		LWARN << "Bad format in peer reference: " << dest.substr(0, 8) << '\n';
-		return 0;
-	}
-	// Never add our own peer to the peers we can connect to
-	if (dest == sam->get_my_dest()) {
-		LDEBUG << "Not adding my own peer reference: " << dest.substr(0, 8)
-			<< '\n';
-		return 0;
-	}
-	// Be sure that the peer is not already known to us
-	Peer *peer = get_peer_by_dest(dest);
-	if (peer != 0) {
-		LDEBUG << "Redundant peer reference: " << dest.substr(0, 8) << '\n';
-		return peer;
-	}
-
-	// Tests passed, add it
-	Sha1 sha1(dest);
-	pair<peersmap_i, bool> p = peersmap.insert(
-		make_pair(sha1, Peer(dest, sha1)));
-	assert(p.second);
-	LMINOR << "New peer reference: " << dest.substr(0, 8)
-		<< " (Kaddr: " << sha1.b64hash() << ")\n";
-	peer = &(p.first->second);
-	return peer;
-}
-
-/*
- * Saves peer destinations to a file
- *
- * file - the file to save to
- */
-void Peers::save(void)
-{
-	ofstream peersf(file.c_str());
-	if (!peersf) {
-		LERROR << "Error opening peers reference file (" << file.c_str()
-			<< ")\n";
-		return;
-	}
-
-	LDEBUG << "Saving " << peersmap.size() + 1 << " peer references\n";
-	peersf << sam->get_my_dest() << '\n';
-	for (peersmap_ci i = peersmap.begin(); i != peersmap.end(); i++) {
-		const Peer& tmp = i->second;
-		peersf << tmp.get_dest() << '\n';
-	}
-}
-
-/*
- * Stores data on some peers
- *
- * sha1 - the sha1 value for the data
- * data - the data
- */
-void Peers::store(const Sha1& sha1)
-{
-	list<Near_peer> near_peers;
-	get_nearest(sam->get_my_sha1(), PAR_RPCS, near_peers);
-	for (list<Near_peer>::const_iterator i = near_peers.begin();
-			i != near_peers.end(); i++) {
-		Rpc rpc(i->get_peer());
-		rpc.store(sha1);
-	}
-}

apps/enclave/src/peers.hpp

@@ -1,65 +0,0 @@
-/*
- * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *     * Neither the name of the author nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
- * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef PEERS_HPP
-#define PEERS_HPP
-
-class Peers {
-	public:
-		static const int PAR_RPCS = 3;  // The number of parallel RPCs to send
-		static const int RET_REFS = 20;  // The number of peer refs to return on
-										 // failed requests
-		Peers(const string& file)
-			: file(file)
-			{ load(); }
-		~Peers(void) { save(); }
-
-		void advertise_self(void);
-		void get_nearest(const Sha1& sha1, size_t n,
-			list<Near_peer>& near_peers);
-		Peer* get_peer_by_dest(const sam_pubkey_t dest);
-		Peer* get_peer_by_dest(const string& dest);
-		Peer* get_peer_by_kaddr(const Sha1& kaddr);
-		Peer* new_peer(const sam_pubkey_t dest);
-		Peer* new_peer(const string& dest);
-		void store(const Sha1& sha1);
-
-	private:
-		typedef map<const Sha1, Peer>::const_iterator peersmap_ci;
-		typedef map<const Sha1, Peer>::iterator peersmap_i;
-
-		void load(void);
-		void save(void);
-
-		const string file;
-		map<const Sha1, Peer> peersmap;
-};
-
-#endif  // PEERS_HPP

apps/enclave/src/platform.hpp

@@ -1,111 +0,0 @@
-/*
- * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *     * Neither the name of the author nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
- * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef PLATFORM_HPP
-#define PLATFORM_HPP
-
-/*
- * Operating system
- */
-#define FREEBSD 0  // FreeBSD (untested)
-#define MINGW   1  // Windows native (Mingw)
-#define LINUX   2  // Linux
-#define CYGWIN  3  // Cygwin
-
-#if OS == MINGW
-	#define NO_SSIZE_T
-	#define WIN_STRERROR
-	#define WINSOCK
-	#define WINTHREADS
-#endif
-
-/*
- * System includes
- */
-#include <arpa/inet.h>
-#include <cstdlib>
-#include <cstring>
-#include <fstream>
-#include <iostream>
-#include <list>
-#include <map>
-#ifdef WINTHREADS
-	#include <windows.h>
-#else
-	#include <pthread.h>
-#endif
-#include <stdexcept>
-#include <stdint.h>
-#include <string>
-#include <time.h>
-
-using namespace std;
-
-#ifdef NO_SSIZE_T
-	typedef signed long ssize_t;
-#endif
-
-/*
- * Define this to '1' to cause the printing of source code file and line number
- * information with each log message.  Set it to '0' for simple logging.
- */
-#define VERBOSE_LOGS 0
-
-/*
- * Library includes
- */
-#include "mycrypt.h"  // LibTomCrypt
-#include "sam.h"  // LibSAM
-
-/*
- * Local includes
- */
-#include "mutex.hpp"  // Mutex (for thread.hpp)
-#include "thread.hpp"  // Thread
-#include "logger.hpp"  // Logger
-#include "config.hpp"  // Config
-#include "sam_error.hpp"  // for sam.hpp
-#include "bigint.hpp"  // for sha1.hpp
-#include "sha1.hpp"  // for peers.hpp
-#include "peer.hpp"  // for peers.hpp
-#include "near_peer.hpp"  // for peers.hpp
-#include "peers.hpp" // for sam.hpp
-#include "sam.hpp"  // SAM
-#include "random.hpp"  // Random
-
-/*
- * Global variables
- */
-extern Config *config;  // Configuration options
-extern Logger *logger;  // Logging mechanism
-extern Random *prng;  // Random number generator
-extern Sam *sam;  // Sam connection
-
-#endif  // PLATFORM_HPP

apps/enclave/src/random.cpp

@@ -1,65 +0,0 @@
-/*
- * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *     * Neither the name of the author nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
- * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include "platform.hpp"
-#include "random.hpp"
-
-/*
- * Prepares the Yarrow PRNG for use
- */
-Random::Random(void)
-{
-	LMINOR << "Initalising PRNG\n";
-
-	int rc = yarrow_start(&prng);
-	assert(rc == CRYPT_OK);
-
-	uchar_t entropy[ENTROPY_SIZE];
-	size_t sz = rng_get_bytes(entropy, ENTROPY_SIZE, NULL);
-	assert(sz == ENTROPY_SIZE);
-
-	rc = yarrow_add_entropy(entropy, ENTROPY_SIZE, &prng);
-	assert(rc == CRYPT_OK);
-
-	rc = yarrow_ready(&prng);
-	assert(rc == CRYPT_OK);
-}
-
-/*
- * Gets `size' random bytes from the PRNG
- *
- * random - space to fill with random bytes
- * size - size of `random'
- */
-void Random::get_bytes(uchar_t* random, size_t size)
-{
-	size_t sz = yarrow_read(random, size, &prng);
-	assert(sz == size);
-}

apps/enclave/src/random.hpp

@@ -1,45 +0,0 @@
-/*
- * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *     * Neither the name of the author nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
- * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef RANDOM_HPP
-#define RANDOM_HPP
-
-class Random {
-	public:
-		Random(void);
-
-		void get_bytes(uchar_t* random, size_t size);
-
-	private:
-		static const size_t ENTROPY_SIZE = 32;
-		prng_state prng;
-};
-
-#endif  // RNG_HPP

apps/enclave/src/rpc.cpp

@@ -1,233 +0,0 @@
-/*
- * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *     * Neither the name of the author nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
- * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include "platform.hpp"
-#include "rpc.hpp"
-
-// These can't be 'const' because I have to make them big-endian first
-uint16_t Rpc::VERSION = htons(1);
-uint16_t Rpc::OLDEST_GOOD_VERSION = htons(1);
-
-/*
- * Requests a peer to find the addresses of the closest peers to the specified
- * sha1 and return them
- *
- * sha1 - closeness to this sha1
- */
-void Rpc::find_peers(const Sha1& sha1)
-{
-	LDEBUG << "To: " << peer->get_sdest() << " [" << peer->get_b64kaddr()
-		<< "] Msg: FIND_PEERS\n";
-
-	// VERSION + command + bin sha1
-	const size_t len = sizeof VERSION + 1 + Sha1::SHA1BIN_LEN;
-	uchar_t buf[len];
-	uchar_t* p = static_cast<uchar_t*>(memcpy(buf, &VERSION, sizeof VERSION));
-	p += sizeof VERSION;
-	*p = FIND_PEERS;
-	p++;
-	memcpy(p, sha1.binhash(), Sha1::SHA1BIN_LEN);
-	sam->send_dgram(peer->get_dest(), buf, len);
-}
-
-/*
- * Returns the closest peer references to a Sha1
- *
- * sha1 - sha1 to test nearness to
- */
-void Rpc::found_peers(const Sha1& sha1)
-{
-	list<Near_peer> near_peers;
-	sam->peers->get_nearest(sha1, Peers::RET_REFS, near_peers);
-	LDEBUG << "To: " << peer->get_sdest() << " [" << peer->get_b64kaddr()
-		<< "] Msg: FOUND_PEERS (" << near_peers.size() << " peers)\n";
-
-	// VERSION + command + number of sha1s (0-255) + bin sha1s
-	const size_t len = sizeof VERSION + 1 + 1 +
-		(near_peers.size() * (SAM_PUBKEY_LEN - 1));
-	assert(near_peers.size() <= 255);
-	uchar_t buf[len];
-	uchar_t* p = static_cast<uchar_t*>(memcpy(buf, &VERSION, sizeof VERSION));
-	p += sizeof VERSION;
-	*p = FOUND_PEERS;
-	p++;
-	*p = near_peers.size();
-	p++;
-	for (list<Near_peer>::const_iterator i = near_peers.begin();
-			i != near_peers.end(); i++) {
-		const Peer* peer = i->get_peer();
-		memcpy(p, peer->get_dest().c_str(), (SAM_PUBKEY_LEN - 1));
-		p += SAM_PUBKEY_LEN - 1;
-	}
-	sam->send_dgram(peer->get_dest(), buf, len);
-}
-
-/*
- * Parse incoming data and invoke the appropriate RPC
- *
- * data - the data
- * size - the size of `data'
- */
-void Rpc::parse(const void* data, size_t size)
-{
-	uint16_t his_ver;
-
-	memcpy(&his_ver, data, sizeof VERSION);
-	if (ntohs(his_ver) < ntohs(VERSION)) {
-		LMINOR << "Ignored RPC from " << peer->get_sdest() << " ["
-			<< peer->get_b64kaddr() << "] using obsolete protocol version "
-			<< ntohs(his_ver) << '\n';
-		return;
-	} else if (size <= 4) {
-		LWARN << "RPC too small from " << peer->get_sdest() << " ["
-			<< peer->get_b64kaddr() << "]\n";
-		return;
-	}
-	const uchar_t* p = static_cast<const uchar_t*>(data);
-
-	if (p[2] == PING) {  //-----------------------------------------------------
-		LDEBUG << "From: " << peer->get_sdest() << " [" << peer->get_b64kaddr()
-			<< "] Msg: PING\n";
-		uint32_t ptime;
-		if (size != sizeof VERSION + 1 + sizeof ptime) {
-			LWARN << "Malformed PING RPC from " << peer->get_sdest()
-				<< " [" << peer->get_b64kaddr() << "]\n";
-			return;
-		}
-		p += sizeof VERSION + 1;
-		memcpy(&ptime, p, sizeof ptime);
-		pong(ptime); // no need to ntohl() it here because we're just copying it
-		return;
-
-	} else if (p[2] == PONG) {  //----------------------------------------------
-		LDEBUG << "From: " << peer->get_sdest() << " [" << peer->get_b64kaddr()
-			<< "] Msg: PONG\n";
-		uint32_t ptime;
-		if (size != sizeof VERSION + 1 + sizeof ptime) {
-			LWARN << "Malformed PONG RPC from " << peer->get_sdest()
-				<< " [" << peer->get_b64kaddr() << "]\n";
-			return;
-		}
-		p += sizeof VERSION + 1;
-		memcpy(&ptime, p, sizeof ptime);
-		ptime = ntohl(ptime);
-		uint32_t now = time(NULL);
-		peer->set_lag(now - ptime);
-		LDEBUG << "Lag is " << peer->get_lag() << " seconds\n";
-		return;
-
-	} else if (p[2] == FIND_PEERS) {  //----------------------------------------
-		if (size != sizeof VERSION + 1 + Sha1::SHA1BIN_LEN) {
-			LWARN << "Malformed FIND_PEERS RPC from " << peer->get_sdest()
-				<< " [" << peer->get_b64kaddr() << "]\n";
-			return;
-		}
-		LDEBUG << "From: " << peer->get_sdest() << " [" << peer->get_b64kaddr()
-			<< "] Msg: FIND_PEERS\n";
-		found_peers(Sha1(p + 4));
-		return;
-
-	} else if (p[2] == FOUND_PEERS) {  //---------------------------------------
-		const size_t refs = p[3];
-		if (size != sizeof VERSION + 1 + 1 + (refs * (SAM_PUBKEY_LEN - 1))) {
-			LWARN << "Malformed FOUND_PEERS RPC from " << peer->get_sdest()
-				<< " [" << peer->get_b64kaddr() << "]\n";
-			return;
-		}
-		LDEBUG << "From: " << peer->get_sdest() << " [" << peer->get_b64kaddr()
-			<< "] Msg: FOUND_PEERS (" << refs << " peers)\n";
-		p += sizeof VERSION + 1 + 1;
-		for (size_t i = 1; i <= refs; i++) {
-			sam_pubkey_t dest;
-			memcpy(dest, p, SAM_PUBKEY_LEN - 1);  // - 1 == no NUL in RPC
-			dest[SAM_PUBKEY_LEN - 1] = '\0';
-			//LDEBUG << "Message had: " << dest << '\n';
-			sam->peers->new_peer(dest);
-			p += SAM_PUBKEY_LEN - 1;
-		}
-		return;
-
-	} else  //------------------------------------------------------------------
-		LWARN << "Unknown RPC #" << static_cast<int>(p[2]) << " from "
-			<< peer->get_sdest() << " [" << peer->get_b64kaddr() << "]\n";
-}
-
-/*
- * Sends a ping to someone
- */
-void Rpc::ping(void)
-{
-	LDEBUG << "To: " << peer->get_sdest() << " [" << peer->get_b64kaddr()
-		<< "] Msg: PING\n";
-
-	uint32_t now = htonl(time(NULL));
-	// VERSION + command + seconds since 1970
-	const size_t len = sizeof VERSION + 1 + sizeof now;
-	uchar_t buf[len];
-	uchar_t* p = static_cast<uchar_t*>(memcpy(buf, &VERSION, sizeof VERSION));
-	p += sizeof VERSION;
-	*p = PING;
-	p++;
-	memcpy(p, &now, sizeof now);
-	sam->send_dgram(peer->get_dest(), buf, len);
-}
-
-/*
- * Sends a ping reply to someone
- *
- * ptime - the time the peer sent us (we echo the same time back)
- */
-void Rpc::pong(uint32_t ptime)
-{
-	LDEBUG << "To: " << peer->get_sdest() << " [" << peer->get_b64kaddr()
-		<< "] Msg: PONG\n";
-
-	// VERSION + command + pinger's seconds since 1970 echoed back
-	const size_t len = sizeof VERSION + 1 + sizeof ptime;
-	uchar_t buf[len];
-	uchar_t* p = static_cast<uchar_t*>(memcpy(buf, &VERSION, sizeof VERSION));
-	p += sizeof VERSION;
-	*p = PONG;
-	p++;
-	memcpy(p, &ptime, sizeof ptime);
-	sam->send_dgram(peer->get_dest(), buf, len);
-}
-
-/*
- * Tells a peer to store some data
- *
- * sha1 - sha1 value for the data
- * data - the data
- */
-void Rpc::store(const Sha1& sha1)
-{
-	LDEBUG << "To: " << peer->get_sdest() << " [" << peer->get_b64kaddr()
-		<< "] Msg: STORE\n";
-}

apps/enclave/src/rpc.hpp

@@ -1,65 +0,0 @@
-/*
- * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *     * Neither the name of the author nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
- * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef RPC_HPP
-#define RPC_HPP
-
-class Rpc {
-	public:
-		// The PROTOCOL version we are using
-		static uint16_t VERSION;
-		// The oldest version we will talk to
-		static uint16_t OLDEST_GOOD_VERSION;
-		// RPC identifiers (0-255)
-		typedef enum {
-			PING = 0,
-			PONG = 1,
-			FIND_PEERS = 2,
-			FOUND_PEERS = 3,
-			STORE = 4
-		} rpc_t;
-
-		Rpc(Peer* peer)
-			: peer(peer) {};
-
-		void find_peers(const Sha1& sha1);
-		void parse(const void* data, size_t size);
-		void ping(void);
-		void store(const Sha1& sha1);
-
-	private:
-		void found_peers(const Sha1& sha1);
-		void pong(uint32_t ptime);
-
-		Peer* peer;
-		basic_string<uchar_t> data;
-};
-
-#endif  // RPC_HPP

apps/enclave/src/sam.cpp

@@ -1,249 +0,0 @@
-/*
- * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *     * Neither the name of the author nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
- * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include "platform.hpp"
-#include "rpc.hpp"
-#include "sam.hpp"
-
-extern "C" {
-	/*
-	 * Assorted callbacks required by LibSAM - ugly, but it works
-	 */
-	static void dgramback(sam_pubkey_t dest, void* data, size_t size);
-	static void diedback(void);
-	static void logback(char* str);
-	static void namingback(char* name, sam_pubkey_t pubkey, samerr_t result);
-}
-
-/*
- * Prevents more than one Sam object from existing in the program at a time
- * (LibSAM limitation)
- */
-bool Sam::exists = false;
-
-Sam::Sam(const string& samhost, uint16_t samport, const string& destname,
-	uint_t tunneldepth)
-{
-	// Only allow one Sam object to exist at a time
-	assert(!exists);
-	exists = true;
-
-	// hook up callbacks
-	sam_dgramback = &dgramback;
-	sam_diedback = &diedback;
-	sam_logback = &logback;
-	sam_namingback = &namingback;
-
-	// we haven't connected to SAM yet
-	set_connected(false);
-
-	// now try to connect to SAM
-	connect(samhost.c_str(), samport, destname.c_str(), tunneldepth);
-}
-
-Sam::~Sam(void)
-{
-	delete peers;  // this must be before set_connected(false)!
-	if (is_connected()) {
-		sam_close();
-		set_connected(false);
-	}
-	exists = false;
-}
-
-/*
- * Connects to the SAM host
- *
- * samhost - host that SAM is running on (hostname or IP address)
- * samport - port number that SAM is running own
- * destname - the destination name of this program
- * tunneldepth - how long the tunnels should be
- */
-void Sam::connect(const char* samhost, uint16_t samport, const char* destname,
-	uint_t tunneldepth)
-{
-	assert(!is_connected());
-	LMINOR << "Connecting to SAM as '" << destname << "'\n";
-	samerr_t rc = sam_connect(samhost, samport, destname, SAM_DGRAM, tunneldepth);
-	if (rc == SAM_OK)
-		set_connected(true);
-	else
-		throw Sam_error(rc);
-}
-
-/*
- * Loads peer references from disk
- * Note: this can only be called after my_dest has been set
- */
-void Sam::load_peers(void)
-{
-	peers = new Peers(config->get_cproperty("references"));
-}
-
-/*
- * Converts `name' to a base 64 destination
- *
- * name - name to lookup
- */
-void Sam::naming_lookup(const string& name) const
-{
-	assert(is_connected());
-	sam_naming_lookup(name.c_str());
-}
-
-/*
- * Parses an incoming datagram
- *
- * dest - source destination address
- * data - datagram payload
- * size - size of `data'
- */
-void Sam::parse_dgram(const string& dest, void* data, size_t size)
-{
-	assert(is_connected());
-	Peer* peer = peers->new_peer(dest);
-	Rpc rpc(peer);
-	rpc.parse(data, size);
-	rpc.ping();
-	free(data);
-}
-
-/*
- * Checks the SAM connection for incoming commands and invokes callbacks
- */
-void Sam::read_buffer(void)
-{
-	assert(is_connected());
-	sam_read_buffer();
-}
-
-/*
- * Sends a datagram to a destination
- *
- * dest - destination to send to
- * data - data to send
- * size - size of `data'
- */
-void Sam::send_dgram(const string& dest, uchar_t *data, size_t size)
-{
-	assert(is_connected());
-	samerr_t rc = sam_dgram_send(dest.c_str(), data, size);
-	assert(rc == SAM_OK);  // i.e. not SAM_TOO_BIG
-}
-
-/*
- * Sets the connection status
- *
- * connected - true for connected, false for disconnected
- */
-void Sam::set_connected(bool connected)
-{
-	if (!connected)
-		my_dest = "";
-	this->connected = connected;
-}
-
-/*
- * Sets my destination address
- *
- * pubkey - the base 64 destination
- */
-void Sam::set_my_dest(const sam_pubkey_t pubkey)
-{
-	my_dest = pubkey;
-	my_sha1 = Sha1(my_dest);
-}
-
-/*
- * Checks whether the destination specified is of a valid base 64 syntax
- *
- * Returns: true if it is valid, false if it isn't
- */
-bool Sam::valid_dest(const string& dest)
-{
-	if (dest.size() != 516)
-		return false;
-	if (dest.substr(512, 4) == "AAAA")  // Note this AAAA signifies a null
-		return true;					// certificate and doesn't actually have
-	else								// any bearing on validity, but we'll
-		return false;					// keep this check here for now anyway
-}
-
-/*
- * * * * Callbacks * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- * Unfortunately these aren't part of the "Sam" object because they are function
- * pointers to _C_ functions.  As a hack, we just have them call the global Sam
- * object.
- */
-
-/*
- * Callback: A datagram was received
- */
-static void dgramback(sam_pubkey_t dest, void* data, size_t size)
-{
-	sam->parse_dgram(dest, data, size);
-}
-
-/*
- * Callback: The connection to SAM has failed
- */
-static void diedback(void)
-{
-	LERROR << "Connection to SAM lost!\n";
-	sam->set_connected(false);
-	throw Sam_error(SAM_SOCKET_ERROR);
-}
-
-/*
- * Callback: A log message has been sent from LibSAM
- */
-static void logback(char* str)
-{
-	LINFO << "LibSAM: " << str << '\n';
-}
-
-/*
- * Callback: A naming lookup has completed
- */
-static void namingback(char* name, sam_pubkey_t pubkey, samerr_t result)
-{
-	Sam_error res(result);
-	if (res.code() == SAM_OK) {
-		if (strcmp(name, "ME") == 0) {
-			sam->set_my_dest(pubkey);
-			sam->load_peers();
-		} else {
-			assert(false);
-		}
-	} else {
-		LERROR << "Naming look failed for '" << name << "': " << res.what()
-			<< '\n';
-	}
-}

apps/enclave/src/sam.hpp

@@ -1,66 +0,0 @@
-/*
- * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *     * Neither the name of the author nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
- * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef SAM_HPP
-#define SAM_HPP
-
-class Sam {
-	public:
-		Sam(const string& samhost, uint16_t samport, const string& destname,
-			uint_t tunneldepth);
-		~Sam(void);
-
-		const string& get_my_dest(void) const { return my_dest; }
-		const Sha1& get_my_sha1(void) const { return my_sha1; }
-		void naming_lookup(const string& name = "ME") const;
-		void read_buffer(void);
-		void send_dgram(const string& dest, uchar_t *data, size_t size);
-		bool valid_dest(const string& dest);
-
-		Peers* peers;
-
-	//callback-private:
-		void load_peers(void);
-		void parse_dgram(const string& dest, void* data, size_t size);
-		void set_connected(bool connected);
-		void set_my_dest(const sam_pubkey_t pubkey);
-
-	private:
-		void connect(const char* samhost, uint16_t samport,
-			const char* destname, uint_t tunneldepth);
-		bool is_connected(void) const { return connected; }
-
-		bool connected;
-		static bool exists;
-		string my_dest;
-		Sha1 my_sha1;
-};
-
-#endif  // SAM_HPP

apps/enclave/src/sam_error.hpp

@@ -1,46 +0,0 @@
-/*
- * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *     * Neither the name of the author nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
- * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef SAM_ERROR_HPP
-#define SAM_ERROR_HPP
-
-class Sam_error {
-	public:
-		Sam_error(samerr_t error)
-			: errcode(error) {}
-
-		samerr_t code(void) const { return errcode; }
-		const char* what(void) const { return sam_strerror(errcode); }
-
-	private:
-		const samerr_t errcode;
-};
-
-#endif  // SAM_ERROR_HPP

apps/enclave/src/sha1.cpp

@@ -1,122 +0,0 @@
-/*
- * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *     * Neither the name of the author nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
- * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include "platform.hpp"
-#include "sha1.hpp"
-
-Sha1::Sha1(void)
-{
-	b64hashed = "No value!";
-	memset(binhashed, 0, sizeof binhashed);
-}
-
-Sha1::Sha1(const string& data)
-{
-	/* Hash it */
-	hash_state md;
-	sha1_init(&md);
-	int rc = sha1_process(&md, reinterpret_cast<const uchar_t*>(data.c_str()),
-		data.size());
-	assert(rc == CRYPT_OK);
-	rc = sha1_done(&md, binhashed);
-	assert(rc == CRYPT_OK);
-	b64();
-}
-
-/*
- * Initialises the Sha1 object from a binary hash
- */
-Sha1::Sha1(const uchar_t binary[SHA1BIN_LEN])
-{
-	memcpy(binhashed, binary, sizeof binhashed);
-	b64();
-}
-
-/*
- * Base 64 the binary hash
- */
-void Sha1::b64(void)
-{
-	ulong_t outlen = 29;
-	char tmp[outlen];
-	// b64 FIXME: replace + with ~, and / with - to be like freenet
-	int rc = base64_encode(binhashed, sizeof binhashed, reinterpret_cast<uchar_t*>(tmp), &outlen);
-	assert(rc == CRYPT_OK);
-	b64hashed = tmp;
-}
-
-/*
- * Compares two Sha1s, returning true if the this one is less than the right one
- */
-bool Sha1::operator<(const Sha1& rhs) const
-{
-	Bigint lhsnum(binhashed, SHA1BIN_LEN);
-	Bigint rhsnum(rhs.binhash(), SHA1BIN_LEN);
-	if (lhsnum < rhsnum)
-		return true;
-	else
-		return false;
-}
-
-/*
- * Assigns a value from another Sha1 to this one
- */
-Sha1& Sha1::operator=(const Sha1& rhs)
-{
-	if (this != &rhs) {  // check for self-assignment: a = a
-		b64hashed = rhs.b64hash();
-		memcpy(binhashed, rhs.binhash(), sizeof binhashed);
-	}
-	return *this;
-}
-
-/*
- * Compares Sha1s for equality
- */
-bool Sha1::operator==(const Sha1& rhs) const
-{
-	if (memcmp(binhashed, rhs.binhash(), sizeof binhashed) == 0)
-		return true;
-	else
-		return false;
-}
-
-/*
- * Xors this Sha1 with another, and stores the result in a Bigint
- *
- * rhs - sha1 to xor this one with
- * result - will be filled with the result
- */
-void Sha1::x_or(const Sha1& rhs, Bigint& result) const
-{
-	Bigint lhsnum(binhashed, SHA1BIN_LEN);
-	Bigint rhsnum(rhs.binhash(), SHA1BIN_LEN);
-	lhsnum.x_or(rhsnum, result);
-}

apps/enclave/src/sha1.hpp

@@ -1,56 +0,0 @@
-/*
- * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *     * Neither the name of the author nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
- * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef SHA1_HPP
-#define SHA1_HPP
-
-class Sha1 {
-	public:
-		static const size_t SHA1BIN_LEN = 20;
-
-		Sha1(void);
-		Sha1(const string& data);
-		Sha1(const uchar_t binary[SHA1BIN_LEN]);
-
-		const string& b64hash(void) const { return b64hashed; }
-		const uchar_t* binhash(void) const { return binhashed; }
-		bool operator<(const Sha1& rhs) const;
-		Sha1& operator=(const Sha1& rhs);
-		bool operator==(const Sha1& rhs) const;
-		void x_or(const Sha1& rhs, Bigint& result) const;
-
-	private:
-		void b64(void);
-
-		string b64hashed;  // base 64 of the hash
-		uchar_t binhashed[SHA1BIN_LEN];  // non-NUL terminated binary hash
-};
-
-#endif  // SHA1_HPP

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/heartbeat/java/src/net/i2p/heartbeat/PeerData.java

@@ -274,9 +274,9 @@ public class PeerData {
 
         _lostRate.addData(numTimedOut, 0);
 
-        _receiveRate.coallesceStats();
-        _sendRate.coallesceStats();
-        _lostRate.coallesceStats();
+        _receiveRate.coalesceStats();
+        _sendRate.coalesceStats();
+        _lostRate.coalesceStats();
 
         if (_log.shouldLog(Log.DEBUG))
             _log.debug("Peer data cleaned up " + numTimedOut + " timed out pings and removed " + numDropped
@@ -409,4 +409,4 @@ public class PeerData {
             _wasPonged = pong;
         }
     }
-}
+}

apps/i2ptunnel/java/build.xml

@@ -4,6 +4,7 @@
     <target name="build" depends="builddep, jar" />
     <target name="builddep">
         <ant dir="../../ministreaming/java/" target="build" />
+        <ant dir="../../jetty/" target="build" />
 	<!-- ministreaming will build core -->
     </target>
     <target name="compile">
@@ -15,7 +16,7 @@
             destdir="./build/obj" 
             classpath="../../../core/java/build/i2p.jar:../../ministreaming/java/build/mstreaming.jar" />
     </target>
-    <target name="jar" depends="compile">
+    <target name="jar" depends="builddep, compile">
         <jar destfile="./build/i2ptunnel.jar" basedir="./build/obj" includes="**/*.class">
             <manifest>
                 <attribute name="Main-Class" value="net.i2p.i2ptunnel.I2PTunnel" />
@@ -30,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 -->
@@ -38,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" />
@@ -51,10 +56,12 @@
             <arg value="-webapp" />
             <arg value="../jsp/" />
         </java>
-        <javac destdir="../jsp/WEB-INF/classes/" srcdir="../jsp/WEB-INF/classes" includes="*.java">
+        <javac 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/I2PTunnel.java

@@ -54,6 +54,7 @@ import net.i2p.I2PAppContext;
 import net.i2p.I2PException;
 import net.i2p.client.I2PClient;
 import net.i2p.client.I2PClientFactory;
+import net.i2p.client.I2PSession;
 import net.i2p.client.naming.NamingService;
 import net.i2p.data.Base64;
 import net.i2p.data.DataFormatException;
@@ -71,6 +72,7 @@ public class I2PTunnel implements Logging, EventDispatcher {
     private static long __tunnelId = 0;
     private long _tunnelId;
     private Properties _clientOptions;
+    private List _sessions;
 
     public static final int PACKET_DELAY = 100;
 
@@ -108,6 +110,7 @@ public class I2PTunnel implements Logging, EventDispatcher {
         _event = new EventDispatcherImpl();
         _clientOptions = new Properties();
         _clientOptions.putAll(System.getProperties());
+        _sessions = new ArrayList(1);
         
         addConnectionEventListener(lsnr);
         boolean gui = true;
@@ -172,6 +175,25 @@ public class I2PTunnel implements Logging, EventDispatcher {
         }
     }
 
+    List getSessions() { 
+        synchronized (_sessions) {
+            return new ArrayList(_sessions); 
+        }
+    }
+    void addSession(I2PSession session) { 
+        if (session == null) return;
+        synchronized (_sessions) {
+            if (!_sessions.contains(session))
+                _sessions.add(session);
+        }
+    }
+    void removeSession(I2PSession session) { 
+        if (session == null) return;
+        synchronized (_sessions) {
+            _sessions.remove(session);
+        }
+    }
+    
     public Properties getClientOptions() { return _clientOptions; }
     
     private void addtask(I2PTunnelTask tsk) {
@@ -208,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)) {
@@ -260,10 +284,11 @@ 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");
-        l.log("client <port> <pubkey>|file:<pubkeyfile>");
+        l.log("client <port> <pubkey>[,<pubkey,...]|file:<pubkeyfile>");
         l.log("httpclient <port>");
         l.log("lookup <name>");
         l.log("quit");
@@ -349,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 />
@@ -428,9 +512,11 @@ public class I2PTunnel implements Logging, EventDispatcher {
                 notifyEvent("clientTaskId", new Integer(-1));
             }
         } else {
-            l.log("client <port> <pubkey>|file:<pubkeyfile>");
+            l.log("client <port> <pubkey>[,<pubkey>]|file:<pubkeyfile>");
             l.log("  creates a client that forwards port to the pubkey.\n"
-                  + "  use 0 as port to get a free port assigned.");
+                  + "  use 0 as port to get a free port assigned.  If you specify\n"
+                  + "  a comma delimited list of pubkeys, it will rotate among them\n"
+                  + "  randomlyl");
             notifyEvent("clientTaskId", new Integer(-1));
         }
     }

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

@@ -4,7 +4,11 @@
 package net.i2p.i2ptunnel;
 
 import java.net.Socket;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.StringTokenizer;
 
+import net.i2p.I2PAppContext;
 import net.i2p.client.streaming.I2PSocket;
 import net.i2p.data.DataFormatException;
 import net.i2p.data.Destination;
@@ -15,15 +19,17 @@ public class I2PTunnelClient extends I2PTunnelClientBase {
 
     private static final Log _log = new Log(I2PTunnelClient.class);
 
-    protected Destination dest;
+    /** list of Destination objects that we point at */
+    protected List dests;
     private static final long DEFAULT_READ_TIMEOUT = 5*60*1000; // -1
     protected long readTimeout = DEFAULT_READ_TIMEOUT;
 
     /**
+     * @param destinations comma delimited list of peers we target
      * @throws IllegalArgumentException if the I2PTunnel does not contain
      *                                  valid config to contact the router
      */
-    public I2PTunnelClient(int localPort, String destination, Logging l, 
+    public I2PTunnelClient(int localPort, String destinations, Logging l, 
                            boolean ownDest, EventDispatcher notifyThis, 
                            I2PTunnel tunnel) throws IllegalArgumentException {
         super(localPort, ownDest, l, notifyThis, "SynSender", tunnel);
@@ -33,19 +39,28 @@ public class I2PTunnelClient extends I2PTunnelClientBase {
             return;
         }
 
-        try {
-            dest = I2PTunnel.destFromName(destination);
-            if (dest == null) {
-                l.log("Could not resolve " + destination + ".");
-                return;
+        StringTokenizer tok = new StringTokenizer(destinations, ",");
+        dests = new ArrayList(1);
+        while (tok.hasMoreTokens()) {
+            String destination = tok.nextToken();
+            try {
+                Destination dest = I2PTunnel.destFromName(destination);
+                if (dest == null)
+                    l.log("Could not resolve " + destination);
+                else
+                    dests.add(dest);
+            } catch (DataFormatException dfe) {
+                l.log("Bad format parsing \"" + destination + "\"");
             }
-        } catch (DataFormatException e) {
-            l.log("Bad format in destination \"" + destination + "\".");
+        }
+
+        if (dests.size() <= 0) {
+            l.log("No target destinations found");
             notifyEvent("openClientResult", "error");
             return;
         }
 
-        setName(getLocalPort() + " -> " + destination);
+        setName(getLocalPort() + " -> " + destinations);
 
         startRunning();
 
@@ -56,14 +71,34 @@ public class I2PTunnelClient extends I2PTunnelClientBase {
     public long getReadTimeout() { return readTimeout; }
     
     protected void clientConnectionRun(Socket s) {
+        Destination dest = pickDestination();
+        I2PSocket i2ps = null;
         try {
-            I2PSocket i2ps = createI2PSocket(dest);
+            i2ps = createI2PSocket(dest);
             i2ps.setReadTimeout(readTimeout);
-            new I2PTunnelRunner(s, i2ps, sockLock, null);
+            new I2PTunnelRunner(s, i2ps, sockLock, null, mySockets);
         } catch (Exception ex) {
             _log.info("Error connecting", ex);
             l.log(ex.getMessage());
             closeSocket(s);
+            if (i2ps != null) {
+                synchronized (sockLock) {
+                    mySockets.remove(sockLock);
+                }
+            }
         }
     }
+    
+    private final Destination pickDestination() {
+        int size = dests.size();
+        if (size <= 0) {
+            if (_log.shouldLog(Log.ERROR))
+                _log.error("No client targets?!");
+            return null;
+        }
+        if (size == 1) // skip the rand in the most common case
+            return (Destination)dests.get(0);
+        int index = I2PAppContext.getGlobalContext().random().nextInt(size);
+        return (Destination)dests.get(index);
+    }
 }

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

@@ -12,11 +12,15 @@ import java.net.ServerSocket;
 import java.net.Socket;
 import java.net.UnknownHostException;
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
+import java.util.Map;
 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;
@@ -24,6 +28,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 {
@@ -31,13 +36,13 @@ public abstract class I2PTunnelClientBase extends I2PTunnelTask implements Runna
     private static final Log _log = new Log(I2PTunnelClientBase.class);
     protected Logging l;
 
-    private static final long DEFAULT_CONNECT_TIMEOUT = 60 * 1000;
+    static final long DEFAULT_CONNECT_TIMEOUT = 60 * 1000;
 
     private static volatile long __clientId = 0;
     protected long _clientId;
     protected Object sockLock = new Object(); // Guards sockMgr and mySockets
-    private I2PSocketManager sockMgr;
-    private List mySockets = new ArrayList();
+    protected I2PSocketManager sockMgr;
+    protected List mySockets = new ArrayList();
 
     protected Destination dest = null;
     private int localPort;
@@ -55,6 +60,32 @@ public abstract class I2PTunnelClientBase extends I2PTunnelTask implements Runna
 
     private String handlerName;
 
+    private Object conLock = new Object();
+    
+    /** 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) {
     //    I2PTunnelClientBase(localPort, ownDest, l, (EventDispatcher)null);
@@ -86,13 +117,15 @@ public abstract class I2PTunnelClientBase extends I2PTunnelTask implements Runna
         }
         l.log("I2P session created");
 
+        getTunnel().addSession(sockMgr.getSession());
+        
         Thread t = new I2PThread(this);
         t.setName("Client " + _clientId);
         listenerReady = false;
         t.start();
         open = true;
         synchronized (this) {
-            while (!listenerReady) {
+            while (!listenerReady && open) {
                 try {
                     wait();
                 } catch (InterruptedException e) {
@@ -101,14 +134,47 @@ public abstract class I2PTunnelClientBase extends I2PTunnelTask implements Runna
             }
         }
 
+        configurePool(tunnel);
+        
         if (open && listenerReady) {
             l.log("Ready! Port " + getLocalPort());
             notifyEvent("openBaseClientResult", "ok");
         } else {
-            l.log("Error!");
+            l.log("Error listening - please see the logs!");
             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;
 
@@ -116,7 +182,16 @@ public abstract class I2PTunnelClientBase extends I2PTunnelTask implements Runna
         return getSocketManager(getTunnel());
     }
     protected static synchronized I2PSocketManager getSocketManager(I2PTunnel tunnel) {
-        if (socketManager == null) {
+        if (socketManager != null) {
+            I2PSession s = socketManager.getSession();
+            if ( (s == null) || (s.isClosed()) ) {
+                _log.info("Building a new socket manager since the old one closed [s=" + s + "]");
+                socketManager = buildSocketManager(tunnel);
+            } else {
+                _log.info("Not building a new socket manager since the old one is open [s=" + s + "]");
+            }
+        } else {
+            _log.info("Building a new socket manager since there is no other one");
             socketManager = buildSocketManager(tunnel);
         }
         return socketManager;
@@ -168,9 +243,24 @@ public abstract class I2PTunnelClientBase extends I2PTunnelTask implements Runna
      * create the default options (using the default timeout, etc)
      *
      */
-    private I2PSocketOptions getDefaultOptions() {
-        I2PSocketOptions opts = new I2PSocketOptions();
-        opts.setConnectTimeout(DEFAULT_CONNECT_TIMEOUT);
+    protected I2PSocketOptions getDefaultOptions() {
+        Properties defaultOpts = getTunnel().getClientOptions();
+        I2PSocketOptions opts = sockMgr.buildOptions(defaultOpts);
+        if (!defaultOpts.containsKey(I2PSocketOptions.PROP_CONNECT_TIMEOUT))
+            opts.setConnectTimeout(DEFAULT_CONNECT_TIMEOUT);
+        return opts;
+    }
+    
+    /** 
+     * create the default options (using the default timeout, etc)
+     *
+     */
+    protected I2PSocketOptions getDefaultOptions(Properties overrides) {
+        Properties defaultOpts = getTunnel().getClientOptions();
+        defaultOpts.putAll(overrides);
+        I2PSocketOptions opts = sockMgr.buildOptions(defaultOpts);
+        if (!defaultOpts.containsKey(I2PSocketOptions.PROP_CONNECT_TIMEOUT))
+            opts.setConnectTimeout(DEFAULT_CONNECT_TIMEOUT);
         return opts;
     }
 
@@ -214,7 +304,14 @@ public abstract class I2PTunnelClientBase extends I2PTunnelTask implements Runna
     public final void run() {
         try {
             InetAddress addr = getListenHost(l);
-            if (addr == null) return;
+            if (addr == null) {
+                open = false;
+                synchronized (this) {
+                    notifyAll();
+                }
+                synchronized (_waitingSockets) { _waitingSockets.notifyAll(); }
+                return;
+            }
             ss = new ServerSocket(localPort, 0, addr);
 
             // If a free port was requested, find out what we got
@@ -245,8 +342,18 @@ public abstract class I2PTunnelClientBase extends I2PTunnelTask implements Runna
                 manageConnection(s);
             }
         } catch (IOException ex) {
-            _log.error("Error listening for connections", ex);
+            _log.error("Error listening for connections on " + localPort, ex);
             notifyEvent("openBaseClientResult", "error");
+            synchronized (sockLock) {
+                mySockets.clear();
+            }
+            open = false;
+            synchronized (this) {
+                notifyAll();
+            }
+        }
+        synchronized (_waitingSockets) {
+            _waitingSockets.notifyAll();
         }
     }
 
@@ -256,7 +363,52 @@ public abstract class I2PTunnelClientBase extends I2PTunnelTask implements Runna
      * @param s Socket to take care of
      */
     protected void manageConnection(Socket s) {
-        new ClientConnectionRunner(s, handlerName);
+        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");
+            }
+        }
     }
 
     public boolean close(boolean forced) {
@@ -275,6 +427,10 @@ public abstract class I2PTunnelClientBase extends I2PTunnelTask implements Runna
                 }
                 return false;
             }
+            I2PSession session = sockMgr.getSession();
+            if (session != null) {
+                getTunnel().removeSession(session);
+            }
             l.log("Closing client " + toString());
             try {
                 if (ss != null) ss.close();
@@ -284,8 +440,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) {
@@ -295,20 +453,30 @@ 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);
+    /**
+     * 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

@@ -13,10 +13,13 @@ import java.util.ArrayList;
 import java.util.Date;
 import java.util.List;
 import java.util.StringTokenizer;
+import java.util.HashMap;
+import java.util.Properties;
 
 import net.i2p.I2PAppContext;
 import net.i2p.I2PException;
 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;
@@ -48,6 +51,8 @@ public class I2PTunnelHTTPClient extends I2PTunnelClientBase implements Runnable
 
     private List proxyList;
 
+    private HashMap addressHelpers = new HashMap();
+
     private final static byte[] ERR_REQUEST_DENIED =
         ("HTTP/1.1 403 Access Denied\r\n"+
          "Content-Type: text/html; charset=iso-8859-1\r\n"+
@@ -82,6 +87,16 @@ public class I2PTunnelHTTPClient extends I2PTunnelClientBase implements Runnable
          "the following Destination:<BR><BR>")
         .getBytes();
 
+    private final static byte[] ERR_NO_OUTPROXY =
+        ("HTTP/1.1 503 Service Unavailable\r\n"+
+         "Content-Type: text/html; charset=iso-8859-1\r\n"+
+         "Cache-control: no-cache\r\n"+
+         "\r\n"+
+         "<html><body><H1>I2P ERROR: No outproxy found</H1>"+
+         "Your request was for a site outside of I2P, but you have no "+
+         "HTTP outproxy configured.  Please configure an outproxy in I2PTunnel")
+         .getBytes();
+    
     /** used to assign unique IDs to the threads / clients.  no logic or functionality */
     private static volatile long __clientId = 0;
 
@@ -113,23 +128,65 @@ public class I2PTunnelHTTPClient extends I2PTunnelClientBase implements Runnable
         notifyEvent("openHTTPClientResult", "ok");
     }
 
-    private String getPrefix() { return "Client[" + _clientId + "]: "; }
+    private String getPrefix(long requestId) { return "Client[" + _clientId + "/" + requestId + "]: "; }
     
     private String selectProxy() {
-        if (proxyList.size() <= 0) {
-            l.log("Proxy list is emtpy - no outproxy available");
-            return null;
+        synchronized (proxyList) {
+            int size = proxyList.size();
+            if (size <= 0) {
+                if (_log.shouldLog(Log.INFO))
+                    _log.info("Proxy list is empty - no outproxy available");
+                l.log("Proxy list is emtpy - no outproxy available");
+                return null;
+            }
+            int index = I2PAppContext.getGlobalContext().random().nextInt(size);
+            String proxy = (String)proxyList.get(index);
+            return proxy;
         }
-        int index = I2PAppContext.getGlobalContext().random().nextInt(proxyList.size());
-        return (String)proxyList.get(index);
+    }
+
+    private static final int DEFAULT_READ_TIMEOUT = 60*1000;
+    
+    /** 
+     * create the default options (using the default timeout, etc)
+     *
+     */
+    protected I2PSocketOptions getDefaultOptions() {
+        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);
+        I2PSocketOptions opts = sockMgr.buildOptions(defaultOpts);
+        if (!defaultOpts.containsKey(I2PSocketOptions.PROP_CONNECT_TIMEOUT))
+            opts.setConnectTimeout(DEFAULT_CONNECT_TIMEOUT);
+        return opts;
     }
     
+    /** 
+     * create the default options (using the default timeout, etc)
+     *
+     */
+    protected I2PSocketOptions getDefaultOptions(Properties overrides) {
+        Properties defaultOpts = getTunnel().getClientOptions();
+        defaultOpts.putAll(overrides);
+        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);
+        I2PSocketOptions opts = sockMgr.buildOptions(defaultOpts);
+        if (!defaultOpts.containsKey(I2PSocketOptions.PROP_CONNECT_TIMEOUT))
+            opts.setConnectTimeout(DEFAULT_CONNECT_TIMEOUT);
+        return opts;
+    }
+
+    private static long __requestId = 0;
     protected void clientConnectionRun(Socket s) {
         OutputStream out = null;
         String targetRequest = null;
         boolean usingWWWProxy = false;
         String currentProxy = null;
-        InactivityTimeoutThread timeoutThread = null;
+        long requestId = ++__requestId;
         try {
             out = s.getOutputStream();
             BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream(), "ISO-8859-1"));
@@ -137,7 +194,7 @@ public class I2PTunnelHTTPClient extends I2PTunnelClientBase implements Runnable
             StringBuffer newRequest = new StringBuffer();
             while ((line = br.readLine()) != null) {
                 if (_log.shouldLog(Log.DEBUG))
-                    _log.debug(getPrefix() + "Line=[" + line + "]");
+                    _log.debug(getPrefix(requestId) + "Line=[" + line + "]");
                 
                 if (line.startsWith("Connection: ") || 
                     line.startsWith("Keep-Alive: ") || 
@@ -146,7 +203,7 @@ public class I2PTunnelHTTPClient extends I2PTunnelClientBase implements Runnable
                 
                 if (method == null) { // first line (GET /base64/realaddr)
                     if (_log.shouldLog(Log.DEBUG))
-                        _log.debug(getPrefix() + "Method is null for [" + line + "]");
+                        _log.debug(getPrefix(requestId) + "Method is null for [" + line + "]");
                     
                     int pos = line.indexOf(" ");
                     if (pos == -1) break;
@@ -154,7 +211,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;
@@ -176,14 +244,73 @@ public class I2PTunnelHTTPClient extends I2PTunnelClientBase implements Runnable
                     if (host.toLowerCase().endsWith(".i2p")) {
                         destination = host;
                         host = getHostName(destination);
+                        if ( (host != null) && ("i2p".equals(host)) ) {
+                            int pos2;
+                            if ((pos2 = request.indexOf("?")) != -1) {
+                                // Try to find an address helper in the fragments
+                                // and split the request into it's component parts for rebuilding later
+                                String fragments = request.substring(pos2 + 1);
+                                String uriPath = request.substring(0, pos2);
+                                pos2 = fragments.indexOf(" ");
+                                String protocolVersion = fragments.substring(pos2 + 1);
+                                String urlEncoding = "";
+                                fragments = fragments.substring(0, pos2);
+                                fragments = fragments + "&";
+                                String fragment;
+                                while(fragments.length() > 0) {
+                                    pos2 = fragments.indexOf("&");
+                                    fragment = fragments.substring(0, pos2);
+                                    fragments = fragments.substring(pos2 + 1);
+                                    if (fragment.startsWith("i2paddresshelper")) {
+                                        pos2 = fragment.indexOf("=");
+                                        if (pos2 >= 0) {
+                                            addressHelpers.put(destination,fragment.substring(pos2 + 1));
+                                        }
+                                    } else {
+                                        // append each fragment unless it's the address helper
+                                        if ("".equals(urlEncoding)) {
+                                            urlEncoding = "?" + fragment;
+                                        } else {
+                                            urlEncoding = urlEncoding + "&" + fragment; 
+                                        }
+				    }
+                                }
+                                // reconstruct the request minus the i2paddresshelper GET var
+                                request = uriPath + urlEncoding + " " + protocolVersion;
+                            }
+
+                            String addressHelper = (String) addressHelpers.get(destination);
+                            if (addressHelper != null) {
+                                destination = addressHelper;
+                                host = getHostName(destination);
+                            }
+                        }
                         line = method + " " + request.substring(pos);
                     } else if (host.indexOf(".") != -1) {
                         // The request must be forwarded to a WWW proxy
+                        if (_log.shouldLog(Log.DEBUG))
+                            _log.debug("Before selecting outproxy for " + host);
                         currentProxy = selectProxy();
+                        if (_log.shouldLog(Log.DEBUG))
+                            _log.debug("After selecting outproxy for " + host + ": " + currentProxy);
+                        if (currentProxy == null) {
+                            if (_log.shouldLog(Log.WARN))
+                                _log.warn(getPrefix(requestId) + "Host wants to be outproxied, but we dont have any!");
+                            l.log("No HTTP outproxy found for the request.");
+                            if (out != null) {
+                                out.write(ERR_NO_OUTPROXY);
+                                out.write("<p /><i>Generated on: ".getBytes());
+                                out.write(new Date().toString().getBytes());
+                                out.write("</i></body></html>\n".getBytes());
+                                out.flush();
+                            }
+                            s.close();
+                            return;
+                        }
                         destination = currentProxy;
                         usingWWWProxy = true;
                         if (_log.shouldLog(Log.DEBUG))
-                            _log.debug(getPrefix() + "Host doesnt end with .i2p and it contains a period [" + host + "]: wwwProxy!");
+                            _log.debug(getPrefix(requestId) + "Host doesnt end with .i2p and it contains a period [" + host + "]: wwwProxy!");
                     } else {
                         request = request.substring(pos + 1);
                         pos = request.indexOf("/");
@@ -193,31 +320,54 @@ public class I2PTunnelHTTPClient extends I2PTunnelClientBase implements Runnable
 
                     boolean isValid = usingWWWProxy || isSupportedAddress(host, protocol);
                     if (!isValid) {
-                        if (_log.shouldLog(Log.INFO)) _log.info(getPrefix() + "notValid(" + host + ")");
+                        if (_log.shouldLog(Log.INFO)) _log.info(getPrefix(requestId) + "notValid(" + host + ")");
                         method = null;
                         destination = null;
                         break;
                     } else if (!usingWWWProxy) {
-                        if (_log.shouldLog(Log.INFO)) _log.info(getPrefix() + "host=getHostName(" + destination + ")");
+                        if (_log.shouldLog(Log.INFO)) _log.info(getPrefix(requestId) + "host=getHostName(" + destination + ")");
                         host = getHostName(destination); // hide original host
                     }
 
                     if (_log.shouldLog(Log.DEBUG)) {
-                        _log.debug(getPrefix() + "METHOD:" + method + ":");
-                        _log.debug(getPrefix() + "PROTOC:" + protocol + ":");
-                        _log.debug(getPrefix() + "HOST  :" + host + ":");
-                        _log.debug(getPrefix() + "DEST  :" + destination + ":");
+                        _log.debug(getPrefix(requestId) + "METHOD:" + method + ":");
+                        _log.debug(getPrefix(requestId) + "PROTOC:" + protocol + ":");
+                        _log.debug(getPrefix(requestId) + "HOST  :" + host + ":");
+                        _log.debug(getPrefix(requestId) + "DEST  :" + destination + ":");
                     }
                     
                 } else {
                     if (line.startsWith("Host: ") && !usingWWWProxy) {
                         line = "Host: " + host;
                         if (_log.shouldLog(Log.INFO)) 
-                            _log.info(getPrefix() + "Setting host = " + host);
+                            _log.info(getPrefix(requestId) + "Setting host = " + host);
+                    } else if (line.startsWith("User-Agent: ")) {
+                        // always stripped, added back at the end
+                        line = null;
+                        continue;
+                    } else if (line.startsWith("Accept")) {
+                        // strip the accept-blah headers, as they vary dramatically from
+                        // browser to browser
+                        line = null;
+                        continue;
+                    } else if (line.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: ")) {
+                        //line = "Via: i2p";
+                        line = null;
+                        continue; // completely strip the line
+                    } else if (line.startsWith("From: ")) {
+                        //line = "From: i2p";
+                        line = null;
+                        continue; // completely strip the line
                     }
                 }
                 
                 if (line.length() == 0) {
+                    newRequest.append("User-Agent: MYOB/6.66 (AN/ON)\r\n");
                     newRequest.append("Connection: close\r\n\r\n");
                     break;
                 } else {
@@ -225,7 +375,7 @@ public class I2PTunnelHTTPClient extends I2PTunnelClientBase implements Runnable
                 }
             }
             if (_log.shouldLog(Log.DEBUG))
-                _log.debug(getPrefix() + "NewRequest header: [" + newRequest.toString() + "]");
+                _log.debug(getPrefix(requestId) + "NewRequest header: [" + newRequest.toString() + "]");
             
             while (br.ready()) { // empty the buffer (POST requests)
                 int i = br.read();
@@ -247,7 +397,7 @@ public class I2PTunnelHTTPClient extends I2PTunnelClientBase implements Runnable
             }
             
             if (_log.shouldLog(Log.DEBUG))
-                _log.debug(getPrefix() + "Destination: " + destination);
+                _log.debug(getPrefix(requestId) + "Destination: " + destination);
             
             Destination dest = I2PTunnel.destFromName(destination);
             if (dest == null) {
@@ -259,116 +409,36 @@ public class I2PTunnelHTTPClient extends I2PTunnelClientBase implements Runnable
                 return;
             }
             String remoteID;
-            I2PSocket i2ps = createI2PSocket(dest);
+            
+            Properties opts = new Properties();
+            opts.setProperty("i2p.streaming.inactivityTimeout", ""+120*1000);
+            // 1 == disconnect.  see ConnectionOptions in the new streaming lib, which i
+            // dont want to hard link to here
+            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);
-            timeoutThread = new InactivityTimeoutThread(runner, out, targetRequest, usingWWWProxy, currentProxy, s);
-            timeoutThread.start();
+            Runnable onTimeout = new OnTimeout(s, s.getOutputStream(), targetRequest, usingWWWProxy, currentProxy, requestId);
+            I2PTunnelRunner runner = new I2PTunnelRunner(s, i2ps, sockLock, data, mySockets, onTimeout);
         } catch (SocketException ex) {
-            if (timeoutThread != null) timeoutThread.disable();
-            _log.info(getPrefix() + "Error trying to connect", ex);
+            _log.info(getPrefix(requestId) + "Error trying to connect", ex);
             l.log(ex.getMessage());
-            handleHTTPClientException(ex, out, targetRequest, usingWWWProxy, currentProxy);
+            handleHTTPClientException(ex, out, targetRequest, usingWWWProxy, currentProxy, requestId);
             closeSocket(s);
         } catch (IOException ex) {
-            if (timeoutThread != null) timeoutThread.disable();
-            _log.info(getPrefix() + "Error trying to connect", ex);
+            _log.info(getPrefix(requestId) + "Error trying to connect", ex);
             l.log(ex.getMessage());
-            handleHTTPClientException(ex, out, targetRequest, usingWWWProxy, currentProxy);
+            handleHTTPClientException(ex, out, targetRequest, usingWWWProxy, currentProxy, requestId);
             closeSocket(s);
         } catch (I2PException ex) {
-            if (timeoutThread != null) timeoutThread.disable();
-            _log.info("getPrefix() + Error trying to connect", ex);
+            _log.info("getPrefix(requestId) + Error trying to connect", ex);
             l.log(ex.getMessage());
-            handleHTTPClientException(ex, out, targetRequest, usingWWWProxy, currentProxy);
-            closeSocket(s);
-        }
-    }
-
-    private static final long INACTIVITY_TIMEOUT = 120 * 1000;
-    private static volatile long __timeoutId = 0;
-
-    private class InactivityTimeoutThread extends I2PThread {
-
-        private Socket s;
-        private I2PTunnelRunner _runner;
-        private OutputStream _out;
-        private String _targetRequest;
-        private boolean _useWWWProxy;
-        private String _currentProxy;
-        private boolean _disabled;
-        private Object _disableLock = new Object();
-
-        public InactivityTimeoutThread(I2PTunnelRunner runner, OutputStream out, String targetRequest,
-                                       boolean useWWWProxy, String currentProxy, Socket s) {
-            this.s = s;
-            _runner = runner;
-            _out = out;
-            _targetRequest = targetRequest;
-            _useWWWProxy = useWWWProxy;
-            _currentProxy = currentProxy;
-            _disabled = false;
-            long timeoutId = ++__timeoutId;
-            setName("InactivityThread " + getPrefix() + timeoutId);
-        }
-
-        public void disable() {
-            _disabled = true;
-            synchronized (_disableLock) {
-                _disableLock.notifyAll();
-            }
-        }
-
-        public void run() {
-            while (!_disabled) {
-                if (_runner.isFinished()) {
-                    if (_log.shouldLog(Log.INFO)) _log.info(getPrefix() + "HTTP client request completed prior to timeout");
-                    return;
-                }
-                if (_runner.getLastActivityOn() < Clock.getInstance().now() - INACTIVITY_TIMEOUT) {
-                    if (_runner.getStartedOn() < Clock.getInstance().now() - INACTIVITY_TIMEOUT) {
-                        if (_log.shouldLog(Log.WARN))
-                            _log.warn(getPrefix() + "HTTP client request timed out (lastActivity: "
-                                      + new Date(_runner.getLastActivityOn()) + ", startedOn: "
-                                      + new Date(_runner.getStartedOn()) + ")");
-                        timeout();
-                        return;
-                    } else {
-                        // runner hasn't been going to long enough
-                    }
-                } else {
-                    // there has been activity in the period
-                }
-                synchronized (_disableLock) {
-                    try {
-                        _disableLock.wait(INACTIVITY_TIMEOUT);
-                    } catch (InterruptedException ie) {
-                    }
-                }
-            }
-        }
-
-        private void timeout() {
-            _log.info(getPrefix() + "Inactivity timeout reached");
-            l.log("Inactivity timeout reached");
-            if (_out != null) {
-                try {
-                    if (_runner.getLastActivityOn() > 0) {
-                        // some  data has been sent, so don't 404 it
-                    } else {
-                        writeErrorMessage(ERR_TIMEOUT, _out, _targetRequest, _useWWWProxy, _currentProxy);
-                    }
-                } catch (IOException ioe) {
-                    _log.warn(getPrefix() + "Error writing out the 'timeout' message", ioe);
-                }
-            } else {
-                _log.warn(getPrefix() + "Client disconnected before we could say we timed out");
-            }
+            handleHTTPClientException(ex, out, targetRequest, usingWWWProxy, currentProxy, requestId);
             closeSocket(s);
         }
     }
 
     private final static String getHostName(String host) {
+        if (host == null) return null;
         try {
             Destination dest = I2PTunnel.destFromName(host);
             if (dest == null) return "i2p";
@@ -378,6 +448,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) {
@@ -394,18 +488,18 @@ public class I2PTunnelHTTPClient extends I2PTunnelClientBase implements Runnable
     }
 
     private void handleHTTPClientException(Exception ex, OutputStream out, String targetRequest,
-                                                  boolean usingWWWProxy, String wwwProxy) {
+                                                  boolean usingWWWProxy, String wwwProxy, long requestId) {
                                                       
         if (_log.shouldLog(Log.WARN))
-            _log.warn("Error sending to " + wwwProxy + " (proxy? " + usingWWWProxy + ", request: " + targetRequest, ex);
+            _log.warn(getPrefix(requestId) + "Error sending to " + wwwProxy + " (proxy? " + usingWWWProxy + ", request: " + targetRequest, ex);
         if (out != null) {
             try {
                 writeErrorMessage(ERR_DESTINATION_UNKNOWN, out, targetRequest, usingWWWProxy, wwwProxy);
             } catch (IOException ioe) {
-                _log.warn(getPrefix() + "Error writing out the 'destination was unknown' " + "message", ioe);
+                _log.warn(getPrefix(requestId) + "Error writing out the 'destination was unknown' " + "message", ioe);
             }
         } else {
-            _log.warn(getPrefix() + "Client disconnected before we could say that destination " + "was unknown", ex);
+            _log.warn(getPrefix(requestId) + "Client disconnected before we could say that destination " + "was unknown", ex);
         }
     }
 

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

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

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

@@ -11,9 +11,11 @@ import java.io.OutputStream;
 import java.net.Socket;
 import java.net.SocketException;
 import java.util.HashMap;
+import java.util.List;
 
-import net.i2p.client.I2PSession;
 import net.i2p.client.streaming.I2PSocket;
+import net.i2p.data.ByteArray;
+import net.i2p.util.ByteCache;
 import net.i2p.util.Clock;
 import net.i2p.util.I2PThread;
 import net.i2p.util.Log;
@@ -38,23 +40,43 @@ public class I2PTunnelRunner extends I2PThread implements I2PSocket.SocketErrorL
     Object slock, finishLock = new Object();
     boolean finished = false;
     HashMap ostreams, sockets;
-    I2PSession session;
-    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;
 
-    public I2PTunnelRunner(Socket s, I2PSocket i2ps, Object slock, byte[] initialData) {
+    private volatile long __forwarderId;
+    
+    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))
             _log.info("I2PTunnelRunner started");
         _runnerId = ++__runnerId;
+        __forwarderId = i2ps.hashCode();
         setName("I2PTunnelRunner " + _runnerId);
         start();
     }
@@ -93,48 +115,77 @@ public class I2PTunnelRunner extends I2PThread implements I2PSocket.SocketErrorL
     public void run() {
         try {
             InputStream in = s.getInputStream();
-            OutputStream out = new BufferedOutputStream(s.getOutputStream(), NETWORK_BUFFER_SIZE);
+            OutputStream out = s.getOutputStream(); // = new BufferedOutputStream(s.getOutputStream(), NETWORK_BUFFER_SIZE);
             i2ps.setSocketErrorListener(this);
             InputStream i2pin = i2ps.getInputStream();
-            OutputStream i2pout = new BufferedOutputStream(i2ps.getOutputStream(), MAX_PACKET_SIZE);
-            if (initialData != null) {
+            OutputStream i2pout = i2ps.getOutputStream(); //new BufferedOutputStream(i2ps.getOutputStream(), MAX_PACKET_SIZE);
+            if (initialI2PData != null) {
                 synchronized (slock) {
-                    i2pout.write(initialData);
-                    i2pout.flush();
+                    i2pout.write(initialI2PData);
+                    //i2pout.flush();
                 }
             }
-            Thread t1 = new StreamForwarder(in, i2pout);
-            Thread t2 = new StreamForwarder(i2pin, out);
+            if (initialSocketData != null) {
+                out.write(initialSocketData);
+            }
+            if (_log.shouldLog(Log.DEBUG))
+                _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();
                 }
             }
+            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();
-            s = null;
             i2ps.close();
-            i2ps = null;
-            t1.join();
-            t2.join();
+            t1.join(30*1000);
+            t2.join(30*1000);
         } catch (InterruptedException ex) {
-            _log.error("Interrupted", ex);
+            if (_log.shouldLog(Log.ERROR))
+                _log.error("Interrupted", ex);
         } catch (IOException ex) {
-            ex.printStackTrace();
-            _log.debug("Error forwarding", ex);
+            if (_log.shouldLog(Log.DEBUG))
+                _log.debug("Error forwarding", ex);
         } catch (Exception e) {
-            _log.error("Internal error", e);
+            if (_log.shouldLog(Log.ERROR))
+                _log.error("Internal error", e);
         } finally {
+            removeRef();
             try {
-                if (s != null) s.close();
-                if (i2ps != null) i2ps.close();
+                if (s != null)
+                    s.close();
             } catch (IOException ex) {
-                ex.printStackTrace();
-                _log.error("Could not close socket", ex);
+                if (_log.shouldLog(Log.ERROR))
+                    _log.error("Could not close java socket", ex);
+            }
+            if (i2ps != null) {
+                try {
+                    i2ps.close();
+                } catch (IOException ex) {
+                    if (_log.shouldLog(Log.ERROR))
+                        _log.error("Could not close I2PSocket", ex);
+                }
+                i2ps.setSocketErrorListener(null);
             }
         }
     }
-
+    
     public void errorOccurred() {
         synchronized (finishLock) {
             finished = true;
@@ -142,69 +193,116 @@ public class I2PTunnelRunner extends I2PThread implements I2PSocket.SocketErrorL
         }
     }
     
-    private volatile long __forwarderId = 0;
+    private void removeRef() {
+        if (sockList != null) {
+            synchronized (slock) {
+                boolean removed = sockList.remove(i2ps);
+                //System.out.println("Removal of i2psocket " + i2ps + " successful? " 
+                //                   + removed + " remaining: " + sockList.size());
+            }
+        }
+    }
     
     private class StreamForwarder extends I2PThread {
 
         InputStream in;
         OutputStream out;
+        String direction;
+        private boolean _toI2P;
+        private ByteCache _cache;
 
-        private StreamForwarder(InputStream in, OutputStream out) {
+        private StreamForwarder(InputStream in, OutputStream out, boolean toI2P) {
             this.in = in;
             this.out = out;
+            _toI2P = toI2P;
+            direction = (toI2P ? "toI2P" : "fromI2P");
+            _cache = ByteCache.getInstance(16, NETWORK_BUFFER_SIZE);
             setName("StreamForwarder " + _runnerId + "." + (++__forwarderId));
             start();
         }
 
         public void run() {
-            byte[] buffer = new byte[NETWORK_BUFFER_SIZE];
+            String from = i2ps.getThisDestination().calculateHash().toBase64().substring(0,6);
+            String to = i2ps.getPeerDestination().calculateHash().toBase64().substring(0,6);
+
+            if (_log.shouldLog(Log.DEBUG)) {
+                _log.debug(direction + ": Forwarding between " 
+                           + from + " and " + to);
+            }
+            
+            ByteArray ba = _cache.acquire();
+            byte[] buffer = ba.getData(); // new byte[NETWORK_BUFFER_SIZE];
             try {
                 int len;
                 while ((len = in.read(buffer)) != -1) {
                     out.write(buffer, 0, len);
+                    if (_toI2P)
+                        totalSent += len;
+                    else
+                        totalReceived += len;
 
                     if (len > 0) updateActivity();
 
                     if (in.available() == 0) {
+                        //if (_log.shouldLog(Log.DEBUG))
+                        //    _log.debug("Flushing after sending " + len + " bytes through");
+                        if (_log.shouldLog(Log.DEBUG))
+                            _log.debug(direction + ": " + len + " bytes flushed through to " 
+                                       + i2ps.getPeerDestination().calculateHash().toBase64().substring(0,6));
                         try {
                             Thread.sleep(I2PTunnel.PACKET_DELAY);
                         } catch (InterruptedException e) {
                             e.printStackTrace();
                         }
-                    }
-                    if (in.available() == 0) {
-                        out.flush(); // make sure the data get though
+                        
+                        if (in.available() <= 0)
+                            out.flush(); // make sure the data get though
                     }
                 }
+                //out.flush(); // close() flushes
             } catch (SocketException ex) {
                 // this *will* occur when the other threads closes the socket
                 synchronized (finishLock) {
                     if (!finished) {
-                        _log.debug("Socket closed - error reading and writing",
-                                   ex);
+                        if (_log.shouldLog(Log.DEBUG))
+                            _log.debug(direction + ": Socket closed - error reading and writing",
+                                       ex);
                     }
                 }
             } catch (InterruptedIOException ex) {
-                _log.warn("Closing connection due to timeout (error: \""
-                          + ex.getMessage() + "\")");
+                if (_log.shouldLog(Log.WARN))
+                    _log.warn(direction + ": Closing connection due to timeout (error: \""
+                              + ex.getMessage() + "\")");
             } catch (IOException ex) {
-                if (!finished)
-                    _log.error("Error forwarding", ex);
-                else
-                    _log.warn("You may ignore this", ex);
+                if (!finished) {
+                    if (_log.shouldLog(Log.WARN))
+                        _log.warn(direction + ": Error forwarding", ex);
+                }
+                //else
+                //    _log.warn("You may ignore this", ex);
             } finally {
+                if (_log.shouldLog(Log.INFO)) {
+                    _log.info(direction + ": done forwarding between " 
+                              + from + " and " + to);
+                }
                 try {
-                    out.close();
                     in.close();
                 } catch (IOException ex) {
                     if (_log.shouldLog(Log.WARN))
-                        _log.warn("Error closing streams", ex);
+                        _log.warn(direction + ": Error closing input stream", ex);
+                }
+                try {
+                    out.flush();
+                } catch (IOException ioe) {
+                    if (_log.shouldLog(Log.WARN))
+                        _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);
@@ -80,6 +81,7 @@ public class I2PTunnelServer extends I2PTunnelTask implements Runnable {
 
         }
         sockMgr.setName("Server");
+        getTunnel().addSession(sockMgr.getSession());
         l.log("Ready!");
         notifyEvent("openServerResult", "ok");
         open = true;
@@ -130,6 +132,7 @@ public class I2PTunnelServer extends I2PTunnelTask implements Runnable {
             l.log("Shutting down server " + toString());
             try {
                 if (i2pss != null) i2pss.close();
+                getTunnel().removeSession(sockMgr.getSession());
                 sockMgr.getSession().destroySession();
             } catch (I2PException ex) {
                 _log.error("Error destroying the session", ex);
@@ -146,6 +149,7 @@ public class I2PTunnelServer extends I2PTunnelTask implements Runnable {
             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();
             }
@@ -176,7 +180,7 @@ public class I2PTunnelServer extends I2PTunnelTask implements Runnable {
                 _handleSocket.setReadTimeout(readTimeout);
                 Socket s = new Socket(remoteHost, remotePort);
                 afterSocket = I2PAppContext.getGlobalContext().clock().now();
-                new I2PTunnelRunner(s, _handleSocket, slock, null);
+                new I2PTunnelRunner(s, _handleSocket, slock, null, null);
             } catch (SocketException ex) {
                 try {
                     _handleSocket.close();

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

@@ -64,6 +64,7 @@ public abstract class I2PTunnelTask implements EventDispatcher {
 
     public void disconnected(I2PSession session) {
         routerDisconnected();
+        getTunnel().removeSession(session);
     }
 
     public void errorOccurred(I2PSession session, String message, Throwable error) {

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

@@ -8,12 +8,15 @@ import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Properties;
+import java.util.Random;
 
 import net.i2p.I2PAppContext;
 import net.i2p.I2PException;
 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;
 
 /**
@@ -27,7 +30,9 @@ public class TunnelController implements Logging {
     private Properties _config;
     private I2PTunnel _tunnel;
     private List _messages;
+    private List _sessions;
     private boolean _running;
+    private boolean _starting;
     
     /**
      * Create a new controller for a tunnel out of the specific config options.
@@ -39,7 +44,7 @@ public class TunnelController implements Logging {
      * @param prefix beginning of key values that are relevent to this tunnel
      */
     public TunnelController(Properties config, String prefix) {
-        this(config, prefix, false);
+        this(config, prefix, true);
     }
     /**
      * 
@@ -53,12 +58,19 @@ public class TunnelController implements Logging {
         setConfig(config, prefix);
         _messages = new ArrayList(4);
         _running = false;
-        if (createKey)
+        if (createKey && ("server".equals(getType()) || "httpserver".equals(getType())) )
             createPrivateKey();
+        _starting = getStartOnLoad();
     }
     
     private void createPrivateKey() {
         I2PClient client = I2PClientFactory.createClient();
+        String filename = getPrivKeyFile();
+        if ( (filename == null) || (filename.trim().length() <= 0) ) {
+            log("No filename specified for the private key");
+            return;
+        }
+        
         File keyFile = new File(getPrivKeyFile());
         if (keyFile.exists()) {
             log("Not overwriting existing private keys in " + keyFile.getAbsolutePath());
@@ -88,11 +100,27 @@ 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)
      *
      */
     public void startTunnel() {
+        _starting = true;
+        try {
+            doStartTunnel();
+        } catch (Exception e) {
+            _log.error("Error starting up the tunnel", e);
+            log("Error starting up the tunnel - " + e.getMessage());
+        }
+        _starting = false;
+    }
+    private void doStartTunnel() {
         if (_running) {
             if (_log.shouldLog(Log.INFO))
                 _log.info("Already running");
@@ -111,8 +139,10 @@ public class TunnelController implements Logging {
             startClient();
         } else if ("server".equals(type)) {
             startServer();
+        } else if ("httpserver".equals(type)) {
+            startHttpServer();
         } else {
-            if (_log.shouldLog(Log.WARN))
+            if (_log.shouldLog(Log.ERROR))
                 _log.error("Cannot start tunnel - unknown type [" + type + "]");
         }
     }
@@ -127,9 +157,42 @@ public class TunnelController implements Logging {
             _tunnel.runHttpClient(new String[] { listenPort }, this);
         else
             _tunnel.runHttpClient(new String[] { listenPort, proxyList }, this);
+        acquire();
         _running = true;
     }
     
+    /** 
+     * Note the fact that we are using some sessions, so that they dont get
+     * closed by some other tunnels
+     */
+    private void acquire() {
+        List sessions = _tunnel.getSessions();
+        if (sessions != null) {
+            for (int i = 0; i < sessions.size(); i++) {
+                I2PSession session = (I2PSession)sessions.get(i);
+                TunnelControllerGroup.getInstance().acquire(this, session);
+            }
+            _sessions = sessions;
+        } else {
+            _log.error("No sessions to acquire?");
+        }
+    }
+    
+    /** 
+     * Note the fact that we are no longer using some sessions, and if
+     * no other tunnels are using them, close them.
+     */
+    private void release() {
+        if (_sessions != null) {
+            for (int i = 0; i < _sessions.size(); i++) {
+                I2PSession s = (I2PSession)_sessions.get(i);
+                TunnelControllerGroup.getInstance().release(this, s);
+            }
+        } else {
+            _log.error("No sessions to release?");
+        }
+    }
+    
     private void startClient() {
         setI2CPOptions();
         setSessionOptions();
@@ -137,6 +200,7 @@ public class TunnelController implements Logging {
         String listenPort = getListenPort(); 
         String dest = getTargetDestination();
         _tunnel.runClient(new String[] { listenPort, dest }, this);
+        acquire();
         _running = true;
     }
 
@@ -147,6 +211,19 @@ public class TunnelController implements Logging {
         String targetPort = getTargetPort(); 
         String privKeyFile = getPrivKeyFile(); 
         _tunnel.runServer(new String[] { targetHost, targetPort, privKeyFile }, this);
+        acquire();
+        _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;
     }
     
@@ -177,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;
@@ -184,6 +264,7 @@ public class TunnelController implements Logging {
     
     public void stopTunnel() {
         _tunnel.runClose(new String[] { "forced", "all" }, this);
+        release();
         _running = false;
     }
     
@@ -237,12 +318,15 @@ 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"); }
     public String getProxyList() { return _config.getProperty("proxyList"); }
+    public boolean getStartOnLoad() { return "true".equalsIgnoreCase(_config.getProperty("startOnLoad", "true")); }
     
     public boolean getIsRunning() { return _running; }
+    public boolean getIsStarting() { return _starting; }
     
     public void getSummary(StringBuffer buf) {
         String type = getType();
@@ -252,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);
     }
@@ -305,10 +391,47 @@ 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) )
             buf.append("Network options: ").append(opts).append("<br />\n");
+        if (_running) {
+            List sessions = _tunnel.getSessions();
+            for (int i = 0; i < sessions.size(); i++) {
+                I2PSession session = (I2PSession)sessions.get(i);
+                Destination dest = session.getMyDestination();
+                if (dest != null) {
+                    buf.append("Destination hash: ").append(dest.calculateHash().toBase64()).append("<br />\n");
+                    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");
+                        long val = new Random().nextLong();
+                        if (val < 0) val = 0 - val;
+                        buf.append("<br />You can <a href=\"http://temp").append(val);
+                        buf.append(".i2p/?i2paddresshelper=").append(dest.toBase64()).append("\">view</a>");
+                        buf.append(" it in a browser (only when you're using the eepProxy)\n");
+                        buf.append("<br />If you are going to share this on IRC, you need to split it up:<br />\n");
+                        String str = dest.toBase64();
+                        buf.append(str.substring(0, str.length()/2)).append("<br />\n");
+                        buf.append(str.substring(str.length()/2)).append("<br />\n");
+                        buf.append("You can also post it to <a href=\"http://forum.i2p/viewforum.php?f=16\">Eepsite announcement forum</a><br />");
+                    }
+                }
+            }
+        }
     }
     
     public void log(String s) {

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

@@ -8,13 +8,21 @@ import java.io.IOException;
 import java.io.InputStreamReader;
 
 import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Properties;
+import java.util.Set;
 import java.util.TreeMap;
 
 import net.i2p.I2PAppContext;
+import net.i2p.client.I2PSession;
+import net.i2p.client.I2PSessionException;
+import net.i2p.data.DataHelper;
+import net.i2p.util.I2PThread;
 import net.i2p.util.Log;
 
 /**
@@ -24,13 +32,49 @@ import net.i2p.util.Log;
  */
 public class TunnelControllerGroup {
     private Log _log;
-    private List _controllers;
-    private static TunnelControllerGroup _instance = new TunnelControllerGroup();
-    public static TunnelControllerGroup getInstance() { return _instance; }
+    private static TunnelControllerGroup _instance;
+    static final String DEFAULT_CONFIG_FILE = "i2ptunnel.config";
     
-    private TunnelControllerGroup() { 
+    private List _controllers;
+    private String _configFile = DEFAULT_CONFIG_FILE;
+    
+    /** 
+     * Map of I2PSession to a Set of TunnelController objects 
+     * using the session (to prevent closing the session until
+     * no more tunnels are using it)
+     *
+     */
+    private Map _sessions;
+    
+    public static TunnelControllerGroup getInstance() { 
+        synchronized (TunnelControllerGroup.class) {
+            if (_instance == null)
+                _instance = new TunnelControllerGroup(DEFAULT_CONFIG_FILE);
+            return _instance; 
+        }
+    }
+
+    private TunnelControllerGroup(String configFile) {
         _log = I2PAppContext.getGlobalContext().logManager().getLog(TunnelControllerGroup.class);
-        _controllers = new ArrayList();
+        _controllers = Collections.synchronizedList(new ArrayList());
+        _configFile = configFile;
+        _sessions = new HashMap(4);
+        loadControllers(_configFile);
+    }
+
+    public static void main(String args[]) {
+        synchronized (TunnelControllerGroup.class) {
+            if (_instance != null) return; // already loaded through the web
+            
+            if ( (args == null) || (args.length <= 0) ) {
+                _instance = new TunnelControllerGroup(DEFAULT_CONFIG_FILE);
+            } else if (args.length == 1) {
+                _instance = new TunnelControllerGroup(args[0]);
+            } else {
+                System.err.println("Usage: TunnelControllerGroup [filename]");
+                return;
+            }
+        }
     }
     
     /**
@@ -54,10 +98,29 @@ public class TunnelControllerGroup {
             _controllers.add(controller);
             i++;
         }
+        I2PThread startupThread = new I2PThread(new StartControllers(), "Startup tunnels");
+        startupThread.start();
+        
         if (_log.shouldLog(Log.INFO))
             _log.info(i + " controllers loaded from " + configFile);
     }
     
+    private class StartControllers implements Runnable {
+        public void run() {
+            for (int i = 0; i < _controllers.size(); i++) {
+                TunnelController controller = (TunnelController)_controllers.get(i);
+                if (controller.getStartOnLoad())
+                    controller.startTunnel();
+            }
+        }
+    }
+    
+    
+    public void reloadControllers() {
+        unloadControllers();
+        loadControllers(_configFile);
+    }
+    
     /**
      * Stop and remove reference to all known tunnels (but dont delete any config
      * file or do other silly things)
@@ -103,7 +166,6 @@ public class TunnelControllerGroup {
             controller.stopTunnel();
             msgs.addAll(controller.clearMessages());
         }
-        
         if (_log.shouldLog(Log.INFO))
             _log.info(_controllers.size() + " controllers stopped");
         return msgs;
@@ -118,10 +180,10 @@ 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());
         }
-        
+
         if (_log.shouldLog(Log.INFO))
             _log.info(_controllers.size() + " controllers started");
         return msgs;
@@ -158,11 +220,20 @@ public class TunnelControllerGroup {
         return msgs;
     }
     
+    /**
+     * Save the configuration of all known tunnels to the default config 
+     * file
+     *
+     */
+    public void saveConfig() {
+        saveConfig(_configFile);
+    }
     /**
      * Save the configuration of all known tunnels to the given file
      *
      */
     public void saveConfig(String configFile) {
+        _configFile = configFile;
         File cfgFile = new File(configFile);
         File parent = cfgFile.getParentFile();
         if ( (parent != null) && (!parent.exists()) )
@@ -210,33 +281,13 @@ public class TunnelControllerGroup {
         }
         
         Properties props = new Properties();
-        FileInputStream fis = null;
         try {
-            fis = new FileInputStream(cfgFile);
-            BufferedReader in = new BufferedReader(new InputStreamReader(fis));
-            String line = null;
-            while ( (line = in.readLine()) != null) {
-                line = line.trim();
-                if (line.length() <= 0) continue;
-                if (line.startsWith("#") || line.startsWith(";"))
-                    continue;
-                int eq = line.indexOf('=');
-                if ( (eq <= 0) || (eq >= line.length() - 1) )
-                    continue;
-                String key = line.substring(0, eq);
-                String val = line.substring(eq+1);
-                props.setProperty(key, val);
-            }
-            
-            if (_log.shouldLog(Log.INFO))
-                _log.info("Props loaded with " + props.size() + " lines");
+            DataHelper.loadProps(props, cfgFile);
             return props;
         } catch (IOException ioe) {
             if (_log.shouldLog(Log.ERROR))
                 _log.error("Error reading the controllers from " + configFile, ioe);
             return null;
-        } finally {
-            if (fis != null) try { fis.close(); } catch (IOException ioe) {}
         }
     }
     
@@ -246,4 +297,62 @@ public class TunnelControllerGroup {
      * @return list of TunnelController objects
      */
     public List getControllers() { return _controllers; }
+    
+    
+    /** 
+     * Note the fact that the controller is using the session so that
+     * it isn't destroyed prematurely.
+     *
+     */
+    void acquire(TunnelController controller, I2PSession session) {
+        synchronized (_sessions) {
+            Set owners = (Set)_sessions.get(session);
+            if (owners == null) {
+                owners = new HashSet(1);
+                _sessions.put(session, owners);
+            }
+            owners.add(controller);
+        }
+        if (_log.shouldLog(Log.INFO))
+            _log.info("Acquiring session " + session + " for " + controller);
+
+    }
+    
+    /** 
+     * Note the fact that the controller is no longer using the session, and if
+     * no other controllers are using it, destroy the session.
+     *
+     */
+    void release(TunnelController controller, I2PSession session) {
+        boolean shouldClose = false;
+        synchronized (_sessions) {
+            Set owners = (Set)_sessions.get(session);
+            if (owners != null) {
+                owners.remove(controller);
+                if (owners.size() <= 0) {
+                    if (_log.shouldLog(Log.INFO))
+                        _log.info("After releasing session " + session + " by " + controller + ", no more owners remain");
+                    shouldClose = true;
+                    _sessions.remove(session);
+                } else {
+                    if (_log.shouldLog(Log.INFO))
+                        _log.info("After releasing session " + session + " by " + controller + ", " + owners.size() + " owners remain");
+                    shouldClose = false;
+                }
+            } else {
+                if (_log.shouldLog(Log.WARN))
+                    _log.warn("After releasing session " + session + " by " + controller + ", no owners were even known?!");
+                shouldClose = true;
+            }
+        }
+        if (shouldClose) {
+            try {
+                session.destroySession();
+                if (_log.shouldLog(Log.INFO))
+                    _log.info("Session destroyed: " + session);
+            } catch (I2PSessionException ise) {
+                _log.error("Error closing the client session", ise);
+            }
+        }
+    }
 }

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

@@ -8,7 +8,7 @@ import java.util.Random;
 import java.util.StringTokenizer;
 
 /**
- * Uuuugly... generate the edit/add forms for the various 
+ * Uuuugly code to generate the edit/add forms for the various 
  * I2PTunnel types (httpclient/client/server)
  *
  */
@@ -18,6 +18,7 @@ class WebEditPageFormGenerator {
       "<option value=\"httpclient\">HTTP proxy</option>" +
       "<option value=\"client\">Client tunnel</option>" +
       "<option value=\"server\">Server tunnel</option>" +
+      "<option value=\"httpserver\">HTTP server tunnel</option>" +
       "</select> <input type=\"submit\" value=\"GO\" />" +
       "</form>\n";
     
@@ -42,6 +43,8 @@ class WebEditPageFormGenerator {
             return getEditClientForm(controller, id);
         else if ("server".equals(type))
             return getEditServerForm(controller, id);
+        else if ("httpserver".equals(type))
+            return getEditHttpServerForm(controller, id);
         else
             return "WTF, unknown type [" + type + "]";
     }
@@ -60,10 +63,13 @@ class WebEditPageFormGenerator {
             buf.append("value=\"squid.i2p\" ");
         buf.append("/><br />\n");
         
+        buf.append("<hr />Note: the following options are shared across all client tunnels and");
+        buf.append(" HTTP proxies<br />\n");
+        
         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</i> <input type=\"checkbox\" name=\"removeConfirm\" value=\"true\" />\n");
+        buf.append(" <i>confirm removal:</i> <input type=\"checkbox\" name=\"removeConfirm\" value=\"true\" />\n");
         buf.append("</form>\n");
         return buf.toString();
     }
@@ -80,10 +86,13 @@ class WebEditPageFormGenerator {
             buf.append("value=\"").append(controller.getTargetDestination()).append("\" ");
         buf.append(" /> (either the hosts.txt name or the full base64 destination)<br />\n");
         
+        buf.append("<hr />Note: the following options are shared across all client tunnels and");
+        buf.append(" HTTP proxies<br />\n");
+        
         addOptions(buf, controller);
         buf.append("<input type=\"submit\" name=\"action\" value=\"Save\"><br />\n");
         buf.append("<input type=\"submit\" name=\"action\" value=\"Remove\">\n");
-        buf.append(" <i>confirm</i> <input type=\"checkbox\" name=\"removeConfirm\" value=\"true\" />\n");
+        buf.append(" <i>confirm removal:</i> <input type=\"checkbox\" name=\"removeConfirm\" value=\"true\" />\n");
         buf.append("</form>\n");
         return buf.toString();
     }
@@ -97,7 +106,7 @@ class WebEditPageFormGenerator {
         if ( (controller != null) && (controller.getTargetHost() != null) )
             buf.append("value=\"").append(controller.getTargetHost()).append("\" ");
         else
-            buf.append("value=\"localhost\" ");
+            buf.append("value=\"127.0.0.1\" ");
         buf.append(" /><br />\n");
         
         buf.append("<b>Target port:</b> <input type=\"text\" size=\"4\" name=\"targetPort\" ");
@@ -118,7 +127,49 @@ class WebEditPageFormGenerator {
         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</i> <input type=\"checkbox\" name=\"removeConfirm\" value=\"true\" />\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\" />");
+        }
+        
+        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();
     }
@@ -135,6 +186,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) )
@@ -145,6 +199,13 @@ class WebEditPageFormGenerator {
         if ( (controller != null) && (controller.getDescription() != null) )
             buf.append("value=\"").append(controller.getDescription()).append("\" ");
         buf.append("/><br />\n");
+        
+        buf.append("<b>Start automatically?</b> \n");
+        buf.append("<input type=\"checkbox\" name=\"startOnLoad\" value=\"true\" ");
+        if ( (controller != null) && (controller.getStartOnLoad()) )
+            buf.append(" checked=\"true\" />\n<br />\n");
+        else
+            buf.append(" />\n<br />\n");
     }
 
     /**
@@ -194,9 +255,11 @@ class WebEditPageFormGenerator {
     private static void addOptions(StringBuffer buf, TunnelController controller) {
         int tunnelDepth = 2;
         int numTunnels = 2;
+        int connectDelay = 0;
+        int maxWindowSize = -1;
         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);
@@ -204,7 +267,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);
@@ -212,6 +275,22 @@ class WebEditPageFormGenerator {
                     numTunnels = 2;
                 }
             }
+            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>Tunnel depth:</b> ");
@@ -251,12 +330,27 @@ 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>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");
+        
         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=\"");
@@ -273,8 +367,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

@@ -29,6 +29,7 @@ public class WebEditPageHelper {
     private String _i2cpPort;
     private String _tunnelDepth;
     private String _tunnelCount;
+    private boolean _connectDelay;
     private String _customOptions;
     private String _proxyList;
     private String _port;
@@ -37,9 +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;
@@ -49,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"
      */
@@ -137,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);
@@ -156,6 +173,19 @@ public class WebEditPageHelper {
     public void setRemoveConfirm(String moo) {
         _removeConfirmed = true;
     }
+    /**
+     * If called with any value, we want this tunnel to start whenever it is
+     * loaded (aka right now and whenever the router is started up)
+     */
+    public void setStartOnLoad(String moo) {
+        _startOnLoad = true;
+    }
+    public void setConnectDelay(String moo) {
+        _connectDelay = true;
+    }
+    public void setProfile(String profile) { 
+        _profile = profile; 
+    }
     
     /**
      * Process the form and display any resulting messages
@@ -207,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))
@@ -240,15 +273,50 @@ public class WebEditPageHelper {
             // creating new
             cur = new TunnelController(config, "", _privKeyGenerate);
             TunnelControllerGroup.getInstance().addController(cur);
+            if (cur.getStartOnLoad())
+                cur.startTunnelBackground();
         } else {
             cur.setConfig(config, "");
         }
         
+        if ("httpclient".equals(cur.getType()) || "client".equals(cur.getType())) {
+            // all clients use the same I2CP session, and as such, use the same
+            // I2CP options
+            List controllers = TunnelControllerGroup.getInstance().getControllers();
+            for (int i = 0; i < controllers.size(); i++) {
+                TunnelController c = (TunnelController)controllers.get(i);
+                if (c == cur) continue;
+                if ("httpclient".equals(c.getType()) || "client".equals(c.getType())) {
+                    Properties cOpt = c.getConfig("");
+                    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);
+                    }
+                    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, "");
+                }
+            }
+        }
         
         return getMessages(doSave());
     }
     private List doSave() { 
-        TunnelControllerGroup.getInstance().saveConfig(WebStatusPageHelper.CONFIG_FILE);
+        TunnelControllerGroup.getInstance().saveConfig();
         return TunnelControllerGroup.getInstance().clearAllMessages();
     }
     
@@ -287,10 +355,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;
     }
     
@@ -314,16 +390,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);
             }
         }
 
-        if (_tunnelCount != null)
-            config.setProperty("option.tunnels.numInbound", _tunnelCount);
-        if (_tunnelDepth != null)
-            config.setProperty("option.tunnels.depthInbound", _tunnelDepth);
+        config.setProperty("startOnLoad", _startOnLoad + "");
+        
+        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,23 +14,17 @@ import net.i2p.util.Log;
  *
  */
 public class WebStatusPageHelper {
+    private I2PAppContext _context;
     private Log _log;
     private String _action;
     private int _controllerNum;
-    private static boolean _configLoaded = false;
-    
-    static final String CONFIG_FILE = "i2ptunnel.cfg";
+    private long _nonce;
     
     public WebStatusPageHelper() {
+        _context = I2PAppContext.getGlobalContext();
         _action = null;
         _controllerNum = -1;
-        _log = I2PAppContext.getGlobalContext().logManager().getLog(WebStatusPageHelper.class);
-        synchronized (WebStatusPageHelper.class) {
-            if (!_configLoaded) {
-                reloadConfig();
-                _configLoaded = true;
-            }
-        }
+        _log = _context.logManager().getLog(WebStatusPageHelper.class);
     }
     
     public void setAction(String action) {
@@ -45,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 {
@@ -56,26 +58,48 @@ public class WebStatusPageHelper {
     }
     
     public String getSummaryList() {
+        TunnelControllerGroup group = TunnelControllerGroup.getInstance();
+        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 = TunnelControllerGroup.getInstance().getControllers();
+        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");
@@ -85,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))
@@ -101,34 +128,59 @@ public class WebStatusPageHelper {
             return "Action <i>" + _action + "</i> unknown";
     }
     private String stopAll() {
-        List msgs = TunnelControllerGroup.getInstance().stopAllControllers();
+        TunnelControllerGroup group = TunnelControllerGroup.getInstance();
+        if (group == null)
+            return "<b>I2PTunnel instances not yet started - please be patient</b>\n";
+        
+        List msgs = group.stopAllControllers();
         return getMessages(msgs);
     }
     private String startAll() {
-        List msgs = TunnelControllerGroup.getInstance().startAllControllers();
+        TunnelControllerGroup group = TunnelControllerGroup.getInstance();
+        if (group == null)
+            return "<b>I2PTunnel instances not yet started - please be patient</b>\n";
+        
+        List msgs = group.startAllControllers();
         return getMessages(msgs);
     }
     private String restartAll() {
-        List msgs = TunnelControllerGroup.getInstance().restartAllControllers();
+        TunnelControllerGroup group = TunnelControllerGroup.getInstance();
+        if (group == null)
+            return "<b>I2PTunnel instances not yet started - please be patient</b>\n";
+        
+        List msgs = group.restartAllControllers();
         return getMessages(msgs);
     }
     private String reloadConfig() {
-        TunnelControllerGroup.getInstance().unloadControllers();
-        TunnelControllerGroup.getInstance().loadControllers(CONFIG_FILE);
+        TunnelControllerGroup group = TunnelControllerGroup.getInstance();
+        if (group == null)
+            return "<b>I2PTunnel instances not yet started - please be patient</b>\n";
+        
+        group.reloadControllers();
         return "Config reloaded";
     }
     private String start() {
+        TunnelControllerGroup group = TunnelControllerGroup.getInstance();
+        if (group == null)
+            return "<b>I2PTunnel instances not yet started - please be patient</b>\n";
+        
         if (_controllerNum < 0) return "Invalid tunnel";
-        List controllers = TunnelControllerGroup.getInstance().getControllers();
+        
+        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());
     }
     
     private String stop() {
+        TunnelControllerGroup group = TunnelControllerGroup.getInstance();
+        if (group == null)
+            return "<b>I2PTunnel instances not yet started - please be patient</b>\n";
+        
         if (_controllerNum < 0) return "Invalid tunnel";
-        List controllers = TunnelControllerGroup.getInstance().getControllers();
+        
+        List controllers = group.getControllers();
         if (_controllerNum >= controllers.size()) return "Invalid tunnel";
         TunnelController controller = (TunnelController)controllers.get(_controllerNum);
         controller.stopTunnel();
@@ -136,7 +188,11 @@ public class WebStatusPageHelper {
     }
     
     private String getMessages() {
-        return getMessages(TunnelControllerGroup.getInstance().clearAllMessages());
+        TunnelControllerGroup group = TunnelControllerGroup.getInstance();
+        if (group == null)
+            return "";
+        
+        return getMessages(group.clearAllMessages());
     }
     
     private String getMessages(List msgs) {

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

@@ -47,7 +47,7 @@ public class I2PSOCKSTunnel extends I2PTunnelClientBase {
             SOCKSServer serv = SOCKSServerFactory.createSOCKSServer(s);
             Socket clientSock = serv.getClientSocket();
             I2PSocket destSock = serv.getDestinationI2PSocket();
-            new I2PTunnelRunner(clientSock, destSock, sockLock, null);
+            new I2PTunnelRunner(clientSock, destSock, sockLock, null, mySockets);
         } catch (SOCKSException e) {
             _log.error("Error from SOCKS connection: " + e.getMessage());
             closeSocket(s);

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

@@ -81,7 +81,7 @@ public abstract class SOCKSServer {
             if (connHostName.toLowerCase().endsWith(".i2p")) {
                 _log.debug("connecting to " + connHostName + "...");
                 I2PSocketManager sm = I2PSocketManagerFactory.createManager();
-                destSock = sm.connect(I2PTunnel.destFromName(connHostName), new I2PSocketOptions());
+                destSock = sm.connect(I2PTunnel.destFromName(connHostName), null);
                 confirmConnection();
                 _log.debug("connection confirmed - exchanging data...");
             } else {

apps/i2ptunnel/jsp/index.jsp

@@ -7,16 +7,10 @@
 
 <jsp:useBean class="net.i2p.i2ptunnel.WebStatusPageHelper" id="helper" scope="request" />
 <jsp:setProperty name="helper" property="*" />
+<h2>Messages since last page load:</h2>
 <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> 
@@ -24,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/ByteCollector.java

@@ -5,7 +5,7 @@ package net.i2p.client.streaming;
  * so care should be taken when using in a multithreaded environment.
  *
  */
-public class ByteCollector {
+class ByteCollector {
     byte[] contents;
     int size;
 

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

@@ -24,7 +24,7 @@ class I2PSocketImpl implements I2PSocket {
     public static final int MAX_PACKET_SIZE = 1024 * 32;
     public static final int PACKET_DELAY = 100;
 
-    private I2PSocketManager manager;
+    private I2PSocketManagerImpl manager;
     private Destination local;
     private Destination remote;
     private String localID;
@@ -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;
@@ -69,14 +69,14 @@ class I2PSocketImpl implements I2PSocket {
      * @param outgoing did we initiate the connection (true) or did we receive it (false)?
      * @param localID what is our half of the socket ID?
      */
-    public I2PSocketImpl(Destination peer, I2PSocketManager mgr, boolean outgoing, String localID) {
+    public I2PSocketImpl(Destination peer, I2PSocketManagerImpl mgr, boolean outgoing, String localID) {
         this.outgoing = outgoing;
         manager = mgr;
         remote = peer;
         _socketId = ++__socketId;
         local = mgr.getSession().getMyDestination();
         String us = mgr.getSession().getMyDestination().calculateHash().toBase64().substring(0,4);
-        String name = us + (outgoing ? "->" : "<-") + peer.calculateHash().toBase64().subSequence(0,4);
+        String name = us + (outgoing ? "->" : "<-") + peer.calculateHash().toBase64().substring(0,4);
         in = new I2PInputStream(name + " in");
         I2PInputStream pin = new I2PInputStream(name + " out");
         out = new I2POutputStream(pin);
@@ -157,7 +157,7 @@ class I2PSocketImpl implements I2PSocket {
              
                 if (_log.shouldLog(Log.DEBUG))
                     _log.debug("TIMING: RemoteID set to " 
-                               + I2PSocketManager.getReadableForm(remoteID) + " for "
+                               + I2PSocketManagerImpl.getReadableForm(remoteID) + " for "
                                + this.hashCode());
             }
             return remoteID;
@@ -234,7 +234,7 @@ class I2PSocketImpl implements I2PSocket {
     }
 
     /**
-     * Close the socket from the I2P side, e. g. by a close packet.
+     * Close the socket from the I2P side (by a close packet)
      */
     protected void internalClose() {
         synchronized (flagLock) {
@@ -249,9 +249,9 @@ class I2PSocketImpl implements I2PSocket {
 
     private byte getMask(int add) {
         if (outgoing)
-            return (byte)(I2PSocketManager.DATA_IN + (byte)add);
+            return (byte)(I2PSocketManagerImpl.DATA_IN + (byte)add);
         else
-            return (byte)(I2PSocketManager.DATA_OUT + (byte)add);
+            return (byte)(I2PSocketManagerImpl.DATA_OUT + (byte)add);
     }
 
     public void setOptions(I2PSocketOptions options) {
@@ -284,7 +284,7 @@ class I2PSocketImpl implements I2PSocket {
         in.setReadTimeout(ms);
     }
     
-    public void setSocketErrorListener(SocketErrorListener lsnr) {
+    public void setSocketErrorListener(I2PSocket.SocketErrorListener lsnr) {
         _socketErrorListener = lsnr;
     }
     
@@ -346,7 +346,7 @@ class I2PSocketImpl implements I2PSocket {
             }
             boolean timedOut = false;
 
-            while (read.length == 0) {
+            while ( (read.length == 0) && (!inStreamClosed) ) {
                 synchronized (flagLock) {
                     if (closed) {
                         if (_log.shouldLog(Log.DEBUG))
@@ -378,6 +378,9 @@ class I2PSocketImpl implements I2PSocket {
                 }
             }
             if (read.length > len) throw new RuntimeException("BUG");
+            if ( (inStreamClosed) && ( (read == null) || (read.length <= 0) ) )
+                return -1;
+            
             System.arraycopy(read, 0, b, off, read.length);
 
             if (_log.shouldLog(Log.DEBUG)) {
@@ -456,6 +459,8 @@ class I2PSocketImpl implements I2PSocket {
             synchronized (I2PInputStream.this) {
                 I2PInputStream.this.notifyAll();
             }
+            if (_log.shouldLog(Log.DEBUG))
+                _log.debug(getStreamPrefix() + "After insert " + len + " bytes into queue: " + hashCode());
         }
 
         public void notifyClosed() {
@@ -471,6 +476,8 @@ class I2PSocketImpl implements I2PSocket {
                 inStreamClosed = true;
                 bc.notifyAll();
             }
+            if (_log.shouldLog(Log.DEBUG))
+                _log.debug(getStreamPrefix() + "After close");
         }
 
     }
@@ -518,10 +525,21 @@ class I2PSocketImpl implements I2PSocket {
          */
         private boolean handleNextPacket(ByteCollector bc, byte buffer[]) 
                                          throws IOException, I2PSessionException {
+            if (_log.shouldLog(Log.DEBUG))
+                _log.debug(getPrefix() + ":" + Thread.currentThread().getName() + "handleNextPacket");
             int len = in.read(buffer);
-            int bcsize = bc.getCurrentSize();
+            int bcsize = 0;
+            synchronized (bc) {
+                bcsize = bc.getCurrentSize();
+            }
+
+            if (_log.shouldLog(Log.DEBUG))
+                _log.debug(getPrefix() + ":" + Thread.currentThread().getName() + "handleNextPacket len=" + len + " bcsize=" + bcsize);
+
             if (len != -1) {
-                bc.append(buffer, len);
+                synchronized (bc) {
+                    bc.append(buffer, len);
+                }
             } else if (bcsize == 0) {
                 // nothing left in the buffer, and read(..) got EOF (-1).
                 // the bart the
@@ -529,7 +547,7 @@ class I2PSocketImpl implements I2PSocket {
             }
             if ((bcsize < MAX_PACKET_SIZE) && (in.available() == 0)) {
                 if (_log.shouldLog(Log.DEBUG))
-                    _log.debug(getPrefix() + "Runner Point d: " + hashCode());
+                    _log.debug(getPrefix() + ":" + Thread.currentThread().getName() + "Runner Point d: " + hashCode());
 
                 try {
                     Thread.sleep(PACKET_DELAY);
@@ -538,19 +556,22 @@ class I2PSocketImpl implements I2PSocket {
                 }
             }
             if ((bcsize >= MAX_PACKET_SIZE) || (in.available() == 0)) {
-                byte[] data = bc.startToByteArray(MAX_PACKET_SIZE);
+                byte data[] = null;
+                synchronized (bc) {
+                    data = bc.startToByteArray(MAX_PACKET_SIZE);
+                }
                 if (data.length > 0) {
                     if (_log.shouldLog(Log.DEBUG))
-                        _log.debug(getPrefix() + "Message size is: " + data.length);
+                        _log.debug(getPrefix() + ":" + Thread.currentThread().getName() + "Message size is: " + data.length);
                     boolean sent = sendBlock(data);
                     if (!sent) {
                         if (_log.shouldLog(Log.WARN))
-                            _log.warn(getPrefix() + "Error sending message to peer.  Killing socket runner");
+                            _log.warn(getPrefix() + ":" + Thread.currentThread().getName() + "Error sending message to peer.  Killing socket runner");
                         errorOccurred();
                         return false;
                     } else {
                         if (_log.shouldLog(Log.DEBUG))
-                            _log.debug(getPrefix() + "Message sent to peer");
+                            _log.debug(getPrefix() + ":" + Thread.currentThread().getName() + "Message sent to peer");
                     }
                 }
             }
@@ -567,7 +588,14 @@ class I2PSocketImpl implements I2PSocket {
                 while (keepHandling) {
                     keepHandling = handleNextPacket(bc, buffer);
                     packetsHandled++;
+                    if (_log.shouldLog(Log.DEBUG))
+                        _log.debug(getPrefix() + ":" + Thread.currentThread().getName() 
+                                   + "Packets handled: " + packetsHandled);
                 }
+                if (_log.shouldLog(Log.INFO))
+                    _log.info(getPrefix() + ":" + Thread.currentThread().getName() 
+                               + "After handling packets, we're done.  Packets handled: " + packetsHandled);
+                
                 if ((bc.getCurrentSize() > 0) && (packetsHandled > 1)) {
                     if (_log.shouldLog(Log.WARN))
                         _log.warn(getPrefix() + "We lost some data queued up due to a network send error (input stream: " 
@@ -583,16 +611,20 @@ class I2PSocketImpl implements I2PSocket {
                 } // FIXME: Race here?
                 if (sc) {
                     if (_log.shouldLog(Log.INFO))
-                        _log.info(getPrefix() + "Sending close packet: (we started? " + outgoing + ") after reading " + _bytesRead + " and writing " + _bytesWritten);
-                    byte[] packet = I2PSocketManager.makePacket(getMask(0x02), remoteID, new byte[0]);
+                        _log.info(getPrefix() + ":" + Thread.currentThread().getName() 
+                                  + "Sending close packet: (we started? " + outgoing 
+                                  + ") after reading " + _bytesRead + " and writing " + _bytesWritten);
+                    byte[] packet = I2PSocketManagerImpl.makePacket(getMask(0x02), remoteID, new byte[0]);
                     boolean sent = manager.getSession().sendMessage(remote, packet);
                     if (!sent) {
                         if (_log.shouldLog(Log.WARN))
-                            _log.warn(getPrefix() + "Error sending close packet to peer");
+                            _log.warn(getPrefix() + ":" + Thread.currentThread().getName() 
+                                      + "Error sending close packet to peer");
                         errorOccurred();
                     }
                 }
                 manager.removeSocket(I2PSocketImpl.this);
+                internalClose();
             } catch (InterruptedIOException ex) {
                 _log.error(getPrefix() + "BUG! read() operations should not timeout!", ex);
             } catch (IOException ex) {
@@ -613,7 +645,7 @@ class I2PSocketImpl implements I2PSocket {
                 _log.error(getPrefix() + "NULL REMOTEID");
                 return false;
             }
-            byte[] packet = I2PSocketManager.makePacket(getMask(0x00), remoteID, data);
+            byte[] packet = I2PSocketManagerImpl.makePacket(getMask(0x00), remoteID, data);
             boolean sent;
             synchronized (flagLock) {
                 if (closed2) return false;

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

@@ -13,6 +13,7 @@ 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;
@@ -34,62 +35,8 @@ import net.i2p.util.Log;
  * or receive any messages with its .receiveMessage
  *
  */
-public class I2PSocketManager implements I2PSessionListener {
-    private I2PAppContext _context;
-    private Log _log;
-    private I2PSession _session;
-    private I2PServerSocketImpl _serverSocket = null;
-    private Object lock = new Object(); // for locking socket lists
-    private HashMap _outSockets;
-    private HashMap _inSockets;
-    private I2PSocketOptions _defaultOptions;
-    private long _acceptTimeout;
-    private String _name;
-    private static int __managerId = 0;
-    
-    public static final short ACK = 0x51;
-    public static final short CLOSE_OUT = 0x52;
-    public static final short DATA_OUT = 0x50;
-    public static final short SYN = 0xA1;
-    public static final short CLOSE_IN = 0xA2;
-    public static final short DATA_IN = 0xA0;
-    public static final short CHAFF = 0xFF;
-
-    /**
-     * How long to wait for the client app to accept() before sending back CLOSE?
-     * This includes the time waiting in the queue.  Currently set to 5 seconds.
-     */
-    private static final long ACCEPT_TIMEOUT_DEFAULT = 5*1000;
-    
-    public I2PSocketManager() {
-        this("SocketManager " + (++__managerId));
-    }
-    public I2PSocketManager(String name) {
-        _name = name;
-        _session = null;
-        _inSockets = new HashMap(16);
-        _outSockets = new HashMap(16);
-        _acceptTimeout = ACCEPT_TIMEOUT_DEFAULT;
-        _context = I2PAppContext.getGlobalContext();
-        _log = _context.logManager().getLog(I2PSocketManager.class);
-        _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 });
-        _context.statManager().createRateStat("streaming.sent", "How many bytes are sent in the stream?", "streaming", new long[] { 10*60*1000, 60*60*1000, 24*60*60*1000 });
-        _context.statManager().createRateStat("streaming.received", "How many bytes are received in the stream?", "streaming", new long[] { 10*60*1000, 60*60*1000, 24*60*60*1000 });
-        _context.statManager().createRateStat("streaming.transferBalance", "How many streams send more than they receive (positive means more sent, negative means more received)?", "streaming", new long[] { 10*60*1000, 60*60*1000, 24*60*60*1000 });
-        _context.statManager().createRateStat("streaming.synNoAck", "How many times have we sent a SYN but not received an ACK?", "streaming", new long[] { 10*60*1000, 60*60*1000, 24*60*60*1000 });
-        _context.statManager().createRateStat("streaming.ackSendFailed", "How many times have we tried to send an ACK to a SYN and failed?", "streaming", new long[] { 10*60*1000, 60*60*1000, 24*60*60*1000 });
-        _context.statManager().createRateStat("streaming.nackSent", "How many times have we refused a SYN with a NACK?", "streaming", new long[] { 10*60*1000, 60*60*1000, 24*60*60*1000 });
-        _context.statManager().createRateStat("streaming.nackReceived", "How many times have we received a NACK to our SYN?", "streaming", new long[] { 10*60*1000, 60*60*1000, 24*60*60*1000 });
-    }
-
-    public I2PSession getSession() {
-        return _session;
-    }
-
-    public void setSession(I2PSession session) {
-        _session = session;
-        if (session != null) session.setSessionListener(this);
-    }
+public interface I2PSocketManager {
+    public I2PSession getSession();
     
     /**
      * How long should we wait for the client to .accept() a socket before
@@ -97,340 +44,14 @@ public class I2PSocketManager implements I2PSessionListener {
      *
      * @param ms milliseconds to wait, maximum
      */
-    public void setAcceptTimeout(long ms) { _acceptTimeout = ms; }
-    public long getAcceptTimeout() { return _acceptTimeout; }
-
-    public void disconnected(I2PSession session) {
-        _log.info(getName() + ": Disconnected from the session");
-        destroySocketManager();
-    }
-
-    public void errorOccurred(I2PSession session, String message, Throwable error) {
-        _log.error(getName() + ": Error occurred: [" + message + "]", error);
-    }
+    public void setAcceptTimeout(long ms);
+    public long getAcceptTimeout();
+    public void setDefaultOptions(I2PSocketOptions options);
+    public I2PSocketOptions getDefaultOptions();
+    public I2PServerSocket getServerSocket();
     
-    public void messageAvailable(I2PSession session, int msgId, long size) {
-        try {
-            I2PSocketImpl s;
-            byte msg[] = session.receiveMessage(msgId);
-            if (msg.length == 1 && msg[0] == -1) {
-                _log.debug(getName() + ": Ping received");
-                return;
-            }
-            if (msg.length < 4) {
-                _log.error(getName() + ": ==== packet too short ====");
-                return;
-            }
-            int type = msg[0] & 0xff;
-            String id = toString(new byte[] { msg[1], msg[2], msg[3]});
-            byte[] payload = new byte[msg.length - 4];
-            System.arraycopy(msg, 4, payload, 0, payload.length);
-            if (_log.shouldLog(Log.DEBUG))
-                _log.debug(getName() + ": Message read: type = [" + Integer.toHexString(type) 
-                           + "] id = [" + getReadableForm(id)
-                           + "] payload length: [" + payload.length + "]");
-            switch (type) {
-                case ACK:
-                    ackAvailable(id, payload);
-                    return;
-                case CLOSE_OUT:
-                    disconnectAvailable(id, payload);
-                    return;
-                case DATA_OUT:
-                    sendOutgoingAvailable(id, payload);
-                    return;
-                case SYN:
-                    synIncomingAvailable(id, payload, session);
-                    return;
-                case CLOSE_IN:
-                    disconnectIncoming(id, payload);
-                    return;
-                case DATA_IN:
-                    sendIncoming(id, payload);
-                case CHAFF:
-                    // ignore
-                    return;
-                default:
-                    handleUnknown(type, id, payload);
-                    return;
-            }
-        } catch (I2PException ise) {
-            _log.error(getName() + ": Error processing", ise);
-        } catch (IllegalStateException ise) {
-            _log.debug(getName() + ": Error processing", ise);
-        }
-    }
-    
-    /**
-     * We've received an ACK packet (hopefully, in response to a SYN that we 
-     * recently sent out).  Notify the associated I2PSocket that we now have
-     * the remote stream ID (which should get things going, since the handshake
-     * is complete).
-     *
-     */
-    private void ackAvailable(String id, byte payload[]) {
-        long begin = _context.clock().now();
-        I2PSocketImpl s = null;
-        synchronized (lock) {
-            s = (I2PSocketImpl) _outSockets.get(id);
-        }
-
-        if (s == null) {
-            _log.warn(getName() + ": No socket responsible for ACK packet");
-            return;
-        }
-
-        long socketRetrieved = _context.clock().now();
-        
-        String remoteId = null;
-        remoteId = s.getRemoteID(false); 
-
-        if ( (payload.length == 3) && (remoteId == null) ) {
-            String newID = toString(payload);
-            long beforeSetRemId = _context.clock().now();
-            s.setRemoteID(newID);
-            if (_log.shouldLog(Log.DEBUG)) {
-                _log.debug(getName() + ": ackAvailable - socket retrieval took " 
-                           + (socketRetrieved-begin) + "ms, getRemoteId took "
-                           + (beforeSetRemId-socketRetrieved) + "ms, setRemoteId took "
-                           + (_context.clock().now()-beforeSetRemId) + "ms");
-            }
-            return;
-        } else {
-            // (payload.length != 3 || getRemoteId != null)
-            if (_log.shouldLog(Log.WARN)) {
-                if (payload.length != 3)
-                    _log.warn(getName() + ": Ack packet had " + payload.length + " bytes");
-                else
-                    _log.warn(getName() + ": Remote ID already exists? " + remoteId);
-            }
-            if (_log.shouldLog(Log.DEBUG)) {
-                _log.debug(getName() + ": invalid ack - socket retrieval took " 
-                           + (socketRetrieved-begin) + "ms, overall took "
-                           + (_context.clock().now()-begin) + "ms");
-            }
-            return;
-        }
-    }
-    
-    /**
-     * We received a disconnect packet, telling us to tear down the specified
-     * stream.
-     */
-    private void disconnectAvailable(String id, byte payload[]) {
-        I2PSocketImpl s = null;
-        synchronized (lock) {
-            s = (I2PSocketImpl) _outSockets.get(id);
-        }
-        
-        _log.debug(getName() + ": *Disconnect outgoing for socket " + s);
-        try {
-            if (s != null) {
-                if (payload.length > 0) {
-                    _log.debug(getName() + ": Disconnect packet had "
-                               + payload.length + " bytes");
-                }
-                if (s.getRemoteID(false) == null) {
-                    s.setRemoteID(null); // Just to wake up socket
-                    return;
-                }
-                s.internalClose();
-                synchronized (lock) {
-                    _outSockets.remove(id);
-                }
-            }
-            return;
-        } catch (Exception t) {
-            _log.error(getName() + ": Ignoring error on disconnect for socket " + s, t);
-        }
-    }
-    
-    /**
-     * We've received data on a stream we created - toss the data onto
-     * the socket for handling.
-     *
-     * @throws IllegalStateException if the socket isn't open or isn't known
-     */
-    private void sendOutgoingAvailable(String id, byte payload[]) throws IllegalStateException {
-        I2PSocketImpl s = null;
-        synchronized (lock) {
-            s = (I2PSocketImpl) _outSockets.get(id);
-        }
-
-        // packet send outgoing
-        if (_log.shouldLog(Log.DEBUG))
-            _log.debug(getName() + ": *Packet send outgoing [" + payload.length + "] for socket " + s);
-        if (s != null) {
-            s.queueData(payload);
-            return;
-        } else {
-            if (_log.shouldLog(Log.WARN))
-                _log.warn(getName() + ": Null socket with data available");
-            throw new IllegalStateException("Null socket with data available");
-        }
-    }
-    
-    /**
-     * We've received a SYN packet (a request for a new stream).  If the client has 
-     * said they want incoming sockets (by retrieving the serverSocket), the stream
-     * will be ACKed, but if they have not, they'll be NACKed)
-     *
-     * @throws DataFormatException if the destination in the SYN was invalid
-     * @throws I2PSessionException if there was an I2P error sending the ACK or NACK
-     */
-    private void synIncomingAvailable(String id, byte payload[], I2PSession session) 
-                                      throws DataFormatException, I2PSessionException {
-        Destination d = new Destination();
-        d.fromByteArray(payload);
-
-        I2PSocketImpl s = null;
-        boolean acceptConnections = (_serverSocket != null);
-        String newLocalID = null;
-        synchronized (lock) {
-            newLocalID = makeID(_inSockets);
-            if (acceptConnections) {
-                s = new I2PSocketImpl(d, this, false, newLocalID);
-                s.setRemoteID(id);
-            }
-        }    
-        _log.debug(getName() + ": *Syn! for socket " + s);
-        
-        if (!acceptConnections) {
-            // The app did not instantiate an I2PServerSocket
-            byte[] packet = makePacket((byte) CLOSE_OUT, id, toBytes(newLocalID));
-            boolean replySentOk = false;
-            synchronized (_session) {
-                replySentOk = _session.sendMessage(d, packet);
-            }
-            if (!replySentOk) {
-                _log.error(getName() + ": Error sending close to " + d.calculateHash().toBase64()
-                           + " in response to a new con message", 
-                           new Exception("Failed creation"));
-            }
-            _context.statManager().addRateData("streaming.nackSent", 1, 1);
-            return;
-        }
-
-        if (_serverSocket.addWaitForAccept(s, _acceptTimeout)) {
-            _inSockets.put(newLocalID, s);
-            byte[] packet = makePacket((byte) ACK, id, toBytes(newLocalID));
-            boolean replySentOk = false;
-            replySentOk = _session.sendMessage(d, packet);
-            if (!replySentOk) {
-                if (_log.shouldLog(Log.WARN))
-                    _log.warn(getName() + ": Error sending reply to " + d.calculateHash().toBase64()
-                               + " in response to a new con message for socket " + s,
-                               new Exception("Failed creation"));
-                s.internalClose();
-                _context.statManager().addRateData("streaming.ackSendFailed", 1, 1);
-            }
-        } else {
-            // timed out or serverSocket closed
-            byte[] packet = toBytes(" " + id);
-            packet[0] = CLOSE_OUT;
-            boolean nackSent = session.sendMessage(d, packet);
-            if (!nackSent) {
-                _log.warn(getName() + ": Error sending NACK for session creation for socket " + s);
-            }
-            s.internalClose();
-            _context.statManager().addRateData("streaming,nackSent", 1, 1);
-        }
-        return;
-    }
-    
-    /**
-     * We've received a disconnect for a socket we didn't initiate, so kill
-     * the socket.
-     *
-     */
-    private void disconnectIncoming(String id, byte payload[]) {
-        I2PSocketImpl s = null;
-        synchronized (lock) {
-            s = (I2PSocketImpl) _inSockets.get(id);
-            if (payload.length == 0 && s != null) {
-                _inSockets.remove(id);
-            }
-        }
-        
-        _log.debug(getName() + ": *Disconnect incoming for socket " + s);
-        
-        try {
-            if (payload.length == 0 && s != null) {
-                s.internalClose();
-                return;
-            } else {
-                if ( (payload.length > 0) && (_log.shouldLog(Log.ERROR)) )
-                    _log.error(getName() + ": Disconnect packet had " + payload.length + " bytes");
-                if (s != null) 
-                    s.internalClose();
-                return;
-            }
-        } catch (Exception t) {
-            _log.error(getName() + ": Ignoring error on disconnect", t);
-            return;
-        }
-    }
-    
-    /**
-     * We've received data on a stream we received - toss the data onto
-     * the socket for handling.
-     *
-     * @throws IllegalStateException if the socket isn't open or isn't known
-     */
-    private void sendIncoming(String id, byte payload[]) throws IllegalStateException {
-        I2PSocketImpl s = null;
-        synchronized (lock) {
-            s = (I2PSocketImpl) _inSockets.get(id);
-        }
-
-        if (_log.shouldLog(Log.DEBUG))
-            _log.debug(getName() + ": *Packet send incoming [" + payload.length + "] for socket " + s);
-        
-        if (s != null) {
-            s.queueData(payload);
-            return;
-        } else {
-            _log.info(getName() + ": Null socket with data available");
-            throw new IllegalStateException("Null socket with data available");
-        }
-    }
-    
-    /**
-     * Unknown packet.  moo.
-     *
-     */
-    private void handleUnknown(int type, String id, byte payload[]) {
-        _log.error(getName() + ": \n\n=============== Unknown packet! " + "============" 
-                   + "\nType: " + (int) type
-                   + "\nID:   " + getReadableForm(id) 
-                   + "\nBase64'ed Data: " + Base64.encode(payload)
-                   + "\n\n\n");
-        if (id != null) {
-            synchronized (lock) {
-                _inSockets.remove(id);
-                _outSockets.remove(id);
-            }
-        }
-    }
-    
-    public void reportAbuse(I2PSession session, int severity) {
-        _log.error(getName() + ": Abuse reported [" + severity + "]");
-    }
-
-    public void setDefaultOptions(I2PSocketOptions options) {
-        _defaultOptions = options;
-    }
-
-    public I2PSocketOptions getDefaultOptions() {
-        return _defaultOptions;
-    }
-
-    public I2PServerSocket getServerSocket() {
-        if (_serverSocket == null) {
-            _serverSocket = new I2PServerSocketImpl(this);
-        }
-        return _serverSocket;
-    }
+    public I2PSocketOptions buildOptions();
+    public I2PSocketOptions buildOptions(Properties opts);
 
     /**
      * Create a new connected socket (block until the socket is created)
@@ -445,86 +66,7 @@ public class I2PSocketManager implements I2PSessionListener {
      */
     public I2PSocket connect(Destination peer, I2PSocketOptions options) 
                              throws I2PException, ConnectException, 
-                             NoRouteToHostException, InterruptedIOException {
-        String localID, lcID;
-        I2PSocketImpl s;
-        synchronized (lock) {
-            localID = makeID(_outSockets);
-            lcID = getReadableForm(localID);
-            s = new I2PSocketImpl(peer, this, true, localID);
-            _outSockets.put(localID, s);
-        }
-        try {
-            ByteArrayOutputStream pubkey = new ByteArrayOutputStream();
-            _session.getMyDestination().writeBytes(pubkey);
-            String remoteID;
-            byte[] packet = makePacket((byte) SYN, localID, pubkey.toByteArray());
-            boolean sent = false;
-            sent = _session.sendMessage(peer, packet);
-            if (!sent) {
-                _log.info(getName() + ": Unable to send & receive ack for SYN packet for socket " + s);
-                synchronized (lock) {
-                    _outSockets.remove(s.getLocalID());
-                }
-                _context.statManager().addRateData("streaming.synNoAck", 1, 1);
-                throw new I2PException("Error sending through I2P network");
-            }
-            if (options != null)
-                remoteID = s.getRemoteID(true, options.getConnectTimeout());
-            else
-                remoteID = s.getRemoteID(true, getDefaultOptions().getConnectTimeout());
-            
-            if (remoteID == null) {
-                _context.statManager().addRateData("streaming.nackReceived", 1, 1);
-                throw new ConnectException("Connection refused by peer for socket " + s);
-            }
-            if ("".equals(remoteID)) {
-                _context.statManager().addRateData("streaming.synNoAck", 1, 1);
-                throw new NoRouteToHostException("Unable to reach peer for socket " + s);
-            }
-            if (_log.shouldLog(Log.DEBUG))
-                _log.debug(getName() + ": TIMING: s given out for remoteID " 
-                           + getReadableForm(remoteID) + " for socket " + s);
-            
-            return s;
-        } catch (InterruptedIOException ioe) {
-            if (_log.shouldLog(Log.ERROR))
-                _log.error(getName() + ": Timeout waiting for ack from syn for id " 
-                           + getReadableForm(lcID) + " for socket " + s, ioe);
-            synchronized (lock) {
-                _outSockets.remove(s.getLocalID());
-            }
-            s.internalClose();
-            _context.statManager().addRateData("streaming.synNoAck", 1, 1);
-            throw new InterruptedIOException("Timeout waiting for ack");
-        } catch (ConnectException ex) {
-            s.internalClose();
-            throw ex;
-        } catch (NoRouteToHostException ex) {
-            s.internalClose();
-            throw ex;
-        } catch (IOException ex) {
-            if (_log.shouldLog(Log.ERROR))
-                _log.error(getName() + ": Error sending syn on id " + getReadableForm(lcID) + " for socket " + s, ex);
-            synchronized (lock) {
-                _outSockets.remove(s.getLocalID());
-            }
-            s.internalClose();
-            throw new I2PException("Unhandled IOException occurred");
-        } catch (I2PException ex) {
-            if (_log.shouldLog(Log.INFO))
-                _log.info(getName() + ": Error sending syn on id " + getReadableForm(lcID) + " for socket " + s, ex);
-            synchronized (lock) {
-                _outSockets.remove(s.getLocalID());
-            }
-            s.internalClose();
-            throw ex;
-        } catch (Exception e) {
-            s.internalClose();
-            _log.error(getName() + ": Unhandled error connecting", e);
-            throw new ConnectException("Unhandled error connecting: " + e.getMessage());
-        }
-    }
+                             NoRouteToHostException, InterruptedIOException;
 
     /**
      * Create a new connected socket (block until the socket is created)
@@ -537,179 +79,37 @@ public class I2PSocketManager implements I2PSessionListener {
      * @throws I2PException if there is some other I2P-related problem
      */
     public I2PSocket connect(Destination peer) throws I2PException, ConnectException, 
-                                               NoRouteToHostException, InterruptedIOException {
-        return connect(peer, null);
-    }
-
+                                               NoRouteToHostException, InterruptedIOException;
+    
     /**
      * Destroy the socket manager, freeing all the associated resources.  This
      * method will block untill all the managed sockets are closed.
      *
      */
-    public void destroySocketManager() {
-        if (_serverSocket != null) {
-            _serverSocket.close();
-            _serverSocket = null;
-        }
-
-        synchronized (lock) {
-            Iterator iter;
-            String id = null;
-            I2PSocketImpl sock;
-
-            iter = _inSockets.keySet().iterator();
-            while (iter.hasNext()) {
-                id = (String)iter.next();
-                sock = (I2PSocketImpl)_inSockets.get(id);
-                if (_log.shouldLog(Log.DEBUG))
-                    _log.debug(getName() + ": Closing inSocket \""
-                               + getReadableForm(sock.getLocalID()) + "\"");
-                sock.internalClose();
-            }
-            
-            iter = _outSockets.keySet().iterator();
-            while (iter.hasNext()) {
-                id = (String)iter.next();
-                sock = (I2PSocketImpl)_outSockets.get(id);
-                if (_log.shouldLog(Log.DEBUG))
-                    _log.debug(getName() + ": Closing outSocket \""
-                               + getReadableForm(sock.getLocalID()) + "\"");
-                sock.internalClose();
-            }            
-        }
-
-        _log.debug(getName() + ": Waiting for all open sockets to really close...");
-        synchronized (lock) {
-            while ((_inSockets.size() != 0) || (_outSockets.size() != 0)) {
-                try {
-                    lock.wait();
-                } catch (InterruptedException e) {}
-            }
-        }
-
-        try {
-            _log.debug(getName() + ": Destroying I2P session...");
-            _session.destroySession();
-            _log.debug(getName() + ": I2P session destroyed");
-        } catch (I2PSessionException e) {
-            _log.error(getName() + ": Error destroying I2P session", e);
-        }
-    }
+    public void destroySocketManager();
 
     /**
      * Retrieve a set of currently connected I2PSockets, either initiated locally or remotely.
      *
      */
-    public Set listSockets() {
-        Set sockets = new HashSet(8);
-        synchronized (lock) {
-            sockets.addAll(_inSockets.values());
-            sockets.addAll(_outSockets.values());
-        }
-        return sockets;
-    }
+    public Set listSockets();
 
     /**
      * Ping the specified peer, returning true if they replied to the ping within 
      * the timeout specified, false otherwise.  This call blocks.
      *
      */
-    public boolean ping(Destination peer, long timeoutMs) {
-        try {
-            return _session.sendMessage(peer, new byte[] { (byte) CHAFF});
-        } catch (I2PException ex) {
-            _log.error(getName() + ": I2PException:", ex);
-            return false;
-        }
-    }
+    public boolean ping(Destination peer, long timeoutMs);
 
-    public void removeSocket(I2PSocketImpl sock) {
-        synchronized (lock) {
-            _inSockets.remove(sock.getLocalID());
-            _outSockets.remove(sock.getLocalID());
-            lock.notify();
-        }
+    public String getName();
+    public void setName(String name);
 
-        long now = _context.clock().now();
-        long lifetime = now - sock.getCreatedOn();
-        long timeSinceClose = now - sock.getClosedOn();
-        long sent = sock.getBytesSent();
-        long recv = sock.getBytesReceived();
-
-        if (_log.shouldLog(Log.DEBUG)) {
-            _log.debug(getName() + ": Removing socket \"" + getReadableForm(sock.getLocalID()) + "\" [" + sock 
-                       + ", send: " + sent + ", recv: " + recv
-                       + ", lifetime: " + lifetime + "ms, time since close: " + timeSinceClose + ")]",
-                       new Exception("removeSocket called"));
-        }
-
-        _context.statManager().addRateData("streaming.lifetime", lifetime, lifetime);
-        _context.statManager().addRateData("streaming.sent", sent, lifetime);
-        _context.statManager().addRateData("streaming.received", recv, lifetime);
-        
-        if (sent > recv) {
-            _context.statManager().addRateData("streaming.transferBalance", 1, lifetime);
-        } else if (recv > sent) {
-            _context.statManager().addRateData("streaming.transferBalance", -1, lifetime);
-        } else {
-            // noop
-        }
-    }
-
-    public String getName() { return _name; }
-    public void setName(String name) { _name = name; }
+    public void init(I2PAppContext context, I2PSession session, Properties opts, String name);
     
-    public static String getReadableForm(String id) {
-        if (id == null) return "(null)";
-        if (id.length() != 3) return "Bogus";
-        return Base64.encode(toBytes(id));
-    }
-
-    /**
-     * Create a new part the connection ID that is locally unique
-     *
-     * @param uniqueIn map of already known local IDs so we don't collide. WARNING - NOT THREADSAFE!
-     */
-    private static String makeID(HashMap uniqueIn) {
-        String newID;
-        do {
-            int id = (int) (Math.random() * 16777215 + 1);
-            byte[] nid = new byte[3];
-            nid[0] = (byte) (id / 65536);
-            nid[1] = (byte) ((id / 256) % 256);
-            nid[2] = (byte) (id % 256);
-            newID = toString(nid);
-        } while (uniqueIn.get(newID) != null);
-        return newID;
-    }
-
-    /**
-     * Create a new packet of the given type for the specified connection containing
-     * the given payload
-     */
-    public static byte[] makePacket(byte type, String id, byte[] payload) {
-        byte[] packet = new byte[payload.length + 4];
-        packet[0] = type;
-        byte[] temp = toBytes(id);
-        if (temp.length != 3) throw new RuntimeException("Incorrect ID length: " + temp.length);
-        System.arraycopy(temp, 0, packet, 1, 3);
-        System.arraycopy(payload, 0, packet, 4, payload.length);
-        return packet;
-    }
+    public void addDisconnectListener(DisconnectListener lsnr);
+    public void removeDisconnectListener(DisconnectListener lsnr);
     
-    private static final String toString(byte data[]) {
-        try {
-            return new String(data, "ISO-8859-1");
-        } catch (UnsupportedEncodingException uee) {
-            throw new RuntimeException("WTF!  iso-8859-1 isn't supported?");
-        }
-    }
-    
-    private static final byte[] toBytes(String str) {
-        try {
-            return str.getBytes("ISO-8859-1");
-        } catch (UnsupportedEncodingException uee) {
-            throw new RuntimeException("WTF!  iso-8859-1 isn't supported?");
-        }
+    public static interface DisconnectListener {
+        public void sessionDisconnected();
     }
 }

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

@@ -4,8 +4,10 @@ import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
+import java.util.Iterator;
 import java.util.Properties;
 
+import net.i2p.I2PAppContext;
 import net.i2p.I2PException;
 import net.i2p.client.I2PClient;
 import net.i2p.client.I2PClientFactory;
@@ -23,6 +25,10 @@ import net.i2p.util.Log;
 public class I2PSocketManagerFactory {
     private final static Log _log = new Log(I2PSocketManagerFactory.class);
 
+    public static final String PROP_MANAGER = "i2p.streaming.manager";
+    //public static final String DEFAULT_MANAGER = "net.i2p.client.streaming.I2PSocketManagerImpl";
+    public static final String DEFAULT_MANAGER = "net.i2p.client.streaming.I2PSocketManagerFull";
+    
     /**
      * Create a socket manager using a brand new destination connected to the
      * I2CP router on the local machine on the default port (7654).
@@ -76,23 +82,76 @@ public class I2PSocketManagerFactory {
     public static I2PSocketManager createManager(InputStream myPrivateKeyStream, String i2cpHost, int i2cpPort,
                                                  Properties opts) {
         I2PClient client = I2PClientFactory.createClient();
-        opts.setProperty(I2PClient.PROP_RELIABILITY, I2PClient.PROP_RELIABILITY_GUARANTEED);
-        opts.setProperty(I2PClient.PROP_TCP_HOST, i2cpHost);
-        opts.setProperty(I2PClient.PROP_TCP_PORT, "" + i2cpPort);
+        if (opts == null)
+            opts = new Properties();
+        for (Iterator iter = System.getProperties().keySet().iterator(); iter.hasNext(); ) {
+            String name = (String)iter.next();
+            if (!opts.containsKey(name))
+                opts.setProperty(name, System.getProperty(name));
+        }
+        boolean oldLib = DEFAULT_MANAGER.equals(opts.getProperty(PROP_MANAGER, DEFAULT_MANAGER));
+        if (oldLib && false) {
+            // for the old streaming lib
+            opts.setProperty(I2PClient.PROP_RELIABILITY, I2PClient.PROP_RELIABILITY_GUARANTEED);
+            //opts.setProperty("tunnels.depthInbound", "0");
+        } else {
+            // for new streaming lib:
+            opts.setProperty(I2PClient.PROP_RELIABILITY, I2PClient.PROP_RELIABILITY_BEST_EFFORT);
+            //p.setProperty("tunnels.depthInbound", "0");
+        }
+
+        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);
             session.connect();
-            return createManager(session);
+            I2PSocketManager sockMgr = createManager(session, opts, "manager");
+            if (sockMgr != null)
+                sockMgr.setDefaultOptions(sockMgr.buildOptions(opts));
+            return sockMgr;
         } catch (I2PSessionException ise) {
             _log.error("Error creating session for socket manager", ise);
             return null;
         }
     }
 
-    private static I2PSocketManager createManager(I2PSession session) {
-        I2PSocketManager mgr = new I2PSocketManager();
-        mgr.setSession(session);
-        mgr.setDefaultOptions(new I2PSocketOptions());
-        return mgr;
+    private static I2PSocketManager createManager(I2PSession session, Properties opts, String name) {
+        if (false) {
+            I2PSocketManagerImpl mgr = new I2PSocketManagerImpl();
+            mgr.setSession(session);
+            //mgr.setDefaultOptions(new I2PSocketOptions());
+            return mgr;
+        } else {
+            String classname = opts.getProperty(PROP_MANAGER, DEFAULT_MANAGER);
+            if (classname != null) {
+                try {
+                    Class cls = Class.forName(classname);
+                    Object obj = cls.newInstance();
+                    if (obj instanceof I2PSocketManager) {
+                        I2PSocketManager mgr = (I2PSocketManager)obj;
+                        I2PAppContext context = I2PAppContext.getGlobalContext();
+                        mgr.init(context, session, opts, name);
+                        return mgr;
+                    } else {
+                        throw new IllegalStateException("Invalid manager class [" + classname + "]");
+                    }
+                } catch (ClassNotFoundException cnfe) {
+                    _log.error("Error loading " + classname, cnfe);
+                    throw new IllegalStateException("Invalid manager class [" + classname + "] - not found");
+                } catch (InstantiationException ie) {
+                    _log.error("Error loading " + classname, ie);
+                    throw new IllegalStateException("Invalid manager class [" + classname + "] - unable to instantiate");
+                } catch (IllegalAccessException iae) {
+                    _log.error("Error loading " + classname, iae);
+                    throw new IllegalStateException("Invalid manager class [" + classname + "] - illegal access");
+                }
+            } else {
+                throw new IllegalStateException("No manager class specified");
+            }
+        }
+        
     }
 }

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

@@ -0,0 +1,787 @@
+/*
+ * licensed under BSD license...
+ * (if you know the proper clause for that, add it ...)
+ */
+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.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;
+
+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;
+
+
+/**
+ * Centralize the coordination and multiplexing of the local client's streaming.
+ * There should be one I2PSocketManager for each I2PSession, and if an application
+ * is sending and receiving data through the streaming library using an
+ * I2PSocketManager, it should not attempt to call I2PSession's setSessionListener
+ * or receive any messages with its .receiveMessage
+ *
+ */
+class I2PSocketManagerImpl implements I2PSocketManager, I2PSessionListener {
+    private I2PAppContext _context;
+    private Log _log;
+    private I2PSession _session;
+    private I2PServerSocketImpl _serverSocket = null;
+    private Object lock = new Object(); // for locking socket lists
+    private HashMap _outSockets;
+    private HashMap _inSockets;
+    private I2PSocketOptions _defaultOptions;
+    private long _acceptTimeout;
+    private String _name;
+    private List _listeners;
+    private static int __managerId = 0;
+    
+    public static final short ACK = 0x51;
+    public static final short CLOSE_OUT = 0x52;
+    public static final short DATA_OUT = 0x50;
+    public static final short SYN = 0xA1;
+    public static final short CLOSE_IN = 0xA2;
+    public static final short DATA_IN = 0xA0;
+    public static final short CHAFF = 0xFF;
+
+    /**
+     * How long to wait for the client app to accept() before sending back CLOSE?
+     * This includes the time waiting in the queue.  Currently set to 5 seconds.
+     */
+    private static final long ACCEPT_TIMEOUT_DEFAULT = 5*1000;
+    
+    public I2PSocketManagerImpl() {
+        this("SocketManager " + (++__managerId));
+    }
+    public I2PSocketManagerImpl(String name) {
+        init(I2PAppContext.getGlobalContext(), null, null, name);
+    }
+    
+    public void init(I2PAppContext context, I2PSession session, Properties opts, String name) {
+        _name = name;
+        _context = context;
+        _log = _context.logManager().getLog(I2PSocketManager.class);
+        _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 });
+        _context.statManager().createRateStat("streaming.sent", "How many bytes are sent in the stream?", "streaming", new long[] { 10*60*1000, 60*60*1000, 24*60*60*1000 });
+        _context.statManager().createRateStat("streaming.received", "How many bytes are received in the stream?", "streaming", new long[] { 10*60*1000, 60*60*1000, 24*60*60*1000 });
+        _context.statManager().createRateStat("streaming.transferBalance", "How many streams send more than they receive (positive means more sent, negative means more received)?", "streaming", new long[] { 10*60*1000, 60*60*1000, 24*60*60*1000 });
+        _context.statManager().createRateStat("streaming.synNoAck", "How many times have we sent a SYN but not received an ACK?", "streaming", new long[] { 10*60*1000, 60*60*1000, 24*60*60*1000 });
+        _context.statManager().createRateStat("streaming.ackSendFailed", "How many times have we tried to send an ACK to a SYN and failed?", "streaming", new long[] { 10*60*1000, 60*60*1000, 24*60*60*1000 });
+        _context.statManager().createRateStat("streaming.nackSent", "How many times have we refused a SYN with a NACK?", "streaming", new long[] { 10*60*1000, 60*60*1000, 24*60*60*1000 });
+        _context.statManager().createRateStat("streaming.nackReceived", "How many times have we received a NACK to our SYN?", "streaming", new long[] { 10*60*1000, 60*60*1000, 24*60*60*1000 });
+    }
+
+    public I2PSession getSession() {
+        return _session;
+    }
+
+    public void setSession(I2PSession session) {
+        _session = session;
+        if (session != null) session.setSessionListener(this);
+    }
+    
+    /**
+     * How long should we wait for the client to .accept() a socket before
+     * sending back a NACK/Close?  
+     *
+     * @param ms milliseconds to wait, maximum
+     */
+    public void setAcceptTimeout(long ms) { _acceptTimeout = ms; }
+    public long getAcceptTimeout() { return _acceptTimeout; }
+
+    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) {
+        _log.error(getName() + ": Error occurred: [" + message + "]", error);
+    }
+    
+    public void messageAvailable(I2PSession session, int msgId, long size) {
+        try {
+            I2PSocketImpl s;
+            byte msg[] = session.receiveMessage(msgId);
+            if (msg.length == 1 && msg[0] == -1) {
+                _log.debug(getName() + ": Ping received");
+                return;
+            }
+            if (msg.length < 4) {
+                _log.warn(getName() + ": ==== packet too short ====");
+                return;
+            }
+            int type = msg[0] & 0xff;
+            String id = toString(new byte[] { msg[1], msg[2], msg[3]});
+            byte[] payload = new byte[msg.length - 4];
+            System.arraycopy(msg, 4, payload, 0, payload.length);
+            if (_log.shouldLog(Log.DEBUG))
+                _log.debug(getName() + ": Message read: type = [" + Integer.toHexString(type) 
+                           + "] id = [" + getReadableForm(id)
+                           + "] payload length: [" + payload.length + "]");
+            switch (type) {
+                case ACK:
+                    ackAvailable(id, payload);
+                    return;
+                case CLOSE_OUT:
+                    disconnectAvailable(id, payload);
+                    return;
+                case DATA_OUT:
+                    sendOutgoingAvailable(id, payload);
+                    return;
+                case SYN:
+                    synIncomingAvailable(id, payload, session);
+                    return;
+                case CLOSE_IN:
+                    disconnectIncoming(id, payload);
+                    return;
+                case DATA_IN:
+                    sendIncoming(id, payload);
+                case CHAFF:
+                    // ignore
+                    return;
+                default:
+                    handleUnknown(type, id, payload);
+                    return;
+            }
+        } catch (I2PException ise) {
+            _log.warn(getName() + ": Error processing", ise);
+        } catch (IllegalStateException ise) {
+            _log.debug(getName() + ": Error processing", ise);
+        }
+    }
+    
+    /**
+     * We've received an ACK packet (hopefully, in response to a SYN that we 
+     * recently sent out).  Notify the associated I2PSocket that we now have
+     * the remote stream ID (which should get things going, since the handshake
+     * is complete).
+     *
+     */
+    private void ackAvailable(String id, byte payload[]) {
+        long begin = _context.clock().now();
+        I2PSocketImpl s = null;
+        synchronized (lock) {
+            s = (I2PSocketImpl) _outSockets.get(id);
+        }
+
+        if (s == null) {
+            _log.warn(getName() + ": No socket responsible for ACK packet for id " + getReadableForm(id));
+            return;
+        }
+
+        long socketRetrieved = _context.clock().now();
+        
+        String remoteId = null;
+        remoteId = s.getRemoteID(false); 
+
+        if ( (payload.length == 3) && (remoteId == null) ) {
+            String newID = toString(payload);
+            long beforeSetRemId = _context.clock().now();
+            s.setRemoteID(newID);
+            if (_log.shouldLog(Log.DEBUG)) {
+                _log.debug(getName() + ": ackAvailable - socket retrieval took " 
+                           + (socketRetrieved-begin) + "ms, getRemoteId took "
+                           + (beforeSetRemId-socketRetrieved) + "ms, setRemoteId took "
+                           + (_context.clock().now()-beforeSetRemId) + "ms");
+            }
+            return;
+        } else {
+            // (payload.length != 3 || getRemoteId != null)
+            if (_log.shouldLog(Log.WARN)) {
+                if (payload.length != 3)
+                    _log.warn(getName() + ": Ack packet had " + payload.length + " bytes");
+                else
+                    _log.warn(getName() + ": Remote ID already exists? " + remoteId);
+            }
+            if (_log.shouldLog(Log.DEBUG)) {
+                _log.debug(getName() + ": invalid ack - socket retrieval took " 
+                           + (socketRetrieved-begin) + "ms, overall took "
+                           + (_context.clock().now()-begin) + "ms");
+            }
+            return;
+        }
+    }
+    
+    /**
+     * We received a disconnect packet, telling us to tear down the specified
+     * stream.
+     */
+    private void disconnectAvailable(String id, byte payload[]) {
+        I2PSocketImpl s = null;
+        synchronized (lock) {
+            s = (I2PSocketImpl) _outSockets.get(id);
+        }
+        
+        _log.debug(getName() + ": *Disconnect outgoing for socket " + s + " on id "
+                   + getReadableForm(id));
+        try {
+            if (s != null) {
+                if (payload.length > 0) {
+                    _log.debug(getName() + ": Disconnect packet had "
+                               + payload.length + " bytes");
+                }
+                if (s.getRemoteID(false) == null) {
+                    s.setRemoteID(null); // Just to wake up socket
+                    return;
+                }
+                s.internalClose();
+                synchronized (lock) {
+                    _outSockets.remove(id);
+                }
+            }
+            return;
+        } catch (Exception t) {
+            _log.warn(getName() + ": Ignoring error on disconnect for socket " + s, t);
+        }
+    }
+    
+    /**
+     * We've received data on a stream we created - toss the data onto
+     * the socket for handling.
+     *
+     * @throws IllegalStateException if the socket isn't open or isn't known
+     */
+    private void sendOutgoingAvailable(String id, byte payload[]) throws IllegalStateException {
+        I2PSocketImpl s = null;
+        synchronized (lock) {
+            s = (I2PSocketImpl) _outSockets.get(id);
+        }
+
+        // packet send outgoing
+        if (_log.shouldLog(Log.DEBUG))
+            _log.debug(getName() + ": *Packet send outgoing [" + payload.length + "] for socket " 
+                       + s + " on id " + getReadableForm(id));
+        if (s != null) {
+            s.queueData(payload);
+            return;
+        } else {
+            if (_log.shouldLog(Log.WARN))
+                _log.warn(getName() + ": Null socket with data available");
+            throw new IllegalStateException("Null socket with data available");
+        }
+    }
+    
+    /**
+     * We've received a SYN packet (a request for a new stream).  If the client has 
+     * said they want incoming sockets (by retrieving the serverSocket), the stream
+     * will be ACKed, but if they have not, they'll be NACKed)
+     *
+     * @throws DataFormatException if the destination in the SYN was invalid
+     * @throws I2PSessionException if there was an I2P error sending the ACK or NACK
+     */
+    private void synIncomingAvailable(String id, byte payload[], I2PSession session) 
+                                      throws DataFormatException, I2PSessionException {
+        Destination d = new Destination();
+        d.fromByteArray(payload);
+
+        I2PSocketImpl s = null;
+        boolean acceptConnections = (_serverSocket != null);
+        String newLocalID = null;
+        synchronized (lock) {
+            newLocalID = makeID(_inSockets);
+            if (acceptConnections) {
+                s = new I2PSocketImpl(d, this, false, newLocalID);
+                s.setRemoteID(id);
+            }
+        }    
+        _log.debug(getName() + ": *Syn! for socket " + s + " on id " + getReadableForm(newLocalID) 
+                   + " from " + d.calculateHash().toBase64().substring(0,6));
+        
+        if (!acceptConnections) {
+            // The app did not instantiate an I2PServerSocket
+            byte[] packet = makePacket((byte) CLOSE_OUT, id, toBytes(newLocalID));
+            boolean replySentOk = false;
+            synchronized (_session) {
+                replySentOk = _session.sendMessage(d, packet);
+            }
+            if (!replySentOk) {
+                _log.warn(getName() + ": Error sending close to " + d.calculateHash().toBase64()
+                           + " in response to a new con message", 
+                           new Exception("Failed creation"));
+            }
+            _context.statManager().addRateData("streaming.nackSent", 1, 1);
+            return;
+        }
+
+        if (_serverSocket.addWaitForAccept(s, _acceptTimeout)) {
+            _inSockets.put(newLocalID, s);
+            byte[] packet = makePacket((byte) ACK, id, toBytes(newLocalID));
+            boolean replySentOk = false;
+            replySentOk = _session.sendMessage(d, packet);
+            if (!replySentOk) {
+                if (_log.shouldLog(Log.WARN))
+                    _log.warn(getName() + ": Error sending reply to " + d.calculateHash().toBase64()
+                               + " in response to a new con message for socket " + s,
+                               new Exception("Failed creation"));
+                s.internalClose();
+                _context.statManager().addRateData("streaming.ackSendFailed", 1, 1);
+            }
+        } else {
+            // timed out or serverSocket closed
+            byte[] packet = toBytes(" " + id);
+            packet[0] = CLOSE_OUT;
+            boolean nackSent = session.sendMessage(d, packet);
+            if (!nackSent) {
+                _log.warn(getName() + ": Error sending NACK for session creation for socket " + s);
+            }
+            s.internalClose();
+            _context.statManager().addRateData("streaming,nackSent", 1, 1);
+        }
+        return;
+    }
+    
+    /**
+     * We've received a disconnect for a socket we didn't initiate, so kill
+     * the socket.
+     *
+     */
+    private void disconnectIncoming(String id, byte payload[]) {
+        I2PSocketImpl s = null;
+        synchronized (lock) {
+            s = (I2PSocketImpl) _inSockets.get(id);
+            if (payload.length == 0 && s != null) {
+                _inSockets.remove(id);
+            }
+        }
+        
+        _log.debug(getName() + ": *Disconnect incoming for socket " + s);
+        
+        try {
+            if (payload.length == 0 && s != null) {
+                s.internalClose();
+                return;
+            } else {
+                if ( (payload.length > 0) && (_log.shouldLog(Log.ERROR)) )
+                    _log.warn(getName() + ": Disconnect packet had " + payload.length + " bytes");
+                if (s != null) 
+                    s.internalClose();
+                return;
+            }
+        } catch (Exception t) {
+            _log.warn(getName() + ": Ignoring error on disconnect", t);
+            return;
+        }
+    }
+    
+    /**
+     * We've received data on a stream we received - toss the data onto
+     * the socket for handling.
+     *
+     * @throws IllegalStateException if the socket isn't open or isn't known
+     */
+    private void sendIncoming(String id, byte payload[]) throws IllegalStateException {
+        I2PSocketImpl s = null;
+        synchronized (lock) {
+            s = (I2PSocketImpl) _inSockets.get(id);
+        }
+
+        if (_log.shouldLog(Log.DEBUG))
+            _log.debug(getName() + ": *Packet send incoming [" + payload.length + "] for socket " + s);
+        
+        if (s != null) {
+            s.queueData(payload);
+            return;
+        } else {
+            _log.info(getName() + ": Null socket with data available");
+            throw new IllegalStateException("Null socket with data available");
+        }
+    }
+    
+    /**
+     * Unknown packet.  moo.
+     *
+     */
+    private void handleUnknown(int type, String id, byte payload[]) {
+        _log.error(getName() + ": \n\n=============== Unknown packet! " + "============" 
+                   + "\nType: " + (int) type
+                   + "\nID:   " + getReadableForm(id) 
+                   + "\nBase64'ed Data: " + Base64.encode(payload)
+                   + "\n\n\n");
+        if (id != null) {
+            synchronized (lock) {
+                _inSockets.remove(id);
+                _outSockets.remove(id);
+            }
+        }
+    }
+    
+    public void reportAbuse(I2PSession session, int severity) {
+        _log.error(getName() + ": Abuse reported [" + severity + "]");
+    }
+
+    public void setDefaultOptions(I2PSocketOptions options) {
+        _defaultOptions = options;
+    }
+
+    public I2PSocketOptions getDefaultOptions() {
+        return _defaultOptions;
+    }
+    
+    public I2PSocketOptions buildOptions() { return buildOptions(null); }
+    public I2PSocketOptions buildOptions(Properties opts) {
+        return new I2PSocketOptionsImpl(opts);
+    }
+
+    public I2PServerSocket getServerSocket() {
+        if (_serverSocket == null) {
+            _serverSocket = new I2PServerSocketImpl(this);
+        }
+        return _serverSocket;
+    }
+
+    /**
+     * Create a new connected socket (block until the socket is created)
+     *
+     * @param peer Destination to connect to
+     * @param options I2P socket options to be used for connecting
+     *
+     * @throws ConnectException if the peer refuses the connection
+     * @throws NoRouteToHostException if the peer is not found or not reachable
+     * @throws InterruptedIOException if the connection timeouts
+     * @throws I2PException if there is some other I2P-related problem
+     */
+    public I2PSocket connect(Destination peer, I2PSocketOptions options) 
+                             throws I2PException, ConnectException, 
+                             NoRouteToHostException, InterruptedIOException {
+        String localID, lcID;
+        I2PSocketImpl s;
+        synchronized (lock) {
+            localID = makeID(_outSockets);
+            lcID = getReadableForm(localID);
+            s = new I2PSocketImpl(peer, this, true, localID);
+            _outSockets.put(localID, s);
+        }
+        if (_log.shouldLog(Log.DEBUG))
+            _log.debug(getName() + ": connect(" + peer.calculateHash().toBase64().substring(0,6)
+                       + ", ...): localID = " + lcID);
+        
+        try {
+            ByteArrayOutputStream pubkey = new ByteArrayOutputStream();
+            _session.getMyDestination().writeBytes(pubkey);
+            String remoteID;
+            byte[] packet = makePacket((byte) SYN, localID, pubkey.toByteArray());
+            boolean sent = false;
+            sent = _session.sendMessage(peer, packet);
+            if (!sent) {
+                _log.info(getName() + ": Unable to send & receive ack for SYN packet for socket " 
+                          + s + " with localID = " + lcID);
+                synchronized (lock) {
+                    _outSockets.remove(s.getLocalID());
+                }
+                _context.statManager().addRateData("streaming.synNoAck", 1, 1);
+                throw new I2PException("Error sending through I2P network");
+            } else {
+                if (_log.shouldLog(Log.DEBUG))
+                    _log.debug(getName() + ": syn sent ok to " 
+                               + peer.calculateHash().toBase64().substring(0,6) 
+                               + " with localID = " + lcID);
+            }
+            if (options != null)
+                remoteID = s.getRemoteID(true, options.getConnectTimeout());
+            else
+                remoteID = s.getRemoteID(true, getDefaultOptions().getConnectTimeout());
+            
+            if (_log.shouldLog(Log.DEBUG))
+                _log.debug(getName() + ": remoteID received from " 
+                           + peer.calculateHash().toBase64().substring(0,6) 
+                           + ": " + getReadableForm(remoteID) 
+                           + " with localID = " + lcID);
+            
+            if (remoteID == null) {
+                _context.statManager().addRateData("streaming.nackReceived", 1, 1);
+                throw new ConnectException("Connection refused by peer for socket " + s);
+            }
+            if ("".equals(remoteID)) {
+                _context.statManager().addRateData("streaming.synNoAck", 1, 1);
+                throw new NoRouteToHostException("Unable to reach peer for socket " + s);
+            }
+            if (_log.shouldLog(Log.DEBUG))
+                _log.debug(getName() + ": TIMING: s given out for remoteID " 
+                           + getReadableForm(remoteID) + " for socket " + s);
+            
+            return s;
+        } catch (InterruptedIOException ioe) {
+            if (_log.shouldLog(Log.WARN))
+                _log.warn(getName() + ": Timeout waiting for ack from syn for id " 
+                           + lcID + " to " + peer.calculateHash().toBase64().substring(0,6) 
+                           + " for socket " + s, ioe);
+            synchronized (lock) {
+                _outSockets.remove(s.getLocalID());
+            }
+            s.internalClose();
+            _context.statManager().addRateData("streaming.synNoAck", 1, 1);
+            throw new InterruptedIOException("Timeout waiting for ack");
+        } catch (ConnectException ex) {
+            if (_log.shouldLog(Log.DEBUG))
+                _log.debug(getName() + ": Connection error waiting for ack from syn for id " 
+                           + lcID + " to " + peer.calculateHash().toBase64().substring(0,6) 
+                           + " for socket " + s, ex);
+            s.internalClose();
+            throw ex;
+        } catch (NoRouteToHostException ex) {
+            if (_log.shouldLog(Log.DEBUG))
+                _log.debug(getName() + ": No route to host waiting for ack from syn for id " 
+                           + lcID + " to " + peer.calculateHash().toBase64().substring(0,6) 
+                           + " for socket " + s, ex);
+            s.internalClose();
+            throw ex;
+        } catch (IOException ex) {
+            if (_log.shouldLog(Log.WARN))
+                _log.warn(getName() + ": Error sending syn on id " 
+                           + lcID + " to " + peer.calculateHash().toBase64().substring(0,6) 
+                           + " for socket " + s, ex);
+            synchronized (lock) {
+                _outSockets.remove(s.getLocalID());
+            }
+            s.internalClose();
+            throw new I2PException("Unhandled IOException occurred");
+        } catch (I2PException ex) {
+            if (_log.shouldLog(Log.INFO))
+                _log.info(getName() + ": Error sending syn on id " 
+                          + lcID + " to " + peer.calculateHash().toBase64().substring(0,6) 
+                          + " for socket " + s, ex);
+            synchronized (lock) {
+                _outSockets.remove(s.getLocalID());
+            }
+            s.internalClose();
+            throw ex;
+        } catch (Exception e) {
+            s.internalClose();
+            _log.warn(getName() + ": Unhandled error connecting on "
+                       + lcID + " to " + peer.calculateHash().toBase64().substring(0,6) 
+                       + " for socket " + s, e);
+            throw new ConnectException("Unhandled error connecting: " + e.getMessage());
+        }
+    }
+
+    /**
+     * Create a new connected socket (block until the socket is created)
+     *
+     * @param peer Destination to connect to
+     *
+     * @throws ConnectException if the peer refuses the connection
+     * @throws NoRouteToHostException if the peer is not found or not reachable
+     * @throws InterruptedIOException if the connection timeouts
+     * @throws I2PException if there is some other I2P-related problem
+     */
+    public I2PSocket connect(Destination peer) throws I2PException, ConnectException, 
+                                               NoRouteToHostException, InterruptedIOException {
+        return connect(peer, null);
+    }
+
+    /**
+     * Destroy the socket manager, freeing all the associated resources.  This
+     * method will block untill all the managed sockets are closed.
+     *
+     */
+    public void destroySocketManager() {
+        if (_serverSocket != null) {
+            _serverSocket.close();
+            _serverSocket = null;
+        }
+
+        synchronized (lock) {
+            Iterator iter;
+            String id = null;
+            I2PSocketImpl sock;
+
+            iter = _inSockets.keySet().iterator();
+            while (iter.hasNext()) {
+                id = (String)iter.next();
+                sock = (I2PSocketImpl)_inSockets.get(id);
+                if (_log.shouldLog(Log.DEBUG))
+                    _log.debug(getName() + ": Closing inSocket \""
+                               + getReadableForm(sock.getLocalID()) + "\"");
+                sock.internalClose();
+            }
+            
+            iter = _outSockets.keySet().iterator();
+            while (iter.hasNext()) {
+                id = (String)iter.next();
+                sock = (I2PSocketImpl)_outSockets.get(id);
+                if (_log.shouldLog(Log.DEBUG))
+                    _log.debug(getName() + ": Closing outSocket \""
+                               + getReadableForm(sock.getLocalID()) + "\"");
+                sock.internalClose();
+            }            
+        }
+
+        _log.debug(getName() + ": Waiting for all open sockets to really close...");
+        synchronized (lock) {
+            while ((_inSockets.size() != 0) || (_outSockets.size() != 0)) {
+                try {
+                    lock.wait();
+                } catch (InterruptedException e) {}
+            }
+        }
+
+        try {
+            _log.debug(getName() + ": Destroying I2P session...");
+            _session.destroySession();
+            _log.debug(getName() + ": I2P session destroyed");
+        } catch (I2PSessionException e) {
+            _log.warn(getName() + ": Error destroying I2P session", e);
+        }
+    }
+
+    /**
+     * Retrieve a set of currently connected I2PSockets, either initiated locally or remotely.
+     *
+     */
+    public Set listSockets() {
+        Set sockets = new HashSet(8);
+        synchronized (lock) {
+            sockets.addAll(_inSockets.values());
+            sockets.addAll(_outSockets.values());
+        }
+        return sockets;
+    }
+
+    /**
+     * Ping the specified peer, returning true if they replied to the ping within 
+     * the timeout specified, false otherwise.  This call blocks.
+     *
+     */
+    public boolean ping(Destination peer, long timeoutMs) {
+        try {
+            return _session.sendMessage(peer, new byte[] { (byte) CHAFF});
+        } catch (I2PException ex) {
+            _log.warn(getName() + ": I2PException:", ex);
+            return false;
+        }
+    }
+
+    public void removeSocket(I2PSocketImpl sock) {
+        String localId = sock.getLocalID();
+        boolean removed = false;
+        synchronized (lock) {
+            removed = (null != _inSockets.remove(localId));
+            removed = removed || (null != _outSockets.remove(localId));
+            lock.notify();
+        }
+
+        long now = _context.clock().now();
+        long lifetime = now - sock.getCreatedOn();
+        long timeSinceClose = now - sock.getClosedOn();
+        long sent = sock.getBytesSent();
+        long recv = sock.getBytesReceived();
+
+        if (_log.shouldLog(Log.DEBUG)) {
+            _log.debug(getName() + ": Removing socket \"" + getReadableForm(localId) + "\" [" + sock 
+                       + ", send: " + sent + ", recv: " + recv
+                       + ", lifetime: " + lifetime + "ms, time since close: " + timeSinceClose 
+                       + " removed? " + removed + ")]",
+                       new Exception("removeSocket called"));
+        }
+
+        _context.statManager().addRateData("streaming.lifetime", lifetime, lifetime);
+        _context.statManager().addRateData("streaming.sent", sent, lifetime);
+        _context.statManager().addRateData("streaming.received", recv, lifetime);
+        
+        if (sent > recv) {
+            _context.statManager().addRateData("streaming.transferBalance", 1, lifetime);
+        } else if (recv > sent) {
+            _context.statManager().addRateData("streaming.transferBalance", -1, lifetime);
+        } else {
+            // noop
+        }
+    }
+
+    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";
+        return Base64.encode(toBytes(id));
+    }
+
+    /**
+     * Create a new part the connection ID that is locally unique
+     *
+     * @param uniqueIn map of already known local IDs so we don't collide. WARNING - NOT THREADSAFE!
+     */
+    private static String makeID(HashMap uniqueIn) {
+        String newID;
+        do {
+            int id = (int) (Math.random() * 16777215 + 1);
+            byte[] nid = new byte[3];
+            nid[0] = (byte) (id / 65536);
+            nid[1] = (byte) ((id / 256) % 256);
+            nid[2] = (byte) (id % 256);
+            newID = toString(nid);
+        } while (uniqueIn.get(newID) != null);
+        return newID;
+    }
+
+    /**
+     * Create a new packet of the given type for the specified connection containing
+     * the given payload
+     */
+    public static byte[] makePacket(byte type, String id, byte[] payload) {
+        byte[] packet = new byte[payload.length + 4];
+        packet[0] = type;
+        byte[] temp = toBytes(id);
+        if (temp.length != 3) throw new RuntimeException("Incorrect ID length: " + temp.length);
+        System.arraycopy(temp, 0, packet, 1, 3);
+        System.arraycopy(payload, 0, packet, 4, payload.length);
+        return packet;
+    }
+    
+    private static final String toString(byte data[]) {
+        try {
+            return new String(data, "ISO-8859-1");
+        } catch (UnsupportedEncodingException uee) {
+            throw new RuntimeException("WTF!  iso-8859-1 isn't supported?");
+        }
+    }
+    
+    private static final byte[] toBytes(String str) {
+        try {
+            return str.getBytes("ISO-8859-1");
+        } catch (UnsupportedEncodingException uee) {
+            throw new RuntimeException("WTF!  iso-8859-1 isn't supported?");
+        }
+    }
+}