(1.185) added TheBreton.i2p adab.i2p awup.i2p china.i2p davidkra.i2p

comwiz.i2p dust.i2p eepsites.i2p jmg.i2p kuroneko.i2p
               mywastedlife.i2p site.games.i2p squid2.i2p striker.i2p
               tracker.awup.i2p zzz.i2p

Makefile.gcj

@@ -0,0 +1,100 @@
+# Makefile for building native I2P binaries and libraries with GCJ
+#
+# WARNING: Do not use this yet, as it may explode (etc).
+#
+GCJ=gcj #/usr/local/gcc-4.0.2/bin/gcj
+EXTRA_LD_PATH= #/usr/local/gcc-4.0.2/lib
+ANT=ant #/opt/apache-ant-1.6.5/bin/ant
+ANT_TARGET=buildclean
+NATIVE_DIR=native
+
+## 
+# Define what jar files get into libi2p.so.  The current setup is
+# *incredibly* lazy, throwing everything in the .so, rather than
+# give each .jar file its own .so.
+#  i2p.jar: base SDK
+#  mstreaming.jar: streaming API
+#  streaming.jar: full streaming lib implementation
+#  i2ptunnel.jar: I2PTunnel proxy
+#  sam.jar: SAM bridge and API
+#  i2psnark.jar: bittorrent client
+#  router.jar: full I2P router
+#  jbigi.jar: collection of native optimized GMP routines for crypto
+JAR_BASE=i2p.jar mstreaming.jar streaming.jar
+JAR_CLIENTS=i2ptunnel.jar sam.jar i2psnark.jar
+JAR_ROUTER=router.jar
+JAR_JBIGI=jbigi.jar
+JAR_XML=xml-apis.jar resolver.jar xercesImpl.jar
+JAR_CONSOLE=\
+            javax.servlet.jar \
+            commons-el.jar \
+            commons-logging.jar \
+	    jasper-runtime.jar \
+            ant-apache-bcel.jar \
+            ant.jar \
+            jasper-compiler.jar \
+            org.mortbay.jetty.jar \
+	    routerconsole.jar
+JAR_SUCKER=jdom.jar rome-0.7.jar sucker.jar
+LIBI2P_JARS=${JAR_BASE} ${JAR_CLIENTS} ${JAR_ROUTER} ${JAR_JBIGI}
+# unfortunately, its not quite ready for most end users, as the
+# ${JAR_CONSOLE} fails to compile with: 
+# org/apache/commons/logging/impl/LogKitLogger.java: In class 'org.apache.commons.logging.impl.LogKitLogger':
+# .../LogKitLogger.java: In constructor '(java.lang.String)':
+# .../LogKitLogger.java:91: error: cannot find file for class org.apache.log.Hierarchy
+# .../LogKitLogger.java:91: error: cannot find file for class org.apache.log.Hierarchy
+# .../LogKitLogger.java:104: error: cannot find file for class org.apache.log.Hierarchy
+# .../LogKitLogger.java:104: confused by earlier errors, bailing out
+
+#${JAR_CONSOLE}\
+#${JAR_XML} \
+#${JAR_SUCKER}
+#${JAR_CONSOLE}
+
+SYSTEM_PROPS=-DloggerFilenameOverride=logs/log-router-@.txt \
+             -Dorg.mortbay.http.Version.paranoid=true \
+	     -Dorg.mortbay.util.FileResource.checkAliases=false \
+	     -Dorg.mortbay.xml.XmlParser.NotValidating=true
+#SYSTEM_PROPS=-Di2p.weakPRNG=true
+OPTIMIZE=-O2
+#OPTIMIZE=-O3
+
+LD_LIBRARY_PATH=${EXTRA_LD_PATH}:.
+
+all: jars native
+	@echo "* Build complete"
+
+jars:
+	@${ANT} ${ANT_TARGET}
+
+clean: native_clean
+
+native: native_clean native_shared
+	@echo "* Native code build in ${NATIVE}"
+
+native_clean:
+	@rm -rf ${NATIVE_DIR}
+	@mkdir ${NATIVE_DIR}
+
+native_shared: libi2p.so
+	@cd build ; ${GCJ} ${OPTIMIZE} -fjni -L../${NATIVE_DIR} -li2p ${SYSTEM_PROPS} -o ../${NATIVE_DIR}/i2p_dsa --main=net.i2p.crypto.DSAEngine 
+	@echo "* i2p_dsa is a simple test app with the DSA engine and Fortuna PRNG to make sure crypto is working"
+	@cd build ; ${GCJ} ${OPTIMIZE} -fjni -L../${NATIVE_DIR} -li2p ${SYSTEM_PROPS} -o ../${NATIVE_DIR}/prng --main=gnu.crypto.prng.Fortuna
+	@cd build ; ${GCJ} ${OPTIMIZE} -fjni -L../${NATIVE_DIR} -li2p ${SYSTEM_PROPS} -o ../${NATIVE_DIR}/i2ptunnel --main=net.i2p.i2ptunnel.I2PTunnel 
+	@echo "* i2ptunnel is mihi's I2PTunnel CLI"
+	@echo "  run it as ./i2ptunnel -cli to avoid awt complaints"
+	@cd build ; ${GCJ} ${OPTIMIZE} -fjni -L../${NATIVE_DIR} -li2p ${SYSTEM_PROPS} -o ../${NATIVE_DIR}/i2ptunnelctl --main=net.i2p.i2ptunnel.TunnelControllerGroup 
+	@echo "* i2ptunnelctl is a controller for I2PTunnel, reading i2ptunnel.config"
+	@echo "  and launching the appropriate proxies"
+	@cd build ; ${GCJ} ${OPTIMIZE} -fjni -L../${NATIVE_DIR} -li2p ${SYSTEM_PROPS} -o ../${NATIVE_DIR}/i2psnark --main=org.klomp.snark.Snark
+	@echo "* i2psnark is an anonymous bittorrent client"
+	@cd build ; ${GCJ} ${OPTIMIZE} -fjni -L../${NATIVE_DIR} -li2p ${SYSTEM_PROPS} -o ../${NATIVE_DIR}/i2prouter --main=net.i2p.router.Router 
+	@echo "* i2prouter is the main I2P router"
+	@echo "  it can be used, and while the router console won't load,"
+	@echo "  i2ptunnel will, so it will start all the proxies defined in i2ptunnel.config"
+
+libi2p.so:
+	@echo "* Building libi2p.so"
+	@(cd build ; ${GCJ} ${OPTIMIZE} -fPIC -fjni -shared -o ../${NATIVE_DIR}/libi2p.so ${LIBI2P_JARS} ; cd .. )
+	@ls -l ${NATIVE_DIR}/libi2p.so
+	@echo "* libi2p.so built"

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,51 @@
+<?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"/>
+	
+	<target name="init">
+		<mkdir dir="${build}"/>
+		<mkdir dir="${dist}"/>
+	</target>
+
+	<target name="clean">
+		<delete dir="${build}"/>
+		<delete dir="${dist}"/>
+	</target>
+
+	<target name="distclean" depends="clean" />
+
+	<target name="compile" depends="init">
+		<javac debug="true" deprecation="on" source="1.3" target="1.3" 
+                       srcdir="${src}" destdir="${build}">
+            <classpath>
+                <pathelement location="../../core/java/build/i2p.jar" />
+                <pathelement location="../jetty/jettylib/javax.servlet.jar" />
+            </classpath>
+		</javac>
+	</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,218 @@
+/*
+ * 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.io.File;
+import java.io.IOException;
+
+import net.i2p.I2PAppContext;
+import net.i2p.util.EepGet;
+
+/**
+ * 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(String url, String proxyHost, int proxyPort) {
+        this.location = url;
+        EepGet get = new EepGet(I2PAppContext.getGlobalContext(), true,
+                proxyHost, proxyPort, 0, "addressbook.tmp", url, true, 
+                null);
+        get.fetch();
+        try {
+            this.addresses = ConfigParser.parse(new File("addressbook.tmp"));
+        } catch (IOException exp) {
+            this.addresses = new HashMap();
+        }
+        new File("addressbook.tmp").delete();
+    }
+
+    /**
+     * 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, String proxyHost, int proxyPort) {
+        this.location = subscription.getLocation();
+        EepGet get = new EepGet(I2PAppContext.getGlobalContext(), true,
+                proxyHost, proxyPort, 0, "addressbook.tmp", 
+                subscription.getLocation(), true, subscription.getEtag());
+        get.fetch();
+        subscription.setEtag(get.getETag());
+        try {            
+            this.addresses = ConfigParser.parse(new File("addressbook.tmp"));
+        } catch (IOException exp) {
+            this.addresses = new HashMap();
+        }
+        new File("addressbook.tmp").delete();
+    }
+
+    /**
+     * 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, boolean overwrite, 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) && !overwrite) {
+                    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 if (!this.addresses.containsKey(otherKey)
+                            || !this.addresses.get(otherKey).equals(otherValue)) {
+                    this.addresses.put(otherKey, otherValue);
+                    this.modified = true;
+                    if (log != null) {
+                        log.append("New address " + otherKey
+                            + " added to address book.");
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * 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,304 @@
+/*
+ * 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.*;
+
+/**
+ * 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 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,191 @@
+/*
+ * 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";
+    private static final Daemon _instance = new Daemon();
+    
+    /**
+     * 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 void update(AddressBook master, AddressBook router,
+            File published, SubscriptionList subscriptions, Log log) {
+        router.merge(master, true, null);
+        Iterator iter = subscriptions.iterator();
+        while (iter.hasNext()) {
+            router.merge((AddressBook) iter.next(), false, log);
+        }
+        router.write();
+        if (published != null)
+            router.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 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, (String) settings
+                .get("proxy_host"), Integer.parseInt((String) settings.get("proxy_port")));
+        Log log = new Log(logFile);
+
+        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) {
+        _instance.run(args);
+    }
+    
+    public void run(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", "12");
+        
+        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);
+        
+        settings = ConfigParser.parse(settingsFile, defaultSettings);
+        // wait
+        try {
+            Thread.currentThread().sleep(5*60*1000);
+        } catch (InterruptedException ie) {}
+        
+        while (true) {
+            long delay = Long.parseLong((String) settings.get("update_delay"));
+            if (delay < 1) {
+                delay = 1;
+            }
+            
+            update(settings, home);
+            try {
+                synchronized (this) {
+                    wait(delay * 60 * 60 * 1000);
+                }
+            } catch (InterruptedException exp) {
+            }
+            settings = ConfigParser.parse(settingsFile, defaultSettings);
+        }
+    }
+ 
+    /**
+     * Call this to get the addressbook to reread its config and 
+     * refetch its subscriptions.
+     */
+    public static void wakeup() {
+        synchronized (_instance) {
+            _instance.notifyAll();
+        }
+    }
+}

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,73 @@
+/*
+ * 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;
+    private String proxyHost;
+    private int proxyPort;
+
+    /**
+     * Construct a SubscriptionIterator using the Subscriprions in List subscriptions.
+     * 
+     * @param subscriptions
+     *            List of Subscription objects that represent address books.
+     */
+    public SubscriptionIterator(List subscriptions, String proxyHost, int proxyPort) {
+        this.subIterator = subscriptions.iterator();
+        this.proxyHost = proxyHost;
+        this.proxyPort = proxyPort;
+    }
+
+    
+    /* (non-Javadoc)
+     * @see java.util.Iterator#hasNext()
+     */
+    public boolean hasNext() {
+        return this.subIterator.hasNext();
+    }
+
+    /* (non-Javadoc)
+     * @see java.util.Iterator#next()
+     */
+    public Object next() {
+        Subscription sub = (Subscription) this.subIterator.next();
+        return new AddressBook(sub, this.proxyHost, this.proxyPort);
+    }
+
+    /* (non-Javadoc)
+     * @see java.util.Iterator#remove()
+     */
+    public void remove() {
+        throw new UnsupportedOperationException();
+    }
+}

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

@@ -0,0 +1,129 @@
+/*
+ * 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;
+    
+    private String proxyHost;
+    
+    private int proxyPort;
+
+    /**
+     * 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, String proxyHost, 
+            int proxyPort) {
+        this.subscriptions = new LinkedList();
+        this.etagsFile = etagsFile;
+        this.lastModifiedFile = lastModifiedFile;
+        this.proxyHost = proxyHost;
+        this.proxyPort = proxyPort;
+        Map etags;
+        Map lastModified;
+        String location;
+        List 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();
+            this.subscriptions.add(new Subscription(location, (String) etags
+                    .get(location), (String) lastModified.get(location)));
+        }
+    }
+    
+    /**
+     * Return an iterator over the AddressBooks represented by the Subscriptions
+     * in this SubscriptionList.
+     * 
+     * @return A SubscriptionIterator.
+     */
+    public SubscriptionIterator iterator() {
+        return new SubscriptionIterator(this.subscriptions, this.proxyHost, 
+                this.proxyPort);
+    }
+
+    /**
+     * 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/Bogobot.java

@@ -0,0 +1,349 @@
+/*
+ * bogobot - A simple join/part stats logger bot for I2P IRC.
+ * 
+ * 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;
+import org.apache.log4j.PatternLayout;
+
+import org.jibble.pircbot.IrcException;
+import org.jibble.pircbot.NickAlreadyInUseException;
+import org.jibble.pircbot.PircBot;
+import org.jibble.pircbot.User;
+
+/**
+ * TODO 0.5 Add multi-server capability.
+ * 
+ * @author hypercubus, oOo
+ * @version 0.4
+ */
+public class Bogobot extends PircBot {
+
+    private static final String INTERVAL_DAILY   = "daily";
+    private static final String INTERVAL_MONTHLY = "monthly";
+    private static final String INTERVAL_WEEKLY  = "weekly";
+
+    private boolean _isIntentionalDisconnect      = false;
+    private long    _lastUserlistCommandTimestamp = 0;
+    private Logger  _logger                       = Logger.getLogger(Bogobot.class);
+
+    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.postman.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.postman.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;
+
+        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);
+
+        if (bogobot._isLoggerEnabled)
+            bogobot.initLogger();
+
+        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)
+            System.exit(0);            
+
+        if (_isLoggerEnabled)
+            _logger.info(System.currentTimeMillis() + " quits *** " + this.getName() + " *** (Lost connection)");
+
+        try {
+            Thread.sleep(60000);
+        } catch (InterruptedException e) {
+            // No worries.
+        }
+        connectToServer();
+    }
+
+    protected void onJoin(String channel, String sender, String login, String hostname) {
+
+        if (_isLoggerEnabled) {
+            if (sender.equals(this.getName())) {
+
+                _logger.info(System.currentTimeMillis() + " joins *** " + _botPrimaryNick + " ***");
+
+            } else {
+
+                String prependedHostname = "@" + hostname;
+                if (prependedHostname.endsWith(_loggedHostnamePattern)) {
+                    _logger.info(System.currentTimeMillis() + " joins " + sender);
+                }
+
+            }
+        }
+    }
+
+    protected void onMessage(String channel, String sender, String login, String hostname, String message) {
+        message = message.replaceFirst("<.+?> ", "");
+        if (_isUserlistCommandEnabled && message.equals(_userlistCommandTrigger)) {
+
+            if (System.currentTimeMillis() - _lastUserlistCommandTimestamp < _commandAntiFloodInterval * 1000)
+                return;
+
+            Object[] users = getUsers(_ircChannel);
+            String output = "Userlist for " + _ircChannel + ": ";
+
+            for (int i = 0; i < users.length; i++)
+                output += "[" + ((User) users[i]).getNick() + "] ";
+
+            sendMessage(_ircChannel, output);
+            _lastUserlistCommandTimestamp = System.currentTimeMillis();
+        }
+    }
+
+    protected void onPart(String channel, String sender, String login, String hostname) {
+
+        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);
+                }
+            }
+        }
+
+    }
+
+    protected void onPrivateMessage(String sender, String login, String hostname, String message) {
+        /*
+         * Nobody else except the bot's owner can shut it down, unless of
+         * course the owner's nick isn't registered and someone's spoofing it.
+         */
+        if ((sender.equals(_ownerPrimaryNick) || sender.equals(_ownerSecondaryNick)) && message.equals(_botShutdownPassword)) {
+
+            if (_isLoggerEnabled)
+                _logger.info(System.currentTimeMillis() + " quits *** " + this.getName() + " ***");
+
+            _isIntentionalDisconnect = true;
+            disconnect();
+        }
+    }
+
+    protected void onQuit(String sourceNick, String sourceLogin, String sourceHostname, String reason) {
+        String prependedHostname = "@" + sourceHostname;
+
+        if (sourceNick.equals(_botPrimaryNick))
+            changeNick(_botPrimaryNick);
+
+        if (_isLoggerEnabled) {
+            if (prependedHostname.endsWith(_loggedHostnamePattern)) {
+                _logger.info(System.currentTimeMillis() + " quits " + sourceNick + " " + reason);
+            }
+        }
+
+    }
+
+    private void connectToServer() {
+
+        int loginAttempts = 0;
+
+        while (true) {
+            try {
+                connect(_ircServer, _ircServerPort);
+                break;
+            } catch (NickAlreadyInUseException e) {
+                if (loginAttempts == 1) {
+                    System.out.println("Sorry, the primary and secondary bot nicks are already taken. Exiting.");
+                    System.exit(1);
+                }
+                loginAttempts++;
+                try {
+                    Thread.sleep(5000);
+                } catch (InterruptedException e1) {
+                    // Hmph.
+                }
+
+                if (getName().equals(_botPrimaryNick))
+                    setName(_botSecondaryNick);
+                else
+                    setName(_botPrimaryNick);
+
+                continue;
+            } catch (IOException e) {
+                System.out.println("Error during login: ");
+                e.printStackTrace();
+                System.exit(1);
+            } catch (IrcException e) {
+                System.out.println("Error during login: ");
+                e.printStackTrace();
+                System.exit(1);
+            }
+        }
+        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;
+        DailyRollingFileAppender rollingFileAppender = null;
+
+        if (!(new File("logs").exists()))
+            (new File("logs")).mkdirs();
+
+        try {
+
+            if (_logFileRotationInterval.equals("monthly"))
+                rollingFileAppender = new DailyRollingFileAppender(new PatternLayout("%m%n"), logFilePath, "'.'yyyy-MM'.log'");
+            else if (_logFileRotationInterval.equals("weekly"))
+                rollingFileAppender = new DailyRollingFileAppender(new PatternLayout("%m%n"), logFilePath, "'.'yyyy-ww'.log'");
+            else
+                rollingFileAppender = new DailyRollingFileAppender(new PatternLayout("%m%n"), logFilePath, "'.'yyyy-MM-dd'.log'");
+
+            rollingFileAppender.setThreshold(Level.INFO);
+            _logger.addAppender(rollingFileAppender);
+        } catch (IOException ex) {
+            System.out.println("Error: Couldn't create or open an existing log file. Exiting.");
+            System.exit(1);
+        }
+    }
+
+}

apps/bogobot/Bogoparser.java

