pull out no longer relevent config parameters

start the irc proxy by default within the router
dont package up the startIrcProxy script

apps/enclave/LICENSE

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,87 @@
+#
+# 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

@@ -0,0 +1,87 @@
+#
+# 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

@@ -0,0 +1,87 @@
+#
+# 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

@@ -0,0 +1,32 @@
+#
+# 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

@@ -0,0 +1,2 @@
+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

@@ -0,0 +1,27 @@
+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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,56 @@
+/*
+ * 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/heartbeat/doc/readme.gui.txt

@@ -0,0 +1,39 @@
+The Heartbeat GUI loads up the stat files generated by the Heartbeat
+engine and renders them visually, offering a way to drill through different
+data points and take snapshots as things change (by saving particular stat
+files for later).  The GUI itself doesn't need to be on the same machine
+as the Heartbeat engine - it pulls the stat files through any URL - even 
+through the EepProxy.
+
+An example Heartbeat GUI config file follows
+
+    # how often do we want to pull new data to render
+    refreshFrequency=60
+    ## for each peer test we may want to include in the GUI:
+    # where to find the current stat file (URL or filename)
+    stat.0.location=http://dev.i2p.net/stats/heartbeatStat_khWY_30s_1kb.txt
+    ## optional entries for each peer test describing what we want shown
+    ## (and how we want it shown)
+    # do we want to plot the send time (from when the ping was sent until the pong server got it)?
+    stat.0.plot.current.send=true
+    # do we want to plot the receive time (from when the pong was sent until reception)?
+    stat.0.plot.current.receive=true
+    # do we want to plot the lost messages?
+    stat.0.plot.current.lost=true
+    # what color should the current lines be rendered in?
+    stat.0.plot.current.color=BLUE
+    ## optional entries for each peer test describing what averages we want
+    ## rendered
+    # plot 1 minute send average?
+    stat.0.plot.1m.send=true
+    # plot 1 minute receive average?
+    stat.0.plot.1m.receive=true
+    # plot 1 minute lost message average?
+    stat.0.plot.1m.lost=true
+    # what color should the 1 minute averages be rendered as?
+    stat.0.plot.1m.color=GREEN
+    ## repeated for all of the averaged periods, e.g. 
+    ## stat.0.plot.30m, .60m, 1440m (1 day)
+    
+There may be some other options, such as where to store snapshot files, whether
+to generate PNG images, etc.

apps/heartbeat/doc/readme.txt

@@ -0,0 +1,122 @@
+Heartbeat
+
+Application layer tool for monitoring the long term health of the
+network by periodically testing peers, generating stats, and
+rendering them visually.  The engine (both server and client) should
+work headless and seperate from the GUI, exposing the data in a simple
+to parse (and human readable) text file for each peer being tested.  
+The GUI then periodically refreshes itself by loading those files (
+either locally or from a URL) and renders the current state accordingly, 
+giving users a way to check that the network is alive, devs a tool to 
+both monitor the state of the network and to debug different situations (by 
+accessing the stat file - either live or archived).
+
+The heartbeat configuration file is organized as a standard properties
+file (by default located at heartbeat.config, but that can be overridden by 
+passing a filename as the first argument to the Heartbeat command):
+
+    # where the router is located (default is localhost)
+    i2cpHost=localhost
+    # I2CP port for the router (default is 7654)
+    i2cpPort=4001
+    # How many hops we want the router to put in our tunnels (default is 2)
+    numHops=2
+    # where our private destination keys are located - if this doesn't exist,
+    # a new one will be created and saved there (by default, heartbeat.keys)
+    privateDestinationFile=heartbeat_r2.keys
+
+    ## peer tests configured below:
+    
+    # destination peer for test 0
+    peer.0.peer=[destination in base64]
+    # where will we write out the stat data?
+    peer.0.statFile=heartbeatStat_khWY_30s_1kb.txt
+    # how many minutes will we keep stats for?
+    peer.0.statDuration=30
+    # how often will we write out new stat data (in seconds)?
+    peer.0.statFrequency=60
+    # how often will we send a ping to the peer (in seconds)?
+    peer.0.sendFrequency=30
+    # how many bytes will be included in the ping?
+    peer.0.sendSize=1024
+    # take a guess...
+    peer.0.comment=Test with localhost sending 1KB of data every 30 seconds
+    # we can keep track of a few moving averages - this value includes a whitespace
+    # delimited list of numbers, each specifying a period to calculate the average
+    # over (in minutes)
+    peer.0.averagePeriods=1 5 30
+    ## repeat the peer.0.* for as many tests as desired, incrementing as necessary
+
+If there are no peer.* lines, it will simply run a pong server.  If any data is
+missing, it will use the defaults (though there are no defaults for peer.* lines) -
+running the Heartbeat app with no heartbeat configuration file whatsoever will create
+a new pong server (storing its keys at heartbeat.keys) and using the I2P router at 
+localhost:7654.
+
+The stat file generated for each set of peer.n.* lines contains the current state
+of the test, its averages, as well as any other interesting data points.  An example
+stat file follows (hopefully it is self explanatory):
+
+    peer            khWYqCETu9YtPUvGV92ocsbEW5DezhKlIG7ci8RLX3g=
+    local           u-9hlR1ik2hemXf0HvKMfeRgrS86CbNQh25e7XBhaQE=
+    peerDest        [base 64 of the full destination]
+    localDest       [base 64 of the full destination]
+    numTunnelHops   2
+    comment         Test with localhost sending 30KB every 20 seconds
+    sendFrequency   20
+    sendSize        30720
+    sessionStart    20040409.22:51:10.915
+    currentTime     20040409.23:31:39.607
+    numPending      2
+    lifetimeSent    118
+    lifetimeRecv    113
+    #averages       minutes sendMs  recvMs  numLost
+    periodAverage   1       1843    771     0
+    periodAverage   5       786     752     1
+    periodAverage   30      855     735     3
+    #action status  date and time sent      sendMs  replyMs
+    EVENT   OK      20040409.23:21:44.742   691     670
+    EVENT   OK      20040409.23:22:05.201   671     581
+    EVENT   OK      20040409.23:22:26.301   1182    1452
+    EVENT   OK      20040409.23:22:47.322   24304   1723
+    EVENT   OK      20040409.23:23:08.232   2293    1081
+    EVENT   OK      20040409.23:23:29.332   1392    641
+    EVENT   OK      20040409.23:23:50.262   641     761
+    EVENT   OK      20040409.23:24:11.102   651     701
+    EVENT   OK      20040409.23:24:31.401   841     621
+    EVENT   OK      20040409.23:24:52.061   651     681
+    EVENT   OK      20040409.23:25:12.480   701     1623
+    EVENT   OK      20040409.23:25:32.990   1442    1212
+    EVENT   OK      20040409.23:25:54.230   591     631
+    EVENT   OK      20040409.23:26:14.620   620     691
+    EVENT   OK      20040409.23:26:35.199   1793    1432
+    EVENT   OK      20040409.23:26:56.570   661     641
+    EVENT   OK      20040409.23:27:17.200   641     660
+    EVENT   OK      20040409.23:27:38.120   611     921
+    EVENT   OK      20040409.23:27:58.699   831     621
+    EVENT   OK      20040409.23:28:19.559   801     661
+    EVENT   OK      20040409.23:28:40.279   601     611
+    EVENT   OK      20040409.23:29:00.648   601     621
+    EVENT   OK      20040409.23:29:21.288   701     661
+    EVENT   LOST    20040409.23:29:41.828
+    EVENT   LOST    20040409.23:30:02.327
+    EVENT   LOST    20040409.23:30:22.656
+    EVENT   OK      20040409.23:31:24.305   1843    771
+
+The actual ping and pong messages sent are formatted trivially -
+ping messages contain
+    $from $series $type $sentOn $size $payload
+while pong messages contain
+    $from $series $type $sentOn $receivedOn $size $payload
+
+$series is a number describing the sending client's test (so that you can
+ping the same peer with different configurations concurrently, varying things
+like the frequency and size of the message, window, etc).
+
+They are sent as raw binary messages though, so see I2PAdapter.sendPing(..)
+and I2PAdapter.sendPong(..) for the details.
+
+To get valid measurements, of course, you will want to make sure that 
+both the heartbeat client and pong server have synchronized clocks (even
+more so than I2P requires).  It is highly recommended that only NTP 
+synchronized peers be used for heartbeat tests.

apps/heartbeat/java/build.xml

@@ -0,0 +1,66 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project basedir="." default="all" name="heartbeat">
+    <target name="all" depends="clean, buildGUI" />
+    <target name="build" depends="builddep, jar" />
+    <target name="buildGUI" depends="build, jarGUI" />
+    <target name="builddep">
+        <ant dir="../../../core/java/" target="build" />
+    </target>
+    <target name="compile">
+        <mkdir dir="./build" />
+        <mkdir dir="./build/obj" />
+        <javac srcdir="./src" debug="true" 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" 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" />
+            <classpath path="../../jfreechart/jfreechart-0.9.17/lib/log4j-1.2.8.jar" />
+            <classpath path="../../jfreechart/jfreechart-0.9.17/jfreechart-0.9.17.jar" />
+        </javac>
+    </target>
+    <target name="jar" depends="compile">
+        <jar destfile="./build/heartbeat.jar" basedir="./build/obj" includes="**/*.class">
+            <manifest>
+                <attribute name="Main-Class" value="net.i2p.heartbeat.Heartbeat" />
+                <attribute name="Class-Path" value="i2p.jar heartbeat.jar" />
+            </manifest>
+        </jar>
+    </target>
+    <target name="jarGUI" depends="compileGUI">
+        <copy file="../../jfreechart/jfreechart-0.9.17/jfreechart-0.9.17.jar" todir="build/" />
+        <copy file="../../jfreechart/jfreechart-0.9.17/lib/log4j-1.2.8.jar" todir="build/" />
+        <copy file="../../jfreechart/jfreechart-0.9.17/lib/jcommon-0.9.2.jar" todir="build/" />
+        <jar destfile="./build/heartbeatGUI.jar" basedir="./build/obj" includes="**">
+            <manifest>
+                <attribute name="Main-Class" value="net.i2p.heartbeat.gui.HeartbeatMonitor" />
+                <attribute name="Class-Path" value="log4j-1.2.8.jar jcommon-0.9.2.jar jfreechart-0.9.17.jar heartbeatGUI.jar i2p.jar" />
+            </manifest>
+        </jar>
+        <echo message="You will need to copy the log4j, jcommon, and jfreechart jar files into your lib dir" />
+    </target>
+    <target name="javadoc">
+        <mkdir dir="./build" />
+        <mkdir dir="./build/javadoc" />
+        <javadoc 
+            sourcepath="./src:../../../core/java/src:../../../core/java/test" destdir="./build/javadoc" 
+            packagenames="*" 
+            use="true" 
+            access="package"
+            splitindex="true" 
+            windowtitle="I2P heartbeat monitor" />
+    </target>
+    <target name="clean">
+        <delete dir="./build" />
+    </target>
+    <target name="cleandep" depends="clean">
+        <ant dir="../../../core/java/" target="cleandep" />
+        <ant dir="../../../core/java/" target="cleandep" />
+    </target>
+    <target name="distclean" depends="clean">
+        <ant dir="../../../core/java/" target="distclean" />
+    </target>
+</project>

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

@@ -0,0 +1,468 @@
+package net.i2p.heartbeat;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Properties;
+import java.util.StringTokenizer;
+
+import net.i2p.data.DataFormatException;
+import net.i2p.data.Destination;
+import net.i2p.util.Log;
+
+/**
+ * Define the configuration for testing against one particular peer as a client
+ */
+public class ClientConfig {
+    private static final Log _log = new Log(ClientConfig.class);
+    private Destination _peer;
+    private Destination _us;
+    private String _statFile;
+    private int _statDuration;
+    private int _statFrequency;
+    private int _sendFrequency;
+    private int _sendSize;
+    private int _numHops;
+    private String _comment;
+    private int _averagePeriods[];
+
+    /**
+     * @seeRoutine ClientConfig#load
+     * @seeRoutine ClientConfig#store
+     */
+    public static final String PROP_PREFIX = "peer.";
+
+    /**
+     * @seeRoutine ClientConfig#load
+     * @seeRoutine ClientConfig#store
+     */
+    public static final String PROP_PEER = ".peer";
+
+    /**
+     * @seeRoutine ClientConfig#load
+     * @seeRoutine ClientConfig#store
+     */
+    public static final String PROP_STATFILE = ".statFile";
+
+    /**
+     * @seeRoutine ClientConfig#load
+     * @seeRoutine ClientConfig#store
+     */
+    public static final String PROP_STATDURATION = ".statDuration";
+
+    /**
+     * @seeRoutine ClientConfig#load
+     * @seeRoutine ClientConfig#store
+     */
+    public static final String PROP_STATFREQUENCY = ".statFrequency";
+
+    /**
+     * @seeRoutine ClientConfig#load
+     * @seeRoutine ClientConfig#store
+     */
+    public static final String PROP_SENDFREQUENCY = ".sendFrequency";
+
+    /**
+     * @seeRoutine ClientConfig#load
+     * @seeRoutine ClientConfig#store
+     */
+    public static final String PROP_SENDSIZE = ".sendSize";
+
+    /**
+     * @seeRoutine ClientConfig#load
+     * @seeRoutine ClientConfig#store
+     */
+    public static final String PROP_COMMENT = ".comment";
+
+    /**
+     * @seeRoutine ClientConfig#load
+     * @seeRoutine ClientConfig#store
+     */
+    public static final String PROP_AVERAGEPERIODS = ".averagePeriods";
+
+    /**
+     * Default constructor...
+     */
+    public ClientConfig() {
+        this(null, null, null, -1, -1, -1, -1, 0, null, null);
+    }
+    
+    /**
+     * Create a dummy client config to be fetched from the specified location
+     * @param location the location to fetch from
+     */
+    public ClientConfig(String location) {
+        this(null, null, location, -1, -1, -1, -1, 0, null, null);
+    }
+
+    /**
+     * @param peer who we will test against
+     * @param us who we are
+     * @param statLocation where the stat data should be stored/fetched
+     * @param duration how many minutes to keep events for
+     * @param statFreq how often to write out stats
+     * @param sendFreq how often to send pings
+     * @param sendSize how large the pings should be
+     * @param numHops how many hops is the current Heartbeat app using
+     * @param comment describe this test
+     * @param averagePeriods list of minutes to summarize over
+     */
+    public ClientConfig(Destination peer, Destination us, String statLocation, int duration, int statFreq, int sendFreq,
+                        int sendSize, int numHops, String comment, int averagePeriods[]) {
+        _peer = peer;
+        _us = us;
+        _statFile = statLocation;
+        _statDuration = duration;
+        _statFrequency = statFreq;
+        _sendFrequency = sendFreq;
+        _sendSize = sendSize;
+        _numHops = numHops;
+        _comment = comment;
+        _averagePeriods = averagePeriods;
+    }
+
+    /**
+     * Retrieves the peer to test against
+     * 
+     * @return the Destination (peer)
+     */
+    public Destination getPeer() {
+        return _peer;
+    }
+
+    /**
+     * Sets the peer to test against
+     * 
+     * @param peer the Destination (peer)
+     */
+    public void setPeer(Destination peer) {
+        _peer = peer;
+    }
+
+    /**
+     * Retrieves who we are when we test
+     * 
+     * @return the Destination (us)
+     */
+    public Destination getUs() {
+        return _us;
+    }
+
+    /**
+     * Sets who we are when we test
+     * 
+     * @param us the Destination (us)
+     */
+    public void setUs(Destination us) {
+        _us = us;
+    }
+
+    /**
+     * Retrieves the location to write the current stats to
+     * 
+     * @return the name of the file
+     */
+    public String getStatFile() {
+        return _statFile;
+    }
+
+    /**
+     * Sets the name of the location we write the current stats to
+     * 
+     * @param statFile the name of the file
+     */
+    public void setStatFile(String statFile) {
+        _statFile = statFile;
+    }
+
+    /**
+     * Retrieves how many minutes of statistics should be maintained within the window for this client
+     * 
+     * @return the number of minutes
+     */
+    public int getStatDuration() {
+        return _statDuration;
+    }
+
+    /**
+     * Sets how many minutes of statistics should be maintained within the window for this client
+     * 
+     * @param durationMinutes the number of minutes
+     */
+    public void setStatDuration(int durationMinutes) {
+        _statDuration = durationMinutes;
+    }
+
+    /**
+     * Retrieves how frequently the stats are written out (in seconds)
+     * 
+     * @return the frequency in seconds
+     */
+    public int getStatFrequency() {
+        return _statFrequency;
+    }
+
+    /**
+     * Sets how frequently the stats are written out (in seconds)
+     * 
+     * @param freqSeconds the frequency in seconds
+     */
+    public void setStatFrequency(int freqSeconds) {
+        _statFrequency = freqSeconds;
+    }
+
+    /**
+     * Retrieves how frequenty we send messages to the peer (in seconds)
+     * 
+     * @return the frequency in seconds
+     */
+    public int getSendFrequency() {
+        return _sendFrequency;
+    }
+
+    /**
+     * Sets how frequenty we send messages to the peer (in seconds)
+     * 
+     * @param freqSeconds the frequency in seconds
+     */
+    public void setSendFrequency(int freqSeconds) {
+        _sendFrequency = freqSeconds;
+    }
+
+    /**
+     * Retrieves how many bytes the ping messages should be (min values ~700, max ~32KB)
+     * 
+     * @return the size in bytes
+     */
+    public int getSendSize() {
+        return _sendSize;
+    }
+
+    /**
+     * Sets how many bytes the ping messages should be (min values ~700, max ~32KB)
+     * 
+     * @param numBytes the size in bytes
+     */
+    public void setSendSize(int numBytes) {
+        _sendSize = numBytes;
+    }
+
+    /**
+     * Retrieves the brief, 1 line description of the test. Useful comments are along the lines of "The peer is located on a fast router and connection with 2
+     * hop tunnels".
+     * 
+     * @return the brief comment
+     */
+    public String getComment() {
+        return _comment;
+    }
+
+    /**
+     * Sets a brief, 1 line description (comment) of the test.
+     * 
+     * @param comment the brief comment
+     */
+    public void setComment(String comment) {
+        _comment = comment;
+    }
+
+    /**
+     * Retrieves the periods that the client's tests should be averaged over.
+     * 
+     * @return list of periods (in minutes) that the data should be averaged over, or null
+     */
+    public int[] getAveragePeriods() {
+        return _averagePeriods;
+    }
+
+    /**
+     * Sets the periods that the client's tests should be averaged over.
+     * 
+     * @param periods the list of periods (in minutes) that the data should be averaged over, or null
+     */
+    public void setAveragePeriods(int periods[]) {
+        _averagePeriods = periods;
+    }
+    
+    /**
+     * Make sure we're keeping track of the average over the given time period.
+     *
+     * @param minutes how many minutes to monitor
+     */
+    public void addAveragePeriod(int minutes) {
+        if (_averagePeriods != null) {
+            for (int i = 0; i < _averagePeriods.length; i++) {
+                if (_averagePeriods[i] == minutes)
+                    return;
+            }
+        }
+        
+        int numPeriods = 1;
+        if (_averagePeriods != null)
+            numPeriods += _averagePeriods.length;
+        int periods[] = new int[numPeriods];
+        if (_averagePeriods != null)
+            System.arraycopy(_averagePeriods, 0, periods, 0, _averagePeriods.length);
+        periods[periods.length-1] = minutes;
+        Arrays.sort(periods);
+        _averagePeriods = periods;
+    }
+
+    /**
+     * Retrieves how many hops this test engine is configured to use for its outbound and inbound tunnels
+     * 
+     * @return the number of hops
+     */
+    public int getNumHops() {
+        return _numHops;
+    }
+
+    /**
+     * Sets how many hops this test engine is configured to use for its outbound and inbound tunnels
+     * 
+     * @param numHops the number of hops
+     */
+    public void setNumHops(int numHops) {
+        _numHops = numHops;
+    }
+
+    /**
+     * Load the client config from the properties specified, deriving the current config entry from the peer number.
+     * 
+     * @param clientConfig the properties to load from
+     * @param peerNum the number associated with the peer
+     * @return true if it was loaded correctly, false if there were errors
+     */
+    public boolean load(Properties clientConfig, int peerNum) {
+        if ((clientConfig == null) || (peerNum < 0)) return false;
+        String peerVal = clientConfig.getProperty(PROP_PREFIX + peerNum + PROP_PEER);
+        String statFileVal = clientConfig.getProperty(PROP_PREFIX + peerNum + PROP_STATFILE);
+        String statDurationVal = clientConfig.getProperty(PROP_PREFIX + peerNum + PROP_STATDURATION);
+        String statFrequencyVal = clientConfig.getProperty(PROP_PREFIX + peerNum + PROP_STATFREQUENCY);
+        String sendFrequencyVal = clientConfig.getProperty(PROP_PREFIX + peerNum + PROP_SENDFREQUENCY);
+        String sendSizeVal = clientConfig.getProperty(PROP_PREFIX + peerNum + PROP_SENDSIZE);
+        String commentVal = clientConfig.getProperty(PROP_PREFIX + peerNum + PROP_COMMENT);
+        String periodsVal = clientConfig.getProperty(PROP_PREFIX + peerNum + PROP_AVERAGEPERIODS);
+
+        if ((peerVal == null) || (statFileVal == null) || (statDurationVal == null) || (statFrequencyVal == null)
+            || (sendFrequencyVal == null) || (sendSizeVal == null)) {
+            if (_log.shouldLog(Log.DEBUG)) {
+                _log.debug("Peer number " + peerNum + " does not exist");
+            }
+            return false;
+        }
+
+        try {
+            int duration = getInt(statDurationVal);
+            int statFreq = getInt(statFrequencyVal);
+            int sendFreq = getInt(sendFrequencyVal);
+            int sendSize = getInt(sendSizeVal);
+
+            if ((duration <= 0) || (statFreq <= 0) || (sendFreq < 0) || (sendSize <= 0)) {
+                if (_log.shouldLog(Log.WARN)) {
+                    _log.warn("Invalid client config: duration [" + statDurationVal + "] stat frequency ["
+                              + statFrequencyVal + "] send frequency [" + sendFrequencyVal + "] send size ["
+                              + sendSizeVal + "]");
+                }
+                return false;
+            }
+
+            statFileVal = statFileVal.trim();
+            if (statFileVal.length() <= 0) {
+                if (_log.shouldLog(Log.WARN)) {
+                    _log.warn("Stat file is blank for peer " + peerNum);
+                }
+                return false;
+            }
+
+            Destination d = new Destination();
+            d.fromBase64(peerVal);
+
+            if (commentVal == null) {
+                commentVal = "";
+            }
+
+            commentVal = commentVal.trim();
+            commentVal = commentVal.replace('\n', '_');
+
+            List periods = new ArrayList(4);
+            if (periodsVal != null) {
+                StringTokenizer tok = new StringTokenizer(periodsVal);
+                while (tok.hasMoreTokens()) {
+                    String periodVal = tok.nextToken();
+                    int minutes = getInt(periodVal);
+                    if (minutes > 0) {
+                        periods.add(new Integer(minutes));
+                    }
+                }
+            }
+            int avgPeriods[] = new int[periods.size()];
+            for (int i = 0; i < periods.size(); i++) {
+                avgPeriods[i] = ((Integer) periods.get(i)).intValue();
+            }
+
+            _comment = commentVal;
+            _statDuration = duration;
+            _statFrequency = statFreq;
+            _sendFrequency = sendFreq;
+            _sendSize = sendSize;
+            _statFile = statFileVal;
+            _peer = d;
+            _averagePeriods = avgPeriods;
+            return true;
+        } catch (DataFormatException dfe) {
+            _log.error("Peer destination for " + peerNum + " was invalid: " + peerVal);
+            return false;
+        }
+    }
+
+    /**
+     * Store the client config to the properties specified, deriving the current config entry from the peer number.
+     * 
+     * @param clientConfig the properties to store to
+     * @param peerNum the number associated with the peer
+     * @return true if it was stored correctly, false if there were errors
+     */
+    public boolean store(Properties clientConfig, int peerNum) {
+        if ((_peer == null) || (_sendFrequency < 0) || (_sendSize <= 0) || (_statDuration <= 0)
+            || (_statFrequency <= 0) || (_statFile == null)) { return false; }
+
+        String comment = _comment;
+        if (comment == null) {
+            comment = "";
+        }
+
+        comment = comment.trim();
+        comment = comment.replace('\n', '_');
+
+        StringBuffer buf = new StringBuffer(32);
+        if (_averagePeriods != null) {
+            for (int i = 0; i < _averagePeriods.length; i++) {
+                buf.append(_averagePeriods[i]).append(' ');
+            }
+        }
+
+        clientConfig.setProperty(PROP_PREFIX + peerNum + PROP_PEER, _peer.toBase64());
+        clientConfig.setProperty(PROP_PREFIX + peerNum + PROP_STATFILE, _statFile);
+        clientConfig.setProperty(PROP_PREFIX + peerNum + PROP_STATDURATION, _statDuration + "");
+        clientConfig.setProperty(PROP_PREFIX + peerNum + PROP_STATFREQUENCY, _statFrequency + "");
+        clientConfig.setProperty(PROP_PREFIX + peerNum + PROP_SENDFREQUENCY, _sendFrequency + "");
+        clientConfig.setProperty(PROP_PREFIX + peerNum + PROP_SENDSIZE, _sendSize + "");
+        clientConfig.setProperty(PROP_PREFIX + peerNum + PROP_COMMENT, comment);
+        clientConfig.setProperty(PROP_PREFIX + peerNum + PROP_AVERAGEPERIODS, buf.toString());
+        return true;
+    }
+
+    private static final int getInt(String val) {
+        if (val == null) return -1;
+        try {
+            int i = Integer.parseInt(val);
+            return i;
+        } catch (NumberFormatException nfe) {
+            if (_log.shouldLog(Log.DEBUG)) {
+                _log.debug("Value [" + val + "] is not a valid integer");
+            }
+            return -1;
+        }
+    }
+}

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

@@ -0,0 +1,133 @@
+package net.i2p.heartbeat;
+
+import net.i2p.data.Destination;
+import net.i2p.util.Clock;
+import net.i2p.util.I2PThread;
+import net.i2p.util.Log;
+
+/**
+ * Responsible for actually conducting the tests, coordinating the storing of the 
+ * stats, and the management of the rates.  This has its own thread specific for
+ * pumping data around as well.
+ *
+ */
+class ClientEngine {
+    private static final Log _log = new Log(ClientEngine.class);
+    /** who can send our pings? */
+    private Heartbeat _heartbeat;
+    /** actual test state */
+    private PeerData _data;
+    /** have we been stopped? */
+    private boolean _active;
+    /** used to generate engine IDs */
+    private static int __id = 0;
+    /** this engine's id, unique to the {test,sendingClient,startTime} */
+    private int _id;
+    private static PeerDataWriter writer = new PeerDataWriter();
+
+    /**
+     * Create a new engine that will send its pings through the given heartbeat
+     * system, and will coordinate the test according to the configuration specified.
+     * @param heartbeat the Heartbeat to send pings through
+     * @param config the Configuration to load configuration from =p
+     */
+    public ClientEngine(Heartbeat heartbeat, ClientConfig config) {
+        _heartbeat = heartbeat;
+        _data = new PeerData(config);
+        _active = false;
+        _id = ++__id;
+    }
+
+    /** stop sending any more pings or writing any more state */
+    public void stopEngine() {
+        _active = false;
+        if (_log.shouldLog(Log.INFO))
+            _log.info("Stopping engine talking to peer " + _data.getConfig().getPeer().calculateHash().toBase64());
+    }
+
+    /** start up the test (this does not block, as it fires up the test thread) */
+    public void startEngine() {
+        _active = true;
+        I2PThread t = new I2PThread(new ClientRunner());
+        t.setName("HeartbeatClient " + _id);
+        t.start();
+    }
+
+    /**
+     * Who are we testing? 
+     * @return the Destination (peer) we're testing
+     */
+    public Destination getPeer() {
+        return _data.getConfig().getPeer();
+    }
+
+    /**
+     * What is our series identifier (used to locally identify a test) 
+     * @return the series identifier
+     */
+    public int getSeriesNum() {
+        return _id;
+    }
+
+    /** 
+     * receive notification from the heartbeat system that a pong was received in 
+     * reply to a ping we have sent.  
+     *
+     * @param sentOn when did we send the ping?
+     * @param replyOn when did the peer send the pong?
+     */
+    public void receivePong(long sentOn, long replyOn) {
+        _data.pongReceived(sentOn, replyOn);
+    }
+
+    /** fire off a new ping */
+    private void doSend() {
+        long now = Clock.getInstance().now();
+        _data.addPing(now);
+        _heartbeat.sendPing(_data.getConfig().getPeer(), _id, now, _data.getConfig().getSendSize());
+    }
+
+    /** our actual heartbeat pumper - this drives the test */
+    private class ClientRunner implements Runnable {
+
+        /**
+         * @see java.lang.Runnable#run()
+         */
+        public void run() {
+            if (_log.shouldLog(Log.INFO))
+                _log.info("Starting engine talking to peer " + _data.getConfig().getPeer().calculateHash().toBase64());
+
+            // when do we need to send the next PING?
+            long nextSend = Clock.getInstance().now();
+            // when do we need to write out the next state data?
+            long nextWrite = Clock.getInstance().now();
+
+            while (_active) {
+
+                if (Clock.getInstance().now() >= nextSend) {
+                    doSend();
+                    nextSend = Clock.getInstance().now() + _data.getConfig().getSendFrequency() * 1000;
+                }
+
+                if (Clock.getInstance().now() >= nextWrite) {
+                    boolean written = writer.persist(_data);
+                    if (!written) {
+                        if (_log.shouldLog(Log.ERROR)) _log.error("Unable to write the client state data");
+                    } else {
+                        if (_log.shouldLog(Log.DEBUG)) _log.debug("Client state data written");
+                    }
+                }
+
+                _data.cleanup();
+
+                long timeToWait = nextSend - Clock.getInstance().now();
+                if (timeToWait > 0) {
+                    try {
+                        Thread.sleep(timeToWait);
+                    } catch (InterruptedException ie) {
+                    }
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,254 @@
+package net.i2p.heartbeat;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Properties;
+
+import net.i2p.data.Destination;
+import net.i2p.util.Log;
+
+/**
+ * Main driver for the heartbeat engine, loading 0 or more tests, firing
+ * up a ClientEngine for each, and serving as a pong server.  If there isn't
+ * a configuration file, or if the configuration file doesn't specify any tests,
+ * it simply sits around as a pong server, passively responding to whatever is 
+ * sent its way.  <p />
+ *
+ * The config file format is examplified below:
+ * <pre>
+ *    # where the router is located (default is localhost)
+ *    i2cpHost=localhost
+ *    # I2CP port for the router (default is 7654)
+ *    i2cpPort=4001
+ *    # How many hops we want the router to put in our tunnels (default is 2)
+ *    numHops=2
+ *    # where our private destination keys are located - if this doesn't exist,
+ *    # a new one will be created and saved there (by default, heartbeat.keys)
+ *    privateDestinationFile=heartbeat_r2.keys
+ *    # where do we want to export the plain base64 of our destination?
+ *    publicDestinationFile=heartbeat_r2.txt
+ *
+ *    ## peer tests configured below:
+ *    
+ *    # destination peer for test 0
+ *    peer.0.peer=[destination in base64]
+ *    # where will we write out the stat data?
+ *    peer.0.statFile=heartbeatStat_khWY_30s_1kb.txt
+ *    # how many minutes will we keep stats for?
+ *    peer.0.statDuration=30
+ *    # how often will we write out new stat data (in seconds)?
+ *    peer.0.statFrequency=60
+ *    # how often will we send a ping to the peer (in seconds)?
+ *    peer.0.sendFrequency=30
+ *    # how many bytes will be included in the ping?
+ *    peer.0.sendSize=1024
+ *    # take a guess...
+ *    peer.0.comment=Test with localhost sending 1KB of data every 30 seconds
+ *    # we can keep track of a few moving averages - this value includes a whitespace
+ *    # delimited list of numbers, each specifying a period to calculate the average
+ *    # over (in minutes)
+ *    peer.0.averagePeriods=1 5 30
+ *    ## repeat the peer.0.* for as many tests as desired, incrementing as necessary
+ * </pre>
+ *
+ */
+public class Heartbeat {
+    private static final Log _log = new Log(Heartbeat.class);
+    /** location containing this heartbeat's config */
+    private String _configFile;
+    /** clientNum (Integer) to ClientConfig mapping */
+    private Map _clientConfigs;
+    /** series num (Integer) to ClientEngine mapping */
+    private Map _clientEngines;
+    /** helper class for managing our I2P send/receive and message formatting */
+    private I2PAdapter _adapter;
+    /** our own callback that the I2PAdapter notifies on ping or pong messages */
+    private PingPongAdapter _eventAdapter;
+
+    /** if there are no command line arguments, load the config from "heartbeat.config" */
+    public static final String CONFIG_FILE_DEFAULT = "heartbeat.config";
+
+    /**
+     * build up a new heartbeat manager, but don't actually do anything
+     * @param configFile the name of the configuration file
+     */
+    public Heartbeat(String configFile) {
+        _configFile = configFile;
+        _clientConfigs = new HashMap();
+        _clientEngines = new HashMap();
+        _eventAdapter = new PingPongAdapter();
+        _adapter = new I2PAdapter();
+        _adapter.setListener(_eventAdapter);
+    }
+
+    private Heartbeat() {
+    }
+
+    /** load up the config data (but don't build any engines or start them up) */
+    public void loadConfig() {
+        Properties props = new Properties();
+        FileInputStream fin = null;
+        File configFile = new File(_configFile);
+        if (configFile.exists()) {
+            try {
+                fin = new FileInputStream(_configFile);
+                props.load(fin);
+            } catch (IOException ioe) {
+                if (_log.shouldLog(Log.ERROR)) {
+                    _log.error("Error reading the config data", ioe);
+                }
+            } finally {
+                if (fin != null) try {
+                    fin.close();
+                } catch (IOException ioe) {
+                }
+            }
+        }
+
+        loadBaseConfig(props);
+        loadClientConfigs(props);
+    }
+
+    /** 
+     * send a ping message to the peer
+     *
+     * @param peer peer to ping
+     * @param seriesNum id used to keep track of multiple pings (of different size/frequency) to a peer
+     * @param now current time to be sent in the ping (so we can watch for it in the pong)
+     * @param size total message size to send
+     */
+    void sendPing(Destination peer, int seriesNum, long now, int size) {
+        if (_adapter.getIsConnected()) _adapter.sendPing(peer, seriesNum, now, size);
+    }
+
+    /**
+     * load up the base data (I2CP config, etc)
+     * @param props the properties to load from 
+     */
+    private void loadBaseConfig(Properties props) {
+        _adapter.loadConfig(props);
+    }
+
+    /** 
+     * load up all of the test config data 
+     * @param props the properties to load from
+     * */
+    private void loadClientConfigs(Properties props) {
+        int i = 0;
+        while (true) {
+            ClientConfig config = new ClientConfig();
+            if (!config.load(props, i)) {
+                break;
+            }
+            _clientConfigs.put(new Integer(i), config);
+            i++;
+        }
+    }
+
+    /** connect to the network */
+    private void connect() {
+        boolean connected = _adapter.connect();
+        if (!connected) _log.error("Unable to connect to the router");
+    }
+
+    /** disconnect from the network */
+    private void disconnect() { /* UNUSED */
+        _adapter.disconnect();
+    }
+
+    /** start up all of the tests */
+    public void startEngines() {
+        for (Iterator iter = _clientConfigs.values().iterator(); iter.hasNext();) {
+            ClientConfig config = (ClientConfig) iter.next();
+            ClientEngine engine = new ClientEngine(this, config);
+            config.setUs(_adapter.getLocalDestination());
+            config.setNumHops(_adapter.getNumHops());
+            _clientEngines.put(new Integer(engine.getSeriesNum()), engine);
+            engine.startEngine();
+        }
+    }
+
+    /** stop all of the tests */
+    public void stopEngines() {
+        for (Iterator iter = _clientEngines.values().iterator(); iter.hasNext();) {
+            ClientEngine engine = (ClientEngine) iter.next();
+            engine.stopEngine();
+        }
+        _clientEngines.clear();
+    }
+
+    /**
+     * Fire up a new heartbeat system, waiting until, well, forever.  Builds
+     * a new heartbeat system, loads the config, connects to the network, starts
+     * the engines, and then sits back and relaxes, responding to any pings and
+     * running any tests. <p />
+     *
+     * <code> <b>Usage: </b> Heartbeat [<i>configFileName</i>]</code> <p />
+     * @param args the list of args passed to the program from the command-line
+     */
+    public static void main(String args[]) {
+        String configFile = CONFIG_FILE_DEFAULT;
+        if (args.length == 1) {
+            configFile = args[0];
+        }
+
+        if (_log.shouldLog(Log.INFO)) {
+            _log.info("Starting up with config file " + configFile);
+        }
+        Heartbeat heartbeat = new Heartbeat(configFile);
+        heartbeat.loadConfig();
+        heartbeat.connect();
+        heartbeat.startEngines();
+        Object o = new Object();
+        while (true) {
+            try {
+                synchronized (o) {
+                    o.wait();
+                }
+            } catch (InterruptedException ie) {
+            }
+        }
+    }
+
+    /**
+     * Receive event notification from the I2PAdapter
+     *
+     */
+    private class PingPongAdapter implements I2PAdapter.PingPongEventListener {
+        /**
+         * We were pinged, so always just send a pong back.
+         * 
+         * @param from who sent us the ping?
+         * @param seriesNum what series did the sender specify?
+         * @param sentOn when did the sender say they sent their ping?
+         * @param data arbitrary payload data
+         */
+        public void receivePing(Destination from, int seriesNum, Date sentOn, byte[] data) {
+            if (_adapter.getIsConnected()) {
+                _adapter.sendPong(from, seriesNum, sentOn, data);
+            }
+        }
+
+        /**
+         * We received a pong, so find the right client engine and tell it about the pong.
+         *
+         * @param from who sent us the pong
+         * @param seriesNum our client ID
+         * @param sentOn when did we send the ping?
+         * @param replyOn when did they send their pong?
+         * @param data the arbitrary data we sent in the ping (that they sent back in the pong)
+         */
+        public void receivePong(Destination from, int seriesNum, Date sentOn, Date replyOn, byte[] data) {
+            ClientEngine engine = (ClientEngine) _clientEngines.get(new Integer(seriesNum));
+            if (engine.getPeer().equals(from)) {
+                engine.receivePong(sentOn.getTime(), replyOn.getTime());
+            }
+        }
+    }
+
+}

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

@@ -0,0 +1,604 @@
+package net.i2p.heartbeat;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.Date;
+import java.util.Properties;
+
+import net.i2p.I2PAppContext;
+import net.i2p.I2PException;
+import net.i2p.client.I2PClient;
+import net.i2p.client.I2PClientFactory;
+import net.i2p.client.I2PSession;
+import net.i2p.client.I2PSessionException;
+import net.i2p.client.I2PSessionListener;
+import net.i2p.data.DataFormatException;
+import net.i2p.data.DataHelper;
+import net.i2p.data.Destination;
+import net.i2p.util.Clock;
+import net.i2p.util.Log;
+
+/**
+ * Tie-in to the I2P SDK for the Heartbeat system, talking to the I2PSession and
+ * dealing with the raw ping and pong messages.
+ *
+ */
+class I2PAdapter {
+    private final static Log _log = new Log(I2PAdapter.class);
+    /** I2CP host */
+    private String _i2cpHost;
+    /** I2CP port */
+    private int _i2cpPort;
+    /** how long do we want our tunnels to be? */
+    private int _numHops;
+    /** filename containing the heartbeat engine's private destination info */
+    private String _privateDestFile;
+    /** filename to store the heartbeat engine's public destination in base64*/
+    private String _publicDestFile;
+    /** our destination */
+    private Destination _localDest;
+    /** who do we tell? */
+    private PingPongEventListener _listener;
+    /** how do we talk to the router */
+    private I2PSession _session;
+    /** object that receives our i2cp notifications from the session and tells us */
+    private I2PListener _i2pListener; /* UNUSED */
+
+    /** 
+     * This config property tells us where the private destination data for our 
+     * connection (or if it doesn't exist, where will we save it)
+     */
+    private static final String DEST_FILE_PROP = "privateDestinationFile";
+    /** by default, the private destination data is in "heartbeat.keys" */
+    private static final String DEST_FILE_DEFAULT = "heartbeat.keys";
+    /** where will we export the public destination in base 64? */
+    private static final String PUBLIC_DEST_FILE_PROP = "publicDestinationFile";
+    /** where will we export the public destination in base 64? */
+    private static final String PUBLIC_DEST_FILE_DEFAULT = "heartbeat.txt";
+    /** This config property defines where the I2P router is */
+    private static final String I2CP_HOST_PROP = "i2cpHost";
+    /** by default, the I2P host is "localhost" */
+    private static final String I2CP_HOST_DEFAULT = "localhost";
+    /** This config property defines the I2CP port on the router */
+    private static final String I2CP_PORT_PROP = "i2cpPort";
+    /** by default, the I2CP port is 7654 */
+    private static final int I2CP_PORT_DEFAULT = 7654;
+
+    /** This property defines how many hops we want in our tunnels. */
+    public static final String NUMHOPS_PROP = "numHops";
+    /** by default, use 2 hop tunnels */
+    public static final int NUMHOPS_DEFAULT = 2;
+
+    /**
+     * Constructs an I2PAdapter . . .
+     */
+    public I2PAdapter() {
+        _privateDestFile = null;
+        _publicDestFile = null;
+        _i2cpHost = null;
+        _i2cpPort = -1;
+        _localDest = null;
+        _listener = null;
+        _session = null;
+        _numHops = 0;
+    }
+
+    /**
+     * who are we?
+     * @return the destination (us)
+     */
+    public Destination getLocalDestination() {
+        return _localDest;
+    }
+
+    /** 
+     * who gets notified when we receive a ping or a pong? 
+     * @return the event listener who gets notified
+     */
+    public PingPongEventListener getListener() {
+        return _listener;
+    }
+
+    /**
+     * Sets who gets notified when we receive a ping or a pong
+     * @param listener the event listener to get notified
+     */
+    public void setListener(PingPongEventListener listener) {
+        _listener = listener;
+    }
+
+    /** 
+     * how many hops do we want in our tunnels?
+     * @return the number of hops
+     */
+    public int getNumHops() {
+        return _numHops;
+    }
+
+    /**
+     * are we connected?
+     * @return true or false . . .
+     */
+    public boolean getIsConnected() {
+        return _session != null;
+    }
+
+    /**
+     * Read in all of the config data
+     * @param props the properties to load from
+     */
+    void loadConfig(Properties props) {
+        String privDestFile = props.getProperty(DEST_FILE_PROP, DEST_FILE_DEFAULT);
+        String pubDestFile = props.getProperty(PUBLIC_DEST_FILE_PROP, PUBLIC_DEST_FILE_DEFAULT);
+        String host = props.getProperty(I2CP_HOST_PROP, I2CP_HOST_DEFAULT);
+        String port = props.getProperty(I2CP_PORT_PROP, "" + I2CP_PORT_DEFAULT);
+        String numHops = props.getProperty(NUMHOPS_PROP, "" + NUMHOPS_DEFAULT);
+
+        int portNum = -1;
+        try {
+            portNum = Integer.parseInt(port);
+        } catch (NumberFormatException nfe) {
+            if (_log.shouldLog(Log.WARN)) {
+                _log.warn("Invalid I2CP port specified [" + port + "]");
+            }
+            portNum = I2CP_PORT_DEFAULT;
+        }
+        int hops = -1;
+        try {
+            hops = Integer.parseInt(numHops);
+        } catch (NumberFormatException nfe) {
+            if (_log.shouldLog(Log.WARN)) {
+                _log.warn("Invalid # hops specified [" + numHops + "]");
+            }
+            hops = NUMHOPS_DEFAULT;
+        }
+
+        _numHops = hops;
+        _privateDestFile = privDestFile;
+        _publicDestFile = pubDestFile;
+        _i2cpHost = host;
+        _i2cpPort = portNum;
+    }
+
+    /**
+     * write out the config to the props
+     * @param props the properties to write to 
+     */
+    void storeConfig(Properties props) {
+        if (_privateDestFile != null) {
+            props.setProperty(DEST_FILE_PROP, _privateDestFile);
+        } else {
+            props.setProperty(DEST_FILE_PROP, DEST_FILE_DEFAULT);
+        }
+        
+        if (_publicDestFile != null) {
+            props.setProperty(PUBLIC_DEST_FILE_PROP, _publicDestFile);
+        } else {
+            props.setProperty(PUBLIC_DEST_FILE_PROP, PUBLIC_DEST_FILE_DEFAULT);
+        }
+
+        if (_i2cpHost != null) {
+            props.setProperty(I2CP_HOST_PROP, _i2cpHost);
+        } else {
+            props.setProperty(I2CP_HOST_PROP, I2CP_HOST_DEFAULT);
+        }
+
+        if (_i2cpPort > 0) {
+            props.setProperty(I2CP_PORT_PROP, "" + _i2cpPort);
+        } else {
+            props.setProperty(I2CP_PORT_PROP, "" + I2CP_PORT_DEFAULT);
+        }
+
+        props.setProperty(NUMHOPS_PROP, "" + _numHops);
+    }
+
+    private static final int TYPE_PING = 0;
+    private static final int TYPE_PONG = 1;
+
+    /** 
+     * send a ping message to the peer
+     *
+     * @param peer peer to ping
+     * @param seriesNum id used to keep track of multiple pings (of different size/frequency) to a peer
+     * @param now current time to be sent in the ping (so we can watch for it in the pong)
+     * @param size total message size to send
+     *
+     * @throws IllegalStateException if we are not connected to the router
+     */
+    public void sendPing(Destination peer, int seriesNum, long now, int size) {
+        if (_session == null) throw new IllegalStateException("Not connected to the router");
+        ByteArrayOutputStream baos = new ByteArrayOutputStream(size);
+        try {
+            _localDest.writeBytes(baos);
+            DataHelper.writeLong(baos, 2, seriesNum);
+            DataHelper.writeLong(baos, 1, TYPE_PING);
+            DataHelper.writeDate(baos, new Date(now));
+            int padding = size - baos.size();
+            byte paddingData[] = new byte[padding];
+            I2PAppContext.getGlobalContext().random().nextBytes(paddingData);
+            //Arrays.fill(paddingData, (byte) 0x2A);
+            DataHelper.writeLong(baos, 2, padding);
+            baos.write(paddingData);
+            boolean sent = _session.sendMessage(peer, baos.toByteArray());
+            if (!sent) {
+                if (_log.shouldLog(Log.ERROR)) {
+                    _log.error("Error sending the ping to " + peer.calculateHash().toBase64() + " for series "
+                               + seriesNum);
+                }
+            } else {
+                if (_log.shouldLog(Log.INFO)) {
+                    _log.info("Ping sent to " + peer.calculateHash().toBase64() + " for series " + seriesNum);
+                }
+            }
+        } catch (IOException ioe) {
+            if (_log.shouldLog(Log.ERROR)) {
+                _log.error("Error sending the ping", ioe);
+            }
+        } catch (DataFormatException dfe) {
+            if (_log.shouldLog(Log.ERROR)) {
+                _log.error("Error writing out the ping message", dfe);
+            }
+        } catch (I2PSessionException ise) {
+            if (_log.shouldLog(Log.ERROR)) {
+                _log.error("Error writing out the ping message", ise);
+            }
+        }
+    }
+
+    /** 
+     * send a pong message to the peer
+     *
+     * @param peer peer to pong
+     * @param seriesNum id given to us in the ping
+     * @param sentOn date the peer said they sent us the message
+     * @param data payload the peer sent us in the ping
+     *
+     * @throws IllegalStateException if we are not connected to the router
+     */
+    public void sendPong(Destination peer, int seriesNum, Date sentOn, byte data[]) {
+        if (_session == null) throw new IllegalStateException("Not connected to the router");
+        ByteArrayOutputStream baos = new ByteArrayOutputStream(data.length + 768);
+        try {
+            _localDest.writeBytes(baos);
+            DataHelper.writeLong(baos, 2, seriesNum);
+            DataHelper.writeLong(baos, 1, TYPE_PONG);
+            DataHelper.writeDate(baos, sentOn);
+            DataHelper.writeDate(baos, new Date(Clock.getInstance().now()));
+            DataHelper.writeLong(baos, 2, data.length);
+            baos.write(data);
+            boolean sent = _session.sendMessage(peer, baos.toByteArray());
+            if (!sent) {
+                if (_log.shouldLog(Log.ERROR)) {
+                    _log.error("Error sending the pong to " + peer.calculateHash().toBase64() + " for series "
+                               + seriesNum + " which was sent on " + sentOn);
+                }
+            } else {
+                if (_log.shouldLog(Log.INFO)) {
+                    _log.info("Pong sent to " + peer.calculateHash().toBase64() + " for series " + seriesNum
+                              + " which was sent on " + sentOn);
+                }
+            }
+        } catch (IOException ioe) {
+            if (_log.shouldLog(Log.ERROR)) {
+                _log.error("Error sending the ping", ioe);
+            }
+        } catch (DataFormatException dfe) {
+            if (_log.shouldLog(Log.ERROR)) {
+                _log.error("Error writing out the pong message", dfe);
+            }
+        } catch (I2PSessionException ise) {
+            if (_log.shouldLog(Log.ERROR)) {
+                _log.error("Error writing out the pong message", ise);
+            }
+        }
+    }
+
+    /**
+     * We've received this data from I2P - parse it into a ping or a pong 
+     * and notify accordingly
+     * @param data the data to handle
+     */
+    private void handleMessage(byte data[]) {
+        ByteArrayInputStream bais = new ByteArrayInputStream(data);
+        try {
+            Destination from = new Destination();
+            from.readBytes(bais);
+            int series = (int) DataHelper.readLong(bais, 2);
+            long type = DataHelper.readLong(bais, 1);
+            Date sentOn = DataHelper.readDate(bais);
+            Date receivedOn = null;
+            if (type == TYPE_PONG) {
+                receivedOn = DataHelper.readDate(bais);
+            }
+            int size = (int) DataHelper.readLong(bais, 2);
+            byte payload[] = new byte[size];
+            int read = DataHelper.read(bais, payload);
+            if (read != size) { throw new IOException("Malformed payload - read " + read + " instead of " + size); }
+
+            if (_listener == null) {
+                if (_log.shouldLog(Log.ERROR)) {
+                    _log.error("Listener isn't set, but we received a valid message of type " + type + " sent from "
+                               + from.calculateHash().toBase64());
+                }
+                return;
+            }
+
+            if (type == TYPE_PING) {
+                if (_log.shouldLog(Log.INFO)) {
+                    _log.info("Ping received from " + from.calculateHash().toBase64() + " on series " + series
+                              + " sent on " + sentOn + " containing " + size + " bytes");
+                }
+                _listener.receivePing(from, series, sentOn, payload);
+            } else if (type == TYPE_PONG) {
+                if (_log.shouldLog(Log.INFO)) {
+                    _log.info("Pong received from " + from.calculateHash().toBase64() + " on series " + series
+                              + " sent on " + sentOn + " with pong sent on " + receivedOn + " containing " + size
+                              + " bytes");
+                }
+                _listener.receivePong(from, series, sentOn, receivedOn, payload);
+            } else {
+                throw new IOException("Invalid message type " + type);
+            }
+
+        } catch (IOException ioe) {
+            if (_log.shouldLog(Log.ERROR)) {
+                _log.error("Error handling the message", ioe);
+            }
+        } catch (DataFormatException dfe) {
+            if (_log.shouldLog(Log.ERROR)) {
+                _log.error("Error parsing the message", dfe);
+            }
+        }
+    }
+
+    /** 
+     * connect to the I2P router and either authenticate ourselves with the 
+     * destination we're given, or create a new one and write that to the 
+     * destination file.
+     *
+     * @return true if we connect successfully, false otherwise
+     */
+    boolean connect() {
+        I2PClient client = I2PClientFactory.createClient();
+        Destination us = null;
+        File destFile = new File(_privateDestFile);
+        us = verifyDestination(client, destFile);
+        if (us == null) return false;
+
+        // if we're here, we got a destination.  lets connect
+        FileInputStream fin = null;
+        try {
+            fin = new FileInputStream(destFile);
+            Properties options = getOptions();
+            I2PSession session = client.createSession(fin, options);
+            I2PListener lsnr = new I2PListener();
+            session.setSessionListener(lsnr);
+            session.connect();
+            _localDest = session.getMyDestination();
+            if (_log.shouldLog(Log.INFO)) {
+                _log.info("I2CP Session created and connected as " + _localDest.calculateHash().toBase64());
+            }
+            _session = session;
+            _i2pListener = lsnr;
+        } catch (I2PSessionException ise) {
+            if (_log.shouldLog(Log.ERROR)) {
+                _log.error("Error connecting", ise);
+            }
+            return false;
+        } catch (IOException ioe) {
+            if (_log.shouldLog(Log.ERROR)) {
+                _log.error("Error loading the destionation", ioe);
+            }
+            return false;
+        } finally {
+            if (fin != null) try {
+                fin.close();
+            } catch (IOException ioe) {
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * load, verify, or create a destination 
+     *
+     * @param client the client
+     * @param destFile the file holding the destination
+     * @return the destination loaded, or null if there was an error
+     */
+    private Destination verifyDestination(I2PClient client, File destFile) {
+        Destination us = null;
+        FileInputStream fin = null;
+        if (destFile.exists()) {
+            try {
+                fin = new FileInputStream(destFile);
+                us = new Destination();
+                us.readBytes(fin);
+                if (_log.shouldLog(Log.INFO)) {
+                    _log.info("Existing destination loaded: [" + us.toBase64() + "]");
+                }
+                
+                FileOutputStream fos = null;
+                try {
+                    fos = new FileOutputStream(_publicDestFile);
+                    fos.write(us.toBase64().getBytes());
+                    fos.flush();
+                } catch (IOException fioe) {
+                    _log.error("Error writing out the plain destination to [" + _publicDestFile + "]", fioe);
+                } finally {
+                    if (fos != null) try { fos.close(); } catch (IOException fioe) {}
+                }
+                
+            } catch (IOException ioe) {
+                if (fin != null) try {
+                    fin.close();
+                } catch (IOException ioe2) {
+                }
+                fin = null;
+                destFile.delete();
+                us = null;
+            } catch (DataFormatException dfe) {
+                if (fin != null) try {
+                    fin.close();
+                } catch (IOException ioe2) {
+                }
+                fin = null;
+                destFile.delete();
+                us = null;
+            } finally {
+                if (fin != null) try {
+                    fin.close();
+                } catch (IOException ioe2) {
+                }
+                fin = null;
+            }
+        }
+
+        if (us == null) {
+            // need to create a new one
+            FileOutputStream fos = null;
+            try {
+                fos = new FileOutputStream(destFile);
+                us = client.createDestination(fos);
+                if (_log.shouldLog(Log.INFO)) {
+                    _log.info("New destination created: [" + us.toBase64() + "]");
+                }
+                fos.close();
+                
+                try {
+                    fos = new FileOutputStream(_publicDestFile);
+                    fos.write(us.toBase64().getBytes());
+                    fos.flush();
+                } catch (IOException fioe) {
+                    _log.error("Error writing out the plain destination to [" + _publicDestFile + "]", fioe);
+                } finally {
+                    if (fos != null) try { fos.close(); } catch (IOException fioe) {}
+                    fos = null;
+                }
+                
+            } catch (IOException ioe) {
+                if (_log.shouldLog(Log.ERROR)) {
+                    _log.error("Error writing out the destination keys being created", ioe);
+                }
+                return null;
+            } catch (I2PException ie) {
+                if (_log.shouldLog(Log.ERROR)) {
+                    _log.error("Error creating the destination", ie);
+                }
+                return null;
+            } finally {
+                if (fos != null) try {
+                    fos.close();
+                } catch (IOException ioe) {
+                }
+            }
+        }
+        return us;
+    }
+
+    /**
+     * I2PSession connect options
+     * @return the options as Properties
+     */
+    private Properties getOptions() {
+        Properties props = new Properties();
+        // this should be BEST_EFFORT, but i'm too lazy to update the code to handle tracking 
+        // sessionTags and sessionKeys, marking them as delivered on pong.
+        props.setProperty(I2PClient.PROP_RELIABILITY, I2PClient.PROP_RELIABILITY_GUARANTEED);
+        props.setProperty(I2PClient.PROP_TCP_HOST, _i2cpHost);
+        props.setProperty(I2PClient.PROP_TCP_PORT, _i2cpPort + "");
+        props.setProperty("tunnels.depthInbound", "" + _numHops);
+        props.setProperty("tunnels.depthOutbound", "" + _numHops);
+        return props;
+    }
+
+    /** disconnect from the I2P router */
+    void disconnect() {
+        if (_session != null) {
+            try {
+                _session.destroySession();
+            } catch (I2PSessionException ise) {
+                if (_log.shouldLog(Log.ERROR)) {
+                    _log.error("Error destroying the session", ise);
+                }
+            }
+            _session = null;
+        }
+    }
+
+    /**
+     * Defines an event notification system for receiving pings and pongs
+     * 
+     */
+    public interface PingPongEventListener {
+        /** 
+         * receive a ping message from the peer
+         *
+         * @param from peer that sent us the ping
+         * @param seriesNum id the peer sent us in the ping
+         * @param sentOn date the peer said they sent us the message
+         * @param data payload from the ping
+         */
+        void receivePing(Destination from, int seriesNum, Date sentOn, byte data[]);
+
+        /** 
+         * receive a pong message from the peer
+         *
+         * @param from peer that sent us the pong
+         * @param seriesNum id the peer sent us in the pong (that we sent them in the ping)
+         * @param sentOn when we sent out the ping
+         * @param replyOn when they sent out the pong
+         * @param data payload from the ping/pong
+         */
+        void receivePong(Destination from, int seriesNum, Date sentOn, Date replyOn, byte data[]);
+    }
+
+    /**
+     * Receive data from the session and pass it along to handleMessage for parsing/dispersal
+     *
+     */
+    private class I2PListener implements I2PSessionListener {
+
+        /* (non-Javadoc)
+         * @see net.i2p.client.I2PSessionListener#disconnected(net.i2p.client.I2PSession)
+         */
+        public void disconnected(I2PSession session) {
+            if (_log.shouldLog(Log.ERROR)) {
+                _log.error("Session disconnected");
+            }
+            disconnect();
+        }
+
+        /* (non-Javadoc)
+         * @see net.i2p.client.I2PSessionListener#errorOccurred(net.i2p.client.I2PSession, java.lang.String, java.lang.Throwable)
+         */
+        public void errorOccurred(I2PSession session, String message, Throwable error) {
+            if (_log.shouldLog(Log.ERROR)) _log.error("Error occurred: " + message, error);
+        }
+
+        /* (non-Javadoc)
+         * @see net.i2p.client.I2PSessionListener#reportAbuse(net.i2p.client.I2PSession, int)
+         */
+        public void reportAbuse(I2PSession session, int severity) {
+            if (_log.shouldLog(Log.ERROR)) _log.error("Abuse reported with severity " + String.valueOf(severity));
+        }
+
+        /* (non-Javadoc)
+         * @see net.i2p.client.I2PSessionListener#messageAvailable(net.i2p.client.I2PSession, int, long)
+         */
+        public void messageAvailable(I2PSession session, int msgId, long size) {
+            try {
+                byte data[] = session.receiveMessage(msgId);
+                handleMessage(data);
+            } catch (I2PSessionException ise) {
+                if (_log.shouldLog(Log.ERROR)) _log.error("Error receiving the message", ise);
+                disconnect();
+            }
+        }
+    }
+}

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

@@ -0,0 +1,394 @@
+package net.i2p.heartbeat;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+
+import net.i2p.stat.Rate;
+import net.i2p.stat.RateStat;
+import net.i2p.util.Clock;
+import net.i2p.util.Log;
+
+/**
+ * Contain the current window of data for a particular series of ping/pong stats 
+ * sent to a peer.  This should be periodically kept clean by calling cleanup()
+ * to timeout expired pings and to drop data outside the window.
+ *
+ */
+public class PeerData {
+    private final static Log _log = new Log(PeerData.class);
+    /** peer / sequence / config in this data series */
+    private ClientConfig _peer;
+    /** 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 long _sessionStart;
+    private long _lifetimeSent;
+    private long _lifetimeReceived;
+    /** rate averaging the time to send over a variety of periods */
+    private RateStat _sendRate;
+    /** rate averaging the time to receive over a variety of periods */
+    private RateStat _receiveRate;
+    /** rate averaging the frequency of lost messages over a variety of periods */
+    private RateStat _lostRate;
+
+    /** how long we wait before timing out pending pings (30 seconds) */
+    private static final long TIMEOUT_PERIOD = 60 * 1000;
+
+    /** synchronize on this when updating _dataPoints or _pendingPings */
+    private Object _updateLock = new Object();
+
+    /**
+     * Creates a PeerData . . .
+     * @param config configuration to load from
+     */
+    public PeerData(ClientConfig config) {
+        _peer = config;
+        _dataPoints = new TreeMap();
+        _pendingPings = new TreeMap();
+        _sessionStart = Clock.getInstance().now();
+        _lifetimeSent = 0;
+        _lifetimeReceived = 0;
+        _sendRate = new RateStat("sendRate", "How long it takes to send", "peer",
+                                 getPeriods(config.getAveragePeriods()));
+        _receiveRate = new RateStat("receiveRate", "How long it takes to receive", "peer",
+                                    getPeriods(config.getAveragePeriods()));
+        _lostRate = new RateStat("lostRate", "How frequently we lose messages", "peer",
+                                 getPeriods(config.getAveragePeriods()));
+    }
+
+    /**
+     * turn the periods (# minutes) into rate periods (# milliseconds)
+     * @param periods (in minutes)
+     * @return an array of periods (in milliseconds)
+     */
+    private static long[] getPeriods(int periods[]) {
+        long rv[] = null;
+        if (periods == null) periods = new int[0];
+        rv = new long[periods.length];
+        for (int i = 0; i < periods.length; i++)
+            rv[i] = (long) periods[i] * 60 * 1000; // they're in minutes
+        Arrays.sort(rv);
+        return rv;
+    }
+
+    /** 
+     * how many pings are still outstanding?
+     * @return the number of pings outstanding
+     */
+    public int getPendingCount() {
+        synchronized (_updateLock) {
+            return _pendingPings.size();
+        }
+    }
+
+    /**
+     * how many data points are available in the current window?
+     * @return the number of datapoints available 
+     */
+    public int getDataPointCount() {
+        synchronized (_updateLock) {
+            return _dataPoints.size();
+        }
+    }
+
+    /**
+     * when did this test begin?
+     * @return when the test began  
+     */
+    public long getSessionStart() { return _sessionStart; }
+    
+    /**
+     * sets when the test began
+     * @param when when it began
+     */
+    public void setSessionStart(long when) { _sessionStart = when; }
+
+    /**
+     * how many pings have we sent for this test?
+     * @return the number of pings sent
+     */
+    public long getLifetimeSent() { return _lifetimeSent; }
+
+    /**
+     * how many pongs have we received for this test?
+     * @return the number of pings received
+     */
+    public long getLifetimeReceived() { return _lifetimeReceived; }
+
+    /**
+     * @return the client configuration
+     */
+    public ClientConfig getConfig() {
+        return _peer;
+    }
+
+    /** 
+     * What periods are we averaging the data over (in minutes)?
+     * @return the periods as an array of ints (in minutes)
+     */
+    public int[] getAveragePeriods() {
+        return (_peer.getAveragePeriods() != null ? _peer.getAveragePeriods() : new int[0]);
+    }
+
+    /** 
+     * average time to send over the given period.
+     *
+     * @param period number of minutes to retrieve the average for
+     * @return milliseconds average, or -1 if we dont track that period
+     */
+    public double getAverageSendTime(int period) {
+        return getAverage(_sendRate, period);
+    }
+
+    /** 
+     * average time to receive over the given period.
+     *
+     * @param period number of minutes to retrieve the average for
+     * @return milliseconds average, or -1 if we dont track that period
+     */
+    public double getAverageReceiveTime(int period) {
+        return getAverage(_receiveRate, period);
+    }
+
+    /** 
+     * number of lost messages over the given period.
+     *
+     * @param period number of minutes to retrieve the average for
+     * @return number of lost messages in the period, or -1 if we dont track that period
+     */
+    public double getLostMessages(int period) {
+        Rate rate = _lostRate.getRate(period * 60 * 1000);
+        if (rate == null) return -1;
+        return rate.getCurrentTotalValue();
+    }
+
+    private double getAverage(RateStat stat, int period) {
+        Rate rate = stat.getRate(period * 60 * 1000);
+        if (rate == null) return -1;
+        return rate.getAverageValue();
+    }
+
+    /**
+     * Return an ordered list of data points in the current window (after doing a cleanup)
+     *
+     * @return list of EventDataPoint objects
+     */
+    public List getDataPoints() {
+        cleanup();
+        synchronized (_updateLock) {
+            return new ArrayList(_dataPoints.values());
+        }
+    }
+
+    /**
+     * We have sent the peer a ping on this series (using the send time as given)
+     * @param dateSent when the ping was sent
+     */
+    public void addPing(long dateSent) {
+        EventDataPoint sent = new EventDataPoint(dateSent);
+        synchronized (_updateLock) {
+            _pendingPings.put(new Long(dateSent), sent);
+        }
+        _lifetimeSent++;
+    }
+
+    /** 
+     * we have received a pong from the peer on this series 
+     * 
+     * @param dateSent when we sent the ping
+     * @param pongSent when the peer received the ping and sent the pong
+     */
+    public void pongReceived(long dateSent, long pongSent) {
+        long now = Clock.getInstance().now();
+        synchronized (_updateLock) {
+            EventDataPoint data = (EventDataPoint) _pendingPings.remove(new Long(dateSent));
+            if (data != null) {
+                data.setPongReceived(now);
+                data.setPongSent(pongSent);
+                data.setWasPonged(true);
+                locked_addDataPoint(data);
+            } else {
+                _log.warn("Pong received, but no matching ping?  ping sent at = " + dateSent);
+            }
+        }
+        _sendRate.addData(pongSent - dateSent, 0);
+        _receiveRate.addData(now - pongSent, 0);
+        _lifetimeReceived++;
+    }
+    
+    protected void addDataPoint(EventDataPoint data) {
+        synchronized (_updateLock) {
+            locked_addDataPoint(data);
+        }
+    }
+    
+    private void locked_addDataPoint(EventDataPoint data) {
+        Object val = _dataPoints.put(new Long(data.getPingSent()), data);
+        if (val != null) {
+            if (_log.shouldLog(Log.WARN))
+                _log.warn("Duplicate data point received: " + data);
+        }
+    }
+
+    /** 
+     * drop all datapoints outside the window we're watching, and timeout all
+     * pending pings not ponged in the TIMEOUT_PERIOD, both updating the lost message
+     * rate and coallescing all of the rates.
+     *
+     */
+    public void cleanup() {
+        long dropBefore = Clock.getInstance().now() - _peer.getStatDuration() * 60 * 1000;
+        long timeoutBefore = Clock.getInstance().now() - TIMEOUT_PERIOD;
+        long numDropped = 0;
+        long numTimedOut = 0;
+
+        synchronized (_updateLock) {
+            numDropped = locked_dropExpired(dropBefore);
+            numTimedOut = locked_timeoutPending(timeoutBefore);
+        }
+
+        _lostRate.addData(numTimedOut, 0);
+
+        _receiveRate.coallesceStats();
+        _sendRate.coallesceStats();
+        _lostRate.coallesceStats();
+
+        if (_log.shouldLog(Log.DEBUG))
+            _log.debug("Peer data cleaned up " + numTimedOut + " timed out pings and removed " + numDropped
+                       + " old entries");
+    }
+    
+    /**
+     * Drop all data points that are already too old for us to be interested in
+     *
+     * @param when the earliest ping send time we care about
+     * @return number of data points dropped
+     */
+    private int locked_dropExpired(long when) {
+        Set toDrop = new HashSet(4);
+        // drop the failed and really old
+        for (Iterator iter = _dataPoints.keySet().iterator(); iter.hasNext(); ) {
+            Long pingTime = (Long)iter.next();
+            if (pingTime.longValue() < when)
+                toDrop.add(pingTime);
+        }
+        for (Iterator iter = toDrop.iterator(); iter.hasNext(); ) {
+            _dataPoints.remove(iter.next());
+        }
+        return toDrop.size();
+    }
+    
+    /** 
+     * timeout and remove all pings that were sent before the given time, 
+     * moving them from the set of pending pings to the set of data points
+     *
+     * @param when the earliest ping send time we care about
+     * @return number of pings timed out
+     */
+    private int locked_timeoutPending(long when) {
+        Set toDrop = new HashSet(4);
+        for (Iterator iter = _pendingPings.keySet().iterator(); iter.hasNext(); ) {
+            Long pingTime = (Long)iter.next();
+            if (pingTime.longValue() < when) {
+                toDrop.add(pingTime);
+                EventDataPoint point = (EventDataPoint)_pendingPings.get(pingTime);
+                point.setWasPonged(false);
+                locked_addDataPoint(point);
+            }
+        }
+        for (Iterator iter = toDrop.iterator(); iter.hasNext(); ) {
+            _pendingPings.remove(iter.next());
+        }
+        return toDrop.size();
+    }
+
+    /** actual data point for the peer */
+    public class EventDataPoint {
+        private boolean _wasPonged;
+        private long _pingSent;
+        private long _pongSent;
+        private long _pongReceived;
+
+        /**
+         * Creates an EventDataPoint
+         */
+        public EventDataPoint() { this(-1); }
+
+        /**
+         * Creates an EventDataPoint with pingtime associated with it =)
+         * @param pingSentOn the time a ping was sent
+         */
+        public EventDataPoint(long pingSentOn) {
+            _wasPonged = false;
+            _pingSent = pingSentOn;
+            _pongSent = -1;
+            _pongReceived = -1;
+        }
+
+        /** 
+         * when did we send this ping?
+         * @return the time the ping was sent
+         */
+        public long getPingSent() { return _pingSent; }
+        
+        /**
+         * sets when we sent this ping
+         * @param when when we sent the ping
+         */
+        public void setPingSent(long when) { _pingSent = when; }
+
+        /**
+         * when did the peer receive the ping?
+         * @return the time the ping was receieved 
+         */
+        public long getPongSent() {
+            return _pongSent;
+        }
+
+        /**
+         * Set the time the peer received the ping
+         * @param when the time to set
+         */
+        public void setPongSent(long when) {
+            _pongSent = when;
+        }
+
+        /** 
+         * when did we receive the peer's pong?
+         * @return the time we receieved the pong
+         */
+        public long getPongReceived() {
+            return _pongReceived;
+        }
+
+        /**
+         * Set the time the peer's pong was receieved
+         * @param when the time to set
+         */
+        public void setPongReceived(long when) {
+            _pongReceived = when;
+        }
+
+        /** 
+         * did the peer reply in time? 
+         * @return true or false, whether we got a reply in time */
+        public boolean getWasPonged() {
+            return _wasPonged;
+        }
+
+        /**
+         * Set whether we receieved the peer's reply in time
+         * @param pong true or false
+         */
+        public void setWasPonged(boolean pong) {
+            _wasPonged = pong;
+        }
+    }
+}

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

@@ -0,0 +1,142 @@
+package net.i2p.heartbeat;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.text.DecimalFormat;
+import java.text.DecimalFormatSymbols;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.Iterator;
+import java.util.Locale;
+
+import net.i2p.util.Clock;
+import net.i2p.util.Log;
+
+/**
+ * Actually write out the stats for peer test
+ *
+ */
+public class PeerDataWriter {
+    private final static Log _log = new Log(PeerDataWriter.class);
+
+    /** 
+     * persist the peer state to the location specified in the peer config
+     *
+     * @param data the peer data to persist
+     * @return true if it was persisted correctly, false on error
+     */
+    public boolean persist(PeerData data) {
+        String filename = data.getConfig().getStatFile();
+        File statFile = new File(filename);
+        FileOutputStream fos = null;
+        try {
+            fos = new FileOutputStream(statFile);
+            persist(data, fos);
+        } catch (IOException ioe) {
+            if (_log.shouldLog(Log.ERROR))
+                _log.error("Error persisting the peer data for "
+                           + data.getConfig().getPeer().calculateHash().toBase64(), ioe);
+            return false;
+        } finally {
+            if (fos != null) try {
+                fos.close();
+            } catch (IOException ioe) {
+            }
+        }
+        return true;
+    }
+    
+    /**
+     * persists the peer state to the output stream
+     * @param data the peer data to persist
+     * @param out where to persist the data
+     * @return true if it was persisted correctly [always (as implemented)], false on error
+     * @throws IOException
+     */
+    public boolean persist(PeerData data, OutputStream out) throws IOException {
+        String header = getHeader(data);
+
+        out.write(header.getBytes());
+        out.write("#action\tstatus\tdate and time sent   \tsendMs\treplyMs\troundTrip\n".getBytes());
+        for (Iterator iter = data.getDataPoints().iterator(); iter.hasNext();) {
+            PeerData.EventDataPoint point = (PeerData.EventDataPoint) iter.next();
+            String line = getEvent(point);
+            out.write(line.getBytes());
+        }
+        return true;
+    }
+
+    private String getHeader(PeerData data) {
+        StringBuffer buf = new StringBuffer(1024);
+        buf.append("peer         \t").append(data.getConfig().getPeer().calculateHash().toBase64()).append('\n');
+        buf.append("local        \t").append(data.getConfig().getUs().calculateHash().toBase64()).append('\n');
+        buf.append("peerDest     \t").append(data.getConfig().getPeer().toBase64()).append('\n');
+        buf.append("localDest    \t").append(data.getConfig().getUs().toBase64()).append('\n');
+        buf.append("numTunnelHops\t").append(data.getConfig().getNumHops()).append('\n');
+        buf.append("comment      \t").append(data.getConfig().getComment()).append('\n');
+        buf.append("sendFrequency\t").append(data.getConfig().getSendFrequency()).append('\n');
+        buf.append("sendSize     \t").append(data.getConfig().getSendSize()).append('\n');
+        buf.append("sessionStart \t").append(getTime(data.getSessionStart())).append('\n');
+        buf.append("currentTime  \t").append(getTime(Clock.getInstance().now())).append('\n');
+        buf.append("numPending   \t").append(data.getPendingCount()).append('\n');
+        buf.append("lifetimeSent \t").append(data.getLifetimeSent()).append('\n');
+        buf.append("lifetimeRecv \t").append(data.getLifetimeReceived()).append('\n');
+        int periods[] = data.getAveragePeriods();
+        buf.append("#averages\tminutes\tsendMs\trecvMs\tnumLost\troundTrip\n");
+        for (int i = 0; i < periods.length; i++) {
+            buf.append("periodAverage\t").append(periods[i]).append('\t');
+            buf.append(getNum(data.getAverageSendTime(periods[i]))).append('\t');
+            buf.append(getNum(data.getAverageReceiveTime(periods[i]))).append('\t');
+            buf.append(getNum(data.getLostMessages(periods[i]))).append('\t');
+            double rtt = data.getAverageSendTime(periods[i]) 
+                         + data.getAverageReceiveTime(periods[i]);
+            buf.append(getNum(rtt)).append('\n');
+        }
+        return buf.toString();
+    }
+
+    private String getEvent(PeerData.EventDataPoint point) {
+        StringBuffer buf = new StringBuffer(128);
+        buf.append("EVENT\t");
+        if (point.getWasPonged())
+            buf.append("OK\t");
+        else
+            buf.append("LOST\t");
+        buf.append(getTime(point.getPingSent())).append('\t');
+        if (point.getWasPonged()) {
+            buf.append(point.getPongSent() - point.getPingSent()).append('\t');
+            buf.append(point.getPongReceived() - point.getPongSent()).append('\t');
+            buf.append(point.getPongReceived() - point.getPingSent()).append('\t');
+        }
+        buf.append('\n');
+        return buf.toString();
+    }
+
+    private final SimpleDateFormat _fmt = new SimpleDateFormat("yyyyMMdd.HH:mm:ss.SSS", Locale.UK);
+
+    /**
+     * Converts a time (long) to text
+     * @param when the time to convert
+     * @return the textual representation
+     */
+    public String getTime(long when) {
+        synchronized (_fmt) {
+            return _fmt.format(new Date(when));
+        }
+    }
+
+    private final DecimalFormat _numFmt = new DecimalFormat("#0", new DecimalFormatSymbols(Locale.UK));
+
+    /**
+     * Converts a number (double) to text
+     * @param val the number to convert
+     * @return the textual representation
+     */
+    public String getNum(double val) {
+        synchronized (_numFmt) {
+            return _numFmt.format(val);
+        }
+    }
+}

apps/heartbeat/java/src/net/i2p/heartbeat/gui/HeartbeatControlPane.java

@@ -0,0 +1,108 @@
+package net.i2p.heartbeat.gui;
+
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+import javax.swing.JTabbedPane;
+
+import net.i2p.util.Log;
+
+/**
+ * Render the control widgets (refresh/load/snapshot and the 
+ * tabbed panel with the plot config data)
+ *
+ */
+class HeartbeatControlPane extends JPanel {
+    private final static Log _log = new Log(HeartbeatControlPane.class);
+    private HeartbeatMonitorGUI _gui;
+    private JTabbedPane _configPane;
+    private final static Color WHITE = new Color(255, 255, 255);
+    private final static Color LIGHT_BLUE = new Color(180, 180, 255); /* UNUSED */
+    private final static Color BLACK = new Color(0, 0, 0);
+    private Color _background = WHITE;
+    private Color _foreground = BLACK;
+        
+    /**
+     * Constructs a control panel onto the gui
+     * @param gui the gui the panel is associated with
+     */
+    public HeartbeatControlPane(HeartbeatMonitorGUI gui) {
+        _gui = gui;
+        initializeComponents();
+    }
+    
+    /**
+     * Adds a test to the panel
+     * @param config the configuration for the test
+     */
+    public void addTest(PeerPlotConfig config) {
+        _configPane.addTab(config.getTitle(), null, new JScrollPane(new PeerPlotConfigPane(config, this)), config.getSummary());
+        _configPane.setBackgroundAt(_configPane.getTabCount()-1, _background);
+        _configPane.setForegroundAt(_configPane.getTabCount()-1, _foreground);
+        _gui.pack();
+    }
+    
+    /**
+     * Removes a test from the panel
+     * @param config the configuration for the test
+     */
+    public void removeTest(PeerPlotConfig config) {
+        _gui.getMonitor().getState().removeTest(config);
+        int index = _configPane.indexOfTab(config.getTitle());
+        if (index >= 0)
+            _configPane.removeTabAt(index);
+    }
+    
+    /**
+     * Callback: when tests have changed
+     */
+    public void testsUpdated() {
+        List knownNames = new ArrayList(8);
+        for (int i = 0; i < _gui.getMonitor().getState().getTestCount(); i++) {
+            PeerPlotState state = _gui.getMonitor().getState().getTest(i);
+            String title = state.getPlotConfig().getTitle();
+            knownNames.add(state.getPlotConfig().getTitle());
+            if (_configPane.indexOfTab(title) >= 0) {
+                _log.debug("We already know about [" + title + "]");
+            } else {
+                _log.info("The test [" + title + "] is new to us");
+                PeerPlotConfigPane pane = new PeerPlotConfigPane(state.getPlotConfig(), this);
+                _configPane.addTab(state.getPlotConfig().getTitle(), null, new JScrollPane(pane), state.getPlotConfig().getSummary());
+                _configPane.setBackgroundAt(_configPane.getTabCount()-1, _background);
+                _configPane.setForegroundAt(_configPane.getTabCount()-1, _foreground);
+            }
+        }
+        List toRemove = new ArrayList(4);
+        for (int i = 0; i < _configPane.getTabCount(); i++) {
+            if (knownNames.contains(_configPane.getTitleAt(i))) {
+                // noop
+            } else {
+                toRemove.add(_configPane.getTitleAt(i));
+            }
+        }
+        for (int i = 0; i < toRemove.size(); i++) {
+            String title = (String)toRemove.get(i);
+            _log.info("Removing test [" + title + "]");
+            _configPane.removeTabAt(_configPane.indexOfTab(title));
+        }
+    }
+    
+    private void initializeComponents() {
+        if (_gui != null)
+            setBackground(_gui.getBackground());
+        else
+            setBackground(_background);
+        setLayout(new BorderLayout());
+        HeartbeatMonitorCommandBar bar = new HeartbeatMonitorCommandBar(_gui);
+        bar.setBackground(getBackground());
+        add(bar, BorderLayout.NORTH);
+        _configPane = new JTabbedPane(JTabbedPane.LEFT);
+        _configPane.setBackground(_background);
+        //add(_configPane, BorderLayout.CENTER);
+        add(_configPane, BorderLayout.SOUTH);
+    }
+}

apps/heartbeat/java/src/net/i2p/heartbeat/gui/HeartbeatMonitor.java

@@ -0,0 +1,116 @@
+package net.i2p.heartbeat.gui;
+
+import net.i2p.util.I2PThread;
+import net.i2p.util.Log;
+
+/**
+ * The HeartbeatMonitor, complete with main()!  Act now, and it's only 5 easy
+ * payments of $19.95 (plus shipping and handling)!  You heard me, only _5_
+ * easy payments of $19.95 (plus shipping and handling)! <p />
+ * 
+ * (fine print:  something about some states in the US requiring the addition
+ * of sales tax... or something) <p />
+ * 
+ * (finer print:  Satan owns you.  Deal with it.) <p />
+ *
+ * (even finer print: usage: <code>HeartbeatMonitor [configFilename]</code>)
+ */
+public class HeartbeatMonitor implements PeerPlotStateFetcher.FetchStateReceptor, PeerPlotConfig.UpdateListener {
+    private final static Log _log = new Log(HeartbeatMonitor.class);
+    private HeartbeatMonitorState _state;
+    private HeartbeatMonitorGUI _gui;
+    
+    /**
+     * Delegating constructor.
+     * @see HeartbeatMonitor#HeartbeatMonitor(String)
+     */
+    public HeartbeatMonitor() { this(null); }
+    
+    /**
+     * Creates a HeartbeatMonitor . . .
+     * @param configFilename the configuration file to read from
+     */
+    public HeartbeatMonitor(String configFilename) {
+        _state = new HeartbeatMonitorState(configFilename);
+        _gui = new HeartbeatMonitorGUI(this);
+    }
+    
+    /**
+     * Starts the game rollin'
+     */
+    public void runMonitor() {
+        loadConfig();
+        I2PThread t = new I2PThread(new HeartbeatMonitorRunner(this));
+        t.setName("HeartbeatMonitor");
+        t.setDaemon(false);
+        t.start();
+        _log.debug("Monitor started");
+    }
+    
+    /**
+     * give us all the data/config available 
+     * @return the current state (data/config)
+     */
+    HeartbeatMonitorState getState() {
+        return _state;
+    }
+    
+    /** for all of the peer tests being monitored, refetch the data and rerender */
+    void refetchData() {
+        _log.debug("Refetching data");
+        for (int i = 0; i < _state.getTestCount(); i++)
+            PeerPlotStateFetcher.fetchPeerPlotState(this, _state.getTest(i));
+    }
+    
+    /** (re)load the config defining what peer tests we are monitoring (and how to render) */
+    void loadConfig() {
+        //for (int i = 0; i < 10; i++) {
+        //    load("fake" + i);
+        //}
+    }
+    
+    /**
+     * Loads config data
+     * @param location the name of the location to load data from
+     */
+    public void load(String location) {
+        PeerPlotConfig cfg = new PeerPlotConfig(location);
+        cfg.addListener(this);
+        PeerPlotState state = new PeerPlotState(cfg);
+        PeerPlotStateFetcher.fetchPeerPlotState(this, state);
+    }
+    
+    /* (non-Javadoc)
+     * @see PeerPlotStateFetcher.FetchStateReceptor#peerPlotStateFetched
+     */
+    public synchronized void peerPlotStateFetched(PeerPlotState state) {
+        _state.addTest(state);
+        _gui.stateUpdated();
+    }
+    
+    /**
+     *  store the config defining what peer tests we are monitoring (and how to render) 
+     */
+    void storeConfig() {}
+    
+    /**
+     * And now, the main function, the one you've all been waiting for! . . .
+     * @param args da args.  Should take 1, which is the location to load config data from
+     */
+    public static void main(String args[]) {
+        Thread.currentThread().setName("HeartbeatMonitor.main");
+        if (args.length == 1)
+            new HeartbeatMonitor(args[0]).runMonitor();
+        else
+            new HeartbeatMonitor().runMonitor();
+    }
+    
+    /**
+     * Called when the config is updated
+     * @param config the updated config
+     */
+    public void configUpdated(PeerPlotConfig config) { 
+        _log.debug("Config updated, revamping the gui");
+        _gui.stateUpdated(); 
+    }
+}

apps/heartbeat/java/src/net/i2p/heartbeat/gui/HeartbeatMonitorCommandBar.java

@@ -0,0 +1,67 @@
+package net.i2p.heartbeat.gui;
+
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.ItemEvent;
+import java.awt.event.ItemListener;
+
+import javax.swing.DefaultComboBoxModel;
+import javax.swing.JButton;
+import javax.swing.JComboBox;
+import javax.swing.JFileChooser;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JTextField;
+
+class HeartbeatMonitorCommandBar extends JPanel {
+    private HeartbeatMonitorGUI _gui;
+    private JComboBox _refreshRate;
+    private JTextField _location;
+    
+    /**
+     * Constructs a command bar onto the gui
+     * @param gui the gui the command bar is associated with
+     */
+    public HeartbeatMonitorCommandBar(HeartbeatMonitorGUI gui) {
+        _gui = gui;
+        initializeComponents();
+    }
+    
+    private void refreshChanged(ItemEvent evt) {}
+    private void loadCalled() {
+        _gui.getMonitor().load(_location.getText());
+    }
+    
+    private void browseCalled() {
+        JFileChooser chooser = new JFileChooser(_location.getText());
+        chooser.setBackground(_gui.getBackground());
+        chooser.setMultiSelectionEnabled(false);
+        int rv = chooser.showDialog(this, "Load");
+        if (rv == JFileChooser.APPROVE_OPTION) 
+            _gui.getMonitor().load(chooser.getSelectedFile().getAbsolutePath());
+    }
+    
+    private void initializeComponents() {
+        _refreshRate = new JComboBox(new DefaultComboBoxModel(new Object[] {"10 second refresh", "30 second refresh", "1 minute refresh", "5 minute refresh"}));
+        _refreshRate.addItemListener(new ItemListener() { public void itemStateChanged(ItemEvent evt) { refreshChanged(evt); } });
+        _refreshRate.setEnabled(false);
+        _refreshRate.setBackground(_gui.getBackground());
+        //add(_refreshRate);
+        JLabel loadLabel = new JLabel("Load from: ");
+        loadLabel.setBackground(_gui.getBackground());
+        add(loadLabel);
+        _location = new JTextField(20);
+        _location.setToolTipText("Either specify a local filename or a fully qualified URL");
+        _location.setBackground(_gui.getBackground());
+        add(_location);
+        JButton browse = new JButton("Browse...");
+        browse.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent evt) { browseCalled(); } });
+        browse.setBackground(_gui.getBackground());
+        add(browse);
+        JButton load = new JButton("Load");
+        load.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent evt) { loadCalled(); } });
+        load.setBackground(_gui.getBackground());
+        add(load);
+        setBackground(_gui.getBackground());
+    }
+}

apps/heartbeat/java/src/net/i2p/heartbeat/gui/HeartbeatMonitorGUI.java

@@ -0,0 +1,98 @@
+package net.i2p.heartbeat.gui;
+
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+import javax.swing.JFrame;
+import javax.swing.JMenu;
+import javax.swing.JMenuBar;
+import javax.swing.JMenuItem;
+import javax.swing.JScrollPane;
+
+class HeartbeatMonitorGUI extends JFrame {
+    private HeartbeatMonitor _monitor;
+    private HeartbeatPlotPane _plotPane;
+    private HeartbeatControlPane _controlPane;
+    private final static Color WHITE = new Color(255, 255, 255);
+    private Color _background = WHITE;
+    
+    /**
+     * Creates the GUI for all youz who be too shoopid for text based shitz
+     * @param monitor the monitor the gui operates over
+     */
+    public HeartbeatMonitorGUI(HeartbeatMonitor monitor) {
+        super("Heartbeat Monitor");
+        _monitor = monitor;
+        initializeComponents();
+        pack();
+        //setResizable(false);
+        setVisible(true);
+    }
+    
+    HeartbeatMonitor getMonitor() { return _monitor; }
+    
+    /** build up all our widgets */
+    private void initializeComponents() {
+        getContentPane().setLayout(new BorderLayout());
+        
+        setBackground(_background);
+        
+        _plotPane = new JFreeChartHeartbeatPlotPane(this); // new HeartbeatPlotPane(this);
+        _plotPane.setBackground(_background);
+        //JScrollPane pane = new JScrollPane(_plotPane);
+        //pane.setBackground(_background);
+        getContentPane().add(new JScrollPane(_plotPane), BorderLayout.CENTER);
+        
+        _controlPane = new HeartbeatControlPane(this);
+        _controlPane.setBackground(_background);
+        getContentPane().add(_controlPane, BorderLayout.SOUTH);
+        
+        //JSplitPane pane = new JSplitPane(JSplitPane.VERTICAL_SPLIT, new JScrollPane(_plotPane), new JScrollPane(_controlPane));
+        //getContentPane().add(pane, BorderLayout.CENTER);
+        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        initializeMenus();
+    }
+    
+    /**
+     * Callback:  when the state of the world changes . . .
+     */
+    public void stateUpdated() {
+        _controlPane.testsUpdated();
+        _plotPane.stateUpdated();
+    }
+    
+    private void exitCalled() {
+        _monitor.getState().setWasKilled(true);
+        setVisible(false);
+        System.exit(0);
+    }
+    private void loadConfigCalled() {}
+    private void saveConfigCalled() {}
+    private void loadSnapshotCalled() {}
+    private void saveSnapshotCalled() {}
+    
+    private void initializeMenus() {
+        JMenuBar bar = new JMenuBar();
+        JMenu fileMenu = new JMenu("File");
+        JMenuItem loadConfig = new JMenuItem("Load config");
+        loadConfig.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent evt) { loadConfigCalled(); } });
+        JMenuItem saveConfig = new JMenuItem("Save config");
+        saveConfig.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent evt) { saveConfigCalled(); } });
+        JMenuItem saveSnapshot = new JMenuItem("Save snapshot");
+        saveSnapshot.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent evt) { saveSnapshotCalled(); } });
+        JMenuItem loadSnapshot = new JMenuItem("Load snapshot");
+        loadSnapshot.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent evt) { loadSnapshotCalled(); } });
+        JMenuItem exit = new JMenuItem("Exit");
+        exit.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent evt) { exitCalled(); } });
+        
+        fileMenu.add(loadConfig);
+        fileMenu.add(saveConfig);
+        fileMenu.add(loadSnapshot);
+        fileMenu.add(saveSnapshot);
+        fileMenu.add(exit);
+        bar.add(fileMenu);
+        setJMenuBar(bar);
+    }
+}

apps/heartbeat/java/src/net/i2p/heartbeat/gui/HeartbeatMonitorRunner.java

@@ -0,0 +1,32 @@
+package net.i2p.heartbeat.gui;
+
+import net.i2p.util.Log;
+
+/** 
+ * Periodically fire off necessary events (instructing the heartbeat monitor when
+ * to refetch the data, etc).  This is the only active thread in the heartbeat 
+ * monitor (outside the swing/jvm threads) 
+ */
+class HeartbeatMonitorRunner implements Runnable {
+    private final static Log _log = new Log(HeartbeatMonitorRunner.class);
+    private HeartbeatMonitor _monitor;
+    
+    /**
+     * Creates the thread . . .
+     * @param monitor the monitor the thread runs over
+     */
+    public HeartbeatMonitorRunner(HeartbeatMonitor monitor) {
+        _monitor = monitor;
+    }
+    
+    /* (non-Javadoc)
+     * @see java.lang.Runnable#run()
+     */
+    public void run() {
+        while (!_monitor.getState().getWasKilled()) {
+            _monitor.refetchData();
+            try { Thread.sleep(_monitor.getState().getRefreshRateMs()); } catch (InterruptedException ie) {}
+        }
+        _log.info("Stopping the heartbeat monitor runner");
+    }
+}

apps/heartbeat/java/src/net/i2p/heartbeat/gui/HeartbeatMonitorState.java

@@ -0,0 +1,129 @@
+package net.i2p.heartbeat.gui;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * manage the current state of the GUI - all data points, as well as any
+ * rendering or configuration options.
+ */
+class HeartbeatMonitorState {
+    private String _configFile;
+    private List _peerPlotState;
+    private int _currentPeerPlotConfig;
+    private int _refreshRateMs;
+    private boolean _killed;
+    
+    /** by default, refresh every 30 seconds */
+    private final static int DEFAULT_REFRESH_RATE = 30*1000;
+    /** where do we load/store config info from? */
+    private final static String DEFAULT_CONFIG_FILE = "heartbeatMonitor.config";
+    
+    /**
+     * A delegating constructor.
+     * @see HeartbeatMonitorState#HeartbeatMonitorState(String)
+     */
+    public HeartbeatMonitorState() { this(DEFAULT_CONFIG_FILE); }
+
+    /**
+     * Constructs the state, loading from the specified location
+     * @param configFile the name of the file to load info from
+     */
+    public HeartbeatMonitorState(String configFile) {
+        _peerPlotState = Collections.synchronizedList(new ArrayList());
+        _refreshRateMs = DEFAULT_REFRESH_RATE;
+        _configFile = configFile;
+        _killed = false;
+        _currentPeerPlotConfig = 0;
+    }
+    
+    /**
+     * how many tests are we monitoring?
+     * @return the number of tests
+     */
+    public int getTestCount() { return _peerPlotState.size(); }
+
+    /**
+     * Retrieves the current info of a test for a certain peer . . . 
+     * @param peer a number associated with a certain peer
+     * @return the test data
+     */
+    public PeerPlotState getTest(int peer) { return (PeerPlotState)_peerPlotState.get(peer); }
+
+    /**
+     * Adds a test . . .
+     * @param peerState the test (by state) to add . . .
+     */
+    public void addTest(PeerPlotState peerState) { 
+        if (!_peerPlotState.contains(peerState))
+            _peerPlotState.add(peerState); 
+    }
+    /**
+     * Removes a test . . .
+     * @param peerState the test (by state) to remove . . .
+     */
+    public void removeTest(PeerPlotState peerState) { _peerPlotState.remove(peerState); }
+    
+    /**
+     * Removes a test . . .
+     * @param peerConfig the test (by config) to remove . . .
+     */
+    public void removeTest(PeerPlotConfig peerConfig) {
+        for (int i = 0; i < getTestCount(); i++) {
+            PeerPlotState state = getTest(i);
+            if (state.getPlotConfig() == peerConfig) {
+                removeTest(state);
+                return;
+            }
+        }
+    }
+    
+    /** 
+     * which of the tests are we currently editing/viewing?
+     * @return the number associated with the test
+     */
+    public int getPeerPlotConfig() { return _currentPeerPlotConfig; }
+
+    /**
+     * Sets the test we are currently editting/viewing
+     * @param whichTest the number associated with the test
+     */
+    public void setPeerPlotConfig(int whichTest) { _currentPeerPlotConfig = whichTest; }
+    
+    /**
+     * how frequently should we update the data?
+     * @return the current frequency (in milliseconds) 
+     */
+    public int getRefreshRateMs() { return _refreshRateMs; }
+
+    /**
+     * Sets how frequently we should update data
+     * @param ms the frequency (in milliseconds)
+     */
+    public void setRefreshRateMs(int ms) { _refreshRateMs = ms; }
+    
+    /** 
+     * where is our config stored? 
+     * @return the name of the config file
+     */
+    public String getConfigFile() { return _configFile; }
+
+    /**
+     * Sets where our config is stored
+     * @param filename the name of the config file
+     */
+    public void setConfigFile(String filename) { _configFile = filename; }
+    
+    /** 
+     * have we been shut down?
+     * @return true if we have, false otherwise 
+     */
+    public boolean getWasKilled() { return _killed; }
+
+    /**
+     * Sets if we have been shutdown or not
+     * @param killed true if we've been shutdown, false otherwise
+     */
+    public void setWasKilled(boolean killed) { _killed = killed; }
+}

apps/heartbeat/java/src/net/i2p/heartbeat/gui/HeartbeatPlotPane.java

@@ -0,0 +1,62 @@
+package net.i2p.heartbeat.gui;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+
+import javax.swing.JPanel;
+import javax.swing.JTextArea;
+
+import net.i2p.heartbeat.PeerDataWriter;
+import net.i2p.util.Log;
+
+/**
+ * Render the graph and legend
+ */
+class HeartbeatPlotPane extends JPanel {
+    private final static Log _log = new Log(HeartbeatPlotPane.class);
+    protected HeartbeatMonitorGUI _gui;
+    private JTextArea _text;
+    
+    /**
+     * Constructs the plot pane
+     * @param gui the gui the pane is attached to
+     */
+    public HeartbeatPlotPane(HeartbeatMonitorGUI gui) {
+        _gui = gui;
+        initializeComponents();
+    }
+    
+    /**
+     * Callback: when things change . . . 
+     */
+    public void stateUpdated() {
+        StringBuffer buf = new StringBuffer(32*1024);
+        PeerDataWriter writer = new PeerDataWriter();
+        
+        for (int i = 0; i < _gui.getMonitor().getState().getTestCount(); i++) {
+            StaticPeerData data = _gui.getMonitor().getState().getTest(i).getCurrentData();
+            ByteArrayOutputStream baos = new ByteArrayOutputStream(4096);
+            try {
+                writer.persist(data, baos);
+            } catch (IOException ioe) {
+                _log.error("wtf, error writing to a byte array?", ioe);
+            }
+            buf.append(new String(baos.toByteArray())).append("\n\n\n");
+        }
+        
+        _text.setText(buf.toString());
+    }
+    
+    protected void initializeComponents() {
+        setBackground(_gui.getBackground());
+        //Dimension size = new Dimension(800, 600);
+        _text = new JTextArea("",30,80); // 16, 60);
+        _text.setAutoscrolls(true);
+        _text.setEditable(false);
+        // _text.setLineWrap(true);
+        // add(new JScrollPane(_text));
+        add(_text);
+        // add(new JScrollPane(_text, JScrollPane.VERTICAL_SCROLLBAR_ALWAYS, JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS));
+        // setPreferredSize(size);
+    }
+}

apps/heartbeat/java/src/net/i2p/heartbeat/gui/JFreeChartAdapter.java

@@ -0,0 +1,233 @@
+package net.i2p.heartbeat.gui;
+
+import java.awt.Color;
+import java.awt.Font;
+import java.util.List;
+
+import org.jfree.chart.ChartPanel;
+import org.jfree.chart.JFreeChart;
+import org.jfree.chart.axis.DateAxis;
+import org.jfree.chart.axis.NumberAxis;
+import org.jfree.chart.plot.Plot;
+import org.jfree.chart.plot.XYPlot;
+import org.jfree.chart.renderer.XYItemRenderer;
+import org.jfree.chart.renderer.XYLineAndShapeRenderer;
+import org.jfree.data.XYSeries;
+import org.jfree.data.XYSeriesCollection;
+
+import net.i2p.heartbeat.PeerData;
+import net.i2p.util.Log;
+
+class JFreeChartAdapter {
+    private final static Log _log = new Log(JFreeChartAdapter.class); /* UNUSED */
+    private final static Color WHITE = new Color(255, 255, 255);
+    
+    ChartPanel createPanel(HeartbeatMonitorState state) {
+        ChartPanel panel = new ChartPanel(createChart(state));
+        panel.setDisplayToolTips(true);
+        panel.setEnforceFileExtensions(true);
+        panel.setHorizontalZoom(true);
+        panel.setVerticalZoom(true);
+        panel.setMouseZoomable(true, true);
+        panel.getChart().setBackgroundPaint(WHITE);
+        return panel;
+    }
+    
+    JFreeChart createChart(HeartbeatMonitorState state) {
+        Plot plot = createPlot(state);
+        JFreeChart chart = new JFreeChart("I2P Heartbeat performance", Font.getFont("arial"), plot, true);
+        return chart;
+    }
+    
+    void updateChart(ChartPanel panel, HeartbeatMonitorState state) {
+        XYPlot plot = (XYPlot)panel.getChart().getPlot();
+        plot.setDataset(getCollection(state));
+        updateLines(plot, state);
+    }
+    
+    private long getFirst(HeartbeatMonitorState state) { /* UNUSED */
+        long first = -1;
+        for (int i = 0; i < state.getTestCount(); i++) {
+            List dataPoints = state.getTest(i).getCurrentData().getDataPoints();
+            if ( (dataPoints != null) && (dataPoints.size() > 0) ) {
+                PeerData.EventDataPoint data = (PeerData.EventDataPoint)dataPoints.get(0);
+                if ( (first < 0) || (first > data.getPingSent()) )
+                    first = data.getPingSent();
+            }
+        }
+        return first;
+    }
+    
+    Plot createPlot(HeartbeatMonitorState state) {
+        XYItemRenderer renderer = new XYLineAndShapeRenderer(); // new XYDotRenderer(); // 
+        XYPlot plot = new XYPlot(getCollection(state), new DateAxis(), new NumberAxis("ms"), renderer);
+        updateLines(plot, state);
+        return plot;
+    }
+    
+    private void updateLines(XYPlot plot, HeartbeatMonitorState state) {
+        if (true) return;
+        if (state == null) return;
+        for (int i = 0; i < state.getTestCount(); i++) {
+            PeerPlotConfig config = state.getTest(i).getPlotConfig();
+            PeerPlotConfig.PlotSeriesConfig curConfig = config.getCurrentSeriesConfig();
+            XYSeriesCollection col = ((XYSeriesCollection)plot.getDataset());
+            for (int j = 0; j < col.getSeriesCount(); j++) {
+                //XYItemRenderer renderer = plot.getRendererForDataset(col.getSeries(j));
+                XYItemRenderer renderer = plot.getRendererForDataset(col);
+                if (col.getSeriesName(j).startsWith(config.getTitle() + " send")) {
+                    if (curConfig.getPlotSendTime()) {
+                        //renderer.setPaint(curConfig.getPlotLineColor());
+                    }
+                }
+                if (col.getSeriesName(j).startsWith(config.getTitle() + " receive")) {
+                    if (curConfig.getPlotReceiveTime()) {
+                        //renderer.setPaint(curConfig.getPlotLineColor());
+                    }
+                }
+                if (col.getSeriesName(j).startsWith(config.getTitle() + " lost")) {
+                    if (curConfig.getPlotLostMessages()) {
+                        //renderer.setPaint(curConfig.getPlotLineColor());
+                    }
+                }
+            }
+        }
+    }
+    
+    XYSeriesCollection getCollection(HeartbeatMonitorState state) {
+        XYSeriesCollection col = new XYSeriesCollection();
+        if (state != null) {
+            for (int i = 0; i < state.getTestCount(); i++) {
+                addTest(col, state.getTest(i));
+            }
+        } else {
+            XYSeries series = new XYSeries("latency", false, false);
+            series.add(System.currentTimeMillis(), 0);
+            col.addSeries(series);
+        }
+        return col;
+    }
+    
+    void addTest(XYSeriesCollection col, PeerPlotState state) {
+        PeerPlotConfig config = state.getPlotConfig();
+        PeerPlotConfig.PlotSeriesConfig curConfig = config.getCurrentSeriesConfig();
+        addLines(col, curConfig, config.getTitle(), state.getCurrentData().getDataPoints());
+        addAverageLines(col, config, config.getTitle(), state.getCurrentData());
+    }
+    
+    /**
+     * @param col the collection of xy series to add to
+     * @param config preferences for how to display this test
+     * @param lineName minimal name of the test (e.g. "jxHa.32KB.60s")
+     * @param data List of PeerData.EventDataPoint describing all of the events in the test
+     */
+    void addLines(XYSeriesCollection col, PeerPlotConfig.PlotSeriesConfig config, String lineName, List data) {
+        if (config.getPlotSendTime()) {
+            XYSeries sendSeries = getSendSeries(data);
+            sendSeries.setName(lineName + " send");
+            sendSeries.setDescription("milliseconds for the ping to reach the peer");
+            col.addSeries(sendSeries);
+        }
+        if (config.getPlotReceiveTime()) {
+            XYSeries recvSeries = getReceiveSeries(data);
+            recvSeries.setName(lineName + " receive");
+            recvSeries.setDescription("milliseconds for the peer's pong to reach the sender");
+            col.addSeries(recvSeries);
+        }
+        if (config.getPlotLostMessages()) {
+            XYSeries lostSeries = getLostSeries(data);
+            lostSeries.setName(lineName + " lost");
+            lostSeries.setDescription("number of ping/pong messages lost");
+            col.addSeries(lostSeries);
+        }
+    }
+    
+    /**
+     * Add a data series for each average that we're configured to render
+     *
+     * @param col the collection of xy series to add to
+     * @param config preferences for how to display this test
+     * @param lineName minimal name of the test (e.g. "jxHa.32KB.60s")
+     * @param data List of PeerData.EventDataPoint describing all of the events in the test
+     */
+    void addAverageLines(XYSeriesCollection col, PeerPlotConfig config, String lineName, StaticPeerData data) {
+        if (data.getDataPointCount() <= 0) return;
+        PeerData.EventDataPoint start = (PeerData.EventDataPoint)data.getDataPoints().get(0);
+        PeerData.EventDataPoint finish = (PeerData.EventDataPoint)data.getDataPoints().get(data.getDataPointCount()-1);
+
+        List configs = config.getAverageSeriesConfigs();
+
+        for (int i = 0; i < configs.size(); i++) {
+            PeerPlotConfig.PlotSeriesConfig cfg = (PeerPlotConfig.PlotSeriesConfig)configs.get(i);
+            int minutes = (int)cfg.getPeriod()/(60*1000);
+            if (cfg.getPlotSendTime()) {
+                double time = data.getAverageSendTime(minutes);
+                if (time > 0) {
+                    XYSeries series = new XYSeries(lineName + " send " + minutes + "m avg [" + time + "]", false, false);
+                    series.add(start.getPingSent(), time);
+                    series.add(finish.getPingSent(), time);
+                    series.setDescription("send time, averaged over the last " + minutes + " minutes");
+                    col.addSeries(series);
+                }
+            }
+            if (cfg.getPlotReceiveTime()) {
+                double time = data.getAverageReceiveTime(minutes);
+                if (time > 0) {
+                    XYSeries series = new XYSeries(lineName + " receive " + minutes + "m avg[" + time + "]", false, false);
+                    series.add(start.getPingSent(), time);
+                    series.add(finish.getPingSent(), time);
+                    series.setDescription("receive time, averaged over the last " + minutes + " minutes");
+                    col.addSeries(series);
+                }
+            }
+            if (cfg.getPlotLostMessages()) {
+                double num = data.getLostMessages(minutes);
+                if (num > 0) {
+                    XYSeries series = new XYSeries(lineName + " lost messages (" + num + " in " + minutes + "m)", false, false);
+                    series.add(start.getPingSent(), num);
+                    series.add(finish.getPingSent(), num);
+                    series.setDescription("number of messages lost in the last " + minutes + " minutes");
+                    col.addSeries(series);
+                }
+            }
+        }
+    }
+    
+    XYSeries getSendSeries(List data) {
+        XYSeries series = new XYSeries("sent", false, false);
+        for (int i = 0; i < data.size(); i++) {
+            PeerData.EventDataPoint point = (PeerData.EventDataPoint)data.get(i);
+            if (point.getWasPonged()) {
+                series.add(point.getPingSent(), point.getPongSent()-point.getPingSent());
+            } else {
+                // series.add(data.getPingSent(), 0);
+            }
+        }
+        return series;
+    }
+    
+    XYSeries getReceiveSeries(List data) {
+        XYSeries series = new XYSeries("receive", false, false);
+        for (int i = 0; i < data.size(); i++) {
+            PeerData.EventDataPoint point = (PeerData.EventDataPoint)data.get(i);
+            if (point.getWasPonged()) {
+                series.add(point.getPingSent(), point.getPongReceived()-point.getPongSent());
+            } else {
+                // series.add(data.getPingSent(), 0);
+            }
+        }
+        return series;
+    }
+    XYSeries getLostSeries(List data) {
+        XYSeries series = new XYSeries("lost", false, false);
+        for (int i = 0; i < data.size(); i++) {
+            PeerData.EventDataPoint point = (PeerData.EventDataPoint)data.get(i);
+            if (point.getWasPonged()) {
+                //series.add(point.getPingSent(), 0);
+            } else {
+                series.add(point.getPingSent(), 1);
+            }
+        }
+        return series;
+    }
+}

apps/heartbeat/java/src/net/i2p/heartbeat/gui/JFreeChartHeartbeatPlotPane.java

@@ -0,0 +1,58 @@
+package net.i2p.heartbeat.gui;
+
+import java.awt.BorderLayout;
+
+import javax.swing.JLabel;
+import javax.swing.JScrollPane;
+
+import org.jfree.chart.ChartPanel;
+
+import net.i2p.util.Log;
+
+/**
+ * Render the graph and legend
+ *
+ */
+class JFreeChartHeartbeatPlotPane extends HeartbeatPlotPane {
+    private final static Log _log = new Log(JFreeChartHeartbeatPlotPane.class); /* UNUSED */
+    private ChartPanel _panel;
+    private JFreeChartAdapter _adapter;
+
+    /**
+     * Creates a JFreeChart plot pane for the given gui
+     * @param gui the heartbeat monitor gui
+     */
+    public JFreeChartHeartbeatPlotPane(HeartbeatMonitorGUI gui) {
+        super(gui);
+    }
+    
+    /**
+     * Called when the state is updated
+     */
+    public void stateUpdated() {
+        if (_panel == null) {
+            remove(0); // remove the dummy
+            
+            _adapter = new JFreeChartAdapter();
+            _panel = _adapter.createPanel(_gui.getMonitor().getState());
+            _panel.setBackground(_gui.getBackground());
+            add(new JScrollPane(_panel), BorderLayout.CENTER);
+            _gui.pack();
+        } else {
+            _adapter.updateChart(_panel, _gui.getMonitor().getState());
+            //_gui.pack();
+        }
+    }
+    
+    protected void initializeComponents() {
+        // noop
+        setLayout(new BorderLayout());
+        add(new JLabel(), BorderLayout.CENTER);
+        //dummy.setBackground(_gui.getBackground());
+        //dummy.setPreferredSize(new Dimension(800,600));
+        //add(dummy);
+
+        //add(_panel);
+
+    }
+}

apps/heartbeat/java/src/net/i2p/heartbeat/gui/PeerPlotConfig.java

@@ -0,0 +1,367 @@
+package net.i2p.heartbeat.gui;
+
+import java.awt.Color;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeMap;
+
+import net.i2p.data.Destination;
+import net.i2p.heartbeat.ClientConfig;
+import net.i2p.util.Log;
+
+/**
+ * Configure how we want to render a particular clientConfig in the GUI
+ */
+class PeerPlotConfig {
+    private final static Log _log = new Log(PeerPlotConfig.class); /* UNUSED */
+    /** where can we find the current state/data (either as a filename or a URL)? */
+    private String _location;
+    /** what test are we defining the plot data for? */
+    private ClientConfig _config;
+    /** how should we render the current data set? */
+    private PlotSeriesConfig _currentSeriesConfig;
+    /** how should we render the various averages available? */
+    private List _averageSeriesConfigs;
+    private Set _listeners;
+    private boolean _disabled;
+
+    /**
+     * Delegating constructor . . .
+     * @param location the name of the file/URL to get the data from
+     */
+    public PeerPlotConfig(String location) {
+        this(location, null, null, null);
+    }
+    
+    /**
+     * Constructs a config =)
+     * @param location the location of the file/URL to get the data from
+     * @param config the client's configuration
+     * @param currentSeriesConfig the series config
+     * @param averageSeriesConfigs the average
+     */
+    public PeerPlotConfig(String location, ClientConfig config, PlotSeriesConfig currentSeriesConfig, List averageSeriesConfigs) {
+        _location = location;
+        if (config == null) 
+            config = new ClientConfig(location);
+        _config = config;
+        if (currentSeriesConfig != null)
+            _currentSeriesConfig = currentSeriesConfig;
+        else
+            _currentSeriesConfig = new PlotSeriesConfig(0);
+        
+        if (averageSeriesConfigs != null) {
+            _averageSeriesConfigs = averageSeriesConfigs;
+        } else {
+            rebuildAverageSeriesConfigs();
+        }
+        _listeners = Collections.synchronizedSet(new HashSet(2));
+        _disabled = false;
+    }
+    
+    /**
+     * 'Rebuilds' the average series stuff from the client configuration
+     */
+    public void rebuildAverageSeriesConfigs() {
+        int periods[] = _config.getAveragePeriods();
+        if (periods == null) {
+            _averageSeriesConfigs = Collections.synchronizedList(new ArrayList(0));
+        } else {
+            Arrays.sort(periods);
+            _averageSeriesConfigs = Collections.synchronizedList(new ArrayList(periods.length));
+            for (int i = 0; i < periods.length; i++) {
+                _averageSeriesConfigs.add(new PlotSeriesConfig(periods[i]*60*1000));
+            }
+        }
+    }
+    
+    /**
+     * Adds an average period
+     * @param minutes the number of minutes averaged over
+     */
+    public void addAverage(int minutes) {
+        _config.addAveragePeriod(minutes);
+        
+        TreeMap ordered = new TreeMap();
+        for (int i = 0; i < _averageSeriesConfigs.size(); i++) {
+            PlotSeriesConfig cfg = (PlotSeriesConfig)_averageSeriesConfigs.get(i);
+            ordered.put(new Long(cfg.getPeriod()), cfg);
+        }
+        Long period = new Long(minutes*60*1000);
+        if (!ordered.containsKey(period))
+            ordered.put(period, new PlotSeriesConfig(minutes*60*1000));
+        
+        List cfgs = Collections.synchronizedList(new ArrayList(ordered.size()));
+        for (Iterator iter = ordered.values().iterator(); iter.hasNext(); )
+            cfgs.add(iter.next());
+        
+        _averageSeriesConfigs = cfgs;
+    }
+    
+    /** 
+     * Where is the current state data supposed to be found?  This must either be a 
+     * local file path or a URL
+     * @return the current location
+     */
+    public String getLocation() { return _location; }
+
+    /**
+     * The location the current state data is supposed to be found.  This must either be
+     * a local file path or a URL
+     * @param location the location
+     */
+    public void setLocation(String location) { 
+        _location = location; 
+        fireUpdate();
+    }
+    
+    /** 
+     * What are we configuring? 
+     * @return the client configuration
+     */
+    public ClientConfig getClientConfig() { return _config; }
+
+    /**
+     * Sets what we are currently configuring
+     * @param config the new config
+     */
+    public void setClientConfig(ClientConfig config) { 
+        _config = config; 
+        fireUpdate();
+    }
+    
+    /** 
+     * How do we want to render the current data set?
+     * @return the way we currently render the data
+     */
+    public PlotSeriesConfig getCurrentSeriesConfig() { return _currentSeriesConfig; }
+
+    /**
+     * Sets how we want to render the current data set.
+     * @param config the new config
+     */
+    public void setCurrentSeriesConfig(PlotSeriesConfig config) { 
+        _currentSeriesConfig = config; 
+        fireUpdate();
+    }
+    
+    /** 
+     * How do we want to render the averages? 
+     * @return the way we currently render the averages
+     */
+    public List getAverageSeriesConfigs() { return _averageSeriesConfigs; }
+
+    /**
+     * Sets how we want to render the averages
+     * @param configs the new configs
+     */
+    public void setAverageSeriesConfigs(List configs) { _averageSeriesConfigs = configs; }
+    
+    /** 
+     * four char description of the peer 
+     * @return the name
+     */
+    public String getPeerName() { 
+        Destination peer = getClientConfig().getPeer();
+        if (peer == null) 
+            return "????";
+
+        return peer.calculateHash().toBase64().substring(0, 4);
+    }
+
+    /**
+     * title:  name.packetsize.sendfrequency
+     * @return the title
+     */
+    public String getTitle() { 
+        return getPeerName() + '.' + getSize() + '.' + getClientConfig().getSendFrequency(); 
+    }
+    
+    /**
+     * summary.  includes:name, size, sendfrequency, and # of hops  
+     * @return the summary
+     */
+    public String getSummary() { 
+        return "Send peer " + getPeerName() + ' ' + getSize() + " every " + 
+               getClientConfig().getSendFrequency() + " seconds through " +
+               getClientConfig().getNumHops() + "-hop tunnels";
+    }
+    
+    private String getSize() {
+        int bytes = getClientConfig().getSendSize();
+        if (bytes < 1024)
+            return bytes + "b";
+
+        return bytes/1024 + "kb";
+    }
+
+    /** 
+     * we've got someone who wants to be notified of changes to the plot config
+     * @param lsnr the listener to be added 
+     */
+    public void addListener(UpdateListener lsnr) { _listeners.add(lsnr); }
+
+    /**
+     * remove a listener
+     * @param lsnr the listener to remove
+     */
+    public void removeListener(UpdateListener lsnr) { _listeners.remove(lsnr); }
+    
+    void fireUpdate() {
+        if (_disabled) return;
+        for (Iterator iter = _listeners.iterator(); iter.hasNext(); ) {
+            ((UpdateListener)iter.next()).configUpdated(this);
+        }
+    }
+    
+    /**
+     * Disables notification of events listeners
+     * @see PeerPlotConfig#fireUpdate()
+     */
+    public void disableEvents() { _disabled = true; }
+
+    /**
+     * Enables notification of events listeners
+     * @see PeerPlotConfig#fireUpdate()
+     */
+    public void enableEvents() { _disabled = false; }
+    
+    /** 
+     * How do we want to render a particular dataset (either the current or the averaged values)?
+     */
+    public class PlotSeriesConfig {
+        private long _period;
+        private boolean _plotSendTime;
+        private boolean _plotReceiveTime;
+        private boolean _plotLostMessages;
+        private Color _plotLineColor;
+        
+        /**
+         * Delegating constructor . . .
+         * @param period the period for the config 
+         *        (0 for current, otherwise # of milliseconds being averaged over)
+         */
+        public PlotSeriesConfig(long period) {
+            this(period, false, false, false, null);
+            if (period <= 0) {
+                _plotSendTime = true;
+                _plotReceiveTime = true;
+                _plotLostMessages = true;
+            }
+        }
+        
+        
+        /**
+         * Creates a config for the rendering of a particular dataset)
+         * @param period the period for the config
+         *        (0 for current, otherwise # of milliseconds being averaged over)
+         * @param plotSend do we plot send times?
+         * @param plotReceive do we plot receive times?
+         * @param plotLost do we plot lost packets?
+         * @param plotColor in what color?
+         */
+        public PlotSeriesConfig(long period, boolean plotSend, boolean plotReceive, boolean plotLost, Color plotColor) {
+            _period = period;
+            _plotSendTime = plotSend;
+            _plotReceiveTime = plotReceive;
+            _plotLostMessages = plotLost;
+            _plotLineColor = plotColor;
+        }
+        
+        /**
+         * Retrieves the plot config this plot series config is a part of
+         * @return the plot config
+         */
+        public PeerPlotConfig getPlotConfig() { return PeerPlotConfig.this; }
+        
+        /** 
+         * What period is this series config describing?
+         * @return 0 for current, otherwise # milliseconds that are being averaged over
+         */
+        public long getPeriod() { return _period; }
+
+        /**
+         * Sets the period this series config is describing
+         * @param period the period
+         *        (0 for current, otherwise # milliseconds that are being averaged over)
+         */
+        public void setPeriod(long period) { 
+            _period = period; 
+            fireUpdate();
+        }
+        
+        /**
+         * Should we render the time to send (ping to peer)?
+         * @return true or false . . .
+         */
+        public boolean getPlotSendTime() { return _plotSendTime; }
+
+        /**
+         * Sets whether we render the time to send (ping to peer) or not
+         * @param shouldPlot true or false 
+         */
+        public void setPlotSendTime(boolean shouldPlot) { 
+            _plotSendTime = shouldPlot; 
+            fireUpdate();
+        }
+
+        /** 
+         * Should we render the time to receive (peer pong to us)?
+         * @return true or false . . . 
+         */
+        public boolean getPlotReceiveTime() { return _plotReceiveTime; }
+
+        /**
+         * Sets whether we render the time to receive (peer pong to us)
+         * @param shouldPlot true or false
+         */
+        public void setPlotReceiveTime(boolean shouldPlot) { 
+            _plotReceiveTime = shouldPlot; 
+            fireUpdate();
+        }
+        /**
+         * Should we render the number of messages lost (ping sent, no pong received in time)? 
+         * @return true or false . . .
+         */
+        public boolean getPlotLostMessages() { return _plotLostMessages; }
+
+        /**
+         * Sets whether we render the number of messages lost (ping sent, no pong received in time) or not
+         * @param shouldPlot true or false
+         */
+        public void setPlotLostMessages(boolean shouldPlot) { 
+            _plotLostMessages = shouldPlot; 
+            fireUpdate();
+        }
+        /**
+         * What color should we plot the data with? 
+         * @return the color
+         */
+        public Color getPlotLineColor() { return _plotLineColor; }
+
+        /**
+         * Sets the color we should plot the data with
+         * @param color the color to use
+         */
+        public void setPlotLineColor(Color color) { 
+            _plotLineColor = color; 
+            fireUpdate();
+        }
+    }
+    
+    /**
+     * An interface for listening to updates . . .
+     */
+    public interface UpdateListener {
+        /**
+         * @param config the peer plot config that changes
+         * @see PeerPlotConfig#fireUpdate()
+         */
+        void configUpdated(PeerPlotConfig config);
+    }
+}

apps/heartbeat/java/src/net/i2p/heartbeat/gui/PeerPlotConfigPane.java

@@ -0,0 +1,371 @@
+package net.i2p.heartbeat.gui;
+
+import java.awt.Color;
+import java.awt.GridBagConstraints;
+import java.awt.GridBagLayout;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.util.List;
+import java.util.Random;
+
+import javax.swing.JButton;
+import javax.swing.JCheckBox;
+import javax.swing.JColorChooser;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+import javax.swing.JTextArea;
+import javax.swing.JTextField;
+
+import net.i2p.util.Log;
+
+class PeerPlotConfigPane extends JPanel implements PeerPlotConfig.UpdateListener {
+    private final static Log _log = new Log(PeerPlotConfigPane.class);
+    private PeerPlotConfig _config;
+    private HeartbeatControlPane _parent;
+    private JLabel _title;
+    private JButton _delete;
+    private JLabel _fromLabel;
+    private JTextField _from;
+    private JTextArea _comments;
+    private JLabel _peerLabel;
+    private JTextField _peerKey;
+    private JLabel _localLabel;
+    private JTextField _localKey;
+    private OptionLine _options[];
+    private Random _rnd = new Random();
+    private final static Color WHITE = new Color(255, 255, 255);
+    private Color _background = WHITE;
+    
+    /**
+     * Constructs a pane
+     * @param config the plot config it represents
+     * @param pane the pane this one is attached to
+     */
+    public PeerPlotConfigPane(PeerPlotConfig config, HeartbeatControlPane pane) {
+        _config = config;
+        _parent = pane;
+        if (_parent != null)
+            _background = _parent.getBackground();
+        _config.addListener(this);
+        initializeComponents();
+    }
+    
+    /** called when the user wants to stop monitoring this test */
+    private void delete() {
+        _parent.removeTest(_config);
+    }
+    
+    private void initializeComponents() {
+        buildComponents();
+        placeComponents(this);
+        refreshView();
+        //setBorder(new BevelBorder(BevelBorder.RAISED));
+        setBackground(_background);
+    }
+    
+    /** 
+     * place all the gui components onto the given panel 
+     * @param body the panel to place the components on
+     */
+    private void placeComponents(JPanel body) {
+        body.setLayout(new GridBagLayout());
+        GridBagConstraints cts = new GridBagConstraints();
+        
+        // row 0: title + delete
+        cts.gridx = 0;
+        cts.gridy = 0;
+        cts.gridwidth = 5;
+        cts.anchor = GridBagConstraints.WEST;
+        cts.fill = GridBagConstraints.NONE;
+        body.add(_title, cts);
+        cts.gridx = 5;
+        cts.gridwidth = 1;
+        cts.anchor = GridBagConstraints.NORTHWEST;
+        cts.fill = GridBagConstraints.BOTH;
+        body.add(_delete, cts);
+        
+        // row 1: from + location
+        cts.gridx = 0;
+        cts.gridy = 1;
+        cts.gridwidth = 1;
+        cts.fill = GridBagConstraints.NONE;
+        body.add(_fromLabel, cts);
+        cts.gridx = 1;
+        cts.gridwidth = 5;
+        cts.fill = GridBagConstraints.BOTH;
+        body.add(_from, cts);
+
+        // row 2: comment
+        cts.gridx = 0;
+        cts.gridy = 2;
+        cts.gridwidth = 6;
+        cts.fill = GridBagConstraints.BOTH;
+        body.add(_comments, cts);
+        
+        // row 3: peer + peerKey 
+        cts.gridx = 0;
+        cts.gridy = 3;
+        cts.gridwidth = 1;
+        cts.fill = GridBagConstraints.NONE;
+        body.add(_peerLabel, cts);
+        cts.gridx = 1;
+        cts.gridwidth = 5;
+        cts.fill = GridBagConstraints.BOTH;
+        body.add(_peerKey, cts);
+        
+        // row 4: local + localKey
+        cts.gridx = 0;
+        cts.gridy = 4;
+        cts.gridwidth = 1;
+        cts.fill = GridBagConstraints.NONE;
+        body.add(_localLabel, cts);
+        cts.gridx = 1;
+        cts.gridwidth = 5;
+        cts.fill = GridBagConstraints.BOTH;
+        body.add(_localKey, cts);
+        
+        // row 5-N: data row
+        for (int i = 0; i < _options.length; i++) {
+            cts.gridx = 0;
+            cts.gridy = 5 + i;
+            cts.gridwidth = 1;
+            cts.fill = GridBagConstraints.NONE;
+            cts.anchor = GridBagConstraints.WEST;
+            if (_options[i]._durationMinutes <= 0)
+                body.add(new JLabel("Data: "), cts);
+            else
+                body.add(new JLabel(_options[i]._durationMinutes + "m avg: "), cts);
+            
+            cts.gridx = 1;
+            body.add(_options[i]._send, cts);
+            cts.gridx = 2;
+            body.add(_options[i]._recv, cts);
+            cts.gridx = 3;
+            body.add(_options[i]._lost, cts);
+            cts.gridx = 4;
+            body.add(_options[i]._all, cts);
+            cts.gridx = 5;
+            body.add(_options[i]._color, cts);
+        }
+    }
+    
+    /** build all of the gui components */
+    private void buildComponents() {
+        _title = new JLabel(_config.getSummary());
+        _title.setBackground(_background);
+        _delete = new JButton("Delete");
+        _delete.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent evt) { delete(); } });
+        _delete.setEnabled(false);
+        _delete.setBackground(_background);
+        _fromLabel = new JLabel("Location: ");
+        _fromLabel.setBackground(_background);
+        _from = new JTextField(_config.getLocation());
+        _from.setEditable(false);
+        _from.setBackground(_background);
+        _comments = new JTextArea(_config.getClientConfig().getComment(), 2, 20);
+        // _comments = new JTextArea(_config.getClientConfig().getComment(), 2, 40);
+        _comments.setEditable(false);
+        _comments.setBackground(_background);
+        _peerLabel = new JLabel("Peer: ");
+        _peerLabel.setBackground(_background);
+        _peerKey = new JTextField(_config.getClientConfig().getPeer().toBase64(), 8);
+        _peerKey.setBackground(_background);
+        _localLabel = new JLabel("Local: ");
+        _localLabel.setBackground(_background);
+        _localKey = new JTextField(_config.getClientConfig().getUs().toBase64(), 8);
+        _localKey.setBackground(_background);
+        
+        int averagedPeriods[] = _config.getClientConfig().getAveragePeriods();
+        if (averagedPeriods == null)
+            averagedPeriods = new int[0];
+        
+        _options = new OptionLine[1 + averagedPeriods.length];
+        _options[0] = new OptionLine(0);
+        for (int i = 0; i < averagedPeriods.length; i++) {
+            _options[1+i] = new OptionLine(averagedPeriods[i]);
+        }   
+    }
+    
+    /** the settings have changed - revise */
+    private void refreshView() {
+        for (int i = 0; i < _options.length; i++) {
+            PeerPlotConfig.PlotSeriesConfig cfg = getConfig(_options[i]._durationMinutes);
+            if (cfg == null) {
+                _log.warn("Config for minutes " + _options[i]._durationMinutes + " was not found?");
+                continue;
+            }
+            //_log.debug("Refreshing view for minutes ["+ _options[i]._durationMinutes + "]: send [" + 
+            //           _options[i]._send.isSelected() + "/" + cfg.getPlotSendTime() + "] recv [" + 
+            //           _options[i]._recv.isSelected() + "/" + cfg.getPlotReceiveTime() + "] lost [" +
+            //           _options[i]._lost.isSelected() + "/" + cfg.getPlotLostMessages() + "]");
+            _options[i]._send.setSelected(cfg.getPlotSendTime());
+            _options[i]._recv.setSelected(cfg.getPlotReceiveTime());
+            _options[i]._lost.setSelected(cfg.getPlotLostMessages());
+            if (cfg.getPlotLineColor() != null)
+                _options[i]._color.setBackground(cfg.getPlotLineColor());
+        }
+    }
+    
+    /** 
+     * find the right config for the given period
+     * @param minutes the minutes to locate the config by
+     * @return the config for the given period, or null
+     */
+    private PeerPlotConfig.PlotSeriesConfig getConfig(int minutes) {
+        if (minutes <= 0)
+            return _config.getCurrentSeriesConfig();
+        
+        List configs = _config.getAverageSeriesConfigs();
+        for (int i = 0; i < configs.size(); i++) {
+            PeerPlotConfig.PlotSeriesConfig cfg = (PeerPlotConfig.PlotSeriesConfig)configs.get(i);
+            if (cfg.getPeriod() == minutes * 60*1000)
+                return cfg;
+        }
+        return null;
+    }
+    
+    /** 
+     * notified that the config has been updated 
+     * @param config the config that was been updated
+     */
+    public void configUpdated(PeerPlotConfig config) { refreshView(); }
+    
+    private class ChooseColor implements ActionListener {
+        private int _minutes;
+        private JButton _button;
+        
+        /**
+         * @param minutes the minutes (line) to change the color of...
+         * @param button the associated button
+         */
+        public ChooseColor(int minutes, JButton button) { 
+            _minutes = minutes; 
+            _button = button;
+        }
+
+        /* (non-Javadoc)
+         * @see java.awt.event.ActionListener#actionPerformed(java.awt.event.ActionEvent)
+         */
+        public void actionPerformed(ActionEvent evt) { 
+            PeerPlotConfig.PlotSeriesConfig cfg = getConfig(_minutes);
+            Color origColor = null;
+            if (cfg != null)
+                origColor = cfg.getPlotLineColor();
+            Color color = JColorChooser.showDialog(PeerPlotConfigPane.this, "What color should this line be?", origColor);
+            if (color != null) {
+                if (cfg != null)
+                    cfg.setPlotLineColor(color);
+                _button.setBackground(color);
+            }
+        }
+    }
+    
+    private class OptionLine {
+        int _durationMinutes;
+        JCheckBox _send;
+        JCheckBox _recv;
+        JCheckBox _lost;
+        JCheckBox _all;
+        JButton _color;
+        
+        /**
+         * Creates an OptionLine.  
+         * @param durationMinutes the minutes =)
+         */
+        public OptionLine(int durationMinutes) {
+            _durationMinutes = durationMinutes;
+            _send = new JCheckBox("send time");
+            _send.setBackground(_background);
+            _recv = new JCheckBox("receive time");
+            _recv.setBackground(_background);
+            _lost = new JCheckBox("lost messages");
+            _lost.setBackground(_background);
+            _all = new JCheckBox("all");
+            _all.setBackground(_background);
+            _color = new JButton("color");
+            int r = _rnd.nextInt(255);
+            if (r < 0) r = -r;
+            int g = _rnd.nextInt(255);
+            if (g < 0) g = -g;
+            int b = _rnd.nextInt(255);
+            if (b < 0) b = -b;
+            //_color.setBackground(new Color(r, g, b));
+            _color.setBackground(_background);
+            
+            _send.addActionListener(new UpdateListener(OptionLine.this, _durationMinutes));
+            _recv.addActionListener(new UpdateListener(OptionLine.this, _durationMinutes));
+            _lost.addActionListener(new UpdateListener(OptionLine.this, _durationMinutes));
+            _all.addActionListener(new UpdateListener(OptionLine.this, _durationMinutes));
+            _color.addActionListener(new ChooseColor(durationMinutes, _color));
+            _color.setEnabled(false);
+        }
+    }
+    
+    private class UpdateListener implements ActionListener {
+        private OptionLine _line;
+        private int _minutes;
+
+        /**
+         * Update Listener constructor . . . 
+         * @param line the line
+         * @param minutes the minutes
+         */
+        public UpdateListener(OptionLine line, int minutes) {
+            _line = line;
+            _minutes = minutes;
+        }
+        
+        /* (non-Javadoc)
+         * @see java.awt.event.ActionListener#actionPerformed(java.awt.event.ActionEvent)
+         */
+        public void actionPerformed(ActionEvent evt) { 
+            PeerPlotConfig.PlotSeriesConfig cfg = getConfig(_minutes);
+            
+            cfg.getPlotConfig().disableEvents();
+            _log.debug("Updating data for minutes ["+ _line._durationMinutes + "]: send [" + 
+                       _line._send.isSelected() + "/" + cfg.getPlotSendTime() + "] recv [" + 
+                       _line._recv.isSelected() + "/" + cfg.getPlotReceiveTime() + "] lost [" +
+                       _line._lost.isSelected() + "/" + cfg.getPlotLostMessages() + "]: config = " + cfg);
+            
+            boolean force = _line._all.isSelected();
+            cfg.setPlotSendTime(_line._send.isSelected() || force);
+            cfg.setPlotReceiveTime(_line._recv.isSelected() || force);
+            cfg.setPlotLostMessages(_line._lost.isSelected() || force);
+            cfg.getPlotConfig().enableEvents();
+            cfg.getPlotConfig().fireUpdate();
+        } 
+    }
+    
+    /**
+     * Unit test stuff
+     * @param args da arsg
+     */
+    public final static void main(String args[]) {
+        Test t = new Test();
+        t.runTest();
+    }
+    
+    private final static class Test implements PeerPlotStateFetcher.FetchStateReceptor {
+        /**
+         * Runs da test
+         */
+        public void runTest() {
+            PeerPlotConfig cfg = new PeerPlotConfig("C:\\testnet\\r2\\heartbeatStat_10s_30kb.txt");
+            PeerPlotState state = new PeerPlotState(cfg);
+            PeerPlotStateFetcher.fetchPeerPlotState(this, state);
+            try { Thread.sleep(60*1000); } catch (InterruptedException ie) {}
+            System.exit(-1);
+        }
+        
+        /* (non-Javadoc)
+         * @see net.i2p.heartbeat.gui.PeerPlotStateFetcher.FetchStateReceptor#peerPlotStateFetched(net.i2p.heartbeat.gui.PeerPlotState)
+         */
+        public void peerPlotStateFetched(PeerPlotState state) {
+            javax.swing.JFrame f = new javax.swing.JFrame("Test");
+            f.getContentPane().add(new JScrollPane(new PeerPlotConfigPane(state.getPlotConfig(), null)));
+            f.pack();
+            f.setVisible(true);
+        }
+    }
+}

apps/heartbeat/java/src/net/i2p/heartbeat/gui/PeerPlotState.java

@@ -0,0 +1,95 @@
+package net.i2p.heartbeat.gui;
+
+
+/**
+ * Current data + plot config for a particular test
+ * 
+ */
+class PeerPlotState {
+    private StaticPeerData _currentData;
+    private PeerPlotConfig _plotConfig;
+    
+    /**
+     * Delegating constructor . . .
+     * @see PeerPlotState#PeerPlotState(PeerPlotConfig, StaticPeerData)
+     */
+    public PeerPlotState() {
+        this(null, null);
+    }
+    
+    /**
+     * Delegating constructor . . .
+     * @param config plot config
+     * @see PeerPlotState#PeerPlotState(PeerPlotConfig, StaticPeerData)
+     */
+    public PeerPlotState(PeerPlotConfig config) {
+        this(config, new StaticPeerData(config.getClientConfig()));
+    }
+    /**
+     * Creates a PeerPlotState
+     * @param config plot config
+     * @param data peer data
+     */
+    public PeerPlotState(PeerPlotConfig config, StaticPeerData data) {
+        _plotConfig = config;
+        _currentData = data;
+    }
+    
+    /**
+     * Add an average
+     * @param minutes mins averaged over
+     * @param sendMs how much later did the peer receieve
+     * @param recvMs how much later did we receieve
+     * @param lost how many were lost
+     */
+    public void addAverage(int minutes, int sendMs, int recvMs, int lost) {
+        // make sure we've got the config entry for the average
+        _plotConfig.addAverage(minutes);
+        // add the data point...
+        _currentData.addAverage(minutes, sendMs, recvMs, lost);
+    }
+    
+    /**
+     * we successfully got a ping/pong through
+     *
+     * @param sendTime when did the ping get sent?
+     * @param sendMs how much later did the peer receive the ping?
+     * @param recvMs how much later than that did we receive the pong? 
+     */
+    public void addSuccess(long sendTime, int sendMs, int recvMs) {
+        _currentData.addData(sendTime, sendMs, recvMs);
+    }
+    
+    /**
+     * we lost a ping/pong
+     *
+     * @param sendTime when did we send the ping?
+     */
+    public void addLost(long sendTime) {
+        _currentData.addData(sendTime);
+    }
+    
+    /**
+     * data set to render 
+     * @return the data set
+     */
+    public StaticPeerData getCurrentData() { return _currentData; }
+
+    /**
+     * Sets the data set to render
+     * @param data the data set
+     */
+    public void setCurrentData(StaticPeerData data) { _currentData = data; }
+    
+    /**
+     * configuration options on how to render the data set 
+     * @return the config options
+     */
+    public PeerPlotConfig getPlotConfig() { return _plotConfig; }
+
+    /**
+     * Sets the configuration options on how to render the data
+     * @param config the config options
+     */
+    public void setPlotConfig(PeerPlotConfig config) { _plotConfig = config; }
+}

apps/heartbeat/java/src/net/i2p/heartbeat/gui/PeerPlotStateFetcher.java

@@ -0,0 +1,363 @@
+package net.i2p.heartbeat.gui;
+
+import java.io.BufferedReader;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Locale;
+import java.util.StringTokenizer;
+
+import net.i2p.data.DataFormatException;
+import net.i2p.data.Destination;
+import net.i2p.util.I2PThread;
+import net.i2p.util.Log;
+
+class PeerPlotStateFetcher {
+    private final static Log _log = new Log(PeerPlotStateFetcher.class);
+    
+    /**
+     * Fetch and fill the specified state structure
+     * @param receptor the 'receptor' (callbacks)
+     * @param state the state
+     */
+    public static void fetchPeerPlotState(FetchStateReceptor receptor, PeerPlotState state) {
+        I2PThread t = new I2PThread(new Fetcher(receptor, state));
+        t.setDaemon(true);
+        t.setName("Fetch state from " + state.getPlotConfig().getLocation());
+        t.start();
+    }
+    
+    /**
+     * Callback stuff . . .
+     */
+    public interface FetchStateReceptor {
+        /**
+         * Called when a peer plot state is fetched
+         * @param state state that was fetched
+         */
+        void peerPlotStateFetched(PeerPlotState state);
+    }
+    
+    private static class Fetcher implements Runnable {
+        private PeerPlotState _state;
+        private FetchStateReceptor _receptor;
+
+        /**
+         * Creates a Fetcher thread
+         * @param receptor the 'receptor' (callbacks)
+         * @param state the state
+         */
+        public Fetcher(FetchStateReceptor receptor, PeerPlotState state) {
+            _state = state;
+            _receptor = receptor;
+        }
+        
+        /* (non-Javadoc)
+         * @see java.lang.Runnable#run()
+         */
+        public void run() {
+            String loc = _state.getPlotConfig().getLocation();
+            _log.debug("Load called [" + loc + "]");
+            InputStream in = null;
+            try {
+                try {
+                    URL location = new URL(loc);
+                    in = location.openStream();
+                } catch (MalformedURLException mue) {
+                    _log.debug("Not a url [" + loc + "]");
+                    in = null;
+                }
+                
+                if (in == null)
+                    in = new FileInputStream(loc);
+                
+                BufferedReader reader = new BufferedReader(new InputStreamReader(in));
+                String line = null;
+                while ( (line = reader.readLine()) != null) {
+                    handleLine(line);
+                }
+                
+                if (valid())
+                    _receptor.peerPlotStateFetched(_state);
+            } catch (IOException ioe) {
+                _log.error("Error retrieving from the location [" + loc + "]", ioe);
+            } finally {
+                if (in != null) try { in.close(); } catch (IOException ioe) {}
+            }
+        }
+        
+        /** 
+         * check to make sure we've got everything we need 
+         * @return true [always]
+         */
+        boolean valid() {
+            return true;
+        }
+        
+        /**
+         * handle a line from the data set - these can be formatted in one of the
+         * following ways.  <p />
+         *
+         * <pre>
+         * peer            khWYqCETu9YtPUvGV92ocsbEW5DezhKlIG7ci8RLX3g=
+         * local           u-9hlR1ik2hemXf0HvKMfeRgrS86CbNQh25e7XBhaQE=
+         * peerDest        [base 64 of the full destination]
+         * localDest       [base 64 of the full destination]
+         * numTunnelHops   2
+         * comment         Test with localhost sending 30KB every 20 seconds
+         * sendFrequency   20
+         * sendSize        30720
+         * sessionStart    20040409.22:51:10.915
+         * currentTime     20040409.23:31:39.607
+         * numPending      2
+         * lifetimeSent    118
+         * lifetimeRecv    113
+         * #averages       minutes sendMs  recvMs  numLost
+         * periodAverage   1       1843    771     0
+         * periodAverage   5       786     752     1
+         * periodAverage   30      855     735     3
+         * #action status  date and time sent      sendMs  replyMs
+         * EVENT   OK      20040409.23:21:44.742   691     670
+         * EVENT   OK      20040409.23:22:05.201   671     581
+         * EVENT   OK      20040409.23:22:26.301   1182    1452
+         * EVENT   OK      20040409.23:22:47.322   24304   1723
+         * EVENT   OK      20040409.23:23:08.232   2293    1081
+         * EVENT   OK      20040409.23:23:29.332   1392    641
+         * EVENT   OK      20040409.23:23:50.262   641     761
+         * EVENT   OK      20040409.23:24:11.102   651     701
+         * EVENT   OK      20040409.23:24:31.401   841     621
+         * EVENT   OK      20040409.23:24:52.061   651     681
+         * EVENT   OK      20040409.23:25:12.480   701     1623
+         * EVENT   OK      20040409.23:25:32.990   1442    1212
+         * EVENT   OK      20040409.23:25:54.230   591     631
+         * EVENT   OK      20040409.23:26:14.620   620     691
+         * EVENT   OK      20040409.23:26:35.199   1793    1432
+         * EVENT   OK      20040409.23:26:56.570   661     641
+         * EVENT   OK      20040409.23:27:17.200   641     660
+         * EVENT   OK      20040409.23:27:38.120   611     921
+         * EVENT   OK      20040409.23:27:58.699   831     621
+         * EVENT   OK      20040409.23:28:19.559   801     661
+         * EVENT   OK      20040409.23:28:40.279   601     611
+         * EVENT   OK      20040409.23:29:00.648   601     621
+         * EVENT   OK      20040409.23:29:21.288   701     661
+         * EVENT   LOST    20040409.23:29:41.828
+         * EVENT   LOST    20040409.23:30:02.327
+         * EVENT   LOST    20040409.23:30:22.656
+         * EVENT   OK      20040409.23:31:24.305   1843    771
+         * </pre>
+         * 
+         * @param line (see above)
+         */
+        private void handleLine(String line) {
+            if (line.startsWith("peerDest"))
+                handlePeerDest(line);
+            else if (line.startsWith("localDest"))
+                handleLocalDest(line);
+            else if (line.startsWith("numTunnelHops"))
+                handleNumTunnelHops(line);
+            else if (line.startsWith("comment"))
+                handleComment(line);
+            else if (line.startsWith("sendFrequency"))
+                handleSendFrequency(line);
+            else if (line.startsWith("sendSize"))
+                handleSendSize(line);
+            else if (line.startsWith("periodAverage"))
+                handlePeriodAverage(line);
+            else if (line.startsWith("EVENT"))
+                handleEvent(line);
+            else if (line.startsWith("numPending"))
+                handleNumPending(line);
+            else if (line.startsWith("sessionStart"))
+                handleSessionStart(line);
+            else
+                _log.debug("Not handled: " + line);
+        }
+        
+        private void handlePeerDest(String line) {
+            StringTokenizer tok = new StringTokenizer(line);
+            tok.nextToken(); // ignore;
+            String destKey = tok.nextToken();
+            try {
+                Destination d = new Destination();
+                d.fromBase64(destKey);
+                _state.getPlotConfig().getClientConfig().setPeer(d);
+                _log.debug("Setting the peer to " + d.calculateHash().toBase64());
+            } catch (DataFormatException dfe) {
+                _log.error("Unable to parse the peerDest line: [" + line + "]", dfe);
+            }
+        }
+        
+        private void handleLocalDest(String line) {
+            StringTokenizer tok = new StringTokenizer(line);
+            tok.nextToken(); // ignore;
+            String destKey = tok.nextToken();
+            try {
+                Destination d = new Destination();
+                d.fromBase64(destKey);
+                _state.getPlotConfig().getClientConfig().setUs(d);
+            } catch (DataFormatException dfe) {
+                _log.error("Unable to parse the localDest line: [" + line + "]", dfe);
+            }
+        }
+        
+        private void handleComment(String line) {
+            StringTokenizer tok = new StringTokenizer(line);
+            tok.nextToken(); // ignore;
+            StringBuffer buf = new StringBuffer(line.length()-32);
+            while (tok.hasMoreTokens())
+                buf.append(tok.nextToken()).append(' ');
+            _state.getPlotConfig().getClientConfig().setComment(buf.toString());
+        }
+        
+        private void handleNumTunnelHops(String line) {
+            StringTokenizer tok = new StringTokenizer(line);
+            tok.nextToken(); // ignore;
+            String num = tok.nextToken();
+            try {
+                int val = Integer.parseInt(num);
+                _state.getPlotConfig().getClientConfig().setNumHops(val);
+            } catch (NumberFormatException nfe) {
+                _log.error("Unable to parse the numTunnelHops line: [" + line + "]", nfe);
+            }
+        }
+        
+        private void handleNumPending(String line) {
+            StringTokenizer tok = new StringTokenizer(line);
+            tok.nextToken(); // ignore;
+            String num = tok.nextToken();
+            try {
+                int val = Integer.parseInt(num);
+                _state.getCurrentData().setPendingCount(val);
+            } catch (NumberFormatException nfe) {
+                _log.error("Unable to parse the numPending line: [" + line + "]", nfe);
+            }
+        }
+        
+        private void handleSendFrequency(String line) {
+            StringTokenizer tok = new StringTokenizer(line);
+            tok.nextToken(); // ignore;
+            String num = tok.nextToken();
+            try {
+                int val = Integer.parseInt(num);
+                _state.getPlotConfig().getClientConfig().setSendFrequency(val);
+            } catch (NumberFormatException nfe) {
+                _log.error("Unable to parse the sendFrequency line: [" + line + "]", nfe);
+            }
+        }
+        
+        private void handleSendSize(String line) {
+            StringTokenizer tok = new StringTokenizer(line);
+            tok.nextToken(); // ignore;
+            String num = tok.nextToken();
+            try {
+                int val = Integer.parseInt(num);
+                _state.getPlotConfig().getClientConfig().setSendSize(val);
+            } catch (NumberFormatException nfe) {
+                _log.error("Unable to parse the sendSize line: [" + line + "]", nfe);
+            }
+        }
+        
+        private void handleSessionStart(String line) {
+            StringTokenizer tok = new StringTokenizer(line);
+            tok.nextToken(); // ignore;
+            String date = tok.nextToken();
+            try {
+                long when = getDate(date);
+                _state.getCurrentData().setSessionStart(when);
+            } catch (NumberFormatException nfe) {
+                _log.error("Unable to parse the sessionStart line: [" + line + "]", nfe);
+            }
+        }
+        
+        private void handlePeriodAverage(String line) {
+            StringTokenizer tok = new StringTokenizer(line);
+            tok.nextToken(); // ignore;
+            try {
+                // periodAverage minutes sendMs  recvMs  numLost
+                int min = Integer.parseInt(tok.nextToken());
+                int send = Integer.parseInt(tok.nextToken());
+                int recv = Integer.parseInt(tok.nextToken());
+                int lost = Integer.parseInt(tok.nextToken());
+                _state.addAverage(min, send, recv, lost);
+            } catch (NumberFormatException nfe) {
+                _log.error("Unable to parse the sendSize line: [" + line + "]", nfe);
+            }
+        }
+        
+        private void handleEvent(String line) {
+            StringTokenizer tok = new StringTokenizer(line);
+            
+            // * EVENT   OK      20040409.23:29:21.288   701     661
+            // * EVENT   LOST    20040409.23:29:41.828
+            tok.nextToken(); // ignore first two
+            tok.nextToken();
+            try {
+                long when = getDate(tok.nextToken());
+                if (when < 0) {
+                    _log.error("Invalid EVENT line: [" + line + "]");
+                    return;
+                }
+                if (tok.hasMoreTokens()) {
+                    int sendMs = Integer.parseInt(tok.nextToken());
+                    int recvMs = Integer.parseInt(tok.nextToken());
+                    _state.addSuccess(when, sendMs, recvMs);
+                } else {
+                    _state.addLost(when);
+                }
+            } catch (NumberFormatException nfe) {
+                _log.error("Unable to parse the EVENT line: [" + line + "]", nfe);
+            }
+        }
+        
+        private static final SimpleDateFormat _fmt = new SimpleDateFormat("yyyyMMdd.HH:mm:ss.SSS", Locale.UK);
+        private long getDate(String date) {
+            synchronized (_fmt) {
+                try {
+                    return _fmt.parse(date).getTime();
+                } catch (ParseException pe) {
+                    _log.error("Unable to parse the date [" + date + "]", pe);
+                    return -1;
+                }
+            }
+        }
+        
+        private void fakeRun() { /* UNUSED */
+            try {
+                Destination peer = new Destination();
+                Destination us = new Destination();
+                peer.fromBase64("3RPLOkQGlq8anNyNWhjbMyHxpAvUyUJKbiUejI80DnPR59T3blc7-XrBhQ2iPbf-BRAR~v1j34Kpba1eDyhPk2gevsE6ULO1irarJ3~C9WcQH2wAbNiVwfWqbh6onQ~YmkSpGNwGHD6ytwbvTyXeBJ" +
+                                "cS8e6gmfNN-sYLn1aQu8UqWB3D6BmTfLtyS3eqWVk66Nrzmwy8E1Hvq5z~1lukYb~cyiDO1oZHAOLyUQtd9eN16yJY~2SRG8LiscpPMl9nSJUr6fmXMUubW-M7QGFH82Om-735PJUk6WMy1Hi9Vgh4Pxhdl7g" +
+                                "fqGRWioFABdhcypb7p1Ca77p73uabLDFK-SjIYmdj7TwSdbNa6PCmzEvCEW~IZeZmnZC5B6pK30AdmD9vc641wUGce9xTJVfNRupf5L7pSsVIISix6FkKQk-FTW2RsZKLbuMCYMaPzLEx5gzODEqtI6Jf2teM" +
+                                "d5xCz51RPayDJl~lJ-W0IWYfosnjM~KxYaqc4agviBuF5ZWeAAAA");
+                us.fromBase64("W~JFpqSH8uopylox2V5hMbpcHSsb-dJkSKvdJ1vj~KQcUFJWXFyfbetBAukcGH5S559aK9oslU0qbVoMDlJITVC4OXfXSnVbJBP1IhsK8SvjSYicjmIi2fA~k4HvSh9Wxu~bg8yo~jgfHA8tjYpp" +
+                              "K9QKc56BpkJb~hx0nNGy4Ny9eW~6A5AwAmHvwdt5NqcREYRMjRd63dMGm8BcEe-6FbOyMo3dnIFcETWAe8TCeoMxm~S1n~6Jlinw3ETxv-L6lQkhFFWnC5zyzQ~4JhVxxT3taTMYXg8td4CBGmrS078jcjW63" +
+                              "rlSiQgZBlYfN3iEYmurhuIEV9NXRcmnMrBOQUAoXPpVuRIxJbaQNDL71FO2iv424n4YjKs84suAho34GGQKq7WoL5V5KQgihfcl0f~xne-qP3FtpoPFeyA9x-sA2JWDAsxoZlfvgkiP5eyOn23prT9TJK47HC" +
+                              "VilHSV11uTVaC4Jc5YsjoBCZadWbgQnMCKlZ4jk-bLE1PSWLg7AAAA");
+                _state.getPlotConfig().getClientConfig().setPeer(peer);
+                _state.getPlotConfig().getClientConfig().setUs(us);
+                _state.getPlotConfig().getClientConfig().setNumHops(2);
+                _state.getPlotConfig().getClientConfig().setComment("we do stuff\nreally nifty stuff.  really");
+                _state.getPlotConfig().getClientConfig().setAveragePeriods(new int[] { 1, 5, 30, 60 });
+                int rnd = new java.util.Random().nextInt();
+                if (rnd > 0) 
+                    rnd = rnd % 10;
+                else
+                    rnd = (-rnd) % 10;
+                _state.getPlotConfig().getClientConfig().setSendFrequency(rnd);
+                _state.getPlotConfig().getClientConfig().setSendSize(16*1024);
+                _state.getPlotConfig().getClientConfig().setStatDuration(10);
+                _state.getPlotConfig().rebuildAverageSeriesConfigs();
+                _state.setCurrentData(new StaticPeerData(_state.getPlotConfig().getClientConfig()));
+                
+                _receptor.peerPlotStateFetched(_state);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+    }
+}

apps/heartbeat/java/src/net/i2p/heartbeat/gui/StaticPeerData.java

@@ -0,0 +1,134 @@
+package net.i2p.heartbeat.gui;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import net.i2p.heartbeat.ClientConfig;
+import net.i2p.heartbeat.PeerData;
+
+/**
+ * Raw data points for a test
+ */
+class StaticPeerData extends PeerData {
+    private int _pending;
+    /** Integer (period, in minutes) to Integer (milliseconds) for sending a ping */
+    private Map _averageSendTimes;
+    /** Integer (period, in minutes) to Integer (milliseconds) for receiving a pong */
+    private Map _averageReceiveTimes;
+    /** Integer (period, in minutes) to Integer (num messages) of how many messages were lost on average */
+    private Map _lostMessages;
+    
+    /**
+     * Creates a static peer data with a specified client config ... duh
+     * @param config the client config
+     */
+    public StaticPeerData(ClientConfig config) {
+        super(config);
+        _averageSendTimes = new HashMap(4);
+        _averageReceiveTimes = new HashMap(4);
+        _lostMessages = new HashMap(4);
+    }
+    
+    /**
+     * Adds averaged data
+     * @param minutes the minutes (averaged over)
+     * @param sendMs the send time (ping) in milliseconds
+     * @param recvMs the receive time (pong) in milliseconds
+     * @param lost the number lost
+     */
+    public void addAverage(int minutes, int sendMs, int recvMs, int lost) {
+        _averageSendTimes.put(new Integer(minutes), new Integer(sendMs));
+        _averageReceiveTimes.put(new Integer(minutes), new Integer(recvMs));
+        _lostMessages.put(new Integer(minutes), new Integer(lost));
+    }
+    
+    /**
+     * Sets the number pending
+     * @param numPending the number pending
+     */
+    public void setPendingCount(int numPending) { _pending = numPending; }
+
+    /* (non-Javadoc)
+     * @see net.i2p.heartbeat.PeerData#setSessionStart(long)
+     */
+    public void setSessionStart(long when) { super.setSessionStart(when); }
+    
+    /**
+     * Adds data
+     * @param sendTime the time it was sent
+     * @param sendMs the send time (ping) in milliseconds
+     * @param recvMs the receive time (pong) in milliseconds
+     */
+    public void addData(long sendTime, int sendMs, int recvMs) {
+        PeerData.EventDataPoint dataPoint = new PeerData.EventDataPoint(sendTime);
+        dataPoint.setPongSent(sendTime + sendMs);
+        dataPoint.setPongReceived(sendTime + sendMs + recvMs);
+        dataPoint.setWasPonged(true);
+        addDataPoint(dataPoint);
+    }
+    
+    /**
+     * Adds data
+     * @param sendTime the time it was sent
+     */
+    public void addData(long sendTime) {
+        PeerData.EventDataPoint dataPoint = new PeerData.EventDataPoint(sendTime);
+        dataPoint.setWasPonged(false);
+        addDataPoint(dataPoint);
+    }
+
+    /** 
+     * how many pings are still outstanding?
+     * @return the number of pings outstanding
+     */
+    public int getPendingCount() { return _pending; }
+    
+    
+    /** 
+     * average time to send over the given period.
+     *
+     * @param period number of minutes to retrieve the average for
+     * @return milliseconds average, or -1 if we dont track that period
+     */
+    public double getAverageSendTime(int period) { 
+        Integer i = (Integer)_averageSendTimes.get(new Integer(period));
+        if (i == null)
+            return -1;
+
+        return i.doubleValue();
+    }
+    
+    
+    /** 
+     * average time to receive over the given period.
+     *
+     * @param period number of minutes to retrieve the average for
+     * @return milliseconds average, or -1 if we dont track that period
+     */
+    public double getAverageReceiveTime(int period) {
+        Integer i = (Integer)_averageReceiveTimes.get(new Integer(period));
+        if (i == null)
+            return -1;
+
+        return i.doubleValue();
+    }
+       
+    /** 
+     * number of lost messages over the given period.
+     *
+     * @param period number of minutes to retrieve the average for
+     * @return number of lost messages in the period, or -1 if we dont track that period
+     */
+    public double getLostMessages(int period) {
+        Integer i = (Integer)_lostMessages.get(new Integer(period));
+        if (i == null)
+            return -1;
+
+        return i.doubleValue();
+    }
+        
+    /* (non-Javadoc)
+     * @see net.i2p.heartbeat.PeerData#cleanup()
+     */
+    public void cleanup() {}
+}

apps/httptunnel/java/build.xml

@@ -4,7 +4,7 @@
     <target name="build" depends="builddep, jar" />
     <target name="builddep">
         <ant dir="../../ministreaming/java/" target="build" />
-        <ant dir="../../../core/java/" target="build" />
+	<!-- ministreaming will build core -->
     </target>
     <target name="compile">
         <mkdir dir="./build" />
@@ -37,11 +37,11 @@
         <delete dir="./build" />
     </target>
     <target name="cleandep" depends="clean">
-        <ant dir="../../../core/java/" target="cleandep" />
+	<!-- ministreaming will clean core -->
         <ant dir="../../ministreaming/java/" target="distclean" />
     </target>
     <target name="distclean" depends="clean">
-        <ant dir="../../../core/java/" target="distclean" />
+	<!-- ministreaming will clean core -->
         <ant dir="../../ministreaming/java/" target="distclean" />
     </target>
 </project>

apps/httptunnel/java/src/net/i2p/httptunnel/HTTPListener.java

@@ -19,49 +19,69 @@ public class HTTPListener extends Thread {
     private String listenHost;
     private SocketManagerProducer smp;
 
-    public HTTPListener(SocketManagerProducer smp, int port,
-			String listenHost) {
-	this.smp = smp;
-	this.port = port;
-	start();
+    /**
+     * A public constructor.  It contstructs things.  In this case, 
+     * it constructs a nice HTTPListener, for all your listening on
+     * HTTP needs.  Yep.  That's right.
+     * @param smp A SocketManagerProducer, producing Sockets, no doubt
+     * @param port A port, to connect to.
+     * @param listenHost A host, to connect to.
+     */
+
+    public HTTPListener(SocketManagerProducer smp, int port, String listenHost) {
+        this.smp = smp;
+        this.port = port;
+        start();
     }
-    
+
+    /* (non-Javadoc)
+     * @see java.lang.Thread#run()
+     */
     public void run() {
-	try {
-	    InetAddress lh = listenHost == null
-		? null
-		: InetAddress.getByName(listenHost);
-	    ServerSocket ss = new ServerSocket(port, 0, lh);
-	    while(true) {
-		Socket s = ss.accept();
-		new HTTPSocketHandler(this, s);
-	    }
-	} catch (IOException ex) {
-	    _log.error("Error while accepting connections", ex);
-	}
+        try {
+            InetAddress lh = listenHost == null ? null : InetAddress.getByName(listenHost);
+            ServerSocket ss = new ServerSocket(port, 0, lh);
+            while (true) {
+                Socket s = ss.accept();
+                new HTTPSocketHandler(this, s);
+            }
+        } catch (IOException ex) {
+            _log.error("Error while accepting connections", ex);
+        }
     }
 
-    private boolean proxyUsed=false;
-    
+    private boolean proxyUsed = false;
+
+    /**
+     * Query whether this is the first use of the proxy or not
+     * @return Whether this is the first proxy use, no doubt.
+     */
     public boolean firstProxyUse() {
-	// FIXME: check a config option here
-	if (true) return false;
-	if (proxyUsed) {
-	    return false;
-	} else {
-	    proxyUsed=true;
-	    return true;
-	}
+        if (true) return false; // FIXME: check a config option here
+        
+        if (proxyUsed) {
+            return false;
+        }
+
+        proxyUsed = true;
+        return true;
     }
 
+    /**
+     * @return The SocketManagerProducer being used.
+     */
     public SocketManagerProducer getSMP() {
-	return smp;
+        return smp;
     }
 
-    /** @deprecated */
+    /** 
+     * Outputs with HTTP 1.1 flair that a feature isn't implemented.
+     * @param out The stream the text goes to.
+     * @deprecated
+     * @throws IOException
+     */
     public void handleNotImplemented(OutputStream out) throws IOException {
-	out.write(("HTTP/1.1 200 Document following\n\n"+
-		  "<h1>Feature not implemented</h1>").getBytes("ISO-8859-1"));
-	out.flush();
+        out.write(("HTTP/1.1 200 Document following\n\n" + "<h1>Feature not implemented</h1>").getBytes("ISO-8859-1"));
+        out.flush();
     }
-}
+}

apps/httptunnel/java/src/net/i2p/httptunnel/HTTPSocketHandler.java

@@ -21,34 +21,42 @@ public class HTTPSocketHandler extends Thread {
     private HTTPListener httpl;
     private RootHandler h;
 
+    /**
+     * A public constructor.
+     * @param httpl An HTTPListener, to listen for HTTP, no doubt
+     * @param s A socket.
+     */
     public HTTPSocketHandler(HTTPListener httpl, Socket s) {
-	this.httpl = httpl;
-	this.s=s;
-	h = RootHandler.getInstance();
-	start();
+        this.httpl = httpl;
+        this.s = s;
+        h = RootHandler.getInstance();
+        start();
     }
-    
+
+    /* (non-Javadoc)
+     * @see java.lang.Thread#run()
+     */
     public void run() {
-	InputStream in = null;
-	OutputStream out = null;
-	try {
-	    in = new BufferedInputStream(s.getInputStream());
-	    out = new BufferedOutputStream(s.getOutputStream());
-	    Request req = new Request(in);
-	    h.handle(req, httpl, out);
-	} catch (IOException ex) {
-	    _log.error("Error while handling data", ex);
-	} finally {
-	    try {
-		if (in != null) in.close();
-		if (out != null) {
-		    out.flush();
-		    out.close();
-		}
-		s.close();
-	    } catch (IOException ex) {
-		_log.error("IOException in finalizer", ex);
-	    }
-	}
+        InputStream in = null;
+        OutputStream out = null;
+        try {
+            in = new BufferedInputStream(s.getInputStream());
+            out = new BufferedOutputStream(s.getOutputStream());
+            Request req = new Request(in);
+            h.handle(req, httpl, out);
+        } catch (IOException ex) {
+            _log.error("Error while handling data", ex);
+        } finally {
+            try {
+                if (in != null) in.close();
+                if (out != null) {
+                    out.flush();
+                    out.close();
+                }
+                s.close();
+            } catch (IOException ex) {
+                _log.error("IOException in finalizer", ex);
+            }
+        }
     }
-}
+}

apps/httptunnel/java/src/net/i2p/httptunnel/HTTPTunnel.java

@@ -41,13 +41,12 @@ public class HTTPTunnel {
      * 
      * @param initialManagers a list of socket managers to use
      * @param maxManagers how many managers to have in the cache
-     * @param mcDonaldsMode whether to throw away a manager after use
+     * @param shouldThrowAwayManagers whether to throw away a manager after use
      * @param listenPort which port to listen on
      */
-    public HTTPTunnel(I2PSocketManager[] initialManagers, int maxManagers,
-		      boolean mcDonaldsMode, int listenPort) {
-	this(initialManagers, maxManagers, mcDonaldsMode, listenPort,
-	     "127.0.0.1", 7654);
+    public HTTPTunnel(I2PSocketManager[] initialManagers, int maxManagers, boolean shouldThrowAwayManagers,
+                      int listenPort) {
+        this(initialManagers, maxManagers, shouldThrowAwayManagers, listenPort, "127.0.0.1", 7654);
     }
 
     /**
@@ -55,56 +54,55 @@ public class HTTPTunnel {
      * 
      * @param initialManagers a list of socket managers to use
      * @param maxManagers how many managers to have in the cache
-     * @param mcDonaldsMode whether to throw away a manager after use
+     * @param shouldThrowAwayManagers whether to throw away a manager after use
      * @param listenPort which port to listen on
      * @param i2cpAddress the I2CP address
      * @param i2cpPort the I2CP port
      */
-    public HTTPTunnel(I2PSocketManager[] initialManagers, int maxManagers,
-		      boolean mcDonaldsMode, int listenPort,
-		      String i2cpAddress, int i2cpPort) {
-	SocketManagerProducer smp = 
-	    new SocketManagerProducer(initialManagers, maxManagers,
-				      mcDonaldsMode, i2cpAddress, i2cpPort);
-	new HTTPListener(smp, listenPort, "127.0.0.1");
+    public HTTPTunnel(I2PSocketManager[] initialManagers, int maxManagers, boolean shouldThrowAwayManagers,
+                      int listenPort, String i2cpAddress, int i2cpPort) {
+        SocketManagerProducer smp = new SocketManagerProducer(initialManagers, maxManagers, shouldThrowAwayManagers,
+                                                              i2cpAddress, i2cpPort);
+        new HTTPListener(smp, listenPort, "127.0.0.1");
     }
-    
+
+    /**
+     * The all important main function, allowing HTTPTunnel to be 
+     * stand-alone, a program in it's own right, and all that jazz.
+     * @param args A list of String passed to the program
+     */
     public static void main(String[] args) {
-	String host = "127.0.0.1";
-	int port = 7654, max = 1;
-	boolean mc = false;
-	if (args.length >1) {
-	    if (args.length == 4) {
-		host = args[2];
-		port = Integer.parseInt(args[3]);
-	    } else if (args.length != 2) {
-		showInfo(); return;
-	    }
-	    max = Integer.parseInt(args[1]);
-	} else if (args.length != 1) {
-	    showInfo(); return;
-	}
-	if (max == 0) {
-	    max = 1;
-	} else if (max <0) {
-	    max = -max;
-	    mc = true;
-	}
-	new HTTPTunnel(null, max, mc, Integer.parseInt(args[0]), host, port);
+        String host = "127.0.0.1";
+        int port = 7654, max = 1;
+        boolean throwAwayManagers = false;
+        if (args.length > 1) {
+            if (args.length == 4) {
+                host = args[2];
+                port = Integer.parseInt(args[3]);
+            } else if (args.length != 2) {
+                showInfo();
+                return;
+            }
+            max = Integer.parseInt(args[1]);
+        } else if (args.length != 1) {
+            showInfo();
+            return;
+        }
+        if (max == 0) {
+            max = 1;
+        } else if (max < 0) {
+            max = -max;
+            throwAwayManagers = true;
+        }
+        new HTTPTunnel(null, max, throwAwayManagers, Integer.parseInt(args[0]), host, port);
     }
-	    
+
     private static void showInfo() {
-	System.out.println
-	    ("Usage: java HTTPTunnel <listenPort> [<max> "+
-	     "[<i2cphost> <i2cpport>]]\n"+
-	     "  <listenPort>  port to listen for browsers\n"+
-	     "  <max>         max number of SocketMangers in pool, "+
-	     "use neg. number\n"+
-	     "                to use each SocketManager only once "+
-	     "(default: 1)\n"+
-	     "  <i2cphost>    host to connect to the router "+
-	     "(default: 127.0.0.1)\n"+
-	     "  <i2cpport>    port to connect to the router "+
-	     "(default: 7654)");
+        System.out.println("Usage: java HTTPTunnel <listenPort> [<max> " + "[<i2cphost> <i2cpport>]]\n"
+                           + "  <listenPort>  port to listen for browsers\n"
+                           + "  <max>         max number of SocketMangers in pool, " + "use neg. number\n"
+                           + "                to use each SocketManager only once " + "(default: 1)\n"
+                           + "  <i2cphost>    host to connect to the router " + "(default: 127.0.0.1)\n"
+                           + "  <i2cpport>    port to connect to the router " + "(default: 7654)");
     }
-}
+}

apps/httptunnel/java/src/net/i2p/httptunnel/Request.java

@@ -22,109 +22,132 @@ public class Request {
     private String proto;
     private String params;
     private String postData;
-    
+
+    /**
+     * A constructor, creating a request from an InputStream
+     * @param in InputStream from which we "read-in" a Request
+     * @throws IOException
+     */
     public Request(InputStream in) throws IOException {
-	BufferedReader br = new BufferedReader
-	    (new InputStreamReader(in, "ISO-8859-1"));
-	String line = br.readLine();
-	if (line == null) { // no data at all
-	    method = null;
-	    _log.error("Connection but no data");
-	    return;
-	}
-	int pos = line.indexOf(" ");
-	if (pos == -1) {
-	    method = line;
-	    url="";
-	    _log.error("Malformed HTTP request: "+line);
-	} else {
-	    method = line.substring(0,pos);
-	    url=line.substring(pos+1);
-	}
-	proto="";
-	pos = url.indexOf(" ");
-	if (pos != -1) {
-	    proto=url.substring(pos); // leading space intended
-	    url = url.substring(0,pos);
-	}
-	StringBuffer sb = new StringBuffer(512);
-	while((line=br.readLine()) != null) {
-	    if (line.length() == 0) break;
-	    sb.append(line).append("\r\n");
-	}
-	params = sb.toString(); // no leading empty line!
-	sb = new StringBuffer();
-	// hack for POST requests, ripped from HttpClient
-	// this won't work for large POSTDATA
-	// FIXME: do this better, please.
-	if (!method.equals("GET")) {
-	    while (br.ready()) { // empty the buffer (POST requests)
-		int i=br.read();
-		if (i != -1) {
-		    sb.append((char)i);
-		    }
-	    }
-	    postData = sb.toString();
-	} else {
-	    postData="";
-	}
+        BufferedReader br = new BufferedReader(new InputStreamReader(in, "ISO-8859-1"));
+        String line = br.readLine();
+        if (line == null) { // no data at all
+            method = null;
+            _log.error("Connection but no data");
+            return;
+        }
+        int pos = line.indexOf(" ");
+        if (pos == -1) {
+            method = line;
+            url = "";
+            _log.error("Malformed HTTP request: " + line);
+        } else {
+            method = line.substring(0, pos);
+            url = line.substring(pos + 1);
+        }
+        proto = "";
+        pos = url.indexOf(" ");
+        if (pos != -1) {
+            proto = url.substring(pos); // leading space intended
+            url = url.substring(0, pos);
+        }
+        StringBuffer sb = new StringBuffer(512);
+        while ((line = br.readLine()) != null) {
+            if (line.length() == 0) break;
+            sb.append(line).append("\r\n");
+        }
+        params = sb.toString(); // no leading empty line!
+        sb = new StringBuffer();
+        // hack for POST requests, ripped from HttpClient
+        // this won't work for large POSTDATA
+        // FIXME: do this better, please.
+        if (!method.equals("GET")) {
+            while (br.ready()) { // empty the buffer (POST requests)
+                int i = br.read();
+                if (i != -1) {
+                    sb.append((char) i);
+                }
+            }
+            postData = sb.toString();
+        } else {
+            postData = "";
+        }
     }
 
+    /**
+     * @return A Request as an array of bytes of a String in ISO-8859-1 format
+     * @throws IOException
+     */
     public byte[] toByteArray() throws IOException {
-	if (method == null) return null;
-	return toISO8859_1String().getBytes("ISO-8859-1");
+        if (method == null) return null;
+        return toISO8859_1String().getBytes("ISO-8859-1");
 
     }
 
     private String toISO8859_1String() throws IOException {
-	if (method == null) return null;
-	return method+" "+url+proto+"\r\n"+params+"\r\n"+postData;
+        if (method == null) return null;
+        return method + " " + url + proto + "\r\n" + params + "\r\n" + postData;
     }
 
+    /**
+     * @return the URL of the request
+     */
     public String getURL() {
-	return url;
+        return url;
     }
 
+    /**
+     * Sets the URL of the Request
+     * @param newURL the new URL
+     */
     public void setURL(String newURL) {
-	url=newURL;
+        url = newURL;
     }
 
+    /**
+     * Retrieves the value of a param.
+     * @param name The name of the param
+     * @return The value of the param, or null
+     */
     public String getParam(String name) {
-	try {
-	    BufferedReader br= new BufferedReader(new StringReader(params));
-	    String line;
-	    while ((line = br.readLine()) != null) {
-		if (line.startsWith(name)) {
-		    return line.substring(name.length());
-		}
-	    }
-	    return null;
-	} catch (IOException ex) {
-	    _log.error("Error getting parameter", ex);
-	    return null;
-	}
+        try {
+            BufferedReader br = new BufferedReader(new StringReader(params));
+            String line;
+            while ((line = br.readLine()) != null) {
+                if (line.startsWith(name)) { return line.substring(name.length()); }
+            }
+            return null;
+        } catch (IOException ex) {
+            _log.error("Error getting parameter", ex);
+            return null;
+        }
     }
 
+    /**
+     * Sets the value of a param.
+     * @param name the name of the param
+     * @param value the value to be set
+     */
     public void setParam(String name, String value) {
-	try {
-	    StringBuffer sb = new StringBuffer(params.length()+value.length());
-	    BufferedReader br= new BufferedReader(new StringReader(params));
-	    String line;
-	    boolean replaced = false;
-	    while((line=br.readLine()) != null) {
-		if (line.startsWith(name)) {
-		    replaced=true;
-		    if (value == null) continue; // kill param
-		    line = name+value;
-		}
-		sb.append(line).append("\r\n");
-	    }
-	    if (!replaced && value != null) {
-		sb.append(name).append(value).append("\r\n");
-	    }
-	    params=sb.toString();
-	} catch (IOException ex) {
-	    _log.error("Error getting parameter", ex);
-	}
+        try {
+            StringBuffer sb = new StringBuffer(params.length() + value.length());
+            BufferedReader br = new BufferedReader(new StringReader(params));
+            String line;
+            boolean replaced = false;
+            while ((line = br.readLine()) != null) {
+                if (line.startsWith(name)) {
+                    replaced = true;
+                    if (value == null) continue; // kill param
+                    line = name + value;
+                }
+                sb.append(line).append("\r\n");
+            }
+            if (!replaced && value != null) {
+                sb.append(name).append(value).append("\r\n");
+            }
+            params = sb.toString();
+        } catch (IOException ex) {
+            _log.error("Error getting parameter", ex);
+        }
     }
-}
+}

apps/httptunnel/java/src/net/i2p/httptunnel/SocketManagerProducer.java

@@ -1,7 +1,12 @@
 package net.i2p.httptunnel;
 
-import java.util.*;
-import net.i2p.client.streaming.*;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Properties;
+
+import net.i2p.client.streaming.I2PSocketManager;
+import net.i2p.client.streaming.I2PSocketManagerFactory;
 
 /**
  * Produces SocketManagers in a thread and gives them to those who
@@ -14,57 +19,58 @@ public class SocketManagerProducer extends Thread {
     private int port;
     private String host;
     private int maxManagers;
-    private boolean mcDonalds;
+    private boolean shouldThrowAwayManagers;
 
-    public SocketManagerProducer(I2PSocketManager[] initialManagers,
-				 int maxManagers,
-				 boolean mcDonaldsMode,
-				 String host, int port) {
-	if (maxManagers < 1) {
-	    throw new IllegalArgumentException("maxManagers < 1");
-	}
-	this.host=host;
-	this.port=port;
-	mcDonalds=mcDonaldsMode;
-	if (initialManagers != null) {
-	    myManagers.addAll(Arrays.asList(initialManagers));
-	}
-	this.maxManagers=maxManagers;
-	mcDonalds=mcDonaldsMode;
-	setDaemon(true);
-	start();
+    /**
+     * Public constructor creating a SocketManagerProducer 
+     * @param initialManagers a list of socket managers to use
+     * @param maxManagers how many managers to have in the cache
+     * @param shouldThrowAwayManagers whether to throw away a manager after use
+     * @param host which host to listen on
+     * @param port which port to listen on
+     */
+    public SocketManagerProducer(I2PSocketManager[] initialManagers, int maxManagers, boolean shouldThrowAwayManagers,
+                                 String host, int port) {
+        if (maxManagers < 1) { throw new IllegalArgumentException("maxManagers < 1"); }
+        this.host = host;
+        this.port = port;
+        this.shouldThrowAwayManagers = shouldThrowAwayManagers;
+        if (initialManagers != null) {
+            myManagers.addAll(Arrays.asList(initialManagers));
+        }
+        this.maxManagers = maxManagers;
+        this.shouldThrowAwayManagers = shouldThrowAwayManagers;
+        setDaemon(true);
+        start();
     }
 
-    
     /**
      * Thread producing new SocketManagers.
      */
     public void run() {
-	while (true) {
-	    synchronized(this) {
-		// without mcDonalds mode, we most probably need no
-		// new managers.
-		while (!mcDonalds && myManagers.size() == maxManagers) {
-		    myWait();
-		}
-	    }
-	    // produce a new manager, regardless whether it is needed
-	    // or not. Do not synchronized this part, since it can be
-	    // quite time-consuming.
-	    I2PSocketManager newManager =
-		I2PSocketManagerFactory.createManager(host, port,
-						      new Properties());
-	    // when done, check if it is needed.
-	    synchronized(this) {
-		while(myManagers.size() == maxManagers) {
-		    myWait();
-		}
-		myManagers.add(newManager);
-		notifyAll();
-	    }
-	}
+        while (true) {
+            synchronized (this) {
+                // without mcDonalds mode, we most probably need no
+                // new managers.
+                while (!shouldThrowAwayManagers && myManagers.size() == maxManagers) {
+                    myWait();
+                }
+            }
+            // produce a new manager, regardless whether it is needed
+            // or not. Do not synchronized this part, since it can be
+            // quite time-consuming.
+            I2PSocketManager newManager = I2PSocketManagerFactory.createManager(host, port, new Properties());
+            // when done, check if it is needed.
+            synchronized (this) {
+                while (myManagers.size() == maxManagers) {
+                    myWait();
+                }
+                myManagers.add(newManager);
+                notifyAll();
+            }
+        }
     }
-    
+
     /**
      * Get a manager for connecting to a given destination. Each
      * destination will always get the same manager.
@@ -73,12 +79,12 @@ public class SocketManagerProducer extends Thread {
      * @return the SocketManager to use
      */
     public synchronized I2PSocketManager getManager(String dest) {
-	I2PSocketManager result = (I2PSocketManager) usedManagers.get(dest);
-	if (result == null) {
-	    result = getManager();
-	    usedManagers.put(dest,result);
-	}
-	return result;
+        I2PSocketManager result = (I2PSocketManager) usedManagers.get(dest);
+        if (result == null) {
+            result = getManager();
+            usedManagers.put(dest, result);
+        }
+        return result;
     }
 
     /**
@@ -89,23 +95,26 @@ public class SocketManagerProducer extends Thread {
      * @return the SocketManager to use
      */
     public synchronized I2PSocketManager getManager() {
-	while (myManagers.size() == 0) {
-	    myWait(); // no manager here, so wait until one is produced
-	}
-	int which = (int)(Math.random()*myManagers.size());
-	I2PSocketManager result = (I2PSocketManager) myManagers.get(which);
-	if (mcDonalds) {
-	    myManagers.remove(which);
-	    notifyAll();
-	}
-	return result;
+        while (myManagers.size() == 0) {
+            myWait(); // no manager here, so wait until one is produced
+        }
+        int which = (int) (Math.random() * myManagers.size());
+        I2PSocketManager result = (I2PSocketManager) myManagers.get(which);
+        if (shouldThrowAwayManagers) {
+            myManagers.remove(which);
+            notifyAll();
+        }
+        return result;
     }
 
+    /**
+     * Wait until InterruptedException
+     */
     public void myWait() {
-	try {
-	    wait();
-	} catch (InterruptedException ex) {
-	    ex.printStackTrace();
-	}
+        try {
+            wait();
+        } catch (InterruptedException ex) {
+            ex.printStackTrace();
+        }
     }
-}
+}

apps/httptunnel/java/src/net/i2p/httptunnel/filter/ChainFilter.java

@@ -1,9 +1,11 @@
 package net.i2p.httptunnel.filter;
 
-import net.i2p.util.Log;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.Collection;
+import java.util.Iterator;
 
-import java.io.*;
-import java.util.*;
+import net.i2p.util.Log;
 
 /**
  * Chain multiple filters. Decorator pattern...
@@ -11,40 +13,49 @@ import java.util.*;
 public class ChainFilter implements Filter {
 
     private static final Log _log = new Log(ChainFilter.class);
-    
-    public Collection filters;
-    
+
+    private Collection filters; // perhaps protected?
+
+    /**
+     * @param filters A collection (list) of filters to chain to
+     */
     public ChainFilter(Collection filters) {
-	this.filters=filters;
+        this.filters = filters;
     }
 
+    /* (non-Javadoc)
+     * @see net.i2p.httptunnel.filter.Filter#filter(byte[])
+     */
     public byte[] filter(byte[] toFilter) {
-	byte[] buf = toFilter;
-	for (Iterator it = filters.iterator(); it.hasNext();) {
-	    Filter f = (Filter) it.next();
-	    buf = f.filter(buf);
-	}
-	return buf;
+        byte[] buf = toFilter;
+        for (Iterator it = filters.iterator(); it.hasNext();) {
+            Filter f = (Filter) it.next();
+            buf = f.filter(buf);
+        }
+        return buf;
     }
 
+    /* (non-Javadoc)
+     * @see net.i2p.httptunnel.filter.Filter#finish()
+     */
     public byte[] finish() {
-	// this is a bit complicated. Think about it...
-	try {
-	    byte[] buf = EMPTY;
-	    for (Iterator it = filters.iterator(); it.hasNext();) {
-		Filter f = (Filter) it.next();
-		ByteArrayOutputStream baos = new ByteArrayOutputStream();
-		if (buf.length != 0) {
-		    baos.write(f.filter(buf));
-		}
-		baos.write(f.finish());
-	    buf = baos.toByteArray();
-	    }
-	    return buf;
-	} catch (IOException ex) {
-	    _log.error("Error chaining filters", ex);
-	    return EMPTY;
-	}
+        // this is a bit complicated. Think about it...
+        try {
+            byte[] buf = EMPTY;
+            for (Iterator it = filters.iterator(); it.hasNext();) {
+                Filter f = (Filter) it.next();
+                ByteArrayOutputStream baos = new ByteArrayOutputStream();
+                if (buf.length != 0) {
+                    baos.write(f.filter(buf));
+                }
+                baos.write(f.finish());
+                buf = baos.toByteArray();
+            }
+            return buf;
+        } catch (IOException ex) {
+            _log.error("Error chaining filters", ex);
+            return EMPTY;
+        }
     }
-	
-}
+
+}

apps/httptunnel/java/src/net/i2p/httptunnel/filter/Filter.java

@@ -12,11 +12,14 @@ public interface Filter {
 
     /**
      * Filter some data. Not all filtered data need to be returned.
+     * @param toFilter the bytes that are to be filtered.
+     * @return the filtered data
      */
     public byte[] filter(byte[] toFilter);
 
     /**
      * Data stream has finished. Return all of the rest data.
+     * @return the rest of the data
      */
     public byte[] finish();
-}
+}

apps/httptunnel/java/src/net/i2p/httptunnel/filter/NullFilter.java

@@ -5,11 +5,17 @@ package net.i2p.httptunnel.filter;
  */
 public class NullFilter implements Filter {
 
+    /* (non-Javadoc)
+     * @see net.i2p.httptunnel.filter.Filter#filter(byte[])
+     */
     public byte[] filter(byte[] toFilter) {
-	return toFilter;
+        return toFilter;
     }
 
+    /* (non-Javadoc)
+     * @see net.i2p.httptunnel.filter.Filter#finish()
+     */
     public byte[] finish() {
-	return EMPTY;
+        return EMPTY;
     }
-}
+}

apps/httptunnel/java/src/net/i2p/httptunnel/handler/EepHandler.java

@@ -1,12 +1,14 @@
 package net.i2p.httptunnel.handler;
+
 import java.io.BufferedInputStream;
 import java.io.BufferedOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
+import java.net.SocketException;
 
+import net.i2p.I2PAppContext;
 import net.i2p.I2PException;
-import net.i2p.client.naming.NamingService;
 import net.i2p.client.streaming.I2PSocket;
 import net.i2p.client.streaming.I2PSocketManager;
 import net.i2p.client.streaming.I2PSocketOptions;
@@ -24,70 +26,88 @@ import net.i2p.util.Log;
 public class EepHandler {
 
     private static final Log _log = new Log(EepHandler.class);
+    private static I2PAppContext _context = new I2PAppContext();
 
     protected ErrorHandler errorHandler;
-    
-    /* package private */ EepHandler(ErrorHandler eh) {
-	errorHandler=eh;
-    }
-    
-    public void handle(Request req, HTTPListener httpl, OutputStream out,
-		       boolean fromProxy, String destination)
-	throws IOException {
-	SocketManagerProducer smp = httpl.getSMP();
-	Destination dest = NamingService.getInstance().lookup(destination);
-	if (dest == null) {
-	    errorHandler.handle(req, httpl, out,
-				"Could not lookup host: "+destination);
-	    return;
-	}
-	I2PSocketManager sm = smp.getManager(destination);
-	Filter f = new NullFilter(); //FIXME: use other filter
-	req.setParam("Host: ", dest.toBase64());
-	if (!handle(req, f, out, dest, sm)) {
-	    errorHandler.handle(req, httpl, out, "Unable to reach peer");
-	}
+
+    /* package private */EepHandler(ErrorHandler eh) {
+        errorHandler = eh;
     }
 
-    public boolean handle(Request req, Filter f, OutputStream out,
-		       Destination dest, I2PSocketManager sm)
-    throws IOException {
-	I2PSocket s = null;
-	boolean written = false;
-	try {
-	    synchronized(sm) {
-		s = sm.connect(dest, new I2PSocketOptions());
-	    }
-	    InputStream in = new BufferedInputStream(s.getInputStream());
-	    OutputStream sout = new BufferedOutputStream(s.getOutputStream());
-	    sout.write(req.toByteArray());
-	    sout.flush();
-	    byte[] buffer = new byte[16384], filtered;
-	    int len;
-	    while ((len=in.read(buffer)) != -1) {
-		if (len != buffer.length) {
-		    byte[] b2 = new byte[len];
-		    System.arraycopy(buffer, 0, b2, 0, len);
-		    filtered=f.filter(b2);
-		} else {
-		    filtered=f.filter(buffer);
-		}
-		written=true;
-		out.write(filtered);
-	    }
-	    filtered=f.finish();
-	    written=true;
-	    out.write(filtered);
-	    out.flush();
-	} catch (IOException ex) {
-	    _log.error("Error while handling eepsite request");
-	    return written;
-	} catch (I2PException ex) {
-	    _log.error("Error while handling eepsite request");
-	    return written;
-	} finally {
-	    if (s != null) s.close();
-	}
-	return true;
+    /**
+     * @param req the Request
+     * @param httpl an HTTPListener
+     * @param out where to write the results
+     * @param destination destination as a string, (subject to naming
+     *  service lookup)
+     * @throws IOException
+     */
+    public void handle(Request req, HTTPListener httpl, OutputStream out,
+    /* boolean fromProxy, */String destination) throws IOException {
+        SocketManagerProducer smp = httpl.getSMP();
+        Destination dest = _context.namingService().lookup(destination);
+        if (dest == null) {
+            errorHandler.handle(req, httpl, out, "Could not lookup host: " + destination);
+            return;
+        }
+        I2PSocketManager sm = smp.getManager(destination);
+        Filter f = new NullFilter(); //FIXME: use other filter
+        req.setParam("Host: ", dest.toBase64());
+        if (!handle(req, f, out, dest, sm)) {
+            errorHandler.handle(req, httpl, out, "Unable to reach peer");
+        }
+    }
+
+    /**
+     * @param req the Request to send out
+     * @param f a Filter to apply to the bytes retrieved from the Destination
+     * @param out where to write the results
+     * @param dest the Destination of the Request
+     * @param sm an I2PSocketManager, to get a socket for the Destination
+     * @return boolean, true if something was written, false otherwise.
+     * @throws IOException
+     */
+    public boolean handle(Request req, Filter f, OutputStream out, Destination dest, 
+                          I2PSocketManager sm) throws IOException {
+        I2PSocket s = null;
+        boolean written = false;
+        try {
+            synchronized (sm) {
+                s = sm.connect(dest, new I2PSocketOptions());
+            }
+            InputStream in = new BufferedInputStream(s.getInputStream());
+            OutputStream sout = new BufferedOutputStream(s.getOutputStream());
+            sout.write(req.toByteArray());
+            sout.flush();
+            byte[] buffer = new byte[16384], filtered;
+            int len;
+            while ((len = in.read(buffer)) != -1) {
+                if (len != buffer.length) {
+                    byte[] b2 = new byte[len];
+                    System.arraycopy(buffer, 0, b2, 0, len);
+                    filtered = f.filter(b2);
+                } else {
+                    filtered = f.filter(buffer);
+                }
+                written = true;
+                out.write(filtered);
+            }
+            filtered = f.finish();
+            written = true;
+            out.write(filtered);
+            out.flush();
+        } catch (SocketException ex) {
+            _log.error("Error while handling eepsite request");
+            return written;
+        } catch (IOException ex) {
+            _log.error("Error while handling eepsite request");
+            return written;
+        } catch (I2PException ex) {
+            _log.error("Error while handling eepsite request");
+            return written;
+        } finally {
+            if (s != null) s.close();
+        }
+        return true;
     }
 }

apps/httptunnel/java/src/net/i2p/httptunnel/handler/ErrorHandler.java

@@ -1,4 +1,5 @@
 package net.i2p.httptunnel.handler;
+
 import java.io.IOException;
 import java.io.OutputStream;
 
@@ -11,26 +12,30 @@ import net.i2p.util.Log;
  */
 public class ErrorHandler {
 
-    private static final Log _log = new Log(ErrorHandler.class);
+    private static final Log _log = new Log(ErrorHandler.class); /* UNUSED */
 
-    /* package private */ ErrorHandler() {
+    /* package private */ErrorHandler() {
 
     }
-    
-    public void handle(Request req, HTTPListener httpl,
-		       OutputStream out, String error) throws IOException {
-	// FIXME: Make nicer messages for more likely errors.
-	out.write(("HTTP/1.1 500 Internal Server Error\r\n"+
-		   "Content-Type: text/html; charset=iso-8859-1\r\n\r\n")
-		  .getBytes("ISO-8859-1"));
-	out.write(("<html><head><title>"+error+"</title></head><body><h1>"+
-		   error+"</h1>An internal error occurred while "+
-		   "handling a request by HTTPTunnel:<br><b>"+error+
-		   "</b><h2>Complete request:</h2><b>---</b><br><i><pre>\r\n")
-		  .getBytes("ISO-8859-1"));
-	out.write(req.toByteArray());
-	out.write(("</pre></i><br><b>---</b></body></html>")
-		  .getBytes("ISO-8859-1"));
-	out.flush();
+
+    /**
+     * @param req the Request
+     * @param httpl an HTTPListener
+     * @param out where to write the results
+     * @param error the error that happened
+     * @throws IOException
+     */
+    public void handle(Request req, HTTPListener httpl, OutputStream out, String error) throws IOException {
+        // FIXME: Make nicer messages for more likely errors.
+        out
+           .write(("HTTP/1.1 500 Internal Server Error\r\n" + "Content-Type: text/html; charset=iso-8859-1\r\n\r\n")
+                                                                                                                    .getBytes("ISO-8859-1"));
+        out
+           .write(("<html><head><title>" + error + "</title></head><body><h1>" + error
+                   + "</h1>An internal error occurred while " + "handling a request by HTTPTunnel:<br><b>" + error + "</b><h2>Complete request:</h2><b>---</b><br><i><pre>\r\n")
+                                                                                                                                                                                .getBytes("ISO-8859-1"));
+        out.write(req.toByteArray());
+        out.write(("</pre></i><br><b>---</b></body></html>").getBytes("ISO-8859-1"));
+        out.flush();
     }
-}
+}

apps/httptunnel/java/src/net/i2p/httptunnel/handler/LocalHandler.java

@@ -1,4 +1,5 @@
 package net.i2p.httptunnel.handler;
+
 import java.io.IOException;
 import java.io.OutputStream;
 
@@ -12,38 +13,55 @@ import net.i2p.util.Log;
  */
 public class LocalHandler {
 
-    private static final Log _log = new Log(LocalHandler.class);
+    private static final Log _log = new Log(LocalHandler.class); /* UNUSED */
 
-    /* package private */ LocalHandler() {
-
-    }
-    
-    public void handle(Request req, HTTPListener httpl, OutputStream out,
-		       boolean fromProxy) throws IOException {
-	//FIXME: separate multiple pages, not only a start page
-	//FIXME: provide some info on this page
-	out.write(("HTTP/1.1 200 Document following\r\n"+
-		   "Content-Type: text/html; charset=iso-8859-1\r\n\r\n"+
-		   "<html><head><title>Welcome to I2P HTTPTunnel</title>"+
-		   "</head><body><h1>Welcome to I2P HTTPTunnel</h1>You can "+
-		   "browse Eepsites by adding an eepsite name to the request."+
-		   "</body></html>").getBytes("ISO-8859-1"));
-	out.flush();
+    /* package private */LocalHandler() {
     }
 
-    public void handleProxyConfWarning(Request req, HTTPListener httpl,
-				       OutputStream out) throws IOException {
-	//FIXME
+    /**
+     * @param req the Request
+     * @param httpl an HTTPListener 
+     * @param out where to write the results
+     * @throws IOException
+     */
+    public void handle(Request req, HTTPListener httpl, OutputStream out
+    /*, boolean fromProxy */) throws IOException {
+        //FIXME: separate multiple pages, not only a start page
+        //FIXME: provide some info on this page
+        out
+           .write(("HTTP/1.1 200 Document following\r\n" + "Content-Type: text/html; charset=iso-8859-1\r\n\r\n"
+                   + "<html><head><title>Welcome to I2P HTTPTunnel</title>"
+                   + "</head><body><h1>Welcome to I2P HTTPTunnel</h1>You can "
+                   + "browse Eepsites by adding an eepsite name to the request." + "</body></html>")
+                                                                                                    .getBytes("ISO-8859-1"));
+        out.flush();
+    }
+
+    /**
+     * Currently always throws an IO Exception
+     * @param req the Request
+     * @param httpl an HTTPListener
+     * @param out where to write the results
+     * @throws IOException
+     */
+    public void handleProxyConfWarning(Request req, HTTPListener httpl, OutputStream out) throws IOException {
+        //FIXME
         throw new IOException("jrandom ate the deprecated method. mooo");
-	//httpl.handleNotImplemented(out);
+        //httpl.handleNotImplemented(out);
 
     }
 
-    public void handleHTTPWarning(Request req, HTTPListener httpl,
-				  OutputStream out, boolean fromProxy)
-    throws IOException {
-	// FIXME
+    /**
+     * Currently always throws an IO Exception
+     * @param req the Request
+     * @param httpl an HTTPListener
+     * @param out where to write the results
+     * @throws IOException
+     */
+    public void handleHTTPWarning(Request req, HTTPListener httpl, OutputStream out /*, boolean fromProxy */)
+                                                                                                              throws IOException {
+        // FIXME
         throw new IOException("jrandom ate the deprecated method. mooo");
-	//httpl.handleNotImplemented(out);
+        //httpl.handleNotImplemented(out);
     }
-}
+}

apps/httptunnel/java/src/net/i2p/httptunnel/handler/ProxyHandler.java

@@ -1,8 +1,9 @@
 package net.i2p.httptunnel.handler;
+
 import java.io.IOException;
 import java.io.OutputStream;
 
-import net.i2p.client.naming.NamingService;
+import net.i2p.I2PAppContext;
 import net.i2p.client.streaming.I2PSocketManager;
 import net.i2p.data.Destination;
 import net.i2p.httptunnel.HTTPListener;
@@ -17,31 +18,37 @@ import net.i2p.util.Log;
  */
 public class ProxyHandler extends EepHandler {
 
-    private static final Log _log = new Log(ErrorHandler.class);
+    private static final Log _log = new Log(ErrorHandler.class); /* UNUSED */
+    private static I2PAppContext _context = new I2PAppContext();
 
-    /* package private */ ProxyHandler(ErrorHandler eh) {
-	super(eh);
+    /* package private */ProxyHandler(ErrorHandler eh) {
+        super(eh);
     }
-    
-    public void handle(Request req, HTTPListener httpl, OutputStream out,
-		       boolean fromProxy) throws IOException {
-	SocketManagerProducer smp = httpl.getSMP();
-	Destination dest = findProxy();
-	if (dest == null) {
-	    errorHandler.handle(req, httpl, out,
-				"Could not find proxy");
-	    return;
-	}
-	// one manager for all proxy requests
-	I2PSocketManager sm = smp.getManager("--proxy--");
-	Filter f = new NullFilter(); //FIXME: use other filter
-	if (!handle(req, f, out, dest, sm)) {
-	    errorHandler.handle(req, httpl, out, "Unable to reach peer");
-	}
+
+    /**
+     * @param req a Request
+     * @param httpl an HTTPListener
+     * @param out where to write the results
+     * @throws IOException
+     */
+    public void handle(Request req, HTTPListener httpl, OutputStream out
+                       /*, boolean fromProxy */) throws IOException {
+        SocketManagerProducer smp = httpl.getSMP();
+        Destination dest = findProxy();
+        if (dest == null) {
+            errorHandler.handle(req, httpl, out, "Could not find proxy");
+            return;
+        }
+        // one manager for all proxy requests
+        I2PSocketManager sm = smp.getManager("--proxy--");
+        Filter f = new NullFilter(); //FIXME: use other filter
+        if (!handle(req, f, out, dest, sm)) {
+            errorHandler.handle(req, httpl, out, "Unable to reach peer");
+        }
     }
 
     private Destination findProxy() {
-	//FIXME!
-	return NamingService.getInstance().lookup("squid.i2p");
+        //FIXME!
+        return _context.namingService().lookup("squid.i2p");
     }
-}
+}

apps/httptunnel/java/src/net/i2p/httptunnel/handler/RootHandler.java

@@ -1,4 +1,5 @@
 package net.i2p.httptunnel.handler;
+
 import java.io.IOException;
 import java.io.OutputStream;
 
@@ -11,99 +12,105 @@ import net.i2p.util.Log;
  */
 public class RootHandler {
 
-    private static final Log _log = new Log(RootHandler.class);
+    private static final Log _log = new Log(RootHandler.class); /* UNUSED */
 
     private RootHandler() {
-	errorHandler=new ErrorHandler();
-	localHandler=new LocalHandler();
-	proxyHandler=new ProxyHandler(errorHandler);
-	eepHandler=new EepHandler(errorHandler);
+        errorHandler = new ErrorHandler();
+        localHandler = new LocalHandler();
+        proxyHandler = new ProxyHandler(errorHandler);
+        eepHandler = new EepHandler(errorHandler);
     }
 
     private ErrorHandler errorHandler;
     private ProxyHandler proxyHandler;
     private LocalHandler localHandler;
     private EepHandler eepHandler;
-    
+
     private static RootHandler instance;
 
+    /**
+     * Singleton stuff
+     * @return the one and only instance, yay!
+     */
     public static synchronized RootHandler getInstance() {
-	if (instance == null) {
-	    instance = new RootHandler();
-	}
-	return instance;
+        if (instance == null) {
+            instance = new RootHandler();
+        }
+        return instance;
     }
-    
-    public void handle(Request req, HTTPListener httpl,
-		       OutputStream out) throws IOException {
-	String url=req.getURL();
-	System.out.println(url);
-	boolean byProxy = false;
-	int pos;
-	if (url.startsWith("http://")) { // access via proxy
-	    byProxy=true;
-	    if (httpl.firstProxyUse()) {
-		localHandler.handleProxyConfWarning(req,httpl,out);
-		return;
-	    }
-	    url = url.substring(7);
-	    pos = url.indexOf("/");
-	    String host;
-	    String rest;
-	    if (pos == -1) {
-		errorHandler.handle(req, httpl, out, "No host end in URL");
-		return;
-	    } else {
-		host = url.substring(0,pos);
-		url = url.substring(pos);
-		if ("i2p".equals(host) || "i2p.i2p".equals(host)) {
-		    // normal request; go on below...
-		} else if (host.endsWith(".i2p")) {
-		    // "old" service request, send a redirect...
-		    out.write(("HTTP/1.1 302 Moved\r\nLocation: "+
-			       "http://i2p.i2p/"+host+url+
-			       "\r\n\r\n").getBytes("ISO-8859-1"));
-		    return;
-		} else {
-		    // this is for proxying to the real web
-		    proxyHandler.handle(req, httpl, out, true);
-		    return;
-		}
-	    }
-	}
-	if (url.equals("/")) { // main page
-	    url="/_/local/index";
-	} else if (!url.startsWith("/")) {
-	    errorHandler.handle(req, httpl, out,
-				"No leading slash in URL: "+url);
-	    return;
-	}
-	String dest;
-	url=url.substring(1);
-	pos = url.indexOf("/");
-	if (pos == -1) {
-	    dest=url;
-	    url="/";
-	} else {
-	    dest = url.substring(0,pos);
-	    url=url.substring(pos);
-	}
-	req.setURL(url);
-	if (dest.equals("_")) { // no eepsite
-	    if (url.startsWith("/local/")) { // local request
-		req.setURL(url.substring(6));
-		localHandler.handle(req, httpl, out, byProxy);
-	    } else if (url.startsWith("/http/")) {  // http warning
-		localHandler.handleHTTPWarning(req, httpl, out, byProxy);
-	    } else if (url.startsWith("/proxy/")) { // http proxying
-		req.setURL("http://"+url.substring(7));
-		proxyHandler.handle(req, httpl, out, byProxy);
-	    } else {
-		errorHandler.handle(req, httpl, out,
-				    "No local handler for this URL: "+url);
-	    }
-	} else {
-	    eepHandler.handle(req, httpl, out, byProxy, dest);
-	}
+
+    /**
+     * The _ROOT_ handler:  it passes its workload off to the other handlers.
+     * @param req a Request
+     * @param httpl an HTTPListener
+     * @param out where to write the results
+     * @throws IOException
+     */
+    public void handle(Request req, HTTPListener httpl, OutputStream out) throws IOException {
+        String url = req.getURL();
+        System.out.println(url);
+        /* boolean byProxy = false; */
+        int pos;
+        if (url.startsWith("http://")) { // access via proxy
+            /* byProxy=true; */
+            if (httpl.firstProxyUse()) {
+                localHandler.handleProxyConfWarning(req, httpl, out);
+                return;
+            }
+            url = url.substring(7);
+            pos = url.indexOf("/");
+            String host;
+
+            if (pos == -1) {
+                errorHandler.handle(req, httpl, out, "No host end in URL");
+                return;
+            }
+            
+            host = url.substring(0, pos);
+            url = url.substring(pos);
+            if ("i2p".equals(host) || "i2p.i2p".equals(host)) {
+                // normal request; go on below...
+            } else if (host.endsWith(".i2p")) {
+                // "old" service request, send a redirect...
+                out.write(("HTTP/1.1 302 Moved\r\nLocation: " + "http://i2p.i2p/" + host + url + "\r\n\r\n").getBytes("ISO-8859-1"));
+                return;
+            } else {
+                // this is for proxying to the real web
+                proxyHandler.handle(req, httpl, out /*, true */);
+                return;
+            }
+        }
+        if (url.equals("/")) { // main page
+            url = "/_/local/index";
+        } else if (!url.startsWith("/")) {
+            errorHandler.handle(req, httpl, out, "No leading slash in URL: " + url);
+            return;
+        }
+        String dest;
+        url = url.substring(1);
+        pos = url.indexOf("/");
+        if (pos == -1) {
+            dest = url;
+            url = "/";
+        } else {
+            dest = url.substring(0, pos);
+            url = url.substring(pos);
+        }
+        req.setURL(url);
+        if (dest.equals("_")) { // no eepsite
+            if (url.startsWith("/local/")) { // local request
+                req.setURL(url.substring(6));
+                localHandler.handle(req, httpl, out /*, byProxy */);
+            } else if (url.startsWith("/http/")) { // http warning
+                localHandler.handleHTTPWarning(req, httpl, out /*, byProxy */);
+            } else if (url.startsWith("/proxy/")) { // http proxying
+                req.setURL("http://" + url.substring(7));
+                proxyHandler.handle(req, httpl, out /*, byProxy */);
+            } else {
+                errorHandler.handle(req, httpl, out, "No local handler for this URL: " + url);
+            }
+        } else {
+            eepHandler.handle(req, httpl, out, /* byProxy, */dest);
+        }
     }
-}
+}

apps/i2ptunnel/java/build.xml

@@ -4,7 +4,7 @@
     <target name="build" depends="builddep, jar" />
     <target name="builddep">
         <ant dir="../../ministreaming/java/" target="build" />
-        <ant dir="../../../core/java/" target="build" />
+	<!-- ministreaming will build core -->
     </target>
     <target name="compile">
         <mkdir dir="./build" />
@@ -37,11 +37,11 @@
         <delete dir="./build" />
     </target>
     <target name="cleandep" depends="clean">
-        <ant dir="../../../core/java/" target="cleandep" />
+	<!-- ministreaming will clean core -->
         <ant dir="../../ministreaming/java/" target="distclean" />
     </target>
     <target name="distclean" depends="clean">
-        <ant dir="../../../core/java/" target="distclean" />
+	<!-- ministreaming will clean core -->
         <ant dir="../../ministreaming/java/" target="distclean" />
     </target>
 </project>

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

@@ -16,16 +16,26 @@ class BufferLogger implements Logging {
     private final static Log _log = new Log(BufferLogger.class);
     private ByteArrayOutputStream _baos;
     private boolean _ignore;
-    
+
+    /**
+     * Constructs a buffered logger.
+     */
     public BufferLogger() {
-	_baos = new ByteArrayOutputStream(512);
-	_ignore = false;
+        _baos = new ByteArrayOutputStream(512);
+        _ignore = false;
     }
 
     private final static String EMPTY = "";
-    public String getBuffer() { 
-	if (_ignore) return EMPTY;
-	else return new String(_baos.toByteArray()); 
+
+    /**
+     * Retrieves the buffer
+     * @return the buffer
+     */
+    public String getBuffer() {
+        if (_ignore)
+            return EMPTY;
+
+        return new String(_baos.toByteArray());
     }
 
     /**
@@ -36,26 +46,27 @@ class BufferLogger implements Logging {
      *
      */
     public void ignoreFurtherActions() {
-	_ignore = true;
-	synchronized (_baos) {
-	    _baos.reset();
-	}
-	_baos = null;
+        _ignore = true;
+        synchronized (_baos) {
+            _baos.reset();
+        }
+        _baos = null;
     }
-    
+
     /**
      * Pass in some random data 
+     * @param s String containing what we're logging.
      */
     public void log(String s) {
-	if (_ignore) return;
-	if (s != null) {
-	    _log.debug("logging [" + s + "]");
-	    try {
-		_baos.write(s.getBytes());
-		_baos.write('\n');
-	    } catch (IOException ioe) {
-		_log.error("Error logging [" + s + "]");
-	    }
-	}
+        if (_ignore) return;
+        if (s != null) {
+            _log.debug("logging [" + s + "]");
+            try {
+                _baos.write(s.getBytes());
+                _baos.write('\n');
+            } catch (IOException ioe) {
+                _log.error("Error logging [" + s + "]");
+            }
+        }
     }
-}
+}

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

@@ -5,7 +5,6 @@ package net.i2p.i2ptunnel;
 
 import java.net.Socket;
 
-import net.i2p.I2PException;
 import net.i2p.client.streaming.I2PSocket;
 import net.i2p.data.DataFormatException;
 import net.i2p.data.Destination;
@@ -17,45 +16,48 @@ public class I2PTunnelClient extends I2PTunnelClientBase {
     private static final Log _log = new Log(I2PTunnelClient.class);
 
     protected Destination dest;
+    private static final long DEFAULT_READ_TIMEOUT = 5*60*1000; // -1
+    protected long readTimeout = DEFAULT_READ_TIMEOUT;
 
-    public I2PTunnelClient(int localPort, String destination,
-			   Logging l, boolean ownDest,
-			   EventDispatcher notifyThis) {
-	super(localPort, ownDest, l, notifyThis, "SynSender");
+    public I2PTunnelClient(int localPort, String destination, Logging l, boolean ownDest, EventDispatcher notifyThis) {
+        super(localPort, ownDest, l, notifyThis, "SynSender");
 
-	if (waitEventValue("openBaseClientResult").equals("error")) {
-	    notifyEvent("openClientResult", "error");
-	    return;
-	}
-	
-	try {
-	    dest=I2PTunnel.destFromName(destination);
-	    if (dest == null) {
-		l.log("Could not resolve " + destination + ".");
-		return;
-	    }
-	} catch (DataFormatException e) {
-	    l.log("Bad format in destination \"" + destination + "\".");
-	    notifyEvent("openClientResult", "error");
-	    return;
-	}
+        if (waitEventValue("openBaseClientResult").equals("error")) {
+            notifyEvent("openClientResult", "error");
+            return;
+        }
 
-	setName(getLocalPort() + " -> " + destination);
+        try {
+            dest = I2PTunnel.destFromName(destination);
+            if (dest == null) {
+                l.log("Could not resolve " + destination + ".");
+                return;
+            }
+        } catch (DataFormatException e) {
+            l.log("Bad format in destination \"" + destination + "\".");
+            notifyEvent("openClientResult", "error");
+            return;
+        }
 
-	startRunning();
+        setName(getLocalPort() + " -> " + destination);
 
-	notifyEvent("openClientResult", "ok");
+        startRunning();
+
+        notifyEvent("openClientResult", "ok");
     }
 
+    public void setReadTimeout(long ms) { readTimeout = ms; }
+    public long getReadTimeout() { return readTimeout; }
+    
     protected void clientConnectionRun(Socket s) {
-	try {
-	    I2PSocket i2ps = createI2PSocket(dest);
-	    new I2PTunnelRunner(s, i2ps, sockLock, null);
-	} catch (I2PException ex) {
-	    _log.info("Error connecting", ex);
-	    l.log("Unable to reach peer");
-	    // s has been initialized before the try block...
-	    closeSocket(s);
-	}
+        try {
+            I2PSocket i2ps = createI2PSocket(dest);
+            i2ps.setReadTimeout(readTimeout);
+            new I2PTunnelRunner(s, i2ps, sockLock, null);
+        } catch (Exception ex) {
+            _log.info("Error connecting", ex);
+            l.log(ex.getMessage());
+            closeSocket(s);
+        }
     }
 }

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

@@ -4,7 +4,10 @@
 package net.i2p.i2ptunnel;
 
 import java.io.IOException;
+import java.io.InterruptedIOException;
+import java.net.ConnectException;
 import java.net.InetAddress;
+import java.net.NoRouteToHostException;
 import java.net.ServerSocket;
 import java.net.Socket;
 import java.net.UnknownHostException;
@@ -20,16 +23,18 @@ import net.i2p.client.streaming.I2PSocketManagerFactory;
 import net.i2p.client.streaming.I2PSocketOptions;
 import net.i2p.data.Destination;
 import net.i2p.util.EventDispatcher;
+import net.i2p.util.I2PThread;
 import net.i2p.util.Log;
 
-public abstract class I2PTunnelClientBase extends I2PTunnelTask 
-    implements Runnable {
-    
+public abstract class I2PTunnelClientBase extends I2PTunnelTask implements Runnable {
+
     private static final Log _log = new Log(I2PTunnelClientBase.class);
     protected Logging l;
-    
-    private static final long DEFAULT_CONNECT_TIMEOUT = 60*1000;
 
+    private static final long DEFAULT_CONNECT_TIMEOUT = 60 * 1000;
+
+    private static volatile long __clientId = 0;
+    protected long _clientId;
     protected Object sockLock = new Object(); // Guards sockMgr and mySockets
     private I2PSocketManager sockMgr;
     private List mySockets = new ArrayList();
@@ -40,12 +45,12 @@ public abstract class I2PTunnelClientBase extends I2PTunnelTask
     private boolean listenerReady = false;
 
     private ServerSocket ss;
-    
+
     private Object startLock = new Object();
     private boolean startRunning = false;
 
     private Object closeLock = new Object();
-    
+
     private byte[] pubkey;
 
     private String handlerName;
@@ -55,101 +60,99 @@ public abstract class I2PTunnelClientBase extends I2PTunnelTask
     //    I2PTunnelClientBase(localPort, ownDest, l, (EventDispatcher)null);
     //}
 
-    public I2PTunnelClientBase(int localPort, boolean ownDest,
-			       Logging l, EventDispatcher notifyThis,
-			       String handlerName) {
-	super(localPort+" (uninitialized)", notifyThis);
-	this.localPort=localPort;
-	this.l = l;
-	this.handlerName=handlerName;
+    public I2PTunnelClientBase(int localPort, boolean ownDest, Logging l, EventDispatcher notifyThis, String handlerName) {
+        super(localPort + " (uninitialized)", notifyThis);
+        _clientId = ++__clientId;
+        this.localPort = localPort;
+        this.l = l;
+        this.handlerName = handlerName + _clientId;
 
-	synchronized(sockLock) {
-	    if (ownDest) {
-		sockMgr=buildSocketManager();
-	    } else {
-		sockMgr=getSocketManager();
-	    }
-	}
-	if (sockMgr == null) throw new NullPointerException();
-	l.log("I2P session created");
-        
-	Thread t = new Thread(this);
-	t.setName("Client");
-	listenerReady=false;
-	t.start();
-	open=true;
-	synchronized (this) {
-	    while (!listenerReady) {
-		try {
-		    wait();
-		}
-		catch (InterruptedException e) {
-		    // ignore
-		}
-	    }
-	}
-	
-	if (open && listenerReady) {
-	    l.log("Ready! Port " + getLocalPort());
-	    notifyEvent("openBaseClientResult", "ok");
-	} else {
-	    l.log("Error!");
-	    notifyEvent("openBaseClientResult", "error");
-	}
+        synchronized (sockLock) {
+            if (ownDest) {
+                sockMgr = buildSocketManager();
+            } else {
+                sockMgr = getSocketManager();
+            }
+        }
+        if (sockMgr == null) throw new NullPointerException();
+        l.log("I2P session created");
+
+        Thread t = new I2PThread(this);
+        t.setName("Client " + _clientId);
+        listenerReady = false;
+        t.start();
+        open = true;
+        synchronized (this) {
+            while (!listenerReady) {
+                try {
+                    wait();
+                } catch (InterruptedException e) {
+                    // ignore
+                }
+            }
+        }
+
+        if (open && listenerReady) {
+            l.log("Ready! Port " + getLocalPort());
+            notifyEvent("openBaseClientResult", "ok");
+        } else {
+            l.log("Error!");
+            notifyEvent("openBaseClientResult", "error");
+        }
     }
 
     private static I2PSocketManager socketManager;
-    
+
     protected static synchronized I2PSocketManager getSocketManager() {
-	if (socketManager == null) {
-	    socketManager = buildSocketManager();
-	}
-	return socketManager;
+        if (socketManager == null) {
+            socketManager = buildSocketManager();
+        }
+        return socketManager;
     }
-    
+
     protected static I2PSocketManager buildSocketManager() {
-	Properties props = new Properties();
-	props.putAll(System.getProperties());
-	return I2PSocketManagerFactory.createManager
-	    (I2PTunnel.host, Integer.parseInt(I2PTunnel.port), props);
+        Properties props = new Properties();
+        props.putAll(System.getProperties());
+        I2PSocketManager sockManager = I2PSocketManagerFactory.createManager(I2PTunnel.host, Integer.parseInt(I2PTunnel.port), props);
+        sockManager.setName("Client");
+        return sockManager;
     }
-    
+
     public final int getLocalPort() {
         return localPort;
     }
 
     protected final InetAddress getListenHost(Logging l) {
-	try {
-	    return InetAddress.getByName(I2PTunnel.listenHost);
-	} catch (UnknownHostException uhe) {
-	    l.log("Could not find listen host to bind to [" +
-		  I2PTunnel.host + "]");
-	    _log.error("Error finding host to bind", uhe);
-	    notifyEvent("openBaseClientResult", "error");
-	    return null;
-	}
+        try {
+            return InetAddress.getByName(I2PTunnel.listenHost);
+        } catch (UnknownHostException uhe) {
+            l.log("Could not find listen host to bind to [" + I2PTunnel.host + "]");
+            _log.error("Error finding host to bind", uhe);
+            notifyEvent("openBaseClientResult", "error");
+            return null;
+        }
     }
-    
+
     /**
      * Actually start working on incoming connections.  *Must* be
      * called by derived classes after initialization.
      *
      */
     public final void startRunning() {
-	synchronized (startLock) {
-	    startRunning = true;
-	    startLock.notify();
-	}
+        synchronized (startLock) {
+            startRunning = true;
+            startLock.notify();
+        }
     }
-    
+
     /** 
      * create the default options (using the default timeout, etc)
      *
      */
     private I2PSocketOptions getDefaultOptions() {
-	I2PSocketOptions opts = new I2PSocketOptions();
-	opts.setConnectTimeout(DEFAULT_CONNECT_TIMEOUT);
-	return opts;
+        I2PSocketOptions opts = new I2PSocketOptions();
+        opts.setConnectTimeout(DEFAULT_CONNECT_TIMEOUT);
+        return opts;
     }
 
     /**
@@ -160,8 +163,8 @@ public abstract class I2PTunnelClientBase extends I2PTunnelTask
      * @param dest The destination to connect to
      * @return a new I2PSocket
      */
-    public I2PSocket createI2PSocket(Destination dest) throws I2PException {
-	return createI2PSocket(dest, getDefaultOptions());
+    public I2PSocket createI2PSocket(Destination dest) throws I2PException, ConnectException, NoRouteToHostException, InterruptedIOException {
+        return createI2PSocket(dest, getDefaultOptions());
     }
 
     /**
@@ -172,55 +175,60 @@ public abstract class I2PTunnelClientBase extends I2PTunnelTask
      * @param dest The destination to connect to
      * @param opt Option to be used to open when opening the socket
      * @return a new I2PSocket
+     *
+     * @throws ConnectException if the peer refuses the connection
+     * @throws NoRouteToHostException if the peer is not found or not reachable
+     * @throws InterruptedIOException if the connection timeouts
+     * @throws I2PException if there is some other I2P-related problem
      */
-    public I2PSocket createI2PSocket(Destination dest, I2PSocketOptions opt) throws I2PException {
-	I2PSocket i2ps;
+    public I2PSocket createI2PSocket(Destination dest, I2PSocketOptions opt) throws I2PException, ConnectException, NoRouteToHostException, InterruptedIOException {
+        I2PSocket i2ps;
 
-	synchronized (sockLock) {
-	    i2ps = sockMgr.connect(dest, opt);
-	    mySockets.add(i2ps);
-	}
+        i2ps = sockMgr.connect(dest, opt);
+        synchronized (sockLock) {
+            mySockets.add(i2ps);
+        }
 
-	return i2ps;
+        return i2ps;
     }
 
     public final void run() {
-	try {
-	    InetAddress addr = getListenHost(l);
-	    if (addr == null) return;
-	    ss = new ServerSocket(localPort, 0, addr);
-        
-	    // If a free port was requested, find out what we got
-	    if (localPort == 0) {
-		localPort = ss.getLocalPort();
-	    }
-	    notifyEvent("clientLocalPort", new Integer(ss.getLocalPort()));
-	    l.log("Listening for clients on port " + localPort +
-		  " of " + I2PTunnel.listenHost);
-	    
-	    // Notify constructor that port is ready
-	    synchronized(this) {
-		listenerReady = true;
-		notify();        
-	    }
+        try {
+            InetAddress addr = getListenHost(l);
+            if (addr == null) return;
+            ss = new ServerSocket(localPort, 0, addr);
 
-	    // Wait until we are authorized to process data
-	    synchronized (startLock) {
-		while (!startRunning) {
-		    try {
-			startLock.wait();
-		    } catch (InterruptedException ie) {}
-		}
-	    } 
+            // If a free port was requested, find out what we got
+            if (localPort == 0) {
+                localPort = ss.getLocalPort();
+            }
+            notifyEvent("clientLocalPort", new Integer(ss.getLocalPort()));
+            l.log("Listening for clients on port " + localPort + " of " + I2PTunnel.listenHost);
 
-	    while (true) {
-		Socket s = ss.accept();
-		manageConnection(s);
-	    }
-	} catch (IOException ex) {
-	    _log.error("Error listening for connections", ex);
-	    notifyEvent("openBaseClientResult", "error");
-	}
+            // Notify constructor that port is ready
+            synchronized (this) {
+                listenerReady = true;
+                notify();
+            }
+
+            // Wait until we are authorized to process data
+            synchronized (startLock) {
+                while (!startRunning) {
+                    try {
+                        startLock.wait();
+                    } catch (InterruptedException ie) {
+                    }
+                }
+            }
+
+            while (true) {
+                Socket s = ss.accept();
+                manageConnection(s);
+            }
+        } catch (IOException ex) {
+            _log.error("Error listening for connections", ex);
+            notifyEvent("openBaseClientResult", "error");
+        }
     }
 
     /**
@@ -229,59 +237,60 @@ public abstract class I2PTunnelClientBase extends I2PTunnelTask
      * @param s Socket to take care of
      */
     protected void manageConnection(Socket s) {
-	new ClientConnectionRunner(s, handlerName);
+        new ClientConnectionRunner(s, handlerName);
     }
 
-    
     public boolean close(boolean forced) {
-	if (!open) return true;
-	// FIXME: here we might have to wait quite a long time if
-	// there is a connection attempt atm. But without waiting we
-	// might risk to create an orphan socket. Would be better
-	// to return with an error in that situation quickly.
-	synchronized(sockLock) {
-	    mySockets.retainAll(sockMgr.listSockets());
-	    if (!forced && mySockets.size() != 0) {
-		l.log("There are still active connections!");
-		_log.debug("can't close: there are still active connections!");
-		for (Iterator it = mySockets.iterator(); it.hasNext();) {
-		    l.log("->"+it.next());
-		}
-		return false;
-	    }
-	    l.log("Closing client "+toString());
-	    try {
-		if (ss != null) ss.close();
-	    } catch (IOException ex) {
-		ex.printStackTrace();
-		return false;
-	    }
-	    l.log("Client closed.");
-	    open=false;
-	    return true;
-	}
+        if (!open) return true;
+        // FIXME: here we might have to wait quite a long time if
+        // there is a connection attempt atm. But without waiting we
+        // might risk to create an orphan socket. Would be better
+        // to return with an error in that situation quickly.
+        synchronized (sockLock) {
+            mySockets.retainAll(sockMgr.listSockets());
+            if (!forced && mySockets.size() != 0) {
+                l.log("There are still active connections!");
+                _log.debug("can't close: there are still active connections!");
+                for (Iterator it = mySockets.iterator(); it.hasNext();) {
+                    l.log("->" + it.next());
+                }
+                return false;
+            }
+            l.log("Closing client " + toString());
+            try {
+                if (ss != null) ss.close();
+            } catch (IOException ex) {
+                ex.printStackTrace();
+                return false;
+            }
+            l.log("Client closed.");
+            open = false;
+            return true;
+        }
     }
 
     public static void closeSocket(Socket s) {
-	try {
-	    s.close();
-	} catch (IOException ex) {
-	    _log.error("Could not close socket", ex);
-	}
+        try {
+            s.close();
+        } catch (IOException ex) {
+            _log.error("Could not close socket", ex);
+        }
     }
 
-    public class ClientConnectionRunner extends Thread {
-	private Socket s;
-	
-	public ClientConnectionRunner(Socket s, String name) {
-	    this.s=s;
-	    setName(name);
-	    start();
-	}
-	
-	public void run() {
-	    clientConnectionRun(s);
-	}
+    private static volatile long __runnerId = 0;
+    
+    public class ClientConnectionRunner extends I2PThread {
+        private Socket s;
+
+        public ClientConnectionRunner(Socket s, String name) {
+            this.s = s;
+            setName(name + '.' + (++__runnerId));
+            start();
+        }
+
+        public void run() {
+            clientConnectionRun(s);
+        }
     }
 
     /**

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

@@ -19,30 +19,30 @@ public class I2PTunnelGUI extends Frame implements ActionListener, Logging {
     TextField input;
     TextArea log;
     I2PTunnel t;
-    
+
     public I2PTunnelGUI(I2PTunnel t) {
-	super("I2PTunnel control panel");
-	this.t=t;
-	setLayout(new BorderLayout());
-	add("South", input=new TextField());
-	input.addActionListener(this);
-	Font font = new Font("Monospaced",Font.PLAIN,12);
-	add("Center",log=new TextArea("",20,80,TextArea.SCROLLBARS_VERTICAL_ONLY));
-	log.setFont(font);
-	log.setEditable(false);
-	log("enter 'help' for help.");
-	pack();
-	show();
+        super("I2PTunnel control panel");
+        this.t = t;
+        setLayout(new BorderLayout());
+        add("South", input = new TextField());
+        input.addActionListener(this);
+        Font font = new Font("Monospaced", Font.PLAIN, 12);
+        add("Center", log = new TextArea("", 20, 80, TextArea.SCROLLBARS_VERTICAL_ONLY));
+        log.setFont(font);
+        log.setEditable(false);
+        log("enter 'help' for help.");
+        pack();
+        show();
     }
 
     public void log(String s) {
-	log.append(s+"\n");
+        log.append(s + "\n");
     }
 
     public void actionPerformed(ActionEvent evt) {
-	log("I2PTunnel>"+input.getText());
-	t.runCommand(input.getText(), this);
-	log("---");
-	input.setText("");
+        log("I2PTunnel>" + input.getText());
+        t.runCommand(input.getText(), this);
+        log("---");
+        input.setText("");
     }
-}
+}

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

@@ -8,6 +8,7 @@ import java.io.IOException;
 import java.io.InputStreamReader;
 import java.io.OutputStream;
 import java.net.Socket;
+import java.net.SocketException;
 import java.util.Date;
 
 import net.i2p.I2PException;
@@ -19,316 +20,388 @@ import net.i2p.util.EventDispatcher;
 import net.i2p.util.I2PThread;
 import net.i2p.util.Log;
 
-public class I2PTunnelHTTPClient extends I2PTunnelClientBase
-    implements Runnable {
-    private static final Log _log =
-	new Log(I2PTunnelHTTPClient.class);
+/**
+ * Act as a mini HTTP proxy, handling various different types of requests,
+ * forwarding them through I2P appropriately, and displaying the reply.  Supported
+ * request formats are: <pre>
+ *   $method http://$site[$port]/$path $protocolVersion
+ * or
+ *   $method $path $protocolVersion\nHost: $site
+ * or
+ *   $method http://i2p/$site/$path $protocolVersion
+ * or 
+ *   $method /$site/$path $protocolVersion
+ * </pre>
+ *
+ * If the $site resolves with the I2P naming service, then it is directed towards
+ * that eepsite, otherwise it is directed towards this client's outproxy (typically
+ * "squid.i2p").  Only HTTP is supported (no HTTPS, ftp, mailto, etc).  Both GET
+ * and POST have been tested, though other $methods should work.
+ *
+ */
+public class I2PTunnelHTTPClient extends I2PTunnelClientBase implements Runnable {
+    private static final Log _log = new Log(I2PTunnelHTTPClient.class);
 
     private String wwwProxy;
 
-    private final static byte[] ERR_REQUEST_DENIED = "HTTP/1.1 404 Not Found\r\nContent-Type: text/html; charset=iso-8859-1\r\nCache-control: no-cache\r\n\r\n<html><body><H1>I2P ERROR: REQUEST DENIED</H1>You attempted to connect to a non-I2P website or location.<BR>".getBytes();
-    private final static byte[] ERR_DESTINATION_UNKNOWN = "HTTP/1.1 404 Not Found\r\nContent-Type: text/html; charset=iso-8859-1\r\nCache-control: no-cache\r\n\r\n<html><body><H1>I2P ERROR: NOT FOUND</H1>That Desitination was not found. Perhaps you pasted in the wrong BASE64 I2P Destination or the link you are following is bad. The host (or the WWW proxy, if you're using one) could also be temporarily offline. Could not find the following Destination:<BR><BR>".getBytes();
-    private final static byte[] ERR_TIMEOUT = "HTTP/1.1 404 Not Found\r\nContent-Type: text/html; charset=iso-8859-1\r\nCache-control: no-cache\r\n\r\n<html><body><H1>I2P ERROR: TIMEOUT</H1>That Desitination was reachable, but timed out getting a response.  This may be a temporary error, so you should simply try to refresh, though if the problem persists, the remote destination may have issues.  Could not get a response from the following Destination:<BR><BR>".getBytes();
+    private final static byte[] ERR_REQUEST_DENIED =
+        ("HTTP/1.1 403 Access Denied\r\n"+
+         "Content-Type: text/html; charset=iso-8859-1\r\n"+
+         "Cache-control: no-cache\r\n"+
+         "\r\n"+
+         "<html><body><H1>I2P ERROR: REQUEST DENIED</H1>"+
+         "You attempted to connect to a non-I2P website or location.<BR>")
+        .getBytes();
     
-    //public I2PTunnelHTTPClient(int localPort, Logging l,
-    //			       boolean ownDest,
-    //			       String wwwProxy) {
-    //	I2PTunnelHTTPClient(localPort, l, ownDest, wwwProxy,
-    //			    (EventDispatcher)null);
-    //}
+    private final static byte[] ERR_DESTINATION_UNKNOWN =
+        ("HTTP/1.1 503 Service Unavailable\r\n"+
+         "Content-Type: text/html; charset=iso-8859-1\r\n"+
+         "Cache-control: no-cache\r\n"+
+         "\r\n"+
+         "<html><body><H1>I2P ERROR: DESTINATION NOT FOUND</H1>"+
+         "That I2P Desitination was not found. Perhaps you pasted in the "+
+         "wrong BASE64 I2P Destination or the link you are following is "+
+         "bad. The host (or the WWW proxy, if you're using one) could also "+
+	 "be temporarily offline.  You may want to <b>retry</b>.  "+
+         "Could not find the following Destination:<BR><BR>")
+        .getBytes();
+    
+    private final static byte[] ERR_TIMEOUT =
+        ("HTTP/1.1 504 Gateway Timeout\r\n"+
+         "Content-Type: text/html; charset=iso-8859-1\r\n"+
+         "Cache-control: no-cache\r\n\r\n"+
+         "<html><body><H1>I2P ERROR: TIMEOUT</H1>"+
+         "That Desitination was reachable, but timed out getting a "+
+         "response.  This is likely a temporary error, so you should simply "+
+         "try to refresh, though if the problem persists, the remote "+
+         "destination may have issues.  Could not get a response from "+
+         "the following Destination:<BR><BR>")
+        .getBytes();
 
-    public I2PTunnelHTTPClient(int localPort, Logging l,
-			       boolean ownDest,
-			       String wwwProxy, EventDispatcher notifyThis) {
-	super(localPort, ownDest, l, notifyThis, "HTTPHandler");
+    /** used to assign unique IDs to the threads / clients.  no logic or functionality */
+    private static volatile long __clientId = 0;
+    
+    public I2PTunnelHTTPClient(int localPort, Logging l, boolean ownDest, String wwwProxy, EventDispatcher notifyThis) {
+        super(localPort, ownDest, l, notifyThis, "HTTPHandler " + (++__clientId));
 
-	if (waitEventValue("openBaseClientResult").equals("error")) {
-	    notifyEvent("openHTTPClientResult", "error");
-	    return;
-	}
-	
-	this.wwwProxy = wwwProxy;
+        if (waitEventValue("openBaseClientResult").equals("error")) {
+            notifyEvent("openHTTPClientResult", "error");
+            return;
+        }
 
-	setName(getLocalPort()
-		+ " -> HTTPClient [WWW outproxy: " + this.wwwProxy + "]");
+        this.wwwProxy = wwwProxy;
 
-	startRunning();
+        setName(getLocalPort() + " -> HTTPClient [WWW outproxy: " + this.wwwProxy + "]");
 
-	notifyEvent("openHTTPClientResult", "ok");
+        startRunning();
+
+        notifyEvent("openHTTPClientResult", "ok");
     }
 
+    private String getPrefix() { return "Client[" + _clientId + "]: "; }
+    
     protected void clientConnectionRun(Socket s) {
-	    OutputStream out = null;
-	    String targetRequest = null;
-	    boolean usingWWWProxy = false;
-	    InactivityTimeoutThread timeoutThread = null;
-	    try {
-		out = s.getOutputStream();
-		BufferedReader br = new BufferedReader
-		    (new InputStreamReader(s.getInputStream(),
-					   "ISO-8859-1"));
-		String line, method=null, protocol=null, host=null, destination=null;
-		StringBuffer newRequest=new StringBuffer();
-		while ((line=br.readLine()) != null) {
-		    if (method==null) { // first line (GET /base64/realaddr)
-			int pos=line.indexOf(" ");
-			if (pos == -1)  break;
-			method=line.substring(0, pos);
-			String request = line.substring(pos+1);
-			if (request.startsWith("/") &&
-			    System.getProperty("i2ptunnel.noproxy") != null) {
-			    request="http://i2p"+request;
-			}
-			pos = request.indexOf("//");
-			if (pos == -1) {
-			    method=null;
-			    break;
-			}
-			protocol=request.substring(0,pos+2);
-			request=request.substring(pos+2);
+        OutputStream out = null;
+        String targetRequest = null;
+        boolean usingWWWProxy = false;
+        InactivityTimeoutThread timeoutThread = null;
+        try {
+            out = s.getOutputStream();
+            BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream(), "ISO-8859-1"));
+            String line, method = null, protocol = null, host = null, destination = null;
+            StringBuffer newRequest = new StringBuffer();
+            while ((line = br.readLine()) != null) {
+                if (_log.shouldLog(Log.DEBUG))
+                    _log.debug(getPrefix() + "Line=[" + line + "]");
+                
+                if (line.startsWith("Connection: ") || 
+                    line.startsWith("Keep-Alive: ") || 
+                    line.startsWith("Proxy-Connection: "))
+                    continue;
+                
+                if (method == null) { // first line (GET /base64/realaddr)
+                    if (_log.shouldLog(Log.DEBUG))
+                        _log.debug(getPrefix() + "Method is null for [" + line + "]");
+                    
+                    int pos = line.indexOf(" ");
+                    if (pos == -1) break;
+                    method = line.substring(0, pos);
+                    String request = line.substring(pos + 1);
+                    if (request.startsWith("/") && System.getProperty("i2ptunnel.noproxy") != null) {
+                        request = "http://i2p" + request;
+                    }
+                    pos = request.indexOf("//");
+                    if (pos == -1) {
+                        method = null;
+                        break;
+                    }
+                    protocol = request.substring(0, pos + 2);
+                    request = request.substring(pos + 2);
 
-			targetRequest = request;
+                    targetRequest = request;
 
-			pos = request.indexOf("/");
-			if (pos == -1) {
-			    method=null;
-			    break;
-			}
-			host=request.substring(0,pos);
+                    pos = request.indexOf("/");
+                    if (pos == -1) {
+                        method = null;
+                        break;
+                    }
+                    host = request.substring(0, pos);
 
-			// Quick hack for foo.bar.i2p
-		 	if (host.toLowerCase().endsWith( ".i2p")) {
-			    destination=host;
-		 	    host=getHostName(destination);
-			    line=method+" "+request.substring(pos);
-			} else if (host.indexOf(".") != -1) {
-			    // The request must be forwarded to a WWW proxy
-			    destination = wwwProxy;
-			    usingWWWProxy = true;
-			} else {
-			    request=request.substring(pos+1);
-			    pos = request.indexOf("/");
-			    destination=request.substring(0,pos);
-			    line=method+" "+request.substring(pos);
-			}
+                    // Quick hack for foo.bar.i2p
+                    if (host.toLowerCase().endsWith(".i2p")) {
+                        destination = host;
+                        host = getHostName(destination);
+                        line = method + " " + request.substring(pos);
+                    } else if (host.indexOf(".") != -1) {
+                        // The request must be forwarded to a WWW proxy
+                        destination = wwwProxy;
+                        usingWWWProxy = true;
+                        if (_log.shouldLog(Log.DEBUG))
+                            _log.debug(getPrefix() + "Host doesnt end with .i2p and it contains a period [" + host + "]: wwwProxy!");
+                    } else {
+                        request = request.substring(pos + 1);
+                        pos = request.indexOf("/");
+                        destination = request.substring(0, pos);
+                        line = method + " " + request.substring(pos);
+                    }
 
-			boolean isValid = usingWWWProxy ||
-			    isSupportedAddress(host, protocol);
-			if (!isValid) {
-			    if (_log.shouldLog(Log.INFO))
-				_log.info("notValid(" + host + ")");
-			    method=null;
-			    destination=null;
-			    break;
-			} else if (!usingWWWProxy) {
-			    if (_log.shouldLog(Log.INFO))
-				_log.info("host=getHostName(" + destination + ")");
-			    host=getHostName(destination); // hide original host
-			}
+                    boolean isValid = usingWWWProxy || isSupportedAddress(host, protocol);
+                    if (!isValid) {
+                        if (_log.shouldLog(Log.INFO)) _log.info(getPrefix() + "notValid(" + host + ")");
+                        method = null;
+                        destination = null;
+                        break;
+                    } else if (!usingWWWProxy) {
+                        if (_log.shouldLog(Log.INFO)) _log.info(getPrefix() + "host=getHostName(" + destination + ")");
+                        host = getHostName(destination); // hide original host
+                    }
 
-			if (_log.shouldLog(Log.DEBUG)) {
-			    _log.debug("METHOD:"+method+":");
-			    _log.debug("PROTOC:"+protocol+":");
-			    _log.debug("HOST  :"+host+":");
-			    _log.debug("DEST  :"+destination+":");
-			}
-
-		    } else if (line.startsWith("Host: ") && !usingWWWProxy) {
-			line="Host: "+host;
-			if (_log.shouldLog(Log.INFO))
-			    _log.info("Setting host = " + host);
-		    }
-		    newRequest.append(line).append("\r\n"); // HTTP spec
-		    if (line.length()==0)  break;
-		}
-		while (br.ready()) { // empty the buffer (POST requests)
-		    int i=br.read();
-		    if (i != -1) {
-			newRequest.append((char)i);
-		    }
-		}
-		if (method==null || destination==null) {
-		    l.log("No HTTP method found in the request.");
-		    if (out != null) {
-			out.write(ERR_REQUEST_DENIED);
-			out.write("<p /><i>Generated on: ".getBytes());
-			out.write(new Date().toString().getBytes());
-			out.write("</i></body></html>\n".getBytes());
-			out.flush();
-		    }
-		    s.close();
-		    return;
-		}
-		Destination dest=I2PTunnel.destFromName(destination);
-		if (dest == null) {
-		    l.log("Could not resolve "+destination+".");
-		    writeErrorMessage(ERR_DESTINATION_UNKNOWN, out, targetRequest,
-				      usingWWWProxy, destination);
-		    s.close();
-		    return;
-		}
-		String remoteID;
-		I2PSocket i2ps = createI2PSocket(dest);
-		byte[] data=newRequest.toString().getBytes("ISO-8859-1");
-		I2PTunnelRunner runner = new I2PTunnelRunner(s, i2ps, sockLock, data);
-		timeoutThread = new InactivityTimeoutThread(runner, out, targetRequest, usingWWWProxy, s);
-		timeoutThread.start();
-	    } catch (IOException ex) {
-		if (timeoutThread != null) timeoutThread.disable();
-		_log.error("Error sending syn", ex);
-		handleHTTPClientException(ex, out, targetRequest,
-					  usingWWWProxy, wwwProxy);
-		closeSocket(s);
-	    } catch (I2PException ex) {
-		if (timeoutThread != null) timeoutThread.disable();
-		_log.info("Error sending syn", ex);
-		l.log("Unable to reach peer");
-		handleHTTPClientException(ex, out, targetRequest,
-					  usingWWWProxy, wwwProxy);
-		closeSocket(s);
-	    }
+                    if (_log.shouldLog(Log.DEBUG)) {
+                        _log.debug(getPrefix() + "METHOD:" + method + ":");
+                        _log.debug(getPrefix() + "PROTOC:" + protocol + ":");
+                        _log.debug(getPrefix() + "HOST  :" + host + ":");
+                        _log.debug(getPrefix() + "DEST  :" + destination + ":");
+                    }
+                    
+                } else {
+                    if (line.startsWith("Host: ") && !usingWWWProxy) {
+                        line = "Host: " + host;
+                        if (_log.shouldLog(Log.INFO)) 
+                            _log.info(getPrefix() + "Setting host = " + host);
+                    }
+                }
+                
+                if (line.length() == 0) {
+                    newRequest.append("Connection: close\r\n\r\n");
+                    break;
+                } else {
+                    newRequest.append(line).append("\r\n"); // HTTP spec
+                }
+            }
+            if (_log.shouldLog(Log.DEBUG))
+                _log.debug(getPrefix() + "NewRequest header: [" + newRequest.toString() + "]");
+            
+            while (br.ready()) { // empty the buffer (POST requests)
+                int i = br.read();
+                if (i != -1) {
+                    newRequest.append((char) i);
+                }
+            }
+            if (method == null || destination == null) {
+                l.log("No HTTP method found in the request.");
+                if (out != null) {
+                    out.write(ERR_REQUEST_DENIED);
+                    out.write("<p /><i>Generated on: ".getBytes());
+                    out.write(new Date().toString().getBytes());
+                    out.write("</i></body></html>\n".getBytes());
+                    out.flush();
+                }
+                s.close();
+                return;
+            }
+            
+            if (_log.shouldLog(Log.DEBUG))
+                _log.debug(getPrefix() + "Destination: " + destination);
+            
+            Destination dest = I2PTunnel.destFromName(destination);
+            if (dest == null) {
+                l.log("Could not resolve " + destination + ".");
+                if (_log.shouldLog(Log.WARN))
+                    _log.warn("Unable to resolve " + destination + " (proxy? " + usingWWWProxy + ", request: " + targetRequest);
+                writeErrorMessage(ERR_DESTINATION_UNKNOWN, out, targetRequest, usingWWWProxy, destination);
+                s.close();
+                return;
+            }
+            String remoteID;
+            I2PSocket i2ps = createI2PSocket(dest);
+            byte[] data = newRequest.toString().getBytes("ISO-8859-1");
+            I2PTunnelRunner runner = new I2PTunnelRunner(s, i2ps, sockLock, data);
+            timeoutThread = new InactivityTimeoutThread(runner, out, targetRequest, usingWWWProxy, s);
+            timeoutThread.start();
+        } catch (SocketException ex) {
+            if (timeoutThread != null) timeoutThread.disable();
+            _log.info(getPrefix() + "Error trying to connect", ex);
+            l.log(ex.getMessage());
+            handleHTTPClientException(ex, out, targetRequest, usingWWWProxy, wwwProxy);
+            closeSocket(s);
+        } catch (IOException ex) {
+            if (timeoutThread != null) timeoutThread.disable();
+            _log.info(getPrefix() + "Error trying to connect", ex);
+            l.log(ex.getMessage());
+            handleHTTPClientException(ex, out, targetRequest, usingWWWProxy, wwwProxy);
+            closeSocket(s);
+        } catch (I2PException ex) {
+            if (timeoutThread != null) timeoutThread.disable();
+            _log.info("getPrefix() + Error trying to connect", ex);
+            l.log(ex.getMessage());
+            handleHTTPClientException(ex, out, targetRequest, usingWWWProxy, wwwProxy);
+            closeSocket(s);
+        }
     }
 
-    private static final long INACTIVITY_TIMEOUT = 120*1000;
-    
+    private static final long INACTIVITY_TIMEOUT = 120 * 1000;
+    private static volatile long __timeoutId = 0;
+
     private class InactivityTimeoutThread extends I2PThread {
-	
-	    private Socket s;
-	    private I2PTunnelRunner _runner;
-	    private OutputStream _out;
-	    private String _targetRequest;
-	    private boolean _useWWWProxy;
-	    private boolean _disabled;
-	    private Object _disableLock = new Object();
-	    
-	    public InactivityTimeoutThread(I2PTunnelRunner runner, OutputStream out, String targetRequest, boolean useWWWProxy, Socket s) {
-		this.s=s;
-		_runner = runner;
-		_out = out;
-		_targetRequest = targetRequest;
-		_useWWWProxy = useWWWProxy;
-		_disabled = false;
-	    }
-	    public void disable() { 
-		_disabled = true; 
-		synchronized (_disableLock) { _disableLock.notifyAll(); } 
-	    }
-	    public void run() {
-		while (!_disabled) {
-		    if (_runner.isFinished()) {
-			if (_log.shouldLog(Log.INFO))
-			    _log.info("HTTP client request completed prior to timeout");			    
-			return;
-		    }
-		    if (_runner.getLastActivityOn() < Clock.getInstance().now() - INACTIVITY_TIMEOUT) {
-			if (_runner.getStartedOn() < Clock.getInstance().now() - INACTIVITY_TIMEOUT) {
-			    if (_log.shouldLog(Log.WARN))
-				_log.warn("HTTP client request timed out (lastActivity: " + new Date(_runner.getLastActivityOn()) + ", startedOn: " + new Date(_runner.getLastActivityOn()) + ")");
-			    timeout();
-			    return;
-			} else {
-			    // runner hasn't been going to long enough
-			}
-		    } else {
-			// there has been activity in the period
-		    }
-		    synchronized (_disableLock) {
-			try { 
-			    _disableLock.wait(INACTIVITY_TIMEOUT); 
-			} catch (InterruptedException ie) {}
-		    }
-		}
-	    }
-	    private void timeout() {
-		_log.info("Inactivity timeout reached");
-		l.log("Inactivity timeout reached");
-		if (_out != null) {
-		    try {
-			if (_runner.getLastActivityOn() > 0) {
-			    // some  data has been sent, so don't 404 it
-			} else {
-			    writeErrorMessage(ERR_TIMEOUT, _out, _targetRequest,
-					      _useWWWProxy, wwwProxy);
-			}
-		    } catch (IOException ioe) {
-			_log.warn("Error writing out the 'timeout' message", ioe);
-		    }
-		} else { 
-		    _log.warn("Client disconnected before we could say we timed out");
-		}
-		closeSocket(s);
-	    }
+
+        private Socket s;
+        private I2PTunnelRunner _runner;
+        private OutputStream _out;
+        private String _targetRequest;
+        private boolean _useWWWProxy;
+        private boolean _disabled;
+        private Object _disableLock = new Object();
+
+        public InactivityTimeoutThread(I2PTunnelRunner runner, OutputStream out, String targetRequest,
+                                       boolean useWWWProxy, Socket s) {
+            this.s = s;
+            _runner = runner;
+            _out = out;
+            _targetRequest = targetRequest;
+            _useWWWProxy = useWWWProxy;
+            _disabled = false;
+            long timeoutId = ++__timeoutId;
+            setName("InactivityThread " + getPrefix() + timeoutId);
+        }
+
+        public void disable() {
+            _disabled = true;
+            synchronized (_disableLock) {
+                _disableLock.notifyAll();
+            }
+        }
+
+        public void run() {
+            while (!_disabled) {
+                if (_runner.isFinished()) {
+                    if (_log.shouldLog(Log.INFO)) _log.info(getPrefix() + "HTTP client request completed prior to timeout");
+                    return;
+                }
+                if (_runner.getLastActivityOn() < Clock.getInstance().now() - INACTIVITY_TIMEOUT) {
+                    if (_runner.getStartedOn() < Clock.getInstance().now() - INACTIVITY_TIMEOUT) {
+                        if (_log.shouldLog(Log.WARN))
+                            _log.warn(getPrefix() + "HTTP client request timed out (lastActivity: "
+                                      + new Date(_runner.getLastActivityOn()) + ", startedOn: "
+                                      + new Date(_runner.getStartedOn()) + ")");
+                        timeout();
+                        return;
+                    } else {
+                        // runner hasn't been going to long enough
+                    }
+                } else {
+                    // there has been activity in the period
+                }
+                synchronized (_disableLock) {
+                    try {
+                        _disableLock.wait(INACTIVITY_TIMEOUT);
+                    } catch (InterruptedException ie) {
+                    }
+                }
+            }
+        }
+
+        private void timeout() {
+            _log.info(getPrefix() + "Inactivity timeout reached");
+            l.log("Inactivity timeout reached");
+            if (_out != null) {
+                try {
+                    if (_runner.getLastActivityOn() > 0) {
+                        // some  data has been sent, so don't 404 it
+                    } else {
+                        writeErrorMessage(ERR_TIMEOUT, _out, _targetRequest, _useWWWProxy, wwwProxy);
+                    }
+                } catch (IOException ioe) {
+                    _log.warn(getPrefix() + "Error writing out the 'timeout' message", ioe);
+                }
+            } else {
+                _log.warn(getPrefix() + "Client disconnected before we could say we timed out");
+            }
+            closeSocket(s);
+        }
     }
 
     private final static String getHostName(String host) {
-	try {
-	    Destination dest=I2PTunnel.destFromName(host);
-	    if (dest == null) return "i2p";
-	    return dest.toBase64();
-	} catch (DataFormatException dfe) {
-	    return "i2p";
-	}
-    }
-   
-    private static void writeErrorMessage(byte[] errMessage, OutputStream out,
-					  String targetRequest,
-					  boolean usingWWWProxy,
-					  String wwwProxy)
-	throws IOException {
-	if (out != null) {
-	    out.write(errMessage);
-	    if (targetRequest != null) {
-		out.write(targetRequest.getBytes());
-		if (usingWWWProxy)
-		    out.write(("<br>WWW proxy: " +
-			       wwwProxy).getBytes()); 
-	    }
-	    out.write("<p /><i>Generated on: ".getBytes());
-	    out.write(new Date().toString().getBytes());
-	    out.write("</i></body></html>\n".getBytes());
-	    out.flush();
-	}	
+        try {
+            Destination dest = I2PTunnel.destFromName(host);
+            if (dest == null) return "i2p";
+            return dest.toBase64();
+        } catch (DataFormatException dfe) {
+            return "i2p";
+        }
     }
 
-    private static void handleHTTPClientException (Exception ex, OutputStream out,
-						   String targetRequest,
-						   boolean usingWWWProxy,
-						   String wwwProxy) {
-	if (out != null) {
-	    try {
-		writeErrorMessage(ERR_DESTINATION_UNKNOWN, out, targetRequest,
-				  usingWWWProxy, wwwProxy);
-	    } catch (IOException ioe) {
-		_log.warn("Error writing out the 'destination was unknown' "+
-			  "message", ioe);
-	    }
-	} else { 
-	    _log.warn("Client disconnected before we could say that destination "+
-		      "was unknown", ex);
-	}
+    private static void writeErrorMessage(byte[] errMessage, OutputStream out, String targetRequest,
+                                          boolean usingWWWProxy, String wwwProxy) throws IOException {
+        if (out != null) {
+            out.write(errMessage);
+            if (targetRequest != null) {
+                out.write(targetRequest.getBytes());
+                if (usingWWWProxy) out.write(("<br>WWW proxy: " + wwwProxy).getBytes());
+            }
+            out.write("<p /><i>Generated on: ".getBytes());
+            out.write(new Date().toString().getBytes());
+            out.write("</i></body></html>\n".getBytes());
+            out.flush();
+        }
     }
 
-    private final static String SUPPORTED_HOSTS[] = { "i2p", "www.i2p.com",
-						      "i2p." };
-    
+    private void handleHTTPClientException(Exception ex, OutputStream out, String targetRequest,
+                                                  boolean usingWWWProxy, String wwwProxy) {
+                                                      
+        if (_log.shouldLog(Log.WARN))
+            _log.warn("Error sending to " + wwwProxy + " (proxy? " + usingWWWProxy + ", request: " + targetRequest, ex);
+        if (out != null) {
+            try {
+                writeErrorMessage(ERR_DESTINATION_UNKNOWN, out, targetRequest, usingWWWProxy, wwwProxy);
+            } catch (IOException ioe) {
+                _log.warn(getPrefix() + "Error writing out the 'destination was unknown' " + "message", ioe);
+            }
+        } else {
+            _log.warn(getPrefix() + "Client disconnected before we could say that destination " + "was unknown", ex);
+        }
+    }
+
+    private final static String SUPPORTED_HOSTS[] = { "i2p", "www.i2p.com", "i2p."};
+
     private boolean isSupportedAddress(String host, String protocol) {
-	if ( (host == null) || (protocol == null) ) return false;
-	boolean found = false;
-	String lcHost = host.toLowerCase();
-	for (int i = 0; i < SUPPORTED_HOSTS.length; i++) {
-	    if (SUPPORTED_HOSTS[i].equals(lcHost)) {
-		found = true;
-		break;
-	    }
-	}
+        if ((host == null) || (protocol == null)) return false;
+        boolean found = false;
+        String lcHost = host.toLowerCase();
+        for (int i = 0; i < SUPPORTED_HOSTS.length; i++) {
+            if (SUPPORTED_HOSTS[i].equals(lcHost)) {
+                found = true;
+                break;
+            }
+        }
 
-	if (!found) {
-	    try {
-		Destination d = I2PTunnel.destFromName(host);
-		if (d == null) return false;
-	    } catch (DataFormatException dfe) {}
-	}
-	
-	return protocol.equalsIgnoreCase("http://");
+        if (!found) {
+            try {
+                Destination d = I2PTunnel.destFromName(host);
+                if (d == null) return false;
+            } catch (DataFormatException dfe) {
+            }
+        }
+
+        return protocol.equalsIgnoreCase("http://");
     }
 }

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

@@ -6,6 +6,7 @@ package net.i2p.i2ptunnel;
 import java.io.BufferedOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
+import java.io.InterruptedIOException;
 import java.io.OutputStream;
 import java.net.Socket;
 import java.net.SocketException;
@@ -13,26 +14,29 @@ import java.util.HashMap;
 
 import net.i2p.client.I2PSession;
 import net.i2p.client.streaming.I2PSocket;
-import net.i2p.util.Log;
 import net.i2p.util.Clock;
+import net.i2p.util.I2PThread;
+import net.i2p.util.Log;
 
-public class I2PTunnelRunner extends Thread {
+public class I2PTunnelRunner extends I2PThread implements I2PSocket.SocketErrorListener {
     private final static Log _log = new Log(I2PTunnelRunner.class);
-    
+
+    private static volatile long __runnerId;
+    private long _runnerId;
     /** 
      * max bytes streamed in a packet - smaller ones might be filled
      * up to this size. Larger ones are not split (at least not on
      * Sun's impl of BufferedOutputStream), but that is the streaming
      * api's job...
      */
-    static int MAX_PACKET_SIZE = 1024*32;
+    static int MAX_PACKET_SIZE = 1024 * 32;
 
     static final int NETWORK_BUFFER_SIZE = MAX_PACKET_SIZE;
 
     private Socket s;
     private I2PSocket i2ps;
     Object slock, finishLock = new Object();
-    boolean finished=false;
+    boolean finished = false;
     HashMap ostreams, sockets;
     I2PSession session;
     byte[] initialData;
@@ -41,17 +45,18 @@ public class I2PTunnelRunner extends Thread {
     /** when the runner started up */
     private long startedOn;
 
-    public I2PTunnelRunner(Socket s, I2PSocket i2ps, Object slock,
-			   byte[] initialData) {
-	this.s=s;
-	this.i2ps=i2ps;
-	this.slock=slock;
-	this.initialData = initialData;
-	lastActivityOn = -1;
-	startedOn = -1;
-	_log.info("I2PTunnelRunner started");
-	setName("I2PTunnelRunner");
-	start();
+    public I2PTunnelRunner(Socket s, I2PSocket i2ps, Object slock, byte[] initialData) {
+        this.s = s;
+        this.i2ps = i2ps;
+        this.slock = slock;
+        this.initialData = initialData;
+        lastActivityOn = -1;
+        startedOn = Clock.getInstance().now();
+        if (_log.shouldLog(Log.INFO))
+            _log.info("I2PTunnelRunner started");
+        _runnerId = ++__runnerId;
+        setName("I2PTunnelRunner " + _runnerId);
+        start();
     }
 
     /** 
@@ -59,126 +64,148 @@ public class I2PTunnelRunner extends Thread {
      * [aka we're done running the streams]? 
      *
      */
-    public boolean isFinished() { return finished; }
-    
+    public boolean isFinished() {
+        return finished;
+    }
+
     /** 
-     * When was the last data for this runner sent or received?  (-1 if no data
-     * has been transferred yet)
+     * When was the last data for this runner sent or received?  
+     *
+     * @return date (ms since the epoch), or -1 if no data has been transferred yet
      *
      */
-    public long getLastActivityOn() { return lastActivityOn; }
-    private void updateActivity() { lastActivityOn = Clock.getInstance().now(); }
-    
+    public long getLastActivityOn() {
+        return lastActivityOn;
+    }
+
+    private void updateActivity() {
+        lastActivityOn = Clock.getInstance().now();
+    }
+
     /**
      * When this runner started up transferring data
      *
      */
-    public long getStartedOn() { return startedOn; }
-    
-    public void run() {
-	startedOn = Clock.getInstance().now();
-	try {
-	    InputStream in = s.getInputStream();
-	    OutputStream out = new BufferedOutputStream(s.getOutputStream(),
-							NETWORK_BUFFER_SIZE);
-	    InputStream i2pin = i2ps.getInputStream();
-	    OutputStream i2pout = new BufferedOutputStream
-		(i2ps.getOutputStream(), MAX_PACKET_SIZE);
-	    if (initialData != null) {
-		synchronized(slock) {
-		    i2pout.write(initialData);
-		    i2pout.flush();
-		}
-	    }
-	    Thread t1 = new StreamForwarder(in, i2pout);
-	    Thread t2 = new StreamForwarder(i2pin, out);
-	    synchronized(finishLock) {
-		while (!finished) {
-		    finishLock.wait();
-		}
-	    }
-	    // now one connection is dead - kill the other as well.
-	    s.close();
-	    s = null;
-	    i2ps.close();
-	    i2ps = null;
-	    t1.join();
-	    t2.join();
-	} catch (InterruptedException ex) {
-	    _log.error("Interrupted", ex);
-	} catch (IOException ex) {
-	    ex.printStackTrace();
-	    _log.error("Error forwarding", ex);
-	} finally {
-	    try {
-		if (s != null) s.close();
-		if (i2ps != null) i2ps.close();
-	    } catch (IOException ex) {
-		ex.printStackTrace();
-		_log.error("Could not close socket", ex);
-	    }
-	}
+    public long getStartedOn() {
+        return startedOn;
     }
 
-    private class StreamForwarder extends Thread {
+    public void run() {
+        try {
+            InputStream in = s.getInputStream();
+            OutputStream out = new BufferedOutputStream(s.getOutputStream(), NETWORK_BUFFER_SIZE);
+            i2ps.setSocketErrorListener(this);
+            InputStream i2pin = i2ps.getInputStream();
+            OutputStream i2pout = new BufferedOutputStream(i2ps.getOutputStream(), MAX_PACKET_SIZE);
+            if (initialData != null) {
+                synchronized (slock) {
+                    i2pout.write(initialData);
+                    i2pout.flush();
+                }
+            }
+            Thread t1 = new StreamForwarder(in, i2pout);
+            Thread t2 = new StreamForwarder(i2pin, out);
+            synchronized (finishLock) {
+                while (!finished) {
+                    finishLock.wait();
+                }
+            }
+            // now one connection is dead - kill the other as well.
+            s.close();
+            s = null;
+            i2ps.close();
+            i2ps = null;
+            t1.join();
+            t2.join();
+        } catch (InterruptedException ex) {
+            _log.error("Interrupted", ex);
+        } catch (IOException ex) {
+            ex.printStackTrace();
+            _log.debug("Error forwarding", ex);
+        } catch (Exception e) {
+            _log.error("Internal error", e);
+        } finally {
+            try {
+                if (s != null) s.close();
+                if (i2ps != null) i2ps.close();
+            } catch (IOException ex) {
+                ex.printStackTrace();
+                _log.error("Could not close socket", ex);
+            }
+        }
+    }
 
-	InputStream in;
-	OutputStream out;
-	
-	private StreamForwarder(InputStream in, OutputStream out) {
-	    this.in=in;
-	    this.out=out;
-	    setName("StreamForwarder");
-	    start();
-	}
+    public void errorOccurred() {
+        synchronized (finishLock) {
+            finished = true;
+            finishLock.notifyAll();
+        }
+    }
+    
+    private volatile long __forwarderId = 0;
+    
+    private class StreamForwarder extends I2PThread {
 
-	public void run() {
-	    byte[] buffer = new byte[NETWORK_BUFFER_SIZE];
-	    try {
-		int len;
-		while ((len=in.read(buffer)) != -1) {
-		    out.write(buffer, 0, len);
-		    
-		    if (len > 0)
-			updateActivity();
-		    
-		    if (in.available()==0) {
-			try {
-			    Thread.sleep(I2PTunnel.PACKET_DELAY);
-			} catch (InterruptedException e) {
-			    e.printStackTrace();
-			}
-		    }
-		    if (in.available()==0) {
-			out.flush(); // make sure the data get though
-		    }
-		}
-	    } catch (SocketException ex) {
-		// this *will* occur when the other threads closes the socket
-		synchronized(finishLock) {
-		    if (!finished) 
-			_log.error("Error reading and writing", ex);
-		    else
-			_log.warn("You may ignore this", ex);
-		}
-	    } catch (IOException ex) {
-		if (!finished)
-		    _log.error("Error forwarding", ex);
-		else
-		    _log.warn("You may ignore this", ex);
-	    } finally {
-		try {
-		    out.close();
-		    in.close();
-		} catch (IOException ex) {
-		    _log.error("Error closing streams", ex);
-		}
-		synchronized(finishLock) {
-		    finished=true;
-		    finishLock.notifyAll();
-		    // the main thread will close sockets etc. now
-		}
-	    }
-	}
-    }    
+        InputStream in;
+        OutputStream out;
+
+        private StreamForwarder(InputStream in, OutputStream out) {
+            this.in = in;
+            this.out = out;
+            setName("StreamForwarder " + _runnerId + "." + (++__forwarderId));
+            start();
+        }
+
+        public void run() {
+            byte[] buffer = new byte[NETWORK_BUFFER_SIZE];
+            try {
+                int len;
+                while ((len = in.read(buffer)) != -1) {
+                    out.write(buffer, 0, len);
+
+                    if (len > 0) updateActivity();
+
+                    if (in.available() == 0) {
+                        try {
+                            Thread.sleep(I2PTunnel.PACKET_DELAY);
+                        } catch (InterruptedException e) {
+                            e.printStackTrace();
+                        }
+                    }
+                    if (in.available() == 0) {
+                        out.flush(); // make sure the data get though
+                    }
+                }
+            } catch (SocketException ex) {
+                // this *will* occur when the other threads closes the socket
+                synchronized (finishLock) {
+                    if (!finished) {
+                        _log.debug("Socket closed - error reading and writing",
+                                   ex);
+                    }
+                }
+            } catch (InterruptedIOException ex) {
+                _log.warn("Closing connection due to timeout (error: \""
+                          + ex.getMessage() + "\")");
+            } catch (IOException ex) {
+                if (!finished)
+                    _log.error("Error forwarding", ex);
+                else
+                    _log.warn("You may ignore this", ex);
+            } finally {
+                try {
+                    out.close();
+                    in.close();
+                } catch (IOException ex) {
+                    if (_log.shouldLog(Log.WARN))
+                        _log.warn("Error closing streams", ex);
+                }
+                synchronized (finishLock) {
+                    finished = true;
+                    finishLock.notifyAll();
+                    // the main thread will close sockets etc. now
+                }
+            }
+        }
+    }
 }

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

@@ -11,8 +11,10 @@ import java.io.InputStream;
 import java.net.InetAddress;
 import java.net.Socket;
 import java.net.SocketException;
-import java.util.*;
+import java.util.Iterator;
+import java.util.Properties;
 
+import net.i2p.I2PAppContext;
 import net.i2p.I2PException;
 import net.i2p.client.I2PClient;
 import net.i2p.client.I2PClientFactory;
@@ -22,11 +24,11 @@ import net.i2p.client.streaming.I2PSocketManager;
 import net.i2p.client.streaming.I2PSocketManagerFactory;
 import net.i2p.data.Base64;
 import net.i2p.util.EventDispatcher;
+import net.i2p.util.I2PThread;
 import net.i2p.util.Log;
 
-public class I2PTunnelServer extends I2PTunnelTask
-    implements Runnable {
-    
+public class I2PTunnelServer extends I2PTunnelTask implements Runnable {
+
     private final static Log _log = new Log(I2PTunnelServer.class);
 
     private I2PSocketManager sockMgr;
@@ -38,101 +40,158 @@ public class I2PTunnelServer extends I2PTunnelTask
     private int remotePort;
 
     private Logging l;
-    
-    public I2PTunnelServer(InetAddress host, int port, 
-			   String privData, Logging l,
-			   EventDispatcher notifyThis) {
-        super(host+":"+port+" <- "+privData, notifyThis);
-	ByteArrayInputStream bais = new ByteArrayInputStream(Base64.decode(privData));
-	init(host, port, bais, privData, l);
-    }
-    
-    public I2PTunnelServer(InetAddress host, int port,
-			   File privkey, String privkeyname,
-			   Logging l, EventDispatcher notifyThis) {
-        super(host+":"+port+" <- "+privkeyname, notifyThis);
-	try {
-	    init(host, port, new FileInputStream(privkey), privkeyname, l);
-	} catch (IOException ioe) {
-	    _log.error("Error starting server", ioe);
-	    notifyEvent("openServerResult", "error");
-	}
-    }
-    public I2PTunnelServer(InetAddress host, int port,
-			   InputStream privData, String privkeyname,
-			   Logging l, EventDispatcher notifyThis) {
-	super(host+":"+port+" <- "+privkeyname, notifyThis);
-	init(host, port, privData, privkeyname, l);
-    }
-    
-    private void init(InetAddress host, int port, InputStream privData,
-		      String privkeyname, Logging l) {
-	this.l=l;
-	this.remoteHost=host;
-	this.remotePort=port;
-	I2PClient client = I2PClientFactory.createClient();
-	Properties props = new Properties();
-	props.putAll(System.getProperties());
-	synchronized(slock) {
-	    sockMgr = I2PSocketManagerFactory.createManager
-		(privData, I2PTunnel.host,
-		 Integer.parseInt(I2PTunnel.port), props);
-	    
-	}
-	l.log("Ready!");
-	notifyEvent("openServerResult", "ok");
-	open=true;
-	Thread t = new Thread(this);
-	t.setName("Server");
-	t.start();
+
+    private static final long DEFAULT_READ_TIMEOUT = -1; // 3*60*1000;
+    /** default timeout to 3 minutes - override if desired */
+    private long readTimeout = DEFAULT_READ_TIMEOUT;
+
+    public I2PTunnelServer(InetAddress host, int port, String privData, Logging l, EventDispatcher notifyThis) {
+        super(host + ":" + port + " <- " + privData, notifyThis);
+        ByteArrayInputStream bais = new ByteArrayInputStream(Base64.decode(privData));
+        init(host, port, bais, privData, l);
     }
 
+    public I2PTunnelServer(InetAddress host, int port, File privkey, String privkeyname, Logging l,
+                           EventDispatcher notifyThis) {
+        super(host + ":" + port + " <- " + privkeyname, notifyThis);
+        try {
+            init(host, port, new FileInputStream(privkey), privkeyname, l);
+        } catch (IOException ioe) {
+            _log.error("Error starting server", ioe);
+            notifyEvent("openServerResult", "error");
+        }
+    }
+
+    public I2PTunnelServer(InetAddress host, int port, InputStream privData, String privkeyname, Logging l,  EventDispatcher notifyThis) {
+        super(host + ":" + port + " <- " + privkeyname, notifyThis);
+        init(host, port, privData, privkeyname, l);
+    }
+
+    private void init(InetAddress host, int port, InputStream privData, String privkeyname, Logging l) {
+        this.l = l;
+        this.remoteHost = host;
+        this.remotePort = port;
+        I2PClient client = I2PClientFactory.createClient();
+        Properties props = new Properties();
+        props.putAll(System.getProperties());
+        synchronized (slock) {
+            sockMgr = I2PSocketManagerFactory.createManager(privData, I2PTunnel.host, Integer.parseInt(I2PTunnel.port),
+                                                            props);
+
+        }
+        sockMgr.setName("Server");
+        l.log("Ready!");
+        notifyEvent("openServerResult", "ok");
+        open = true;
+    }
+
+    
+    private static volatile long __serverId = 0;
+    
+    /**
+     * Start running the I2PTunnelServer.
+     *
+     */
+    public void startRunning() {
+        Thread t = new I2PThread(this);
+        t.setName("Server " + (++__serverId));
+        t.start();
+    }
+
+    /**
+     * Set the read idle timeout for newly-created connections (in
+     * milliseconds).  After this time expires without data being reached from
+     * the I2P network, the connection itself will be closed.
+     */
+    public void setReadTimeout(long ms) {
+        readTimeout = ms;
+    }
+    
+    /**
+     * Get the read idle timeout for newly-created connections (in
+     * milliseconds).
+     *
+     * @return The read timeout used for connections
+     */
+    public long getReadTimeout() {
+        return readTimeout;
+    }
 
     public boolean close(boolean forced) {
-	if (!open) return true;
-	synchronized(lock) {
-	    if (!forced && sockMgr.listSockets().size() != 0) {
-		l.log("There are still active connections!");
-		for (Iterator it = sockMgr.listSockets().iterator();
-		     it.hasNext();) {
-		    l.log("->"+it.next());
-		}
-		return false;
-	    }
-	    l.log("Shutting down server "+toString());
-	    try {
-		if (i2pss != null) i2pss.close();
-		sockMgr.getSession().destroySession();
-	    } catch (I2PException ex) {
-		_log.error("Error destroying the session", ex);
-		System.exit(1);
-	    }
-	    l.log("Server shut down.");
-	    open=false;
-	    return true;
-	}
+        if (!open) return true;
+        synchronized (lock) {
+            if (!forced && sockMgr.listSockets().size() != 0) {
+                l.log("There are still active connections!");
+                for (Iterator it = sockMgr.listSockets().iterator(); it.hasNext();) {
+                    l.log("->" + it.next());
+                }
+                return false;
+            }
+            l.log("Shutting down server " + toString());
+            try {
+                if (i2pss != null) i2pss.close();
+                sockMgr.getSession().destroySession();
+            } catch (I2PException ex) {
+                _log.error("Error destroying the session", ex);
+                System.exit(1);
+            }
+            l.log("Server shut down.");
+            open = false;
+            return true;
+        }
     }
 
-
     public void run() {
-	try {
-	    I2PServerSocket i2pss = sockMgr.getServerSocket();
-	    while (true) {
-		I2PSocket i2ps = i2pss.accept();
-		//local is fast, so synchronously. Does not need that many
-		//threads.
-		try {
-		    Socket s = new Socket(remoteHost, remotePort);
-		    new I2PTunnelRunner(s, i2ps, slock, null);
-		} catch (SocketException ex) {
-		    i2ps.close();
-		}
-	    }
-	} catch (I2PException ex) {
-	    _log.error("Error while waiting for I2PConnections", ex);
-	} catch (IOException ex) {
-	    _log.error("Error while waiting for I2PConnections", ex);
-	}
-    }    
+        try {
+            I2PServerSocket i2pss = sockMgr.getServerSocket();
+            while (true) {
+                I2PSocket i2ps = i2pss.accept();
+                I2PThread t = new I2PThread(new Handler(i2ps));
+                t.start();
+            }
+        } catch (I2PException ex) {
+            _log.error("Error while waiting for I2PConnections", ex);
+        } catch (IOException ex) {
+            _log.error("Error while waiting for I2PConnections", ex);
+        }
+    }
+    
+    /**
+     * Async handler to keep .accept() from blocking too long.  
+     * todo: replace with a thread pool so we dont get overrun by threads if/when
+     * receiving a lot of connection requests concurrently.
+     *
+     */
+    private class Handler implements Runnable { 
+        private I2PSocket _handleSocket;
+        public Handler(I2PSocket socket) {
+            _handleSocket = socket;
+        }
+        public void run() {
+            long afterAccept = I2PAppContext.getGlobalContext().clock().now();
+            long afterSocket = -1;
+            //local is fast, so synchronously. Does not need that many
+            //threads.
+            try {
+                _handleSocket.setReadTimeout(readTimeout);
+                Socket s = new Socket(remoteHost, remotePort);
+                afterSocket = I2PAppContext.getGlobalContext().clock().now();
+                new I2PTunnelRunner(s, _handleSocket, slock, null);
+            } catch (SocketException ex) {
+                try {
+                    _handleSocket.close();
+                } catch (IOException ioe) {
+                    _log.error("Error while closing the received i2p con", ex);
+                }
+            } catch (IOException ex) {
+                _log.error("Error while waiting for I2PConnections", ex);
+            }
+            
+            long afterHandle = I2PAppContext.getGlobalContext().clock().now();
+            long timeToHandle = afterHandle - afterAccept;
+            if (timeToHandle > 1000)
+                _log.warn("Took a while to handle the request [" + timeToHandle + ", socket create: " + (afterSocket-afterAccept) + "]");
+        }
+    }
 }
 

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

@@ -27,49 +27,86 @@ public abstract class I2PTunnelTask implements EventDispatcher {
     //}
 
     protected I2PTunnelTask(String name, EventDispatcher notifyThis) {
-	attachEventDispatcher(notifyThis);
-	this.name=name;
-	this.id = -1;
+        attachEventDispatcher(notifyThis);
+        this.name = name;
+        this.id = -1;
     }
-    
+
     /** for apps that use multiple I2PTunnel instances */
-    public void setTunnel(I2PTunnel pTunnel) { tunnel = pTunnel; }
-    
+    public void setTunnel(I2PTunnel pTunnel) {
+        tunnel = pTunnel;
+    }
+
     public int getId() {
         return this.id;
     }
 
-    public boolean isOpen() {return open;}
+    public boolean isOpen() {
+        return open;
+    }
 
     public void setId(int id) {
         this.id = id;
     }
 
     protected void setName(String name) {
-        this.name=name;
+        this.name = name;
+    }
+
+    protected void routerDisconnected() {
+        tunnel.routerDisconnected();
     }
 
-    protected void routerDisconnected() { tunnel.routerDisconnected(); }
-    
     public abstract boolean close(boolean forced);
 
-    public void disconnected(I2PSession session) { routerDisconnected(); }
-    public void errorOccurred(I2PSession session, String message,
-			      Throwable error) {}
-    public void reportAbuse(I2PSession session, int severity) {}
-    
+    public void disconnected(I2PSession session) {
+        routerDisconnected();
+    }
+
+    public void errorOccurred(I2PSession session, String message, Throwable error) {
+    }
+
+    public void reportAbuse(I2PSession session, int severity) {
+    }
+
     public String toString() {
-	return name;
+        return name;
     }
 
     /* Required by the EventDispatcher interface */
-    public EventDispatcher getEventDispatcher() { return _event; }
-    public void attachEventDispatcher(EventDispatcher e) { _event.attachEventDispatcher(e.getEventDispatcher()); }
-    public void detachEventDispatcher(EventDispatcher e) { _event.detachEventDispatcher(e.getEventDispatcher()); }
-    public void notifyEvent(String e, Object a) { _event.notifyEvent(e,a); }
-    public Object getEventValue(String n) { return _event.getEventValue(n); }
-    public Set getEvents() { return _event.getEvents(); }
-    public void ignoreEvents() { _event.ignoreEvents(); }
-    public void unIgnoreEvents() { _event.unIgnoreEvents(); }
-    public Object waitEventValue(String n) { return _event.waitEventValue(n); }
-}
+    public EventDispatcher getEventDispatcher() {
+        return _event;
+    }
+
+    public void attachEventDispatcher(EventDispatcher e) {
+        _event.attachEventDispatcher(e.getEventDispatcher());
+    }
+
+    public void detachEventDispatcher(EventDispatcher e) {
+        _event.detachEventDispatcher(e.getEventDispatcher());
+    }
+
+    public void notifyEvent(String e, Object a) {
+        _event.notifyEvent(e, a);
+    }
+
+    public Object getEventValue(String n) {
+        return _event.getEventValue(n);
+    }
+
+    public Set getEvents() {
+        return _event.getEvents();
+    }
+
+    public void ignoreEvents() {
+        _event.ignoreEvents();
+    }
+
+    public void unIgnoreEvents() {
+        _event.unIgnoreEvents();
+    }
+
+    public Object waitEventValue(String n) {
+        return _event.waitEventValue(n);
+    }
+}

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

@@ -14,6 +14,7 @@ import net.i2p.I2PException;
 import net.i2p.client.streaming.I2PSocketManager;
 import net.i2p.data.Destination;
 import net.i2p.util.EventDispatcher;
+import net.i2p.util.I2PThread;
 import net.i2p.util.Log;
 
 public class I2Ping extends I2PTunnelTask implements Runnable {
@@ -21,17 +22,17 @@ public class I2Ping extends I2PTunnelTask implements Runnable {
 
     private static final int PING_COUNT = 3;
     private static final int CPING_COUNT = 5;
-    private static final int PING_TIMEOUT= 5000;
+    private static final int PING_TIMEOUT = 5000;
 
-    private static final long PING_DISTANCE=1000;
+    private static final long PING_DISTANCE = 1000;
 
-    private int MAX_SIMUL_PINGS=10; // not really final...
+    private int MAX_SIMUL_PINGS = 10; // not really final...
 
-    private boolean countPing=false;
+    private boolean countPing = false;
 
     private I2PSocketManager sockMgr;
     private Logging l;
-    private boolean finished=false;
+    private boolean finished = false;
     private String command;
     private long timeout = PING_TIMEOUT;
 
@@ -39,190 +40,183 @@ public class I2Ping extends I2PTunnelTask implements Runnable {
     private int simulPings = 0;
     private long lastPingTime = 0;
 
-    private Object lock = new Object(),  slock = new Object();
+    private Object lock = new Object(), slock = new Object();
 
     //public I2Ping(String cmd, Logging l,
     //		  boolean ownDest) {
     //	I2Ping(cmd, l, (EventDispatcher)null);
     //}
 
-    public I2Ping(String cmd, Logging l,
-		  boolean ownDest, EventDispatcher notifyThis) {
-	super("I2Ping ["+cmd+"]", notifyThis);
-	this.l=l;
-	command=cmd;
-	synchronized(slock) {
-	    if (ownDest) {
-		sockMgr = I2PTunnelClient.buildSocketManager();
-	    } else {
-		sockMgr = I2PTunnelClient.getSocketManager();
-	    }
-	}
-	Thread t = new Thread(this);
-	t.setName("Client");
-	t.start();
-	open=true;
+    public I2Ping(String cmd, Logging l, boolean ownDest, EventDispatcher notifyThis) {
+        super("I2Ping [" + cmd + "]", notifyThis);
+        this.l = l;
+        command = cmd;
+        synchronized (slock) {
+            if (ownDest) {
+                sockMgr = I2PTunnelClient.buildSocketManager();
+            } else {
+                sockMgr = I2PTunnelClient.getSocketManager();
+            }
+        }
+        Thread t = new I2PThread(this);
+        t.setName("Client");
+        t.start();
+        open = true;
     }
 
     public void run() {
-	l.log("*** I2Ping results:");
-	try {
-	    runCommand(command);
-	} catch (InterruptedException ex) {
-	    l.log("*** Interrupted");
-	    _log.error("Pinger interrupted",ex);
-	} catch (IOException ex) {
-	    _log.error("Pinger exception",ex);
-	} 
-	l.log("*** Finished.");
-	synchronized(lock) {
-	    finished=true;
-	}
-	close(false);
+        l.log("*** I2Ping results:");
+        try {
+            runCommand(command);
+        } catch (InterruptedException ex) {
+            l.log("*** Interrupted");
+            _log.error("Pinger interrupted", ex);
+        } catch (IOException ex) {
+            _log.error("Pinger exception", ex);
+        }
+        l.log("*** Finished.");
+        synchronized (lock) {
+            finished = true;
+        }
+        close(false);
     }
 
-    public void runCommand(String cmd) throws InterruptedException,
-					      IOException {
-	if (cmd.startsWith("-t ")) { // timeout
-	    cmd = cmd.substring(3);
-	    int pos = cmd.indexOf(" ");
-	    if (pos == -1) {
-		l.log("Syntax error");
-		return;
-	    } else {
-		timeout = Long.parseLong(cmd.substring(0, pos));
-		cmd=cmd.substring(pos+1);
-	    }
-	}
-	if (cmd.startsWith("-m ")) { // max simultaneous pings
-	    cmd = cmd.substring(3);
-	    int pos = cmd.indexOf(" ");
-	    if (pos == -1) {
-		l.log("Syntax error");
-		return;
-	    } else {
-		MAX_SIMUL_PINGS = Integer.parseInt(cmd.substring(0, pos));
-		cmd=cmd.substring(pos+1);
-	    }
-	}
-	if (cmd.startsWith("-c ")) { // "count" ping
-	    countPing=true;
-	    cmd=cmd.substring(3);
-	}
-	if (cmd.equals("-h")) { // ping all hosts
-	    cmd="-l hosts.txt";
-	}
-	if (cmd.startsWith("-l ")) { // ping a list of hosts
-	    BufferedReader br = new BufferedReader
-		(new FileReader(cmd.substring(3)));
-	    String line;
-	    List pingHandlers = new ArrayList();
-	    while ((line = br.readLine()) != null) {
-		if (line.startsWith("#")) continue; // comments
-		if (line.startsWith(";")) continue; 
-		if (line.startsWith("!")) continue; 
-		if (line.indexOf("=") != -1) { // maybe file is hosts.txt?
-		    line=line.substring(0,line.indexOf("="));
-		}
-		pingHandlers.add(new PingHandler(line));
-	    }
-	    br.close();
-	    for (Iterator it= pingHandlers.iterator(); it.hasNext(); ) {
-		Thread t = (Thread) it.next();
-		t.join();
-	    }
+    public void runCommand(String cmd) throws InterruptedException, IOException {
+        if (cmd.startsWith("-t ")) { // timeout
+            cmd = cmd.substring(3);
+            int pos = cmd.indexOf(" ");
+            if (pos == -1) {
+                l.log("Syntax error");
+                return;
+            } else {
+                timeout = Long.parseLong(cmd.substring(0, pos));
+                cmd = cmd.substring(pos + 1);
+            }
+        }
+        if (cmd.startsWith("-m ")) { // max simultaneous pings
+            cmd = cmd.substring(3);
+            int pos = cmd.indexOf(" ");
+            if (pos == -1) {
+                l.log("Syntax error");
+                return;
+            } else {
+                MAX_SIMUL_PINGS = Integer.parseInt(cmd.substring(0, pos));
+                cmd = cmd.substring(pos + 1);
+            }
+        }
+        if (cmd.startsWith("-c ")) { // "count" ping
+            countPing = true;
+            cmd = cmd.substring(3);
+        }
+        if (cmd.equals("-h")) { // ping all hosts
+            cmd = "-l hosts.txt";
+        }
+        if (cmd.startsWith("-l ")) { // ping a list of hosts
+            BufferedReader br = new BufferedReader(new FileReader(cmd.substring(3)));
+            String line;
+            List pingHandlers = new ArrayList();
+            while ((line = br.readLine()) != null) {
+                if (line.startsWith("#")) continue; // comments
+                if (line.startsWith(";")) continue;
+                if (line.startsWith("!")) continue;
+                if (line.indexOf("=") != -1) { // maybe file is hosts.txt?
+                    line = line.substring(0, line.indexOf("="));
+                }
+                pingHandlers.add(new PingHandler(line));
+            }
+            br.close();
+            for (Iterator it = pingHandlers.iterator(); it.hasNext();) {
+                Thread t = (Thread) it.next();
+                t.join();
+            }
 
-	} else {
-	    Thread t = new PingHandler(cmd);
-	    t.join();
-	}
+        } else {
+            Thread t = new PingHandler(cmd);
+            t.join();
+        }
     }
 
     public boolean close(boolean forced) {
-	if (!open) return true;
-	synchronized(lock) {
-	    if (!forced && !finished) {
-		l.log("There are still pings running!");
-		return false;
-	    }
-	    l.log("Closing pinger "+toString());
-	    l.log("Pinger closed.");
-	    open=false;
-	    return true;
-	}
+        if (!open) return true;
+        synchronized (lock) {
+            if (!forced && !finished) {
+                l.log("There are still pings running!");
+                return false;
+            }
+            l.log("Closing pinger " + toString());
+            l.log("Pinger closed.");
+            open = false;
+            return true;
+        }
     }
 
     public boolean ping(Destination dest) throws I2PException {
-	try {
-	    synchronized(simulLock) {
-		while (simulPings >= MAX_SIMUL_PINGS) {
-		    simulLock.wait();
-		}
-		simulPings++;
-		while (lastPingTime + PING_DISTANCE >
-		       System.currentTimeMillis()) {
-		    // no wait here, to delay all pingers
-		    Thread.sleep(PING_DISTANCE/2);
-		}
-		lastPingTime=System.currentTimeMillis();
-	    }
-	    boolean sent = sockMgr.ping(dest, PING_TIMEOUT);
-	    synchronized(simulLock) {
-		simulPings--;
-		simulLock.notifyAll();
-	    }
-	    return sent;
-	} catch (InterruptedException ex) {
-	    _log.error("Interrupted", ex);
-	    return false;
-	}
+        try {
+            synchronized (simulLock) {
+                while (simulPings >= MAX_SIMUL_PINGS) {
+                    simulLock.wait();
+                }
+                simulPings++;
+                while (lastPingTime + PING_DISTANCE > System.currentTimeMillis()) {
+                    // no wait here, to delay all pingers
+                    Thread.sleep(PING_DISTANCE / 2);
+                }
+                lastPingTime = System.currentTimeMillis();
+            }
+            boolean sent = sockMgr.ping(dest, PING_TIMEOUT);
+            synchronized (simulLock) {
+                simulPings--;
+                simulLock.notifyAll();
+            }
+            return sent;
+        } catch (InterruptedException ex) {
+            _log.error("Interrupted", ex);
+            return false;
+        }
     }
-	
 
+    public class PingHandler extends I2PThread {
+        private String destination;
 
-    public class PingHandler extends Thread {
-	private String destination;
-	
-	public PingHandler(String dest) {
-	    this.destination=dest;
-	    setName("PingHandler for " + dest);
-	    start();
-	}
-	
-	public void run() {
-	    try {
-		Destination dest=I2PTunnel.destFromName(destination);
-		if (dest == null) {
-		    synchronized(lock) { // Logger is not thread safe
-			l.log("Unresolvable: "+destination+"");
-		    }
-		    return;
-		}
-		int cnt = countPing ? CPING_COUNT : PING_COUNT;
-		StringBuffer pingResults = new StringBuffer
-		    (2*cnt+ destination.length()+3);
-		for (int i=0;i<cnt; i++) {
-		    boolean sent;
-		    sent = ping(dest);
-		    if (countPing) {
-			if (!sent) {
-			    pingResults.append(i).append(" ");
-			    break;
-			} else if (i == cnt - 1) {
-			    pingResults.append("+ ");
-			}
-		    } else {
-			pingResults.append(sent?"+ ":"- ");
-		    }
-//		    System.out.println(sent+" -> "+destination);
-		}
-		pingResults.append("  ").append(destination);
-		synchronized(lock) { // Logger is not thread safe
-		    l.log(pingResults.toString());
-		}
-	    } catch (I2PException ex) {
-		_log.error("Error pinging " + destination, ex);
-	    }
-	}
+        public PingHandler(String dest) {
+            this.destination = dest;
+            setName("PingHandler for " + dest);
+            start();
+        }
+
+        public void run() {
+            try {
+                Destination dest = I2PTunnel.destFromName(destination);
+                if (dest == null) {
+                    synchronized (lock) { // Logger is not thread safe
+                        l.log("Unresolvable: " + destination + "");
+                    }
+                    return;
+                }
+                int cnt = countPing ? CPING_COUNT : PING_COUNT;
+                StringBuffer pingResults = new StringBuffer(2 * cnt + destination.length() + 3);
+                for (int i = 0; i < cnt; i++) {
+                    boolean sent;
+                    sent = ping(dest);
+                    if (countPing) {
+                        if (!sent) {
+                            pingResults.append(i).append(" ");
+                            break;
+                        } else if (i == cnt - 1) {
+                            pingResults.append("+ ");
+                        }
+                    } else {
+                        pingResults.append(sent ? "+ " : "- ");
+                    }
+                    //		    System.out.println(sent+" -> "+destination);
+                }
+                pingResults.append("  ").append(destination);
+                synchronized (lock) { // Logger is not thread safe
+                    l.log(pingResults.toString());
+                }
+            } catch (I2PException ex) {
+                _log.error("Error pinging " + destination, ex);
+            }
+        }
     }
-}
+}

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

@@ -3,7 +3,6 @@
  */
 package net.i2p.i2ptunnel;
 
-
 public interface Logging {
     public void log(String s);
-}
+}

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

@@ -151,283 +151,285 @@ public class TunnelManager implements Runnable {
     private I2PTunnel _tunnel;
     private ServerSocket _socket;
     private boolean _keepAccepting;
-    
+
     public TunnelManager(int listenPort) {
-	this(null, listenPort);
+        this(null, listenPort);
     }
+
     public TunnelManager(String listenHost, int listenPort) {
-	_tunnel = new I2PTunnel();
-	_keepAccepting = true;
-	try {
-	    if (listenHost != null) {
-		_socket = new ServerSocket(listenPort, 0, InetAddress.getByName(listenHost));
-		_log.info("Listening for tunnel management clients on " + listenHost + ":" + listenPort);
-	    } else {
-		_socket = new ServerSocket(listenPort);
-		_log.info("Listening for tunnel management clients on localhost:" + listenPort);
-	    }
-	} catch (Exception e) {
-	    _log.error("Error starting up tunnel management listener on " + listenPort, e);
-	}
+        _tunnel = new I2PTunnel();
+        _keepAccepting = true;
+        try {
+            if (listenHost != null) {
+                _socket = new ServerSocket(listenPort, 0, InetAddress.getByName(listenHost));
+                _log.info("Listening for tunnel management clients on " + listenHost + ":" + listenPort);
+            } else {
+                _socket = new ServerSocket(listenPort);
+                _log.info("Listening for tunnel management clients on localhost:" + listenPort);
+            }
+        } catch (Exception e) {
+            _log.error("Error starting up tunnel management listener on " + listenPort, e);
+        }
     }
 
     public static void main(String args[]) {
-	int port = 7676;
-	String host = null;
-	if (args.length == 1) {
-	    try {
-		port = Integer.parseInt(args[0]);
-	    } catch (NumberFormatException nfe) {
-		_log.error("Usage: TunnelManager [host] [port]");
-		return;
-	    }
-	} else if (args.length == 2) {
-	    host = args[0];
-	    try {
-		port = Integer.parseInt(args[1]);
-	    } catch (NumberFormatException nfe) {
-		_log.error("Usage: TunnelManager [host] [port]");
-		return;
-	    }
-	}
+        int port = 7676;
+        String host = null;
+        if (args.length == 1) {
+            try {
+                port = Integer.parseInt(args[0]);
+            } catch (NumberFormatException nfe) {
+                _log.error("Usage: TunnelManager [host] [port]");
+                return;
+            }
+        } else if (args.length == 2) {
+            host = args[0];
+            try {
+                port = Integer.parseInt(args[1]);
+            } catch (NumberFormatException nfe) {
+                _log.error("Usage: TunnelManager [host] [port]");
+                return;
+            }
+        }
 
-	TunnelManager mgr = new TunnelManager(host, port);
-	Thread t = new Thread(mgr, "Listener");
-	t.start();
+        TunnelManager mgr = new TunnelManager(host, port);
+        Thread t = new I2PThread(mgr, "Listener");
+        t.start();
     }
-    
+
     public void run() {
-	if (_socket == null) {
-	    _log.error("Unable to start listening, since the socket was not bound.  Already running?");
-	    return;
-	}
-	_log.debug("Running");
-	try {
-	    while (_keepAccepting) {
-		Socket socket = _socket.accept();
-		_log.debug("Client accepted");
-		if (socket != null) {
-		    Thread t = new I2PThread(new TunnelManagerClientRunner(this, socket));
-		    t.setName("TunnelManager Client");
-		    t.setPriority(I2PThread.MIN_PRIORITY);
-		    t.start();
-		}
-	    }
-	} catch (IOException ioe) {
-	    _log.error("Error accepting connections", ioe);
-	} catch (Exception e) {
-	    _log.error("Other error?!", e);
-	} finally {
-	    if (_socket != null) try { _socket.close(); } catch (IOException ioe) {}
-	} 
-	try { Thread.sleep(5000); } catch (InterruptedException ie) {}
+        if (_socket == null) {
+            _log.error("Unable to start listening, since the socket was not bound.  Already running?");
+            return;
+        }
+        _log.debug("Running");
+        try {
+            while (_keepAccepting) {
+                Socket socket = _socket.accept();
+                _log.debug("Client accepted");
+                if (socket != null) {
+                    Thread t = new I2PThread(new TunnelManagerClientRunner(this, socket));
+                    t.setName("TunnelManager Client");
+                    t.setPriority(I2PThread.MIN_PRIORITY);
+                    t.start();
+                }
+            }
+        } catch (IOException ioe) {
+            _log.error("Error accepting connections", ioe);
+        } catch (Exception e) {
+            _log.error("Other error?!", e);
+        } finally {
+            if (_socket != null) try {
+                _socket.close();
+            } catch (IOException ioe) {
+            }
+        }
+        try {
+            Thread.sleep(5000);
+        } catch (InterruptedException ie) {
+        }
     }
 
     public void error(String msg, OutputStream out) throws IOException {
-	out.write(msg.getBytes());
-	out.write('\n');
+        out.write(msg.getBytes());
+        out.write('\n');
     }
-	
+
     public void processQuit(OutputStream out) throws IOException {
-	out.write("Nice try".getBytes());
-	out.write('\n');
+        out.write("Nice try".getBytes());
+        out.write('\n');
     }
-    
+
     public void processList(OutputStream out) throws IOException {
-	BufferLogger buf = new BufferLogger();
-	long startCommand = Clock.getInstance().now();
-	_tunnel.runCommand("list", buf);
-	Object obj = _tunnel.waitEventValue("listDone");
-	long endCommand = Clock.getInstance().now();
-	String str = buf.getBuffer();
-	_log.debug("ListDone complete after " + (endCommand-startCommand) + "ms: [" + str + "]");
-	out.write(str.getBytes());
-	out.write('\n');
-	buf.ignoreFurtherActions();
+        BufferLogger buf = new BufferLogger();
+        long startCommand = Clock.getInstance().now();
+        _tunnel.runCommand("list", buf);
+        Object obj = _tunnel.waitEventValue("listDone");
+        long endCommand = Clock.getInstance().now();
+        String str = buf.getBuffer();
+        _log.debug("ListDone complete after " + (endCommand - startCommand) + "ms: [" + str + "]");
+        out.write(str.getBytes());
+        out.write('\n');
+        buf.ignoreFurtherActions();
     }
 
     public void processListenOn(String ip, OutputStream out) throws IOException {
-	BufferLogger buf = new BufferLogger();
-	_tunnel.runCommand("listen_on " + ip, buf);
-	String status = (String)_tunnel.waitEventValue("listen_onResult");
-	out.write((status + "\n").getBytes());
-	buf.ignoreFurtherActions();
+        BufferLogger buf = new BufferLogger();
+        _tunnel.runCommand("listen_on " + ip, buf);
+        String status = (String) _tunnel.waitEventValue("listen_onResult");
+        out.write((status + "\n").getBytes());
+        buf.ignoreFurtherActions();
     }
-    
+
     /**
      * "lookup <name>" returns with the result in base64, else "Unknown host" [or something like that],
      * then a newline.
      *
      */
     public void processLookup(String name, OutputStream out) throws IOException {
-	BufferLogger buf = new BufferLogger();
-	_tunnel.runCommand("lookup " + name, buf);
-	String rv = (String)_tunnel.waitEventValue("lookupResult");
-	out.write(rv.getBytes());
-	out.write('\n');
-	buf.ignoreFurtherActions();
+        BufferLogger buf = new BufferLogger();
+        _tunnel.runCommand("lookup " + name, buf);
+        String rv = (String) _tunnel.waitEventValue("lookupResult");
+        out.write(rv.getBytes());
+        out.write('\n');
+        buf.ignoreFurtherActions();
     }
 
     public void processTestDestination(String destKey, OutputStream out) throws IOException {
-	try { 
-	    Destination d = new Destination(); 
-	    d.fromBase64(destKey); 
-	    out.write("valid\n".getBytes());
-	} catch (DataFormatException dfe) { 
-	    out.write("invalid\n".getBytes());
-	}
-	out.flush();
+        try {
+            Destination d = new Destination();
+            d.fromBase64(destKey);
+            out.write("valid\n".getBytes());
+        } catch (DataFormatException dfe) {
+            out.write("invalid\n".getBytes());
+        }
+        out.flush();
     }
-    
+
     public void processConvertPrivate(String priv, OutputStream out) throws IOException {
-	try {
-	    Destination dest = new Destination();
-	    dest.fromBase64(priv);
-	    String str = dest.toBase64();
-	    out.write(str.getBytes());
-	    out.write('\n');
-	} catch (DataFormatException dfe) {
-	    _log.error("Error converting private data", dfe);
-	    out.write("Error converting private key\n".getBytes());
-	}
+        try {
+            Destination dest = new Destination();
+            dest.fromBase64(priv);
+            String str = dest.toBase64();
+            out.write(str.getBytes());
+            out.write('\n');
+        } catch (DataFormatException dfe) {
+            _log.error("Error converting private data", dfe);
+            out.write("Error converting private key\n".getBytes());
+        }
     }
-    
+
     public void processClose(String which, boolean forced, OutputStream out) throws IOException {
-	BufferLogger buf = new BufferLogger();
-	_tunnel.runCommand((forced?"close forced ":"close ") + which, buf);
-	String str = (String)_tunnel.waitEventValue("closeResult");
-	out.write((str + "\n").getBytes());
-	buf.ignoreFurtherActions();
+        BufferLogger buf = new BufferLogger();
+        _tunnel.runCommand((forced ? "close forced " : "close ") + which, buf);
+        String str = (String) _tunnel.waitEventValue("closeResult");
+        out.write((str + "\n").getBytes());
+        buf.ignoreFurtherActions();
     }
-    
+
     /**
      * "genkey" returns with the base64 of the destination, followed by a tab, then the base64 of that
      * destination's private keys, then a newline.
      *
      */
     public void processGenKey(OutputStream out) throws IOException {
-	BufferLogger buf = new BufferLogger();
-	_tunnel.runCommand("gentextkeys", buf);
-	String priv = (String)_tunnel.waitEventValue("privateKey");
-	String pub = (String)_tunnel.waitEventValue("publicDestination");
-	out.write((pub + "\t" + priv).getBytes());
-	out.write('\n');
-	buf.ignoreFurtherActions();
+        BufferLogger buf = new BufferLogger();
+        _tunnel.runCommand("gentextkeys", buf);
+        String priv = (String) _tunnel.waitEventValue("privateKey");
+        String pub = (String) _tunnel.waitEventValue("publicDestination");
+        out.write((pub + "\t" + priv).getBytes());
+        out.write('\n');
+        buf.ignoreFurtherActions();
     }
-    
+
     public void processOpenClient(int listenPort, String peer, OutputStream out) throws IOException {
-	BufferLogger buf = new BufferLogger();
-	_tunnel.runCommand("client " + listenPort + " " + peer, buf);
-	Integer taskId = (Integer)_tunnel.waitEventValue("clientTaskId");
-	if (taskId.intValue() < 0) {
-	    out.write("error\n".getBytes());
-	    buf.ignoreFurtherActions();
-	    return;
-	}
-	String rv = (String)_tunnel.waitEventValue("openClientResult");
-	if (rv.equals("error")) {
-	    out.write((rv + "\n").getBytes());
-	    buf.ignoreFurtherActions();
-	    return;
-	}
+        BufferLogger buf = new BufferLogger();
+        _tunnel.runCommand("client " + listenPort + " " + peer, buf);
+        Integer taskId = (Integer) _tunnel.waitEventValue("clientTaskId");
+        if (taskId.intValue() < 0) {
+            out.write("error\n".getBytes());
+            buf.ignoreFurtherActions();
+            return;
+        }
+        String rv = (String) _tunnel.waitEventValue("openClientResult");
+        if (rv.equals("error")) {
+            out.write((rv + "\n").getBytes());
+            buf.ignoreFurtherActions();
+            return;
+        }
 
-	if (listenPort != 0) {
-	    out.write((rv + " [" + taskId.intValue() + "]\n").getBytes());
-	    buf.ignoreFurtherActions();
-	    return;
-	}
-	Integer port = (Integer)_tunnel.waitEventValue("clientLocalPort");
-	out.write((rv + " " + port.intValue() + " [" + taskId.intValue()
-		   + "]\n").getBytes());
-	buf.ignoreFurtherActions();
+        if (listenPort != 0) {
+            out.write((rv + " [" + taskId.intValue() + "]\n").getBytes());
+            buf.ignoreFurtherActions();
+            return;
+        }
+        Integer port = (Integer) _tunnel.waitEventValue("clientLocalPort");
+        out.write((rv + " " + port.intValue() + " [" + taskId.intValue() + "]\n").getBytes());
+        buf.ignoreFurtherActions();
     }
 
-    public void processOpenHTTPClient(int listenPort,
-				      String proxy,
-				      OutputStream out) throws IOException {
-	BufferLogger buf = new BufferLogger();
-	_tunnel.runCommand("httpclient " + listenPort + " " + proxy, buf);
-	Integer taskId = (Integer)_tunnel.waitEventValue("httpclientTaskId");
-	if (taskId.intValue() < 0) {
-	    out.write("error\n".getBytes());
-	    buf.ignoreFurtherActions();
-	    return;
-	}
-	String rv = (String)_tunnel.waitEventValue("openHTTPClientResult");
-	if (rv.equals("error")) {
-	    out.write((rv + "\n").getBytes());
-	    buf.ignoreFurtherActions();
-	    return;
-	}
+    public void processOpenHTTPClient(int listenPort, String proxy, OutputStream out) throws IOException {
+        BufferLogger buf = new BufferLogger();
+        _tunnel.runCommand("httpclient " + listenPort + " " + proxy, buf);
+        Integer taskId = (Integer) _tunnel.waitEventValue("httpclientTaskId");
+        if (taskId.intValue() < 0) {
+            out.write("error\n".getBytes());
+            buf.ignoreFurtherActions();
+            return;
+        }
+        String rv = (String) _tunnel.waitEventValue("openHTTPClientResult");
+        if (rv.equals("error")) {
+            out.write((rv + "\n").getBytes());
+            buf.ignoreFurtherActions();
+            return;
+        }
 
-	if (listenPort != 0) {
-	    out.write((rv + " [" + taskId.intValue() + "]\n").getBytes());
-	    buf.ignoreFurtherActions();
-	    return;
-	}
-	Integer port = (Integer)_tunnel.waitEventValue("clientLocalPort");
-	out.write((rv + " " + port.intValue() + " [" + taskId.intValue()
-		   + "]\n").getBytes());
-	buf.ignoreFurtherActions();
-    }
-    
-    public void processOpenSOCKSTunnel(int listenPort,
-				       OutputStream out) throws IOException {
-	BufferLogger buf = new BufferLogger();
-	_tunnel.runCommand("sockstunnel " + listenPort, buf);
-	Integer taskId = (Integer)_tunnel.waitEventValue("sockstunnelTaskId");
-	if (taskId.intValue() < 0) {
-	    out.write("error\n".getBytes());
-	    buf.ignoreFurtherActions();
-	    return;
-	}
-	String rv = (String)_tunnel.waitEventValue("openSOCKSTunnelResult");
-	if (rv.equals("error")) {
-	    out.write((rv + "\n").getBytes());
-	    buf.ignoreFurtherActions();
-	    return;
-	}
-
-	if (listenPort != 0) {
-	    out.write((rv + " [" + taskId.intValue() + "]\n").getBytes());
-	    buf.ignoreFurtherActions();
-	    return;
-	}
-	Integer port = (Integer)_tunnel.waitEventValue("clientLocalPort");
-	out.write((rv + " " + port.intValue() + " [" + taskId.intValue()
-		   + "]\n").getBytes());
-	buf.ignoreFurtherActions();
+        if (listenPort != 0) {
+            out.write((rv + " [" + taskId.intValue() + "]\n").getBytes());
+            buf.ignoreFurtherActions();
+            return;
+        }
+        Integer port = (Integer) _tunnel.waitEventValue("clientLocalPort");
+        out.write((rv + " " + port.intValue() + " [" + taskId.intValue() + "]\n").getBytes());
+        buf.ignoreFurtherActions();
     }
 
-    public void processOpenServer(String serverHost, int serverPort, String privateKeys, OutputStream out) throws IOException {
-	BufferLogger buf = new BufferLogger();
-	_tunnel.runCommand("textserver " + serverHost + " " + serverPort + " " + privateKeys, buf);
-	Integer taskId = (Integer)_tunnel.waitEventValue("serverTaskId");
-	if (taskId.intValue() < 0) {
-	    out.write("error\n".getBytes());
-	    buf.ignoreFurtherActions();
-	    return;
-	}
-	
-	String rv = (String)_tunnel.waitEventValue("openServerResult");
+    public void processOpenSOCKSTunnel(int listenPort, OutputStream out) throws IOException {
+        BufferLogger buf = new BufferLogger();
+        _tunnel.runCommand("sockstunnel " + listenPort, buf);
+        Integer taskId = (Integer) _tunnel.waitEventValue("sockstunnelTaskId");
+        if (taskId.intValue() < 0) {
+            out.write("error\n".getBytes());
+            buf.ignoreFurtherActions();
+            return;
+        }
+        String rv = (String) _tunnel.waitEventValue("openSOCKSTunnelResult");
+        if (rv.equals("error")) {
+            out.write((rv + "\n").getBytes());
+            buf.ignoreFurtherActions();
+            return;
+        }
 
-	if (rv.equals("error")) {
-	    out.write((rv + "\n").getBytes());
-	    buf.ignoreFurtherActions();
-	    return;
-	}
-
-	out.write((rv + " [" + taskId.intValue() + "]\n").getBytes());
-	buf.ignoreFurtherActions();
+        if (listenPort != 0) {
+            out.write((rv + " [" + taskId.intValue() + "]\n").getBytes());
+            buf.ignoreFurtherActions();
+            return;
+        }
+        Integer port = (Integer) _tunnel.waitEventValue("clientLocalPort");
+        out.write((rv + " " + port.intValue() + " [" + taskId.intValue() + "]\n").getBytes());
+        buf.ignoreFurtherActions();
     }
-    
+
+    public void processOpenServer(String serverHost, int serverPort, String privateKeys, OutputStream out)
+                                                                                                          throws IOException {
+        BufferLogger buf = new BufferLogger();
+        _tunnel.runCommand("textserver " + serverHost + " " + serverPort + " " + privateKeys, buf);
+        Integer taskId = (Integer) _tunnel.waitEventValue("serverTaskId");
+        if (taskId.intValue() < 0) {
+            out.write("error\n".getBytes());
+            buf.ignoreFurtherActions();
+            return;
+        }
+
+        String rv = (String) _tunnel.waitEventValue("openServerResult");
+
+        if (rv.equals("error")) {
+            out.write((rv + "\n").getBytes());
+            buf.ignoreFurtherActions();
+            return;
+        }
+
+        out.write((rv + " [" + taskId.intValue() + "]\n").getBytes());
+        buf.ignoreFurtherActions();
+    }
+
     /**
      * Frisbee.
      *
      */
     public void unknownCommand(String command, OutputStream out) throws IOException {
-	out.write("Unknown command: ".getBytes());
-	out.write(command.getBytes());
-	out.write("\n".getBytes());
+        out.write("Unknown command: ".getBytes());
+        out.write(command.getBytes());
+        out.write("\n".getBytes());
     }
-}
+}

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

@@ -3,15 +3,14 @@
  */
 package net.i2p.i2ptunnel;
 
-import net.i2p.util.Log;
-
-import java.util.StringTokenizer;
-
-import java.net.Socket;
+import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStreamReader;
-import java.io.BufferedReader;
 import java.io.OutputStream;
+import java.net.Socket;
+import java.util.StringTokenizer;
+
+import net.i2p.util.Log;
 
 /**
  * Runner thread that reads commands from the socket and fires off commands to
@@ -22,172 +21,174 @@ class TunnelManagerClientRunner implements Runnable {
     private final static Log _log = new Log(TunnelManagerClientRunner.class);
     private TunnelManager _mgr;
     private Socket _clientSocket;
-    
-    public TunnelManagerClientRunner(TunnelManager mgr, Socket socket) {
-	_clientSocket = socket;
-	_mgr = mgr;
-    }
-    
-    public void run() {
-	_log.debug("Client running");
-	try {
-	    BufferedReader reader = new BufferedReader(new InputStreamReader(_clientSocket.getInputStream()));
-	    OutputStream out = _clientSocket.getOutputStream();
 
-	    String cmd = reader.readLine();
-	    if (cmd != null)
-		processCommand(cmd, out);
-	} catch (IOException ioe) {
-	    _log.error("Error processing client commands", ioe);
-	} finally {
-	    if (_clientSocket != null) try { _clientSocket.close(); } catch (IOException ioe) {}
-	}
-	_log.debug("Client closed");
+    public TunnelManagerClientRunner(TunnelManager mgr, Socket socket) {
+        _clientSocket = socket;
+        _mgr = mgr;
     }
-    
+
+    public void run() {
+        _log.debug("Client running");
+        try {
+            BufferedReader reader = new BufferedReader(new InputStreamReader(_clientSocket.getInputStream()));
+            OutputStream out = _clientSocket.getOutputStream();
+
+            String cmd = reader.readLine();
+            if (cmd != null) processCommand(cmd, out);
+        } catch (IOException ioe) {
+            _log.error("Error processing client commands", ioe);
+        } finally {
+            if (_clientSocket != null) try {
+                _clientSocket.close();
+            } catch (IOException ioe) {
+            }
+        }
+        _log.debug("Client closed");
+    }
+
     /**
      * Parse the command string and fire off the appropriate tunnelManager method,
      * sending the results to the output stream
      */
     private void processCommand(String command, OutputStream out) throws IOException {
-	_log.debug("Processing [" + command + "]");
-	StringTokenizer tok = new StringTokenizer(command);
-	if (!tok.hasMoreTokens()) {
-	    _mgr.unknownCommand(command, out);
-	} else {
-	    String cmd = tok.nextToken();
-	    if ("quit".equalsIgnoreCase(cmd)) {
-		_mgr.processQuit(out);
-	    } else if ("lookup".equalsIgnoreCase(cmd)) {
-		if (tok.hasMoreTokens())
-		    _mgr.processLookup(tok.nextToken(), out);
-		else
-		    _mgr.error("Usage: lookup <hostname>", out);
-	    } else if ("testdestination".equalsIgnoreCase(cmd)) {
-		if (tok.hasMoreTokens())
-		    _mgr.processTestDestination(tok.nextToken(), out);
-		else
-		    _mgr.error("Usage: testdestination <publicDestination>", out);
-	    } else if ("convertprivate".equalsIgnoreCase(cmd)) {
-		if (tok.hasMoreTokens())
-		    _mgr.processConvertPrivate(tok.nextToken(), out);
-		else
-		    _mgr.error("Usage: convertprivate <privateData>", out);
-	    } else if ("close".equalsIgnoreCase(cmd)) {
-		if (tok.hasMoreTokens()) {
-		    String closeArg;
-		    if ((closeArg = tok.nextToken()).equals("forced")) {
-			if (tok.hasMoreTokens()) {
-			    _mgr.processClose(tok.nextToken(), true, out);
-			} else {
-			    _mgr.error("Usage: close [forced] <jobnumber>|all", out);
-			}
-		    } else {                
-   		        _mgr.processClose(closeArg, false, out);
-		    }
-		} else {
-		    _mgr.error("Usage: close [forced] <jobnumber>|all", out);
-		}
-	    } else if ("genkey".equalsIgnoreCase(cmd)) {
-		_mgr.processGenKey(out);
-	    } else if ("list".equalsIgnoreCase(cmd)) {
-		_mgr.processList(out);
-	    } else if ("listen_on".equalsIgnoreCase(cmd)) {
-		if (tok.hasMoreTokens()) {
-		    _mgr.processListenOn(tok.nextToken(), out);
-		} else {
-		    _mgr.error("Usage: listen_on <ip>", out);
-		}
-	    } else if ("openclient".equalsIgnoreCase(cmd)) {
-		int listenPort = 0;
-		String peer = null;
-		if (!tok.hasMoreTokens()) {
-		    _mgr.error("Usage: openclient <listenPort> <peer>", out);
-		    return;
-		}
-		try {
-		    String portStr = tok.nextToken();
-		    listenPort = Integer.parseInt(portStr);
-		} catch (NumberFormatException nfe) {
-		    _mgr.error("Bad listen port", out);
-		    return;
-		}
-		if (!tok.hasMoreTokens()) {
-		    _mgr.error("Usage: openclient <listenport> <peer>", out);
-		    return;
-		}
-		peer = tok.nextToken();
-		_mgr.processOpenClient(listenPort, peer, out);
-	    } else if ("openhttpclient".equalsIgnoreCase(cmd)) {
-		int listenPort = 0;
-		String proxy = "squid.i2p";
-		if (!tok.hasMoreTokens()) {
-		    _mgr.error("Usage: openhttpclient <listenPort> [<proxy>]",out);
-		    return;
-		}
-		try {
-		    String portStr = tok.nextToken();
-		    listenPort = Integer.parseInt(portStr);
-		} catch (NumberFormatException nfe) {
-		    _mgr.error("Bad listen port", out);
-		    return;
-		}
-		if (tok.hasMoreTokens()) {
-		    proxy = tok.nextToken();
-		}
-		if (tok.hasMoreTokens()) {
-		    _mgr.error("Usage: openclient <listenport> [<proxy>]",out);
-		    return;
-		}
-		_mgr.processOpenHTTPClient(listenPort, proxy, out);
-	    } else if ("opensockstunnel".equalsIgnoreCase(cmd)) {
-		int listenPort = 0;
-		if (!tok.hasMoreTokens()) {
-		    _mgr.error("Usage: opensockstunnel <listenPort>",out);
-		    return;
-		}
-		try {
-		    String portStr = tok.nextToken();
-		    listenPort = Integer.parseInt(portStr);
-		} catch (NumberFormatException nfe) {
-		    _mgr.error("Bad listen port", out);
-		    return;
-		}
-		if (tok.hasMoreTokens()) {
-		    _mgr.error("Usage: opensockstunnel <listenport>",out);
-		    return;
-		}
-		_mgr.processOpenSOCKSTunnel(listenPort, out);
-	    } else if ("openserver".equalsIgnoreCase(cmd)) {
-		int listenPort = 0;
-		String serverHost = null;
-		String serverKeys = null;
-		if (!tok.hasMoreTokens()) {
-		    _mgr.error("Usage: openserver <serverHost> <serverPort> <serverKeys>", out);
-		    return;
-		}
-		serverHost = tok.nextToken();
+        _log.debug("Processing [" + command + "]");
+        StringTokenizer tok = new StringTokenizer(command);
+        if (!tok.hasMoreTokens()) {
+            _mgr.unknownCommand(command, out);
+        } else {
+            String cmd = tok.nextToken();
+            if ("quit".equalsIgnoreCase(cmd)) {
+                _mgr.processQuit(out);
+            } else if ("lookup".equalsIgnoreCase(cmd)) {
+                if (tok.hasMoreTokens())
+                    _mgr.processLookup(tok.nextToken(), out);
+                else
+                    _mgr.error("Usage: lookup <hostname>", out);
+            } else if ("testdestination".equalsIgnoreCase(cmd)) {
+                if (tok.hasMoreTokens())
+                    _mgr.processTestDestination(tok.nextToken(), out);
+                else
+                    _mgr.error("Usage: testdestination <publicDestination>", out);
+            } else if ("convertprivate".equalsIgnoreCase(cmd)) {
+                if (tok.hasMoreTokens())
+                    _mgr.processConvertPrivate(tok.nextToken(), out);
+                else
+                    _mgr.error("Usage: convertprivate <privateData>", out);
+            } else if ("close".equalsIgnoreCase(cmd)) {
+                if (tok.hasMoreTokens()) {
+                    String closeArg;
+                    if ((closeArg = tok.nextToken()).equals("forced")) {
+                        if (tok.hasMoreTokens()) {
+                            _mgr.processClose(tok.nextToken(), true, out);
+                        } else {
+                            _mgr.error("Usage: close [forced] <jobnumber>|all", out);
+                        }
+                    } else {
+                        _mgr.processClose(closeArg, false, out);
+                    }
+                } else {
+                    _mgr.error("Usage: close [forced] <jobnumber>|all", out);
+                }
+            } else if ("genkey".equalsIgnoreCase(cmd)) {
+                _mgr.processGenKey(out);
+            } else if ("list".equalsIgnoreCase(cmd)) {
+                _mgr.processList(out);
+            } else if ("listen_on".equalsIgnoreCase(cmd)) {
+                if (tok.hasMoreTokens()) {
+                    _mgr.processListenOn(tok.nextToken(), out);
+                } else {
+                    _mgr.error("Usage: listen_on <ip>", out);
+                }
+            } else if ("openclient".equalsIgnoreCase(cmd)) {
+                int listenPort = 0;
+                String peer = null;
+                if (!tok.hasMoreTokens()) {
+                    _mgr.error("Usage: openclient <listenPort> <peer>", out);
+                    return;
+                }
+                try {
+                    String portStr = tok.nextToken();
+                    listenPort = Integer.parseInt(portStr);
+                } catch (NumberFormatException nfe) {
+                    _mgr.error("Bad listen port", out);
+                    return;
+                }
+                if (!tok.hasMoreTokens()) {
+                    _mgr.error("Usage: openclient <listenport> <peer>", out);
+                    return;
+                }
+                peer = tok.nextToken();
+                _mgr.processOpenClient(listenPort, peer, out);
+            } else if ("openhttpclient".equalsIgnoreCase(cmd)) {
+                int listenPort = 0;
+                String proxy = "squid.i2p";
+                if (!tok.hasMoreTokens()) {
+                    _mgr.error("Usage: openhttpclient <listenPort> [<proxy>]", out);
+                    return;
+                }
+                try {
+                    String portStr = tok.nextToken();
+                    listenPort = Integer.parseInt(portStr);
+                } catch (NumberFormatException nfe) {
+                    _mgr.error("Bad listen port", out);
+                    return;
+                }
+                if (tok.hasMoreTokens()) {
+                    proxy = tok.nextToken();
+                }
+                if (tok.hasMoreTokens()) {
+                    _mgr.error("Usage: openclient <listenport> [<proxy>]", out);
+                    return;
+                }
+                _mgr.processOpenHTTPClient(listenPort, proxy, out);
+            } else if ("opensockstunnel".equalsIgnoreCase(cmd)) {
+                int listenPort = 0;
+                if (!tok.hasMoreTokens()) {
+                    _mgr.error("Usage: opensockstunnel <listenPort>", out);
+                    return;
+                }
+                try {
+                    String portStr = tok.nextToken();
+                    listenPort = Integer.parseInt(portStr);
+                } catch (NumberFormatException nfe) {
+                    _mgr.error("Bad listen port", out);
+                    return;
+                }
+                if (tok.hasMoreTokens()) {
+                    _mgr.error("Usage: opensockstunnel <listenport>", out);
+                    return;
+                }
+                _mgr.processOpenSOCKSTunnel(listenPort, out);
+            } else if ("openserver".equalsIgnoreCase(cmd)) {
+                int listenPort = 0;
+                String serverHost = null;
+                String serverKeys = null;
+                if (!tok.hasMoreTokens()) {
+                    _mgr.error("Usage: openserver <serverHost> <serverPort> <serverKeys>", out);
+                    return;
+                }
+                serverHost = tok.nextToken();
 
-		if (!tok.hasMoreTokens()) {
-		    _mgr.error("Usage: openserver <serverHost> <serverPort> <serverKeys>", out);
-		    return;
-		}
-		try {
-		    String portStr = tok.nextToken();
-		    listenPort = Integer.parseInt(portStr);
-		} catch (NumberFormatException nfe) {
-		    _mgr.error("Bad listen port", out);
-		    return;
-		}
-		if (!tok.hasMoreTokens()) {
-		    _mgr.error("Usage: openserver <serverHost> <serverPort> <serverKeys>", out);
-		    return;
-		}
-		serverKeys = tok.nextToken();
-		_mgr.processOpenServer(serverHost, listenPort, serverKeys, out);
-	    } else {
-		_mgr.unknownCommand(command, out);
-	    }
-	}
+                if (!tok.hasMoreTokens()) {
+                    _mgr.error("Usage: openserver <serverHost> <serverPort> <serverKeys>", out);
+                    return;
+                }
+                try {
+                    String portStr = tok.nextToken();
+                    listenPort = Integer.parseInt(portStr);
+                } catch (NumberFormatException nfe) {
+                    _mgr.error("Bad listen port", out);
+                    return;
+                }
+                if (!tok.hasMoreTokens()) {
+                    _mgr.error("Usage: openserver <serverHost> <serverPort> <serverKeys>", out);
+                    return;
+                }
+                serverKeys = tok.nextToken();
+                _mgr.processOpenServer(serverHost, listenPort, serverKeys, out);
+            } else {
+                _mgr.unknownCommand(command, out);
+            }
+        }
     }
-}
+}

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

@@ -26,31 +26,30 @@ public class I2PSOCKSTunnel extends I2PTunnelClientBase {
     //	  I2PSOCKSTunnel(localPort, l, ownDest, (EventDispatcher)null);
     //}
 
-    public I2PSOCKSTunnel(int localPort, Logging l, boolean ownDest,
-			  EventDispatcher notifyThis) {
-	super(localPort, ownDest, l, notifyThis, "SOCKSHandler");
+    public I2PSOCKSTunnel(int localPort, Logging l, boolean ownDest, EventDispatcher notifyThis) {
+        super(localPort, ownDest, l, notifyThis, "SOCKSHandler");
 
-	if (waitEventValue("openBaseClientResult").equals("error")) {
-	    notifyEvent("openSOCKSTunnelResult", "error");
-	    return;
-	}
-	
-	setName(getLocalPort() + " -> SOCKSTunnel");
+        if (waitEventValue("openBaseClientResult").equals("error")) {
+            notifyEvent("openSOCKSTunnelResult", "error");
+            return;
+        }
 
-	startRunning();
+        setName(getLocalPort() + " -> SOCKSTunnel");
 
-	notifyEvent("openSOCKSTunnelResult", "ok");
+        startRunning();
+
+        notifyEvent("openSOCKSTunnelResult", "ok");
     }
 
     protected void clientConnectionRun(Socket s) {
-	try {
-	    SOCKSServer serv = SOCKSServerFactory.createSOCKSServer(s);
-	    Socket clientSock = serv.getClientSocket();
-	    I2PSocket destSock = serv.getDestinationI2PSocket();
-	    new I2PTunnelRunner (clientSock, destSock, sockLock, null);
-	} catch (SOCKSException e) {
-	    _log.error("Error from SOCKS connection: " + e.getMessage());
-	    closeSocket(s);
-	}
+        try {
+            SOCKSServer serv = SOCKSServerFactory.createSOCKSServer(s);
+            Socket clientSock = serv.getClientSocket();
+            I2PSocket destSock = serv.getDestinationI2PSocket();
+            new I2PTunnelRunner(clientSock, destSock, sockLock, null);
+        } catch (SOCKSException e) {
+            _log.error("Error from SOCKS connection: " + e.getMessage());
+            closeSocket(s);
+        }
     }
-}
+}

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

@@ -42,189 +42,168 @@ public class SOCKS5Server extends SOCKSServer {
      * @param clientSock client socket
      */
     public SOCKS5Server(Socket clientSock) {
-	this.clientSock = clientSock;
+        this.clientSock = clientSock;
     }
 
     public Socket getClientSocket() throws SOCKSException {
-	setupServer();
+        setupServer();
 
-	return clientSock;
+        return clientSock;
     }
 
     protected void setupServer() throws SOCKSException {
-	if (setupCompleted) {
-	    return;
-	}
+        if (setupCompleted) { return; }
 
-	DataInputStream in;
-	DataOutputStream out;
-	try {
-	    in = new DataInputStream(clientSock.getInputStream());
-	    out = new DataOutputStream(clientSock.getOutputStream());
+        DataInputStream in;
+        DataOutputStream out;
+        try {
+            in = new DataInputStream(clientSock.getInputStream());
+            out = new DataOutputStream(clientSock.getOutputStream());
 
-	    init(in, out);
-	    manageRequest(in, out);
-	} catch (IOException e) {
-	    throw new SOCKSException("Connection error ("
-				     + e.getMessage() + ")");
-	}
+            init(in, out);
+            manageRequest(in, out);
+        } catch (IOException e) {
+            throw new SOCKSException("Connection error (" + e.getMessage() + ")");
+        }
 
-	setupCompleted = true;
+        setupCompleted = true;
     }
 
     /**
      * SOCKS5 connection initialization.  This method assumes that
      * SOCKS "VER" field has been stripped from the input stream.
      */
-    private void init (DataInputStream in,
-		       DataOutputStream out) throws IOException, SOCKSException {
-	int nMethods = in.readByte() & 0xff;
-	boolean methodOk = false;
-	int method = Method.NO_ACCEPTABLE_METHODS;
+    private void init(DataInputStream in, DataOutputStream out) throws IOException, SOCKSException {
+        int nMethods = in.readByte() & 0xff;
+        boolean methodOk = false;
+        int method = Method.NO_ACCEPTABLE_METHODS;
 
-	for (int i = 0; i < nMethods; ++i) {
-	    method = in.readByte() & 0xff;
-	    if (method == Method.NO_AUTH_REQUIRED) {
-		// That's fine, we do support this method
-		break;
-	    }
-	}
-	
-	boolean canContinue = false;
-	switch (method) {
-	case Method.NO_AUTH_REQUIRED:
-	    _log.debug("no authentication required");
-	    sendInitReply(Method.NO_AUTH_REQUIRED, out);
-	    return;
-	default:
-	    _log.debug("no suitable authentication methods found ("
-		       + Integer.toHexString(method)+ ")");
-	    sendInitReply(Method.NO_ACCEPTABLE_METHODS, out);
-	    throw new SOCKSException("Unsupported authentication method");
-	}
+        for (int i = 0; i < nMethods; ++i) {
+            method = in.readByte() & 0xff;
+            if (method == Method.NO_AUTH_REQUIRED) {
+                // That's fine, we do support this method
+                break;
+            }
+        }
+
+        boolean canContinue = false;
+        switch (method) {
+        case Method.NO_AUTH_REQUIRED:
+            _log.debug("no authentication required");
+            sendInitReply(Method.NO_AUTH_REQUIRED, out);
+            return;
+        default:
+            _log.debug("no suitable authentication methods found (" + Integer.toHexString(method) + ")");
+            sendInitReply(Method.NO_ACCEPTABLE_METHODS, out);
+            throw new SOCKSException("Unsupported authentication method");
+        }
     }
-    
+
     /**
      * SOCKS5 request management.  This method assumes that all the
      * stuff preceding or enveloping the actual request (e.g. protocol
      * initialization, integrity/confidentiality encapsulations, etc)
      * has been stripped out of the input/output streams.
      */
-    private void manageRequest(DataInputStream in,
-			       DataOutputStream out) throws IOException, SOCKSException {
-	int socksVer = in.readByte() & 0xff;
-	if (socksVer != SOCKS_VERSION_5) {
-	    _log.debug("error in SOCKS5 request (protocol != 5? wtf?)");
-	    throw new SOCKSException("Invalid protocol version in request");
-	}
-	
-	int command = in.readByte() & 0xff;
-	switch (command) {
-	case Command.CONNECT:
-	    break;
-	case Command.BIND:
-	    _log.debug("BIND command is not supported!");
-	    sendRequestReply(Reply.COMMAND_NOT_SUPPORTED,
-			     AddressType.DOMAINNAME, null,
-			     "0.0.0.0", 0, out);
-	    throw new SOCKSException("BIND command not supported");
-	case Command.UDP_ASSOCIATE:
-	    _log.debug("UDP ASSOCIATE command is not supported!");
-	    sendRequestReply(Reply.COMMAND_NOT_SUPPORTED,
-			     AddressType.DOMAINNAME, null,
-			     "0.0.0.0", 0, out);
-	    throw new SOCKSException("UDP ASSOCIATE command not supported");
-	default:
-	    _log.debug("unknown command in request ("
-		       + Integer.toHexString(command) + ")");
-	    throw new SOCKSException("Invalid command in request");
-	}
+    private void manageRequest(DataInputStream in, DataOutputStream out) throws IOException, SOCKSException {
+        int socksVer = in.readByte() & 0xff;
+        if (socksVer != SOCKS_VERSION_5) {
+            _log.debug("error in SOCKS5 request (protocol != 5? wtf?)");
+            throw new SOCKSException("Invalid protocol version in request");
+        }
 
-	{
-	    // Reserved byte, should be 0x00
-	    byte rsv = in.readByte();
-	}
+        int command = in.readByte() & 0xff;
+        switch (command) {
+        case Command.CONNECT:
+            break;
+        case Command.BIND:
+            _log.debug("BIND command is not supported!");
+            sendRequestReply(Reply.COMMAND_NOT_SUPPORTED, AddressType.DOMAINNAME, null, "0.0.0.0", 0, out);
+            throw new SOCKSException("BIND command not supported");
+        case Command.UDP_ASSOCIATE:
+            _log.debug("UDP ASSOCIATE command is not supported!");
+            sendRequestReply(Reply.COMMAND_NOT_SUPPORTED, AddressType.DOMAINNAME, null, "0.0.0.0", 0, out);
+            throw new SOCKSException("UDP ASSOCIATE command not supported");
+        default:
+            _log.debug("unknown command in request (" + Integer.toHexString(command) + ")");
+            throw new SOCKSException("Invalid command in request");
+        }
 
-	int addressType = in.readByte() & 0xff;
-	switch (addressType) {
-	case AddressType.IPV4:
-	    connHostName = new String("");
-	    for (int i = 0; i < 4; ++i) {
-		int octet = in.readByte() & 0xff;
-		connHostName += Integer.toString(octet);
-		if (i != 3) {
-		    connHostName += ".";
-		}
-	    }
-	    _log.warn("IPV4 address type in request: " + connHostName
-		      + ". Is your client secure?");
-	    break;
-	case AddressType.DOMAINNAME:
-	    {
-		int addrLen = in.readByte() & 0xff;
-		if (addrLen == 0) {
-		    _log.debug("0-sized address length? wtf?");
-		    throw new SOCKSException("Illegal DOMAINNAME length");
-		}
-		byte addr[] = new byte[addrLen];
-		in.readFully(addr);
-		connHostName = new String(addr);
-	    }
-	    _log.debug("DOMAINNAME address type in request: " + connHostName);
-	    break;
-	case AddressType.IPV6:
-	    _log.warn("IP V6 address type in request! Is your client secure?"
-		      + " (IPv6 is not supported, anyway :-)");
-	    sendRequestReply(Reply.ADDRESS_TYPE_NOT_SUPPORTED,
-			     AddressType.DOMAINNAME, null,
-			     "0.0.0.0", 0, out);
-	    throw new SOCKSException("IPV6 addresses not supported");
-	default:
-	    _log.debug("unknown address type in request ("
-		       + Integer.toHexString(command) + ")");
-	    throw new SOCKSException("Invalid addresses type in request");
-	}
-	
-	connPort = in.readUnsignedShort();
-	if (connPort == 0) {
-	    _log.debug("trying to connect to TCP port 0?  Dropping!");
-	    throw new SOCKSException("Invalid port number in request");
-	}
+        {
+            // Reserved byte, should be 0x00
+            byte rsv = in.readByte();
+        }
+
+        int addressType = in.readByte() & 0xff;
+        switch (addressType) {
+        case AddressType.IPV4:
+            connHostName = new String("");
+            for (int i = 0; i < 4; ++i) {
+                int octet = in.readByte() & 0xff;
+                connHostName += Integer.toString(octet);
+                if (i != 3) {
+                    connHostName += ".";
+                }
+            }
+            _log.warn("IPV4 address type in request: " + connHostName + ". Is your client secure?");
+            break;
+        case AddressType.DOMAINNAME:
+            {
+                int addrLen = in.readByte() & 0xff;
+                if (addrLen == 0) {
+                    _log.debug("0-sized address length? wtf?");
+                    throw new SOCKSException("Illegal DOMAINNAME length");
+                }
+                byte addr[] = new byte[addrLen];
+                in.readFully(addr);
+                connHostName = new String(addr);
+            }
+            _log.debug("DOMAINNAME address type in request: " + connHostName);
+            break;
+        case AddressType.IPV6:
+            _log.warn("IP V6 address type in request! Is your client secure?" + " (IPv6 is not supported, anyway :-)");
+            sendRequestReply(Reply.ADDRESS_TYPE_NOT_SUPPORTED, AddressType.DOMAINNAME, null, "0.0.0.0", 0, out);
+            throw new SOCKSException("IPV6 addresses not supported");
+        default:
+            _log.debug("unknown address type in request (" + Integer.toHexString(command) + ")");
+            throw new SOCKSException("Invalid addresses type in request");
+        }
+
+        connPort = in.readUnsignedShort();
+        if (connPort == 0) {
+            _log.debug("trying to connect to TCP port 0?  Dropping!");
+            throw new SOCKSException("Invalid port number in request");
+        }
     }
 
     protected void confirmConnection() throws SOCKSException {
-	DataInputStream in;
-	DataOutputStream out;
-	try {
-	    out = new DataOutputStream(clientSock.getOutputStream());
-	    
-	    sendRequestReply(Reply.SUCCEEDED,
-			     AddressType.IPV4,
-			     InetAddress.getByName("127.0.0.1"),
-			     null, 1, out);
-	} catch (IOException e) {
-	    throw new SOCKSException("Connection error ("
-				     + e.getMessage() + ")");
-	}
+        DataInputStream in;
+        DataOutputStream out;
+        try {
+            out = new DataOutputStream(clientSock.getOutputStream());
+
+            sendRequestReply(Reply.SUCCEEDED, AddressType.IPV4, InetAddress.getByName("127.0.0.1"), null, 1, out);
+        } catch (IOException e) {
+            throw new SOCKSException("Connection error (" + e.getMessage() + ")");
+        }
     }
 
     /**
      * Send the specified reply during SOCKS5 initialization
      */
-    private void sendInitReply(int replyCode,
-			       DataOutputStream out) throws IOException {
-	ByteArrayOutputStream reps = new ByteArrayOutputStream();
+    private void sendInitReply(int replyCode, DataOutputStream out) throws IOException {
+        ByteArrayOutputStream reps = new ByteArrayOutputStream();
 
-	reps.write(SOCKS_VERSION_5);
-	reps.write(replyCode);
+        reps.write(SOCKS_VERSION_5);
+        reps.write(replyCode);
 
-	byte[] reply = reps.toByteArray();
+        byte[] reply = reps.toByteArray();
 
-	if (_log.shouldLog(Log.DEBUG)) {
-	    _log.debug("Sending init reply:\n" + HexDump.dump(reply));
-	}
+        if (_log.shouldLog(Log.DEBUG)) {
+            _log.debug("Sending init reply:\n" + HexDump.dump(reply));
+        }
 
-	out.write(reply);
+        out.write(reply);
     }
 
     /**
@@ -232,78 +211,72 @@ public class SOCKS5Server extends SOCKSServer {
      * one of inetAddr or domainName can be null, depending on
      * addressType.
      */
-    private void sendRequestReply(int replyCode,
-				  int addressType,
-				  InetAddress inetAddr,
-				  String domainName,
-				  int bindPort,
-				  DataOutputStream out) throws IOException {
-	ByteArrayOutputStream reps = new ByteArrayOutputStream();
-	DataOutputStream dreps = new DataOutputStream(reps);
-	
-	dreps.write(SOCKS_VERSION_5);
-	dreps.write(replyCode);
+    private void sendRequestReply(int replyCode, int addressType, InetAddress inetAddr, String domainName,
+                                  int bindPort, DataOutputStream out) throws IOException {
+        ByteArrayOutputStream reps = new ByteArrayOutputStream();
+        DataOutputStream dreps = new DataOutputStream(reps);
 
-	// Reserved byte, should be 0x00
-	dreps.write(0x00);
+        dreps.write(SOCKS_VERSION_5);
+        dreps.write(replyCode);
 
-	dreps.write(addressType);
-	
-	switch (addressType) {
-	case AddressType.IPV4:
-	    dreps.write(inetAddr.getAddress());
-	    break;
-	case AddressType.DOMAINNAME:
-	    dreps.writeByte(domainName.length());
-	    dreps.writeBytes(domainName);
-	    break;
-	default:
-	    _log.error("unknown address type passed to sendReply() ("
-		       + Integer.toHexString(addressType) + ")! wtf?");
-	    return;
-	}
+        // Reserved byte, should be 0x00
+        dreps.write(0x00);
 
-	dreps.writeShort(bindPort);
+        dreps.write(addressType);
 
-	byte[] reply = reps.toByteArray();
+        switch (addressType) {
+        case AddressType.IPV4:
+            dreps.write(inetAddr.getAddress());
+            break;
+        case AddressType.DOMAINNAME:
+            dreps.writeByte(domainName.length());
+            dreps.writeBytes(domainName);
+            break;
+        default:
+            _log.error("unknown address type passed to sendReply() (" + Integer.toHexString(addressType) + ")! wtf?");
+            return;
+        }
 
-	if (_log.shouldLog(Log.DEBUG)) {
-	    _log.debug("Sending request reply:\n" + HexDump.dump(reply));
-	}
+        dreps.writeShort(bindPort);
 
-	out.write(reply);
+        byte[] reply = reps.toByteArray();
+
+        if (_log.shouldLog(Log.DEBUG)) {
+            _log.debug("Sending request reply:\n" + HexDump.dump(reply));
+        }
+
+        out.write(reply);
     }
-    
-    
+
     /*
      * Some namespaces to enclose SOCKS protocol codes
      */
     private class Method {
-	private static final int NO_AUTH_REQUIRED      = 0x00;
-	private static final int NO_ACCEPTABLE_METHODS = 0xff;
+        private static final int NO_AUTH_REQUIRED = 0x00;
+        private static final int NO_ACCEPTABLE_METHODS = 0xff;
     }
 
     private class AddressType {
-	private static final int IPV4       = 0x01;
-	private static final int DOMAINNAME = 0x03;
-	private static final int IPV6       = 0x04;
+        private static final int IPV4 = 0x01;
+        private static final int DOMAINNAME = 0x03;
+        private static final int IPV6 = 0x04;
     }
 
     private class Command {
-	private static final int CONNECT       = 0x01;
-	private static final int BIND          = 0x02;
-	private static final int UDP_ASSOCIATE = 0x03;
+        private static final int CONNECT = 0x01;
+        private static final int BIND = 0x02;
+        private static final int UDP_ASSOCIATE = 0x03;
     }
 
     private class Reply {
-	private static final int SUCCEEDED                         = 0x00;
-	private static final int GENERAL_SOCKS_SERVER_FAILURE      = 0x01;
-	private static final int CONNECTION_NOT_ALLOWED_BY_RULESET = 0x02;
-	private static final int NETWORK_UNREACHABLE               = 0x03;
-	private static final int HOST_UNREACHABLE                  = 0x04;
-	private static final int CONNECTION_REFUSED                = 0x05;
-	private static final int TTL_EXPIRED                       = 0x06;
-	private static final int COMMAND_NOT_SUPPORTED             = 0x07;
-	private static final int ADDRESS_TYPE_NOT_SUPPORTED        = 0x08;
+        private static final int SUCCEEDED = 0x00;
+        private static final int GENERAL_SOCKS_SERVER_FAILURE = 0x01;
+        private static final int CONNECTION_NOT_ALLOWED_BY_RULESET = 0x02;
+        private static final int NETWORK_UNREACHABLE = 0x03;
+        private static final int HOST_UNREACHABLE = 0x04;
+        private static final int CONNECTION_REFUSED = 0x05;
+        private static final int TTL_EXPIRED = 0x06;
+        private static final int COMMAND_NOT_SUPPORTED = 0x07;
+        private static final int ADDRESS_TYPE_NOT_SUPPORTED = 0x08;
     }
-}
+}

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

@@ -14,10 +14,10 @@ package net.i2p.i2ptunnel.socks;
 public class SOCKSException extends Exception {
 
     public SOCKSException() {
-	super();
+        super();
     }
-    
+
     public SOCKSException(String s) {
-	super(s);
+        super(s);
     }
-}
+}