0.4.1.4

they may have restarted or otherwise lost the tags delivered to them.

apps/bogobot/Bogobot.java

@@ -0,0 +1,349 @@
+/*
+ * bogobot - A simple join/part stats logger bot for I2P IRC.
+ * 
+ * Bogobot.java
+ * 2004 The I2P Project
+ * http://www.i2p.net
+ * This code is public domain.
+ */
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+
+import java.util.Timer;
+import java.util.TimerTask;
+import java.util.Properties;
+
+import org.apache.log4j.DailyRollingFileAppender;
+import org.apache.log4j.Level;
+import org.apache.log4j.Logger;
+import org.apache.log4j.PatternLayout;
+
+import org.jibble.pircbot.IrcException;
+import org.jibble.pircbot.NickAlreadyInUseException;
+import org.jibble.pircbot.PircBot;
+import org.jibble.pircbot.User;
+
+/**
+ * TODO 0.5 Add multi-server capability.
+ * 
+ * @author hypercubus, oOo
+ * @version 0.4
+ */
+public class Bogobot extends PircBot {
+
+    private static final String INTERVAL_DAILY   = "daily";
+    private static final String INTERVAL_MONTHLY = "monthly";
+    private static final String INTERVAL_WEEKLY  = "weekly";
+
+    private boolean _isIntentionalDisconnect      = false;
+    private long    _lastUserlistCommandTimestamp = 0;
+    private Logger  _logger                       = Logger.getLogger(Bogobot.class);
+
+    private int     _currentAutoRoundTripTag      = 0;
+    private long    _lastAutoRoundTripSentTime    = 0;
+    private Timer   _tickTimer;
+
+    private String  _configFile;
+
+    private String  _botPrimaryNick;
+    private String  _botSecondaryNick;
+    private String  _botNickservPassword;
+    private String  _botUsername;
+    private String  _ownerPrimaryNick;
+    private String  _ownerSecondaryNick;
+    private String  _botShutdownPassword;
+    private String  _ircChannel;
+    private String  _ircServer;
+    private int     _ircServerPort;
+    private boolean _isLoggerEnabled;
+    private String  _loggedHostnamePattern;
+    private boolean _isUserlistCommandEnabled;
+    private String  _logFilePrefix;
+    private String  _logFileRotationInterval;
+    private long    _commandAntiFloodInterval;
+    private String  _userlistCommandTrigger;
+    private boolean _isRoundTripDelayEnabled;
+    private int     _roundTripDelayPeriod;
+
+    class BogobotTickTask extends TimerTask {
+        private Bogobot _caller;
+
+        public BogobotTickTask(Bogobot caller) {
+            _caller = caller;
+        }
+
+        public void run() {
+          _caller.onTick();
+        }
+    }
+
+    private void loadConfigFile(String configFileName) {
+
+        _configFile = configFileName;
+
+        Properties config = new Properties();
+        FileInputStream fis = null;
+
+        try {
+            fis = new FileInputStream(configFileName);
+            config.load(fis);
+        } catch (IOException ioe) {
+            System.err.println("Error loading configuration file");
+            System.exit(2);
+
+        } finally {
+            if (fis != null) try {
+                fis.close();
+            } catch (IOException ioe) { // nop
+            }
+        }
+
+        _botPrimaryNick = config.getProperty("botPrimaryNick", "somebot");
+        _botSecondaryNick = config.getProperty("botSecondaryNick", "somebot_");
+        _botNickservPassword = config.getProperty("botNickservPassword", "");
+        _botUsername = config.getProperty("botUsername", "somebot");
+
+        _ownerPrimaryNick = config.getProperty("ownerPrimaryNick", "somenick");
+        _ownerSecondaryNick = config.getProperty("ownerSecondaryNick", "somenick_");
+
+        _botShutdownPassword = config.getProperty("botShutdownPassword", "take off eh");
+
+        _ircChannel = config.getProperty("ircChannel", "#i2p-chat");
+        _ircServer = config.getProperty("ircServer", "irc.duck.i2p");
+        _ircServerPort = Integer.parseInt(config.getProperty("ircServerPort", "6668"));
+
+        _isLoggerEnabled = Boolean.valueOf(config.getProperty("isLoggerEnabled", "true")).booleanValue();
+        _loggedHostnamePattern = config.getProperty("loggedHostnamePattern", "");
+        _logFilePrefix = config.getProperty("logFilePrefix", "irc.duck.i2p.i2p-chat");
+        _logFileRotationInterval = config.getProperty("logFileRotationInterval", INTERVAL_DAILY);
+
+        _isRoundTripDelayEnabled = Boolean.valueOf(config.getProperty("isRoundTripDelayEnabled", "false")).booleanValue();
+        _roundTripDelayPeriod = Integer.parseInt(config.getProperty("roundTripDelayPeriod", "300"));
+
+        _isUserlistCommandEnabled = Boolean.valueOf(config.getProperty("isUserlistCommandEnabled", "true")).booleanValue();
+        _userlistCommandTrigger = config.getProperty("userlistCommandTrigger", "!who");
+        _commandAntiFloodInterval = Long.parseLong(config.getProperty("commandAntiFloodInterval", "60"));
+    }
+
+    public Bogobot(String configFileName) {
+
+        loadConfigFile(configFileName);
+
+        this.setName(_botPrimaryNick);
+        this.setLogin(_botUsername);
+        _tickTimer = new Timer();
+        _tickTimer.scheduleAtFixedRate(new BogobotTickTask(this), 1000, 10 * 1000);
+    }
+
+    public static void main(String[] args) {
+
+        Bogobot bogobot;
+
+        if (args.length > 1) {
+            System.err.println("Too many arguments, the only allowed parameter is configuration file name");
+            System.exit(3);
+        }
+        if (args.length == 1) {
+          bogobot = new Bogobot(args[0]);
+        } else {
+          bogobot = new Bogobot("bogobot.config");
+        }
+
+        bogobot.setVerbose(true);
+
+        if (bogobot._isLoggerEnabled)
+            bogobot.initLogger();
+
+        bogobot.connectToServer();
+    }
+
+    protected void onTick() {
+        // Tick about once every ten seconds
+
+        if (this.isConnected() && _isRoundTripDelayEnabled) {
+            if( ( (System.currentTimeMillis() - _lastAutoRoundTripSentTime) >= (_roundTripDelayPeriod * 1000) ) && (this.getOutgoingQueueSize() == 0) ) {
+                // Connected, sending queue is empty and last RoundTrip is more then 5 minutes old -> Send a new one
+                _currentAutoRoundTripTag ++;
+                _lastAutoRoundTripSentTime = System.currentTimeMillis();
+                sendNotice(this.getNick(),"ROUNDTRIP " + _currentAutoRoundTripTag);
+            }
+        }
+    }
+
+    protected void onDisconnect() {
+
+        if (_isIntentionalDisconnect)
+            System.exit(0);            
+
+        if (_isLoggerEnabled)
+            _logger.info(System.currentTimeMillis() + " quits *** " + this.getName() + " *** (Lost connection)");
+
+        try {
+            Thread.sleep(60000);
+        } catch (InterruptedException e) {
+            // No worries.
+        }
+        connectToServer();
+    }
+
+    protected void onJoin(String channel, String sender, String login, String hostname) {
+
+        if (_isLoggerEnabled) {
+            if (sender.equals(this.getName())) {
+
+                _logger.info(System.currentTimeMillis() + " joins *** " + _botPrimaryNick + " ***");
+
+            } else {
+
+                String prependedHostname = "@" + hostname;
+                if (prependedHostname.endsWith(_loggedHostnamePattern)) {
+                    _logger.info(System.currentTimeMillis() + " joins " + sender);
+                }
+
+            }
+        }
+    }
+
+    protected void onMessage(String channel, String sender, String login, String hostname, String message) {
+        message = message.replaceFirst("<.+?> ", "");
+        if (_isUserlistCommandEnabled && message.equals(_userlistCommandTrigger)) {
+
+            if (System.currentTimeMillis() - _lastUserlistCommandTimestamp < _commandAntiFloodInterval * 1000)
+                return;
+
+            Object[] users = getUsers(_ircChannel);
+            String output = "Userlist for " + _ircChannel + ": ";
+
+            for (int i = 0; i < users.length; i++)
+                output += "[" + ((User) users[i]).getNick() + "] ";
+
+            sendMessage(_ircChannel, output);
+            _lastUserlistCommandTimestamp = System.currentTimeMillis();
+        }
+    }
+
+    protected void onPart(String channel, String sender, String login, String hostname) {
+
+        if (_isLoggerEnabled) {
+            if (sender.equals(this.getName())) {
+                _logger.info(System.currentTimeMillis() + " parts *** " + _botPrimaryNick + " ***");
+            } else {
+                String prependedHostname = "@" + hostname;
+                if (prependedHostname.endsWith(_loggedHostnamePattern)) {
+                    _logger.info(System.currentTimeMillis() + " parts " + sender);
+                }
+            }
+        }
+
+    }
+
+    protected void onPrivateMessage(String sender, String login, String hostname, String message) {
+        /*
+         * Nobody else except the bot's owner can shut it down, unless of
+         * course the owner's nick isn't registered and someone's spoofing it.
+         */
+        if ((sender.equals(_ownerPrimaryNick) || sender.equals(_ownerSecondaryNick)) && message.equals(_botShutdownPassword)) {
+
+            if (_isLoggerEnabled)
+                _logger.info(System.currentTimeMillis() + " quits *** " + this.getName() + " ***");
+
+            _isIntentionalDisconnect = true;
+            disconnect();
+        }
+    }
+
+    protected void onQuit(String sourceNick, String sourceLogin, String sourceHostname, String reason) {
+        String prependedHostname = "@" + sourceHostname;
+
+        if (sourceNick.equals(_botPrimaryNick))
+            changeNick(_botPrimaryNick);
+
+        if (_isLoggerEnabled) {
+            if (prependedHostname.endsWith(_loggedHostnamePattern)) {
+                _logger.info(System.currentTimeMillis() + " quits " + sourceNick + " " + reason);
+            }
+        }
+
+    }
+
+    private void connectToServer() {
+
+        int loginAttempts = 0;
+
+        while (true) {
+            try {
+                connect(_ircServer, _ircServerPort);
+                break;
+            } catch (NickAlreadyInUseException e) {
+                if (loginAttempts == 1) {
+                    System.out.println("Sorry, the primary and secondary bot nicks are already taken. Exiting.");
+                    System.exit(1);
+                }
+                loginAttempts++;
+                try {
+                    Thread.sleep(5000);
+                } catch (InterruptedException e1) {
+                    // Hmph.
+                }
+
+                if (getName().equals(_botPrimaryNick))
+                    setName(_botSecondaryNick);
+                else
+                    setName(_botPrimaryNick);
+
+                continue;
+            } catch (IOException e) {
+                System.out.println("Error during login: ");
+                e.printStackTrace();
+                System.exit(1);
+            } catch (IrcException e) {
+                System.out.println("Error during login: ");
+                e.printStackTrace();
+                System.exit(1);
+            }
+        }
+        joinChannel(_ircChannel);
+    }
+
+    protected void onNotice(String sourceNick, String sourceLogin, String sourceHostname, String target, String notice) {
+
+        if (sourceNick.equals("NickServ") && (notice.indexOf("/msg NickServ IDENTIFY") >= 0) && (_botNickservPassword != "")) {
+            sendRawLineViaQueue("NICKSERV IDENTIFY " + _botNickservPassword);
+        }
+
+        if (sourceNick.equals(getNick()) && notice.equals( "ROUNDTRIP " + _currentAutoRoundTripTag)) {
+            int delay = (int)((System.currentTimeMillis() - _lastAutoRoundTripSentTime) / 100);
+//            sendMessage(_ircChannel, "Round-trip delay = " + (delay / 10.0f) + " seconds");
+            if (_isLoggerEnabled)
+                _logger.info(System.currentTimeMillis() + " roundtrip " + delay);
+        }
+    }
+
+    private void initLogger() {
+
+        String                   logFilePath         = "logs" + File.separator + _logFilePrefix;
+        DailyRollingFileAppender rollingFileAppender = null;
+
+        if (!(new File("logs").exists()))
+            (new File("logs")).mkdirs();
+
+        try {
+
+            if (_logFileRotationInterval.equals("monthly"))
+                rollingFileAppender = new DailyRollingFileAppender(new PatternLayout("%m%n"), logFilePath, "'.'yyyy-MM'.log'");
+            else if (_logFileRotationInterval.equals("weekly"))
+                rollingFileAppender = new DailyRollingFileAppender(new PatternLayout("%m%n"), logFilePath, "'.'yyyy-ww'.log'");
+            else
+                rollingFileAppender = new DailyRollingFileAppender(new PatternLayout("%m%n"), logFilePath, "'.'yyyy-MM-dd'.log'");
+
+            rollingFileAppender.setThreshold(Level.INFO);
+            _logger.addAppender(rollingFileAppender);
+        } catch (IOException ex) {
+            System.out.println("Error: Couldn't create or open an existing log file. Exiting.");
+            System.exit(1);
+        }
+    }
+
+}

apps/bogobot/Bogoparser.java

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

apps/bogobot/LICENSE.log4j.txt

@@ -0,0 +1,48 @@
+/*
+ * ============================================================================
+ *                   The Apache Software License, Version 1.1
+ * ============================================================================
+ * 
+ *    Copyright (C) 1999 The Apache Software Foundation. All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modifica-
+ * tion, are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of  source code must  retain the above copyright  notice,
+ *    this list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 
+ * 3. The end-user documentation included with the redistribution, if any, must
+ *    include  the following  acknowledgment:  "This product includes  software
+ *    developed  by the  Apache Software Foundation  (http://www.apache.org/)."
+ *    Alternately, this  acknowledgment may  appear in the software itself,  if
+ *    and wherever such third-party acknowledgments normally appear.
+ * 
+ * 4. The names "log4j" and  "Apache Software Foundation"  must not be used to
+ *    endorse  or promote  products derived  from this  software without  prior
+ *    written permission. For written permission, please contact
+ *    apache@apache.org.
+ * 
+ * 5. Products  derived from this software may not  be called "Apache", nor may
+ *    "Apache" appear  in their name,  without prior written permission  of the
+ *    Apache Software Foundation.
+ * 
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS  FOR A PARTICULAR  PURPOSE ARE  DISCLAIMED.  IN NO  EVENT SHALL  THE
+ * APACHE SOFTWARE  FOUNDATION  OR ITS CONTRIBUTORS  BE LIABLE FOR  ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL,  EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLU-
+ * DING, BUT NOT LIMITED TO, PROCUREMENT  OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR  PROFITS; OR BUSINESS  INTERRUPTION)  HOWEVER CAUSED AND ON
+ * ANY  THEORY OF LIABILITY,  WHETHER  IN CONTRACT,  STRICT LIABILITY,  OR TORT
+ * (INCLUDING  NEGLIGENCE OR  OTHERWISE) ARISING IN  ANY WAY OUT OF THE  USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ * This software  consists of voluntary contributions made  by many individuals
+ * on  behalf of the Apache Software  Foundation.  For more  information on the 
+ * Apache Software Foundation, please see <http://www.apache.org/>.
+ *
+ */

apps/bogobot/LICENSE.pircbot.txt

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

apps/bogobot/bogobot.bat

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

apps/bogobot/bogobot.config

@@ -0,0 +1,101 @@
+#####
+# Bogobot user configuration
+#####
+
+###
+# The bot's nick and backup nick. You will probably want to register these with
+# the IRC server's NickServ.(a NickServ interface is forthcoming).
+#
+botPrimaryNick=somebot
+botSecondaryNick=somebot_
+
+###
+# The bot's password required by Nickserv service's identify command.
+# You have to register the nickname yourself first, the bot will not.
+#
+botNickservPassword=
+
+###
+# The bot's username. Appears in the whois replies
+#
+botUsername=somebot
+
+#####
+# The bot owner's nick and backup nick. One of these must match the owner's
+# currently-used nick or else remote shutdown will not be possible. You will
+# probably want to register these with the IRC server's NickServ.
+#
+ownerPrimaryNick=somenick
+ownerSecondaryNick=somenick_
+
+###
+# The bot will disconnect and shut down when sent this password via private
+# message (aka query) from either of the owner nicks specified above. DO NOT USE
+# THIS DEFAULT VALUE!
+#
+botShutdownPassword=take off eh
+
+###
+# The server, channel, and port the bot will connect to.
+#
+ircChannel=#i2p-chat
+ircServer=irc.duck.i2p
+ircServerPort=6668
+
+###
+# Set to "true" to enable logging, else "false" (but don't use quotation marks).
+#
+isLoggerEnabled=true
+
+###
+# Restrict logging of joins and parts on the user hostname.
+# Leave empty to log all of them
+# Prepend with a @ for a perfect match
+# Otherwise, specify the required end of the user hostname
+#
+loggedHostnamePattern=@free.duck.i2p
+
+###
+# The prefix to be used for the filenames of logs.
+#
+logFilePrefix=irc.duck.i2p.i2p-chat
+
+###
+# How often the logs should be rotated. Either "daily", "weekly", or "monthly"
+# (but don't use quotation marks).
+#
+logFileRotationInterval=daily
+
+###
+# Set to "true" to enable the regular round-trip delay computation,
+# else "false" (but don't use quotation marks).
+#
+isRoundTripDelayEnabled=false
+
+###
+# How often should the round-trip delay be recorded.
+# (in seconds)
+#
+roundTripDelayPeriod=300
+
+###
+# Set to "true" to enable the userlist command, else "false" (but don't use
+# quotation marks).
+#
+isUserlistCommandEnabled=true
+
+###
+# The userlist trigger command to listen for. It is a good idea to prefix
+# triggers with some non-alphanumeric character in order to avoid accidental
+# trigger use during normal channel conversation. In most cases you will
+# probably want to choose a unique trigger here that no other bots in the
+# channel will respond to.
+#
+userlistCommandTrigger=!who
+
+###
+# The number of seconds to rest after replying to a userlist command issued by
+# a user in the channel. The bot will ignore subsequent userlist commands during
+# this period. This helps prevent flooding.
+#
+commandAntiFloodInterval=60

apps/bogobot/bogobot.sh

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

apps/bogobot/build-eclipse.xml

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

apps/bogobot/build.xml

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

apps/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" deprecation="on" source="1.3" target="1.3" destdir="./build/obj" includes="**/*.java" excludes="net/i2p/heartbeat/gui/**" classpath="../../../core/java/build/i2p.jar" />
+    </target>
+    <target name="compileGUI">
+        <mkdir dir="./build" />
+        <mkdir dir="./build/obj" />
+        <javac debug="true" source="1.3" target="1.3" deprecation="on" destdir="./build/obj">
+            <src path="src/" />
+            <classpath path="../../../core/java/build/i2p.jar" />
+            <classpath path="../../jfreechart/jfreechart-0.9.17/lib/jcommon-0.9.2.jar" />
+            <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,412 @@
+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 TreeMap _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) {
+            if (_pendingPings.size() <= 0) {
+                _log.warn("Pong received (sent at " + dateSent + ", " + (now-dateSent) 
+                          + "ms ago, pong delay " + (pongSent-dateSent) + "ms, pong receive delay "
+                          + (now-pongSent) + "ms)");
+                return;
+            }
+            Long first = (Long)_pendingPings.firstKey();
+            EventDataPoint data = (EventDataPoint)_pendingPings.remove(new Long(dateSent));
+            
+            if (data != null) {
+                data.setPongReceived(now);
+                data.setPongSent(pongSent);
+                data.setWasPonged(true);
+                locked_addDataPoint(data);
+                
+                if (dateSent != first.longValue()) {
+                    _log.error("Out of order delivery: received " + dateSent 
+                               + " but the first pending is " + first.longValue()
+                               + " (delta " + (dateSent - first.longValue()) + ")");
+                } else {
+                    _log.info("In order delivery for " + dateSent + " in ping " 
+                               + _peer.getComment());
+                }
+            } else {
+                _log.warn("Pong received, but no matching ping?  ping sent at = " + dateSent);
+                return;
+            }
+        }
+        _sendRate.addData(pongSent - dateSent, 0);
+        _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.coalesceStats();
+        _sendRate.coalesceStats();
+        _lostRate.coalesceStats();
+
+        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,14 +4,14 @@
     <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" />
         <mkdir dir="./build/obj" />
         <javac 
             srcdir="./src" 
-            debug="true" 
+            debug="true" deprecation="on" source="1.3" target="1.3" 
             destdir="./build/obj" 
             classpath="../../../core/java/build/i2p.jar:../../ministreaming/java/build/mstreaming.jar" />
     </target>
@@ -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,24 +4,66 @@
     <target name="build" depends="builddep, jar" />
     <target name="builddep">
         <ant dir="../../ministreaming/java/" target="build" />
-        <ant dir="../../../core/java/" target="build" />
+        <ant dir="../../jetty/" target="build" />
+	<!-- ministreaming will build core -->
     </target>
     <target name="compile">
         <mkdir dir="./build" />
         <mkdir dir="./build/obj" />
         <javac 
             srcdir="./src" 
-            debug="true" 
+            debug="true" deprecation="on" source="1.3" target="1.3" 
             destdir="./build/obj" 
             classpath="../../../core/java/build/i2p.jar:../../ministreaming/java/build/mstreaming.jar" />
     </target>
-    <target name="jar" depends="compile">
+    <target name="jar" depends="builddep, compile">
         <jar destfile="./build/i2ptunnel.jar" basedir="./build/obj" includes="**/*.class">
             <manifest>
                 <attribute name="Main-Class" value="net.i2p.i2ptunnel.I2PTunnel" />
                 <attribute name="Class-Path" value="i2p.jar mstreaming.jar" />
             </manifest>
         </jar>
+        <ant target="war" />
+    </target>
+    <target name="war" depends="precompilejsp"> 
+        <war destfile="build/i2ptunnel.war" webxml="../jsp/web-out.xml"
+             basedir="../jsp/" excludes="web.xml, *.java, *.jsp">
+        </war>
+    </target>
+    <target name="precompilejsp">
+        <mkdir dir="../jsp/WEB-INF/" />
+        <mkdir dir="../jsp/WEB-INF/classes" />
+        <!-- there are various jspc ant tasks, but they all seem a bit flakey -->
+        <java classname="org.apache.jasper.JspC" fork="true" >
+            <classpath>
+                <pathelement location="../../jetty/jettylib/jasper-compiler.jar" />
+                <pathelement location="../../jetty/jettylib/jasper-runtime.jar" />
+                <pathelement location="../../jetty/jettylib/javax.servlet.jar" />
+                <pathelement location="../../jetty/jettylib/ant.jar" />
+                <pathelement location="build/i2ptunnel.jar" />
+            </classpath>
+            <arg value="-d" />
+            <arg value="../jsp/WEB-INF/classes" />
+            <arg value="-v9" />
+            <arg value="-p" />
+            <arg value="net.i2p.i2ptunnel.jsp" />
+            <arg value="-webinc" />
+            <arg value="../jsp/web-fragment.xml" />
+            <arg value="-webapp" />
+            <arg value="../jsp/" />
+        </java>
+        <javac destdir="../jsp/WEB-INF/classes/" srcdir="../jsp/WEB-INF/classes" includes="*.java">
+            <classpath>
+                <pathelement location="../../jetty/jettylib/jasper-runtime.jar" />
+                <pathelement location="../../jetty/jettylib/javax.servlet.jar" />
+                <pathelement location="build/i2ptunnel.jar" />
+            </classpath>
+        </javac>
+        <copy file="../jsp/web.xml" tofile="../jsp/web-out.xml" />
+        <loadfile property="jspc.web.fragment" srcfile="../jsp/web-fragment.xml" />
+        <replace file="../jsp/web-out.xml">
+            <replacefilter token="&lt;!-- precompiled servlets --&gt;" value="${jspc.web.fragment}" />
+        </replace>
     </target>
     <target name="javadoc">
         <mkdir dir="./build" />