@@ -0,0 +1,353 @@
+/*
+ * bogoparser - A simple logfile analyzer for bogobot.
+ * 
+ * Bogoparser.java
+ * 2004 The I2P Project
+ * http://www.i2p.net
+ * This code is public domain.
+ */
+
+import java.io.BufferedReader;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * @author hypercubus
+ * @version 0.4
+ */
+public class Bogoparser {
+
+    private static void displayUsageAndExit() {
+        System.out.println("\r\nUsage:\r\n\r\n    java Bogoparser [--by-duration] <logfile>\r\n");
+        System.exit(1);
+    }
+
+    public static void main(String[] args) {
+
+        Bogoparser bogoparser;
+
+        if (args.length < 1 || args.length > 2)
+            displayUsageAndExit();
+
+        if (args.length == 2) {
+            if (!args[0].equals("--by-duration"))
+                displayUsageAndExit();
+            bogoparser = new Bogoparser(args[1], true);
+        }
+
+        if (args.length == 1)
+            bogoparser = new Bogoparser(args[0], false);
+    }
+
+    private Bogoparser(String logfile, boolean sortByDuration) {
+
+        ArrayList sortedSessions;
+
+        if (sortByDuration) {
+            sortedSessions = sortSessionsByDuration(calculateSessionDurations(sortSessionsByTime(readLogfile(logfile))));
+            formatAndOutputByDuration(sortedSessions);
+        } else {
+            sortedSessions = calculateSessionDurations(sortSessionsByQuitReason(sortSessionsByNick(sortSessionsByTime(readLogfile(logfile)))));
+            formatAndOutput(sortedSessions);
+        }
+    }
+
+    private ArrayList calculateSessionDurations(ArrayList sortedSessionsByQuitReasonOrDuration) {
+
+        ArrayList calculatedSessionDurations = new ArrayList();
+
+        for (int i = 0; i+1 < sortedSessionsByQuitReasonOrDuration.size(); i += 2) {
+
+            String   joinsEntry       = (String) sortedSessionsByQuitReasonOrDuration.get(i);
+            String[] joinsEntryFields = joinsEntry.split(" ");
+
+            String  quitsEntry = (String) sortedSessionsByQuitReasonOrDuration.get(i+1);
+            Pattern p          = Pattern.compile("^([^ ]+) [^ ]+ ([^ ]+) (.*)$");
+            Matcher m          = p.matcher(quitsEntry);
+
+            if (m.matches()) {
+
+                String currentJoinTime             = joinsEntryFields[0];
+                String currentNick                 = m.group(2);
+                String currentQuitReason           = m.group(3);
+                String currentQuitTime             = m.group(1);
+                long   joinsTimeInMilliseconds;
+                long   quitsTimeInMilliseconds;
+                long   sessionLengthInMilliseconds;
+                
+                joinsTimeInMilliseconds = Long.parseLong(currentJoinTime);
+                quitsTimeInMilliseconds = Long.parseLong(currentQuitTime);
+                sessionLengthInMilliseconds = quitsTimeInMilliseconds - joinsTimeInMilliseconds;
+                
+                String hours   = "" + sessionLengthInMilliseconds/1000/60/60;
+                String minutes = "" + (sessionLengthInMilliseconds/1000/60)%60;
+
+                if (hours.length() < 2)
+                    hours = "0" + hours;
+
+                if (hours.length() < 3)
+                    hours = "0" + hours;
+
+                if (minutes.length() < 2)
+                    minutes = "0" + minutes;
+
+                int    columnPadding       = 19-currentNick.length();
+                String columnPaddingString = " ";
+
+                for (int j = 0; j < columnPadding; j++)
+                    columnPaddingString = columnPaddingString + " ";
+
+                calculatedSessionDurations.add(sessionLengthInMilliseconds + " " + currentNick + columnPaddingString + " online " + hours + " hours " + minutes + " minutes " + currentQuitReason);
+            } else {
+                System.out.println("\r\nError: Unexpected entry in logfile: " + quitsEntry);
+                System.exit(1);
+            }
+        }
+        return calculatedSessionDurations;
+    }
+
+    private void formatAndOutput(ArrayList sortedSessions) {
+
+        String quitReason = null;
+
+        for (int i = 0; i < sortedSessions.size(); i++) {
+
+            String  entry = (String) sortedSessions.get(i);
+            Pattern p     = Pattern.compile("^[\\d]+ ([^ ]+ +online [\\d]+ hours [\\d]+ minutes) (.*)$");
+            Matcher m     = p.matcher(entry);
+
+            if (m.matches()) {
+
+                if (quitReason == null) {
+                    quitReason = m.group(2);
+                    System.out.println("\r\nQUIT: " + ((m.group(2).equals("")) ? "No Reason Given" : quitReason) + "\r\n");
+                }
+
+                String tempQuitReason = m.group(2);
+                String tempSession    = m.group(1);
+
+                if (tempQuitReason.equals(quitReason)) {
+                    System.out.println("    " + tempSession);
+                } else {
+                    quitReason = null;
+                    i -= 1;
+                    continue;
+                }
+            } else {
+                System.out.println("\r\nError: Unexpected entry in logfile: " + entry);
+                System.exit(1);
+            }
+        }
+        System.out.println("\r\n");
+    }
+
+    private void formatAndOutputByDuration(ArrayList sortedSessions) {
+        System.out.println("\r\n");
+
+        for (int i = 0; i < sortedSessions.size(); i++) {
+            String[] columns = ((String) sortedSessions.get(i)).split(" ", 2);
+            System.out.println(columns[1]);
+        }
+
+        System.out.println("\r\n");
+    }
+
+    private ArrayList readLogfile(String logfile) {
+
+        ArrayList log = new ArrayList();
+
+        try {
+            BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream(logfile)));
+
+            for (String line; (line = in.readLine()) != null; )
+                log.add(line);
+
+            in.close();
+
+        } catch (FileNotFoundException e) {
+            System.out.println("\r\nError: Can't find logfile '" + logfile + "'.\r\n");
+            System.exit(1);
+
+        } catch (IOException e) {
+            System.out.println("\r\nError: Can't read logfile '" + logfile + "'.\r\n");
+            System.exit(1);
+        }
+        return log;
+    }
+
+    /*
+     * Performs an odd-even transposition sort.
+     */
+    private ArrayList sortSessionsByDuration(ArrayList calculatedSessionDurations) {
+
+        for (int i = 0; i < calculatedSessionDurations.size()/2; i++) {
+            for (int j = 0; j+1 < calculatedSessionDurations.size(); j += 2) {
+
+                String[] currentDurationString = ((String) calculatedSessionDurations.get(j)).split(" ", 2);
+                long     currentDuration       = Long.parseLong(currentDurationString[0]);
+                String[] nextDurationString    = ((String) calculatedSessionDurations.get(j+1)).split(" ", 2);
+                long     nextDuration          = Long.parseLong(nextDurationString[0]);
+
+                if (currentDuration > nextDuration) {
+                    calculatedSessionDurations.add(j, calculatedSessionDurations.get(j+1));
+                    calculatedSessionDurations.remove(j+2);
+                }
+            }
+
+            for (int j = 1; j+1 < calculatedSessionDurations.size(); j += 2) {
+
+                String[] currentDurationString = ((String) calculatedSessionDurations.get(j)).split(" ", 2);
+                long     currentDuration       = Long.parseLong(currentDurationString[0]);
+                String[] nextDurationString    = ((String) calculatedSessionDurations.get(j+1)).split(" ", 2);
+                long     nextDuration          = Long.parseLong(nextDurationString[0]);
+
+                if (currentDuration > nextDuration) {
+                    calculatedSessionDurations.add(j, calculatedSessionDurations.get(j+1));
+                    calculatedSessionDurations.remove(j+2);
+                }
+            }
+        }
+        return calculatedSessionDurations;
+    }
+
+    private ArrayList sortSessionsByNick(ArrayList sortedSessionsByTime) {
+
+        ArrayList sortedSessionsByNick = new ArrayList();
+
+        while (sortedSessionsByTime.size() != 0) {
+
+            String   entry       = (String) sortedSessionsByTime.get(0);
+            String[] entryFields = entry.split(" ");
+            String   currentNick = entryFields[2];
+
+            sortedSessionsByNick.add(entry);
+            sortedSessionsByNick.add(sortedSessionsByTime.get(1));
+            sortedSessionsByTime.remove(0);
+            sortedSessionsByTime.remove(0);
+            for (int i = 0; i+1 < sortedSessionsByTime.size(); i += 2) {
+
+                String   nextEntry       = (String) sortedSessionsByTime.get(i);
+                String[] nextEntryFields = nextEntry.split(" ");
+
+                if (nextEntryFields[2].equals(currentNick)) {
+                    sortedSessionsByNick.add(nextEntry);
+                    sortedSessionsByNick.add(sortedSessionsByTime.get(i+1));
+                    sortedSessionsByTime.remove(i);
+                    sortedSessionsByTime.remove(i);
+                    i -= 2;
+                }
+            }
+        }
+        return sortedSessionsByNick;
+    }
+
+    private ArrayList sortSessionsByQuitReason(ArrayList sortedSessionsByNick) {
+
+        ArrayList sortedSessionsByQuitReason = new ArrayList();
+
+        while (sortedSessionsByNick.size() != 0) {
+
+            String  entry = (String) sortedSessionsByNick.get(1);
+            Pattern p     = Pattern.compile("^[^ ]+ [^ ]+ [^ ]+ (.*)$");
+            Matcher m     = p.matcher(entry);
+
+            if (m.matches()) {
+
+                String currentQuitReason = m.group(1);
+
+                sortedSessionsByQuitReason.add(sortedSessionsByNick.get(0));
+                sortedSessionsByQuitReason.add(entry);
+                sortedSessionsByNick.remove(0);
+                sortedSessionsByNick.remove(0);
+                for (int i = 0; i+1 < sortedSessionsByNick.size(); i += 2) {
+
+                    String  nextEntry = (String) sortedSessionsByNick.get(i+1);
+                    Pattern p2        = Pattern.compile("^[^ ]+ [^ ]+ [^ ]+ (.*)$");
+                    Matcher m2        = p2.matcher(nextEntry);
+
+                    if (m2.matches()) {
+
+                        String nextQuitReason = m2.group(1);
+ 
+                        if (nextQuitReason.equals(currentQuitReason)) {
+                            sortedSessionsByQuitReason.add(sortedSessionsByNick.get(i));
+                            sortedSessionsByQuitReason.add(nextEntry);
+                            sortedSessionsByNick.remove(i);
+                            sortedSessionsByNick.remove(i);
+                            i -= 2;
+                        }
+                    } else {
+                        System.out.println("\r\nError: Unexpected entry in logfile: " + nextEntry);
+                        System.exit(1);
+                    }
+                }
+            } else {
+                System.out.println("\r\nError: Unexpected entry in logfile: " + entry);
+                System.exit(1);
+            }
+        }
+        return sortedSessionsByQuitReason;
+    }
+
+    /**
+     * Sessions terminated with "parts" messages instead of "quits" are filtered
+     * out.
+     */
+    private ArrayList sortSessionsByTime(ArrayList log) {
+
+        ArrayList sortedSessionsByTime = new ArrayList();
+
+        mainLoop:
+            while (log.size() > 0) {
+                
+                String   entry       = (String) log.get(0);
+                String[] entryFields = entry.split(" ");
+                
+                if (entryFields[1].equals("quits") && !entryFields[1].equals("joins")) {
+                    /*
+                     * Discard entry. The specified log either doesn't contain
+                     * the corresponding "joins" time for this quit entry or the
+                     * entry is a "parts" or unknown message, and in both cases
+                     * the entry's data is useless.
+                     */
+                    log.remove(0);
+                    continue;
+                }
+                
+                for (int i = 1; i < log.size(); i++) {  // Find corresponding "quits" entry.
+                    
+                    String   tempEntry       = (String) log.get(i);
+                    String[] tempEntryFields = tempEntry.split(" ");
+                    
+                    if (tempEntryFields[2].equals(entryFields[2])) {  // Check if the nick fields for the two entries match.
+                        if (!tempEntryFields[1].equals("quits")) {
+                            if (tempEntryFields[1].equals("joins")) {  // Don't discard a subsequent "joins" entry.
+                                log.remove(0);
+                                continue mainLoop;
+                            }
+                            log.remove(i);
+                            continue;
+                        }
+                        sortedSessionsByTime.add(entry);
+                        sortedSessionsByTime.add(tempEntry);
+                        log.remove(i);
+                        break;
+                    }
+                }
+                /*
+                 * Discard "joins" entry. The specified log doesn't contain the
+                 * corresponding "quits" time for this entry so the entry's
+                 * data is useless.
+                 */
+                
+                log.remove(0);
+            }
+
+        return sortedSessionsByTime;
+    }
+}

apps/bogobot/LICENSE.log4j.txt

@@ -0,0 +1,48 @@
+/*
+ * ============================================================================
+ *                   The Apache Software License, Version 1.1
+ * ============================================================================
+ * 
+ *    Copyright (C) 1999 The Apache Software Foundation. All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modifica-
+ * tion, are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of  source code must  retain the above copyright  notice,
+ *    this list of conditions and the following disclaimer.
+ * 
+ * 2. 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.
+ * 
+ * 3. The end-user documentation included with the redistribution, if any, must
+ *    include  the following  acknowledgment:  "This product includes  software
+ *    developed  by the  Apache Software Foundation  (http://www.apache.org/)."
+ *    Alternately, this  acknowledgment may  appear in the software itself,  if
+ *    and wherever such third-party acknowledgments normally appear.
+ * 
+ * 4. The names "log4j" and  "Apache Software Foundation"  must not be used to
+ *    endorse  or promote  products derived  from this  software without  prior
+ *    written permission. For written permission, please contact
+ *    apache@apache.org.
+ * 
+ * 5. Products  derived from this software may not  be called "Apache", nor may
+ *    "Apache" appear  in their name,  without prior written permission  of the
+ *    Apache Software Foundation.
+ * 
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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
+ * APACHE SOFTWARE  FOUNDATION  OR ITS CONTRIBUTORS  BE LIABLE FOR  ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL,  EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLU-
+ * DING, 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.
+ * 
+ * This software  consists of voluntary contributions made  by many individuals
+ * on  behalf of the Apache Software  Foundation.  For more  information on the 
+ * Apache Software Foundation, please see <http://www.apache.org/>.
+ *
+ */

apps/bogobot/LICENSE.pircbot.txt

@@ -0,0 +1,340 @@
+		    GNU GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+                       59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+		    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+			    NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+	    How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Library General
+Public License instead of this License.

apps/bogobot/bogobot.bat

@@ -0,0 +1 @@
+java -cp .;log4j-1.2.8.jar;pircbot.jar Bogobot

apps/bogobot/bogobot.config

@@ -0,0 +1,101 @@
+#####
+# Bogobot user configuration
+#####
+
+###
+# The bot's nick and backup nick. You will probably want to register these with
+# the IRC server's NickServ.(a NickServ interface is forthcoming).
+#
+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
+# probably want to register these with the IRC server's NickServ.
+#
+ownerPrimaryNick=somenick
+ownerSecondaryNick=somenick_
+
+###
+# The bot will disconnect and shut down when sent this password via private
+# message (aka query) from either of the owner nicks specified above. DO NOT USE
+# THIS DEFAULT VALUE!
+#
+botShutdownPassword=take off eh
+
+###
+# The server, channel, and port the bot will connect to.
+#
+ircChannel=#i2p-chat
+ircServer=irc.duck.i2p
+ircServerPort=6668
+
+###
+# Set to "true" to enable logging, else "false" (but don't use quotation marks).
+#
+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.
+#
+logFilePrefix=irc.duck.i2p.i2p-chat
+
+###
+# How often the logs should be rotated. Either "daily", "weekly", or "monthly"
+# (but don't use quotation marks).
+#
+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).
+#
+isUserlistCommandEnabled=true
+
+###
+# The userlist trigger command to listen for. It is a good idea to prefix
+# triggers with some non-alphanumeric character in order to avoid accidental
+# trigger use during normal channel conversation. In most cases you will
+# probably want to choose a unique trigger here that no other bots in the
+# channel will respond to.
+#
+userlistCommandTrigger=!who
+
+###
+# The number of seconds to rest after replying to a userlist command issued by
+# a user in the channel. The bot will ignore subsequent userlist commands during
+# this period. This helps prevent flooding.
+#
+commandAntiFloodInterval=60

apps/bogobot/bogobot.sh

@@ -0,0 +1,2 @@
+#!/bin/sh
+java -cp .:log4j-1.2.8.jar:pircbot.jar Bogobot

apps/bogobot/build-eclipse.xml

@@ -0,0 +1,58 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!-- ********************************************************** -->
+<!-- bogobot - A simple join/part stats logger bot for I2P IRC. -->
+<!--                                                            -->
+<!-- build-eclipse.xml                                          -->
+<!-- 2004 The I2P Project                                       -->
+<!-- http://www.i2p.net                                         -->
+<!-- This code is public domain.                                -->
+<!--                                                            -->
+<!-- authors: hypercubus, oOo                                   -->
+<!-- version 0.4                                                -->
+<!-- ********************************************************** -->
+
+<project basedir="." default="dist" name="Bogobot">
+
+    <!-- init:
+    Create distribution directory if missing and initialize time stamp for
+    archive naming -->
+    <target name="init">
+        <mkdir dir="dist" />
+        <tstamp>
+            <format pattern="yyyy-MM-dd" property="DSTAMP" />
+        </tstamp>
+    </target>
+
+    <!-- dist.bin:
+    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.config Bogobot.class bogobot.sh Bogoparser.class LICENSE_log4j.txt LICENSE_pircbot.txt log4j-1.2.8.jar pircbot.jar" />
+        </zip>
+    </target>
+
+    <!-- dist.source:
+    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.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>
+
+    <!-- dist:
+    Create both the binary and source distribution archives -->
+    <target depends="dist.bin,dist.source" description="Create both the binary and source distribution archives" name="dist">
+        <echo message="Successfully created binary and source distribution archives in directory &apos;dist&apos;." />
+    </target>
+
+    <!-- clean:
+    Delete all class files and temporary directories -->
+    <target description="Delete all class files and temporary directories" name="clean">
+        <delete>
+            <fileset dir="${basedir}" includes="**/*.class" />
+        </delete>
+        <echo message="Clean successful." />
+    </target>
+
+</project>

apps/bogobot/build.xml

@@ -0,0 +1,64 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!-- ********************************************************** -->
+<!-- bogobot - A simple join/part stats logger bot for I2P IRC. -->
+<!--                                                            -->
+<!-- build.xml                                                  -->
+<!-- 2004 The I2P Project                                       -->
+<!-- http://www.i2p.net                                         -->
+<!-- This code is public domain.                                -->
+<!--                                                            -->
+<!-- authors: hypercubus, oOo                                   -->
+<!-- version 0.4                                                -->
+<!-- ********************************************************** -->
+
+<project basedir="." default="compile" name="Bogobot">
+
+    <!-- init:
+    Create distribution directory if missing and initialize time stamp for
+    archive naming -->
+    <target name="init">
+        <mkdir dir="dist" />
+        <tstamp>
+            <format pattern="yyyy-MM-dd" property="DSTAMP" />
+        </tstamp>
+    </target>
+
+    <!-- compile:
+    Compile source code -->
+    <target depends="init" description="Compile source code" name="compile">
+        <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.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>
+
+    <!-- dist.source:
+    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.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>
+
+    <!-- dist:
+    Create both the binary and source distribution archives -->
+    <target depends="dist.bin,dist.source" description="Create both the binary and source distribution archives" name="dist">
+        <echo message="Successfully created binary and source distribution archives in directory &apos;dist&apos;." />
+    </target>
+
+    <!-- clean:
+    Delete all class files and temporary directories -->
+    <target description="Delete all class files and temporary directories" name="clean">
+        <delete>
+            <fileset dir="${basedir}" includes="**/*.class" />
+        </delete>
+        <echo message="Clean successful." />
+    </target>
+
+</project>

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,163 +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 <cstdarg>
-#include <cstdio>
-#include <iostream>
-#include <string>
-using namespace std;
-#include "mutex.hpp"
-#include "time.hpp"
-#include "logger.hpp"
-using namespace Libsockthread;
-
-/*
- * Closes the log file
- */
-void Logger::close(void)
-{
-	logf_m.lock();
-	if (logf == 0) {
-		logf_m.unlock();
-		return;
-	}
-	if (fclose(logf) == EOF) {
-		cerr_m.lock();
-		cerr << "fclose() failed: " << strerror(errno) << '\n';
-		cerr_m.unlock();
-	}
-	logf = 0;
-	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);
-	string s;
-	Time t;
-	logf_m.lock();
-
-	if (logf != 0) {
-		/*
-		 * Remember!  If you change the format here, change it in the else too
-		 */
-		fprintf(logf, "%c %s ", ll, t.utc(s).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(s).c_str());
-		vfprintf(stderr, format, ap);
-		fputc('\n', stderr);
-	}
-
-	va_end(ap);
-	logf_m.unlock();
-
-	return;
-}
-
-/*
- * Opens a log file for appending.  If there already is an open log file, 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 -lpthread
-int main(void)
-{
-	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,96 +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_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
- *
- * Obviously, these only work if your Logger object is called "logger" and is
- * global
- */
-// 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:
-			typedef enum {DEBUG = 0, MINOR = 1, INFO = 2, WARN = 3, ERROR = 4}
-				priority_t;
-
-			Logger(void)
-				: logf(0), loglevel(Logger::DEBUG) { }
-			~Logger(void) { close(); }
-
-			void close(void);
-			void log(priority_t priority, const char* format, ...);
-			priority_t get_loglevel(void)
-				{ 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,136 +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.
- */
-
-// Modelled after JThread by Jori Liesenborgs
-
-#include <cassert>
-#include "platform.hpp"
-#ifdef WINTHREAD
-	#include <windows.h>
-#else
-	#include <pthread.h>
-#endif
-using namespace std;
-#include "mutex.hpp"
-using namespace Libsockthread;
-
-/*
- * Creates a mutex
- */
-Mutex::Mutex(void)
-{
-#ifdef WINTHREAD
-	mutex = CreateMutex(0, false, 0);
-	assert(mutex != 0);
-#else
-	int rc = pthread_mutex_init(&mutex, 0);
-	assert(rc == 0);
-#endif
-}
-
-/*
- * Destroys a mutex
- */
-Mutex::~Mutex(void)
-{
-#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(void)
-{
-#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(void)
-{
-#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 -lpthread
-#include <iostream>
-#include "thread.hpp"
-
-Mutex widget;
-
-int main(void)
-{
-	class Mutex_test : public Thread
-	{
-		public:
-			Mutex_test(int n)
-				: testval(n) {}
-
-			void* thread(void)
-			{
-				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,53 +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.
- */
-
-// Modelled after JThread by Jori Liesenborgs
-
-#ifndef LIBSOCKTHREAD_MUTEX_HPP
-#define LIBSOCKTHREAD_MUTEX_HPP
-
-namespace Libsockthread {
-	class Mutex {
-		public:
-			Mutex(void);
-			~Mutex(void);
-
-			void lock(void);
-			void unlock(void);
-		private:
-#ifdef WINTHREAD
-			HANDLE mutex;
-#else
-			pthread_mutex_t mutex;
-#endif
-	};
-}
-
-#endif  // LIBSOCKTHREAD_MUTEX_HPP

apps/enclave/libsockthread/src/platform.hpp

@@ -1,63 +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_PLATFORM_HPP
-#define LIBSOCKTHREAD_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 INET_ADDRSTRLEN 16
-	#define NO_GETHOSTBYNAME2
-	#define NO_INET_ATON  /* implies NO_INET_PTON */
-	#define NO_INET_NTOP
-	#define WINSOCK
-	#define WINTHREAD
-#endif
-
-#if OS == LINUX
-	#define NO_GETHOSTBYNAME2
-#endif
-
-#if OS == CYGWIN
-	#define FAST32_IS_LONG
-	#define INET_ADDRSTRLEN 16
-	#define NO_GETHOSTBYNAME2
-	#define NO_INET_NTOP
-	#define NO_INET_PTON
-#endif
-
-#endif  // LIBSOCKTHREAD_PLATFORM_HPP

apps/enclave/libsockthread/src/socket.cpp

@@ -1,277 +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 <cassert>
-using namespace std;
-#include "platform.hpp"
-#include "socket.hpp"
-using namespace Libsockthread;
-
-size_t Socket::total = 0;  // the total number of sockets in use
-
-/*
- * Constructs an IPv4 TCP socket
- */
-Socket::Socket(void)
-{
-	++total;
-	try {
-#ifdef WINSOCK
-		if (total == 1)
-			winsock_startup();
-#endif
-		create_socket(PF_INET, SOCK_STREAM);
-	} catch (const Socket_error& x) {
-		--total;
-		throw;
-	}
-}
-
-/*
- * Constructs the socket
- *
- * domain - either PF_INET or PF_INET6
- * type - either SOCK_STREAM or SOCK_DGRAM
- */
-Socket::Socket(int domain, int type)
-{
-	++total;
-	try {
-#ifdef WINSOCK
-		if (total == 1)
-			winsock_startup();
-#endif
-		create_socket(domain, type);
-	} catch {const Socket_error& x) {
-		--total;
-		throw;
-	}
-}
-
-/*
- * Destroys the socket
- */
-Socket::~Socket(void)
-{
-	close();
-	--total;
-	assert(total >= 0);
-#ifdef WINSOCK
-	if (total == 0)
-		winsock_cleanup();
-#endif
-}
-
-/*
- * Closes the socket
- */
-void Socket::close(void)
-{
-#ifdef WINSOCK
-	if (closesocket(sock) == SOCKET_ERROR) {
-		LERROR("closesocket() failed: %s", winsock_strerror(WSAGetLastError()));
-	}
-#else
-	if (close(sock) == -1) {
-		LERROR("close() failed: %s", strerror(errno));
-	}
-#endif
-}
-
-/*
- * Creates the socket
- *
- * domain - either PF_INET or PF_INET6
- * type - either SOCK_STREAM or SOCK_DGRAM
- */
-void Socket::create_socket(int domain, int type)
-{
-	assert((domain == PF_INET || domain == PF_INET6) &&
-		(type == SOCK_STREAM || type == SOCK_DGRAM));
-	sock = socket(domain, type, 0);
-#ifdef WINSOCK
-	if (sock == INVALID_SOCKET)
-		throw Socket_error(sam_winsock_strerror(WSAGetLastError()));
-#else
-	if (sock == -1)
-		throw Socket_error(strerror(errno));
-#endif
-}
-
-#ifdef WINSOCK
-/*
- * Unloads the Winsock network subsystem
- */
-void Socket::winsock_cleanup(void)
-{
-	int rc = WSACleanup();
-	assert(rc != SOCKET_ERROR);
-}
-
-/*
- * Loads the Winsock network sucksystem
- */
-void Socket::winsock_startup(void)
-{
-	WORD wVersionRequested = MAKEWORD(2, 2);
-	WSADATA wsaData;
-	int rc = WSAStartup(wVersionRequested, &wsaData);
-	if (rc != 0)
-		throw Socket_error(winsock_strerror(rc));
-	if (LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 2) {
-		winsock_cleanup();
-		throw Socket_error("Bad Winsock version");
-	}
-}
-
-/*
- * Apparently Winsock does not have a strerror() equivalent for its functions
- *
- * code - code from WSAGetLastError()
- *
- * Returns: error string (from http://msdn.microsoft.com/library/default.asp?
- *		url=/library/en-us/winsock/winsock/windows_sockets_error_codes_2.asp)
- */
-const char* Socket::winsock_strerror(int code)
-{
-	switch (code) {
-		case WSAEINTR:
-			return "Interrupted function call";
-		case WSAEACCES:  // yes, that is the correct spelling
-			return "Permission denied";
-		case WSAEFAULT:
-			return "Bad address";
-		case WSAEINVAL:
-			return "Invalid argument";
-		case WSAEMFILE:
-			return "Too many open files";
-		case WSAEWOULDBLOCK:
-			return "Resource temporarily unavailable";
-		case WSAEINPROGRESS:
-			return "Operation now in progress";
-		case WSAEALREADY:
-			return "Operation already in progress";
-		case WSAENOTSOCK:
-			return "Socket operations on nonsocket";
-		case WSAEDESTADDRREQ:
-			return "Destination address required";
-		case WSAEMSGSIZE:
-			return "Message too long";
-		case WSAEPROTOTYPE:
-			return "Protocol wrong type for socket";
-		case WSAENOPROTOOPT:
-			return "Bad protocol option";
-		case WSAEPROTONOSUPPORT:
-			return "Protocol not supported";
-		case WSAESOCKTNOSUPPORT:
-			return "Socket type not supported";
-		case WSAEOPNOTSUPP:
-			return "Operation not supported";
-		case WSAEPFNOSUPPORT:
-			return "Protocol family not supported";
-		case WSAEAFNOSUPPORT:
-			return "Address family not supported by protocol family";
-		case WSAEADDRINUSE:
-			return "Address already in use";
-		case WSAEADDRNOTAVAIL:
-			return "Cannot assign requested address";
-		case WSAENETDOWN:
-			return "Network is down";
-		case WSAENETUNREACH:
-			return "Network is unreachable";
-		case WSAENETRESET:
-			return "Network dropped connection on reset";
-		case WSAECONNABORTED:
-			return "Software caused connection abort";
-		case WSAECONNRESET:
-			return "Connection reset by peer";
-		case WSAENOBUFS:
-			return "No buffer space available";
-		case WSAEISCONN:
-			return "Socket is already connected";
-		case WSAENOTCONN:
-			return "Socket is not connected";
-		case WSAESHUTDOWN:
-			return "Cannot send after socket shutdown";
-		case WSAETIMEDOUT:
-			return "Connection timed out";
-		case WSAECONNREFUSED:
-			return "Connection refused";
-		case WSAEHOSTDOWN:
-			return "Host is down";
-		case WSAEHOSTUNREACH:
-			return "No route to host";
-		case WSAEPROCLIM:
-			return "Too many processes";
-		case WSASYSNOTREADY:
-			return "Network subsystem is unavailable";
-		case WSAVERNOTSUPPORTED:
-			return "Winsock.dll version out of range";
-		case WSANOTINITIALISED:
-			return "Successful WSAStartup not yet performed";
-		case WSAEDISCON:
-			return "Graceful shutdown in progress";
-		case WSATYPE_NOT_FOUND:
-			return "Class type not found";
-		case WSAHOST_NOT_FOUND:
-			return "Host not found";
-		case WSATRY_AGAIN:
-			return "Nonauthoritative host not found";
-		case WSANO_RECOVERY:
-			return "This is a nonrecoverable error";
-		case WSANO_DATA:
-			return "Valid name, no data record of requested type";
-/* None of this shit compiles under Mingw - who knows why...
-		case WSA_INVALID_HANDLE:
-			return "Specified event object handle is invalid";
-		case WSA_INVALID_PARAMETER:
-			return "One or more parameters are invalid";
-		case WSA_IO_INCOMPLETE:
-			return "Overlapped I/O event object not in signaled state";
-		case WSA_IO_PENDING:
-			return "Overlapped operations will complete later";
-		case WSA_NOT_ENOUGH_MEMORY:
-			return "Insufficient memory available";
-		case WSA_OPERATION_ABORTED:
-			return "Overlapped operation aborted";
-		case WSAINVALIDPROCTABLE:
-			return "Invalid procedure table from service provider";
-		case WSAINVALIDPROVIDER:
-			return "Invalid service provider version number";
-		case WSAPROVIDERFAILEDINIT:
-			return "Unable to initialize a service provider";
-*/
-		case WSASYSCALLFAILURE:
-			return "System call failure";
-		default:
-			return "Unknown error";
-	}
-}
-#endif  // WINSOCK

apps/enclave/libsockthread/src/socket.hpp

@@ -1,64 +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_HPP
-#define LIBSOCKTHREAD_SOCKET_HPP
-
-namespace Libsockthread {
-	class Socket_error : public runtime_error {
-		public:
-			Socket_error(const string& s)
-				: runtime_error(s) { }
-	};
-	class Socket {
-		public:
-			Socket(void);  // throws Socket_error
-			Socket(int domain, int type);  // throws Socket_error
-			~Socket(void);
-
-			void close(void);
-		private:
-#ifdef WINSOCK
-			typedef SOCKET socket_t;
-
-			void winsock_cleanup(void);
-			void winsock_startup(void);  // throws Socket_error
-			const char* winsock_strerror(int code);
-#else
-			typedef int socket_t;
-#endif
-			void create_socket(int domain, int type);  // throws Socket_error
-
-			socket_t sock;
-			static size_t total;  // the total number of sockets in memory
-	};
-}
-
-#endif  // LIBSOCKTHREAD_SOCKET_HPP

apps/enclave/libsockthread/src/socket_addr.cpp

@@ -1,83 +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 <arpa/inet.h>
-#include <cassert>
-using namespace std;
-#include "platform.hpp"
-#include "socket.hpp"
-#include "socket_addr.hpp"
-using namespace Libsockthread;
-
-Socket_addr::Socket_addr(int domain, const string& host, uint16_t port)
-	: domain(domain), host(host), port(port)
-{
-	memset(&hostaddr, 0, sizeof hostaddr);
-	hostaddr.sin_family = domain;
-	hostaddr.sin_port = htons(port);
-	resolve(host.c_str(), ipaddr);
-	int rc;
-#ifdef NO_INET_ATON
-	rc = hostaddr.sin_addr.s_addr = inet_addr(ipaddr);
-#elif defined NO_INET_PTON
-	rc = inet_aton(ipaddr, &hostaddr.sin_addr);
-#else
-	rc = inet_pton(AF_INET, ipaddr, &hostaddr.sin_addr);
-#endif
-	assert(rc != 0 && rc != -1);
-}
-
-/*
- * Performs a DNS lookup on `hostname' and puts the result in `ipaddr'
- */
-bool Socket::resolve(const char* hostname, char* ipaddr)
-{
-	struct hostent *h;
-#ifdef NO_GETHOSTBYNAME2
-	h = gethostbyname(hostname);
-#else
-	h = gethostbyname2(hostname, domain);
-#endif
-	if (h == 0) {
-		LWARN("DNS resolution failed for %s", hostname);
-		throw Socket_error("DNS resolution failed");
-	}
-	struct in_addr a;
-	a.s_addr = ((struct in_addr *)h->h_addr)->s_addr;
-#ifdef NO_INET_NTOP
-	char *tmp;
-	tmp = inet_ntoa(a);
-	assert(tmp != 0);
-	strlcpy(ipaddr, tmp, INET_ADDRSTRLEN);  // inet_ntoa() was very poorly designed
-#else
-	int rc = inet_ntop(domain, &a, ipaddr, INET_ADDRSTRLEN);
-	assert(rc != 0);
-#endif
-}

apps/enclave/libsockthread/src/socket_addr.hpp

@@ -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.
- */
-
-#ifndef LIBSOCKTHREAD_SOCKET_ADDR_HPP
-#define LIBSOCKTHREAD_SOCKET_ADDR_HPP
-
-namespace Libsockthread {
-	class Socket_addr {
-		public:
-			Socket_addr(int domain, const string& host, uint16_t port);
-		private:
-			bool resolve(const char* hostname, char* ipaddr);
-
-			int domain;  // PF_INET or PF_INET6
-			string host;
-			char ipaddr[INET_ADDRSTRLEN];
-			struct sockaddr_in hostaddr;
-			uint16_t port;
-	};
-}
-
-#endif  // LIBSOCKTHREAD_SOCKET_ADDR_HPP

apps/enclave/libsockthread/src/strl.c

@@ -1,84 +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.
- */
-
-#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,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.
- */
-
-/*
- * 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,199 +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.
- */
-
-// Modelled after JThread by Jori Liesenborgs
-
-#include <cassert>
-#include "platform.hpp"
-#ifdef WINTHREAD
-	#include <windows.h>
-#else
-	#include <pthread.h>
-#endif
-using namespace std;
-#include "mutex.hpp"
-#include "thread.hpp"
-using namespace Libsockthread;
-
-/*
- * Gets the return value of a finished thread
- */
-void* Thread::get_retval(void)
-{
-	void* val;
-	running_m.lock();
-	if (running)
-		val = 0;
-	else
-		val = retval;
-	running_m.unlock();
-	return val;
-}
-
-/*
- * Checks whether the thread is running
- */
-bool Thread::is_running(void)
-{
-	running_m.lock();
-	bool r = running;
-	running_m.unlock();
-	return r;
-}
-
-/*
- * Stops the thread
- * Generally NOT a good idea
- */
-void Thread::kill(void)
-{
-	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, 0);
-	assert(rc);
-#else
-	int rc = pthread_cancel(id);
-	assert(rc == 0);
-#endif
-	running = false;
-	running_m.unlock();
-}
-
-/*
- * Starts the thread
- */
-void Thread::start(void)
-{
-#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(0, 0, &the_thread, this, 0, &id);
-	assert(handle != 0);
-#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 -lpthread
-#include <iostream>
-
-int main(void)
-{
-	class Thread_test : public Thread
-	{
-		public:
-			Thread_test(int testval)
-				: testval(testval) { }
-
-			int get_testval(void)
-			{
-				testval_m.lock();
-				int rc = testval;
-				testval_m.unlock();
-				return rc;
-			}
-
-			void *thread(void)
-			{
-				// 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,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.
- */
-
-// Modelled after JThread by Jori Liesenborgs
-
-#ifndef LIBSOCKTHREAD_THREAD_HPP
-#define LIBSOCKTHREAD_THREAD_HPP
-
-namespace Libsockthread {
-	class Thread {
-		public:
-			Thread(void)
-				: retval(0), running(false) { }
-			virtual ~Thread(void)
-				{ kill(); }
-
-			void* get_retval(void);
-			bool is_running(void);
-			void kill(void);
-			void start(void);
-			virtual void *thread(void) = 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,94 +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 <ctime>
-#include <string>
-using namespace std;
-#include "time.hpp"
-using namespace Libsockthread;
-
-/*
- * Converts the time to an ISO 8601 standard time and date and puts it in a
- * string
- * Example: 2004-07-01T19:03:47Z
- */
-string& Time::utc(string &s) const
-{
-	struct tm* tm;
-
-	tm = gmtime(&unixtime);
-	char t[21];
-	strftime(t, sizeof t, "%Y-%m-%dT%H:%M:%SZ", tm);
-	return s = t;
-}
-
-/*
- * Converts the time to an ISO 8601 standard date and puts it in a string
- * Example: 2004-07-01Z
- */
-string& Time::utc_date(string &s) const
-{
-	struct tm* tm;
-
-	tm = gmtime(&unixtime);
-	char t[12];
-	strftime(t, sizeof t, "%Y-%m-%dZ", tm);
-	return s = t;
-}
-
-/*
- * Converts the time to an ISO 8601 standard time and puts it in a string
- * Example: 19:03:47Z
- */
-string& Time::utc_time(string &s) const
-{
-	struct tm* tm;
-
-	tm = gmtime(&unixtime);
-	char t[10];
-	strftime(t, sizeof t, "%H:%M:%SZ", tm);
-	return s = t;
-}
-
-#ifdef UNIT_TEST
-// g++ -Wall -DUNIT_TEST time.cpp -o time
-#include <iostream>
-
-int main(void)
-{
-	Time t;
-	string s;
-	cout << "Current date and time is " << t.utc(s) << '\n';
-	cout << "Current date is " << t.utc_date(s) << '\n';
-	cout << "Current time is " << t.utc_time(s) << '\n';
-
-	return 0;
-}
-#endif  // UNIT_TEST

apps/enclave/libsockthread/src/time.hpp

@@ -1,48 +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_TIME_HPP
-#define LIBSOCKTHREAD_TIME_HPP
-
-namespace Libsockthread {
-	class Time {
-		public:
-			Time(void) { now(); }
-
-			void now(void) { unixtime = time(0); }
-			string& utc(string &s) const;
-			string& utc_date(string &s) const;
-			string& utc_time(string &s) const;
-		private:
-			time_t unixtime;
-	};
-}
-
-#endif  // LIBSOCKTHREAD_TIME_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/build.xml

@@ -9,12 +9,12 @@
     <target name="compile">
         <mkdir dir="./build" />
         <mkdir dir="./build/obj" />
-        <javac srcdir="./src" debug="true" target="1.1" source="1.3" deprecation="on" destdir="./build/obj" includes="**/*.java" excludes="net/i2p/heartbeat/gui/**" classpath="../../../core/java/build/i2p.jar" />
+        <javac srcdir="./src" debug="true" deprecation="on" source="1.3" target="1.3" destdir="./build/obj" includes="**/*.java" excludes="net/i2p/heartbeat/gui/**" classpath="../../../core/java/build/i2p.jar" />
     </target>
     <target name="compileGUI">
         <mkdir dir="./build" />
         <mkdir dir="./build/obj" />
-        <javac debug="true" target="1.1" source="1.3" deprecation="on" destdir="./build/obj">
+        <javac debug="true" source="1.3" target="1.3" deprecation="on" destdir="./build/obj">
             <src path="src/" />
             <classpath path="../../../core/java/build/i2p.jar" />
             <classpath path="../../jfreechart/jfreechart-0.9.17/lib/jcommon-0.9.2.jar" />

apps/heartbeat/java/src/net/i2p/heartbeat/PeerData.java

@@ -27,7 +27,7 @@ public class PeerData {
     /** date sent (Long) to EventDataPoint containing the datapoints sent in the current period */
     private Map _dataPoints;
     /** date sent (Long) to EventDataPoint containing pings that haven't yet timed out or been ponged */
-    private Map _pendingPings;
+    private TreeMap _pendingPings;
     private long _sessionStart;
     private long _lifetimeSent;
     private long _lifetimeReceived;
@@ -208,14 +208,32 @@ public class PeerData {
     public void pongReceived(long dateSent, long pongSent) {
         long now = Clock.getInstance().now();
         synchronized (_updateLock) {
-            EventDataPoint data = (EventDataPoint) _pendingPings.remove(new Long(dateSent));
+            if (_pendingPings.size() <= 0) {
+                _log.warn("Pong received (sent at " + dateSent + ", " + (now-dateSent) 
+                          + "ms ago, pong delay " + (pongSent-dateSent) + "ms, pong receive delay "
+                          + (now-pongSent) + "ms)");
+                return;
+            }
+            Long first = (Long)_pendingPings.firstKey();
+            EventDataPoint data = (EventDataPoint)_pendingPings.remove(new Long(dateSent));
+            
             if (data != null) {
                 data.setPongReceived(now);
                 data.setPongSent(pongSent);
                 data.setWasPonged(true);
                 locked_addDataPoint(data);
+                
+                if (dateSent != first.longValue()) {
+                    _log.error("Out of order delivery: received " + dateSent 
+                               + " but the first pending is " + first.longValue()
+                               + " (delta " + (dateSent - first.longValue()) + ")");
+                } else {
+                    _log.info("In order delivery for " + dateSent + " in ping " 
+                               + _peer.getComment());
+                }
             } else {
                 _log.warn("Pong received, but no matching ping?  ping sent at = " + dateSent);
+                return;
             }
         }
         _sendRate.addData(pongSent - dateSent, 0);
@@ -256,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
@@ -391,4 +409,4 @@ public class PeerData {
             _wasPonged = pong;
         }
     }
-}
+}

apps/httptunnel/java/build.xml

@@ -11,7 +11,7 @@
         <mkdir dir="./build/obj" />
         <javac 
             srcdir="./src" 
-            debug="true" target="1.1" source="1.3" deprecation="on" 
+            debug="true" deprecation="on" source="1.3" target="1.3" 
             destdir="./build/obj" 
             classpath="../../../core/java/build/i2p.jar:../../ministreaming/java/build/mstreaming.jar" />
     </target>

apps/i2psnark/COPYING

@@ -0,0 +1,340 @@
+		    GNU GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+     59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+		    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+			    NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+	    How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year  name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Library General
+Public License instead of this License.

apps/i2psnark/TODO

@@ -0,0 +1,24 @@
+- I2PSnark:
+  - add multitorrent support by checking the metainfo hash in the
+    PeerAcceptor and feeding it off to the appropriate coordinator
+  - add a web interface
+
+- BEncode
+  - Byte array length indicator can overflow.
+  - Support really big BigNums (only 256 chars allowed now)
+  - Better BEValue toString(). Uses stupid heuristic now for debugging.
+  - Implemented bencoding.
+  - Remove application level hack to calculate sha1 hash for metainfo
+    (But can it be done as efficiently?)
+
+- Storage
+  - Check file name filter.
+
+- TrackerClient
+  - Support undocumented &numwant= request.
+
+- PeerCoordinator
+  - Disconnect from other seeds as soon as you are a seed yourself.
+
+- Text UI
+  - Make it completely silent.

apps/i2psnark/authors.snark

@@ -0,0 +1 @@
+Mark Wielaard <mark@klomp.org>

apps/i2psnark/changelog.snark

@@ -0,0 +1,487 @@
+2003-06-27 14:24  Mark Wielaard  <mark@klomp.org>
+
+	* README: Update version number and explain new features.
+
+2003-06-27 13:51  Mark Wielaard  <mark@klomp.org>
+
+	* Makefile, org/klomp/snark/GnomeInfoWindow.java,
+	org/klomp/snark/GnomePeerList.java,
+	org/klomp/snark/PeerCoordinator.java,
+	org/klomp/snark/SnarkGnome.java: Add GnomeInfoWindow.
+
+2003-06-27 00:37  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/Snark.java: Implement 'info' and 'list' commands.
+
+2003-06-27 00:05  Mark Wielaard  <mark@klomp.org>
+
+	* Makefile, org/klomp/snark/GnomePeerList.java,
+	org/klomp/snark/SnarkGnome.java: Add GnomePeerList to show state of
+	connected peers.
+
+2003-06-27 00:04  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/: Peer.java, PeerID.java: Make Comparable.
+
+2003-06-23 23:32  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/PeerMonitorTask.java: Correctly update
+	lastDownloaded and lastUploaded.
+
+2003-06-23 23:20  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/Snark.java: When checking storage use the
+	MetaInfo from the storage.
+
+2003-06-23 21:47  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/Storage.java: Fill piece hashes, not info hashes.
+
+2003-06-23 21:42  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/MetaInfo.java: New package private
+	getPieceHashes() method.
+
+2003-06-22 19:49  Mark Wielaard  <mark@klomp.org>
+
+	* README, TODO, org/klomp/snark/Snark.java: Add new command line
+	switch --no-commands.  Don't read interactive commands or show
+	usage info.
+
+2003-06-22 19:26  Mark Wielaard  <mark@klomp.org>
+
+	* Makefile, org/klomp/snark/PeerCheckerTask.java,
+	org/klomp/snark/PeerMonitorTask.java, org/klomp/snark/Snark.java:
+	Split peer statistic reporting from PeerCheckerTask into
+	PeerMonitorTask.  Use new task in Snark text ui.
+
+2003-06-22 18:32  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/Snark.java: Only print peer id when debug level
+	is INFO or higher.
+
+2003-06-22 18:00  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/ShutdownListener.java: Add new ShutdownListener
+	interface.
+
+2003-06-22 17:18  Mark Wielaard  <mark@klomp.org>
+
+	* TODO: Text UI item to not read from stdin.
+
+2003-06-22 17:18  Mark Wielaard  <mark@klomp.org>
+
+	* snark-gnome.sh: kaffe java-gnome support (but crashes hard at the
+	moment).
+
+2003-06-22 14:04  Mark Wielaard  <mark@klomp.org>
+
+	* Makefile, org/klomp/snark/CoordinatorListener.java,
+	org/klomp/snark/PeerCoordinator.java,
+	org/klomp/snark/ProgressListener.java, org/klomp/snark/Snark.java,
+	org/klomp/snark/SnarkGnome.java,
+	org/klomp/snark/SnarkShutdown.java, org/klomp/snark/Storage.java,
+	org/klomp/snark/StorageListener.java: Split ProgressListener into
+	Storage, Coordinator and Shutdown listener.
+
+2003-06-20 19:06  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/: PeerCoordinator.java, Snark.java,
+	SnarkGnome.java, Storage.java: Progress listeners for both Storage
+	and PeerCoordinator.
+
+2003-06-20 14:50  Mark Wielaard  <mark@klomp.org>
+
+	* Makefile, org/klomp/snark/PeerCoordinator.java,
+	org/klomp/snark/ProgressListener.java,
+	org/klomp/snark/SnarkGnome.java: Add ProgressListener.
+
+2003-06-20 13:22  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/SnarkGnome.java: Add Pieces collected field.
+
+2003-06-20 12:26  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/: PeerCoordinator.java, PeerListener.java,
+	PeerState.java: Add PeerListener.downloaded() which gets called on
+	chunk updates.	Keep PeerCoordinator.downloaded up to date using
+	this remove adjusting in gotPiece() except when we receive a bad
+	piece.
+
+2003-06-16 00:27  Mark Wielaard  <mark@klomp.org>
+
+	* Makefile, snark-gnome.sh, org/klomp/snark/Snark.java,
+	org/klomp/snark/SnarkGnome.java: Start of a Gnome GUI.
+
+2003-06-05 13:19  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/PeerCoordinator.java: Don't remove a BAD piece
+	from the wantedPieces list.  Revert to synchronizing on
+	wantedPieces for all relevant sections.
+
+2003-06-03 21:09  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/Snark.java: Only call readLine() when !quit. 
+	Always print exception when fatal() is called.
+
+2003-06-01 23:12  Mark Wielaard  <mark@klomp.org>
+
+	* README: Set release version to 0.4.
+
+2003-06-01 22:59  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/PeerConnectionIn.java: Handle negative length
+	prefixes (terminates connection).
+
+2003-06-01 21:34  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/: Snark.java, SnarkShutdown.java: Implement
+	correct shutdown and read commands from stdin.
+
+2003-06-01 21:34  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/TrackerInfo.java: Check that interval and peers
+	list actually exist.
+
+2003-06-01 21:33  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/Storage.java: Implement close().
+
+2003-06-01 21:05  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/PeerState.java: Fix debug logging.
+
+2003-06-01 20:55  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/PeerCoordinator.java: Implement halt().
+
+2003-06-01 20:55  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/ConnectionAcceptor.java: Rename stop() to halt().
+
+2003-06-01 17:35  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/PeerState.java: Drop lock on this when calling
+	addRequest() from havePiece().
+
+2003-06-01 14:46  Mark Wielaard  <mark@klomp.org>
+
+	* README, org/klomp/snark/ConnectionAcceptor.java,
+	org/klomp/snark/HttpAcceptor.java, org/klomp/snark/Peer.java,
+	org/klomp/snark/PeerCheckerTask.java,
+	org/klomp/snark/PeerConnectionIn.java,
+	org/klomp/snark/PeerConnectionOut.java,
+	org/klomp/snark/PeerCoordinator.java,
+	org/klomp/snark/PeerState.java, org/klomp/snark/Snark.java,
+	org/klomp/snark/SnarkShutdown.java, org/klomp/snark/Storage.java,
+	org/klomp/snark/Tracker.java, org/klomp/snark/TrackerClient.java:
+	Add debug/log level.
+
+2003-05-31 23:04  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/: PeerCheckerTask.java, PeerCoordinator.java: Use
+	just one lock (peers) for all synchronization (even for
+	wantedPieces).	Let PeerChecker handle real disconnect and keep
+	count of uploaders.
+
+2003-05-31 22:29  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/: Peer.java, PeerConnectionIn.java: Set state to
+	null on first disconnect() call. So always check whether it might
+	already be null. Helps disconnect check.
+
+2003-05-31 22:27  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/PeerConnectionOut.java: Don't explicitly close
+	the DataOutputStream (if another thread is using it libgcj seems to
+	not like it very much).
+
+2003-05-30 21:33  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/PeerConnectionOut.java: Cancel
+	(un)interested/(un)choke when (inverse) is still in send queue. 
+	Remove pieces from send queue when choke message is actaully send.
+
+2003-05-30 19:32  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/PeerState.java: Make sure listener.wantPiece(int)
+	is never called while lock on this is held.
+
+2003-05-30 19:00  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/PeerConnectionOut.java: Indentation cleanup.
+
+2003-05-30 17:50  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/Storage.java: Only synchronize on bitfield as
+	long as necessary.
+
+2003-05-30 17:43  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/Tracker.java: Identing cleanup.
+
+2003-05-30 16:32  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/PeerState.java: Better error message.
+
+2003-05-30 15:11  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/PeerState.java: Make sure not to hold the lock on
+	this when calling the listener to prevent deadlocks. Implement
+	handling and sending of cancel messages.
+
+2003-05-30 14:50  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/PeerCoordinator.java: First check if we still
+	want a piece before trying to add it to the Storage.
+
+2003-05-30 14:49  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/PeerConnectionOut.java: Implement
+	sendCancel(Request). Add cancelRequest(int, int, int).
+
+2003-05-30 14:46  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/Request.java: Add hashCode() and equals(Object)
+	methods.
+
+2003-05-30 14:45  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/Peer.java: Fix wheter -> whether javadoc
+	comments.  Mark state null immediatly after calling
+	listener.disconnected().  Call PeerState.havePiece() not
+	PeerConnectionOut.sendHave() directly.
+
+2003-05-25 19:23  Mark Wielaard  <mark@klomp.org>
+
+	* TODO: Add PeerCoordinator TODO for connecting to seeds.
+
+2003-05-23 12:12  Mark Wielaard  <mark@klomp.org>
+
+	* Makefile: Create class files with jikes again.
+
+2003-05-18 22:01  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/: PeerCheckerTask.java, PeerCoordinator.java:
+	Prefer to (optimistically) unchoke first those peers that unchoked
+	us.  And make sure to not unchoke a peer that we just choked.
+
+2003-05-18 21:48  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/Peer.java: Fix isChoked() to not always return
+	true.
+
+2003-05-18 14:46  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/: Peer.java, PeerCheckerTask.java,
+	PeerCoordinator.java, PeerState.java: Remove separate Peer
+	downloading/uploading states. Keep choke and interest always up to
+	date. Uploading is now just when we are not choking the peer. 
+	Downloading is now defined as being unchoked and interesting. 
+	CHECK_PERIOD is now 20 seconds. MAX_CONNECTIONS is now 24. 
+	MAX_DOWNLOADERS doesn't exists anymore. We download whenever we can
+	from peers.
+
+2003-05-18 13:57  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/PeerConnectionOut.java: Remove piece messages
+	from queue when we are choking.  (They will have to be rerequested
+	when we unchoke the peer again.)
+
+2003-05-15 00:08  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/PeerState.java: Ignore missed chunk requests,
+	don't requeue them.
+
+2003-05-15 00:06  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/Request.java: Add sanity check
+
+2003-05-10 15:47  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/Snark.java: Add extra '(' to usage message.
+
+2003-05-10 15:22  Mark Wielaard  <mark@klomp.org>
+
+	* README: Set version to 0.3 (The Bakers Tale).
+
+2003-05-10 15:17  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/PeerState.java: Mention received piece in warning
+	message.
+
+2003-05-10 03:20  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/: PeerConnectionIn.java, PeerState.java,
+	Request.java: Remove currentRequest and handle all piece messages
+	from the lastRequested list.
+
+2003-05-09 20:02  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/PeerState.java: Fix nothing requested warning
+	message.
+
+2003-05-09 19:59  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/PeerConnectionOut.java: Piece messages are big.
+	So if there are other (control) messages make sure they are send
+	first. Also remove request messages from the queue if we are
+	currently being choked to prevent them from being send even if we
+	get unchoked a little later. (Since we will resent them anyway in
+	that case.)
+
+2003-05-09 18:33  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/: Peer.java, PeerCheckerTask.java,
+	PeerCoordinator.java, PeerID.java: New definition of PeerID.equals
+	(port + address + id) and new method PeerID.sameID (only id). These
+	are used to really see if we already have a connection to a certain
+	peer (active setup vs passive setup).
+
+2003-05-08 03:05  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/PeerState.java: Use Snark.debug() not
+	System.out.println().
+
+2003-05-06 20:29  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/PeerState.java: s/noting/nothing/
+
+2003-05-06 20:28  Mark Wielaard  <mark@klomp.org>
+
+	* Makefile: s/lagacy/legacy/
+
+2003-05-05 23:17  Mark Wielaard  <mark@klomp.org>
+
+	* README: Set version to 0.2, explain new functionality and add
+	examples.
+
+2003-05-05 22:42  Mark Wielaard  <mark@klomp.org>
+
+	* .cvsignore, Makefile, org/klomp/snark/StaticSnark.java: Enable
+	-static binary creation.
+
+2003-05-05 22:42  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/Tracker.java: Disable --ip support.
+
+2003-05-05 21:02  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/: HttpAcceptor.java, PeerCheckerTask.java,
+	PeerCoordinator.java, TrackerClient.java: Use Snark.debug() not
+	System.out.println().
+
+2003-05-05 21:01  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/PeerConnectionIn.java: Be prepared to handle the
+	case where currentRequest is null.
+
+2003-05-05 21:00  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/Snark.java: Improve argument parsing errors.
+
+2003-05-05 21:00  Mark Wielaard  <mark@klomp.org>
+
+	* Makefile: Use gcj -C again for creating the class files.
+
+2003-05-05 09:24  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/PeerState.java: Just clear outstandingRequests,
+	never make it null.
+
+2003-05-05 02:55  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/TrackerClient.java: Always retry both first
+	started event and every other event as long the TrackerClient is
+	not stopped.
+
+2003-05-05 02:54  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/Snark.java: Remove double assignment port.
+
+2003-05-05 02:54  Mark Wielaard  <mark@klomp.org>
+
+	* TODO: Add Tracker TODO item.
+
+2003-05-04 23:38  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/: ConnectionAcceptor.java, MetaInfo.java,
+	Snark.java, Storage.java, Tracker.java: Add info hash calcultation
+	to MetaInfo.  Add torrent creation to Storage.	Add ip parameter
+	handling to Tracker.  Make ConnectionAcceptor handle
+	null/non-existing HttpAcceptors.  Add debug output, --ip handling
+	and all the above to Snark.
+
+2003-05-04 23:36  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/TrackerClient.java: Handle all failing requests
+	the same (print a warning).
+
+2003-05-03 15:46  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/: Peer.java, PeerID.java, TrackerInfo.java: Split
+	Peer and PeerID a little more.
+
+2003-05-03 15:44  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/MetaInfo.java: Add reannounce() and
+	getTorrentData().
+
+2003-05-03 15:38  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/: PeerCheckerTask.java, PeerCoordinator.java:
+	More concise verbose/debug output.  Always use addUpDownloader() to
+	set peers upload or download state to true.
+
+2003-05-03 13:38  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/TrackerClient.java: Compile fixes.
+
+2003-05-03 13:32  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/TrackerClient.java: Only generate fatal() call on
+	first Tracker access. Otherwise just print a warning error message.
+
+2003-05-03 03:10  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/PeerState.java: Better handle resending
+	outstanding pieces and try to recover better from unrequested
+	pieces.
+
+2003-05-02 21:33  Mark Wielaard  <mark@klomp.org>
+
+	* Makefile, org/klomp/snark/HttpAcceptor.java,
+	org/klomp/snark/MetaInfo.java, org/klomp/snark/PeerID.java,
+	org/klomp/snark/Snark.java, org/klomp/snark/Tracker.java,
+	org/klomp/snark/TrackerClient.java,
+	org/klomp/snark/bencode/BEncoder.java: Add Tracker, PeerID and
+	BEncoder.
+
+2003-05-01 20:17  Mark Wielaard  <mark@klomp.org>
+
+	* Makefile, org/klomp/snark/ConnectionAcceptor.java,
+	org/klomp/snark/HttpAcceptor.java, org/klomp/snark/Peer.java,
+	org/klomp/snark/PeerAcceptor.java, org/klomp/snark/Snark.java: Add
+	ConnectionAcceptor that handles both PeerAcceptor and HttpAcceptor.
+
+2003-05-01 18:39  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/PeerCoordinator.java: connected() synchronize on
+	peers.
+
+2003-04-28 02:56  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/SnarkShutdown.java: Wait some time before
+	returning...
+
+2003-04-28 02:56  Mark Wielaard  <mark@klomp.org>
+
+	* TODO: More items.
+
+2003-04-28 02:56  Mark Wielaard  <mark@klomp.org>
+
+	* org/klomp/snark/Snark.java: Calculate real random ID.
+
+2003-04-27  Mark Wielaard  <mark@klomp.org>
+
+	* snark: Initial (0.1) version.

apps/i2psnark/java/build.xml

@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project basedir="." default="all" name="i2psnark">
+    <target name="all" depends="clean, build" />
+    <target name="build" depends="builddep, jar" />
+    <target name="builddep">
+        <ant dir="../../ministreaming/java/" target="build" />
+	<!-- ministreaming will build core -->
+    </target>
+    <target name="compile">
+        <mkdir dir="./build" />
+        <mkdir dir="./build/obj" />
+        <javac 
+            srcdir="./src" 
+            debug="true" deprecation="on" source="1.3" target="1.3" 
+            destdir="./build/obj" 
+            classpath="../../../core/java/build/i2p.jar:../../ministreaming/java/build/mstreaming.jar" />
+    </target>
+    <target name="jar" depends="builddep, compile">
+        <jar destfile="./build/i2psnark.jar" basedir="./build/obj" includes="**/*.class">
+            <manifest>
+                <attribute name="Main-Class" value="org.klomp.snark.Snark" />
+                <attribute name="Class-Path" value="i2p.jar mstreaming.jar streaming.jar" />
+            </manifest>
+        </jar>
+    </target>
+    <target name="clean">
+        <delete dir="./build" />
+    </target>
+    <target name="cleandep" depends="clean">
+        <ant dir="../../ministreaming/java/" target="distclean" />
+    </target>
+    <target name="distclean" depends="clean">
+        <ant dir="../../ministreaming/java/" target="distclean" />
+    </target>
+</project>

apps/i2psnark/java/src/org/klomp/snark/BitField.java

@@ -0,0 +1,131 @@
+/* BitField - Container of a byte array representing set and unset bits.
+   Copyright (C) 2003 Mark J. Wielaard
+
+   This file is part of Snark.
+   
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+ 
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+ 
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+*/
+
+package org.klomp.snark;
+
+import java.util.Iterator;
+import java.util.Set;
+import java.util.HashSet;
+
+/**
+ * Container of a byte array representing set and unset bits.
+ */
+public class BitField
+{
+
+  private final byte[] bitfield;
+  private final int size;
+
+  /**
+   * Creates a new BitField that represents <code>size</code> unset bits.
+   */
+  public BitField(int size)
+  {
+    this.size = size;
+    int arraysize = ((size-1)/8)+1;
+    bitfield = new byte[arraysize];
+  }
+
+  /**
+   * Creates a new BitField that represents <code>size</code> bits
+   * as set by the given byte array. This will make a copy of the array.
+   * Extra bytes will be ignored.
+   *
+   * @exception ArrayOutOfBoundsException if give byte array is not large
+   * enough.
+   */
+  public BitField(byte[] bitfield, int size)
+  {
+    this.size = size;
+    int arraysize = ((size-1)/8)+1;
+    this.bitfield = new byte[arraysize];
+    
+    // XXX - More correct would be to check that unused bits are
+    // cleared or clear them explicitly ourselves.
+    System.arraycopy(bitfield, 0, this.bitfield, 0, arraysize);
+  }
+
+  /**
+   * This returns the actual byte array used.  Changes to this array
+   * effect this BitField.  Note that some bits at the end of the byte
+   * array are supposed to be always unset if they represent bits
+   * bigger then the size of the bitfield.
+   */
+  public byte[] getFieldBytes()
+  {
+    return bitfield;
+  }
+
+  /**
+   * Return the size of the BitField. The returned value is one bigger
+   * then the last valid bit number (since bit numbers are counted
+   * from zero).
+   */
+  public int size()
+  {
+    return size;
+  }
+
+  /**
+   * Sets the given bit to true.
+   *
+   * @exception IndexOutOfBoundsException if bit is smaller then zero
+   * bigger then size (inclusive).
+   */
+  public void set(int bit)
+  {
+    if (bit < 0 || bit >= size)
+      throw new IndexOutOfBoundsException(Integer.toString(bit));
+    int index = bit/8;
+    int mask = 128 >> (bit % 8);
+    bitfield[index] |= mask;
+  }
+
+  /**
+   * Return true if the bit is set or false if it is not.
+   *
+   * @exception IndexOutOfBoundsException if bit is smaller then zero
+   * bigger then size (inclusive).
+   */
+  public boolean get(int bit)
+  {
+    if (bit < 0 || bit >= size)
+      throw new IndexOutOfBoundsException(Integer.toString(bit));
+
+    int index = bit/8;
+    int mask = 128 >> (bit % 8);
+    return (bitfield[index] & mask) != 0;
+  }
+
+  public String toString()
+  {
+    // Not very efficient
+    StringBuffer sb = new StringBuffer("BitField[");
+    for (int i = 0; i < size; i++)
+      if (get(i))
+        {
+          sb.append(' ');
+          sb.append(i);
+        }
+    sb.append(" ]");
+
+    return sb.toString();
+  }
+}

apps/i2psnark/java/src/org/klomp/snark/ConnectionAcceptor.java

@@ -0,0 +1,143 @@
+/* ConnectionAcceptor - Accepts connections and routes them to sub-acceptors.
+   Copyright (C) 2003 Mark J. Wielaard
+
+   This file is part of Snark.
+   
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+ 
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+ 
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+*/
+
+package org.klomp.snark;
+
+import java.io.*;
+import java.net.*;
+
+import net.i2p.I2PException;
+import net.i2p.client.streaming.I2PServerSocket;
+import net.i2p.client.streaming.I2PSocket;
+
+/**
+ * Accepts connections on a TCP port and routes them to sub-acceptors.
+ */
+public class ConnectionAcceptor implements Runnable
+{
+  private final I2PServerSocket serverSocket;
+  private final PeerAcceptor peeracceptor;
+  private Thread thread;
+
+  private boolean stop;
+
+  public ConnectionAcceptor(I2PServerSocket serverSocket,
+                            PeerAcceptor peeracceptor)
+  {
+    this.serverSocket = serverSocket;
+    this.peeracceptor = peeracceptor;
+    
+    stop = false;
+    thread = new Thread(this);
+    thread.start();
+  }
+
+  public void halt()
+  {
+    stop = true;
+
+    I2PServerSocket ss = serverSocket;
+    if (ss != null)
+      try
+        {
+          ss.close();
+        }
+      catch(I2PException ioe) { }
+
+    Thread t = thread;
+    if (t != null)
+      t.interrupt();
+  }
+
+  public int getPort()
+  {
+    return 6881; // serverSocket.getLocalPort();
+  }
+
+  public void run()
+  {
+    while(!stop)
+      {
+        try
+          {
+            final I2PSocket socket = serverSocket.accept();
+            Thread t = new Thread("Connection-" + socket)
+              {
+                public void run()
+                {
+                  try
+                    {
+                      InputStream in = socket.getInputStream();
+                      OutputStream out = socket.getOutputStream();
+                      BufferedInputStream bis = new BufferedInputStream(in);
+                      BufferedOutputStream bos = new BufferedOutputStream(out);
+                      
+                      // See what kind of connection it is.
+                      /*
+                      if (httpacceptor != null)
+                        {
+                          byte[] scratch = new byte[4];
+                          bis.mark(4);
+                          int len = bis.read(scratch);
+                          if (len != 4)
+                            throw new IOException("Need at least 4 bytes");
+                          bis.reset();
+                          if (scratch[0] == 19 && scratch[1] == 'B'
+                              && scratch[2] == 'i' && scratch[3] == 't')
+                            peeracceptor.connection(socket, bis, bos);
+                          else if (scratch[0] == 'G' && scratch[1] == 'E'
+                                   && scratch[2] == 'T' && scratch[3] == ' ')
+                            httpacceptor.connection(socket, bis, bos);
+                        }
+                      else
+                       */
+                        peeracceptor.connection(socket, bis, bos);
+                    }
+                  catch (IOException ioe)
+                    {
+                      try
+                        {
+                          socket.close();
+                        }
+                      catch (IOException ignored) { }
+                    }
+                }
+              };
+            t.start();
+          }
+        catch (I2PException ioe)
+          {
+            Snark.debug("Error while accepting: " + ioe, Snark.ERROR);
+            stop = true;
+          }
+        catch (IOException ioe)
+          {
+            Snark.debug("Error while accepting: " + ioe, Snark.ERROR);
+            stop = true;
+          }
+      }
+
+    try
+      {
+        serverSocket.close();
+      }
+    catch (I2PException ignored) { }
+  }
+}

apps/i2psnark/java/src/org/klomp/snark/CoordinatorListener.java

@@ -0,0 +1,33 @@
+/* CoordinatorListener.java - Callback when a peer changes state
+
+   Copyright (C) 2003 Mark J. Wielaard
+
+   This file is part of Snark.
+   
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+ 
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+ 
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+*/
+
+package org.klomp.snark;
+
+/**
+ * Callback used when some peer changes state.
+ */
+public interface CoordinatorListener
+{
+  /**
+   * Called when the PeerCoordinator notices a change in the state of a peer.
+   */
+  void peerChange(PeerCoordinator coordinator, Peer peer);
+}

apps/i2psnark/java/src/org/klomp/snark/I2PSnarkUtil.java

@@ -0,0 +1,165 @@
+package org.klomp.snark;
+
+import net.i2p.I2PAppContext;
+import net.i2p.I2PException;
+import net.i2p.util.EepGet;
+import net.i2p.data.Base64;
+import net.i2p.data.DataFormatException;
+import net.i2p.data.Destination;
+import net.i2p.client.streaming.I2PServerSocket;
+import net.i2p.client.streaming.I2PSocket;
+import net.i2p.client.streaming.I2PSocketManager;
+import net.i2p.client.streaming.I2PSocketManagerFactory;
+import net.i2p.util.Log;
+
+import java.io.*;
+import java.util.Properties;
+
+/**
+ * I2P specific helpers for I2PSnark
+ */
+public class I2PSnarkUtil {
+    private I2PAppContext _context;
+    private Log _log;
+    private static I2PSnarkUtil _instance = new I2PSnarkUtil();
+    public static I2PSnarkUtil instance() { return _instance; }
+    
+    private boolean _shouldProxy;
+    private String _proxyHost;
+    private int _proxyPort;
+    private String _i2cpHost;
+    private int _i2cpPort;
+    private Properties _opts;
+    private I2PSocketManager _manager;
+    
+    private I2PSnarkUtil() {
+        _context = I2PAppContext.getGlobalContext();
+        _log = _context.logManager().getLog(Snark.class);
+        setProxy("127.0.0.1", 4444);
+        setI2CPConfig("127.0.0.1", 7654, null);
+    }
+    
+    /**
+     * Specify what HTTP proxy tracker requests should go through (specify a null
+     * host for no proxying)
+     *
+     */
+    public void setProxy(String host, int port) {
+        if ( (host != null) && (port > 0) ) {
+            _shouldProxy = true;
+            _proxyHost = host;
+            _proxyPort = port;
+        } else {
+            _shouldProxy = false;
+            _proxyHost = null;
+            _proxyPort = -1;
+        }
+    }
+    
+    public void setI2CPConfig(String i2cpHost, int i2cpPort, Properties opts) {
+        _i2cpHost = i2cpHost;
+        _i2cpPort = i2cpPort;
+        if (opts != null)
+            _opts = opts;
+    }
+    
+    /**
+     * Connect to the router, if we aren't already
+     */
+    boolean connect() {
+        if (_manager == null) {
+            _manager = I2PSocketManagerFactory.createManager(_i2cpHost, _i2cpPort, _opts);
+        }
+        return (_manager != null);
+    }
+    
+    /** connect to the given destination */
+    I2PSocket connect(PeerID peer) throws IOException {
+        try {
+            return _manager.connect(peer.getAddress());
+        } catch (I2PException ie) {
+            throw new IOException("Unable to reach the peer " + peer + ": " + ie.getMessage());
+        }
+    }
+    
+    /**
+     * fetch the given URL, returning the file it is stored in, or null on error
+     */
+    File get(String url) {
+        File out = null;
+        try {
+            out = File.createTempFile("i2psnark", "url");
+        } catch (IOException ioe) {
+            ioe.printStackTrace();
+            return null;
+        }
+        EepGet get = new EepGet(_context, _shouldProxy, _proxyHost, _proxyPort, 1, out.getAbsolutePath(), url);
+        if (get.fetch()) {
+            return out;
+        } else {
+            out.delete();
+            return null;
+        }
+    }
+    
+    I2PServerSocket getServerSocket() { 
+        return _manager.getServerSocket();
+    }
+    
+    String getOurIPString() {
+        return _manager.getSession().getMyDestination().toBase64();
+    }
+    Destination getDestination(String ip) {
+        if (ip == null) return null;
+        if (ip.endsWith(".i2p")) {
+            Destination dest = _context.namingService().lookup(ip);
+            if (dest != null) {
+                return dest;
+            } else {
+                try {
+                    return new Destination(ip.substring(0, ip.length()-4)); // sans .i2p
+                } catch (DataFormatException dfe) {
+                    return null;
+                }
+            }
+        } else {
+            try {
+                return new Destination(ip);
+            } catch (DataFormatException dfe) {
+                return null;
+            }
+        }
+    }
+
+    /**
+     * Given http://blah.i2p/foo/announce turn it into http://i2p/blah/foo/announce
+     */
+    String rewriteAnnounce(String origAnnounce) {
+        int destStart = "http://".length();
+        int destEnd = origAnnounce.indexOf(".i2p");
+        int pathStart = origAnnounce.indexOf('/', destEnd);
+        return "http://i2p/" + origAnnounce.substring(destStart, destEnd) + origAnnounce.substring(pathStart);
+    }
+    
+    /** hook between snark's logger and an i2p log */
+    void debug(String msg, int snarkDebugLevel, Throwable t) {
+        switch (snarkDebugLevel) {
+            case 0:
+            case 1:
+                _log.error(msg, t);
+                break;
+            case 2:
+                _log.warn(msg, t);
+                break;
+            case 3:
+            case 4:
+                _log.info(msg, t);
+                break;
+            case 5:
+            case 6:
+            default:
+                _log.debug(msg, t);
+                break;
+        }
+    }
+}

apps/i2psnark/java/src/org/klomp/snark/Message.java

@@ -0,0 +1,137 @@
+/* Message - A protocol message which can be send through a DataOutputStream.
+   Copyright (C) 2003 Mark J. Wielaard
+
+   This file is part of Snark.
+   
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+ 
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+ 
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+*/
+
+package org.klomp.snark;
+
+import java.io.DataOutputStream;
+import java.io.IOException;
+
+// Used to queue outgoing connections
+// sendMessage() should be used to translate them to wire format.
+class Message
+{
+  final static byte KEEP_ALIVE   = -1;
+  final static byte CHOKE        = 0;
+  final static byte UNCHOKE      = 1;
+  final static byte INTERESTED   = 2;
+  final static byte UNINTERESTED = 3;
+  final static byte HAVE         = 4;
+  final static byte BITFIELD     = 5;
+  final static byte REQUEST      = 6;
+  final static byte PIECE        = 7;
+  final static byte CANCEL       = 8;
+  
+  // Not all fields are used for every message.
+  // KEEP_ALIVE doesn't have a real wire representation
+  byte type;
+
+  // Used for HAVE, REQUEST, PIECE and CANCEL messages.
+  int piece;
+
+  // Used for REQUEST, PIECE and CANCEL messages.
+  int begin;
+  int length;
+
+  // Used for PIECE and BITFIELD messages
+  byte[] data;
+  int off;
+  int len;
+
+  /** Utility method for sending a message through a DataStream. */
+  void sendMessage(DataOutputStream dos) throws IOException
+  {
+    // KEEP_ALIVE is special.
+    if (type == KEEP_ALIVE)
+      {
+        dos.writeInt(0);
+        return;
+      }
+
+    // Calculate the total length in bytes
+
+    // Type is one byte.
+    int datalen = 1;
+
+    // piece is 4 bytes.
+    if (type == HAVE || type == REQUEST || type == PIECE || type == CANCEL)
+      datalen += 4;
+
+    // begin/offset is 4 bytes
+    if (type == REQUEST || type == PIECE || type == CANCEL)
+      datalen += 4;
+
+    // length is 4 bytes
+    if (type == REQUEST || type == CANCEL)
+      datalen += 4;
+
+    // add length of data for piece or bitfield array.
+    if (type == BITFIELD || type == PIECE)
+      datalen += len;
+
+    // Send length
+    dos.writeInt(datalen);
+    dos.writeByte(type & 0xFF);
+
+    // Send additional info (piece number)
+    if (type == HAVE || type == REQUEST || type == PIECE || type == CANCEL)
+      dos.writeInt(piece);
+
+    // Send additional info (begin/offset)
+    if (type == REQUEST || type == PIECE || type == CANCEL)
+      dos.writeInt(begin);
+
+    // Send additional info (length); for PIECE this is implicit.
+    if (type == REQUEST || type == CANCEL)
+        dos.writeInt(length);
+
+    // Send actual data
+    if (type == BITFIELD || type == PIECE)
+      dos.write(data, off, len);
+  }
+
+  public String toString()
+  {
+    switch (type)
+      {
+      case KEEP_ALIVE:
+        return "KEEP_ALIVE";
+      case CHOKE:
+        return "CHOKE";
+      case UNCHOKE:
+        return "UNCHOKE";
+      case INTERESTED:
+        return "INTERESTED";
+      case UNINTERESTED:
+        return "UNINTERESTED";
+      case HAVE:
+        return "HAVE(" + piece + ")";
+      case BITFIELD:
+        return "BITFIELD";
+      case REQUEST:
+        return "REQUEST(" + piece + "," + begin + "," + length + ")";
+      case PIECE:
+        return "PIECE(" + piece + "," + begin + "," + length + ")";
+      case CANCEL:
+        return "CANCEL(" + piece + "," + begin + "," + length + ")";
+      default:
+        return "<UNKNOWN>";
+      }
+  }
+}

apps/i2psnark/java/src/org/klomp/snark/MetaInfo.java

@@ -0,0 +1,382 @@
+/* MetaInfo - Holds all information gotten from a torrent file.
+   Copyright (C) 2003 Mark J. Wielaard
+
+   This file is part of Snark.
+   
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+ 
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+ 
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+*/
+
+package org.klomp.snark;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.File;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.HashMap;
+
+import org.klomp.snark.bencode.*;
+
+public class MetaInfo
+{
+  private final String announce;
+  private final byte[] info_hash;
+  private final String name;
+  private final List files;
+  private final List lengths;
+  private final int piece_length;
+  private final byte[] piece_hashes;
+  private final long length;
+
+  private byte[] torrentdata;
+
+  MetaInfo(String announce, String name, List files, List lengths,
+           int piece_length, byte[] piece_hashes, long length)
+  {
+    this.announce = announce;
+    this.name = name;
+    this.files = files;
+    this.lengths = lengths;
+    this.piece_length = piece_length;
+    this.piece_hashes = piece_hashes;
+    this.length = length;
+
+    this.info_hash = calculateInfoHash();
+  }
+
+  /**
+   * Creates a new MetaInfo from the given InputStream.  The
+   * InputStream must start with a correctly bencoded dictonary
+   * describing the torrent.
+   */
+  public MetaInfo(InputStream in) throws IOException
+  {
+    this(new BDecoder(in));
+  }
+  
+  /**
+   * Creates a new MetaInfo from the given BDecoder.  The BDecoder
+   * must have a complete dictionary describing the torrent.
+   */
+  public MetaInfo(BDecoder be) throws IOException
+  {
+    // Note that evaluation order matters here...
+    this(be.bdecodeMap().getMap());
+  }
+
+  /**
+   * Creates a new MetaInfo from a Map of BEValues and the SHA1 over
+   * the original bencoded info dictonary (this is a hack, we could
+   * reconstruct the bencoded stream and recalculate the hash). Will
+   * throw a InvalidBEncodingException if the given map does not
+   * contain a valid announce string or info dictonary.
+   */
+  public MetaInfo(Map m) throws InvalidBEncodingException
+  {
+    BEValue val = (BEValue)m.get("announce");
+    if (val == null)
+        throw new InvalidBEncodingException("Missing announce string");
+    this.announce = val.getString();
+
+    val = (BEValue)m.get("info");
+    if (val == null)
+        throw new InvalidBEncodingException("Missing info map");
+    Map info = val.getMap();
+
+    val = (BEValue)info.get("name");
+    if (val == null)
+        throw new InvalidBEncodingException("Missing name string");
+    name = val.getString();
+
+    val = (BEValue)info.get("piece length");
+    if (val == null)
+        throw new InvalidBEncodingException("Missing piece length number");
+    piece_length = val.getInt();
+
+    val = (BEValue)info.get("pieces");
+    if (val == null)
+        throw new InvalidBEncodingException("Missing piece bytes");
+    piece_hashes = val.getBytes();
+
+    val = (BEValue)info.get("length");
+    if (val != null)
+      {
+        // Single file case.
+        length = val.getLong();
+        files = null;
+        lengths = null;
+      }
+    else
+      {
+        // Multi file case.
+        val = (BEValue)info.get("files");
+        if (val == null)
+          throw new InvalidBEncodingException
+            ("Missing length number and/or files list");
+
+        List list = val.getList();
+        int size = list.size();
+        if (size == 0)
+          throw new InvalidBEncodingException("zero size files list");
+
+        files = new ArrayList(size);
+        lengths = new ArrayList(size);
+        long l = 0;
+        for (int i = 0; i < list.size(); i++)
+          {
+            Map desc = ((BEValue)list.get(i)).getMap();
+            val = (BEValue)desc.get("length");
+            if (val == null)
+              throw new InvalidBEncodingException("Missing length number");
+            long len = val.getLong();
+            lengths.add(new Long(len));
+            l += len;
+
+            val = (BEValue)desc.get("path");
+            if (val == null)
+              throw new InvalidBEncodingException("Missing path list");
+            List path_list = val.getList();
+            int path_length = path_list.size();
+            if (path_length == 0)
+              throw new InvalidBEncodingException("zero size file path list");
+
+            List file = new ArrayList(path_length);
+            Iterator it = path_list.iterator();
+            while (it.hasNext())
+              file.add(((BEValue)it.next()).getString());
+
+            files.add(file);
+          }
+        length = l;
+      }
+
+    info_hash = calculateInfoHash();
+  }
+
+  /**
+   * Returns the string representing the URL of the tracker for this torrent.
+   */
+  public String getAnnounce()
+  {
+    return announce;
+  }
+
+  /**
+   * Returns the original 20 byte SHA1 hash over the bencoded info map.
+   */
+  public byte[] getInfoHash()
+  {
+    // XXX - Should we return a clone, just to be sure?
+    return info_hash;
+  }
+
+  /**
+   * Returns the piece hashes. Only used by storage so package local.
+   */
+  byte[] getPieceHashes()
+  {
+    return piece_hashes;
+  }
+
+  /**
+   * Returns the requested name for the file or toplevel directory.
+   * If it is a toplevel directory name getFiles() will return a
+   * non-null List of file name hierarchy name.
+   */
+  public String getName()
+  {
+    return name;
+  }
+
+  /**
+   * Returns a list of lists of file name hierarchies or null if it is
+   * a single name. It has the same size as the list returned by
+   * getLengths().
+   */
+  public List getFiles()
+  {
+    // XXX - Immutable?
+    return files;
+  }
+
+  /**
+   * Returns a list of Longs indication the size of the individual
+   * files, or null if it is a single file. It has the same size as
+   * the list returned by getFiles().
+   */
+  public List getLengths()
+  {
+    // XXX - Immutable?
+    return lengths;
+  }
+
+  /**
+   * Returns the number of pieces.
+   */
+  public int getPieces()
+  {
+    return piece_hashes.length/20;
+  }
+
+  /**
+   * Return the length of a piece. All pieces are of equal length
+   * except for the last one (<code>getPieces()-1</code>).
+   *
+   * @exception IndexOutOfBoundsException when piece is equal to or
+   * greater then the number of pieces in the torrent.
+   */
+  public int getPieceLength(int piece)
+  {
+    int pieces = getPieces();
+    if (piece >= 0 && piece < pieces -1)
+      return piece_length;
+    else if (piece == pieces -1)
+      return (int)(length - piece * piece_length);
+    else
+      throw new IndexOutOfBoundsException("no piece: " + piece);
+  }
+        
+  /**
+   * Checks that the given piece has the same SHA1 hash as the given
+   * byte array. Returns random results or IndexOutOfBoundsExceptions
+   * when the piece number is unknown.
+   */
+  public boolean checkPiece(int piece, byte[] bs, int off, int length)
+  {
+    // Check digest
+    MessageDigest sha1;
+    try
+      {
+        sha1 = MessageDigest.getInstance("SHA");
+      }
+    catch (NoSuchAlgorithmException nsae)
+      {
+        throw new InternalError("No SHA digest available: " + nsae);
+      }
+
+    sha1.update(bs, off, length);
+    byte[] hash = sha1.digest();
+    for (int i = 0; i < 20; i++)
+      if (hash[i] != piece_hashes[20 * piece + i])
+        return false;
+    return true;
+  }
+
+  /**
+   * Returns the total length of the torrent in bytes.
+   */
+  public long getTotalLength()
+  {
+    return length;
+  }
+
+  public String toString()
+  {
+    return "MetaInfo[info_hash='" + hexencode(info_hash)
+      + "', announce='" + announce
+      + "', name='" + name
+      + "', files=" + files
+      + ", #pieces='" + piece_hashes.length/20
+      + "', piece_length='" + piece_length
+      + "', length='" + length
+      + "']";
+  }
+
+  /**
+   * Encode a byte array as a hex encoded string.
+   */
+  private static String hexencode(byte[] bs)
+  {
+    StringBuffer sb = new StringBuffer(bs.length*2);
+    for (int i = 0; i < bs.length; i++)
+      {
+        int c = bs[i] & 0xFF;
+        if (c < 16)
+          sb.append('0');
+        sb.append(Integer.toHexString(c));
+      }
+
+    return sb.toString();
+  }
+
+  /**
+   * Creates a copy of this MetaInfo that shares everything except the
+   * announce URL.
+   */
+  public MetaInfo reannounce(String announce)
+  {
+    return new MetaInfo(announce, name, files,
+                        lengths, piece_length,
+                        piece_hashes, length);
+  }
+
+  public byte[] getTorrentData()
+  {
+    if (torrentdata == null)
+      {
+        Map m = new HashMap();
+        m.put("announce", announce);
+        Map info = createInfoMap();
+        m.put("info", info);
+        torrentdata = BEncoder.bencode(m);
+      }
+    return torrentdata;
+  }
+
+  private Map createInfoMap()
+  {
+    Map info = new HashMap();
+    info.put("name", name);
+    info.put("piece length", new Integer(piece_length));
+    info.put("pieces", piece_hashes);
+    if (files == null)
+      info.put("length", new Long(length));
+    else
+      {
+        List l = new ArrayList();
+        for (int i = 0; i < files.size(); i++)
+          {
+            Map file = new HashMap();
+            file.put("path", files.get(i));
+            file.put("length", lengths.get(i));
+            l.add(file);
+          }
+        info.put("files", l);
+      }
+    return info;
+  }
+
+  private byte[] calculateInfoHash()
+  {
+    Map info = createInfoMap();
+    byte[] infoBytes = BEncoder.bencode(info);
+    try
+      {
+        MessageDigest digest = MessageDigest.getInstance("SHA");
+        return digest.digest(infoBytes);
+      }
+    catch(NoSuchAlgorithmException nsa)
+      {
+        throw new InternalError(nsa.toString());
+      }
+  }
+
+  
+}

apps/i2psnark/java/src/org/klomp/snark/Peer.java

@@ -0,0 +1,388 @@
+/* Peer - All public information concerning a peer.
+   Copyright (C) 2003 Mark J. Wielaard
+
+   This file is part of Snark.
+   
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+ 
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+ 
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+*/
+
+package org.klomp.snark;
+
+import java.io.*;
+import java.net.*;
+import java.util.Arrays;
+import java.util.Map;
+
+import org.klomp.snark.bencode.*;
+
+import net.i2p.client.streaming.I2PSocket;
+
+public class Peer implements Comparable
+{
+  // Identifying property, the peer id of the other side.
+  private final PeerID peerID;
+
+  private final byte[] my_id;
+  private final MetaInfo metainfo;
+
+  // The data in/output streams set during the handshake and used by
+  // the actual connections.
+  private DataInputStream din;
+  private DataOutputStream dout;
+
+  // Keeps state for in/out connections.  Non-null when the handshake
+  // was successful, the connection setup and runs
+  PeerState state;
+
+  private boolean deregister = true;
+
+  /**
+   * Creates a disconnected peer given a PeerID, your own id and the
+   * relevant MetaInfo.
+   */
+  public Peer(PeerID peerID, byte[] my_id, MetaInfo metainfo)
+    throws IOException
+  {
+    this.peerID = peerID;
+    this.my_id = my_id;
+    this.metainfo = metainfo;
+  }
+
+  /**
+   * Creates a unconnected peer from the input and output stream got
+   * from the socket. Note that the complete handshake (which can take
+   * some time or block indefinitely) is done in the calling Thread to
+   * get the remote peer id. To completely start the connection call
+   * the connect() method.
+   *
+   * @exception IOException when an error occurred during the handshake.
+   */
+  public Peer(final I2PSocket sock, BufferedInputStream bis,
+              BufferedOutputStream bos, byte[] my_id, MetaInfo metainfo)
+    throws IOException
+  {
+    this.my_id = my_id;
+    this.metainfo = metainfo;
+
+    byte[] id  = handshake(bis, bos);
+    this.peerID = new PeerID(id, sock.getPeerDestination());
+  }
+
+  /**
+   * Returns the id of the peer.
+   */
+  public PeerID getPeerID()
+  {
+    return peerID;
+  }
+
+  /**
+   * Returns the String representation of the peerID.
+   */
+  public String toString()
+  {
+    return peerID.toString();
+  }
+
+  /**
+   * The hash code of a Peer is the hash code of the peerID.
+   */
+  public int hashCode()
+  {
+    return peerID.hashCode();
+  }
+
+  /**
+   * Two Peers are equal when they have the same PeerID.
+   * All other properties are ignored.
+   */
+  public boolean equals(Object o)
+  {
+    if (o instanceof Peer)
+      {
+        Peer p = (Peer)o;
+        return peerID.equals(p.peerID);
+      }
+    else
+      return false;
+  }
+
+  /**
+   * Compares the PeerIDs.
+   */
+  public int compareTo(Object o)
+  {
+    Peer p = (Peer)o;
+    return peerID.compareTo(p.peerID);
+  }
+
+  /**
+   * Runs the connection to the other peer. This method does not
+   * return until the connection is terminated.
+   *
+   * When the connection is correctly started the connected() method
+   * of the given PeerListener is called. If the connection ends or
+   * the connection could not be setup correctly the disconnected()
+   * method is called.
+   *
+   * If the given BitField is non-null it is send to the peer as first
+   * message.
+   */
+  public void runConnection(PeerListener listener, BitField bitfield)
+  {
+    if (state != null)
+      throw new IllegalStateException("Peer already started");
+
+    try
+      {
+        // Do we need to handshake?
+        if (din == null)
+          {
+            I2PSocket sock = I2PSnarkUtil.instance().connect(peerID);
+            BufferedInputStream bis
+              = new BufferedInputStream(sock.getInputStream());
+            BufferedOutputStream bos
+              = new BufferedOutputStream(sock.getOutputStream());
+            byte [] id = handshake(bis, bos);
+            byte [] expected_id = peerID.getID();
+            if (!Arrays.equals(expected_id, id))
+              throw new IOException("Unexpected peerID '"
+                                    + PeerID.idencode(id)
+                                    + "' expected '"
+                                    + PeerID.idencode(expected_id) + "'");
+          }
+        
+        PeerConnectionIn in = new PeerConnectionIn(this, din);
+        PeerConnectionOut out = new PeerConnectionOut(this, dout);
+        PeerState s = new PeerState(this, listener, metainfo, in, out);
+        
+        // Send our bitmap
+        if (bitfield != null)
+          s.out.sendBitfield(bitfield);
+    
+        // We are up and running!
+        state = s;
+        listener.connected(this);
+  
+        // Use this thread for running the incomming connection.
+        // The outgoing connection has created its own Thread.
+        s.in.run();
+      }
+    catch(IOException eofe)
+      {
+        // Ignore, probably just the other side closing the connection.
+        // Or refusing the connection, timing out, etc.
+      }
+    catch(Throwable t)
+      {
+        Snark.debug(this + ": " + t, Snark.ERROR);
+        t.printStackTrace();
+      }
+    finally
+      {
+        if (deregister) listener.disconnected(this);
+      }
+  }
+
+  /**
+   * Sets DataIn/OutputStreams, does the handshake and returns the id
+   * reported by the other side.
+   */
+  private byte[] handshake(BufferedInputStream bis, BufferedOutputStream bos)
+    throws IOException
+  {
+    din = new DataInputStream(bis);
+    dout = new DataOutputStream(bos);
+    
+    // Handshake write - header
+    dout.write(19);
+    dout.write("BitTorrent protocol".getBytes("UTF-8"));
+    // Handshake write - zeros
+    byte[] zeros = new byte[8];
+    dout.write(zeros);
+    // Handshake write - metainfo hash
+    byte[] shared_hash = metainfo.getInfoHash();
+    dout.write(shared_hash);
+    // Handshake write - peer id
+    dout.write(my_id);
+    dout.flush();
+    
+    // Handshake read - header
+    byte b = din.readByte();
+    if (b != 19)
+      throw new IOException("Handshake failure, expected 19, got "
+                            + (b & 0xff));
+    
+    byte[] bs = new byte[19];
+    din.readFully(bs);
+    String bittorrentProtocol = new String(bs, "UTF-8");
+    if (!"BitTorrent protocol".equals(bittorrentProtocol))
+      throw new IOException("Handshake failure, expected "
+                            + "'Bittorrent protocol', got '"
+                            + bittorrentProtocol + "'");
+    
+    // Handshake read - zeros
+    din.readFully(zeros);
+    
+    // Handshake read - metainfo hash
+    bs = new byte[20];
+    din.readFully(bs);
+    if (!Arrays.equals(shared_hash, bs))
+      throw new IOException("Unexpected MetaInfo hash");
+
+    // Handshake read - peer id
+    din.readFully(bs);
+    return bs;
+  }
+
+  public boolean isConnected()
+  {
+    return state != null;
+  }
+
+  /**
+   * Disconnects this peer if it was connected.  If deregister is
+   * true, PeerListener.disconnected() will be called when the
+   * connection is completely terminated. Otherwise the connection is
+   * silently terminated.
+   */
+  public void disconnect(boolean deregister)
+  {
+    // Both in and out connection will call this.
+    this.deregister = deregister;
+    disconnect();
+  }
+
+  void disconnect()
+  {
+    PeerState s = state;
+    if (s != null)
+      {
+        state = null;
+
+        PeerConnectionIn in = s.in;
+        if (in != null)
+          in.disconnect();
+        PeerConnectionOut out = s.out;
+        if (out != null)
+          out.disconnect();
+      }
+  }
+
+  /**
+   * Tell the peer we have another piece.
+   */
+  public void have(int piece)
+  {
+    PeerState s = state;
+    if (s != null)
+      s.havePiece(piece);
+  }
+
+  /**
+   * Whether or not the peer is interested in pieces we have. Returns
+   * false if not connected.
+   */
+  public boolean isInterested()
+  {
+    PeerState s = state;
+    return (s != null) && s.interested;
+  }
+
+  /**
+   * Sets whether or not we are interested in pieces from this peer.
+   * Defaults to false. When interest is true and this peer unchokes
+   * us then we start downloading from it. Has no effect when not connected.
+   */
+  public void setInteresting(boolean interest)
+  {
+    PeerState s = state;
+    if (s != null)
+      s.setInteresting(interest);
+  }
+
+  /**
+   * Whether or not the peer has pieces we want from it. Returns false
+   * if not connected.
+   */
+  public boolean isInteresting()
+  {
+    PeerState s = state;
+    return (s != null) && s.interesting;
+  }
+
+  /**
+   * Sets whether or not we are choking the peer. Defaults to
+   * true. When choke is false and the peer requests some pieces we
+   * upload them, otherwise requests of this peer are ignored.
+   */
+  public void setChoking(boolean choke)
+  {
+    PeerState s = state;
+    if (s != null)
+      s.setChoking(choke);
+  }
+
+  /**
+   * Whether or not we are choking the peer. Returns true when not connected.
+   */
+  public boolean isChoking()
+  {
+    PeerState s = state;
+    return (s == null) || s.choking;
+  }
+
+  /**
+   * Whether or not the peer choked us. Returns true when not connected.
+   */
+  public boolean isChoked()
+  {
+    PeerState s = state;
+    return (s == null) || s.choked;
+  }
+
+  /**
+   * Returns the number of bytes that have been downloaded.
+   * Can be reset to zero with <code>resetCounters()</code>/
+   */
+  public long getDownloaded()
+  {
+    PeerState s = state;
+    return (s != null) ? s.downloaded : 0;
+  }
+
+  /**
+   * Returns the number of bytes that have been uploaded.
+   * Can be reset to zero with <code>resetCounters()</code>/
+   */
+  public long getUploaded()
+  {
+    PeerState s = state;
+    return (s != null) ? s.uploaded : 0;
+  }
+
+  /**
+   * Resets the downloaded and uploaded counters to zero.
+   */
+  public void resetCounters()
+  {
+    PeerState s = state;
+    if (s != null)
+      {
+        s.downloaded = 0;
+        s.uploaded = 0;
+      }
+  }
+}

apps/i2psnark/java/src/org/klomp/snark/PeerAcceptor.java

@@ -0,0 +1,62 @@
+/* PeerAcceptor - Accepts incomming connections from peers.
+   Copyright (C) 2003 Mark J. Wielaard
+
+   This file is part of Snark.
+   
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+ 
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+ 
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+*/
+
+package org.klomp.snark;
+
+import java.io.*;
+import java.net.*;
+
+import net.i2p.client.streaming.I2PSocket;
+
+/**
+ * Accepts incomming connections from peers. The ConnectionAcceptor
+ * will call the connection() method when it detects an incomming BT
+ * protocol connection. The PeerAcceptor will then create a new peer
+ * if the PeerCoordinator wants more peers.
+ */
+public class PeerAcceptor
+{
+  private final PeerCoordinator coordinator;
+
+  public PeerAcceptor(PeerCoordinator coordinator)
+  {
+    this.coordinator = coordinator;
+  }
+
+  public void connection(I2PSocket socket,
+                         BufferedInputStream bis, BufferedOutputStream bos)
+    throws IOException
+  {
+    if (coordinator.needPeers())
+      {
+        // XXX: inside this Peer constructor's handshake is where you'd deal with the other
+        //      side saying they want to communicate with another torrent - aka multitorrent
+        //      support.  you'd then want to grab the meta info /they/ want, look that up in
+        //      our own list of active torrents, and put it on the right coordinator for it.
+        //      this currently, however, throws an IOException if the metainfo doesn't match
+        //      coodinator.getMetaInfo (Peer.java:242)
+        Peer peer = new Peer(socket, bis, bos, coordinator.getID(),
+                             coordinator.getMetaInfo());
+        coordinator.addPeer(peer);
+      }
+    else
+      socket.close();
+  }
+}

apps/i2psnark/java/src/org/klomp/snark/PeerCheckerTask.java

@@ -0,0 +1,198 @@
+/* PeerCheckTasks - TimerTask that checks for good/bad up/downloaders.
+   Copyright (C) 2003 Mark J. Wielaard
+
+   This file is part of Snark.
+   
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+ 
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+ 
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+*/
+
+package org.klomp.snark;
+
+import java.util.*;
+
+/**
+ * TimerTask that checks for good/bad up/downloader. Works together
+ * with the PeerCoordinator to select which Peers get (un)choked.
+ */
+class PeerCheckerTask extends TimerTask
+{
+  private final long KILOPERSECOND = 1024*(PeerCoordinator.CHECK_PERIOD/1000);
+
+  private final PeerCoordinator coordinator;
+
+  PeerCheckerTask(PeerCoordinator coordinator)
+  {
+    this.coordinator = coordinator;
+  }
+
+  public void run()
+  {
+    synchronized(coordinator.peers)
+      {
+        // Calculate total uploading and worst downloader.
+        long worstdownload = Long.MAX_VALUE;
+        Peer worstDownloader = null;
+
+        int peers = 0;
+        int uploaders = 0;
+        int downloaders = 0;
+        int interested = 0;
+        int interesting = 0;
+        int choking = 0;
+        int choked = 0;
+
+        long uploaded = 0;
+        long downloaded = 0;
+
+        // Keep track of peers we remove now,
+        // we will add them back to the end of the list.
+        List removed = new ArrayList();
+
+        Iterator it = coordinator.peers.iterator();
+        while (it.hasNext())
+          {
+            Peer peer = (Peer)it.next();
+
+            // Remove dying peers
+            if (!peer.isConnected())
+              {
+                it.remove();
+                coordinator.removePeerFromPieces(peer);
+                continue;
+              }
+
+            peers++;
+
+            if (!peer.isChoking())
+              uploaders++;
+            if (!peer.isChoked() && peer.isInteresting())
+              downloaders++;
+            if (peer.isInterested())
+              interested++;
+            if (peer.isInteresting())
+              interesting++;
+            if (peer.isChoking())
+              choking++;
+            if (peer.isChoked())
+              choked++;
+
+            // XXX - We should calculate the up/download rate a bit
+            // more intelligently
+            long upload = peer.getUploaded();
+            uploaded += upload;
+            long download = peer.getDownloaded();
+            downloaded += download;
+            peer.resetCounters();
+
+            if (Snark.debug >= Snark.DEBUG)
+              {
+                Snark.debug(peer + ":", Snark.DEBUG);
+                Snark.debug(" ul: " + upload/KILOPERSECOND
+                            + " dl: " + download/KILOPERSECOND
+                            + " i: " + peer.isInterested()
+                            + " I: " + peer.isInteresting()
+                            + " c: " + peer.isChoking()
+                            + " C: " + peer.isChoked(),
+                            Snark.DEBUG);
+              }
+
+            // If we are at our max uploaders and we have lots of other
+            // interested peers try to make some room.
+            // (Note use of coordinator.uploaders)
+            if (coordinator.uploaders >= PeerCoordinator.MAX_UPLOADERS
+                && interested > PeerCoordinator.MAX_UPLOADERS
+                && !peer.isChoking())
+              {
+                // Check if it still wants pieces from us.
+                if (!peer.isInterested())
+                  {
+                    if (Snark.debug >= Snark.INFO)
+                      Snark.debug("Choke uninterested peer: " + peer,
+                                  Snark.INFO);
+                    peer.setChoking(true);
+                    uploaders--;
+                    coordinator.uploaders--;
+                    
+                    // Put it at the back of the list
+                    it.remove();
+                    removed.add(peer);
+                  }
+                else if (peer.isChoked())
+                  {
+                    // If they are choking us make someone else a downloader
+                    if (Snark.debug >= Snark.DEBUG)
+                      Snark.debug("Choke choking peer: " + peer, Snark.DEBUG);
+                    peer.setChoking(true);
+                    uploaders--;
+                    coordinator.uploaders--;
+                    
+                    // Put it at the back of the list
+                    it.remove();
+                    removed.add(peer);
+                  }
+                else if (peer.isInteresting()
+                         && !peer.isChoked()
+                         && download == 0)
+                  {
+                    // We are downloading but didn't receive anything...
+                    if (Snark.debug >= Snark.DEBUG)
+                      Snark.debug("Choke downloader that doesn't deliver:"
+                                  + peer, Snark.DEBUG);
+                    peer.setChoking(true);
+                    uploaders--;
+                    coordinator.uploaders--;
+                    
+                    // Put it at the back of the list
+                    it.remove();
+                    removed.add(peer);
+                  }
+                else if (!peer.isChoking() && download < worstdownload)
+                  {
+                    // Make sure download is good if we are uploading
+                    worstdownload = download;
+                    worstDownloader = peer;
+                  }
+              }
+          }
+
+        // Resync actual uploaders value
+        // (can shift a bit by disconnecting peers)
+        coordinator.uploaders = uploaders;
+
+        // Remove the worst downloader if needed.
+        if (uploaders >= PeerCoordinator.MAX_UPLOADERS
+            && interested > PeerCoordinator.MAX_UPLOADERS
+            && worstDownloader != null)
+          {
+            if (Snark.debug >= Snark.DEBUG)
+              Snark.debug("Choke worst downloader: " + worstDownloader,
+                          Snark.DEBUG);
+
+            worstDownloader.setChoking(true);
+            coordinator.uploaders--;
+
+            // Put it at the back of the list
+            coordinator.peers.remove(worstDownloader);
+            removed.add(worstDownloader);
+          }
+        
+        // Optimistically unchoke a peer
+        coordinator.unchokePeer();
+
+        // Put peers back at the end of the list that we removed earlier.
+        coordinator.peers.addAll(removed);
+      }
+  }
+}

apps/i2psnark/java/src/org/klomp/snark/PeerConnectionIn.java

@@ -0,0 +1,156 @@
+/* PeerConnectionIn - Handles incomming messages and hands them to PeerState.
+   Copyright (C) 2003 Mark J. Wielaard
+
+   This file is part of Snark.
+   
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+ 
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+ 
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+*/
+
+package org.klomp.snark;
+
+import java.io.*;
+import java.net.*;
+import java.util.*;
+
+class PeerConnectionIn implements Runnable
+{
+  private final Peer peer;
+  private final DataInputStream din;
+
+  private Thread thread;
+  private boolean quit;
+
+  public PeerConnectionIn(Peer peer, DataInputStream din)
+  {
+    this.peer = peer;
+    this.din = din;
+    quit = false;
+  }
+
+  void disconnect()
+  {
+    if (quit == true)
+      return;
+
+    quit = true;
+    Thread t = thread;
+    if (t != null)
+      t.interrupt();
+  }
+
+  public void run()
+  {
+    thread = Thread.currentThread();
+    try
+      {
+        PeerState ps = peer.state;
+        while (!quit && ps != null)
+          {
+            // Common variables used for some messages.
+            int piece;
+            int begin;
+            int len;
+        
+            // Wait till we hear something...
+            // The length of a complete message in bytes.
+            int i = din.readInt();
+            if (i < 0)
+              throw new IOException("Unexpected length prefix: " + i);
+
+            if (i == 0)
+              {
+                ps.keepAliveMessage();
+                continue;
+              }
+            
+            byte b = din.readByte();
+            Message m = new Message();
+            m.type = b;
+            switch (b)
+              {
+              case 0:
+                ps.chokeMessage(true);
+                break;
+              case 1:
+                ps.chokeMessage(false);
+                break;
+              case 2:
+                ps.interestedMessage(true);
+                break;
+              case 3:
+                ps.interestedMessage(false);
+                break;
+              case 4:
+                piece = din.readInt();
+                ps.haveMessage(piece);
+                break;
+              case 5:
+                byte[] bitmap = new byte[i-1];
+                din.readFully(bitmap);
+                ps.bitfieldMessage(bitmap);
+                break;
+              case 6:
+                piece = din.readInt();
+                begin = din.readInt();
+                len = din.readInt();
+                ps.requestMessage(piece, begin, len);
+                break;
+              case 7:
+                piece = din.readInt();
+                begin = din.readInt();
+                len = i-9;
+                Request req = ps.getOutstandingRequest(piece, begin, len);
+                byte[] piece_bytes;
+                if (req != null)
+                  {
+                    piece_bytes = req.bs;
+                    din.readFully(piece_bytes, begin, len);
+                    ps.pieceMessage(req);
+                  }
+                else
+                  {
+                    // XXX - Consume but throw away afterwards.
+                    piece_bytes = new byte[len];
+                    din.readFully(piece_bytes);
+                  }
+                break;
+              case 8:
+                piece = din.readInt();
+                begin = din.readInt();
+                len = din.readInt();
+                ps.cancelMessage(piece, begin, len);
+                break;
+              default:
+                byte[] bs = new byte[i-1];
+                din.readFully(bs);
+                ps.unknownMessage(b, bs);
+              }
+          }
+      }
+    catch (IOException ioe)
+      {
+        // Ignore, probably the other side closed connection.
+      }
+    catch (Throwable t)
+      {
+        Snark.debug(peer + ": " + t, Snark.ERROR);
+        t.printStackTrace();
+      }
+    finally
+      {
+        peer.disconnect();
+      }
+  }
+}

apps/i2psnark/java/src/org/klomp/snark/PeerConnectionOut.java

@@ -0,0 +1,342 @@
+/* PeerConnectionOut - Keeps a queue of outgoing messages and delivers them.
+   Copyright (C) 2003 Mark J. Wielaard
+
+   This file is part of Snark.
+   
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+ 
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+ 
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+*/
+
+package org.klomp.snark;
+
+import java.io.*;
+import java.net.*;
+import java.util.*;
+
+class PeerConnectionOut implements Runnable
+{
+  private final Peer peer;
+  private final DataOutputStream dout;
+
+  private Thread thread;
+  private boolean quit;
+
+  // Contains Messages.
+  private List sendQueue = new ArrayList();
+
+  public PeerConnectionOut(Peer peer, DataOutputStream dout)
+  {
+    this.peer = peer;
+    this.dout = dout;
+
+    quit = false;
+    thread = new Thread(this);
+    thread.start();
+  }
+
+  /**
+   * Continuesly monitors for more outgoing messages that have to be send.
+   * Stops if quit is true of an IOException occurs.
+   */
+  public void run()
+  {
+    try
+      {
+        while (!quit)
+          {
+            Message m = null;
+            PeerState state = null;
+            synchronized(sendQueue)
+              {
+                while (!quit && sendQueue.isEmpty())
+                  {
+                    try
+                      {
+                        // Make sure everything will reach the other side.
+                        dout.flush();
+                        
+                        // Wait till more data arrives.
+                        sendQueue.wait();
+                      }
+                    catch (InterruptedException ie)
+                      {
+                        /* ignored */
+                      }
+                  }
+                state = peer.state;
+                if (!quit && state != null)
+                  {
+                    // Piece messages are big. So if there are other
+                    // (control) messages make sure they are send first.
+                    // Also remove request messages from the queue if
+                    // we are currently being choked to prevent them from
+                    // being send even if we get unchoked a little later.
+                    // (Since we will resent them anyway in that case.)
+                    // And remove piece messages if we are choking.
+                    Iterator it = sendQueue.iterator();
+                    while (m == null && it.hasNext())
+                      {
+                        Message nm = (Message)it.next();
+                        if (nm.type == Message.PIECE)
+                          {
+                            if (state.choking)
+                              it.remove();
+                            nm = null;
+                          }
+                        else if (nm.type == Message.REQUEST && state.choked)
+                          {
+                            it.remove();
+                            nm = null;
+                          }
+                          
+                        if (m == null && nm != null)
+                          {
+                            m = nm;
+                            it.remove();
+                          }
+                      }
+                    if (m == null && sendQueue.size() > 0)
+                      m = (Message)sendQueue.remove(0);
+                  }
+              }
+            if (m != null)
+              {
+                if (Snark.debug >= Snark.ALL)
+                  Snark.debug("Send " + peer + ": " + m, Snark.ALL);
+                m.sendMessage(dout);
+
+                // Remove all piece messages after sending a choke message.
+                if (m.type == Message.CHOKE)
+                  removeMessage(Message.PIECE);
+
+                // XXX - Should also register overhead...
+                if (m.type == Message.PIECE)
+                  state.uploaded(m.len);
+
+                m = null;
+              }
+          }
+      }
+    catch (IOException ioe)
+      {
+        // Ignore, probably other side closed connection.
+      }
+    catch (Throwable t)
+      {
+        Snark.debug(peer + ": "  + t, Snark.ERROR);
+        t.printStackTrace();
+      }
+    finally
+      {
+        quit = true;
+        peer.disconnect();
+      }
+  }
+
+  public void disconnect()
+  {
+    synchronized(sendQueue)
+      {
+        if (quit == true)
+          return;
+        
+        quit = true;
+        thread.interrupt();
+        
+        sendQueue.clear();
+        sendQueue.notify();
+      }
+  }
+
+  /**
+   * Adds a message to the sendQueue and notifies the method waiting
+   * on the sendQueue to change.
+   */
+  private void addMessage(Message m)
+  {
+    synchronized(sendQueue)
+      {
+        sendQueue.add(m);
+        sendQueue.notify();
+      }
+  }
+
+  /**
+   * Removes a particular message type from the queue.
+   *
+   * @param type the Message type to remove.
+   * @returns true when a message of the given type was removed, false
+   * otherwise.
+   */
+  private boolean removeMessage(int type)
+  {
+    boolean removed = false;
+    synchronized(sendQueue)
+      {
+        Iterator it = sendQueue.iterator();
+        while (it.hasNext())
+          {
+            Message m = (Message)it.next();
+            if (m.type == type)
+              {
+                it.remove();
+                removed = true;
+              }
+          }
+      }
+    return removed;
+  }
+
+  void sendAlive()
+  {
+    Message m = new Message();
+    m.type = Message.KEEP_ALIVE;
+    addMessage(m);
+  }
+
+  void sendChoke(boolean choke)
+  {
+    // We cancel the (un)choke but keep PIECE messages.
+    // PIECE messages are purged if a choke is actually send.
+    synchronized(sendQueue)
+      {
+        int inverseType  = choke ? Message.UNCHOKE
+                                 : Message.CHOKE;
+        if (!removeMessage(inverseType))
+          {
+            Message m = new Message();
+            if (choke)
+              m.type = Message.CHOKE;
+            else
+              m.type = Message.UNCHOKE;
+            addMessage(m);
+          }
+      }
+  }
+
+  void sendInterest(boolean interest)
+  {
+    synchronized(sendQueue)
+      {
+        int inverseType  = interest ? Message.UNINTERESTED
+                                    : Message.INTERESTED;
+        if (!removeMessage(inverseType))
+          {
+            Message m = new Message();
+            if (interest)
+              m.type = Message.INTERESTED;
+            else
+              m.type = Message.UNINTERESTED;
+            addMessage(m);
+          }
+      }
+  }
+
+  void sendHave(int piece)
+  {
+    Message m = new Message();
+    m.type = Message.HAVE;
+    m.piece = piece;
+    addMessage(m);
+  }
+
+  void sendBitfield(BitField bitfield)
+  {
+    Message m = new Message();
+    m.type = Message.BITFIELD;
+    m.data = bitfield.getFieldBytes();
+    m.off = 0;
+    m.len = m.data.length;
+    addMessage(m);
+  }
+
+  void sendRequests(List requests)
+  {
+    Iterator it = requests.iterator();
+    while (it.hasNext())
+      {
+        Request req = (Request)it.next();
+        sendRequest(req);
+      }
+  }
+
+  void sendRequest(Request req)
+  {
+    Message m = new Message();
+    m.type = Message.REQUEST;
+    m.piece = req.piece;
+    m.begin = req.off;
+    m.length = req.len;
+    addMessage(m);
+  }
+
+  void sendPiece(int piece, int begin, int length, byte[] bytes)
+  {
+    Message m = new Message();
+    m.type = Message.PIECE;
+    m.piece = piece;
+    m.begin = begin;
+    m.length = length;
+    m.data = bytes;
+    m.off = begin;
+    m.len = length;
+    addMessage(m);
+  }
+
+  void sendCancel(Request req)
+  {
+    // See if it is still in our send queue
+    synchronized(sendQueue)
+      {
+        Iterator it = sendQueue.iterator();
+        while (it.hasNext())
+          {
+            Message m = (Message)it.next();
+            if (m.type == Message.REQUEST
+                && m.piece == req.piece
+                && m.begin == req.off
+                && m.length == req.len)
+              it.remove();
+          }
+      }
+
+    // Always send, just to be sure it it is really canceled.
+    Message m = new Message();
+    m.type = Message.CANCEL;
+    m.piece = req.piece;
+    m.begin = req.off;
+    m.length = req.len;
+    addMessage(m);
+  }
+
+  // Called by the PeerState when the other side doesn't want this
+  // request to be handled anymore. Removes any pending Piece Message
+  // from out send queue.
+  void cancelRequest(int piece, int begin, int length)
+  {
+    synchronized (sendQueue)
+      {
+        Iterator it = sendQueue.iterator();
+        while (it.hasNext())
+          {
+            Message m = (Message)it.next();
+            if (m.type == Message.PIECE
+                && m.piece == piece
+                && m.begin == begin
+                && m.length == length)
+              it.remove();
+          }
+      }
+  }
+}

apps/i2psnark/java/src/org/klomp/snark/PeerCoordinator.java

@@ -0,0 +1,534 @@
+/* PeerCoordinator - Coordinates which peers do what (up and downloading).
+   Copyright (C) 2003 Mark J. Wielaard
+
+   This file is part of Snark.
+   
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+ 
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+ 
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+*/
+
+package org.klomp.snark;
+
+import java.util.*;
+import java.io.IOException;
+
+/**
+ * Coordinates what peer does what.
+ */
+public class PeerCoordinator implements PeerListener
+{
+  final MetaInfo metainfo;
+  final Storage storage;
+
+  // package local for access by CheckDownLoadersTask
+  final static long CHECK_PERIOD = 20*1000; // 20 seconds
+  final static int MAX_CONNECTIONS = 24;
+  final static int MAX_UPLOADERS = 12; // i2p: might as well balance it out
+
+  // Approximation of the number of current uploaders.
+  // Resynced by PeerChecker once in a while.
+  int uploaders = 0;
+
+  // final static int MAX_DOWNLOADERS = MAX_CONNECTIONS;
+  // int downloaders = 0;
+
+  private long uploaded;
+  private long downloaded;
+
+  // synchronize on this when changing peers or downloaders
+  final List peers = new ArrayList();
+
+  /** Timer to handle all periodical tasks. */
+  private final Timer timer = new Timer(true);
+
+  private final byte[] id;
+
+  // Some random wanted pieces
+  private final List wantedPieces;
+
+  private boolean halted = false;
+
+  private final CoordinatorListener listener;
+
+  public PeerCoordinator(byte[] id, MetaInfo metainfo, Storage storage,
+                         CoordinatorListener listener)
+  {
+    this.id = id;
+    this.metainfo = metainfo;
+    this.storage = storage;
+    this.listener = listener;
+
+    // Make a list of pieces
+    wantedPieces = new ArrayList();
+    BitField bitfield = storage.getBitField();
+    for(int i = 0; i < metainfo.getPieces(); i++)
+      if (!bitfield.get(i))
+        wantedPieces.add(new Piece(i));
+    Collections.shuffle(wantedPieces);
+
+    // Install a timer to check the uploaders.
+    timer.schedule(new PeerCheckerTask(this), CHECK_PERIOD, CHECK_PERIOD);
+  }
+
+  public byte[] getID()
+  {
+    return id;
+  }
+
+  public boolean completed()
+  {
+    return storage.complete();
+  }
+
+
+  public int getPeers()
+  {
+    synchronized(peers)
+      {
+        return peers.size();
+      }
+  }
+
+  /**
+   * Returns how many bytes are still needed to get the complete file.
+   */
+  public long getLeft()
+  {
+    // XXX - Only an approximation.
+    return storage.needed() * metainfo.getPieceLength(0);
+  }
+
+  /**
+   * Returns the total number of uploaded bytes of all peers.
+   */
+  public long getUploaded()
+  {
+    return uploaded;
+  }
+
+  /**
+   * Returns the total number of downloaded bytes of all peers.
+   */
+  public long getDownloaded()
+  {
+    return downloaded;
+  }
+
+  public MetaInfo getMetaInfo()
+  {
+    return metainfo;
+  }
+
+  public boolean needPeers()
+  {
+    synchronized(peers)
+      {
+        return !halted && peers.size() < MAX_CONNECTIONS;
+      }
+  }
+
+  public void halt()
+  {
+    halted = true;
+    synchronized(peers)
+      {
+        // Stop peer checker task.
+        timer.cancel();
+
+        // Stop peers.
+        Iterator it = peers.iterator();
+        while(it.hasNext())
+          {
+            Peer peer = (Peer)it.next();
+            peer.disconnect();
+            it.remove();
+            removePeerFromPieces(peer);
+          }
+      }
+  }
+
+  public void connected(Peer peer)
+  {
+    if (halted)
+      {
+        peer.disconnect(false);
+        return;
+      }
+
+    synchronized(peers)
+      {
+        if (peerIDInList(peer.getPeerID(), peers))
+          {
+            if (Snark.debug >= Snark.INFO)
+              Snark.debug("Already connected to: " + peer, Snark.INFO);
+            peer.disconnect(false); // Don't deregister this connection/peer.
+          }
+        else
+          {
+            if (Snark.debug >= Snark.INFO)
+              Snark.debug("New connection to peer: " + peer, Snark.INFO);
+
+            // Add it to the beginning of the list.
+            // And try to optimistically make it a uploader.
+            peers.add(0, peer);
+            unchokePeer();
+
+            if (listener != null)
+              listener.peerChange(this, peer);
+          }
+      }
+  }
+
+  private static boolean peerIDInList(PeerID pid, List peers)
+  {
+    Iterator it = peers.iterator();
+    while (it.hasNext())
+      if (pid.sameID(((Peer)it.next()).getPeerID()))
+        return true;
+    return false;
+  }
+
+  public void addPeer(final Peer peer)
+  {
+    if (halted)
+      {
+        peer.disconnect(false);
+        return;
+      }
+
+    boolean need_more;
+    synchronized(peers)
+      {
+        need_more = !peer.isConnected() && peers.size() < MAX_CONNECTIONS;
+      }
+
+    if (need_more)
+      {
+        // Run the peer with us as listener and the current bitfield.
+        final PeerListener listener = this;
+        final BitField bitfield = storage.getBitField();
+        Runnable r = new Runnable()
+          {
+            public void run()
+            {
+              peer.runConnection(listener, bitfield);
+            }
+          };
+        String threadName = peer.toString();
+        new Thread(r, threadName).start();
+      }
+    else
+      if (Snark.debug >= Snark.INFO)
+        if (peer.isConnected())
+          Snark.debug("Add peer already connected: " + peer, Snark.INFO);
+        else
+          Snark.debug("MAX_CONNECTIONS = " + MAX_CONNECTIONS
+                      + " not accepting extra peer: " + peer, Snark.INFO);
+  }
+
+
+  // (Optimistically) unchoke. Should be called with peers synchronized
+  void unchokePeer()
+  {
+    // linked list will contain all interested peers that we choke.
+    // At the start are the peers that have us unchoked at the end the
+    // other peer that are interested, but are choking us.
+    List interested = new LinkedList();
+    Iterator it = peers.iterator();
+    while (it.hasNext())
+      {
+        Peer peer = (Peer)it.next();
+        boolean remove = false;
+        if (uploaders < MAX_UPLOADERS
+            && peer.isChoking()
+            && peer.isInterested())
+          {
+            if (!peer.isChoked())
+              interested.add(0, peer);
+            else
+              interested.add(peer);
+          }
+      }
+
+    while (uploaders < MAX_UPLOADERS && interested.size() > 0)
+      {
+        Peer peer = (Peer)interested.remove(0);
+        if (Snark.debug >= Snark.INFO)
+          Snark.debug("Unchoke: " + peer, Snark.INFO);
+        peer.setChoking(false);
+        uploaders++;
+        // Put peer back at the end of the list.
+        peers.remove(peer);
+        peers.add(peer);
+      }
+  }
+
+  public byte[] getBitMap()
+  {
+    return storage.getBitField().getFieldBytes();
+  }
+
+  /**
+   * Returns true if we don't have the given piece yet.
+   */
+  public boolean gotHave(Peer peer, int piece)
+  {
+    if (listener != null)
+      listener.peerChange(this, peer);
+
+    synchronized(wantedPieces)
+      {
+        return wantedPieces.contains(new Piece(piece));
+      }
+  }
+
+  /**
+   * Returns true if the given bitfield contains at least one piece we
+   * are interested in.
+   */
+  public boolean gotBitField(Peer peer, BitField bitfield)
+  {
+    if (listener != null)
+      listener.peerChange(this, peer);
+
+    synchronized(wantedPieces)
+      {
+        Iterator it = wantedPieces.iterator();
+        while (it.hasNext())
+          {
+            Piece p = (Piece)it.next();
+            int i = p.getId();
+            if (bitfield.get(i))
+              p.addPeer(peer);
+              return true;
+          }
+      }
+    return false;
+  }
+
+  /**
+   * Returns one of pieces in the given BitField that is still wanted or
+   * -1 if none of the given pieces are wanted.
+   */
+  public int wantPiece(Peer peer, BitField havePieces)
+  {
+    if (halted)
+      return -1;
+
+    synchronized(wantedPieces)
+      {
+        Piece piece = null;
+        Collections.sort(wantedPieces); // Sort in order of rarest first.
+        List requested = new ArrayList(); 
+        Iterator it = wantedPieces.iterator();
+        while (piece == null && it.hasNext())
+          {
+            Piece p = (Piece)it.next();
+            if (havePieces.get(p.getId()) && !p.isRequested())
+              {
+                piece = p;
+              }
+            else if (p.isRequested()) 
+            {
+                requested.add(p);
+            }
+          }
+        
+        //Only request a piece we've requested before if there's no other choice.
+        if (piece == null) {
+            Iterator it2 = requested.iterator();
+            while (piece == null && it2.hasNext())
+              {
+                Piece p = (Piece)it2.next();
+                if (havePieces.get(p.getId()))
+                  {
+                    piece = p;
+                  }
+              }
+            if (piece == null) return -1; //If we still can't find a piece we want, so be it.
+        }
+        piece.setRequested(true);
+        return piece.getId();
+      }
+  }
+
+  /**
+   * Returns a byte array containing the requested piece or null of
+   * the piece is unknown.
+   */
+  public byte[] gotRequest(Peer peer, int piece)
+  {
+    if (halted)
+      return null;
+
+    try
+      {
+        return storage.getPiece(piece);
+      }
+    catch (IOException ioe)
+      {
+        Snark.fatal("Error reading storage", ioe);
+        return null; // Never reached.
+      }
+  }
+
+  /**
+   * Called when a peer has uploaded some bytes of a piece.
+   */
+  public void uploaded(Peer peer, int size)
+  {
+    uploaded += size;
+
+    if (listener != null)
+      listener.peerChange(this, peer);
+  }
+
+  /**
+   * Called when a peer has downloaded some bytes of a piece.
+   */
+  public void downloaded(Peer peer, int size)
+  {
+    downloaded += size;
+
+    if (listener != null)
+      listener.peerChange(this, peer);
+  }
+
+  /**
+   * Returns false if the piece is no good (according to the hash).
+   * In that case the peer that supplied the piece should probably be
+   * blacklisted.
+   */
+  public boolean gotPiece(Peer peer, int piece, byte[] bs)
+  {
+    if (halted)
+      return true; // We don't actually care anymore.
+    
+    synchronized(wantedPieces)
+      {
+        Piece p = new Piece(piece);
+        if (!wantedPieces.contains(p))
+          {
+            if (Snark.debug >= Snark.INFO)
+              Snark.debug(peer + " piece " + piece + " no longer needed",
+                          Snark.INFO);
+            
+            // No need to announce have piece to peers.
+            // Assume we got a good piece, we don't really care anymore.
+            return true;
+          }
+        
+        try
+          {
+            if (storage.putPiece(piece, bs))
+              {
+                if (Snark.debug >= Snark.INFO)
+                  Snark.debug("Recv p" + piece + " " + peer, Snark.INFO);
+              }
+            else
+              {
+                // Oops. We didn't actually download this then... :(
+                downloaded -= metainfo.getPieceLength(piece);
+                if (Snark.debug >= Snark.NOTICE)
+                  Snark.debug("Got BAD piece " + piece + " from " + peer,
+                              Snark.NOTICE);
+                return false; // No need to announce BAD piece to peers.
+              }
+          }
+        catch (IOException ioe)
+          {
+            Snark.fatal("Error writing storage", ioe);
+          }
+        wantedPieces.remove(p);
+      }
+
+    // Announce to the world we have it!
+    synchronized(peers)
+      {
+        Iterator it = peers.iterator();
+        while (it.hasNext())
+          {
+            Peer p = (Peer)it.next();
+            if (p.isConnected())
+              p.have(piece);
+          }
+      }
+    
+    return true;
+  }
+
+  public void gotChoke(Peer peer, boolean choke)
+  {
+    if (Snark.debug >= Snark.INFO)
+      Snark.debug("Got choke(" + choke + "): " + peer, Snark.INFO);
+
+    if (listener != null)
+      listener.peerChange(this, peer);
+  }
+
+  public void gotInterest(Peer peer, boolean interest)
+  {
+    if (interest)
+      {
+        synchronized(peers)
+          {
+            if (uploaders < MAX_UPLOADERS)
+              {
+                if(peer.isChoking())
+                  {
+                    uploaders++;
+                    peer.setChoking(false);
+                    if (Snark.debug >= Snark.INFO)
+                      Snark.debug("Unchoke: " + peer, Snark.INFO);
+                  }
+              }
+          }
+      }
+
+    if (listener != null)
+      listener.peerChange(this, peer);
+  }
+
+  public void disconnected(Peer peer)
+  {
+    if (Snark.debug >= Snark.INFO)
+      Snark.debug("Disconnected " + peer, Snark.INFO);
+    
+    synchronized(peers)
+      {
+        // Make sure it is no longer in our lists
+        if (peers.remove(peer))
+          {
+            // Unchoke some random other peer
+            unchokePeer();
+            removePeerFromPieces(peer);
+          }
+      }
+
+    if (listener != null)
+      listener.peerChange(this, peer);
+  }
+  
+  /** Called when a peer is removed, to prevent it from being used in 
+   * rarest-first calculations.
+   */
+  public void removePeerFromPieces(Peer peer) {
+      synchronized(wantedPieces) {
+          for(Iterator iter = wantedPieces.iterator(); iter.hasNext(); ) {
+              Piece piece = (Piece)iter.next();
+              piece.removePeer(peer);
+          }
+      } 
+  }
+}

apps/i2psnark/java/src/org/klomp/snark/PeerID.java

@@ -0,0 +1,208 @@
+/* PeerID - All public information concerning a peer.
+   Copyright (C) 2003 Mark J. Wielaard
+
+   This file is part of Snark.
+   
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+ 
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+ 
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+*/
+
+package org.klomp.snark;
+
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.util.Map;
+
+import org.klomp.snark.bencode.*;
+
+import net.i2p.data.Base64;
+import net.i2p.data.Destination;
+import net.i2p.data.DataFormatException;
+
+public class PeerID implements Comparable
+{
+  private final byte[] id;
+  private final Destination address;
+  private final int port;
+
+  private final int hash;
+
+  public PeerID(byte[] id, Destination address)
+  {
+    this.id = id;
+    this.address = address;
+    this.port = 6881;
+
+    hash = calculateHash();
+  }
+
+  /**
+   * Creates a PeerID from a BDecoder.
+   */
+  public PeerID(BDecoder be)
+    throws IOException
+  {
+    this(be.bdecodeMap().getMap());
+  }
+
+  /**
+   * Creates a PeerID from a Map containing BEncoded peer id, ip and
+   * port.
+   */
+  public PeerID(Map m)
+    throws InvalidBEncodingException, UnknownHostException
+  {
+    BEValue bevalue = (BEValue)m.get("peer id");
+    if (bevalue == null)
+      throw new InvalidBEncodingException("peer id missing");
+    id = bevalue.getBytes();
+
+    bevalue = (BEValue)m.get("ip");
+    if (bevalue == null)
+      throw new InvalidBEncodingException("ip missing");
+    address = I2PSnarkUtil.instance().getDestination(bevalue.getString());
+    if (address == null)
+        throw new InvalidBEncodingException("Invalid destination [" + bevalue.getString() + "]");
+
+    port = 6881;
+
+    hash = calculateHash();
+  }
+
+  public byte[] getID()
+  {
+    return id;
+  }
+
+  public Destination getAddress()
+  {
+    return address;
+  }
+
+  public int getPort()
+  {
+    return port;
+  }
+
+  private int calculateHash()
+  {
+    int b = 0;
+    for (int i = 0; i < id.length; i++)
+      b ^= id[i];
+    return (b ^ address.hashCode()) ^ port;
+  }
+
+  /**
+   * The hash code of a PeerID is the exclusive or of all id bytes.
+   */
+  public int hashCode()
+  {
+    return hash;
+  }
+
+  /**
+   * Returns true if and only if this peerID and the given peerID have
+   * the same 20 bytes as ID.
+   */
+  public boolean sameID(PeerID pid)
+  {
+    boolean equal = true;
+    for (int i = 0; equal && i < id.length; i++)
+      equal = id[i] == pid.id[i];
+    return equal;
+  }
+
+  /**
+   * Two PeerIDs are equal when they have the same id, address and port.
+   */
+  public boolean equals(Object o)
+  {
+    if (o instanceof PeerID)
+      {
+        PeerID pid = (PeerID)o;
+
+        return port == pid.port
+          && address.equals(pid.address)
+          && sameID(pid);
+      }
+    else
+      return false;
+  }
+
+  /**
+   * Compares port, address and id.
+   */
+  public int compareTo(Object o)
+  {
+    PeerID pid = (PeerID)o;
+
+    int result = port - pid.port;
+    if (result != 0)
+      return result;
+
+    result = address.hashCode() - pid.address.hashCode();
+    if (result != 0)
+      return result;
+
+    for (int i = 0; i < id.length; i++)
+      {
+        result = id[i] - pid.id[i];
+        if (result != 0)
+          return result;
+      }
+
+    return 0;
+  }
+
+  /**
+   * Returns the String "id@address" where id is the base64 encoded id.
+   */
+  public String toString()
+  {
+    int nonZero = 0;
+    for (int i = 0; i < id.length; i++) {
+        if (id[i] != 0) {
+            nonZero = i;
+            break;
+        }
+    }
+    return Base64.encode(id, nonZero, id.length-nonZero).substring(0,4) + "@" + address.calculateHash().toBase64().substring(0,6);
+  }
+
+  /**
+   * Encode an id as a hex encoded string and remove leading zeros.
+   */
+  public static String idencode(byte[] bs)
+  {
+    boolean leading_zeros = true;
+
+    StringBuffer sb = new StringBuffer(bs.length*2);
+    for (int i = 0; i < bs.length; i++)
+      {
+        int c = bs[i] & 0xFF;
+        if (leading_zeros && c == 0)
+          continue;
+        else
+          leading_zeros = false;
+
+        if (c < 16)
+          sb.append('0');
+        sb.append(Integer.toHexString(c));
+      }
+
+    return sb.toString();
+  }
+
+}

apps/i2psnark/java/src/org/klomp/snark/PeerListener.java

@@ -0,0 +1,145 @@
+/* PeerListener - Interface for listening to peer events.
+   Copyright (C) 2003 Mark J. Wielaard
+
+   This file is part of Snark.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+*/
+
+package org.klomp.snark;
+
+/**
+ * Listener for Peer events.
+ */
+public interface PeerListener
+{
+  /**
+   * Called when the connection to the peer has started and the
+   * handshake was successfull.
+   *
+   * @param peer the Peer that just got connected.
+   */
+  void connected(Peer peer);
+
+  /**
+   * Called when the connection to the peer was terminated or the
+   * connection handshake failed.
+   *
+   * @param peer the Peer that just got disconnected.
+   */
+  void disconnected(Peer peer);
+
+  /**
+   * Called when a choke message is received.
+   *
+   * @param peer the Peer that got the message.
+   * @param choke true when the peer got a choke message, false when
+   * the peer got an unchoke message.
+   */
+  void gotChoke(Peer peer, boolean choke);
+
+  /**
+   * Called when an interested message is received.
+   *
+   * @param peer the Peer that got the message.
+   * @param interest true when the peer got a interested message, false when
+   * the peer got an uninterested message.
+   */
+  void gotInterest(Peer peer, boolean interest);
+
+  /**
+   * Called when a have piece message is received. If the method
+   * returns true and the peer has not yet received a interested
+   * message or we indicated earlier to be not interested then an
+   * interested message will be send.
+   *
+   * @param peer the Peer that got the message.
+   * @param piece the piece number that the per just got.
+   *
+   * @return true when it is a piece that we want, false if the piece is
+   * already known.
+   */
+  boolean gotHave(Peer peer, int piece);
+
+  /**
+   * Called when a bitmap message is received. If this method returns
+   * true a interested message will be send back to the peer.
+   *
+   * @param peer the Peer that got the message.
+   * @param bitfield a BitField containing the pieces that the other
+   * side has.
+   *
+   * @return true when the BitField contains pieces we want, false if
+   * the piece is already known.
+   */
+  boolean gotBitField(Peer peer, BitField bitfield);
+
+  /**
+   * Called when a piece is received from the peer. The piece must be
+   * requested by Peer.request() first. If this method returns false
+   * that means the Peer provided a corrupted piece and the connection
+   * will be closed.
+   *
+   * @param peer the Peer that got the piece.
+   * @param piece the piece number received.
+   * @param bs the byte array containing the piece.
+   *
+   * @return true when the bytes represent the piece, false otherwise.
+   */
+  boolean gotPiece(Peer peer, int piece, byte[] bs);
+
+  /**
+   * Called when the peer wants (part of) a piece from us. Only called
+   * when the peer is not choked by us (<code>peer.choke(false)</code>
+   * was called).
+   *
+   * @param peer the Peer that wants the piece.
+   * @param piece the piece number requested.
+   *
+   * @return a byte array containing the piece or null when the piece
+   * is not available (which is a protocol error).
+   */
+  byte[] gotRequest(Peer peer, int piece);
+
+  /**
+   * Called when a (partial) piece has been downloaded from the peer.
+   *
+   * @param peer the Peer from which size bytes where downloaded.
+   * @param size the number of bytes that where downloaded.
+   */
+  void downloaded(Peer peer, int size);
+
+  /**
+   * Called when a (partial) piece has been uploaded to the peer.
+   *
+   * @param peer the Peer to which size bytes where uploaded.
+   * @param size the number of bytes that where uploaded.
+   */
+  void uploaded(Peer peer, int size);
+
+  /**
+   * Called when we are downloading from the peer and need to ask for
+   * a new piece. Might be called multiple times before
+   * <code>gotPiece()</code> is called.
+   *
+   * @param peer the Peer that will be asked to provide the piece.
+   * @param bitfield a BitField containing the pieces that the other
+   * side has.
+   *
+   * @return one of the pieces from the bitfield that we want or -1 if
+   * we are no longer interested in the peer.
+   */
+  int wantPiece(Peer peer, BitField bitfield);
+}

apps/i2psnark/java/src/org/klomp/snark/PeerMonitorTask.java

@@ -0,0 +1,128 @@
+/* PeerMonitorTasks - TimerTask that monitors the peers and total up/down speed
+   Copyright (C) 2003 Mark J. Wielaard
+
+   This file is part of Snark.
+   
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+ 
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+ 
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+*/
+
+package org.klomp.snark;
+
+import java.util.*;
+
+/**
+ * TimerTask that monitors the peers and total up/download speeds.
+ * Works together with the main Snark class to report periodical statistics.
+ */
+class PeerMonitorTask extends TimerTask
+{
+  final static long MONITOR_PERIOD = 10 * 1000; // Ten seconds.
+  private final long KILOPERSECOND = 1024 * (MONITOR_PERIOD / 1000);
+
+  private final PeerCoordinator coordinator;
+
+  private long lastDownloaded = 0;
+  private long lastUploaded = 0;
+
+  PeerMonitorTask(PeerCoordinator coordinator)
+  {
+    this.coordinator = coordinator;
+  }
+
+  public void run()
+  {
+    // Get some statistics
+    int peers = 0;
+    int uploaders = 0;
+    int downloaders = 0;
+    int interested = 0;
+    int interesting = 0;
+    int choking = 0;
+    int choked = 0;
+    
+    synchronized(coordinator.peers)
+      {
+        Iterator it = coordinator.peers.iterator();
+        while (it.hasNext())
+          {
+            Peer peer = (Peer)it.next();
+            
+            // Don't list dying peers
+            if (!peer.isConnected())
+              continue;
+            
+            peers++;
+            
+            if (!peer.isChoking())
+              uploaders++;
+            if (!peer.isChoked() && peer.isInteresting())
+              downloaders++;
+            if (peer.isInterested())
+              interested++;
+            if (peer.isInteresting())
+              interesting++;
+            if (peer.isChoking())
+              choking++;
+            if (peer.isChoked())
+              choked++;
+          }
+      }
+
+    // Print some statistics
+    long downloaded = coordinator.getDownloaded();
+    String totalDown;
+    if (downloaded >= 10 * 1024 * 1024)
+      totalDown = (downloaded / (1024 * 1024)) + "MB";
+    else
+      totalDown = (downloaded / 1024 )+ "KB";
+    long uploaded = coordinator.getUploaded();
+    String totalUp;
+    if (uploaded >= 10 * 1024 * 1024)
+      totalUp = (uploaded / (1024 * 1024)) + "MB";
+    else
+      totalUp = (uploaded / 1024) + "KB";
+    
+    int needP = coordinator.storage.needed();
+    long needMB
+      = needP * coordinator.metainfo.getPieceLength(0) / (1024 * 1024);
+    int totalP = coordinator.metainfo.getPieces();
+    long totalMB = coordinator.metainfo.getTotalLength() / (1024 * 1024);
+    
+    System.out.println();
+    System.out.println("Down: "
+                       + (downloaded - lastDownloaded) / KILOPERSECOND
+                       + "KB/s"
+                       + " (" + totalDown + ")"
+                       + " Up: "
+                       + (uploaded - lastUploaded) / KILOPERSECOND
+                       + "KB/s"
+                       + " (" + totalUp + ")"
+                       + " Need " + needP
+                       + " (" + needMB + "MB)"
+                       + " of " + totalP
+                       + " (" + totalMB + "MB)"
+                       + " pieces");
+    System.out.println(peers + ": Download #" + downloaders
+                       + " Upload #" + uploaders
+                       + " Interested #" + interested
+                       + " Interesting #" + interesting
+                       + " Choking #" + choking
+                       + " Choked #" + choked);
+    System.out.println();
+
+    lastDownloaded = downloaded;
+    lastUploaded = uploaded;
+  }
+}

apps/i2psnark/java/src/org/klomp/snark/PeerState.java

@@ -0,0 +1,539 @@
+/* PeerState - Keeps track of the Peer state through connection callbacks.
+   Copyright (C) 2003 Mark J. Wielaard
+
+   This file is part of Snark.
+   
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+ 
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+ 
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+*/
+
+package org.klomp.snark;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+import java.util.HashSet;
+
+class PeerState
+{
+  final Peer peer;
+  final PeerListener listener;
+  final MetaInfo metainfo;
+
+  // Interesting and choking describes whether we are interested in or
+  // are choking the other side.
+  boolean interesting = false;
+  boolean choking = true;
+
+  // Interested and choked describes whether the other side is
+  // interested in us or choked us.
+  boolean interested = false;
+  boolean choked = true;
+
+  // Package local for use by Peer.
+  long downloaded;
+  long uploaded;
+
+  BitField bitfield;
+
+  // Package local for use by Peer.
+  final PeerConnectionIn in;
+  final PeerConnectionOut out;
+
+  // Outstanding request
+  private final List outstandingRequests = new ArrayList();
+  private Request lastRequest = null;
+
+  // If we have te resend outstanding requests (true after we got choked).
+  private boolean resend = false;
+
+  private final static int MAX_PIPELINE = 5;
+  private final static int PARTSIZE = 64*1024; // default was 16K, i2p-bt uses 64KB
+
+  PeerState(Peer peer, PeerListener listener, MetaInfo metainfo,
+            PeerConnectionIn in, PeerConnectionOut out)
+  {
+    this.peer = peer;
+    this.listener = listener;
+    this.metainfo = metainfo;
+
+    this.in = in;
+    this.out = out;
+  }
+
+  // NOTE Methods that inspect or change the state synchronize (on this).
+
+  void keepAliveMessage()
+  {
+    if (Snark.debug >= Snark.DEBUG)
+      Snark.debug(peer + " rcv alive", Snark.DEBUG);
+    /* XXX - ignored */
+  }
+
+  void chokeMessage(boolean choke)
+  {
+    if (Snark.debug >= Snark.DEBUG)
+      Snark.debug(peer + " rcv " + (choke ? "" : "un") + "choked",
+                  Snark.DEBUG);
+
+    choked = choke;
+    if (choked)
+      resend = true;
+
+    listener.gotChoke(peer, choke);
+
+    if (!choked && interesting)
+      request();
+  }
+
+  void interestedMessage(boolean interest)
+  {
+    if (Snark.debug >= Snark.DEBUG)
+      Snark.debug(peer + " rcv " + (interest ? "" : "un")
+                  + "interested", Snark.DEBUG);
+    interested = interest;
+    listener.gotInterest(peer, interest);
+  }
+
+  void haveMessage(int piece)
+  {
+    if (Snark.debug >= Snark.DEBUG)
+      Snark.debug(peer + " rcv have(" + piece + ")", Snark.DEBUG);
+    // Sanity check
+    if (piece < 0 || piece >= metainfo.getPieces())
+      {
+        // XXX disconnect?
+        if (Snark.debug >= Snark.INFO)
+          Snark.debug("Got strange 'have: " + piece + "' message from " + peer,
+                      + Snark.INFO);
+        return;
+      }
+
+    synchronized(this)
+      {
+        // Can happen if the other side never send a bitfield message.
+        if (bitfield == null)
+          bitfield = new BitField(metainfo.getPieces());
+
+        bitfield.set(piece);
+      }
+
+    if (listener.gotHave(peer, piece))
+      setInteresting(true);
+  }
+
+  void bitfieldMessage(byte[] bitmap)
+  {
+    synchronized(this)
+      {
+        if (Snark.debug >= Snark.DEBUG)
+          Snark.debug(peer + " rcv bitfield", Snark.DEBUG);
+        if (bitfield != null)
+          {
+            // XXX - Be liberal in what you except?
+            if (Snark.debug >= Snark.INFO)
+              Snark.debug("Got unexpected bitfield message from " + peer,
+                          Snark.INFO);
+            return;
+          }
+        
+        // XXX - Check for weird bitfield and disconnect?
+        bitfield = new BitField(bitmap, metainfo.getPieces());
+      }
+    setInteresting(listener.gotBitField(peer, bitfield));
+  }
+
+  void requestMessage(int piece, int begin, int length)
+  {
+    if (Snark.debug >= Snark.DEBUG)
+      Snark.debug(peer + " rcv request("
+                  + piece + ", " + begin + ", " + length + ") ",
+                  Snark.DEBUG);
+    if (choking)
+      {
+        if (Snark.debug >= Snark.INFO)
+          Snark.debug("Request received, but choking " + peer, Snark.INFO);
+        return;
+      }
+
+    // Sanity check
+    if (piece < 0
+        || piece >= metainfo.getPieces()
+        || begin < 0
+        || begin > metainfo.getPieceLength(piece)
+        || length <= 0
+        || length > 4*PARTSIZE)
+      {
+        // XXX - Protocol error -> disconnect?
+        if (Snark.debug >= Snark.INFO)
+          Snark.debug("Got strange 'request: " + piece
+                      + ", " + begin
+                      + ", " + length
+                      + "' message from " + peer,
+                      Snark.INFO);
+        return;
+      }
+
+    byte[] pieceBytes = listener.gotRequest(peer, piece);
+    if (pieceBytes == null)
+      {
+        // XXX - Protocol error-> diconnect?
+        if (Snark.debug >= Snark.INFO)
+          Snark.debug("Got request for unknown piece: " + piece, Snark.INFO);
+        return;
+      }
+
+    // More sanity checks
+    if (begin >= pieceBytes.length || begin + length > pieceBytes.length)
+      {
+        // XXX - Protocol error-> disconnect?
+        if (Snark.debug >= Snark.INFO)
+          Snark.debug("Got out of range 'request: " + piece
+                      + ", " + begin
+                      + ", " + length
+                      + "' message from " + peer,
+                      Snark.INFO);
+        return;
+      }
+
+    if (Snark.debug >= Snark.DEBUG)
+      Snark.debug("Sending (" + piece + ", " + begin + ", "
+                  + length + ")" + " to " + peer, Snark.DEBUG);
+    out.sendPiece(piece, begin, length, pieceBytes);
+
+    // Tell about last subpiece delivery.
+    if (begin + length == pieceBytes.length)
+      if (Snark.debug >= Snark.DEBUG)
+        Snark.debug("Send p" + piece + " " + peer,
+                    Snark.DEBUG);
+  }
+
+  /**
+   * Called when some bytes have left the outgoing connection.
+   * XXX - Should indicate whether it was a real piece or overhead.
+   */
+  void uploaded(int size)
+  {
+    uploaded += size;
+    listener.uploaded(peer, size);
+  }
+
+  /**
+   * Called when a partial piece request has been handled by
+   * PeerConnectionIn.
+   */
+  void pieceMessage(Request req)
+  {
+    int size = req.len;
+    downloaded += size;
+    listener.downloaded(peer, size);
+
+    // Last chunk needed for this piece?
+    if (getFirstOutstandingRequest(req.piece) == -1)
+      {
+        if (listener.gotPiece(peer, req.piece, req.bs))
+          {
+            if (Snark.debug >= Snark.DEBUG)
+              Snark.debug("Got " + req.piece + ": " + peer, Snark.DEBUG);
+          }
+        else
+          {
+            if (Snark.debug >= Snark.DEBUG)
+              Snark.debug("Got BAD " + req.piece + " from " + peer,
+                          Snark.DEBUG);
+            // XXX ARGH What now !?!
+            downloaded = 0;
+          }
+      }
+  }
+
+  synchronized private int getFirstOutstandingRequest(int piece)
+  {
+    for (int i = 0; i < outstandingRequests.size(); i++)
+      if (((Request)outstandingRequests.get(i)).piece == piece)
+        return i;
+    return -1;
+  }
+
+  /**
+   * Called when a piece message is being processed by the incoming
+   * connection. Returns null when there was no such request. It also
+   * requeues/sends requests when it thinks that they must have been
+   * lost.
+   */
+  Request getOutstandingRequest(int piece, int begin, int length)
+  {
+    if (Snark.debug >= Snark.DEBUG)
+      Snark.debug("getChunk("
+                  + piece + "," + begin + "," + length + ") "
+                  + peer, Snark.DEBUG);
+
+    int r = getFirstOutstandingRequest(piece);
+
+    // Unrequested piece number?
+    if (r == -1)
+      {
+        if (Snark.debug >= Snark.INFO)
+          Snark.debug("Unrequested 'piece: " + piece + ", "
+                      + begin + ", " + length + "' received from "
+                      + peer,
+                      Snark.INFO);
+        downloaded = 0; // XXX - punishment?
+        return null;
+      }
+
+    // Lookup the correct piece chunk request from the list.
+    Request req;
+    synchronized(this)
+      {
+        req = (Request)outstandingRequests.get(r);
+        while (req.piece == piece && req.off != begin
+               && r < outstandingRequests.size() - 1)
+          {
+            r++;
+            req = (Request)outstandingRequests.get(r);
+          }
+        
+        // Something wrong?
+        if (req.piece != piece || req.off != begin || req.len != length)
+          {
+            if (Snark.debug >= Snark.INFO)
+              Snark.debug("Unrequested or unneeded 'piece: "
+                          + piece + ", "
+                          + begin + ", "
+                          + length + "' received from "
+                          + peer,
+                          Snark.INFO);
+            downloaded = 0; // XXX - punishment?
+            return null;
+          }
+        
+        // Report missing requests.
+        if (r != 0)
+          {
+            if (Snark.debug >= Snark.INFO)
+              System.err.print("Some requests dropped, got " + req
+                               + ", wanted:");
+            for (int i = 0; i < r; i++)
+              {
+                Request dropReq = (Request)outstandingRequests.remove(0);
+                outstandingRequests.add(dropReq);
+                // We used to rerequest the missing chunks but that mostly
+                // just confuses the other side. So now we just keep
+                // waiting for them. They will be rerequested when we get
+                // choked/unchoked again.
+                /*
+                  if (!choked)
+                  out.sendRequest(dropReq);
+                */
+                if (Snark.debug >= Snark.INFO)
+                  System.err.print(" " + dropReq);
+              }
+            if (Snark.debug >= Snark.INFO)
+              System.err.println(" " + peer);
+          }
+        outstandingRequests.remove(0);
+      }
+
+    // Request more if necessary to keep the pipeline filled.
+    addRequest();
+
+    return req;
+
+  }
+
+  void cancelMessage(int piece, int begin, int length)
+  {
+    if (Snark.debug >= Snark.DEBUG)
+      Snark.debug("Got cancel message ("
+                  + piece + ", " + begin + ", " + length + ")",
+                  Snark.DEBUG);
+    out.cancelRequest(piece, begin, length);
+  }
+
+  void unknownMessage(int type, byte[] bs)
+  {
+    if (Snark.debug >= Snark.WARNING)
+      Snark.debug("Warning: Ignoring unknown message type: " + type
+                  + " length: " + bs.length, Snark.WARNING);
+  }
+
+  void havePiece(int piece)
+  {
+    if (Snark.debug >= Snark.DEBUG)
+      Snark.debug("Tell " + peer + " havePiece(" + piece + ")", Snark.DEBUG);
+
+    synchronized(this)
+      {
+        // Tell the other side that we are no longer interested in any of
+        // the outstanding requests for this piece.
+        if (lastRequest != null && lastRequest.piece == piece)
+          lastRequest = null;
+        
+        Iterator it = outstandingRequests.iterator();
+        while (it.hasNext())
+          {
+            Request req = (Request)it.next();
+            if (req.piece == piece)
+              {
+                it.remove();
+                // Send cancel even when we are choked to make sure that it is
+                // really never ever send.
+                out.sendCancel(req);
+              }
+          }
+      }
+    
+    // Tell the other side that we really have this piece.
+    out.sendHave(piece);
+    
+    // Request something else if necessary.
+    addRequest();
+    
+    synchronized(this)
+      {
+        // Is the peer still interesting?
+        if (lastRequest == null)
+          setInteresting(false);
+      }
+  }
+
+  // Starts or resumes requesting pieces.
+  private void request()
+  {
+    // Are there outstanding requests that have to be resend?
+    if (resend)
+      {
+        out.sendRequests(outstandingRequests);
+        resend = false;
+      }
+
+    // Add/Send some more requests if necessary.
+    addRequest();
+  }
+
+  /**
+   * Adds a new request to the outstanding requests list.
+   */
+  private void addRequest()
+  {
+    boolean more_pieces = true;
+    while (more_pieces)
+      {
+        synchronized(this)
+          {
+            more_pieces = outstandingRequests.size() < MAX_PIPELINE;
+          }
+        
+        // We want something and we don't have outstanding requests?
+        if (more_pieces && lastRequest == null)
+          more_pieces = requestNextPiece();
+        else if (more_pieces) // We want something
+          {
+            int pieceLength;
+            boolean isLastChunk;
+            synchronized(this)
+              {
+                pieceLength = metainfo.getPieceLength(lastRequest.piece);
+                isLastChunk = lastRequest.off + lastRequest.len == pieceLength;
+              }
+
+            // Last part of a piece?
+            if (isLastChunk)
+              more_pieces = requestNextPiece();
+            else
+              {
+                synchronized(this)
+                  {
+                    int nextPiece = lastRequest.piece;
+                    int nextBegin = lastRequest.off + PARTSIZE;
+                    byte[] bs = lastRequest.bs;
+                    int maxLength = pieceLength - nextBegin;
+                    int nextLength = maxLength > PARTSIZE ? PARTSIZE
+                                                          : maxLength;
+                    Request req
+                      = new Request(nextPiece, bs, nextBegin, nextLength);
+                    outstandingRequests.add(req);
+                    if (!choked)
+                      out.sendRequest(req);
+                    lastRequest = req;
+                  }
+              }
+          }
+      }
+
+    if (Snark.debug >= Snark.DEBUG)
+      Snark.debug(peer + " requests " + outstandingRequests, Snark.DEBUG);
+  }
+
+  // Starts requesting first chunk of next piece. Returns true if
+  // something has been added to the requests, false otherwise.
+  private boolean requestNextPiece()
+  {
+    // Check that we already know what the other side has.
+    if (bitfield != null)
+      {
+        int nextPiece = listener.wantPiece(peer, bitfield);
+        if (Snark.debug >= Snark.DEBUG)
+          Snark.debug(peer + " want piece " + nextPiece, Snark.DEBUG);
+        synchronized(this)
+          {
+            if (nextPiece != -1
+                && (lastRequest == null || lastRequest.piece != nextPiece))
+              {
+                int piece_length = metainfo.getPieceLength(nextPiece);
+                byte[] bs = new byte[piece_length];
+                
+                int length = Math.min(piece_length, PARTSIZE);
+                Request req = new Request(nextPiece, bs, 0, length);
+                outstandingRequests.add(req);
+                if (!choked)
+                  out.sendRequest(req);
+                lastRequest = req;
+                return true;
+              }
+          }
+      }
+
+    return false;
+  }
+
+  synchronized void setInteresting(boolean interest)
+  {
+    if (Snark.debug >= Snark.DEBUG)
+      Snark.debug(peer + " setInteresting(" + interest + ")", Snark.DEBUG);
+
+    if (interest != interesting)
+      {
+        interesting = interest;
+        out.sendInterest(interest);
+
+        if (interesting && !choked)
+          request();
+      }
+  }
+
+  synchronized void setChoking(boolean choke)
+  {
+    if (Snark.debug >= Snark.DEBUG)
+      Snark.debug(peer + " setChoking(" + choke + ")", Snark.DEBUG);
+
+    if (choking != choke)
+      {
+        choking = choke;
+        out.sendChoke(choke);
+      }
+  }
+}

apps/i2psnark/java/src/org/klomp/snark/Piece.java

@@ -0,0 +1,38 @@
+package org.klomp.snark;
+
+import java.util.Set;
+import java.util.HashSet;
+import java.util.Collections;
+
+public class Piece implements Comparable {
+
+    private int id;
+    private Set peers;
+    private boolean requested;
+    
+    public Piece(int id) {
+        this.id = id;
+        this.peers = Collections.synchronizedSet(new HashSet());
+        this.requested = false;
+    }
+    
+    public int compareTo(Object o) throws ClassCastException {
+        return this.peers.size() - ((Piece)o).peers.size();
+    }
+    
+    public boolean equals(Object o) {
+        if (o == null) return false;
+        try {
+            return this.id == ((Piece)o).id;
+        } catch (ClassCastException cce) {
+            return false;
+        }
+    }
+    
+    public int getId() { return this.id; }
+    public Set getPeers() { return this.peers; }
+    public boolean addPeer(Peer peer) { return this.peers.add(peer.getPeerID()); }
+    public boolean removePeer(Peer peer) { return this.peers.remove(peer.getPeerID()); }
+    public boolean isRequested() { return this.requested; }
+    public void setRequested(boolean requested) { this.requested = requested; } 
+}

apps/i2psnark/java/src/org/klomp/snark/Request.java

@@ -0,0 +1,73 @@
+/* Request - Holds all information needed for a (partial) piece request.
+   Copyright (C) 2003 Mark J. Wielaard
+
+   This file is part of Snark.
+   
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+ 
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+ 
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+*/
+
+package org.klomp.snark;
+
+/**
+ * Holds all information needed for a partial piece request.
+ */
+class Request
+{
+  final int piece;
+  final byte[] bs;
+  final int off;
+  final int len;
+
+  /**
+   * Creates a new Request.
+   *
+   * @param piece Piece number requested.
+   * @param bs byte array where response should be stored.
+   * @param off the offset in the array.
+   * @param len the number of bytes requested.
+   */
+  Request(int piece, byte[] bs, int off, int len)
+  {
+    this.piece = piece;
+    this.bs = bs;
+    this.off = off;
+    this.len = len;
+
+    // Sanity check
+    if (piece < 0 || off < 0 || len <= 0 || off + len > bs.length)
+      throw new IndexOutOfBoundsException("Illegal Request " + toString());
+  }
+
+  public int hashCode()
+  {
+    return piece ^ off ^ len;
+  }
+
+  public boolean equals(Object o)
+  {
+    if (o instanceof Request)
+      {
+        Request req = (Request)o;
+        return req.piece == piece && req.off == off && req.len == len;
+      }
+
+    return false;
+  }
+
+  public String toString()
+  {
+    return "(" + piece + "," + off + "," + len + ")";
+  }
+}