@@ -37,11 +79,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,54 @@ 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");
+    /**
+     * @throws IllegalArgumentException if the I2PTunnel does not contain
+     *                                  valid config to contact the router
+     */
+    public I2PTunnelClient(int localPort, String destination, Logging l, 
+                           boolean ownDest, EventDispatcher notifyThis, 
+                           I2PTunnel tunnel) throws IllegalArgumentException {
+        super(localPort, ownDest, l, notifyThis, "SynSender", tunnel);
 
-	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;
@@ -14,22 +17,26 @@ import java.util.List;
 import java.util.Properties;
 
 import net.i2p.I2PException;
+import net.i2p.client.I2PSession;
+import net.i2p.client.I2PSessionException;
 import net.i2p.client.streaming.I2PSocket;
 import net.i2p.client.streaming.I2PSocketManager;
 import net.i2p.client.streaming.I2PSocketManagerFactory;
 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 +47,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 +62,129 @@ 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;
+    /**
+     * @throws IllegalArgumentException if the I2CP configuration is b0rked so
+     *                                  badly that we cant create a socketManager
+     */
+    public I2PTunnelClientBase(int localPort, boolean ownDest, Logging l, 
+                               EventDispatcher notifyThis, String handlerName, 
+                               I2PTunnel tunnel) throws IllegalArgumentException{
+        super(localPort + " (uninitialized)", notifyThis, tunnel);
+        _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");
+        synchronized (sockLock) {
+            if (ownDest) {
+                sockMgr = buildSocketManager();
+            } else {
+                sockMgr = getSocketManager();
+            }
+        }
+        if (sockMgr == null) {
+            l.log("Invalid I2CP configuration");
+            throw new IllegalArgumentException("Socket manager could not be created");
+        }
+        l.log("I2P session created");
+
+        getTunnel().addSession(sockMgr.getSession());
         
-	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");
-	}
+        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;
+
+    protected synchronized I2PSocketManager getSocketManager() {
+        return getSocketManager(getTunnel());
     }
-    
-    protected static I2PSocketManager buildSocketManager() {
-	Properties props = new Properties();
-	props.putAll(System.getProperties());
-	return I2PSocketManagerFactory.createManager
-	    (I2PTunnel.host, Integer.parseInt(I2PTunnel.port), props);
+    protected static synchronized I2PSocketManager getSocketManager(I2PTunnel tunnel) {
+        if (socketManager != null) {
+            I2PSession s = socketManager.getSession();
+            if ( (s == null) || (s.isClosed()) ) {
+                _log.info("Building a new socket manager since the old one closed [s=" + s + "]");
+                socketManager = buildSocketManager(tunnel);
+            } else {
+                _log.info("Not building a new socket manager since the old one is open [s=" + s + "]");
+            }
+        } else {
+            _log.info("Building a new socket manager since there is no other one");
+            socketManager = buildSocketManager(tunnel);
+        }
+        return socketManager;
     }
-    
+
+    protected I2PSocketManager buildSocketManager() {
+        return buildSocketManager(getTunnel());
+    }
+    protected static I2PSocketManager buildSocketManager(I2PTunnel tunnel) {
+        Properties props = new Properties();
+        if (tunnel == null)
+            props.putAll(System.getProperties());
+        else
+            props.putAll(tunnel.getClientOptions());
+        I2PSocketManager sockManager = I2PSocketManagerFactory.createManager(tunnel.host, Integer.parseInt(tunnel.port), props);
+        if (sockManager == null) return null;
+        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(getTunnel().listenHost);
+        } catch (UnknownHostException uhe) {
+            l.log("Could not find listen host to bind to [" + getTunnel().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 +195,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 +207,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 " + getTunnel().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 +269,64 @@ 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;
+            }
+            I2PSession session = sockMgr.getSession();
+            if (session != null) {
+                getTunnel().removeSession(session);
+            }
+            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,8 +8,14 @@ import java.io.IOException;
 import java.io.InputStreamReader;
 import java.io.OutputStream;
 import java.net.Socket;
+import java.net.SocketException;
+import java.util.ArrayList;
 import java.util.Date;
+import java.util.List;
+import java.util.StringTokenizer;
+import java.util.HashMap;
 
+import net.i2p.I2PAppContext;
 import net.i2p.I2PException;
 import net.i2p.client.streaming.I2PSocket;
 import net.i2p.data.DataFormatException;
@@ -19,316 +25,509 @@ 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 List proxyList;
 
-    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 HashMap addressHelpers = new HashMap();
+
+    private final static byte[] ERR_REQUEST_DENIED =
+        ("HTTP/1.1 403 Access Denied\r\n"+
+         "Content-Type: text/html; charset=iso-8859-1\r\n"+
+         "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 Destination 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 Destination 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");
+    private final static byte[] ERR_NO_OUTPROXY =
+        ("HTTP/1.1 503 Service Unavailable\r\n"+
+         "Content-Type: text/html; charset=iso-8859-1\r\n"+
+         "Cache-control: no-cache\r\n"+
+         "\r\n"+
+         "<html><body><H1>I2P ERROR: No outproxy found</H1>"+
+         "Your request was for a site outside of I2P, but you have no "+
+         "HTTP outproxy configured.  Please configure an outproxy in I2PTunnel")
+         .getBytes();
+    
+    /** used to assign unique IDs to the threads / clients.  no logic or functionality */
+    private static volatile long __clientId = 0;
 
-	if (waitEventValue("openBaseClientResult").equals("error")) {
-	    notifyEvent("openHTTPClientResult", "error");
-	    return;
-	}
-	
-	this.wwwProxy = wwwProxy;
+    /**
+     * @throws IllegalArgumentException if the I2PTunnel does not contain
+     *                                  valid config to contact the router
+     */
+    public I2PTunnelHTTPClient(int localPort, Logging l, boolean ownDest, 
+                               String wwwProxy, EventDispatcher notifyThis, 
+                               I2PTunnel tunnel) throws IllegalArgumentException {
+        super(localPort, ownDest, l, notifyThis, "HTTPHandler " + (++__clientId), tunnel);
 
-	setName(getLocalPort()
-		+ " -> HTTPClient [WWW outproxy: " + this.wwwProxy + "]");
+        if (waitEventValue("openBaseClientResult").equals("error")) {
+            notifyEvent("openHTTPClientResult", "error");
+            return;
+        }
 
-	startRunning();
+        proxyList = new ArrayList();
+        if (wwwProxy != null) {
+            StringTokenizer tok = new StringTokenizer(wwwProxy, ",");
+            while (tok.hasMoreTokens())
+                proxyList.add(tok.nextToken().trim());
+        }
 
-	notifyEvent("openHTTPClientResult", "ok");
+        setName(getLocalPort() + " -> HTTPClient [WWW outproxy list: " + wwwProxy + "]");
+
+        startRunning();
+
+        notifyEvent("openHTTPClientResult", "ok");
     }
 
+    private String getPrefix(long requestId) { return "Client[" + _clientId + "/" + requestId + "]: "; }
+    
+    private String selectProxy() {
+        synchronized (proxyList) {
+            int size = proxyList.size();
+            if (size <= 0) {
+                if (_log.shouldLog(Log.INFO))
+                    _log.info("Proxy list is empty - no outproxy available");
+                l.log("Proxy list is emtpy - no outproxy available");
+                return null;
+            }
+            int index = I2PAppContext.getGlobalContext().random().nextInt(size);
+            String proxy = (String)proxyList.get(index);
+            return proxy;
+        }
+    }
+    
+    private static long __requestId = 0;
     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;
+        String currentProxy = null;
+        InactivityTimeoutThread timeoutThread = null;
+        long requestId = ++__requestId;
+        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(requestId) + "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(requestId) + "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("/") && getTunnel().getClientOptions().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);
+                        if ( (host != null) && ("i2p".equals(host)) ) {
+                            int pos2;
+                            if ((pos2 = request.indexOf("?")) != -1) {
+                                // Try to find an address helper in the fragments
+                                // and split the request into it's component parts for rebuilding later
+                                String fragments = request.substring(pos2 + 1);
+                                String uriPath = request.substring(0, pos2);
+                                pos2 = fragments.indexOf(" ");
+                                String protocolVersion = fragments.substring(pos2 + 1);
+                                String urlEncoding = "";
+                                fragments = fragments.substring(0, pos2);
+                                fragments = fragments + "&";
+                                String fragment;
+                                while(fragments.length() > 0) {
+                                    pos2 = fragments.indexOf("&");
+                                    fragment = fragments.substring(0, pos2);
+                                    fragments = fragments.substring(pos2 + 1);
+                                    if (fragment.startsWith("i2paddresshelper")) {
+                                        pos2 = fragment.indexOf("=");
+                                        if (pos2 >= 0) {
+                                            addressHelpers.put(destination,fragment.substring(pos2 + 1));
+                                        }
+                                    } else {
+                                        // append each fragment unless it's the address helper
+                                        if ("".equals(urlEncoding)) {
+                                            urlEncoding = "?" + fragment;
+                                        } else {
+                                            urlEncoding = urlEncoding + "&" + fragment; 
+                                        }
+				    }
+                                }
+                                // reconstruct the request minus the i2paddresshelper GET var
+                                request = uriPath + urlEncoding + " " + protocolVersion;
+                            }
 
-			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
-			}
+                            String addressHelper = (String) addressHelpers.get(destination);
+                            if (addressHelper != null) {
+                                destination = addressHelper;
+                                host = getHostName(destination);
+                            }
+                        }
+                        line = method + " " + request.substring(pos);
+                    } else if (host.indexOf(".") != -1) {
+                        // The request must be forwarded to a WWW proxy
+                        if (_log.shouldLog(Log.DEBUG))
+                            _log.debug("Before selecting outproxy for " + host);
+                        currentProxy = selectProxy();
+                        if (_log.shouldLog(Log.DEBUG))
+                            _log.debug("After selecting outproxy for " + host + ": " + currentProxy);
+                        if (currentProxy == null) {
+                            if (_log.shouldLog(Log.WARN))
+                                _log.warn(getPrefix(requestId) + "Host wants to be outproxied, but we dont have any!");
+                            l.log("No HTTP outproxy found for the request.");
+                            if (out != null) {
+                                out.write(ERR_NO_OUTPROXY);
+                                out.write("<p /><i>Generated on: ".getBytes());
+                                out.write(new Date().toString().getBytes());
+                                out.write("</i></body></html>\n".getBytes());
+                                out.flush();
+                            }
+                            s.close();
+                            return;
+                        }
+                        destination = currentProxy;
+                        usingWWWProxy = true;
+                        if (_log.shouldLog(Log.DEBUG))
+                            _log.debug(getPrefix(requestId) + "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);
+                    }
 
-			if (_log.shouldLog(Log.DEBUG)) {
-			    _log.debug("METHOD:"+method+":");
-			    _log.debug("PROTOC:"+protocol+":");
-			    _log.debug("HOST  :"+host+":");
-			    _log.debug("DEST  :"+destination+":");
-			}
+                    boolean isValid = usingWWWProxy || isSupportedAddress(host, protocol);
+                    if (!isValid) {
+                        if (_log.shouldLog(Log.INFO)) _log.info(getPrefix(requestId) + "notValid(" + host + ")");
+                        method = null;
+                        destination = null;
+                        break;
+                    } else if (!usingWWWProxy) {
+                        if (_log.shouldLog(Log.INFO)) _log.info(getPrefix(requestId) + "host=getHostName(" + destination + ")");
+                        host = getHostName(destination); // hide original host
+                    }
 
-		    } 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(requestId) + "METHOD:" + method + ":");
+                        _log.debug(getPrefix(requestId) + "PROTOC:" + protocol + ":");
+                        _log.debug(getPrefix(requestId) + "HOST  :" + host + ":");
+                        _log.debug(getPrefix(requestId) + "DEST  :" + destination + ":");
+                    }
+                    
+                } else {
+                    if (line.startsWith("Host: ") && !usingWWWProxy) {
+                        line = "Host: " + host;
+                        if (_log.shouldLog(Log.INFO)) 
+                            _log.info(getPrefix(requestId) + "Setting host = " + host);
+                    } else if (line.startsWith("User-Agent: ")) {
+                        line = "User-Agent: MYOB/6.66 (AN/ON)";
+                    } else if (line.startsWith("Referer: ")) {
+                        // Shouldn't we be more specific, like accepting in-site referers ?
+                        //line = "Referer: i2p";
+                        line = null;
+                        continue; // completely strip the line
+                    } else if (line.startsWith("Via: ")) {
+                        //line = "Via: i2p";
+                        line = null;
+                        continue; // completely strip the line
+                    } else if (line.startsWith("From: ")) {
+                        //line = "From: i2p";
+                        line = null;
+                        continue; // completely strip the line
+                    }
+                }
+                
+                if (line.length() == 0) {
+                    newRequest.append("Connection: close\r\n\r\n");
+                    break;
+                } else {
+                    newRequest.append(line).append("\r\n"); // HTTP spec
+                }
+            }
+            if (_log.shouldLog(Log.DEBUG))
+                _log.debug(getPrefix(requestId) + "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(requestId) + "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, currentProxy, s, requestId);
+            timeoutThread.start();
+        } catch (SocketException ex) {
+            if (timeoutThread != null) timeoutThread.disable();
+            _log.info(getPrefix(requestId) + "Error trying to connect", ex);
+            l.log(ex.getMessage());
+            handleHTTPClientException(ex, out, targetRequest, usingWWWProxy, currentProxy, requestId);
+            closeSocket(s);
+        } catch (IOException ex) {
+            if (timeoutThread != null) timeoutThread.disable();
+            _log.info(getPrefix(requestId) + "Error trying to connect", ex);
+            l.log(ex.getMessage());
+            handleHTTPClientException(ex, out, targetRequest, usingWWWProxy, currentProxy, requestId);
+            closeSocket(s);
+        } catch (I2PException ex) {
+            if (timeoutThread != null) timeoutThread.disable();
+            _log.info("getPrefix(requestId) + Error trying to connect", ex);
+            l.log(ex.getMessage());
+            handleHTTPClientException(ex, out, targetRequest, usingWWWProxy, currentProxy, requestId);
+            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 String _currentProxy;
+        private long _requestId;
+        private boolean _disabled;
+        private Object _disableLock = new Object();
+
+        public InactivityTimeoutThread(I2PTunnelRunner runner, OutputStream out, String targetRequest,
+                                       boolean useWWWProxy, String currentProxy, Socket s, long requestId) {
+            this.s = s;
+            _runner = runner;
+            _out = out;
+            _targetRequest = targetRequest;
+            _useWWWProxy = useWWWProxy;
+            _currentProxy = currentProxy;
+            _disabled = false;
+            _requestId = requestId;
+            long timeoutId = ++__timeoutId;
+            setName("InactivityThread " + getPrefix(requestId) + 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(_requestId) + "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(_requestId) + "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(_requestId) + "Inactivity timeout reached");
+            l.log("Inactivity timeout reached");
+            if (_out != null) {
+                try {
+                    if (_runner.getLastActivityOn() > 0) {
+                        // some  data has been sent, so don't 404 it
+                    } else {
+                        writeErrorMessage(ERR_TIMEOUT, _out, _targetRequest, _useWWWProxy, _currentProxy);
+                    }
+                } catch (IOException ioe) {
+                    _log.warn(getPrefix(_requestId) + "Error writing out the 'timeout' message", ioe);
+                }
+            } else {
+                _log.warn(getPrefix(_requestId) + "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();
-	}	
+        if (host == null) return null;
+        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, long requestId) {
+                                                      
+        if (_log.shouldLog(Log.WARN))
+            _log.warn(getPrefix(requestId) + "Error sending to " + wwwProxy + " (proxy? " + usingWWWProxy + ", request: " + targetRequest, ex);
+        if (out != null) {
+            try {
+                writeErrorMessage(ERR_DESTINATION_UNKNOWN, out, targetRequest, usingWWWProxy, wwwProxy);
+            } catch (IOException ioe) {
+                _log.warn(getPrefix(requestId) + "Error writing out the 'destination was unknown' " + "message", ioe);
+            }
+        } else {
+            _log.warn(getPrefix(requestId) + "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,161 @@ 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, I2PTunnel tunnel) {
+        super(host + ":" + port + " <- " + privData, notifyThis, tunnel);
+        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, I2PTunnel tunnel) {
+        super(host + ":" + port + " <- " + privkeyname, notifyThis, tunnel);
+        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, I2PTunnel tunnel) {
+        super(host + ":" + port + " <- " + privkeyname, notifyThis, tunnel);
+        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(getTunnel().getClientOptions());
+        synchronized (slock) {
+            sockMgr = I2PSocketManagerFactory.createManager(privData, getTunnel().host, Integer.parseInt(getTunnel().port),
+                                                            props);
+
+        }
+        sockMgr.setName("Server");
+        getTunnel().addSession(sockMgr.getSession());
+        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();
+                getTunnel().removeSession(sockMgr.getSession());
+                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();
+                if (i2ps == null) throw new I2PException("I2PServerSocket closed");
+                I2PThread t = new I2PThread(new Handler(i2ps));
+                t.start();
+            }
+        } catch (I2PException ex) {
+            _log.error("Error while waiting for I2PConnections", ex);
+        } catch (IOException ex) {
+            _log.error("Error while waiting for I2PConnections", ex);
+        }
+    }
+    
+    /**
+     * Async handler to keep .accept() from blocking too long.  
+     * todo: replace with a thread pool so we dont get overrun by threads if/when
+     * receiving a lot of connection requests concurrently.
+     *
+     */
+    private class Handler implements Runnable { 
+        private I2PSocket _handleSocket;
+        public Handler(I2PSocket socket) {
+            _handleSocket = socket;
+        }
+        public void run() {
+            long afterAccept = I2PAppContext.getGlobalContext().clock().now();
+            long afterSocket = -1;
+            //local is fast, so synchronously. Does not need that many
+            //threads.
+            try {
+                _handleSocket.setReadTimeout(readTimeout);
+                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

@@ -26,50 +26,91 @@ public abstract class I2PTunnelTask implements EventDispatcher {
     //	I2PTunnelTask(name, (EventDispatcher)null);
     //}
 
-    protected I2PTunnelTask(String name, EventDispatcher notifyThis) {
-	attachEventDispatcher(notifyThis);
-	this.name=name;
-	this.id = -1;
+    protected I2PTunnelTask(String name, EventDispatcher notifyThis, I2PTunnel tunnel) {
+        attachEventDispatcher(notifyThis);
+        this.name = name;
+        this.id = -1;
+        this.tunnel = tunnel;
+    }
+
+    /** for apps that use multiple I2PTunnel instances */
+    public void setTunnel(I2PTunnel pTunnel) {
+        tunnel = pTunnel;
     }
     
-    /** for apps that use multiple I2PTunnel instances */
-    public void setTunnel(I2PTunnel pTunnel) { tunnel = pTunnel; }
-    
+    public I2PTunnel getTunnel() { return tunnel; }
+
     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();
+        getTunnel().removeSession(session);
+    }
+
+    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, I2PTunnel tunnel) {
+        super("I2Ping [" + cmd + "]", notifyThis, tunnel);
+        this.l = l;
+        command = cmd;
+        synchronized (slock) {
+            if (ownDest) {
+                sockMgr = I2PTunnelClient.buildSocketManager(tunnel);
+            } else {
+                sockMgr = I2PTunnelClient.getSocketManager(tunnel);
+            }
+        }
+        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/TunnelController.java

@@ -0,0 +1,418 @@
+package net.i2p.i2ptunnel;
+
+import java.io.IOException;
+import java.io.File;
+import java.io.FileOutputStream;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Properties;
+import java.util.Random;
+
+import net.i2p.I2PAppContext;
+import net.i2p.I2PException;
+import net.i2p.client.I2PClient;
+import net.i2p.client.I2PClientFactory;
+import net.i2p.client.I2PSession;
+import net.i2p.data.Destination;
+import net.i2p.util.Log;
+
+/**
+ * Coordinate the runtime operation and configuration of a tunnel.  
+ * These objects are bundled together under a TunnelControllerGroup where the
+ * entire group is stored / loaded from a single config file.
+ *
+ */
+public class TunnelController implements Logging {
+    private Log _log;
+    private Properties _config;
+    private I2PTunnel _tunnel;
+    private List _messages;
+    private List _sessions;
+    private boolean _running;
+    
+    /**
+     * Create a new controller for a tunnel out of the specific config options.
+     * The config may contain a large number of options - only ones that begin in
+     * the prefix should be used (and, in turn, that prefix should be stripped off
+     * before being interpreted by this controller)
+     * 
+     * @param config original key=value mapping
+     * @param prefix beginning of key values that are relevent to this tunnel
+     */
+    public TunnelController(Properties config, String prefix) {
+        this(config, prefix, true);
+    }
+    /**
+     * 
+     * @param createKey for servers, whether we want to create a brand new destination
+     *                  with private keys at the location specified or not (does not
+     *                  overwrite existing ones)
+     */
+    public TunnelController(Properties config, String prefix, boolean createKey) {
+        _tunnel = new I2PTunnel();
+        _log = I2PAppContext.getGlobalContext().logManager().getLog(TunnelController.class);
+        setConfig(config, prefix);
+        _messages = new ArrayList(4);
+        _running = false;
+        if (createKey && ("server".equals(getType())) )
+            createPrivateKey();
+        if (getStartOnLoad())
+            startTunnel();
+    }
+    
+    private void createPrivateKey() {
+        I2PClient client = I2PClientFactory.createClient();
+        String filename = getPrivKeyFile();
+        if ( (filename == null) || (filename.trim().length() <= 0) ) {
+            log("No filename specified for the private key");
+            return;
+        }
+        
+        File keyFile = new File(getPrivKeyFile());
+        if (keyFile.exists()) {
+            log("Not overwriting existing private keys in " + keyFile.getAbsolutePath());
+            return;
+        } else {
+            File parent = keyFile.getParentFile();
+            if ( (parent != null) && (!parent.exists()) )
+                parent.mkdirs();
+        }
+        FileOutputStream fos = null;
+        try {
+            fos = new FileOutputStream(keyFile);
+            Destination dest = client.createDestination(fos);
+            String destStr = dest.toBase64();
+            log("Private key created and saved in " + keyFile.getAbsolutePath());
+            log("New destination: " + destStr);
+        } catch (I2PException ie) {
+            if (_log.shouldLog(Log.ERROR))
+                _log.error("Error creating new destination", ie);
+            log("Error creating new destination: " + ie.getMessage());
+        } catch (IOException ioe) {
+            if (_log.shouldLog(Log.ERROR))
+                _log.error("Error creating writing the destination to " + keyFile.getAbsolutePath(), ioe);
+            log("Error writing the keys to " + keyFile.getAbsolutePath());
+        } finally {
+            if (fos != null) try { fos.close(); } catch (IOException ioe) {}
+        }
+    }
+    
+    /**
+     * Start up the tunnel (if it isn't already running)
+     *
+     */
+    public void startTunnel() {
+        try {
+            doStartTunnel();
+        } catch (Exception e) {
+            _log.error("Error starting up the tunnel", e);
+            log("Error starting up the tunnel - " + e.getMessage());
+        }
+    }
+    private void doStartTunnel() {
+        if (_running) {
+            if (_log.shouldLog(Log.INFO))
+                _log.info("Already running");
+            log("Tunnel " + getName() + " is already running");
+            return;
+        }
+        String type = getType(); 
+        if ( (type == null) || (type.length() <= 0) ) {
+            if (_log.shouldLog(Log.WARN))
+                _log.warn("Cannot start the tunnel - no type specified");
+            return;
+        }
+        if ("httpclient".equals(type)) {
+            startHttpClient();
+        } else if ("client".equals(type)) {
+            startClient();
+        } else if ("server".equals(type)) {
+            startServer();
+        } else {
+            if (_log.shouldLog(Log.ERROR))
+                _log.error("Cannot start tunnel - unknown type [" + type + "]");
+        }
+    }
+    
+    private void startHttpClient() {
+        setI2CPOptions();
+        setSessionOptions();
+        setListenOn();
+        String listenPort = getListenPort();
+        String proxyList = getProxyList();
+        if (proxyList == null)
+            _tunnel.runHttpClient(new String[] { listenPort }, this);
+        else
+            _tunnel.runHttpClient(new String[] { listenPort, proxyList }, this);
+        acquire();
+        _running = true;
+    }
+    
+    /** 
+     * Note the fact that we are using some sessions, so that they dont get
+     * closed by some other tunnels
+     */
+    private void acquire() {
+        List sessions = _tunnel.getSessions();
+        if (sessions != null) {
+            for (int i = 0; i < sessions.size(); i++) {
+                I2PSession session = (I2PSession)sessions.get(i);
+                TunnelControllerGroup.getInstance().acquire(this, session);
+            }
+            _sessions = sessions;
+        } else {
+            _log.error("No sessions to acquire?");
+        }
+    }
+    
+    /** 
+     * Note the fact that we are no longer using some sessions, and if
+     * no other tunnels are using them, close them.
+     */
+    private void release() {
+        if (_sessions != null) {
+            for (int i = 0; i < _sessions.size(); i++) {
+                I2PSession s = (I2PSession)_sessions.get(i);
+                TunnelControllerGroup.getInstance().release(this, s);
+            }
+        } else {
+            _log.error("No sessions to release?");
+        }
+    }
+    
+    private void startClient() {
+        setI2CPOptions();
+        setSessionOptions();
+        setListenOn();
+        String listenPort = getListenPort(); 
+        String dest = getTargetDestination();
+        _tunnel.runClient(new String[] { listenPort, dest }, this);
+        acquire();
+        _running = true;
+    }
+
+    private void startServer() {
+        setI2CPOptions();
+        setSessionOptions();
+        String targetHost = getTargetHost(); 
+        String targetPort = getTargetPort(); 
+        String privKeyFile = getPrivKeyFile(); 
+        _tunnel.runServer(new String[] { targetHost, targetPort, privKeyFile }, this);
+        acquire();
+        _running = true;
+    }
+    
+    private void setListenOn() {
+        String listenOn = getListenOnInterface();
+        if ( (listenOn != null) && (listenOn.length() > 0) ) {
+            _tunnel.runListenOn(new String[] { listenOn }, this);
+        }
+    }
+    
+    private void setSessionOptions() {
+        List opts = new ArrayList();
+        for (Iterator iter = _config.keySet().iterator(); iter.hasNext(); ) {
+            String key = (String)iter.next();
+            String val = _config.getProperty(key);
+            if (key.startsWith("option.")) {
+                key = key.substring("option.".length());
+                opts.add(key + "=" + val);
+            }
+        }
+        String args[] = new String[opts.size()];
+        for (int i = 0; i < opts.size(); i++)
+            args[i] = (String)opts.get(i);
+        _tunnel.runClientOptions(args, this);
+    }
+    
+    private void setI2CPOptions() {
+        String host = getI2CPHost();
+        if ( (host != null) && (host.length() > 0) ) 
+            _tunnel.host = host;
+        String port = getI2CPPort();
+        if ( (port != null) && (port.length() > 0) ) 
+            _tunnel.port = port;
+    }
+    
+    public void stopTunnel() {
+        _tunnel.runClose(new String[] { "forced", "all" }, this);
+        release();
+        _running = false;
+    }
+    
+    public void restartTunnel() {
+        stopTunnel();
+        startTunnel();
+    }
+    
+    public void setConfig(Properties config, String prefix) {
+        Properties props = new Properties();
+        for (Iterator iter = config.keySet().iterator(); iter.hasNext(); ) {
+            String key = (String)iter.next();
+            String val = config.getProperty(key);
+            if (key.startsWith(prefix)) {
+                key = key.substring(prefix.length());
+                props.setProperty(key, val);
+                if (_log.shouldLog(Log.DEBUG))
+                    _log.debug("Set prop [" + key + "] to [" + val + "]");
+            }
+        }
+        _config = props;
+    }
+    public Properties getConfig(String prefix) { 
+        Properties rv = new Properties();
+        for (Iterator iter = _config.keySet().iterator(); iter.hasNext(); ) {
+            String key = (String)iter.next();
+            String val = _config.getProperty(key);
+            rv.setProperty(prefix + key, val);
+        }
+        return rv;
+    }
+
+    public String getType() { return _config.getProperty("type"); }
+    public String getName() { return _config.getProperty("name"); }
+    public String getDescription() { return _config.getProperty("description"); }
+    public String getI2CPHost() { return _config.getProperty("i2cpHost"); }
+    public String getI2CPPort() { return _config.getProperty("i2cpPort"); }
+    public String getClientOptions() {
+        StringBuffer opts = new StringBuffer(64);
+        for (Iterator iter = _config.keySet().iterator(); iter.hasNext(); ) {
+            String key = (String)iter.next();
+            String val = _config.getProperty(key);
+            if (key.startsWith("option.")) {
+                key = key.substring("option.".length());
+                if (opts.length() > 0) opts.append(' ');
+                opts.append(key).append('=').append(val);
+            }
+        }
+        return opts.toString();
+    }
+    public String getListenOnInterface() { return _config.getProperty("interface"); }
+    public String getTargetHost() { return _config.getProperty("targetHost"); }
+    public String getTargetPort() { return _config.getProperty("targetPort"); }
+    public String getPrivKeyFile() { return _config.getProperty("privKeyFile"); }
+    public String getListenPort() { return _config.getProperty("listenPort"); }
+    public String getTargetDestination() { return _config.getProperty("targetDestination"); }
+    public String getProxyList() { return _config.getProperty("proxyList"); }
+    public boolean getStartOnLoad() { return "true".equalsIgnoreCase(_config.getProperty("startOnLoad", "true")); }
+    
+    public boolean getIsRunning() { return _running; }
+    
+    public void getSummary(StringBuffer buf) {
+        String type = getType();
+        if ("httpclient".equals(type))
+            getHttpClientSummary(buf);
+        else if ("client".equals(type))
+            getClientSummary(buf);
+        else if ("server".equals(type))
+            getServerSummary(buf);
+        else
+            buf.append("Unknown type ").append(type);
+    }
+    
+    private void getHttpClientSummary(StringBuffer buf) {
+        String description = getDescription();
+        if ( (description != null) && (description.trim().length() > 0) )
+            buf.append("<i>").append(description).append("</i><br />\n");
+        buf.append("HTTP proxy listening on port ").append(getListenPort());
+        String listenOn = getListenOnInterface();
+        if ("0.0.0.0".equals(listenOn)) 
+            buf.append(" (reachable by any machine)");
+        else if ("127.0.0.1".equals(listenOn))
+            buf.append(" (reachable locally only)");
+        else
+            buf.append(" (reachable at the ").append(listenOn).append(" interface)");
+        buf.append("<br />\n");
+        String proxies = getProxyList();
+        if ( (proxies == null) || (proxies.trim().length() <= 0) )
+            buf.append("Outproxy: default [squid.i2p]<br />\n");
+        else
+            buf.append("Outproxy: ").append(proxies).append("<br />\n");
+        getOptionSummary(buf);
+    }
+    
+    private void getClientSummary(StringBuffer buf) {
+        String description = getDescription();
+        if ( (description != null) && (description.trim().length() > 0) )
+            buf.append("<i>").append(description).append("</i><br />\n");
+        buf.append("Client tunnel listening on port ").append(getListenPort());
+        buf.append(" pointing at ").append(getTargetDestination());
+        String listenOn = getListenOnInterface();
+        if ("0.0.0.0".equals(listenOn)) 
+            buf.append(" (reachable by any machine)");
+        else if ("127.0.0.1".equals(listenOn))
+            buf.append(" (reachable locally only)");
+        else
+            buf.append(" (reachable at the ").append(listenOn).append(" interface)");
+        buf.append("<br />\n");
+        getOptionSummary(buf);
+    }
+    
+    private void getServerSummary(StringBuffer buf) {
+        String description = getDescription();
+        if ( (description != null) && (description.trim().length() > 0) )
+            buf.append("<i>").append(description).append("</i><br />\n");
+        buf.append("Server tunnel pointing at port ").append(getTargetPort());
+        buf.append(" on ").append(getTargetHost());
+        buf.append("<br />\n");
+        buf.append("Private destination loaded from ").append(getPrivKeyFile()).append("<br />\n");
+        getOptionSummary(buf);
+    }
+    
+    private void getOptionSummary(StringBuffer buf) {
+        String opts = getClientOptions();
+        if ( (opts != null) && (opts.length() > 0) )
+            buf.append("Network options: ").append(opts).append("<br />\n");
+        if (_running) {
+            List sessions = _tunnel.getSessions();
+            for (int i = 0; i < sessions.size(); i++) {
+                I2PSession session = (I2PSession)sessions.get(i);
+                Destination dest = session.getMyDestination();
+                if (dest != null) {
+                    buf.append("Destination hash: ").append(dest.calculateHash().toBase64()).append("<br />\n");
+                    if ("server".equals(getType())) {
+                        buf.append("Full destination: ");
+                        buf.append("<input type=\"text\" size=\"10\" onclick=\"this.select();\" ");
+                        buf.append("value=\"").append(dest.toBase64()).append("\" />\n");
+                        long val = new Random().nextLong();
+                        if (val < 0) val = 0 - val;
+                        buf.append("<br />You can <a href=\"http://temp").append(val);
+                        buf.append(".i2p/?i2paddresshelper=").append(dest.toBase64()).append("\">view</a>");
+                        buf.append(" it in a browser (only when you're using the eepProxy)\n");
+                        buf.append("<br />If you are going to share this on IRC, you need to split it up:<br />\n");
+                        String str = dest.toBase64();
+                        buf.append(str.substring(0, str.length()/2)).append("<br />\n");
+                        buf.append(str.substring(str.length()/2)).append("<br />\n");
+                        buf.append("You can also post it to <a href=\"http://forum.i2p/viewforum.php?f=16\">Eepsite announcement forum</a><br />");
+                    }
+                }
+            }
+        }
+    }
+    
+    public void log(String s) {
+        synchronized (this) {
+            _messages.add(s);
+            while (_messages.size() > 10)
+                _messages.remove(0);
+        }
+        if (_log.shouldLog(Log.INFO))
+            _log.info(s);
+    }
+    
+    /**
+     * Pull off any messages that the I2PTunnel has produced 
+     *
+     * @return list of messages pulled off (each is a String, earliest first)
+     */
+    public List clearMessages() { 
+        List rv = null;
+        synchronized (this) {
+            rv = new ArrayList(_messages);
+            _messages.clear();
+        }
+        return rv;
+    }
+}

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

@@ -0,0 +1,356 @@
+package net.i2p.i2ptunnel;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.Set;
+import java.util.TreeMap;
+
+import net.i2p.I2PAppContext;
+import net.i2p.client.I2PSession;
+import net.i2p.client.I2PSessionException;
+import net.i2p.util.Log;
+
+/**
+ * Coordinate a set of tunnels within the JVM, loading and storing their config
+ * to disk, and building new ones as requested.
+ *
+ */
+public class TunnelControllerGroup {
+    private Log _log;
+    private static TunnelControllerGroup _instance;
+    static final String DEFAULT_CONFIG_FILE = "i2ptunnel.config";
+    
+    private List _controllers;
+    private String _configFile = DEFAULT_CONFIG_FILE;
+    
+    /** 
+     * Map of I2PSession to a Set of TunnelController objects 
+     * using the session (to prevent closing the session until
+     * no more tunnels are using it)
+     *
+     */
+    private Map _sessions;
+    
+    public static TunnelControllerGroup getInstance() { return _instance; }
+
+    private TunnelControllerGroup(String configFile) {
+        _log = I2PAppContext.getGlobalContext().logManager().getLog(TunnelControllerGroup.class);
+        _instance = this;
+        _controllers = new ArrayList();
+        _configFile = configFile;
+        _sessions = new HashMap(4);
+        loadControllers(_configFile);
+    }
+
+    public static void main(String args[]) {
+        if ( (args == null) || (args.length <= 0) ) {
+            new TunnelControllerGroup(DEFAULT_CONFIG_FILE);
+        } else if (args.length == 1) {
+            if (DEFAULT_CONFIG_FILE.equals(args[0]))
+                new TunnelControllerGroup(DEFAULT_CONFIG_FILE);
+            else
+                new TunnelControllerGroup(args[0]);
+        } else {
+            System.err.println("Usage: TunnelControllerGroup [filename]");
+            return;
+        }
+    }
+    
+    /**
+     * Load up all of the tunnels configured in the given file (but do not start
+     * them)
+     *
+     */
+    public void loadControllers(String configFile) {
+        Properties cfg = loadConfig(configFile);
+        if (cfg == null) {
+            if (_log.shouldLog(Log.WARN))
+                _log.warn("Unable to load the config from " + configFile);
+            return;
+        }
+        int i = 0; 
+        while (true) {
+            String type = cfg.getProperty("tunnel." + i + ".type");
+            if (type == null) 
+                break;
+            TunnelController controller = new TunnelController(cfg, "tunnel." + i + ".");
+            _controllers.add(controller);
+            i++;
+        }
+        if (_log.shouldLog(Log.INFO))
+            _log.info(i + " controllers loaded from " + configFile);
+    }
+    
+    public void reloadControllers() {
+        unloadControllers();
+        loadControllers(_configFile);
+    }
+    
+    /**
+     * Stop and remove reference to all known tunnels (but dont delete any config
+     * file or do other silly things)
+     *
+     */
+    public void unloadControllers() {
+        stopAllControllers();
+        _controllers.clear();
+        if (_log.shouldLog(Log.INFO))
+            _log.info("All controllers stopped and unloaded");
+    }
+    
+    /**
+     * Add the given tunnel to the set of known controllers (but dont add it to
+     * a config file or start it or anything)
+     *
+     */
+    public void addController(TunnelController controller) { _controllers.add(controller); }
+    
+    /**
+     * Stop and remove the given tunnel
+     *
+     * @return list of messages from the controller as it is stopped
+     */
+    public List removeController(TunnelController controller) {
+        if (controller == null) return new ArrayList();
+        controller.stopTunnel();
+        List msgs = controller.clearMessages();
+        _controllers.remove(controller);
+        msgs.add("Tunnel " + controller.getName() + " removed");
+        return msgs;
+    }
+    
+    /**
+     * Stop all tunnels
+     *
+     * @return list of messages the tunnels generate when stopped
+     */
+    public List stopAllControllers() {
+        List msgs = new ArrayList();
+        for (int i = 0; i < _controllers.size(); i++) {
+            TunnelController controller = (TunnelController)_controllers.get(i);
+            controller.stopTunnel();
+            msgs.addAll(controller.clearMessages());
+        }
+        
+        if (_log.shouldLog(Log.INFO))
+            _log.info(_controllers.size() + " controllers stopped");
+        return msgs;
+    }
+    
+    /**
+     * Start all tunnels
+     *
+     * @return list of messages the tunnels generate when started
+     */
+    public List startAllControllers() {
+        List msgs = new ArrayList();
+        for (int i = 0; i < _controllers.size(); i++) {
+            TunnelController controller = (TunnelController)_controllers.get(i);
+            controller.startTunnel();
+            msgs.addAll(controller.clearMessages());
+        }
+        
+        if (_log.shouldLog(Log.INFO))
+            _log.info(_controllers.size() + " controllers started");
+        return msgs;
+    }
+    
+    /**
+     * Restart all tunnels
+     *
+     * @return list of messages the tunnels generate when restarted
+     */
+    public List restartAllControllers() {
+        List msgs = new ArrayList();
+        for (int i = 0; i < _controllers.size(); i++) {
+            TunnelController controller = (TunnelController)_controllers.get(i);
+            controller.restartTunnel();
+            msgs.addAll(controller.clearMessages());
+        }
+        if (_log.shouldLog(Log.INFO))
+            _log.info(_controllers.size() + " controllers restarted");
+        return msgs;
+    }
+    
+    /**
+     * Fetch all outstanding messages from any of the known tunnels
+     *
+     * @return list of messages the tunnels have generated
+     */
+    public List clearAllMessages() {
+        List msgs = new ArrayList();
+        for (int i = 0; i < _controllers.size(); i++) {
+            TunnelController controller = (TunnelController)_controllers.get(i);
+            msgs.addAll(controller.clearMessages());
+        }
+        return msgs;
+    }
+    
+    /**
+     * Save the configuration of all known tunnels to the default config 
+     * file
+     *
+     */
+    public void saveConfig() {
+        saveConfig(_configFile);
+    }
+    /**
+     * Save the configuration of all known tunnels to the given file
+     *
+     */
+    public void saveConfig(String configFile) {
+        _configFile = configFile;
+        File cfgFile = new File(configFile);
+        File parent = cfgFile.getParentFile();
+        if ( (parent != null) && (!parent.exists()) )
+            parent.mkdirs();
+        
+        
+        TreeMap map = new TreeMap();
+        for (int i = 0; i < _controllers.size(); i++) {
+            TunnelController controller = (TunnelController)_controllers.get(i);
+            Properties cur = controller.getConfig("tunnel." + i + ".");
+            map.putAll(cur);
+        }
+        
+        StringBuffer buf = new StringBuffer(1024);
+        for (Iterator iter = map.keySet().iterator(); iter.hasNext(); ) {
+            String key = (String)iter.next();
+            String val = (String)map.get(key);
+            buf.append(key).append('=').append(val).append('\n');
+        }
+        
+        FileOutputStream fos = null;
+        try {
+            fos = new FileOutputStream(cfgFile);
+            fos.write(buf.toString().getBytes());
+            if (_log.shouldLog(Log.INFO))
+                _log.info("Config written to " + cfgFile.getPath());
+        } catch (IOException ioe) {
+            _log.error("Error writing out the config");
+        } finally {
+            if (fos != null) try { fos.close(); } catch (IOException ioe) {}
+        }
+    }
+    
+    /**
+     * Load up the config data from the file
+     *
+     * @return properties loaded or null if there was an error
+     */
+    private Properties loadConfig(String configFile) {
+        File cfgFile = new File(configFile);
+        if (!cfgFile.exists()) {
+            if (_log.shouldLog(Log.ERROR))
+                _log.error("Unable to load the controllers from " + configFile);
+            return null;
+        }
+        
+        Properties props = new Properties();
+        FileInputStream fis = null;
+        try {
+            fis = new FileInputStream(cfgFile);
+            BufferedReader in = new BufferedReader(new InputStreamReader(fis));
+            String line = null;
+            while ( (line = in.readLine()) != null) {
+                line = line.trim();
+                if (line.length() <= 0) continue;
+                if (line.startsWith("#") || line.startsWith(";"))
+                    continue;
+                int eq = line.indexOf('=');
+                if ( (eq <= 0) || (eq >= line.length() - 1) )
+                    continue;
+                String key = line.substring(0, eq);
+                String val = line.substring(eq+1);
+                props.setProperty(key, val);
+            }
+            
+            if (_log.shouldLog(Log.INFO))
+                _log.info("Props loaded with " + props.size() + " lines");
+            return props;
+        } catch (IOException ioe) {
+            if (_log.shouldLog(Log.ERROR))
+                _log.error("Error reading the controllers from " + configFile, ioe);
+            return null;
+        } finally {
+            if (fis != null) try { fis.close(); } catch (IOException ioe) {}
+        }
+    }
+    
+    /**
+     * Retrieve a list of tunnels known
+     *
+     * @return list of TunnelController objects
+     */
+    public List getControllers() { return _controllers; }
+    
+    
+    /** 
+     * Note the fact that the controller is using the session so that
+     * it isn't destroyed prematurely.
+     *
+     */
+    void acquire(TunnelController controller, I2PSession session) {
+        synchronized (_sessions) {
+            Set owners = (Set)_sessions.get(session);
+            if (owners == null) {
+                owners = new HashSet(1);
+                _sessions.put(session, owners);
+            }
+            owners.add(controller);
+        }
+        if (_log.shouldLog(Log.INFO))
+            _log.info("Acquiring session " + session + " for " + controller);
+
+    }
+    
+    /** 
+     * Note the fact that the controller is no longer using the session, and if
+     * no other controllers are using it, destroy the session.
+     *
+     */
+    void release(TunnelController controller, I2PSession session) {
+        boolean shouldClose = false;
+        synchronized (_sessions) {
+            Set owners = (Set)_sessions.get(session);
+            if (owners != null) {
+                owners.remove(controller);
+                if (owners.size() <= 0) {
+                    if (_log.shouldLog(Log.INFO))
+                        _log.info("After releasing session " + session + " by " + controller + ", no more owners remain");
+                    shouldClose = true;
+                    _sessions.remove(session);
+                } else {
+                    if (_log.shouldLog(Log.INFO))
+                        _log.info("After releasing session " + session + " by " + controller + ", " + owners.size() + " owners remain");
+                    shouldClose = false;
+                }
+            } else {
+                if (_log.shouldLog(Log.WARN))
+                    _log.warn("After releasing session " + session + " by " + controller + ", no owners were even known?!");
+                shouldClose = true;
+            }
+        }
+        if (shouldClose) {
+            try {
+                session.destroySession();
+                if (_log.shouldLog(Log.INFO))
+                    _log.info("Session destroyed: " + session);
+            } catch (I2PSessionException ise) {
+                _log.error("Error closing the client session", ise);
+            }
+        }
+    }
+}

apps/i2ptunnel/java/src/net/i2p/i2ptunnel/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/WebEditPageFormGenerator.java

@@ -0,0 +1,313 @@
+package net.i2p.i2ptunnel;
+
+import java.io.File;
+
+import java.util.Iterator;
+import java.util.Properties;
+import java.util.Random;
+import java.util.StringTokenizer;
+
+/**
+ * Uuuugly code to generate the edit/add forms for the various 
+ * I2PTunnel types (httpclient/client/server)
+ *
+ */
+class WebEditPageFormGenerator {
+    private static final String SELECT_TYPE_FORM =
+      "<form action=\"edit.jsp\"> Type of tunnel: <select name=\"type\">" +
+      "<option value=\"httpclient\">HTTP proxy</option>" +
+      "<option value=\"client\">Client tunnel</option>" +
+      "<option value=\"server\">Server tunnel</option>" +
+      "</select> <input type=\"submit\" value=\"GO\" />" +
+      "</form>\n";
+    
+    /**
+     * Retrieve the form requested
+     *
+     */
+    public static String getForm(WebEditPageHelper helper) {
+        TunnelController controller = helper.getTunnelController();
+
+        if ( (helper.getType() == null) && (controller == null) )
+            return SELECT_TYPE_FORM;
+        
+        String id = helper.getNum();
+        String type = helper.getType();
+        if (controller != null)
+            type = controller.getType();
+        
+        if ("httpclient".equals(type))
+            return getEditHttpClientForm(controller, id);
+        else if ("client".equals(type))
+            return getEditClientForm(controller, id);
+        else if ("server".equals(type))
+            return getEditServerForm(controller, id);
+        else
+            return "WTF, unknown type [" + type + "]";
+    }
+    
+    private static String getEditHttpClientForm(TunnelController controller, String id) {
+        StringBuffer buf = new StringBuffer(1024);
+        addGeneral(buf, controller, id);
+        buf.append("<b>Type:</b> <i>HTTP proxy</i><input type=\"hidden\" name=\"type\" value=\"httpclient\" /><br />\n");
+        
+        addListeningOn(buf, controller, 4444);
+        
+        buf.append("<b>Outproxies:</b> <input type=\"text\" name=\"proxyList\" size=\"20\" ");
+        if ( (controller != null) && (controller.getProxyList() != null) )
+            buf.append("value=\"").append(controller.getProxyList()).append("\" ");
+        else
+            buf.append("value=\"squid.i2p\" ");
+        buf.append("/><br />\n");
+        
+        addOptions(buf, controller);
+        buf.append("<input type=\"submit\" name=\"action\" value=\"Save\">\n");
+        buf.append("<input type=\"submit\" name=\"action\" value=\"Remove\">\n");
+        buf.append(" <i>confirm removal:</i> <input type=\"checkbox\" name=\"removeConfirm\" value=\"true\" />\n");
+        buf.append("</form>\n");
+        return buf.toString();
+    }
+    
+    private static String getEditClientForm(TunnelController controller, String id) {
+        StringBuffer buf = new StringBuffer(1024);
+        addGeneral(buf, controller, id);
+        buf.append("<b>Type:</b> <i>Client tunnel</i><input type=\"hidden\" name=\"type\" value=\"client\" /><br />\n");
+        
+        addListeningOn(buf, controller, 2025 + new Random().nextInt(1000)); // 2025 since nextInt can be negative
+
+        buf.append("<b>Target:</b> <input type=\"text\" size=\"40\" name=\"targetDestination\" ");
+        if ( (controller != null) && (controller.getTargetDestination() != null) )
+            buf.append("value=\"").append(controller.getTargetDestination()).append("\" ");
+        buf.append(" /> (either the hosts.txt name or the full base64 destination)<br />\n");
+        
+        addOptions(buf, controller);
+        buf.append("<input type=\"submit\" name=\"action\" value=\"Save\"><br />\n");
+        buf.append("<input type=\"submit\" name=\"action\" value=\"Remove\">\n");
+        buf.append(" <i>confirm removal:</i> <input type=\"checkbox\" name=\"removeConfirm\" value=\"true\" />\n");
+        buf.append("</form>\n");
+        return buf.toString();
+    }
+    
+    private static String getEditServerForm(TunnelController controller, String id) {
+        StringBuffer buf = new StringBuffer(1024);
+        addGeneral(buf, controller, id);
+        buf.append("<b>Type:</b> <i>Server tunnel</i><input type=\"hidden\" name=\"type\" value=\"server\" /><br />\n");
+        
+        buf.append("<b>Target host:</b> <input type=\"text\" size=\"40\" name=\"targetHost\" ");
+        if ( (controller != null) && (controller.getTargetHost() != null) )
+            buf.append("value=\"").append(controller.getTargetHost()).append("\" ");
+        else
+            buf.append("value=\"localhost\" ");
+        buf.append(" /><br />\n");
+        
+        buf.append("<b>Target port:</b> <input type=\"text\" size=\"4\" name=\"targetPort\" ");
+        if ( (controller != null) && (controller.getTargetPort() != null) )
+            buf.append("value=\"").append(controller.getTargetPort()).append("\" ");
+        else
+            buf.append("value=\"80\" ");
+        buf.append(" /><br />\n");
+        
+        buf.append("<b>Private key file:</b> <input type=\"text\" name=\"privKeyFile\" value=\"");
+        if ( (controller != null) && (controller.getPrivKeyFile() != null) ) {
+            buf.append(controller.getPrivKeyFile()).append("\" /><br />");
+        } else {
+            buf.append("myServer.privKey\" /><br />");
+            buf.append("<input type=\"hidden\" name=\"privKeyGenerate\" value=\"true\" />");
+        }
+        
+        addOptions(buf, controller);
+        buf.append("<input type=\"submit\" name=\"action\" value=\"Save\">\n");
+        buf.append("<input type=\"submit\" name=\"action\" value=\"Remove\">\n");
+        buf.append(" <i>confirm removal:</i> <input type=\"checkbox\" name=\"removeConfirm\" value=\"true\" />\n");
+        buf.append("</form>\n");
+        return buf.toString();
+    }
+    
+    /**
+     * Start off the form and add some common fields (name, num, description)
+     *
+     * @param buf where to shove the form
+     * @param controller tunnel in question, or null if we're creating a new tunnel
+     * @param id index into the current list of tunnelControllerGroup.getControllers() list
+     *           (or null if we are generating an 'add' form)
+     */
+    private static void addGeneral(StringBuffer buf, TunnelController controller, String id) {
+        buf.append("<form action=\"edit.jsp\">");
+        if (id != null)
+            buf.append("<input type=\"hidden\" name=\"num\" value=\"").append(id).append("\" />");
+            
+        buf.append("<b>Name:</b> <input type=\"text\" name=\"name\" size=\"20\" ");
+        if ( (controller != null) && (controller.getName() != null) )
+            buf.append("value=\"").append(controller.getName()).append("\" ");
+        buf.append("/><br />\n");
+        
+        buf.append("<b>Description:</b> <input type=\"text\" name=\"description\" size=\"60\" ");
+        if ( (controller != null) && (controller.getDescription() != null) )
+            buf.append("value=\"").append(controller.getDescription()).append("\" ");
+        buf.append("/><br />\n");
+    }
+
+    /**
+     * Generate the fields asking for what port and interface the tunnel should 
+     * listen on.
+     *
+     * @param buf where to shove the form
+     * @param controller tunnel in question, or null if we're creating a new tunnel
+     * @param defaultPort if we are creating a new tunnel, default the form to the given port
+     */
+    private static void addListeningOn(StringBuffer buf, TunnelController controller, int defaultPort) {
+        buf.append("<b>Listening on port:</b> <input type=\"text\" name=\"port\" size=\"20\" ");
+        if ( (controller != null) && (controller.getListenPort() != null) )
+            buf.append("value=\"").append(controller.getListenPort()).append("\" ");
+        else
+            buf.append("value=\"").append(defaultPort).append("\" ");
+        buf.append("/><br />\n");
+
+        String selectedOn = null;
+        if ( (controller != null) && (controller.getListenOnInterface() != null) )
+            selectedOn = controller.getListenOnInterface();
+        
+        buf.append("<b>Reachable by:</b> ");
+        buf.append("<select name=\"reachableBy\">");
+        buf.append("<option value=\"127.0.0.1\" ");
+        if ( (selectedOn != null) && ("127.0.0.1".equals(selectedOn)) )
+            buf.append("selected=\"true\" ");
+        buf.append(">Locally (127.0.0.1)</option>\n");
+        buf.append("<option value=\"0.0.0.0\" ");
+        if ( (selectedOn != null) && ("0.0.0.0".equals(selectedOn)) )
+            buf.append("selected=\"true\" ");
+        buf.append(">Everyone (0.0.0.0)</option>\n");
+        buf.append("</select> ");
+        buf.append("Other: <input type=\"text\" name=\"reachableByOther\" value=\"");
+        if ( (selectedOn != null) && (!"127.0.0.1".equals(selectedOn)) && (!"0.0.0.0".equals(selectedOn)) )
+            buf.append(selectedOn);
+        buf.append("\"><br />\n");
+    }
+    
+    /**
+     * Add fields for customizing the I2PSession options, including helpers for
+     * tunnel depth and count, as well as I2CP host and port.
+     *
+     * @param buf where to shove the form
+     * @param controller tunnel in question, or null if we're creating a new tunnel
+     */
+    private static void addOptions(StringBuffer buf, TunnelController controller) {
+        int tunnelDepth = 2;
+        int numTunnels = 2;
+        Properties opts = getOptions(controller);
+        if (opts != null) {
+            String depth = opts.getProperty("tunnels.depthInbound");
+            if (depth != null) {
+                try {
+                    tunnelDepth = Integer.parseInt(depth);
+                } catch (NumberFormatException nfe) {
+                    tunnelDepth = 2;
+                }
+            }
+            String num = opts.getProperty("tunnels.numInbound");
+            if (num != null) {
+                try {
+                    numTunnels = Integer.parseInt(num);
+                } catch (NumberFormatException nfe) {
+                    numTunnels = 2;
+                }
+            }
+        }
+        
+        buf.append("<b>Tunnel depth:</b> ");
+        buf.append("<select name=\"tunnelDepth\">");
+        buf.append("<option value=\"0\" ");
+        if (tunnelDepth == 0) buf.append(" selected=\"true\" ");
+        buf.append(">0 hop tunnel (low anonymity, low latency)</option>");
+        buf.append("<option value=\"1\" ");
+        if (tunnelDepth == 1) buf.append(" selected=\"true\" ");
+        buf.append(">1 hop tunnel (medium anonymity, medium latency)</option>");
+        buf.append("<option value=\"2\" ");
+        if (tunnelDepth == 2) buf.append(" selected=\"true\" ");
+        buf.append(">2 hop tunnel (high anonymity, high latency)</option>");
+        if (tunnelDepth > 2) {
+            buf.append("<option value=\"").append(tunnelDepth).append("\" selected=\"true\" >");
+            buf.append(tunnelDepth);
+            buf.append(" hop tunnel (custom)</option>");
+        }
+        buf.append("</select><br />\n");
+        
+        buf.append("<b>Tunnel count:</b> ");
+        buf.append("<select name=\"tunnelCount\">");
+        buf.append("<option value=\"1\" ");
+        if (numTunnels == 1) buf.append(" selected=\"true\" ");
+        buf.append(">1 inbound tunnel (low bandwidth usage, less reliability)</option>");
+        buf.append("<option value=\"2\" ");
+        if (numTunnels == 2) buf.append(" selected=\"true\" ");
+        buf.append(">2 inbound tunnels (standard bandwidth usage, standard reliability)</option>");
+        buf.append("<option value=\"3\" ");
+        if (numTunnels == 3) buf.append(" selected=\"true\" ");
+        buf.append(">3 inbound tunnels (higher bandwidth usage, higher reliability)</option>");
+        
+        if (numTunnels > 3) {
+            buf.append("<option value=\"").append(numTunnels).append("\" selected=\"true\" >");
+            buf.append(numTunnels);
+            buf.append(" inbound tunnels (custom)</option>");
+        }
+        buf.append("</select><br />\n");
+        
+        buf.append("<b>I2CP host:</b> ");
+        buf.append("<input type=\"text\" name=\"clientHost\" size=\"20\" value=\"");
+        if ( (controller != null) && (controller.getI2CPHost() != null) )
+            buf.append(controller.getI2CPHost());
+        else
+            buf.append("localhost");
+        buf.append("\" /><br />\n");
+        buf.append("<b>I2CP port:</b> ");
+        buf.append("<input type=\"text\" name=\"clientPort\" size=\"20\" value=\"");
+        if ( (controller != null) && (controller.getI2CPPort() != null) )
+            buf.append(controller.getI2CPPort());
+        else
+            buf.append("7654");
+        buf.append("\" /><br />\n");
+        
+        buf.append("<b>Other custom options:</b> \n");
+        buf.append("<input type=\"text\" name=\"customOptions\" size=\"60\" value=\"");
+        if (opts != null) {
+            int i = 0;
+            for (Iterator iter = opts.keySet().iterator(); iter.hasNext(); ) {
+                String key = (String)iter.next();
+                String val = opts.getProperty(key);
+                if ("tunnels.depthInbound".equals(key)) continue;
+                if ("tunnels.numInbound".equals(key)) continue;
+                if (i != 0) buf.append(' ');
+                buf.append(key).append('=').append(val);
+                i++;
+            }
+        }
+        buf.append("\" /><br />\n");
+        buf.append("<b>Start automatically?</b> \n");
+        buf.append("<input type=\"checkbox\" name=\"startOnLoad\" value=\"true\" ");
+        if ( (controller != null) && (controller.getStartOnLoad()) )
+            buf.append(" checked=\"true\" />\n<br />\n");
+        else
+            buf.append(" />\n<br />\n");
+    }
+
+    /**
+     * Retrieve the client options from the tunnel
+     *
+     * @return map of name=val to be used as I2P session options
+     */
+    private static Properties getOptions(TunnelController controller) {
+        if (controller == null) return null;
+        String opts = controller.getClientOptions();
+        StringTokenizer tok = new StringTokenizer(opts);
+        Properties props = new Properties();
+        while (tok.hasMoreTokens()) {
+            String pair = tok.nextToken();
+            int eq = pair.indexOf('=');
+            if ( (eq <= 0) || (eq >= pair.length()) )
+                continue;
+            String key = pair.substring(0, eq);
+            String val = pair.substring(eq+1);
+            props.setProperty(key, val);
+        }
+        return props;
+    }
+}

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

@@ -0,0 +1,358 @@
+package net.i2p.i2ptunnel;
+
+import java.util.List;
+import java.util.Properties;
+import java.util.StringTokenizer;
+
+import net.i2p.I2PAppContext;
+import net.i2p.util.Log;
+
+/**
+ * UUUUuuuuuugly glue code to handle bean interaction from the web, process
+ * that data, and spit out the results (or the form requested).  The basic 
+ * usage is to set any of the fields with data then query the bean via 
+ * getActionResults() which triggers the request processing (taking all the 
+ * provided data, doing what needs to be done) and returns the results of those
+ * activites.  Then a subsequent call to getEditForm() generates the HTML form
+ * to either edit the currently selected tunnel (if specified) or add a new one.
+ * This functionality is delegated to the WebEditPageFormGenerator.
+ *
+ */
+public class WebEditPageHelper {
+    private Log _log;
+    private String _action;
+    private String _type;
+    private String _id;
+    private String _name;
+    private String _description;
+    private String _i2cpHost;
+    private String _i2cpPort;
+    private String _tunnelDepth;
+    private String _tunnelCount;
+    private String _customOptions;
+    private String _proxyList;
+    private String _port;
+    private String _reachableBy;
+    private String _reachableByOther;
+    private String _targetDestination;
+    private String _targetHost;
+    private String _targetPort;
+    private String _privKeyFile;
+    private boolean _startOnLoad;
+    private boolean _privKeyGenerate;
+    private boolean _removeConfirmed;
+    
+    public WebEditPageHelper() {
+        _action = null;
+        _type = null;
+        _id = null;
+        _removeConfirmed = false;
+        _log = I2PAppContext.getGlobalContext().logManager().getLog(WebEditPageHelper.class);
+    }
+    
+    /**
+     * Used for form submit - either "Save" or Remove"
+     */
+    public void setAction(String action) { 
+        _action = (action != null ? action.trim() : null);   
+    }
+    /**
+     * What type of tunnel (httpclient, client, or server).  This is 
+     * required when adding a new tunnel.
+     *
+     */
+    public void setType(String type) { 
+        _type = (type != null ? type.trim() : null);   
+    }
+    /**
+     * Which particular tunnel should be edited (index into the current
+     * TunnelControllerGroup's getControllers() list).  This is required
+     * when editing a tunnel, but not when adding a new one.
+     *
+     */
+    public void setNum(String id) { 
+        _id = (id != null ? id.trim() : null);   
+    }
+    String getType() { return _type; }
+    String getNum() { return _id; }
+    
+    /** Short name of the tunnel */
+    public void setName(String name) { 
+        _name = (name != null ? name.trim() : null);
+    }
+    /** one line description */
+    public void setDescription(String description) { 
+        _description = (description != null ? description.trim() : null);
+    }
+    /** I2CP host the router is on */
+    public void setClientHost(String host) {
+        _i2cpHost = (host != null ? host.trim() : null);
+    }
+    /** I2CP port the router is on */
+    public void setClientPort(String port) {
+        _i2cpPort = (port != null ? port.trim() : null);
+    }
+    /** how many hops to use for inbound tunnels */
+    public void setTunnelDepth(String tunnelDepth) { 
+        _tunnelDepth = (tunnelDepth != null ? tunnelDepth.trim() : null);
+    }
+    /** how many parallel inbound tunnels to use */
+    public void setTunnelCount(String tunnelCount) { 
+        _tunnelCount = (tunnelCount != null ? tunnelCount.trim() : null);
+    }
+    /** what I2P session overrides should be used */
+    public void setCustomOptions(String customOptions) { 
+        _customOptions = (customOptions != null ? customOptions.trim() : null);
+    }
+    /** what HTTP outproxies should be used (httpclient specific) */
+    public void setProxyList(String proxyList) { 
+        _proxyList = (proxyList != null ? proxyList.trim() : null);
+    }
+    /** what port should this client/httpclient listen on */
+    public void setPort(String port) { 
+        _port = (port != null ? port.trim() : null);
+    }
+    /** 
+     * what interface should this client/httpclient listen on (unless 
+     * overridden by the setReachableByOther() field)
+     */
+    public void setReachableBy(String reachableBy) { 
+        _reachableBy = (reachableBy != null ? reachableBy.trim() : null);
+    }
+    /**
+     * If specified, defines the exact IP interface to listen for requests
+     * on (in the case of client/httpclient tunnels)
+     */
+    public void setReachableByOther(String reachableByOther) { 
+        _reachableByOther = (reachableByOther != null ? reachableByOther.trim() : null);
+    }
+    /** What peer does this client tunnel point at */
+    public void setTargetDestination(String dest) { 
+        _targetDestination = (dest != null ? dest.trim() : null);
+    }
+    /** What host does this server tunnel point at */
+    public void setTargetHost(String host) { 
+        _targetHost = (host != null ? host.trim() : null);
+    }
+    /** What port does this server tunnel point at */
+    public void setTargetPort(String port) { 
+        _targetPort = (port != null ? port.trim() : null);
+    }
+    /** What filename is this server tunnel's private keys stored in */
+    public void setPrivKeyFile(String file) { 
+        _privKeyFile = (file != null ? file.trim() : null);
+    }
+    /** 
+     * If called with any value, we want to generate a new destination
+     * for this server tunnel.  This won't cause any existing private keys
+     * to be overwritten, however.
+     */
+    public void setPrivKeyGenerate(String moo) { 
+        _privKeyGenerate = true;
+    }
+    /**
+     * If called with any value (and the form submitted with action=Remove),
+     * we really do want to stop and remove the tunnel.
+     */
+    public void setRemoveConfirm(String moo) {
+        _removeConfirmed = true;
+    }
+    /**
+     * If called with any value, we want this tunnel to start whenever it is
+     * loaded (aka right now and whenever the router is started up)
+     */
+    public void setStartOnLoad(String moo) {
+        _startOnLoad = true;
+    }
+    
+    /**
+     * Process the form and display any resulting messages
+     *
+     */
+    public String getActionResults() {
+        try {
+            return processAction();
+        } catch (Throwable t) {
+            _log.log(Log.CRIT, "Internal error processing request", t);
+            return "Internal error - " + t.getMessage();
+        }
+    }
+    
+    /**
+     * Generate an HTML form to edit / create a tunnel according to the 
+     * specified fields
+     */
+    public String getEditForm() {
+        try {
+            return WebEditPageFormGenerator.getForm(this);
+        } catch (Throwable t) {
+            _log.log(Log.CRIT, "Internal error retrieving edit form", t);
+            return "Internal error - " + t.getMessage();
+        }
+    }
+
+    /**
+     * Retrieve the tunnel pointed to by the current id
+     *
+     */
+    TunnelController getTunnelController() {
+        if (_id == null) return null;
+        int id = -1;
+        try {
+            id = Integer.parseInt(_id);
+            List controllers = TunnelControllerGroup.getInstance().getControllers();
+            if ( (id < 0) || (id >= controllers.size()) )
+                return null;
+            else
+                return (TunnelController)controllers.get(id);
+        } catch (NumberFormatException nfe) {
+            if (_log.shouldLog(Log.WARN))
+                _log.warn("Invalid tunnel id [" + _id + "]", nfe);
+            return null;
+        }
+    }
+    
+    private String processAction() {
+        if ( (_action == null) || (_action.trim().length() <= 0) )
+            return "";
+        if ("Save".equals(_action))
+            return save();
+        else if ("Remove".equals(_action))
+            return remove();
+        else
+            return "Action <i>" + _action + "</i> unknown";
+    }
+    
+    private String remove() {
+        if (!_removeConfirmed)
+            return "Please confirm removal";
+        
+        TunnelController cur = getTunnelController();
+        if (cur == null)
+            return "Invalid tunnel number";
+        
+        List msgs = TunnelControllerGroup.getInstance().removeController(cur);
+        msgs.addAll(doSave());
+        return getMessages(msgs);
+    }
+    
+    private String save() {
+        if (_type == null)
+            return "<b>Invalid form submission (no type?)</b>";
+        Properties config = getConfig();
+        if (config == null)
+            return "<b>Invalid params</b>";
+        
+        TunnelController cur = getTunnelController();
+        if (cur == null) {
+            // creating new
+            cur = new TunnelController(config, "", _privKeyGenerate);
+            TunnelControllerGroup.getInstance().addController(cur);
+        } else {
+            cur.setConfig(config, "");
+        }
+        
+        
+        return getMessages(doSave());
+    }
+    private List doSave() { 
+        TunnelControllerGroup.getInstance().saveConfig();
+        return TunnelControllerGroup.getInstance().clearAllMessages();
+    }
+    
+    /**
+     * Based on all provided data, create a set of configuration parameters 
+     * suitable for use in a TunnelController.  This will replace (not add to)
+     * any existing parameters, so this should return a comprehensive mapping.
+     *
+     */
+    private Properties getConfig() {
+        Properties config = new Properties();
+        updateConfigGeneric(config);
+        
+        if ("httpclient".equals(_type)) {
+            if (_port != null)
+                config.setProperty("listenPort", _port);
+            if (_reachableByOther != null)
+                config.setProperty("interface", _reachableByOther);
+            else
+                config.setProperty("interface", _reachableBy);
+            if (_proxyList != null)
+                config.setProperty("proxyList", _proxyList);
+        } else if ("client".equals(_type)) {
+            if (_port != null)
+                config.setProperty("listenPort", _port);
+            if (_reachableByOther != null)
+                config.setProperty("interface", _reachableByOther);
+            else
+                config.setProperty("interface", _reachableBy);
+            if (_targetDestination != null)
+                config.setProperty("targetDestination", _targetDestination);
+        } else if ("server".equals(_type)) {
+            if (_targetHost != null)
+                config.setProperty("targetHost", _targetHost);
+            if (_targetPort != null)
+                config.setProperty("targetPort", _targetPort);
+            if (_privKeyFile != null)
+                config.setProperty("privKeyFile", _privKeyFile);
+        } else {
+            return null;
+        }
+        
+        return config;
+    }
+    
+    private void updateConfigGeneric(Properties config) {
+        config.setProperty("type", _type);
+        if (_name != null)
+            config.setProperty("name", _name);
+        if (_description != null)
+            config.setProperty("description", _description);
+        if (_i2cpHost != null)
+            config.setProperty("i2cpHost", _i2cpHost);
+        if (_i2cpPort != null)
+            config.setProperty("i2cpPort", _i2cpPort);
+        
+        if (_customOptions != null) {
+            StringTokenizer tok = new StringTokenizer(_customOptions);
+            while (tok.hasMoreTokens()) {
+                String pair = tok.nextToken();
+                int eq = pair.indexOf('=');
+                if ( (eq <= 0) || (eq >= pair.length()) )
+                    continue;
+                String key = pair.substring(0, eq);
+                String val = pair.substring(eq+1);
+                if ("tunnels.numInbound".equals(key)) continue;
+                if ("tunnels.depthInbound".equals(key)) continue;
+                config.setProperty("option." + key, val);
+            }
+        }
+
+        config.setProperty("startOnLoad", _startOnLoad + "");
+        
+        if (_tunnelCount != null)
+            config.setProperty("option.tunnels.numInbound", _tunnelCount);
+        if (_tunnelDepth != null)
+            config.setProperty("option.tunnels.depthInbound", _tunnelDepth);
+    }
+
+    /**
+     * Pretty print the messages provided
+     *
+     */
+    private String getMessages(List msgs) {
+        if (msgs == null) return "";
+        int num = msgs.size();
+        switch (num) {
+            case 0: return "";
+            case 1: return (String)msgs.get(0);
+            default:
+                StringBuffer buf = new StringBuffer(512);
+                buf.append("<ul>");
+                for (int i = 0; i < num; i++)
+                    buf.append("<li>").append((String)msgs.get(i)).append("</li>\n");
+                buf.append("</ul>\n");
+                return buf.toString();
+        }
+    }
+}

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

@@ -0,0 +1,181 @@
+package net.i2p.i2ptunnel;
+
+import java.util.List;
+import net.i2p.I2PAppContext;
+import net.i2p.util.Log;
+
+/**
+ * Ugly hack to let the web interface access the list of known tunnels and
+ * control their operation.  Any data submitted by setting properties are 
+ * acted upon by calling getActionResults() (which returns any messages
+ * generated).  In addition, the getSummaryList() generates the html for
+ * summarizing all of the tunnels known, including both their status and the
+ * links to edit, stop, or start them.
+ *
+ */
+public class WebStatusPageHelper {
+    private Log _log;
+    private String _action;
+    private int _controllerNum;
+    
+    public WebStatusPageHelper() {
+        _action = null;
+        _controllerNum = -1;
+        _log = I2PAppContext.getGlobalContext().logManager().getLog(WebStatusPageHelper.class);
+    }
+    
+    public void setAction(String action) {
+        _action = action;
+    }
+    public void setNum(String num) {
+        if (num != null) {
+            try {
+                _controllerNum = Integer.parseInt(num);
+            } catch (NumberFormatException nfe) {
+                _controllerNum = -1;
+            }
+        }
+    }
+    
+    public String getActionResults() {
+        try {
+            return processAction();
+        } catch (Throwable t) {
+            _log.log(Log.CRIT, "Internal error processing web status", t);
+            return "Internal error processing request - " + t.getMessage();
+        }
+    }
+    
+    public String getSummaryList() {
+        TunnelControllerGroup group = TunnelControllerGroup.getInstance();
+        if (group == null)
+            return "<b>I2PTunnel instances not yet started - please be patient</b>\n";
+            
+        StringBuffer buf = new StringBuffer(4*1024);
+        buf.append("<ul>");
+        List tunnels = group.getControllers();
+        for (int i = 0; i < tunnels.size(); i++) {
+            buf.append("<li>\n");
+            getSummary(buf, i, (TunnelController)tunnels.get(i));
+            buf.append("</li>\n");
+        }
+        buf.append("</ul>");
+        return buf.toString();
+    }
+    
+    private void getSummary(StringBuffer buf, int num, TunnelController controller) {
+        buf.append("<b>").append(controller.getName()).append("</b>: ");
+        if (controller.getIsRunning()) {
+            buf.append("<i>running</i> ");
+            buf.append("<a href=\"index.jsp?num=").append(num).append("&action=stop\">stop</a> ");
+        } else {
+            buf.append("<i>not running</i> ");
+            buf.append("<a href=\"index.jsp?num=").append(num).append("&action=start\">start</a> ");
+        }
+        buf.append("<a href=\"edit.jsp?num=").append(num).append("\">edit</a> ");
+        buf.append("<br />\n");
+        controller.getSummary(buf);
+    }
+    
+    private String processAction() {
+        if ( (_action == null) || (_action.trim().length() <= 0) )
+            return getMessages();
+        if ("Stop all".equals(_action)) 
+            return stopAll();
+        else if ("Start all".equals(_action))
+            return startAll();
+        else if ("Restart all".equals(_action))
+            return restartAll();
+        else if ("Reload config".equals(_action))
+            return reloadConfig();
+        else if ("stop".equals(_action))
+            return stop();
+        else if ("start".equals(_action))
+            return start();
+        else 
+            return "Action <i>" + _action + "</i> unknown";
+    }
+    private String stopAll() {
+        TunnelControllerGroup group = TunnelControllerGroup.getInstance();
+        if (group == null)
+            return "<b>I2PTunnel instances not yet started - please be patient</b>\n";
+        
+        List msgs = group.stopAllControllers();
+        return getMessages(msgs);
+    }
+    private String startAll() {
+        TunnelControllerGroup group = TunnelControllerGroup.getInstance();
+        if (group == null)
+            return "<b>I2PTunnel instances not yet started - please be patient</b>\n";
+        
+        List msgs = group.startAllControllers();
+        return getMessages(msgs);
+    }
+    private String restartAll() {
+        TunnelControllerGroup group = TunnelControllerGroup.getInstance();
+        if (group == null)
+            return "<b>I2PTunnel instances not yet started - please be patient</b>\n";
+        
+        List msgs = group.restartAllControllers();
+        return getMessages(msgs);
+    }
+    private String reloadConfig() {
+        TunnelControllerGroup group = TunnelControllerGroup.getInstance();
+        if (group == null)
+            return "<b>I2PTunnel instances not yet started - please be patient</b>\n";
+        
+        group.reloadControllers();
+        return "Config reloaded";
+    }
+    private String start() {
+        TunnelControllerGroup group = TunnelControllerGroup.getInstance();
+        if (group == null)
+            return "<b>I2PTunnel instances not yet started - please be patient</b>\n";
+        
+        if (_controllerNum < 0) return "Invalid tunnel";
+        
+        List controllers = group.getControllers();
+        if (_controllerNum >= controllers.size()) return "Invalid tunnel";
+        TunnelController controller = (TunnelController)controllers.get(_controllerNum);
+        controller.startTunnel();
+        return getMessages(controller.clearMessages());
+    }
+    
+    private String stop() {
+        TunnelControllerGroup group = TunnelControllerGroup.getInstance();
+        if (group == null)
+            return "<b>I2PTunnel instances not yet started - please be patient</b>\n";
+        
+        if (_controllerNum < 0) return "Invalid tunnel";
+        
+        List controllers = group.getControllers();
+        if (_controllerNum >= controllers.size()) return "Invalid tunnel";
+        TunnelController controller = (TunnelController)controllers.get(_controllerNum);
+        controller.stopTunnel();
+        return getMessages(controller.clearMessages());
+    }
+    
+    private String getMessages() {
+        TunnelControllerGroup group = TunnelControllerGroup.getInstance();
+        if (group == null)
+            return "";
+        
+        return getMessages(group.clearAllMessages());
+    }
+    
+    private String getMessages(List msgs) {
+        if (msgs == null) return "";
+        int num = msgs.size();
+        switch (num) {
+            case 0: return "";
+            case 1: return (String)msgs.get(0);
+            default:
+                StringBuffer buf = new StringBuffer(512);
+                buf.append("<ul>");
+                for (int i = 0; i < num; i++)
+                    buf.append("<li>").append((String)msgs.get(i)).append("</li>\n");
+                buf.append("</ul>\n");
+                return buf.toString();
+        }
+    }
+}

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

@@ -10,6 +10,7 @@ import java.net.Socket;
 
 import net.i2p.client.streaming.I2PSocket;
 import net.i2p.data.Destination;
+import net.i2p.i2ptunnel.I2PTunnel;
 import net.i2p.i2ptunnel.I2PTunnelClientBase;
 import net.i2p.i2ptunnel.I2PTunnelRunner;
 import net.i2p.i2ptunnel.Logging;
@@ -26,31 +27,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, I2PTunnel tunnel) {
+        super(localPort, ownDest, l, notifyThis, "SOCKSHandler", tunnel);
 
-	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);
     }
-}
+}

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

@@ -6,16 +6,17 @@
  */
 package net.i2p.i2ptunnel.socks;
 
+import java.io.IOException;
 import java.net.Socket;
+import java.net.SocketException;
 
+import net.i2p.I2PException;
 import net.i2p.client.streaming.I2PSocket;
 import net.i2p.client.streaming.I2PSocketManager;
 import net.i2p.client.streaming.I2PSocketManagerFactory;
 import net.i2p.client.streaming.I2PSocketOptions;
 import net.i2p.data.DataFormatException;
-import net.i2p.I2PException;
 import net.i2p.i2ptunnel.I2PTunnel;
-
 import net.i2p.util.Log;
 
 /**
@@ -48,7 +49,6 @@ public abstract class SOCKSServer {
      */
     public abstract Socket getClientSocket() throws SOCKSException;
 
-
     /**
      * Confirm to the client that the connection has succeeded
      */
@@ -61,40 +61,46 @@ public abstract class SOCKSServer {
      * @return an I2PSocket connected with the destination
      */
     public I2PSocket getDestinationI2PSocket() throws SOCKSException {
-	setupServer();
+        setupServer();
 
-	if (connHostName == null) {
-	    _log.error("BUG: destination host name has not been initialized!");
-	    throw new SOCKSException("BUG! See the logs!");
-	}
-	if (connPort == 0) {
-	    _log.error("BUG: destination port has not been initialized!");
-	    throw new SOCKSException("BUG! See the logs!");
-	}
+        if (connHostName == null) {
+            _log.error("BUG: destination host name has not been initialized!");
+            throw new SOCKSException("BUG! See the logs!");
+        }
+        if (connPort == 0) {
+            _log.error("BUG: destination port has not been initialized!");
+            throw new SOCKSException("BUG! See the logs!");
+        }
 
-	// FIXME: here we should read our config file, select an
-	// outproxy, and instantiate the proper socket class that
-	// handles the outproxy itself (SOCKS4a, SOCKS5, HTTP CONNECT...).
-	I2PSocket destSock;
+        // FIXME: here we should read our config file, select an
+        // outproxy, and instantiate the proper socket class that
+        // handles the outproxy itself (SOCKS4a, SOCKS5, HTTP CONNECT...).
+        I2PSocket destSock;
 
-	try {
-	    if (connHostName.toLowerCase().endsWith(".i2p")) {
-		_log.debug("connecting to " + connHostName + "...");
-		I2PSocketManager sm = I2PSocketManagerFactory.createManager();
-		destSock = sm.connect(I2PTunnel.destFromName(connHostName),
-				      new I2PSocketOptions());
-		confirmConnection();
-		_log.debug("connection confirmed - exchanging data...");
-	    } else {
-		_log.error("We don't support outproxies (yet)");
-		throw new SOCKSException("Ouproxies not supported (yet)");
-	    }
-	} catch (DataFormatException e) {
-	    throw new SOCKSException("Error in destination format");
-	} catch (I2PException e) {
-	    throw new SOCKSException("I2P error (" + e.getMessage() + ")");
-	}
-	
-	return destSock;
+        try {
+            if (connHostName.toLowerCase().endsWith(".i2p")) {
+                _log.debug("connecting to " + connHostName + "...");
+                I2PSocketManager sm = I2PSocketManagerFactory.createManager();
+                destSock = sm.connect(I2PTunnel.destFromName(connHostName), new I2PSocketOptions());
+                confirmConnection();
+                _log.debug("connection confirmed - exchanging data...");
+            } else {
+                _log.error("We don't support outproxies (yet)");
+                throw new SOCKSException("Ouproxies not supported (yet)");
+            }
+        } catch (DataFormatException e) {
+            throw new SOCKSException("Error in destination format");
+        } catch (SocketException e) {
+            throw new SOCKSException("Error connecting ("
+                                     + e.getMessage() + ")");
+        } catch (IOException e) {
+            throw new SOCKSException("Error connecting ("
+                                     + e.getMessage() + ")");
+        } catch (I2PException e) {
+            throw new SOCKSException("Error connecting ("
+                                     + e.getMessage() + ")");
+        }
+
+        return destSock;
     }
 }

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

@@ -27,27 +27,26 @@ public class SOCKSServerFactory {
      * @param s a Socket used to choose the SOCKS server type
      */
     public static SOCKSServer createSOCKSServer(Socket s) throws SOCKSException {
-	SOCKSServer serv;
+        SOCKSServer serv;
 
-	try {
-	    DataInputStream in = new DataInputStream(s.getInputStream());
-	    int socksVer = in.readByte();
-	    
-	    switch (socksVer) {
-	    case 0x05: // SOCKS version 5
-		serv = new SOCKS5Server(s);
-		break;
-	    default:
-		_log.debug("SOCKS protocol version not supported ("
-			   + Integer.toHexString(socksVer) + ")");
-		return null;
-	    }
-	} catch (IOException e) {
-	    _log.debug("error reading SOCKS protocol version");
-	    throw new SOCKSException("Connection error ("
-				     + e.getMessage() + ")");
-	}
+        try {
+            DataInputStream in = new DataInputStream(s.getInputStream());
+            int socksVer = in.readByte();
 
-	return serv;
+            switch (socksVer) {
+            case 0x05:
+                // SOCKS version 5
+                serv = new SOCKS5Server(s);
+                break;
+            default:
+                _log.debug("SOCKS protocol version not supported (" + Integer.toHexString(socksVer) + ")");
+                return null;
+            }
+        } catch (IOException e) {
+            _log.debug("error reading SOCKS protocol version");
+            throw new SOCKSException("Connection error (" + e.getMessage() + ")");
+        }
+
+        return serv;
     }
-}
+}

apps/i2ptunnel/jsp/edit.jsp

@@ -0,0 +1,16 @@
+<%@page contentType="text/html" %>
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+
+<html><head>
+<title>I2PTunnel edit</title>
+</head><body>
+
+<a href="index.jsp">Back</a>
+
+<jsp:useBean class="net.i2p.i2ptunnel.WebEditPageHelper" id="helper" scope="request" />
+<jsp:setProperty name="helper" property="*" />
+<b><jsp:getProperty name="helper" property="actionResults" /></b>
+
+<jsp:getProperty name="helper" property="editForm" />
+</body>
+</html>

apps/i2ptunnel/jsp/index.html

@@ -0,0 +1,2 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"><html><head><title>I2P Router Console</title></head>
+<body><meta http-equiv="refresh" content="0;url=index.jsp" /><a href="index.jsp">Enter</a></body></html>

apps/i2ptunnel/jsp/index.jsp

@@ -0,0 +1,32 @@
+<%@page contentType="text/html" %>
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+
+<html><head>
+<title>I2PTunnel status</title>
+</head><body>
+
+<jsp:useBean class="net.i2p.i2ptunnel.WebStatusPageHelper" id="helper" scope="request" />
+<jsp:setProperty name="helper" property="*" />
+<h2>Messages since last page load:</h2>
+<b><jsp:getProperty name="helper" property="actionResults" /></b>
+ 
+<jsp:getProperty name="helper" property="summaryList" />
+<hr />
+<form action="index.jsp" method="GET">
+ <input type="submit" name="action" value="Stop all" />
+ <input type="submit" name="action" value="Start all" />
+ <input type="submit" name="action" value="Restart all" />
+ <input type="submit" name="action" value="Reload config" />
+</form>
+
+<form action="edit.jsp">
+<b>Add new:</b> 
+ <select name="type">
+  <option value="httpclient">HTTP proxy</option>
+  <option value="client">Client tunnel</option>
+  <option value="server">Server tunnel</option>
+ </select> <input type="submit" value="GO" />
+</form>
+
+</body>
+</html>

apps/i2ptunnel/jsp/web.xml

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE web-app
+    PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.2//EN"
+    "http://java.sun.com/j2ee/dtds/web-app_2.2.dtd">
+
+<web-app>
+    <!-- precompiled servlets -->
+    <session-config>
+        <session-timeout>
+            30
+        </session-timeout>
+    </session-config>
+    <welcome-file-list>
+        <welcome-file>index.html</welcome-file>
+        <welcome-file>index.jsp</welcome-file>
+    </welcome-file-list>
+</web-app>

apps/jetty/build.xml

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project basedir="." default="all" name="jetty">
+        
+    <target name="all" depends="build" />
+    <target name="fetchJettylib" >
+        <available property="jetty.available" file="jettylib" />
+        <ant target="doFetchJettylib" />
+    </target>
+    <target name="doFetchJettylib" unless="jetty.available" >
+        <echo message="The libraries contained within the fetched file are from Jetty's 4.2.21 " />
+        <echo message="distribution (http://jetty.mortbay.org/) which we have copied to our website since" />
+        <echo message="theirs doesn't have direct HTTP access to the libs.  These are not " />
+        <echo message="necessary for using I2P, but are used by some applications on top of I2P," />
+        <echo message="such as the routerconsole." />
+        <get src="http://dev.i2p.net/jettylib.tar.bz2" verbose="true" dest="jettylib.tar.bz2" />
+        <untar src="jettylib.tar.bz2" compression="bzip2" dest="." />
+        <delete file="jettylib.tar.bz2" />
+    </target>
+    <target name="build" depends="fetchJettylib" />
+    <target name="builddep" />
+    <target name="compile" />
+    <target name="jar" />
+    <target name="clean" />
+    <target name="cleandep" depends="clean" />
+    <target name="distclean" depends="clean">
+        <echo message="Not actually deleting the jetty libs (since they're so large)" />
+    </target>
+</project>

apps/jfreechart/GUI-licenses.txt

@@ -0,0 +1,590 @@
+The code for the GUI applications netviewer and the 
+heartbeat GUI have been released into the public domain, 
+but they make use of the LGPL JFreeChart library (which
+in turn depends upon the APL log4j library).  These 
+external components, contained within the files:
+ lib/jfreechart-0.9.17.jar
+ lib/jcommon-0.9.2.jar
+ lib/log4j-1.2.8.jar
+were retrieved and built from the source at
+http://www.jfree.org/jfreechart/jfreechart-0.9.17.zip
+
+As a whole, the netviewer and heartbeat GUI applications 
+therefore must state:
+   This product includes software developed by the 
+   Apache Software Foundation (http://www.apache.org/).
+
+The LGPL just makes us state prominently that we use LGPL'ed
+code (the JFreeChart code), and since we make no modifications 
+to it, section 6.b of the LGPL seems to apply.
+
+The relevent licenses are shown below.
+
+*****************************************************************
+For the jfreechart-0.9.17.jar and jcommon-0.9.2.jar, the 
+LGPL is relevent:
+*****************************************************************
+		  GNU LESSER GENERAL PUBLIC LICENSE
+		       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+     59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+  When we speak of free software, we are referring to freedom of use,
+not price.  Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard.  To achieve this, non-free programs must be
+allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+		  GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+  
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+			    NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+           How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!
+
+
+*****************************************************************
+For the file log4j-1.2.8.jar, the APL is relevent:
+*****************************************************************
+/* ====================================================================
+ *
+ * The Apache Software License, Version 1.1
+ *
+ * Copyright (c) 2003 The Apache Software Foundation.  All rights
+ * reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * 3. The end-user documentation included with the redistribution, if
+ *    any, must include the following acknowlegement:
+ *       "This product includes software developed by the
+ *        Apache Software Foundation (http://www.apache.org/)."
+ *    Alternately, this acknowlegement may appear in the software itself,
+ *    if and wherever such third-party acknowlegements normally appear.
+ *
+ * 4. The names "The Apache Logging Services Project", "log4j", and "Apache Software
+ *    Foundation" must not be used to endorse or promote products derived
+ *    from this software without prior written permission. For written
+ *    permission, please contact apache@apache.org.
+ *
+ * 5. Products derived from this software may not be called "Apache"
+ *    nor may "Apache" appear in their names without prior written
+ *    permission of the Apache Group.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (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.
+ * ====================================================================
+ *
+ * This software consists of voluntary contributions made by many
+ * individuals on behalf of the Apache Software Foundation.  For more
+ * information on the Apache Software Foundation, please see
+ * <http://www.apache.org/>.
+ *
+ * [Additional notices, if required by prior licensing conditions]
+ *
+ */

apps/jfreechart/build.xml

@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project basedir="." default="all" name="jfreechart">
+    <target name="all">
+        <echo message="The code in the JFreeChart software contains LGPL and APL licensed software," />
+        <echo message="and is not necessary for using I2P.  However, there is a seperate GUI for the " />
+        <echo message="heartbeat and netmonitor applications that uses this, so the retrieval of that " />
+        <echo message="code from the JFreeChart distribution is being made available (though we make no" />
+        <echo message="modifications to the code used here whatsoever - it is simply used by the public domain GUIs.  " />
+        <echo message="If you would like to fetch the code, run the ant task 'fetchJfreechart'" />
+        <echo message="If you would like to build the code, run the ant task 'build'" />
+        <echo message="If you would like to delete the code, run the ant task 'clean'" />
+    </target>
+    <target name="build">
+        <ant dir="./jfreechart-0.9.17/" antfile="ant/build.xml" target="compile" />
+    </target>
+    <target name="fetchJfreechart">
+        <mkdir dir="./lib" />
+        <get src="http://www.jfree.org/jfreechart/jfreechart-0.9.17.zip" verbose="true" dest="jfreechart-0.9.17.zip" />
+        <unzip src="jfreechart-0.9.17.zip" dest="." />
+    </target>
+    <target name="builddep" />
+    <target name="compile" />
+    <target name="jar" />
+    <target name="clean">
+        <delete dir="./jfreechart-0.9.17/" />
+    </target>
+    <target name="cleandep" depends="clean" />
+    <target name="distclean" depends="clean" />
+</project>

apps/ministreaming/doc/protocol.txt

@@ -1,5 +1,5 @@
-ministreaming protocol:
-*******************
+ministreaming protocol
+**********************
 
 Each message looks like the following
 
@@ -15,9 +15,11 @@ These IDs may be any 3-byte values except 00 00 00, which is reserved.
 
 All connections are created as PROP_RELIABILITY_GUARANTEED.
 
-"actions" are the things a proper tunnel implementation SHOULD do 
-when it receives such a message.
+"actions" are the things a proper ministreaming implementation SHOULD 
+do when it receives such a message.
 
+A "ministreaming connection" is a connection where the user of the
+library can send data into or receive from.
 
 Client->Server:
 ===============
@@ -25,13 +27,13 @@ Client->Server:
 0xA0 Send data
   id:      the server id
   payload: the data to send
-  actions: send the data to the TCP connection
+  actions: send the data to the ministreaming connection
 
 0xA1 SYN
   id:      the client id
   payload: the public key dynamically created by the client
-  actions: create a server ID and create a TCP connection. When successful,
-           send an ACK back, otherwise a close.
+  actions: create a server ID and create a ministreaming connection. When 
+           successful, send an ACK back, otherwise a close.
 
 0xA2 Close
   id:      the server id
@@ -44,7 +46,7 @@ Server->Client
 0x50 Send data
   id:      the client id
   payload: the data to send
-  actions: send the data to the TCP connection
+  actions: send the data to the ministreaming connection
 
 0x51 ACK
   id:      the client id
@@ -60,7 +62,7 @@ Server->Client
 Sample conversations:
 =====================
 
-a) Service not available (e.g. the server on the TCP port is not running)
+a) Service not available (e.g. the server is not accepting connections)
 
 C->S  A1 12 34 56 key... (SYN, client ID = 12 34 56)
 S->C  52 12 34 56  (Close)

apps/ministreaming/java/build.xml

@@ -8,7 +8,7 @@
     <target name="compile">
         <mkdir dir="./build" />
         <mkdir dir="./build/obj" />
-        <javac srcdir="./src" debug="true" destdir="./build/obj" classpath="../../../core/java/build/i2p.jar" />
+        <javac srcdir="./src" debug="true" deprecation="on" source="1.3" target="1.3" destdir="./build/obj" classpath="../../../core/java/build/i2p.jar" />
     </target>
     <target name="jar" depends="compile">
         <jar destfile="./build/mstreaming.jar" basedir="./build/obj" includes="**/*.class" />

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

@@ -1,159 +1,294 @@
 package net.i2p.client.streaming;
 
-/** Like a StringBuffer, but for bytes */
+/** 
+ * Like a StringBuffer, but for bytes.  This class is not internally synchronized,
+ * so care should be taken when using in a multithreaded environment.
+ *
+ */
 public class ByteCollector {
     byte[] contents;
     int size;
 
+    private static final int INITIAL_CAPACITY = 1024;
+    private static final int SHORT_CAPACITY = 80;
+    
+    /**
+     * New collector with the default initial capacity
+     *
+     */
     public ByteCollector() {
-	contents=new byte[80];
-	size=0;
+        this(INITIAL_CAPACITY);
+    }
+    
+    /**
+     * New collector with an initial capacity as specified
+     *
+     */
+    public ByteCollector(int capacity) {
+        contents = new byte[capacity];
+        size = 0;
     }
 
+    
+    /**
+     * New collector containing the specified bytes
+     *
+     */
     public ByteCollector(byte[] b) {
-	this();
-	append(b);
+        this();
+        append(b);
     }
 
+    /**
+     * New collector with the specified byte
+     *
+     */
     public ByteCollector(byte b) {
-	this();
-	append(b);
+        this();
+        append(b);
     }
 
-    public ByteCollector append (byte b) {
-	ensureCapacity(size+1);
-	contents[size++]=b;
-	return this;
+    /**
+     * Add a new byte to the collector (extending the buffer if necessary) 
+     *
+     * @param b byte to add
+     * @return this object
+     */
+    public ByteCollector append(byte b) {
+        ensureCapacity(size + 1);
+        contents[size++] = b;
+        return this;
     }
 
-    public ByteCollector append (byte[] b) {
-	ensureCapacity(size+b.length);
-	System.arraycopy(b,0,contents,size,b.length);
-	size+=b.length;
-	return this;
+    /**
+     * Add new bytes to the collector (extending the buffer if necessary) 
+     *
+     * @param b bytes to add
+     * @return this object
+     */
+    public ByteCollector append(byte[] b) {
+        ensureCapacity(size + b.length);
+        System.arraycopy(b, 0, contents, size, b.length);
+        size += b.length;
+        return this;
     }
 
+    /**
+     * Add new bytes to the collector (extending the buffer if necessary) 
+     *
+     * @param b byte array to add from
+     * @param len number of bytes in the array to add
+     * @return this object
+     */
     public ByteCollector append(byte[] b, int len) {
-	return append(b,0,len);
+        return append(b, 0, len);
     }
 
+    /**
+     * Add new bytes to the collector (extending the buffer if necessary) 
+     *
+     * @param b byte array to add from
+     * @param off offset into the array to begin adding from
+     * @param len number of bytes in the array to add
+     * @return this object
+     */
     public ByteCollector append(byte[] b, int off, int len) {
-	ensureCapacity(size+len);
-	System.arraycopy(b,off,contents,size,len);
-	size+=len;
-	return this;
+        ensureCapacity(size + len);
+        System.arraycopy(b, off, contents, size, len);
+        size += len;
+        return this;
     }
-    
+
+    /**
+     * Add the contents of the byte collector to the current collector (extending the buffer if necessary) 
+     *
+     * @param bc collector to copy 
+     * @return this object
+     */
     public ByteCollector append(ByteCollector bc) {
-	// optimieren?
-	return append(bc.toByteArray());
+        // optimieren?
+        return append(bc.toByteArray());
     }
 
+    /**
+     * Copy the contents of the collector into a new array and return it
+     *
+     * @return new array containing a copy of the current collector's data
+     */
     public byte[] toByteArray() {
-	byte[] result=new byte[size];
-	System.arraycopy(contents,0,result,0,size);
-	return result;
+        byte[] result = new byte[size];
+        System.arraycopy(contents, 0, result, 0, size);
+        return result;
     }
 
+    /**
+     * Pull off the first $maxlen bytes from the collector, shifting the remaining
+     * bytes into the beginning of the collector's array.
+     *
+     * @param maxlen max number of bytes we want to pull from the collector (we will get
+     *               less if the collector doesnt have that many bytes yet)
+     * @return copy of the bytes pulled from the collector
+     */
     public byte[] startToByteArray(int maxlen) {
-	if (size < maxlen) {
-	    byte[] res = toByteArray();
-	    clear();
-	    return res;
-	} else {
-	    byte[] result = new byte[maxlen];
-	    System.arraycopy(contents,0,result,0,maxlen);
-	    System.arraycopy(contents,maxlen,contents,0,size-maxlen);
-	    size-=maxlen;
-	    return result;
-	}
-    }
-    
-    public int getCurrentSize() { 
-	return size;
+        if (size < maxlen) {
+            byte[] res = toByteArray();
+            clear();
+            return res;
+        } else {
+            byte[] result = new byte[maxlen];
+            System.arraycopy(contents, 0, result, 0, maxlen);
+            System.arraycopy(contents, maxlen, contents, 0, size - maxlen);
+            size -= maxlen;
+            return result;
+        }
     }
 
+    /**
+     * How many bytes are available for retrieval?
+     *
+     * @return number of bytes
+     */
+    public int getCurrentSize() {
+        return size;
+    }
+
+    /**
+     * Make sure we have sufficient storage space.
+     *
+     * @param cap minimum number of bytes that the buffer should contain
+     * @return true if the the collector was expanded to meet the minimum, 
+     *         false if it was already large enough
+     */
     public boolean ensureCapacity(int cap) {
-	if (contents.length<cap) {
-	    int l=contents.length;
-	    while (l<cap) {
-		l=(l*3)/2+1;
-	    }
-	    byte[] newcont=new byte[l];
-	    System.arraycopy(contents,0,newcont,0,size);
-	    contents=newcont;
-	    return true;
-	}
-	return false;
+        if (contents.length < cap) {
+            int l = contents.length;
+            while (l < cap) {
+                l = (l * 3) / 2 + 1;
+            }
+            byte[] newcont = new byte[l];
+            System.arraycopy(contents, 0, newcont, 0, size);
+            contents = newcont;
+            return true;
+        }
+        return false;
     }
 
+    /**
+     * Does the collector have meaningful data or is it empty?
+     *
+     * @return true if it has no data
+     */
     public boolean isEmpty() {
-	return size==0;
+        return size == 0;
     }
 
+    /**
+     * Search through the collector for the first occurrence of the sequence of 
+     * bytes contained within the specified collector
+     *
+     * @param bc bytes that will be searched for
+     * @return index into the current collector, or -1 if it isn't found
+     */
     public int indexOf(ByteCollector bc) {
-	// optimieren?
-	return indexOf(bc.toByteArray());
+        // optimieren?
+        return indexOf(bc.toByteArray());
     }
-    
+
+    /**
+     * Search through the collector for the first occurrence of the specified 
+     * byte
+     *
+     * @param b byte that will be searched for
+     * @return index into the current collector, or -1 if it isn't found
+     */
     public int indexOf(byte b) {
-	// optimieren?
-	return indexOf(new byte[] {b});
+        // optimieren?
+        return indexOf(new byte[] { b});
     }
-    
+
+    /**
+     * Search through the collector for the first occurrence of the sequence of 
+     * bytes
+     *
+     * @param ba bytes that will be searched for
+     * @return index into the current collector, or -1 if it isn't found
+     */
     public int indexOf(byte[] ba) {
-	loop:
-	for (int i=0;i<size-ba.length+1;i++) {
-	    for (int j=0;j<ba.length;j++) {
-		if (contents[i+j]!=ba[j]) continue loop;
-	    }
-	    return i;
-	}
-	return -1;
+        loop: for (int i = 0; i < size - ba.length + 1; i++) {
+            for (int j = 0; j < ba.length; j++) {
+                if (contents[i + j] != ba[j]) continue loop;
+            }
+            return i;
+        }
+        return -1;
     }
-    
+
+    /**
+     * Empty the collector.  This does not affect its capacity.
+     *
+     */
     public void clear() {
-	size=0;
+        size = 0;
     }
 
+    /**
+     * Empty the collector and reduce its capacity.
+     *
+     */
     public void clearAndShorten() {
-	size=0;
-	contents=new byte[80];
+        size = 0;
+        contents = new byte[SHORT_CAPACITY];
     }
 
+    /**
+     * Render the bytes as a string
+     *
+     * @return the, uh, string
+     */
     public String toString() {
-	return new String(toByteArray());
+        return new String(toByteArray());
     }
 
     public int hashCode() {
-	int h =0;
-	for (int i=0;i<size;i++) {
-	    h+=contents[i]*contents[i];
-	}
-	return h;
+        int h = 0;
+        for (int i = 0; i < size; i++) {
+            h += contents[i] * contents[i];
+        }
+        return h;
     }
 
+    /**
+     * Compare the collectors.  
+     * 
+     * @return true if and only if both are the same size and the 
+     *         byte arrays they contain are equal.
+     */
     public boolean equals(Object o) {
-	if (o instanceof ByteCollector) {
-	    ByteCollector by=(ByteCollector)o;
-	    if (size!=by.size) return false;
-	    for (int i=0;i<size;i++) {
-		if (contents[i]!=by.contents[i]) return false;
-	    }
-	    return true;
-	} else {
-	    return false;
-	}
+        if (o instanceof ByteCollector) {
+            ByteCollector by = (ByteCollector) o;
+            if (size != by.size) return false;
+            for (int i = 0; i < size; i++) {
+                if (contents[i] != by.contents[i]) return false;
+            }
+            return true;
+        } else {
+            return false;
+        }
     }
 
-    public byte removeFirst() {
-	byte bb=contents[0];
-	if (size==0)
-	    throw new IllegalArgumentException("ByteCollector is empty");
-	if(size>1)
-	    System.arraycopy(contents,1,contents,0,--size);
-	else
-	    size=0;
-	return bb;
+    /**
+     * Remove the first byte from the collector, shifting its contents accordingly.
+     *
+     * @return byte removed
+     * @throws IllegalArgumentException if the collector is empty
+     */
+    public byte removeFirst() throws IllegalArgumentException {
+        byte bb = contents[0];
+        if (size == 0) throw new IllegalArgumentException("ByteCollector is empty");
+        if (size > 1)
+            System.arraycopy(contents, 1, contents, 0, --size);
+        else
+            size = 0;
+        return bb;
     }
-}
+}

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

@@ -1,5 +1,7 @@
 package net.i2p.client.streaming;
 
+import java.net.ConnectException;
+
 import net.i2p.I2PException;
 
 /**
@@ -11,16 +13,19 @@ public interface I2PServerSocket {
      * Closes the socket.
      */
     public void close() throws I2PException;
-    
+
     /**
      * Waits for the next socket connecting.  If a remote user tried to make a 
      * connection and the local application wasn't .accept()ing new connections,
      * they should get refused (if .accept() doesnt occur in some small period)
      *
+     * @return a connected I2PSocket
+     *
      * @throws I2PException if there is a problem with reading a new socket
      *         from the data available (aka the I2PSession closed, etc)
+     * @throws ConnectException if the I2PServerSocket is closed
      */
-    public I2PSocket accept() throws I2PException;
+    public I2PSocket accept() throws I2PException, ConnectException;
 
     /**
      * Access the manager which is coordinating the server socket

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

@@ -1,50 +1,150 @@
 package net.i2p.client.streaming;
 
+import java.net.ConnectException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import net.i2p.I2PAppContext;
 import net.i2p.I2PException;
+import net.i2p.util.Clock;
 import net.i2p.util.Log;
 
 /**
- * Initial stub implementation for the server socket
+ * Server socket implementation, allowing multiple threads to accept I2PSockets 
+ * and pull from a queue populated by various threads (each of whom have their own
+ * timeout)
  *
  */
 class I2PServerSocketImpl implements I2PServerSocket {
     private final static Log _log = new Log(I2PServerSocketImpl.class);
     private I2PSocketManager mgr;
-    private I2PSocket cached=null; // buffer one socket here
+    /** list of sockets waiting for the client to accept them */
+    private List pendingSockets = Collections.synchronizedList(new ArrayList(4));
+    
+    /** have we been closed */
+    private volatile boolean closing = false;
+    
+    /** lock on this when accepting a pending socket, and wait on it for notification of acceptance */
+    private Object socketAcceptedLock = new Object();
+    /** lock on this when adding a new socket to the pending list, and wait on it accordingly */
+    private Object socketAddedLock = new Object();
     
     public I2PServerSocketImpl(I2PSocketManager mgr) {
-	this.mgr = mgr;
+        this.mgr = mgr;
     }
     
-    public synchronized I2PSocket accept() throws I2PException {
-	while(cached == null) {
-	    myWait();
-	}
-	I2PSocket ret=cached;
-	cached=null;
-	notifyAll();
-	_log.debug("TIMING: handed out accept result "+ret.hashCode());
-	return ret;
+    /**
+     * Waits for the next socket connecting.  If a remote user tried to make a 
+     * connection and the local application wasn't .accept()ing new connections,
+     * they should get refused (if .accept() doesnt occur in some small period -
+     * currently 5 seconds)
+     *
+     * @return a connected I2PSocket
+     *
+     * @throws I2PException if there is a problem with reading a new socket
+     *         from the data available (aka the I2PSession closed, etc)
+     * @throws ConnectException if the I2PServerSocket is closed
+     */
+    public I2PSocket accept() throws I2PException, ConnectException {
+        if (_log.shouldLog(Log.DEBUG))
+            _log.debug("accept() called, pending: " + pendingSockets.size());
+        
+        I2PSocket ret = null;
+        
+        while ( (ret == null) && (!closing) ){
+            while (pendingSockets.size() <= 0) {
+                if (closing) throw new ConnectException("I2PServerSocket closed");
+                try {
+                    synchronized(socketAddedLock) {
+                        socketAddedLock.wait();
+                    }
+                } catch (InterruptedException ie) {}
+            }
+            synchronized (pendingSockets) {
+                if (pendingSockets.size() > 0) {
+                    ret = (I2PSocket)pendingSockets.remove(0);
+                }
+            } 
+            if (ret != null) {
+                synchronized (socketAcceptedLock) {
+                    socketAcceptedLock.notifyAll();
+                }
+            }
+        }
+        
+        if (_log.shouldLog(Log.DEBUG))
+            _log.debug("TIMING: handed out accept result " + ret.hashCode());
+        return ret;
     }
     
-    public synchronized boolean getNewSocket(I2PSocket s){
-	while(cached != null) {
-	    myWait();
-	}
-	cached=s;
-	notifyAll();
-	return true;
+    /**
+     * Make the socket available and wait until the client app accepts it, or until
+     * the given timeout elapses.  This doesn't have any limits on the queue size -
+     * perhaps it should add some choking (e.g. after 5 waiting for accept, refuse)
+     *
+     * @param timeoutMs how long to wait until accept
+     * @return true if the socket was accepted, false if the timeout expired 
+     *         or the socket was closed
+     */
+    public boolean addWaitForAccept(I2PSocket s, long timeoutMs) {
+        if (_log.shouldLog(Log.DEBUG))
+            _log.debug("addWaitForAccept [new socket arrived [" + s.toString() + "], pending: " + pendingSockets.size());
+        
+        if (closing) {
+            if (_log.shouldLog(Log.WARN))
+                _log.warn("Already closing the socket");
+            return false;
+        }
+        
+        Clock clock = I2PAppContext.getGlobalContext().clock();
+        long start = clock.now();
+        long end = start + timeoutMs;
+        pendingSockets.add(s);
+        synchronized (socketAddedLock) {
+            socketAddedLock.notifyAll();
+        }
+        
+        // keep looping until the socket has been grabbed by the accept()
+        // (or the expiration passes, or the socket is closed)
+        while (pendingSockets.contains(s)) {
+            long now = clock.now();
+            if (now >= end) {
+                if (_log.shouldLog(Log.INFO))
+                    _log.info("Expired while waiting for accept (time elapsed =" + (now - start) + "ms) for socket " + s.toString());
+                pendingSockets.remove(s);
+                return false;
+            }
+            if (closing) {
+                if (_log.shouldLog(Log.WARN))
+                    _log.warn("Server socket closed while waiting for accept");
+                pendingSockets.remove(s);
+                return false;
+            }
+            long remaining = end - now;
+            try {
+                synchronized (socketAcceptedLock) {
+                    socketAcceptedLock.wait(remaining);
+                }
+            } catch (InterruptedException ie) {}
+        }
+        long now = clock.now();
+        if (_log.shouldLog(Log.DEBUG))
+            _log.info("Socket accepted after " + (now-start) + "ms for socket " + s.toString());
+        return true;
     }
     
-    public void close() throws I2PException {
-	//noop
+    public void close() {
+        closing = true;
+        // let anyone .accept()ing know to fsck off
+        synchronized (socketAddedLock) {
+            socketAddedLock.notifyAll();
+        }
+        // let anyone addWaitForAccept()ing know to fsck off
+        synchronized (socketAcceptedLock) {
+            socketAcceptedLock.notifyAll();
+        }
     }
     
-    private void myWait() {
-	try{
-	    wait();
-	} catch (InterruptedException ex) {}
-    }
-
     public I2PSocketManager getManager() { return mgr; }
 }

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

@@ -1,10 +1,10 @@
 package net.i2p.client.streaming;
 
-import net.i2p.data.Destination;
-
+import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
-import java.io.IOException;
+
+import net.i2p.data.Destination;
 
 /**
  * Minimalistic adapter between the socket api and I2PTunnel's way.
@@ -32,8 +32,50 @@ public interface I2PSocket {
      */
     public OutputStream getOutputStream() throws IOException;
 
+    /** 
+     * Retrieve this socket's configuration
+     */
+    public I2PSocketOptions getOptions();
+    /** 
+     * Configure the socket
+     */
+    public void setOptions(I2PSocketOptions options);
+    
+    /**
+     * How long we will wait blocked on a read() operation.  This is simply a
+     * helper to query the I2PSocketOptions
+     *
+     * @return milliseconds to wait, or -1 if we will wait indefinitely
+     */
+    public long getReadTimeout();
+
+    /**
+     * Define how long we will wait blocked on a read() operation (-1 will make
+     * the socket wait forever).  This is simply a helper to adjust the 
+     * I2PSocketOptions
+     *
+     */
+    public void setReadTimeout(long ms);
+
     /**
      * Closes the socket if not closed yet
      */
     public void close() throws IOException;
+    
+    public void setSocketErrorListener(SocketErrorListener lsnr);
+    /**
+     * Allow notification of underlying errors communicating across I2P without
+     * waiting for any sort of cleanup process.  For example, if some data could
+     * not be sent, this listener is notified immediately, and while the input/output
+     * streams are notified through IOExceptions, they are told only after the 
+     * TCP-like stream is closed (which may be a minute later, if the close message
+     * times out as well).  This is not fired on normal close() activity.
+     *
+     */
+    public interface SocketErrorListener {
+        /**
+         * An error occurred communicating with the peer.
+         */
+        void errorOccurred();
+    }
 }

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

@@ -5,11 +5,15 @@ import java.io.InputStream;
 import java.io.InterruptedIOException;
 import java.io.OutputStream;
 
+import net.i2p.I2PAppContext;
 import net.i2p.I2PException;
 import net.i2p.client.I2PSessionException;
 import net.i2p.data.Destination;
+import net.i2p.util.Clock;
+import net.i2p.util.I2PThread;
 import net.i2p.util.Log;
 
+
 /**
  * Initial stub implementation for the socket
  *
@@ -17,10 +21,10 @@ import net.i2p.util.Log;
 class I2PSocketImpl implements I2PSocket {
     private final static Log _log = new Log(I2PSocketImpl.class);
 
-    public static final int MAX_PACKET_SIZE = 1024*32;
-    public static final int PACKET_DELAY=100;
-    
-    private I2PSocketManager manager;
+    public static final int MAX_PACKET_SIZE = 1024 * 32;
+    public static final int PACKET_DELAY = 100;
+
+    private I2PSocketManagerImpl manager;
     private Destination local;
     private Destination remote;
     private String localID;
@@ -28,308 +32,628 @@ class I2PSocketImpl implements I2PSocket {
     private Object remoteIDWaiter = new Object();
     private I2PInputStream in;
     private I2POutputStream out;
+    private SocketErrorListener _socketErrorListener;
     private boolean outgoing;
+    private long _socketId;
+    private static long __socketId = 0;
+    private long _bytesRead = 0;
+    private long _bytesWritten = 0;
+    private long _createdOn;
+    private long _closedOn;
+    private long _remoteIdSetTime;
+    private I2PSocketOptions _options;
     private Object flagLock = new Object();
-    private boolean closed = false, sendClose=true, closed2=false;
-    
-    public I2PSocketImpl(Destination peer, I2PSocketManager mgr,
-			 boolean outgoing, String localID) {
-	this.outgoing=outgoing;
-	manager = mgr;
-	remote = peer;
-	local = mgr.getSession().getMyDestination();
-	in = new I2PInputStream();
-	I2PInputStream pin = new I2PInputStream();
-	out = new I2POutputStream(pin);
-	new I2PSocketRunner(pin);
-	this.localID = localID;
+
+    /**
+     * Whether the I2P socket has already been closed.
+     */
+    private boolean closed = false;
+
+    /**
+     * Whether to send out a close packet when the socket is
+     * closed. (If the socket is closed because of an incoming close
+     * packet, we need not send one.)
+     */
+    private boolean sendClose = true;
+
+    /**
+     * Whether the I2P socket has already been closed and all data
+     * (from I2P to the app, dunno whether to call this incoming or
+     * outgoing) has been processed.
+     */
+    private boolean closed2 = false;
+
+    /**
+     * @param peer who this socket is (or should be) connected to 
+     * @param mgr how we talk to the network
+     * @param outgoing did we initiate the connection (true) or did we receive it (false)?
+     * @param localID what is our half of the socket ID?
+     */
+    public I2PSocketImpl(Destination peer, I2PSocketManagerImpl mgr, boolean outgoing, String localID) {
+        this.outgoing = outgoing;
+        manager = mgr;
+        remote = peer;
+        _socketId = ++__socketId;
+        local = mgr.getSession().getMyDestination();
+        String us = mgr.getSession().getMyDestination().calculateHash().toBase64().substring(0,4);
+        String name = us + (outgoing ? "->" : "<-") + peer.calculateHash().toBase64().substring(0,4);
+        in = new I2PInputStream(name + " in");
+        I2PInputStream pin = new I2PInputStream(name + " out");
+        out = new I2POutputStream(pin);
+        new I2PSocketRunner(pin);
+        this.localID = localID;
+        _createdOn = I2PAppContext.getGlobalContext().clock().now();
+        _remoteIdSetTime = -1;
+        _closedOn = -1;
+        _options = mgr.getDefaultOptions();
     }
-    
+
+    /**
+     * Our half of the socket's unique ID
+     *
+     */
     public String getLocalID() {
-	return localID;
+        return localID;
     }
 
+    /**
+     * We've received the other side's half of the socket's unique ID 
+     */
     public void setRemoteID(String id) {
-	synchronized(remoteIDWaiter) {
-	    remoteID=id;
-	    remoteIDWaiter.notifyAll();
-	}
+        synchronized (remoteIDWaiter) {
+            remoteID = id;
+            _remoteIdSetTime = System.currentTimeMillis();
+            remoteIDWaiter.notifyAll();
+        }
     }
 
-    public String getRemoteID(boolean wait) throws InterruptedIOException {
-	return getRemoteID(wait, -1);
+    /**
+     * Retrieve the other side's half of the socket's unique ID, or null if it
+     * isn't known yet
+     *
+     * @param wait if true, we should wait until we receive it from the peer, otherwise
+     *             return what we know immediately (which may be null)
+     */
+    public String getRemoteID(boolean wait) {
+        try {
+            return getRemoteID(wait, -1);
+        } catch (InterruptedIOException iie) {
+            _log.error("wtf, we said we didn't want it to time out!  you smell", iie);
+            return null;
+        }
     }
+
+    /**
+     * Retrieve the other side's half of the socket's unique ID, or null if it isn't
+     * known yet and we were instructed not to wait
+     *
+     * @param wait should we wait for the peer to send us their half of the ID, or 
+     *             just return immediately?
+     * @param maxWait if we're going to wait, after how long should we timeout and fail?
+     *                (if this value is < 0, we wait indefinitely)
+     * @throws InterruptedIOException when the max waiting period has been exceeded
+     */
     public String getRemoteID(boolean wait, long maxWait) throws InterruptedIOException {
-	long dieAfter = System.currentTimeMillis() + maxWait;
-	synchronized(remoteIDWaiter) {
-	    while (wait && remoteID==null) {
-		try {
-		    if (maxWait > 0)
-			remoteIDWaiter.wait(maxWait);
-		    else
-			remoteIDWaiter.wait();
-		} catch (InterruptedException ex) {}
-		    
-		if ( (maxWait > 0) && (System.currentTimeMillis() > dieAfter) )
-		    throw new InterruptedIOException("Timed out waiting for remote ID");
-	    }
-	    if (wait) {
-		_log.debug("TIMING: RemoteID set to " + I2PSocketManager.getReadableForm(remoteID) +" for "+this.hashCode());
-	    }
-	    return remoteID;
-	}
+        long dieAfter = System.currentTimeMillis() + maxWait;
+        synchronized (remoteIDWaiter) {
+            if (wait) {
+                if (remoteID == null) {
+                    try {
+                        if (maxWait >= 0)
+                            remoteIDWaiter.wait(maxWait);
+                        else
+                            remoteIDWaiter.wait();
+                    } catch (InterruptedException ex) {
+                    }
+                }
+
+                long now = System.currentTimeMillis();
+                if ((maxWait >= 0) && (now >= dieAfter)) {
+                    long waitedExcess = now - dieAfter;
+                    throw new InterruptedIOException("Timed out waiting for remote ID (waited " + waitedExcess 
+                                                     + "ms too long [" + maxWait + "ms, remId " + remoteID
+                                                     + ", remId set " + (now-_remoteIdSetTime) + "ms ago])");
+                }
+             
+                if (_log.shouldLog(Log.DEBUG))
+                    _log.debug("TIMING: RemoteID set to " 
+                               + I2PSocketManagerImpl.getReadableForm(remoteID) + " for "
+                               + this.hashCode());
+            }
+            return remoteID;
+        }
     }
 
-    public String getRemoteID() throws InterruptedIOException {
-	return getRemoteID(false);
+    /**
+     * Retrieve the other side's half of the socket's unique ID, or null if it
+     * isn't known yet.  This does not wait
+     *
+     */
+    public String getRemoteID() {
+        return getRemoteID(false);
     }
 
+    /**
+     * The other side has given us some data, so inject it into our socket's 
+     * inputStream
+     *
+     * @param data the data to inject into our local inputStream
+     */
     public void queueData(byte[] data) {
-	in.queueData(data);
+        _bytesRead += data.length;
+        try {
+            in.queueData(data, false);
+        } catch (IOException ioe) {
+            _log.log(Log.CRIT, "wtf, we said DONT block, how can we timeout?", ioe);
+        }
     }
 
     /**
      * Return the Destination of this side of the socket.
      */
-    public Destination getThisDestination() { return local; }
+    public Destination getThisDestination() {
+        return local;
+    }
 
     /**
      * Return the destination of the peer.
      */
-    public Destination getPeerDestination() { return remote; }
+    public Destination getPeerDestination() {
+        return remote;
+    }
 
     /**
      * Return an InputStream to read from the socket.
      */
-    public InputStream getInputStream() throws IOException { 
-	if ( (in == null) )
-	    throw new IOException("Not connected");
-	return in;
+    public InputStream getInputStream() throws IOException {
+        if ((in == null)) throw new IOException("Not connected");
+        return in;
     }
 
     /**
      * Return an OutputStream to write into the socket.
      */
     public OutputStream getOutputStream() throws IOException {
-	if ( (out == null) ) 
-	    throw new IOException("Not connected");
-	return out;
+        if ((out == null)) throw new IOException("Not connected");
+        return out;
     }
 
     /**
-     * Closes the socket if not closed yet
+     * Closes the socket if not closed yet (from the Application
+     * side).
      */
     public void close() throws IOException {
-	synchronized(flagLock) {
-	    _log.debug("Closing connection");
-	    closed=true;
-	}
-	out.close();
-	in.notifyClosed();
+        synchronized (flagLock) {
+            if (_log.shouldLog(Log.DEBUG))
+                _log.debug("Closing connection");
+            closed = true;
+            _closedOn = I2PAppContext.getGlobalContext().clock().now();
+        }
+        out.close();
+        in.notifyClosed();
     }
 
-    public void internalClose() {
-	synchronized(flagLock) {
-	    closed=true;
-	    closed2=true;
-	    sendClose=false;
-	}
-	out.close();
-	in.notifyClosed();
+    /**
+     * Close the socket from the I2P side (by a close packet)
+     */
+    protected void internalClose() {
+        synchronized (flagLock) {
+            closed = true;
+            closed2 = true;
+            sendClose = false;
+            _closedOn = I2PAppContext.getGlobalContext().clock().now();
+        }
+        out.close();
+        in.notifyClosed();
     }
-	
 
     private byte getMask(int add) {
-	return (byte)((outgoing?(byte)0xA0:(byte)0x50)+(byte)add);
+        if (outgoing)
+            return (byte)(I2PSocketManagerImpl.DATA_IN + (byte)add);
+        else
+            return (byte)(I2PSocketManagerImpl.DATA_OUT + (byte)add);
+    }
+
+    public void setOptions(I2PSocketOptions options) {
+        _options = options;
+        in.setReadTimeout(options.getReadTimeout());
     }
     
+    public I2PSocketOptions getOptions() { 
+        return _options;
+    }
+    
+    /**
+     * How long we will wait blocked on a read() operation.  This is simply a
+     * helper to query the I2PSocketOptions
+     *
+     * @return milliseconds to wait, or -1 if we will wait indefinitely
+     */
+    public long getReadTimeout() {
+        return _options.getReadTimeout();
+    }
+
+    /**
+     * Define how long we will wait blocked on a read() operation (-1 will make
+     * the socket wait forever).  This is simply a helper to adjust the 
+     * I2PSocketOptions
+     *
+     */
+    public void setReadTimeout(long ms) {
+        _options.setReadTimeout(ms);
+        in.setReadTimeout(ms);
+    }
+    
+    public void setSocketErrorListener(SocketErrorListener lsnr) {
+        _socketErrorListener = lsnr;
+    }
+    
+    void errorOccurred() {
+        if (_socketErrorListener != null)
+            _socketErrorListener.errorOccurred();
+    }
+    
+    public long getBytesSent() { return _bytesWritten; }
+    public long getBytesReceived() { return _bytesRead; }
+    public long getCreatedOn() { return _createdOn; }
+    public long getClosedOn() { return _closedOn; }
+    
+    
+    private String getPrefix() { return "[" + _socketId + "]: "; }
+    
     //--------------------------------------------------
-    public class I2PInputStream extends InputStream {
+    private class I2PInputStream extends InputStream {
+        private String streamName;
+        private ByteCollector bc = new ByteCollector();
+        private boolean inStreamClosed = false;
 
-	private ByteCollector bc = new ByteCollector();
+        private long readTimeout = -1;
 
-	public int read() throws IOException {
-	    byte[] b = new byte[1];
-	    int res = read(b);
-	    if (res == 1) return b[0] & 0xff;
-	    if (res == -1) return -1;
-	    throw new RuntimeException("Incorrect read() result");
-	}
+        public I2PInputStream(String name) {
+            streamName = name;
+        }
+        
+        public long getReadTimeout() {
+            return readTimeout;
+        }
+        
+        private String getStreamPrefix() { 
+            return getPrefix() + streamName + ": ";
+        }
+        
+        public void setReadTimeout(long ms) {
+            readTimeout = ms;
+        }
+        
+        public int read() throws IOException {
+            byte[] b = new byte[1];
+            int res = read(b);
+            if (res == 1) return b[0] & 0xff;
+            if (res == -1) return -1;
+            throw new RuntimeException("Incorrect read() result");
+        }
 
-	public synchronized int read(byte[] b, int off, int len) throws IOException {
-	    _log.debug("Read called: "+this.hashCode());
-	    if (len==0) return 0;
-	    byte[] read = bc.startToByteArray(len);
-	    while (read.length==0) {
-		synchronized(flagLock) {
-		    if (closed){
-			_log.debug("Closed is set, so closing stream: "+this.hashCode());
-			return -1;
-		    }
-		}
-		try {
-		    wait();
-		} catch (InterruptedException ex) {}
-		read = bc.startToByteArray(len);
-	    }
-	    if (read.length>len) throw new RuntimeException("BUG");
-	    System.arraycopy(read,0,b,off,read.length);
+        public int read(byte[] b, int off, int len) throws IOException {
+            if (_log.shouldLog(Log.DEBUG))
+                _log.debug(getStreamPrefix() + "Read called for " + len + " bytes (avail=" 
+                           + bc.getCurrentSize() + "): " + this.hashCode());
+            if (len == 0) return 0;
+            long dieAfter = System.currentTimeMillis() + readTimeout;
+            byte[] read = null;
+            synchronized (bc) {
+                read = bc.startToByteArray(len);
+                bc.notifyAll();
+            }
+            boolean timedOut = false;
 
-	    if (_log.shouldLog(Log.DEBUG)) {
-		_log.debug("Read from I2PInputStream " + this.hashCode()
-			   + " returned "+read.length+" bytes");
-	    }
-	    //if (_log.shouldLog(Log.DEBUG)) {
-	    //  _log.debug("Read from I2PInputStream " + this.hashCode()
-	    //	   + " returned "+read.length+" bytes:\n"
-	    //	   + HexDump.dump(read));
-	    //}
-	    return read.length;
-	}
+            while ( (read.length == 0) && (!inStreamClosed) ) {
+                synchronized (flagLock) {
+                    if (closed) {
+                        if (_log.shouldLog(Log.DEBUG))
+                            _log.debug(getStreamPrefix() + "Closed is set after reading " 
+                                       + _bytesRead + " and writing " + _bytesWritten 
+                                       + ", so closing stream: " + hashCode());
+                        return -1;
+                    }
+                }
+                try {
+                    synchronized (I2PSocketImpl.I2PInputStream.this) {
+                        if (readTimeout >= 0) {
+                            wait(readTimeout);
+                        } else {
+                            wait();
+                        }
+                    }
+                } catch (InterruptedException ex) {}
 
-	public int available() {
-	    return bc.getCurrentSize();
-	}
+                if ((readTimeout >= 0)
+                    && (System.currentTimeMillis() >= dieAfter)) {
+                    throw new InterruptedIOException(getStreamPrefix() + "Timeout reading from I2PSocket (" 
+                                                     + readTimeout + " msecs)");
+                }
 
-	public void queueData(byte[] data) {
-	    queueData(data,0,data.length);
-	}
+                synchronized (bc) {
+                    read = bc.startToByteArray(len);
+                    bc.notifyAll();
+                }
+            }
+            if (read.length > len) throw new RuntimeException("BUG");
+            if ( (inStreamClosed) && ( (read == null) || (read.length <= 0) ) )
+                return -1;
+            
+            System.arraycopy(read, 0, b, off, read.length);
 
-	public synchronized void queueData(byte[] data, int off, int len) {
-	    _log.debug("Insert "+len+" bytes into queue: "+this.hashCode());
-	    bc.append(data, off, len);
-	    notifyAll();
-	}
+            if (_log.shouldLog(Log.DEBUG)) {
+                _log.debug(getStreamPrefix() + "Read from I2PInputStream " + hashCode() + " returned " 
+                           + read.length + " bytes");
+            }
+            //if (_log.shouldLog(Log.DEBUG)) {
+            //  _log.debug("Read from I2PInputStream " + this.hashCode()
+            //             + " returned "+read.length+" bytes:\n"
+            //             + HexDump.dump(read));
+            //}
+            return read.length;
+        }
+
+        public int available() {
+            synchronized (bc) {
+                return bc.getCurrentSize();
+            }
+        }
+
+        /**
+         * Add the data to the queue
+         *
+         * @param allowBlock if true, we will block if the buffer and the socket options
+         *                   say so, otherwise we simply take the data regardless.
+         * @throws InterruptedIOException if the queue's buffer is full, the socket has
+         *                                a write timeout, and that timeout is exceeded
+         * @throws IOException if the connection was closed while queueing up the data
+         */
+        void queueData(byte[] data, boolean allowBlock) throws InterruptedIOException, IOException {
+            queueData(data, 0, data.length, allowBlock);
+        }
+
+        /**
+         * Add the data to the queue
+         *
+         * @param allowBlock if true, we will block if the buffer and the socket options
+         *                   say so, otherwise we simply take the data regardless.
+         * @throws InterruptedIOException if the queue's buffer is full, the socket has
+         *                                a write timeout, and that timeout is exceeded
+         * @throws IOException if the connection was closed while queueing up the data
+         */
+        public void queueData(byte[] data, int off, int len, boolean allowBlock) throws InterruptedIOException, IOException {
+            if (_log.shouldLog(Log.DEBUG))
+                _log.debug(getStreamPrefix() + "Insert " + len + " bytes into queue: " + hashCode());
+            Clock clock = I2PAppContext.getGlobalContext().clock();
+            long endAfter = clock.now() + _options.getWriteTimeout();
+            synchronized (bc) {
+                if (allowBlock) {
+                    if (_options.getMaxBufferSize() > 0) {
+                        while (bc.getCurrentSize() > _options.getMaxBufferSize()) {
+                            if (_log.shouldLog(Log.DEBUG))
+                                _log.debug(getStreamPrefix() + "Buffer size exceeded: pending " 
+                                           + bc.getCurrentSize() + " limit " + _options.getMaxBufferSize());
+                            if (_options.getWriteTimeout() > 0) {
+                                long timeLeft = endAfter - clock.now();
+                                if (timeLeft <= 0) {
+                                    long waited = _options.getWriteTimeout() - timeLeft;
+                                    throw new InterruptedIOException(getStreamPrefix() + "Waited too long (" 
+                                                                     + waited + "ms) to write " 
+                                                                     + len + " with a buffer at " + bc.getCurrentSize());
+                                }
+                            }
+                            if (inStreamClosed)
+                                throw new IOException(getStreamPrefix() + "Stream closed while writing");
+                            if (_closedOn > 0)
+                                throw new IOException(getStreamPrefix() + "I2PSocket closed while writing");
+                            try {
+                                bc.wait(1000);
+                            } catch (InterruptedException ie) {}
+                        }
+                    }
+                }
+                bc.append(data, off, len);
+            }
+            synchronized (I2PInputStream.this) {
+                I2PInputStream.this.notifyAll();
+            }
+            if (_log.shouldLog(Log.DEBUG))
+                _log.debug(getStreamPrefix() + "After insert " + len + " bytes into queue: " + hashCode());
+        }
+
+        public void notifyClosed() {
+            synchronized (I2PInputStream.this) {
+                I2PInputStream.this.notifyAll();
+            }
+        }
+        
+        public void close() throws IOException {
+            super.close();
+            notifyClosed();
+            synchronized (bc) {
+                inStreamClosed = true;
+                bc.notifyAll();
+            }
+            if (_log.shouldLog(Log.DEBUG))
+                _log.debug(getStreamPrefix() + "After close");
+        }
 
-	public synchronized void notifyClosed() {
-	    notifyAll();
-	}
-	
     }
 
-    public class I2POutputStream extends OutputStream {
+    private class I2POutputStream extends OutputStream {
 
-	public I2PInputStream sendTo;
-	
-	public I2POutputStream(I2PInputStream sendTo) {
-	    this.sendTo=sendTo;
-	}
-	public void write(int b) throws IOException {
-	    write(new byte[] {(byte)b});
-	}
+        public I2PInputStream sendTo;
 
-	public void write (byte[] b, int off, int len)  throws IOException {
-	    sendTo.queueData(b,off,len);
-	}
+        public I2POutputStream(I2PInputStream sendTo) {
+            this.sendTo = sendTo;
+        }
 
-	public void close() {
-	    sendTo.notifyClosed();
-	}
+        public void write(int b) throws IOException {
+            write(new byte[] { (byte) b});
+        }
+
+        public void write(byte[] b, int off, int len) throws IOException {
+            _bytesWritten += len;
+            sendTo.queueData(b, off, len, true);
+        }
+
+        public void close() {
+            sendTo.notifyClosed();
+        }
     }
 
-    public class I2PSocketRunner extends Thread {
+    private static volatile long __runnerId = 0;
+    private class I2PSocketRunner extends I2PThread {
 
-	public InputStream in;
+        public InputStream in;
 
-	public I2PSocketRunner(InputStream in) {
-	    _log.debug("Runner's input stream is: "+in.hashCode());
-	    this.in=in;
-	    start();
-	}
+        public I2PSocketRunner(InputStream in) {
+            if (_log.shouldLog(Log.DEBUG))
+                _log.debug(getPrefix() + "Runner's input stream is: " + in.hashCode());
+            this.in = in;
+            String peer = I2PSocketImpl.this.remote.calculateHash().toBase64();
+            setName("SocketRunner " + (++__runnerId) + "/" + _socketId + " " + peer.substring(0, 4));
+            start();
+        }
+        
+        /**
+         * Pump some more data
+         *
+         * @return true if we should keep on handling, false otherwise
+         */
+        private boolean handleNextPacket(ByteCollector bc, byte buffer[]) 
+                                         throws IOException, I2PSessionException {
+            if (_log.shouldLog(Log.DEBUG))
+                _log.debug(getPrefix() + ":" + Thread.currentThread().getName() + "handleNextPacket");
+            int len = in.read(buffer);
+            int bcsize = 0;
+            synchronized (bc) {
+                bcsize = bc.getCurrentSize();
+            }
 
-	public void run() {
-	    byte[] buffer = new byte[MAX_PACKET_SIZE];
-	    ByteCollector bc = new ByteCollector();
-	    boolean sent = true;
-	    try {
-		int len, bcsize;
-//		try {
-		while (true) {
-		    len = in.read(buffer);
-		    bcsize = bc.getCurrentSize();
-		    if (len != -1) {
-			bc.append(buffer,len);
-		    } else if (bcsize == 0) {
-			break;
-		    }
-		    if ((bcsize < MAX_PACKET_SIZE)
-			&& (in.available()==0)) {
-			_log.debug("Runner Point d: "+this.hashCode());
-						
-			try {
-			    Thread.sleep(PACKET_DELAY);
-			} catch (InterruptedException e) {
-			    e.printStackTrace();
-			}
-		    } 
-		    if ((bcsize >= MAX_PACKET_SIZE)
-			|| (in.available()==0) ) {
-			byte[] data = bc.startToByteArray(MAX_PACKET_SIZE);
-			if (data.length > 0) {
-			    _log.debug("Message size is: "+data.length);
-			    sent = sendBlock(data);
-			    if (!sent) {
-				_log.error("Error sending message to peer.  Killing socket runner");
-				break;
-			    }
-			}
-		    }
-		}
-		if ((bc.getCurrentSize() > 0) && sent) {
-		    _log.error("A SCARY MONSTER HAS EATEN SOME DATA! "
-			       + "(input stream: " + in.hashCode() + "; "
-			       + "queue size: " + bc.getCurrentSize() + ")");
-		}
-		synchronized(flagLock) {
-		    closed2=true;
-		}
-// 		} catch (IOException ex) {
-// 		    if (_log.shouldLog(Log.INFO))
-// 			_log.info("Error reading and writing", ex);
-// 		}
-		boolean sc;
-		synchronized(flagLock) {
-		    sc=sendClose;
-		} // FIXME: Race here?
-		if (sc) {
-		    _log.info("Sending close packet: "+outgoing);
-		    byte[] packet = I2PSocketManager.makePacket
-			((byte)(getMask(0x02)),remoteID, new byte[0]);
-		    synchronized(manager.getSession()) {
-			sent = manager.getSession().sendMessage(remote, packet);
-		    }
-		    if (!sent) {
-			_log.error("Error sending close packet to peer");
-		    }
-		}
-		manager.removeSocket(I2PSocketImpl.this);
-	    } catch (IOException ex) {
-		// WHOEVER removes this event on inconsistent
-		// state before fixing the inconsistent state (a
-		// reference on the socket in the socket manager
-		// etc.) will get hanged by me personally -- mihi
-		_log.error("Error running - **INCONSISTENT STATE!!!**", ex);
-	    } catch (I2PException ex) {
-		_log.error("Error running - **INCONSISTENT STATE!!!**" , ex);
-	    }
-	}
-	
-	private boolean sendBlock(byte data[]) throws I2PSessionException {
-	    _log.debug("TIMING: Block to send for "+I2PSocketImpl.this.hashCode());
-	    if (remoteID==null) {
-		_log.error("NULL REMOTEID");
-		return false;
-	    }
-	    byte[] packet = I2PSocketManager.makePacket(getMask(0x00), remoteID,
-						 data);
-	    boolean sent;
-	    synchronized(flagLock) {
-		if (closed2) return false;
-	    }
-	    synchronized(manager.getSession()) {
-		sent = manager.getSession().sendMessage(remote, packet);
-	    }
-	    return sent;
-	}
+            if (_log.shouldLog(Log.DEBUG))
+                _log.debug(getPrefix() + ":" + Thread.currentThread().getName() + "handleNextPacket len=" + len + " bcsize=" + bcsize);
+
+            if (len != -1) {
+                synchronized (bc) {
+                    bc.append(buffer, len);
+                }
+            } else if (bcsize == 0) {
+                // nothing left in the buffer, and read(..) got EOF (-1).
+                // the bart the
+                return false;
+            }
+            if ((bcsize < MAX_PACKET_SIZE) && (in.available() == 0)) {
+                if (_log.shouldLog(Log.DEBUG))
+                    _log.debug(getPrefix() + ":" + Thread.currentThread().getName() + "Runner Point d: " + hashCode());
+
+                try {
+                    Thread.sleep(PACKET_DELAY);
+                } catch (InterruptedException e) {
+                    _log.warn("wtf", e);
+                }
+            }
+            if ((bcsize >= MAX_PACKET_SIZE) || (in.available() == 0)) {
+                byte data[] = null;
+                synchronized (bc) {
+                    data = bc.startToByteArray(MAX_PACKET_SIZE);
+                }
+                if (data.length > 0) {
+                    if (_log.shouldLog(Log.DEBUG))
+                        _log.debug(getPrefix() + ":" + Thread.currentThread().getName() + "Message size is: " + data.length);
+                    boolean sent = sendBlock(data);
+                    if (!sent) {
+                        if (_log.shouldLog(Log.WARN))
+                            _log.warn(getPrefix() + ":" + Thread.currentThread().getName() + "Error sending message to peer.  Killing socket runner");
+                        errorOccurred();
+                        return false;
+                    } else {
+                        if (_log.shouldLog(Log.DEBUG))
+                            _log.debug(getPrefix() + ":" + Thread.currentThread().getName() + "Message sent to peer");
+                    }
+                }
+            }
+            return true;
+        }
+
+        public void run() {
+            byte[] buffer = new byte[MAX_PACKET_SIZE];
+            ByteCollector bc = new ByteCollector();
+            boolean keepHandling = true;
+            int packetsHandled = 0;
+            try {
+                //              try {
+                while (keepHandling) {
+                    keepHandling = handleNextPacket(bc, buffer);
+                    packetsHandled++;
+                    if (_log.shouldLog(Log.DEBUG))
+                        _log.debug(getPrefix() + ":" + Thread.currentThread().getName() 
+                                   + "Packets handled: " + packetsHandled);
+                }
+                if (_log.shouldLog(Log.INFO))
+                    _log.info(getPrefix() + ":" + Thread.currentThread().getName() 
+                               + "After handling packets, we're done.  Packets handled: " + packetsHandled);
+                
+                if ((bc.getCurrentSize() > 0) && (packetsHandled > 1)) {
+                    if (_log.shouldLog(Log.WARN))
+                        _log.warn(getPrefix() + "We lost some data queued up due to a network send error (input stream: " 
+                                  + in.hashCode() + "; "
+                                  + "queue size: " + bc.getCurrentSize() + ")");
+                }
+                synchronized (flagLock) {
+                    closed2 = true;
+                }
+                boolean sc;
+                synchronized (flagLock) {
+                    sc = sendClose;
+                } // FIXME: Race here?
+                if (sc) {
+                    if (_log.shouldLog(Log.INFO))
+                        _log.info(getPrefix() + ":" + Thread.currentThread().getName() 
+                                  + "Sending close packet: (we started? " + outgoing 
+                                  + ") after reading " + _bytesRead + " and writing " + _bytesWritten);
+                    byte[] packet = I2PSocketManagerImpl.makePacket(getMask(0x02), remoteID, new byte[0]);
+                    boolean sent = manager.getSession().sendMessage(remote, packet);
+                    if (!sent) {
+                        if (_log.shouldLog(Log.WARN))
+                            _log.warn(getPrefix() + ":" + Thread.currentThread().getName() 
+                                      + "Error sending close packet to peer");
+                        errorOccurred();
+                    }
+                }
+                manager.removeSocket(I2PSocketImpl.this);
+                internalClose();
+            } catch (InterruptedIOException ex) {
+                _log.error(getPrefix() + "BUG! read() operations should not timeout!", ex);
+            } catch (IOException ex) {
+                // WHOEVER removes this event on inconsistent
+                // state before fixing the inconsistent state (a
+                // reference on the socket in the socket manager
+                // etc.) will get hanged by me personally -- mihi
+                _log.error(getPrefix() + "Error running - **INCONSISTENT STATE!!!**", ex);
+            } catch (I2PException ex) {
+                _log.error(getPrefix() + "Error running - **INCONSISTENT STATE!!!**", ex);
+            }
+        }
+
+        private boolean sendBlock(byte data[]) throws I2PSessionException {
+            if (_log.shouldLog(Log.DEBUG))
+                _log.debug(getPrefix() + "TIMING: Block to send for " + I2PSocketImpl.this.hashCode());
+            if (remoteID == null) {
+                _log.error(getPrefix() + "NULL REMOTEID");
+                return false;
+            }
+            byte[] packet = I2PSocketManagerImpl.makePacket(getMask(0x00), remoteID, data);
+            boolean sent;
+            synchronized (flagLock) {
+                if (closed2) return false;
+            }
+            sent = manager.getSession().sendMessage(remote, packet);
+            return sent;
+        }
     }
+    
+    public String toString() { return "" + hashCode(); }
 }

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

@@ -4,22 +4,29 @@
  */
 package net.i2p.client.streaming;
 
-import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.InterruptedIOException;
 import java.io.UnsupportedEncodingException;
+import java.net.ConnectException;
+import java.net.NoRouteToHostException;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Properties;
 import java.util.Set;
 
+import net.i2p.I2PAppContext;
 import net.i2p.I2PException;
 import net.i2p.client.I2PSession;
+import net.i2p.client.I2PSessionException;
 import net.i2p.client.I2PSessionListener;
 import net.i2p.data.Base64;
+import net.i2p.data.DataFormatException;
 import net.i2p.data.Destination;
 import net.i2p.util.Log;
 
+
 /**
  * Centralize the coordination and multiplexing of the local client's streaming.
  * There should be one I2PSocketManager for each I2PSession, and if an application
@@ -28,359 +35,71 @@ import net.i2p.util.Log;
  * or receive any messages with its .receiveMessage
  *
  */
-public class I2PSocketManager implements I2PSessionListener {
-    private final static Log _log = new Log(I2PSocketManager.class);
-    private I2PSession _session;
-    private I2PServerSocketImpl _serverSocket;
-    private Object lock = new Object(); // for locking socket lists
-    private HashMap _outSockets;
-    private HashMap _inSockets;
-    private I2PSocketOptions _defaultOptions;
+public interface I2PSocketManager {
+    public I2PSession getSession();
+    
+    /**
+     * How long should we wait for the client to .accept() a socket before
+     * sending back a NACK/Close?  
+     *
+     * @param ms milliseconds to wait, maximum
+     */
+    public void setAcceptTimeout(long ms);
+    public long getAcceptTimeout();
+    public void setDefaultOptions(I2PSocketOptions options);
+    public I2PSocketOptions getDefaultOptions();
+    public I2PServerSocket getServerSocket();
 
-    public static final int PUBKEY_LENGTH=387;
-
-    
-    public I2PSocketManager() {
-	_session=null;
-	_serverSocket = new I2PServerSocketImpl(this);
-	_inSockets = new HashMap(16);
-	_outSockets = new HashMap(16);
-    }
-
-    public I2PSession getSession() {
-	return _session;
-    }
-    
-    public void setSession(I2PSession session) { 
-	_session = session; 
-	if (session != null)
-	    session.setSessionListener(this);
-    }
-    
-    public void disconnected(I2PSession session) {
-	_log.error("Disconnected from the session");
-    }
-    
-    public void errorOccurred(I2PSession session, String message, Throwable error) {
-	_log.error("Error occurred: [" + message + "]", error);
-    }
-    
-    public void messageAvailable(I2PSession session, int msgId, long size) {
-	try {
-	    I2PSocketImpl s;
-	    byte msg[] = session.receiveMessage(msgId);
-	    if (msg.length == 1 && msg[0] == -1) {
-		_log.debug("Ping received");
-		return;
-	    }
-	    if (msg.length <4) {
-		_log.error("==== packet too short ====");
-		return;
-	    }
-	    int type = msg[0] & 0xff;
-	    String id = new String(new byte[] {msg[1], msg[2], msg[3]},
-				   "ISO-8859-1");
-	    byte[] payload = new byte[msg.length-4];
-	    System.arraycopy(msg, 4, payload, 0, payload.length);
-	    _log.debug("Message read: type = [" + Integer.toHexString(type) +
-		       "] id = [" + getReadableForm(id)+
-		       "] payload length: " + payload.length + "]");
-	    synchronized(lock) {
-		switch(type) {
-		case 0x51: // ACK outgoing
-		    s = (I2PSocketImpl) _outSockets.get(id);
-		    if (s == null) {
-			_log.warn("No socket responsible for ACK packet");
-			return;
-		    }
-		    if (payload.length==3 && s.getRemoteID(false)==null) {
-			String newID = new String(payload,
-						  "ISO-8859-1");
-			s.setRemoteID(newID);
-			return;
-		    } else {
-			if (payload.length != 3)
-			    _log.warn("Ack packet had " + payload.length + " bytes");
-			else
-			    _log.warn("Remote ID already exists? " + s.getRemoteID());
-			return;
-		    }
-		case 0x52: // disconnect outgoing
-		    _log.debug("*Disconnect outgoing!");
-		    try {
-			s = (I2PSocketImpl) _outSockets.get(id);
-			if (payload.length==0 && s != null) {
-			    s.internalClose();
-			    _outSockets.remove(id);
-			    return;
-			} else {
-			    if (payload.length > 0)
-				_log.warn("Disconnect packet had " + payload.length + " bytes");
-			    return;
-			}
-		    } catch (Exception t) {
-			_log.error("Ignoring error on disconnect", t);
-		    }
-		case 0x50: // packet send outgoing
-		    _log.debug("*Packet send outgoing [" + payload.length + "]");
-		    s = (I2PSocketImpl) _outSockets.get(id);
-		    if (s != null) {
-			s.queueData(payload);
-			return;
-		    } else {
-			_log.error("Null socket with data available");
-			throw new IllegalStateException("Null socket with data available");
-		    }
-		case 0xA1: // SYN incoming
-		    _log.debug("*Syn!");
-		    if (payload.length==PUBKEY_LENGTH) {
-			String newLocalID = makeID(_inSockets);
-			Destination d = new Destination();
-			d.readBytes(new ByteArrayInputStream(payload));
-			
-			s = new I2PSocketImpl(d, this, false,
-					      newLocalID);
-			s.setRemoteID(id);
-			if (_serverSocket.getNewSocket(s)) {
-			    _inSockets.put(newLocalID, s);
-			    byte[] packet = makePacket
-				((byte)0x51, id,
-				 newLocalID.getBytes("ISO-8859-1"));
-			    boolean replySentOk = false;
-			    synchronized(_session) {
-				replySentOk = _session.sendMessage(d, packet);
-			    } 
-				if (!replySentOk) {
-				    _log.error("Error sending reply to " +
-					       d.calculateHash().toBase64() +
-					       " in response to a new con message",
-					       new Exception("Failed creation"));
-				    s.internalClose();
-				}
-			} else {
-			    byte[] packet =
-				(" "+id).getBytes("ISO-8859-1");
-			    packet[0]=0x52;
-			    boolean nackSent = session.sendMessage(d, packet);
-			    if (!nackSent) {
-				_log.error("Error sending NACK for session creation");
-			    }
-			    s.internalClose();
-			}
-			return;
-		    } else {
-			_log.error("Syn packet that has a payload not equal to the pubkey length (" + payload.length + " != " + PUBKEY_LENGTH + ")");
-			return;
-		    }
-		case 0xA2: // disconnect incoming
-		    _log.debug("*Disconnect incoming!");
-		    try {
-			s = (I2PSocketImpl) _inSockets.get(id);
-			if (payload.length==0 && s != null) {
-			    s.internalClose();
-			    _inSockets.remove(id);
-			    return;
-			} else {
-			    if (payload.length > 0)
-				_log.warn("Disconnect packet had " + payload.length + " bytes");
-			    return;
-			}
-		    } catch (Exception t) {
-			_log.error("Ignoring error on disconnect", t);
-			return;
-		    }
-		case 0xA0: // packet send incoming
-		    _log.debug("*Packet send incoming [" + payload.length + "]");
-		    s = (I2PSocketImpl) _inSockets.get(id);
-		    if (s != null) {
-			s.queueData(payload);
-			return;
-		    } else {
-			_log.error("Null socket with data available");
-			throw new IllegalStateException("Null socket with data available");
-		    }
-		case 0xFF: // ignore
-		    return;
-		}
-		_log.error("\n\n=============== Unknown packet! "+
-				   "============"+
-				   "\nType: "+(int)type+
-				   "\nID:   " + getReadableForm(id)+
-				   "\nBase64'ed Data: "+Base64.encode(payload)+
-				   "\n\n\n");
-		if (id != null) {
-		    _inSockets.remove(id);
-		    _outSockets.remove(id);
-		}
-	    }
-	} catch (I2PException ise) {
-	    _log.error("Error processing", ise);
-	} catch (IOException ioe) {
-	    _log.error("Error processing", ioe);
-	} catch (IllegalStateException ise) {
-	    _log.debug("Error processing", ise);
-	}
-    }
-    
-    public void reportAbuse(I2PSession session, int severity) {
-	_log.error("Abuse reported [" + severity + "]");
-    }
- 
-    public void setDefaultOptions(I2PSocketOptions options) { _defaultOptions = options; }
-
-    public I2PSocketOptions getDefaultOptions() { return _defaultOptions ; }
-    
-    public I2PServerSocket getServerSocket() { return _serverSocket; }
-    
     /**
      * Create a new connected socket (block until the socket is created)
      *
-     * @throws I2PException if there is a problem connecting
+     * @param peer Destination to connect to
+     * @param options I2P socket options to be used for connecting
+     *
+     * @throws ConnectException if the peer refuses the connection
+     * @throws NoRouteToHostException if the peer is not found or not reachable
+     * @throws InterruptedIOException if the connection timeouts
+     * @throws I2PException if there is some other I2P-related problem
      */
-    public I2PSocket connect(Destination peer, I2PSocketOptions options) throws I2PException {
+    public I2PSocket connect(Destination peer, I2PSocketOptions options) 
+                             throws I2PException, ConnectException, 
+                             NoRouteToHostException, InterruptedIOException;
 
-	String localID, lcID;
-	I2PSocketImpl s;
-	synchronized(lock) {
-	    localID=makeID(_outSockets);
-	    lcID=getReadableForm(localID);
-	    s = new I2PSocketImpl(peer, this, true, localID);
-	    _outSockets.put(s.getLocalID(),s);
-	}
-	try {
-	    ByteArrayOutputStream pubkey = new ByteArrayOutputStream();
-	    _session.getMyDestination().writeBytes(pubkey);
-	    String remoteID;
-	    byte[] packet = makePacket((byte)0xA1, localID,
-				       pubkey.toByteArray());
-	    boolean sent = false;
-	    synchronized(_session) {
-		sent = _session.sendMessage(peer, packet);
-	    }
-	    if (!sent) {
-		_log.info("Unable to send & receive ack for SYN packet");
-		synchronized(lock) {
-		    _outSockets.remove(s.getLocalID());
-		}
-		throw new I2PException("Unable to reach peer");
-	    }		    
-	    remoteID = s.getRemoteID(true, options.getConnectTimeout());
-	    if ("".equals(remoteID)) {
-		throw new I2PException("Unable to reach peer");
-	    }
-	    _log.debug("TIMING: s given out for remoteID "+getReadableForm(remoteID));
-	    return s;
-	} catch (InterruptedIOException ioe) {
-	    _log.error("Timeout waiting for ack from syn for id " + getReadableForm(lcID), ioe);
-	    synchronized(lock) {
-		_outSockets.remove(s.getLocalID());
-	    }
-	    throw new I2PException("Timeout waiting for ack");
-	} catch (IOException ex) {
-	    _log.error("Error sending syn on id " + getReadableForm(lcID), ex);
-	    synchronized(lock) {
-		_outSockets.remove(s.getLocalID());
-	    }
-	    throw new I2PException("IOException occurred");
-	} catch (I2PException ex) {
- 		_log.info("Error sending syn on id " + getReadableForm(lcID), ex);
-		synchronized(lock) {
-		    _outSockets.remove(s.getLocalID());
-		}
-		throw ex;
-	}
-    }
+    /**
+     * Create a new connected socket (block until the socket is created)
+     *
+     * @param peer Destination to connect to
+     *
+     * @throws ConnectException if the peer refuses the connection
+     * @throws NoRouteToHostException if the peer is not found or not reachable
+     * @throws InterruptedIOException if the connection timeouts
+     * @throws I2PException if there is some other I2P-related problem
+     */
+    public I2PSocket connect(Destination peer) throws I2PException, ConnectException, 
+                                               NoRouteToHostException, InterruptedIOException;
     
-    public I2PSocket connect(Destination peer) throws I2PException {
-	return connect(peer, null); 
-    }
-    
-     /**
+    /**
+     * Destroy the socket manager, freeing all the associated resources.  This
+     * method will block untill all the managed sockets are closed.
+     *
+     */
+    public void destroySocketManager();
+
+    /**
      * Retrieve a set of currently connected I2PSockets, either initiated locally or remotely.
      *
      */
-    public Set listSockets() {
-	Set sockets = new HashSet(8);
-	synchronized (lock) {
-	    sockets.addAll(_inSockets.values());
-	    sockets.addAll(_outSockets.values());
-	}
-	return sockets;
-    }
-    
+    public Set listSockets();
+
     /**
      * Ping the specified peer, returning true if they replied to the ping within 
      * the timeout specified, false otherwise.  This call blocks.
      *
      */
-    public boolean ping(Destination peer, long timeoutMs) {
-	try {
-	    return _session.sendMessage(peer, new byte[] {(byte)0xFF});
-	} catch (I2PException ex) {
-	    _log.error("I2PException:",ex);
-	    return false;
-	}
-    }
+    public boolean ping(Destination peer, long timeoutMs);
 
-    public void removeSocket(I2PSocketImpl sock) {
-	synchronized(lock) {
-	    _inSockets.remove(sock.getLocalID());
-	    _outSockets.remove(sock.getLocalID());
-	}
-    }
+    public String getName();
+    public void setName(String name);
 
-    public static String getReadableForm(String id) {
-	try {
-	    if (id.length() != 3) return "Bogus";
-	    return Base64.encode(id.getBytes("ISO-8859-1"));
-	} catch (UnsupportedEncodingException ex) {
-	    ex.printStackTrace();
-	    return null;
-	}
-    }
-
-    /**
-     * Create a new part the connection ID that is locally unique
-     *
-     * @param uniqueIn map of already known local IDs so we don't collide. WARNING - NOT THREADSAFE!
-     */
-    public static String makeID(HashMap uniqueIn) {
-	String newID;
-	try {
-	    do {
-		int id = (int)(Math.random()*16777215+1);
-		byte[] nid = new byte[3];
-		nid[0]=(byte)(id / 65536);
-		nid[1] = (byte)((id/256) % 256);
-		nid[2]= (byte)(id %256);
-		newID = new String(nid, "ISO-8859-1");
-	    } while (uniqueIn.get(newID) != null);
-	    return newID;
-	} catch (UnsupportedEncodingException ex) {
-	    ex.printStackTrace();
-	    return null;
-	}
-    }
-
-    /**
-     * Create a new packet of the given type for the specified connection containing
-     * the given payload
-     */
-    public static byte[] makePacket(byte type, String id, byte[] payload) {
-	try {
-	    byte[] packet = new byte[payload.length+4];
-	    packet[0]=type;
-	    byte[] temp = id.getBytes("ISO-8859-1");
-	    if (temp.length != 3)
-		throw new RuntimeException("Incorrect ID length: "+
-					   temp.length);
-	    System.arraycopy(temp,0,packet,1,3);
-	    System.arraycopy(payload,0,packet,4,payload.length);
-	    return packet;
-	} catch (UnsupportedEncodingException ex) {
-	    if (_log.shouldLog(Log.ERROR))
-		_log.error("Error building the packet", ex);
-	    return new byte[0];
-	}
-    }
+    public void init(I2PAppContext context, I2PSession session, Properties opts, String name);
 }

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

@@ -1,20 +1,21 @@
 package net.i2p.client.streaming;
 
-import net.i2p.client.I2PSession;
-import net.i2p.client.I2PClient;
-import net.i2p.client.I2PClientFactory;
-import net.i2p.client.I2PSessionException;
-import net.i2p.I2PException;
-import net.i2p.data.Destination;
-import net.i2p.util.Log;
-
-import java.io.InputStream;
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
-
+import java.io.InputStream;
+import java.util.Iterator;
 import java.util.Properties;
 
+import net.i2p.I2PAppContext;
+import net.i2p.I2PException;
+import net.i2p.client.I2PClient;
+import net.i2p.client.I2PClientFactory;
+import net.i2p.client.I2PSession;
+import net.i2p.client.I2PSessionException;
+import net.i2p.data.Destination;
+import net.i2p.util.Log;
+
 /**
  * Simplify the creation of I2PSession and transient I2P Destination objects if 
  * necessary to create a socket manager.  This class is most likely how classes
@@ -23,6 +24,10 @@ import java.util.Properties;
  */
 public class I2PSocketManagerFactory {
     private final static Log _log = new Log(I2PSocketManagerFactory.class);
+
+    public static final String PROP_MANAGER = "i2p.streaming.manager";
+    public static final String DEFAULT_MANAGER = "net.i2p.client.streaming.I2PSocketManagerImpl";
+    //public static final String DEFAULT_MANAGER = "net.i2p.client.streaming.I2PSocketManagerFull";
     
     /**
      * Create a socket manager using a brand new destination connected to the
@@ -31,9 +36,20 @@ public class I2PSocketManagerFactory {
      * @return the newly created socket manager, or null if there were errors
      */
     public static I2PSocketManager createManager() {
-	return createManager("localhost", 7654, new Properties());
+        String i2cpHost = System.getProperty(I2PClient.PROP_TCP_HOST, "localhost");
+        int i2cpPort = 7654;
+        String i2cpPortStr = System.getProperty(I2PClient.PROP_TCP_PORT);
+        if (i2cpPortStr != null) {
+            try {
+                i2cpPort = Integer.parseInt(i2cpPortStr);
+            } catch (NumberFormatException nfe) {
+                // gobble gobble
+            }
+        }
+
+        return createManager(i2cpHost, i2cpPort, System.getProperties());
     }
-    
+
     /**
      * Create a socket manager using a brand new destination connected to the
      * I2CP router on the given machine reachable through the given port.
@@ -41,21 +57,21 @@ public class I2PSocketManagerFactory {
      * @return the newly created socket manager, or null if there were errors
      */
     public static I2PSocketManager createManager(String i2cpHost, int i2cpPort, Properties opts) {
-	I2PClient client = I2PClientFactory.createClient();
-	ByteArrayOutputStream keyStream = new ByteArrayOutputStream(512);
-	try {
-	    Destination dest = client.createDestination(keyStream);
-	    ByteArrayInputStream in = new ByteArrayInputStream(keyStream.toByteArray());
-	    return createManager(in, i2cpHost, i2cpPort, opts);
-	} catch (IOException ioe) {
-	    _log.error("Error creating the destination for socket manager", ioe);
-	    return null;
-	} catch (I2PException ie) {
-	    _log.error("Error creating the destination for socket manager", ie);
-	    return null;
-	}
+        I2PClient client = I2PClientFactory.createClient();
+        ByteArrayOutputStream keyStream = new ByteArrayOutputStream(512);
+        try {
+            Destination dest = client.createDestination(keyStream);
+            ByteArrayInputStream in = new ByteArrayInputStream(keyStream.toByteArray());
+            return createManager(in, i2cpHost, i2cpPort, opts);
+        } catch (IOException ioe) {
+            _log.error("Error creating the destination for socket manager", ioe);
+            return null;
+        } catch (I2PException ie) {
+            _log.error("Error creating the destination for socket manager", ie);
+            return null;
+        }
     }
-    
+
     /**
      * Create a socket manager using the destination loaded from the given private key
      * stream and connected to the I2CP router on the specified machine on the given
@@ -63,24 +79,74 @@ public class I2PSocketManagerFactory {
      *
      * @return the newly created socket manager, or null if there were errors
      */
-    public static I2PSocketManager createManager(InputStream myPrivateKeyStream, String i2cpHost, int i2cpPort, Properties opts) {
-	I2PClient client = I2PClientFactory.createClient();
-	opts.setProperty(I2PClient.PROP_RELIABILITY, I2PClient.PROP_RELIABILITY_GUARANTEED);
-	opts.setProperty(I2PClient.PROP_TCP_HOST, i2cpHost);
-	opts.setProperty(I2PClient.PROP_TCP_PORT, ""+i2cpPort);
-	try {
-	    I2PSession session = client.createSession(myPrivateKeyStream, opts);
-	    session.connect();
-	    return createManager(session);
-	} catch (I2PSessionException ise) {
-	    _log.error("Error creating session for socket manager", ise);
-	    return null;
-	}
+    public static I2PSocketManager createManager(InputStream myPrivateKeyStream, String i2cpHost, int i2cpPort,
+                                                 Properties opts) {
+        I2PClient client = I2PClientFactory.createClient();
+        if (opts == null)
+            opts = new Properties();
+        for (Iterator iter = System.getProperties().keySet().iterator(); iter.hasNext(); ) {
+            String name = (String)iter.next();
+            if (!opts.containsKey(name))
+                opts.setProperty(name, System.getProperty(name));
+        }
+        boolean oldLib = DEFAULT_MANAGER.equals(opts.getProperty(PROP_MANAGER, DEFAULT_MANAGER));
+        if (oldLib) {
+            // for the old streaming lib
+            opts.setProperty(I2PClient.PROP_RELIABILITY, I2PClient.PROP_RELIABILITY_GUARANTEED);
+            //opts.setProperty("tunnels.depthInbound", "0");
+        } else {
+            // for new streaming lib:
+            opts.setProperty(I2PClient.PROP_RELIABILITY, I2PClient.PROP_RELIABILITY_BEST_EFFORT);
+            //p.setProperty("tunnels.depthInbound", "0");
+        }
+
+        opts.setProperty(I2PClient.PROP_TCP_HOST, i2cpHost);
+        opts.setProperty(I2PClient.PROP_TCP_PORT, "" + i2cpPort);
+        
+        try {
+            I2PSession session = client.createSession(myPrivateKeyStream, opts);
+            session.connect();
+            return createManager(session, opts, "manager");
+        } catch (I2PSessionException ise) {
+            _log.error("Error creating session for socket manager", ise);
+            return null;
+        }
     }
-    
-    private static I2PSocketManager createManager(I2PSession session) {
-	I2PSocketManager mgr = new I2PSocketManager();
-	mgr.setSession(session);
-	return mgr;
+
+    private static I2PSocketManager createManager(I2PSession session, Properties opts, String name) {
+        if (false) {
+            I2PSocketManagerImpl mgr = new I2PSocketManagerImpl();
+            mgr.setSession(session);
+            mgr.setDefaultOptions(new I2PSocketOptions());
+            return mgr;
+        } else {
+            String classname = opts.getProperty(PROP_MANAGER, DEFAULT_MANAGER);
+            if (classname != null) {
+                try {
+                    Class cls = Class.forName(classname);
+                    Object obj = cls.newInstance();
+                    if (obj instanceof I2PSocketManager) {
+                        I2PSocketManager mgr = (I2PSocketManager)obj;
+                        I2PAppContext context = I2PAppContext.getGlobalContext();
+                        mgr.init(context, session, opts, name);
+                        return mgr;
+                    } else {
+                        throw new IllegalStateException("Invalid manager class [" + classname + "]");
+                    }
+                } catch (ClassNotFoundException cnfe) {
+                    _log.error("Error loading " + classname, cnfe);
+                    throw new IllegalStateException("Invalid manager class [" + classname + "] - not found");
+                } catch (InstantiationException ie) {
+                    _log.error("Error loading " + classname, ie);
+                    throw new IllegalStateException("Invalid manager class [" + classname + "] - unable to instantiate");
+                } catch (IllegalAccessException iae) {
+                    _log.error("Error loading " + classname, iae);
+                    throw new IllegalStateException("Invalid manager class [" + classname + "] - illegal access");
+                }
+            } else {
+                throw new IllegalStateException("No manager class specified");
+            }
+        }
+        
     }
-}
+}

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

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

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

@@ -1,14 +1,36 @@
 package net.i2p.client.streaming;
 
+import java.util.Properties;
+
 /**
  * Define the configuration for streaming and verifying data on the socket.
- * No options available...
  *
  */
 public class I2PSocketOptions {
     private long _connectTimeout;
+    private long _readTimeout;
+    private long _writeTimeout;
+    private int _maxBufferSize;
+
+    public static final int DEFAULT_BUFFER_SIZE = 1024*64;
+    public static final int DEFAULT_WRITE_TIMEOUT = 60*1000;
+    
     public I2PSocketOptions() {
-	_connectTimeout = -1;
+        _connectTimeout = -1;
+        _readTimeout = -1;
+        _writeTimeout = DEFAULT_WRITE_TIMEOUT;
+        _maxBufferSize = DEFAULT_BUFFER_SIZE;
+    }
+    
+    public I2PSocketOptions(I2PSocketOptions opts) {
+        _connectTimeout = opts.getConnectTimeout();
+        _readTimeout = opts.getReadTimeout();
+        _writeTimeout = opts.getWriteTimeout();
+        _maxBufferSize = opts.getMaxBufferSize();
+    }
+
+    public I2PSocketOptions(Properties opts) {
+        
     }
     
     /**
@@ -16,6 +38,76 @@ public class I2PSocketOptions {
      *
      * @return milliseconds to wait, or -1 if we will wait indefinitely
      */
-    public long getConnectTimeout() { return _connectTimeout; }
-    public void setConnectTimeout(long ms) { _connectTimeout = ms; }
+    public long getConnectTimeout() {
+        return _connectTimeout;
+    }
+
+    /**
+     * Define how long we will wait for the ACK from a SYN, in milliseconds.
+     *
+     */
+    public void setConnectTimeout(long ms) {
+        _connectTimeout = ms;
+    }
+    
+    /**
+     * What is the longest we'll block on the input stream while waiting
+     * for more data.  If this value is exceeded, the read() throws 
+     * InterruptedIOException
+     */
+    public long getReadTimeout() {
+        return _readTimeout;
+    }
+
+    /**
+     * What is the longest we'll block on the input stream while waiting
+     * for more data.  If this value is exceeded, the read() throws 
+     * InterruptedIOException
+     */
+    public void setReadTimeout(long ms) {
+        _readTimeout = ms;
+    }
+    
+    /**
+     * How much data will we accept that hasn't been written out yet.  After 
+     * this amount has been exceeded, subsequent .write calls will block until
+     * either some data is removed or the connection is closed.  If this is 
+     * less than or equal to zero, there is no limit (warning: can eat ram)
+     *
+     * @return buffer size limit, in bytes
+     */
+    public int getMaxBufferSize() {
+        return _maxBufferSize; 
+    }
+    
+    /**
+     * How much data will we accept that hasn't been written out yet.  After 
+     * this amount has been exceeded, subsequent .write calls will block until
+     * either some data is removed or the connection is closed.  If this is 
+     * less than or equal to zero, there is no limit (warning: can eat ram)
+     *
+     */
+    public void setMaxBufferSize(int numBytes) {
+        _maxBufferSize = numBytes; 
+    }
+    
+    /**
+     * What is the longest we'll block on the output stream while waiting
+     * for the data to flush.  If this value is exceeded, the write() throws 
+     * InterruptedIOException.  If this is less than or equal to zero, there 
+     * is no timeout.
+     */
+    public long getWriteTimeout() {
+        return _writeTimeout;
+    }
+
+    /**
+     * What is the longest we'll block on the output stream while waiting
+     * for the data to flush.  If this value is exceeded, the write() throws 
+     * InterruptedIOException.  If this is less than or equal to zero, there 
+     * is no timeout.
+     */
+    public void setWriteTimeout(long ms) {
+        _writeTimeout = ms;
+    }
 }

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

@@ -0,0 +1,162 @@
+package net.i2p.client.streaming;
+
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InterruptedIOException;
+import java.io.OutputStream;
+
+import java.net.ConnectException;
+import java.net.NoRouteToHostException;
+
+import java.util.Properties;
+import java.util.Random;
+
+import net.i2p.I2PAppContext;
+import net.i2p.I2PException;
+import net.i2p.data.Destination;
+import net.i2p.data.DataFormatException;
+import net.i2p.util.Log;
+
+/**
+ * Simple streaming lib test app that connects to a given destination and sends 
+ * it a particular amount of random data, then disconnects.  See the {@link #main}
+ *
+ */
+public class StreamSinkClient {
+    private Log _log;
+    private int _sendSize;
+    private int _writeDelay;
+    private String _peerDestFile;
+    private String _i2cpHost;
+    private int _i2cpPort;
+
+    
+    /**
+     * Build the client but don't fire it up.
+     * @param sendSize how many KB to send
+     * @param writeDelayMs how long to wait between each .write (0 for no delay)
+     * @param serverDestFile file containing the StreamSinkServer's binary Destination
+     */
+    public StreamSinkClient(int sendSize, int writeDelayMs, String serverDestFile) {
+        this(null, -1, sendSize, writeDelayMs, serverDestFile);
+    }
+    public StreamSinkClient(String i2cpHost, int i2cpPort, int sendSize, int writeDelayMs, String serverDestFile) {
+        _i2cpHost = i2cpHost;
+        _i2cpPort = i2cpPort;
+        _sendSize = sendSize;
+        _writeDelay = writeDelayMs;
+        _peerDestFile = serverDestFile;
+        _log = I2PAppContext.getGlobalContext().logManager().getLog(StreamSinkClient.class);
+    }
+    
+    /**
+     * Actually connect and run the client - this call blocks until completion.
+     *
+     */
+    public void runClient() {
+        I2PSocketManager mgr = null;
+        if (_i2cpHost != null)
+            mgr = I2PSocketManagerFactory.createManager(_i2cpHost, _i2cpPort, new Properties());
+        else
+            mgr = I2PSocketManagerFactory.createManager();
+        Destination peer = null;
+        FileInputStream fis = null;
+        try { 
+            fis = new FileInputStream(_peerDestFile);
+            peer = new Destination();
+            peer.readBytes(fis);
+        } catch (IOException ioe) {
+            _log.error("Error finding the peer destination to contact in " + _peerDestFile, ioe);
+            return;
+        } catch (DataFormatException dfe) {
+            _log.error("Peer destination is not valid in " + _peerDestFile, dfe);
+            return;
+        } finally {
+            if (fis == null) try { fis.close(); } catch (IOException ioe) {}
+        }
+        
+        
+        System.out.println("Send " + _sendSize + "KB to " + peer.calculateHash().toBase64());
+        
+        try {
+            I2PSocket sock = mgr.connect(peer);
+            byte buf[] = new byte[32*1024];
+            Random rand = new Random();
+            OutputStream out = sock.getOutputStream();
+            long beforeSending = System.currentTimeMillis();
+            for (int i = 0; i < _sendSize; i+= 32) {
+                rand.nextBytes(buf);
+                out.write(buf);
+                if (_log.shouldLog(Log.DEBUG))
+                    _log.debug("Wrote " + (i+32) + "/" + _sendSize + "KB");
+                if (_writeDelay > 0) {
+                    try { Thread.sleep(_writeDelay); } catch (InterruptedException ie) {}
+                }   
+            }
+            sock.close();
+            long afterSending = System.currentTimeMillis();
+            System.out.println("Sent " + _sendSize + "KB in " + (afterSending-beforeSending) + "ms");
+        } catch (InterruptedIOException iie) {
+            _log.error("Timeout connecting to the peer", iie);
+            return;
+        } catch (NoRouteToHostException nrthe) {
+            _log.error("Unable to connect to the peer", nrthe);
+            return;
+        } catch (ConnectException ce) {
+            _log.error("Connection already dropped", ce);
+            return;
+        } catch (I2PException ie) {
+            _log.error("Error connecting to the peer", ie);
+            return;
+        } catch (IOException ioe) {
+            _log.error("IO error sending", ioe);
+            return;
+        }
+    }
+
+    /**
+     * Fire up the client.  <code>Usage: StreamSinkClient [i2cpHost i2cpPort] sendSizeKB writeDelayMs serverDestFile</code> <br />
+     * <ul>
+     *  <li><b>sendSizeKB</b>: how many KB to send</li>
+     *  <li><b>writeDelayMs</b>: how long to wait between each .write (0 for no delay)</li>
+     *  <li><b>serverDestFile</b>: file containing the StreamSinkServer's binary Destination</li>
+     * </ul>
+     */
+    public static void main(String args[]) {
+        StreamSinkClient client = null;
+        int sendSizeKB = -1;
+        int writeDelayMs = -1;
+        
+        switch (args.length) {
+            case 3:
+                try {
+                    sendSizeKB = Integer.parseInt(args[0]);
+                } catch (NumberFormatException nfe) {
+                    System.err.println("Send size invalid [" + args[0] + "]");
+                    return;
+                }
+                try {
+                    writeDelayMs = Integer.parseInt(args[1]);
+                } catch (NumberFormatException nfe) {
+                    System.err.println("Write delay ms invalid [" + args[1] + "]");
+                    return;
+                }
+                client = new StreamSinkClient(sendSizeKB, writeDelayMs, args[2]);
+                break;
+            case 5:
+                try { 
+                    int port = Integer.parseInt(args[1]);
+                    sendSizeKB = Integer.parseInt(args[2]);
+                    writeDelayMs = Integer.parseInt(args[3]);
+                    client = new StreamSinkClient(args[0], port, sendSizeKB, writeDelayMs, args[4]);
+                } catch (NumberFormatException nfe) {
+                    System.err.println("arg error");
+                }
+                break;
+            default: 
+                System.out.println("Usage: StreamSinkClient [i2cpHost i2cpPort] sendSizeKB writeDelayMs serverDestFile");
+        }
+        if (client != null)
+            client.runClient();
+    }
+}

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

@@ -0,0 +1,132 @@
+package net.i2p.client.streaming;
+
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InterruptedIOException;
+import java.io.OutputStream;
+
+import java.net.ConnectException;
+import java.net.NoRouteToHostException;
+
+import java.util.Random;
+
+import net.i2p.I2PAppContext;
+import net.i2p.I2PException;
+import net.i2p.data.Destination;
+import net.i2p.data.DataFormatException;
+import net.i2p.util.Log;
+
+/**
+ * Simple streaming lib test app that connects to a given destination and sends 
+ * the contents of a file, then disconnects.  See the {@link #main}
+ *
+ */
+public class StreamSinkSend {
+    private Log _log;
+    private String _sendFile;
+    private int _writeDelay;
+    private String _peerDestFile;
+    
+    /**
+     * Build the client but don't fire it up.
+     * @param filename file to send
+     * @param writeDelayMs how long to wait between each .write (0 for no delay)
+     * @param serverDestFile file containing the StreamSinkServer's binary Destination
+     */
+    public StreamSinkSend(String filename, int writeDelayMs, String serverDestFile) {
+        _sendFile = filename;
+        _writeDelay = writeDelayMs;
+        _peerDestFile = serverDestFile;
+        _log = I2PAppContext.getGlobalContext().logManager().getLog(StreamSinkClient.class);
+    }
+    
+    /**
+     * Actually connect and run the client - this call blocks until completion.
+     *
+     */
+    public void runClient() {
+        I2PSocketManager mgr = I2PSocketManagerFactory.createManager();
+        Destination peer = null;
+        FileInputStream fis = null;
+        try { 
+            fis = new FileInputStream(_peerDestFile);
+            peer = new Destination();
+            peer.readBytes(fis);
+        } catch (IOException ioe) {
+            _log.error("Error finding the peer destination to contact in " + _peerDestFile, ioe);
+            return;
+        } catch (DataFormatException dfe) {
+            _log.error("Peer destination is not valid in " + _peerDestFile, dfe);
+            return;
+        } finally {
+            if (fis != null) try { fis.close(); } catch (IOException ioe) {}
+        }
+        
+        
+        System.out.println("Send " + _sendFile + " to " + peer.calculateHash().toBase64());
+        
+        try {
+            I2PSocket sock = mgr.connect(peer);
+            byte buf[] = new byte[32*1024];
+            OutputStream out = sock.getOutputStream();
+            long beforeSending = System.currentTimeMillis();
+            fis = new FileInputStream(_sendFile);
+            long size = 0;
+            while (true) {
+                int read = fis.read(buf);
+                if (read < 0)
+                    break;
+                out.write(buf, 0, read);
+                size += read;
+                if (_log.shouldLog(Log.DEBUG))
+                    _log.debug("Wrote " + read);
+                if (_writeDelay > 0) {
+                    try { Thread.sleep(_writeDelay); } catch (InterruptedException ie) {}
+                }   
+            }
+            fis.close();
+            sock.close();
+            long afterSending = System.currentTimeMillis();
+            System.out.println("Sent " + (size / 1024) + "KB in " + (afterSending-beforeSending) + "ms");
+        } catch (InterruptedIOException iie) {
+            _log.error("Timeout connecting to the peer", iie);
+            return;
+        } catch (NoRouteToHostException nrthe) {
+            _log.error("Unable to connect to the peer", nrthe);
+            return;
+        } catch (ConnectException ce) {
+            _log.error("Connection already dropped", ce);
+            return;
+        } catch (I2PException ie) {
+            _log.error("Error connecting to the peer", ie);
+            return;
+        } catch (IOException ioe) {
+            _log.error("IO error sending", ioe);
+            return;
+        }
+    }
+
+    /**
+     * Fire up the client.  <code>Usage: StreamSinkClient sendFile writeDelayMs serverDestFile</code> <br />
+     * <ul>
+     *  <li><b>sendFile</b>: filename to send</li>
+     *  <li><b>writeDelayMs</b>: how long to wait between each .write (0 for no delay)</li>
+     *  <li><b>serverDestFile</b>: file containing the StreamSinkServer's binary Destination</li>
+     * </ul>
+     */
+    public static void main(String args[]) {
+        if (args.length != 3) {
+            System.out.println("Usage: StreamSinkClient sendFile writeDelayMs serverDestFile");
+        } else {
+            int writeDelayMs = -1;
+            try {
+                writeDelayMs = Integer.parseInt(args[1]);
+            } catch (NumberFormatException nfe) {
+                System.err.println("Write delay ms invalid [" + args[1] + "]");
+                return;
+            }
+            StreamSinkSend client = new StreamSinkSend(args[0], writeDelayMs, args[2]);
+            client.runClient();
+        }
+    }
+}

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

@@ -0,0 +1,163 @@
+package net.i2p.client.streaming;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+import java.net.ConnectException;
+import java.util.Properties;
+
+import net.i2p.I2PAppContext;
+import net.i2p.I2PException;
+import net.i2p.data.DataFormatException;
+import net.i2p.data.Destination;
+import net.i2p.util.I2PThread;
+import net.i2p.util.Log;
+
+/**
+ * Listen to a destination, receiving any sockets and writing anything they 
+ * send to a new file. See the {@link #main}
+ *
+ */
+public class StreamSinkServer {
+    private Log _log;
+    private String _sinkDir;
+    private String _destFile;
+    private String _i2cpHost;
+    private int _i2cpPort;
+    
+    /**
+     * Create but do not start the streaming server.  
+     *
+     * @param sinkDir Directory to store received files in
+     * @param ourDestFile filename to write our binary destination to
+     */
+    public StreamSinkServer(String sinkDir, String ourDestFile) {
+        this(sinkDir, ourDestFile, null, -1);
+    }
+    public StreamSinkServer(String sinkDir, String ourDestFile, String i2cpHost, int i2cpPort) {
+        _sinkDir = sinkDir;
+        _destFile = ourDestFile;
+        _i2cpHost = i2cpHost;
+        _i2cpPort = i2cpPort;
+        _log = I2PAppContext.getGlobalContext().logManager().getLog(StreamSinkServer.class);
+    }
+    
+    /**
+     * Actually fire up the server - this call blocks forever (or until the server 
+     * socket closes)
+     * 
+     */
+    public void runServer() {
+        I2PSocketManager mgr = null;
+        if (_i2cpHost != null)
+            mgr = I2PSocketManagerFactory.createManager(_i2cpHost, _i2cpPort, new Properties());
+        else 
+            mgr = I2PSocketManagerFactory.createManager();
+        Destination dest = mgr.getSession().getMyDestination();
+        System.out.println("Listening for connections on: " + dest.calculateHash().toBase64());
+        FileOutputStream fos = null;
+        try {
+            fos = new FileOutputStream(_destFile);
+            dest.writeBytes(fos);
+        } catch (IOException ioe) {
+            _log.error("Error writing out our destination to " + _destFile, ioe);
+            return;
+        } catch (DataFormatException dfe) {
+            _log.error("Error formatting the destination", dfe);
+            return;
+        } finally {
+            if (fos != null) try { fos.close(); } catch (IOException ioe) {}
+        }
+        
+        I2PServerSocket sock = mgr.getServerSocket();
+        while (true) {
+            try {
+                I2PSocket curSock = sock.accept();
+                handle(curSock);
+            } catch (I2PException ie) {
+                _log.error("Error accepting connection", ie);
+                return;
+            } catch (ConnectException ce) {
+                _log.error("Connection already dropped", ce);
+                return;
+            }
+        }
+    }
+    
+    private void handle(I2PSocket socket) {
+        I2PThread t = new I2PThread(new ClientRunner(socket));
+        t.setName("Handle " + socket.getPeerDestination().calculateHash().toBase64().substring(0,4));
+        t.start();
+    }
+    
+    /**
+     * Actually deal with a client - pull anything they send us and write it to a file.
+     *
+     */
+    private class ClientRunner implements Runnable {
+        private I2PSocket _sock;
+        private FileOutputStream _fos;
+        public ClientRunner(I2PSocket socket) {
+            _sock = socket;
+            try {
+                File sink = new File(_sinkDir);
+                if (!sink.exists())
+                    sink.mkdirs();
+                File cur = File.createTempFile("clientSink", ".dat", sink);
+                _fos = new FileOutputStream(cur);
+                System.out.println("Writing to " + cur.getAbsolutePath());
+            } catch (IOException ioe) {
+                _log.error("Error creating sink", ioe);
+                _fos = null;
+            }
+        }
+        public void run() {
+            if (_fos == null) return;
+            try {
+                InputStream in = _sock.getInputStream();
+                byte buf[] = new byte[4096];
+                int read = 0;
+                while ( (read = in.read(buf)) != -1) {
+                    _fos.write(buf, 0, read);
+                }
+                _log.error("Got EOF from client socket");
+            } catch (IOException ioe) {
+                _log.error("Error writing the sink", ioe);
+            } finally {
+                if (_fos != null) try { _fos.close(); } catch (IOException ioe) {}
+                if (_sock != null) try { _sock.close(); } catch (IOException ioe) {}
+                _log.error("Client socket closed");
+            }
+        }
+    }
+    
+    /**
+     * Fire up the streaming server.  <code>Usage: StreamSinkServer [i2cpHost i2cpPort] sinkDir ourDestFile</code><br />
+     * <ul>
+     *  <li><b>sinkDir</b>: Directory to store received files in</li>
+     *  <li><b>ourDestFile</b>: filename to write our binary destination to</li>
+     * </ul>
+     */
+    public static void main(String args[]) {
+        StreamSinkServer server = null;
+        switch (args.length) {
+            case 2:
+                server = new StreamSinkServer(args[0], args[1]);
+                break;
+            case 4:
+                try { 
+                    int port = Integer.parseInt(args[1]);
+                    server = new StreamSinkServer(args[2], args[3], args[0], port);
+                } catch (NumberFormatException nfe) {
+                    System.out.println("Usage: StreamSinkServer [i2cpHost i2cpPort] sinkDir ourDestFile");
+                }
+                break;
+            default:
+                System.out.println("Usage: StreamSinkServer [i2cpHost i2cpPort] sinkDir ourDestFile");
+        }
+        if (server != null)
+            server.runServer();
+    }
+}

apps/ministreaming/java/src/net/i2p/client/streaming/package.html

@@ -0,0 +1,24 @@
+<html><body>
+<p>Implements a TCP-like (reliable, authenticated, in order) set of sockets for 
+communicating over the IP-like (unreliable, unauthenticated, unordered) I2P
+messages.</p>
+
+<p>When an application wants to use streams, it must fetch an {@link
+net.i2p.client.streaming.I2PSocketManager} from the {@link 
+net.i2p.client.streaming.I2PSocketManagerFactory}, which in turn builds its own
+{@link net.i2p.client.I2PSession} internally.  All communication over that 
+{@link net.i2p.client.I2PSession} is handled by the {@link 
+net.i2p.client.streaming.I2PSocketManager}, as it imposes its own formatting on
+the raw messages sent and received.  If an application wants to receive streams
+from other clients on the network, it should access the blocking {@link
+net.i2p.client.streaming.I2PServerSocket#accept} method, which will provide an
+{@link net.i2p.client.streaming.I2PSocket} when a new one is available.  If an
+application wants to create a new stream to a peer, it should do so with the
+appropriate {@link net.i2p.client.streaming.I2PSocketManager#connect} call.</p>
+
+<p>There is a simple pair of demo applications available as well - {@link
+net.i2p.client.streaming.StreamSinkServer} listens to a destination and dumps 
+the data from all sockets it accepts to individual files, while {@link
+net.i2p.client.streaming.StreamSinkClient} connects to a particular destination
+and sends a specific amount of random data then disconnects.</p>
+</body></html>

apps/myi2p/java/build.xml

@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project basedir="." default="all" name="myi2p">
+    <target name="all" depends="clean, build" />
+    <target name="build" depends="builddep, jar" />
+    <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" deprecation="on" source="1.3" target="1.3" 
+            destdir="./build/obj" 
+            classpath="../../../core/java/build/i2p.jar" />
+    </target>
+    <target name="jar" depends="compile">
+        <jar destfile="./build/myi2p.jar" basedir="./build/obj" includes="**/*.class" />
+    </target>
+    <target name="javadoc">
+        <mkdir dir="./build" />
+        <mkdir dir="./build/javadoc" />
+        <javadoc 
+            sourcepath="./src:../../../core/java/src" destdir="./build/javadoc" 
+            packagenames="*" 
+            use="true" 
+            splitindex="true" 
+            windowtitle="MyI2P" />
+    </target>
+    <target name="clean">
+        <delete dir="./build" />
+    </target>
+    <target name="cleandep" depends="clean">
+        <ant dir="../../../core/java/" target="distclean" />
+    </target>
+    <target name="distclean" depends="clean">
+        <ant dir="../../../core/java/" target="distclean" />
+    </target>
+</project>

apps/myi2p/java/src/net/i2p/myi2p/MyI2PMessage.java

@@ -0,0 +1,116 @@
+package net.i2p.myi2p;
+
+import net.i2p.data.Destination;
+
+/**
+ * Packages up a message for delivery.  The raw format of the message within a
+ * repliable datagram is
+ *  <code>MyI2P $maj.$min $service $type\n$payload</code>
+ * where <code>$maj.$min</code> is currently 1.0, $service is the type of MyI2P
+ * service, $type is the type of message within that service, and $payload is 
+ * the data specific to that type.
+ *
+ */
+public class MyI2PMessage {
+    private Destination _peer;
+    private String _service;
+    private String _type;
+    private byte[] _payload;
+    
+    private static final byte[] MESSAGE_PREFIX = "MyI2P 1.0 ".getBytes();
+    
+    /**
+     * Build a new MyI2P message to be sent.
+     *
+     * @param to address to send the message
+     * @param service what MyI2P service is involved
+     * @param type type of message within that service is involved
+     * @param data payload of the message to deliver
+     */
+    public MyI2PMessage(Destination to, String service, String type, byte data[]) {
+        _peer = to;
+        _service = service;
+        _type = type;
+        _payload = data;
+    }
+    
+    /**
+     * Read in the MyI2P data from the given datagram info.
+     *
+     * @param from authenticated from address
+     * @param dgramPayload raw MyI2P formatted message
+     * @throws IllegalArgumentException if the message is not a valid MyI2P message
+     */
+    public MyI2PMessage(Destination from, byte dgramPayload[]) throws IllegalArgumentException {
+        _peer = from;
+        int index = 0;
+        while (index < dgramPayload.length) {
+            if (index >= MESSAGE_PREFIX.length) break;
+            if (dgramPayload[index] != MESSAGE_PREFIX[index])
+                throw new IllegalArgumentException("Invalid payload (not a MyI2P message)");
+            index++;
+        }
+        
+        // $service $type\n$payload
+        StringBuffer service = new StringBuffer(8);
+        while (index < dgramPayload.length) {
+            if (dgramPayload[index] == ' ') {
+                _service = service.toString();
+                index++;
+                break;
+            } else if (dgramPayload[index] == '\n') {
+                throw new IllegalArgumentException("Ran into newline while reading the service");
+            } else {
+                service.append((char)dgramPayload[index]);
+                index++;
+            }
+        }
+        
+        StringBuffer type = new StringBuffer(8);
+        while (index < dgramPayload.length) {
+            if (dgramPayload[index] == '\n') {
+                _type = type.toString();
+                index++;
+                break;
+            } else {
+                service.append((char)dgramPayload[index]);
+                index++;
+            }
+        }
+        
+        _payload = new byte[dgramPayload.length-index];
+        System.arraycopy(dgramPayload, index, _payload, 0, _payload.length);
+    }
+   
+    /** who is this message from or who is it going to? */
+    public Destination getPeer() { return _peer; }
+    /** what MyI2P service is this bound for (addressBook, blog, etc)? */
+    public String getServiceType() { return _service; }
+    /** within that service, what type of message is this? */
+    public String getMessageType() { return _type; }
+    /** what is the raw data for the particular message? */
+    public byte[] getPayload() { return _payload; }
+    
+    /**
+     * Retrieve the raw payload, suitable for wrapping in an I2PDatagramMaker 
+     * and sending to another MyI2P node.
+     *
+     * @throws IllegalStateException if some data is missing
+     */
+    public byte[] toRawPayload() throws IllegalStateException {
+        if (_service == null) throw new IllegalStateException("Service is null");
+        if (_type == null) throw new IllegalStateException("Type is null");
+        if (_payload == null) throw new IllegalStateException("Payload is null");
+        
+        byte service[] = _service.getBytes();
+        byte type[] = _type.getBytes();
+        byte rv[] = new byte[MESSAGE_PREFIX.length + service.length + 1 + type.length + 1 + _payload.length];
+        System.arraycopy(MESSAGE_PREFIX, 0, rv, 0, MESSAGE_PREFIX.length);
+        System.arraycopy(service, 0, rv, MESSAGE_PREFIX.length, service.length);
+        rv[MESSAGE_PREFIX.length + service.length] = ' ';
+        System.arraycopy(type, 0, rv, MESSAGE_PREFIX.length + service.length + 1, type.length);
+        rv[MESSAGE_PREFIX.length + service.length + 1 + type.length] = '\n';
+        System.arraycopy(_payload, 0, rv, MESSAGE_PREFIX.length + service.length + 1 + type.length + 1, _payload.length);
+        return rv;
+    }
+}

apps/myi2p/java/src/net/i2p/myi2p/Node.java

@@ -0,0 +1,266 @@
+package net.i2p.myi2p;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+
+import net.i2p.I2PAppContext;
+import net.i2p.util.Log;
+
+/**
+ * Main controller for a MyI2P node, coordinating all network communication and
+ * distributing messages to the appropriate services.
+ *
+ */
+public class Node {
+    private static List _nodes = new ArrayList(1);
+    /**
+     * Return a list of Node instances that are currently 
+     * operating in the JVM
+     */
+    private static List nodes() { 
+        synchronized (_nodes) {
+            return new ArrayList(_nodes);
+        }
+    }
+    
+    private I2PAppContext _context;
+    private Log _log;
+    private NodeAdapter _adapter;
+    /** 
+     * contains configuration properties, such where our router is, what 
+     * services to run, etc
+     *
+     */
+    private Properties _config;
+    /** filename where _config is stored */
+    private String _configFile = DEFAULT_CONFIG_FILE;
+    /** mapping of service name (String) to Service for all services loaded */
+    private Map _services;
+    
+    private static final String DEFAULT_CONFIG_FILE = "myi2p.config";
+    private static final String DEFAULT_KEY_FILE = "myi2p.keys";
+    private static final String PROP_KEY_FILE = "keyFile";
+    
+    public Node(I2PAppContext context) {
+        _context = context;
+        _log = context.logManager().getLog(Node.class);
+        _config = new Properties();
+        _services = new HashMap(1);
+        if (_log.shouldLog(Log.CRIT))
+            _log.log(Log.CRIT, "Node created");
+        _adapter = new NodeAdapter(_context, this);
+    }
+    
+    /**
+     * Main driver for the node.  Usage: <code>Node [configFile]</code>
+     *
+     */
+    public static void main(String args[]) {
+        String filename = DEFAULT_CONFIG_FILE;
+        if ( (args != null) && (args.length == 1) )
+            filename = args[0];
+        Node node = new Node(I2PAppContext.getGlobalContext());
+        node.setConfigFile(filename);
+        node.loadConfig();
+        node.startup();
+        while (true) {
+            //try { Thread.sleep(10*1000); } catch (InterruptedException ie) {}
+            //node.shutdown();
+            //if (true) return;
+            synchronized (node) {
+                try { node.wait(); } catch (InterruptedException ie) {}
+            }
+        }
+    }
+    
+    public Properties getConfig() { 
+        synchronized (_config) {
+            return new Properties(_config); 
+        }
+    }
+    public void setConfig(Properties props) { 
+        synchronized (_config) {
+            _config.clear();
+            _config.putAll(props);
+        }
+    }
+    
+    public String getConfigFile() { return _configFile; }
+    public void setConfigFile(String filename) { _configFile = filename; }
+    
+    /**
+     * Load up the config and all of the services
+     *
+     */
+    public void loadConfig() {
+        FileInputStream fis = null;
+        try {
+            File cfgFile = new File(_configFile);
+            if (cfgFile.exists()) {
+                fis = new FileInputStream(cfgFile);
+                Properties props = new Properties();
+                props.load(fis);
+                setConfig(props);
+                if (_log.shouldLog(Log.INFO))
+                    _log.info("Config loaded from " + _configFile);
+            } else {
+                if (_log.shouldLog(Log.ERROR))
+                    _log.error("Config file " + _configFile + " does not exist, so we aren't going to do much");
+            }
+        } catch (IOException ioe) {
+            if (_log.shouldLog(Log.ERROR))
+                _log.error("Error reading config file " + _configFile, ioe);
+        } finally {
+            if (fis != null) try { fis.close(); } catch (IOException ioe) {}
+        }
+    }
+    
+    /**
+     * Boot up the node, connect to the router, and start all the services
+     *
+     */
+    public void startup() {
+        boolean connected = connect();
+        if (connected) {
+            Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {
+                public void run() { shutdown(); }
+            }));
+            loadServices();
+            startServices();
+            synchronized (_nodes) {
+                _nodes.add(this);
+            }
+            if (_log.shouldLog(Log.INFO))
+                _log.info("Node started");
+        } else {
+            if (_log.shouldLog(Log.ERROR))
+                _log.error("Unable to connect, startup didn't do much");
+        }
+    }
+    
+    /**
+     * Drop any connections to the network and stop all services
+     *
+     */
+    public void shutdown() {
+        disconnect();
+        stopServices();
+        synchronized (_nodes) {
+            _nodes.remove(this);
+        }
+    }
+    
+    /**
+     * Send a message from the node to the peer as specified in the message
+     *
+     * @return true if it was sent
+     */
+    public boolean sendMessage(MyI2PMessage msg) {
+        return _adapter.sendMessage(msg);
+    }
+    
+    private void loadServices() {
+        Properties config = getConfig();
+        int i = 0;
+        while (true) {
+            String classname = config.getProperty("service."+i+".classname");
+            if ( (classname == null) || (classname.trim().length() <= 0) )
+                break;
+            boolean ok = loadService("service." + i + ".", config);
+            if (ok) i++;
+        }
+        if (_log.shouldLog(Log.INFO))
+            _log.info(i + " services loaded");
+    }
+    
+    private boolean loadService(String prefix, Properties config) {
+        String classname = config.getProperty(prefix + "classname");
+        String type = config.getProperty(prefix + "type");
+        if (type == null) return false;
+        
+        Properties opts = new Properties();
+        int i = 0;
+        while (true) {
+            String name = config.getProperty(prefix + "option." + i + ".name");
+            String value = config.getProperty(prefix + "option." + i + ".value");
+            if ( (name == null) || (name.trim().length() <= 0) || (value == null) || (value.trim().length() <= 0) )
+                break;
+            opts.setProperty(name.trim(), value.trim());
+            i++;
+        }
+        
+        try {
+            Class cls = Class.forName(classname);
+            Object obj = cls.newInstance();
+            if (obj instanceof Service) {
+                Service service = (Service)obj;
+                service.setType(type);
+                service.setOptions(opts);
+                service.setNode(this);
+                service.setContext(_context);
+                synchronized (_services) {
+                    _services.put(type, service);
+                }
+                if (_log.shouldLog(Log.INFO))
+                    _log.info("Service " + type + " loaded");
+                return true;
+            } else {
+                if (_log.shouldLog(Log.ERROR))
+                    _log.error("Error loading service " + type + ": not a service [" + classname + "]");
+            }
+        } catch (ClassNotFoundException cnfe) {
+            if (_log.shouldLog(Log.ERROR))
+                _log.error("Error loading service " + type + ": class " + classname + " is invalid", cnfe);
+        } catch (InstantiationException ie) {
+            if (_log.shouldLog(Log.ERROR))
+                _log.error("Error instantiating service " + type + ": class " + classname + " could not be created", ie);
+        } catch (IllegalAccessException iae) {
+            if (_log.shouldLog(Log.ERROR))
+                _log.error("Error creating service " + type + ": class " + classname + " could not be accessed", iae);
+        }
+        return false;
+    }
+    
+    private boolean connect() {
+        Properties config = getConfig();
+        File keyFile = new File(config.getProperty(PROP_KEY_FILE, DEFAULT_KEY_FILE));
+        return _adapter.connect(config, keyFile);
+    }
+    
+    private void disconnect() {
+        _adapter.disconnect();
+    }
+    
+    private void startServices() {
+        for (Iterator iter = _services.values().iterator(); iter.hasNext(); ) {
+            Service service = (Service)iter.next();
+            service.startup();
+        }
+    }
+    private void stopServices() {
+        for (Iterator iter = _services.values().iterator(); iter.hasNext(); ) {
+            Service service = (Service)iter.next();
+            service.shutdown();
+        }
+    }
+    
+    void handleMessage(MyI2PMessage msg) {
+        Service service = (Service)_services.get(msg.getServiceType());
+        if (service == null) {
+            if (_log.shouldLog(Log.ERROR))
+                _log.error("Message received for an unknown service [" 
+                           + msg.getServiceType() + "] from " 
+                           + msg.getPeer().calculateHash().toBase64());
+        } else {
+            service.receiveMessage(msg);
+        }
+    }
+}

apps/myi2p/java/src/net/i2p/myi2p/NodeAdapter.java

@@ -0,0 +1,178 @@
+package net.i2p.myi2p;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.FileInputStream;
+import java.io.IOException;
+
+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.I2PSessionListener;
+import net.i2p.client.I2PSessionException;
+import net.i2p.client.datagram.I2PDatagramDissector;
+import net.i2p.client.datagram.I2PDatagramMaker;
+import net.i2p.client.datagram.I2PInvalidDatagramException;
+import net.i2p.data.DataFormatException;
+import net.i2p.data.Destination;
+import net.i2p.util.Log;
+
+/**
+ * Bind the MyI2P node to the I2P network, handling messages, sessions,
+ * etc.
+ *
+ */
+public class NodeAdapter implements I2PSessionListener {
+    private I2PAppContext _context;
+    private Log _log;
+    private Node _node;
+    private I2PSession _session;
+    
+    public NodeAdapter(I2PAppContext context, Node node) {
+        _node = node;
+        _context = context;
+        _log = context.logManager().getLog(NodeAdapter.class);
+    }
+    
+    boolean sendMessage(MyI2PMessage msg) {
+        if (_session == null) {
+            if (_log.shouldLog(Log.ERROR))
+                _log.error("Cannot send the message, as we are not connected");
+            return false;
+        }
+        try {
+            I2PDatagramMaker builder = new I2PDatagramMaker(_session);
+            byte dgram[] = builder.makeI2PDatagram(msg.toRawPayload());
+            return _session.sendMessage(msg.getPeer(), dgram);
+        } catch (IllegalStateException ise) {
+            if (_log.shouldLog(Log.ERROR))
+                _log.error("MyI2PMessage was not valid", ise);
+            return false;
+        } catch (I2PSessionException ise) {
+            if (_log.shouldLog(Log.ERROR))
+                _log.error("Error sending to the peer", ise);
+            return false;
+        }
+    }
+    
+    /**
+     * Connect to the network using the current I2CP config and the private 
+     * key file specified in the node config.  If the file does not exist, a new 
+     * destination will be created.
+     *
+     * @param config MyI2P node and I2CP configuration
+     * @param keyFile file to load the private keystream from (if it doesn't 
+     *                exist, a new one will be created and stored at that location)
+     *
+     * @return true if connection was successful, false otherwise
+     */
+    boolean connect(Properties config, File keyFile) {
+        I2PClient client = I2PClientFactory.createClient();
+        if (!keyFile.exists()) {
+            File parent = keyFile.getParentFile();
+            if (parent != null) parent.mkdirs();
+            FileOutputStream fos = null;
+            try {
+                fos = new FileOutputStream(keyFile);
+                Destination dest = client.createDestination(fos);
+                if (_log.shouldLog(Log.INFO))
+                    _log.info("New destination created [" 
+                              + dest.calculateHash().toBase64() 
+                              + "] with keys at " + keyFile);
+            } catch (IOException ioe) {
+                if (_log.shouldLog(Log.ERROR))
+                    _log.error("Error writing new keystream to " + keyFile, ioe);
+                return false;
+            } catch (I2PException ie) {
+                if (_log.shouldLog(Log.ERROR))
+                    _log.error("Internal error creating new destination", ie);
+                return false;
+            } finally {
+                if (fos != null) try { fos.close(); } catch (IOException ioe) {}
+            }
+        }
+        
+        FileInputStream fis = null;
+        try {
+            fis = new FileInputStream(keyFile);
+            _session = client.createSession(fis, config);
+            if (_session == null) {
+                _log.error("wtf, why did it create a null session?");
+                return false;
+            }
+            _session.setSessionListener(this);
+            _session.connect();
+            if (_log.shouldLog(Log.INFO))
+                _log.info("I2P session created");
+            return true;
+        } catch (IOException ioe) {
+            if (_log.shouldLog(Log.ERROR))
+                _log.error("Unable to read the keystream from " + keyFile, ioe);
+            return false;
+        } catch (I2PSessionException ise) {
+            if (_log.shouldLog(Log.ERROR))
+                _log.error("Unable to connect to the router", ise);
+            return false;
+        } finally {
+            if (fis != null) try { fis.close(); } catch (IOException ioe) {}
+        }
+    }
+    
+    void disconnect() {
+        if (_session != null) {
+            try {
+                _session.destroySession();
+            } catch (I2PSessionException ise) {
+                if (_log.shouldLog(Log.WARN))
+                    _log.warn("Error destroying the session in shutdown", ise);
+            }
+            _session = null;
+        }
+    }
+    
+    public void disconnected(I2PSession session) {
+        if (_log.shouldLog(Log.INFO))
+            _log.info("Session disconnected");
+    }
+    
+    public void errorOccurred(I2PSession session, String message, Throwable error) {
+        if (_log.shouldLog(Log.ERROR))
+            _log.error("Session error occurred - " + message, error);
+    }
+    
+    public void messageAvailable(I2PSession session, int msgId, long size) {
+        if (_log.shouldLog(Log.INFO))
+            _log.info("message available [" + msgId + "/"+ size + " bytes]");
+        
+        try {
+            byte data[] = session.receiveMessage(msgId);
+            I2PDatagramDissector dissector = new I2PDatagramDissector();
+            dissector.loadI2PDatagram(data);
+            try {
+                MyI2PMessage msg = new MyI2PMessage(dissector.getSender(), dissector.getPayload());
+                _node.handleMessage(msg);
+            } catch (IllegalArgumentException iae) {
+                if (_log.shouldLog(Log.ERROR))
+                    _log.error("Message is a valid datagram but invalid MyI2P message", iae);
+            }
+        } catch (I2PSessionException ise) {
+            if (_log.shouldLog(Log.ERROR))
+                _log.error("Error retrieving message payload for message " + msgId, ise);
+        } catch (I2PInvalidDatagramException iide) {
+            if (_log.shouldLog(Log.ERROR))
+                _log.error("Message received was not a valid repliable datagram", iide);
+        } catch (DataFormatException dfe) {
+            if (_log.shouldLog(Log.ERROR))
+                _log.error("Message received was a corrupt repliable datagram", dfe);
+        }
+    }
+    
+    public void reportAbuse(I2PSession session, int severity) {
+        if (_log.shouldLog(Log.INFO))
+            _log.info("abuse occurred");
+    }
+}

apps/myi2p/java/src/net/i2p/myi2p/Service.java

@@ -0,0 +1,35 @@
+package net.i2p.myi2p;
+
+import java.util.Properties;
+import net.i2p.I2PAppContext;
+
+/**
+ * Defines a service that can operate within a MyI2P node, responding to 
+ * messages and performing whatever tasks are necessary.
+ *
+ */
+public interface Service {
+    /** what type of message will this service respond to? */
+    public String getType();
+    public void setType(String type);
+    
+    /** what node is this service hooked into */
+    public Node getNode();
+    public void setNode(Node node);
+    
+    /** what options specific to this node does the service have? */
+    public Properties getOptions();
+    public void setOptions(Properties opts);
+    
+    /** give the service a scope */
+    public I2PAppContext getContext();
+    public void setContext(I2PAppContext context);
+    
+    /** called when a message is received for the service */
+    public void receiveMessage(MyI2PMessage msg);
+    
+    /** start the service up - the node is ready */
+    public void startup();
+    /** shut the service down - the node is going offline */
+    public void shutdown();
+}

apps/myi2p/java/src/net/i2p/myi2p/ServiceImpl.java

@@ -0,0 +1,36 @@
+package net.i2p.myi2p;
+
+import java.util.Properties;
+
+import net.i2p.I2PAppContext;
+import net.i2p.myi2p.Service;
+import net.i2p.myi2p.Node;
+import net.i2p.myi2p.MyI2PMessage;
+
+/**
+ * Base service implementation
+ *
+ */
+public abstract class ServiceImpl implements Service {
+    private I2PAppContext _context;
+    private Node _node;
+    private Properties _options;
+    private String _serviceType;
+    
+    public ServiceImpl() {
+        _context = null;
+        _node = null;
+        _options = null;
+        _serviceType = null;
+    }
+    
+    // base inspectors / mutators
+    public Node getNode() { return _node; }
+    public void setNode(Node node) { _node = node; }
+    public I2PAppContext getContext() { return _context; }
+    public void setContext(I2PAppContext context) { _context = context; }
+    public Properties getOptions() { return _options; }
+    public void setOptions(Properties opts) { _options = opts; }
+    public String getType() { return _serviceType; }
+    public void setType(String type) { _serviceType = type; }
+}