0.3.4.1, backwards compatible, release later today, blah blah blah

only relevent to simulations, obviously

apps/bogobot/.cvsignore

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

apps/bogobot/Bogobot.java

@@ -0,0 +1,214 @@
+/*
+ * bogobot - A simple join/part stats logger bot for I2P IRC.
+ * 
+ * Bogobot.java
+ * 2004 The I2P Project
+ * This code is public domain.
+ */
+
+import java.io.File;
+import java.io.IOException;
+
+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.4 Implement java.util.Properties for configuration.
+ * TODO 0.4 Add NickServ interface.
+ * TODO 0.5 Add multi-server capability.
+ * 
+ * @author hypercubus
+ * @version 0.3.1
+ */
+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);
+    /*
+     * The following will soon be moved to bogo.config and loaded via
+     * java.util.Properties when I get some time.
+     */
+    private String  _botPrimaryNick           = "somebot";
+    private String  _botSecondaryNick         = "somebot_";
+    private String  _botShutdownPassword      = "take off eh";
+    private long    _commandAntiFloodInterval = 60;
+    private String  _ircChannel               = "#i2p-chat";
+    private String  _ircServer                = "irc.duck.i2p";
+    private int     _ircServerPort            = 6668;
+    private boolean _isLoggerEnabled          = true;
+    private boolean _isUserlistCommandEnabled = true;
+    private String  _logFilePrefix            = "irc.duck.i2p.i2p-chat";
+    private String  _logFileRotationInterval  = INTERVAL_DAILY;
+    private String  _ownerPrimaryNick         = "somenick";
+    private String  _ownerSecondaryNick       = "somenick_";
+    private String  _userlistCommandTrigger   = "!who";
+
+    public Bogobot() {
+        this.setName(_botPrimaryNick);
+    }
+
+    public static void main(String[] args) {
+
+        Bogobot bogobot = new Bogobot();
+
+        bogobot.setVerbose(true);
+
+        if (bogobot._isLoggerEnabled)
+            bogobot.initLogger();
+
+        bogobot.connectToServer();
+    }
+
+    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 (sender.equals(this.getName())) {
+
+            if (_isLoggerEnabled)
+                _logger.info(System.currentTimeMillis() + " joins *** " + _botPrimaryNick + " ***");
+
+        } else {
+
+            if (_isLoggerEnabled)
+                _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)
+            _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) {
+
+        if (_isLoggerEnabled)
+            _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);
+    }
+
+    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,352 @@
+/*
+ * bogoparser - A simple logfile analyzer for bogobot.
+ * 
+ * Bogoparser.java
+ * 2004 The I2P Project
+ * 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.3.1
+ */
+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/bogo.config

@@ -0,0 +1,70 @@
+#####
+# Bogobot user configuration (This file is not yet used.)
+#####
+
+###
+# 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 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
+
+###
+# 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 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.bat

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

apps/bogobot/bogobot.sh

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

apps/bogobot/build.xml

@@ -0,0 +1,63 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!-- ********************************************************** -->
+<!-- bogobot - A simple join/part stats logger bot for I2P IRC. -->
+<!--                                                            -->
+<!-- build.xml                                                  -->
+<!-- 2004 The I2P Project                                       -->
+<!-- This code is public domain.                                -->
+<!--                                                            -->
+<!-- author hypercubus                                          -->
+<!-- version 0.3.1                                              -->
+<!-- ********************************************************** -->
+
+<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}" source="1.4" srcdir="." />
+    </target>
+
+    <!-- dist.bin:
+    Create the binary distribution archive -->
+    <target depends="init,compile" description="Create the binary distribution archive" name="dist.bin">
+        <zip destfile="dist/Bogobot_${DSTAMP}.zip">
+            <zipfileset dir="${basedir}" includes="bogobot.bat Bogobot.class bogobot.sh Bogoparser.class LICENSE_log4j.txt LICENSE_pircbot.txt log4j-1.2.8.jar pircbot.jar" />
+        </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.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_eclipse.xml

@@ -0,0 +1,57 @@
+<?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                                       -->
+<!-- This code is public domain.                                -->
+<!--                                                            -->
+<!-- author hypercubus                                          -->
+<!-- version 0.3.1                                              -->
+<!-- ********************************************************** -->
+
+<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.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.java bogobot.sh Bogoparser.java build.xml build_eclipse.xml LICENSE_log4j.txt LICENSE_pircbot.txt log4j-1.2.8.jar pircbot.jar" />
+        </zip>
+    </target>
+
+    <!-- dist:
+    Create both the binary and source distribution archives -->
+    <target depends="dist.bin,dist.source" description="Create both the binary and source distribution archives" name="dist">
+        <echo message="Successfully created binary and source distribution archives in directory &apos;dist&apos;." />
+    </target>
+
+    <!-- clean:
+    Delete all class files and temporary directories -->
+    <target description="Delete all class files and temporary directories" name="clean">
+        <delete>
+            <fileset dir="${basedir}" includes="**/*.class" />
+        </delete>
+        <echo message="Clean successful." />
+    </target>
+
+</project>

apps/enclave/libsockthread/src/logger.cpp

@@ -26,13 +26,11 @@
  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $Id$
  */
 
-#include <cstdarg>
-#include <cstdio>
-#include <iostream>
-#include <string>
-using namespace std;
+#include "platform.hpp"
 #include "mutex.hpp"
 #include "time.hpp"
 #include "logger.hpp"
@@ -41,10 +39,10 @@ using namespace Libsockthread;
 /*
  * Closes the log file
  */
-void Logger::close(void)
+void Logger::close()
 {
 	logf_m.lock();
-	if (logf == 0) {
+	if (logf == NULL) {
 		logf_m.unlock();
 		return;
 	}
@@ -53,7 +51,7 @@ void Logger::close(void)
 		cerr << "fclose() failed: " << strerror(errno) << '\n';
 		cerr_m.unlock();
 	}
-	logf = 0;
+	logf = NULL;
 	logf_m.unlock();
 }
 
@@ -88,15 +86,14 @@ void Logger::log(priority_t priority, const char* format, ...)
 
 	va_list ap;
 	va_start(ap, format);
-	string s;
 	Time t;
 	logf_m.lock();
 
-	if (logf != 0) {
+	if (logf != NULL) {
 		/*
 		 * Remember!  If you change the format here, change it in the else too
 		 */
-		fprintf(logf, "%c %s ", ll, t.utc(s).c_str());
+		fprintf(logf, "%c %s ", ll, t.utc().c_str());
 		vfprintf(logf, format, ap);
 		fputc('\n', logf);
 		if (fflush(logf) == EOF) {
@@ -106,7 +103,7 @@ void Logger::log(priority_t priority, const char* format, ...)
 		}
 	} else {
 		// if they don't have an open log file, just use stderr
-		fprintf(stderr, "%c %s ", ll, t.utc(s).c_str());
+		fprintf(stderr, "%c %s ", ll, t.utc().c_str());
 		vfprintf(stderr, format, ap);
 		fputc('\n', stderr);
 	}
@@ -118,8 +115,8 @@ void Logger::log(priority_t priority, const char* format, ...)
 }
 
 /*
- * Opens a log file for appending.  If there already is an open log file, then
- * it is closed and the new one is opened.
+ * Opens a log file for appending.  If a log file is already open, then it is
+ * closed and the new one is opened.
  *
  * file - file location to open
  */
@@ -145,8 +142,8 @@ bool Logger::open(const string& file)
 // g++ -Wall -c mutex.cpp -o mutex.o
 // g++ -Wall -c time.cpp -o time.o
 // g++ -Wall -DUNIT_TEST -c logger.cpp -o logger.o
-// g++ -Wall -DUNIT_TEST logger.o mutex.o thread.o time.o -o logger -lpthread
-int main(void)
+// g++ -Wall -DUNIT_TEST logger.o mutex.o thread.o time.o -o logger -pthread
+int main()
 {
 	Logger logger;
 

apps/enclave/libsockthread/src/logger.hpp

@@ -26,6 +26,8 @@
  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $Id$
  */
 
 #ifndef LIBSOCKTHREAD_LOGGER_HPP
@@ -40,8 +42,7 @@
  * LWARN - errors we automatically recover from
  * LERROR - major, important errors
  *
- * Obviously, these only work if your Logger object is called "logger" and is
- * global
+ * These only work if your Logger object is called "logger"
  */
 // Prints out the file name, function name, and line number before the message
 #define LDEBUG(format, ...) logger.log(Logger::DEBUG, "%s:%s:%d:" \
@@ -69,16 +70,17 @@
 namespace Libsockthread {
 	class Logger {
 		public:
-			typedef enum {DEBUG = 0, MINOR = 1, INFO = 2, WARN = 3, ERROR = 4}
-				priority_t;
+			enum priority_t {DEBUG = 0, MINOR = 1, INFO = 2, WARN = 3,
+				ERROR = 4};
 
-			Logger(void)
-				: logf(0), loglevel(Logger::DEBUG) { }
-			~Logger(void) { close(); }
+			Logger()
+				: logf(NULL), loglevel(Logger::DEBUG) { }
+			~Logger()
+				{ close(); }
 
-			void close(void);
+			void close();
 			void log(priority_t priority, const char* format, ...);
-			priority_t get_loglevel(void)
+			priority_t get_loglevel()
 				{ loglevel_m.lock(); priority_t ll = loglevel;
 					loglevel_m.unlock(); return ll; }
 			bool open(const string& file);

apps/enclave/libsockthread/src/mutex.cpp

@@ -26,31 +26,28 @@
  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $Id$
  */
 
-// Modelled after JThread by Jori Liesenborgs
+/*
+ * Modelled after JThread by Jori Liesenborgs
+ */
 
-#include <cassert>
 #include "platform.hpp"
-#ifdef WINTHREAD
-	#include <windows.h>
-#else
-	#include <pthread.h>
-#endif
-using namespace std;
 #include "mutex.hpp"
 using namespace Libsockthread;
 
 /*
  * Creates a mutex
  */
-Mutex::Mutex(void)
+Mutex::Mutex()
 {
 #ifdef WINTHREAD
-	mutex = CreateMutex(0, false, 0);
-	assert(mutex != 0);
+	mutex = CreateMutex(NULL, false, NULL);
+	assert(mutex != NULL);
 #else
-	int rc = pthread_mutex_init(&mutex, 0);
+	int rc = pthread_mutex_init(&mutex, NULL);
 	assert(rc == 0);
 #endif
 }
@@ -58,7 +55,7 @@ Mutex::Mutex(void)
 /*
  * Destroys a mutex
  */
-Mutex::~Mutex(void)
+Mutex::~Mutex()
 {
 #ifdef WINTHREAD
 	BOOL rc = CloseHandle(mutex);
@@ -72,7 +69,7 @@ Mutex::~Mutex(void)
 /*
  * Locks the mutex
  */
-void Mutex::lock(void)
+void Mutex::lock()
 {
 #ifdef WINTHREAD
 	DWORD rc = WaitForSingleObject(mutex, INFINITE);
@@ -86,7 +83,7 @@ void Mutex::lock(void)
 /*
  * Unlocks the mutex
  */
-void Mutex::unlock(void)
+void Mutex::unlock()
 {
 #ifdef WINTHREAD
 	BOOL rc = ReleaseMutex(mutex);
@@ -100,13 +97,12 @@ void Mutex::unlock(void)
 #ifdef UNIT_TEST
 // g++ -Wall -c thread.cpp -o thread.o
 // g++ -Wall -DUNIT_TEST -c mutex.cpp -o mutex.o
-// g++ -Wall -DUNIT_TEST mutex.o thread.o -o mutex -lpthread
-#include <iostream>
+// g++ -Wall -DUNIT_TEST mutex.o thread.o -o mutex -pthread
 #include "thread.hpp"
 
 Mutex widget;
 
-int main(void)
+int main()
 {
 	class Mutex_test : public Thread
 	{
@@ -114,7 +110,7 @@ int main(void)
 			Mutex_test(int n)
 				: testval(n) {}
 
-			void* thread(void)
+			void* thread()
 			{
 				widget.lock();
 				cout << "I got it!  thread #" << testval << '\n';
@@ -122,9 +118,11 @@ int main(void)
 				// widget, since it is never unlocked
 				return 0;
 			}
+
 		private:
 			int testval;
 	};
+
 	Mutex_test t1(1);
 	Mutex_test t2(2);
 	Mutex_test t3(3);

apps/enclave/libsockthread/src/mutex.hpp

@@ -26,9 +26,13 @@
  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $Id$
  */
 
-// Modelled after JThread by Jori Liesenborgs
+/*
+ * Modelled after JThread by Jori Liesenborgs
+ */
 
 #ifndef LIBSOCKTHREAD_MUTEX_HPP
 #define LIBSOCKTHREAD_MUTEX_HPP
@@ -36,11 +40,11 @@
 namespace Libsockthread {
 	class Mutex {
 		public:
-			Mutex(void);
-			~Mutex(void);
+			Mutex();
+			~Mutex();
 
-			void lock(void);
-			void unlock(void);
+			void lock();
+			void unlock();
 		private:
 #ifdef WINTHREAD
 			HANDLE mutex;

apps/enclave/libsockthread/src/platform.hpp

@@ -26,6 +26,14 @@
  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $Id: platform.hpp,v 1.5 2004/07/22 03:54:01 mpc Exp $
+ */
+
+/*
+ * Global includes and platform configuration.  This is used to compile the
+ * library, but is not intended for use by users of the library in their
+ * own programs.
  */
 
 #ifndef LIBSOCKTHREAD_PLATFORM_HPP
@@ -34,30 +42,36 @@
 /*
  * Operating system
  */
-#define FREEBSD	0  // FreeBSD (untested)
-#define MINGW	1  // Windows native (Mingw)
+#define FREEBSD	0  // FreeBSD
+#define WIN32	1  // Windows
 #define LINUX	2  // Linux
-#define CYGWIN	3  // Cygwin
 
-#if OS == MINGW
-	#define INET_ADDRSTRLEN 16
-	#define NO_GETHOSTBYNAME2
-	#define NO_INET_ATON  /* implies NO_INET_PTON */
-	#define NO_INET_NTOP
+#if OS == WIN32
 	#define WINSOCK
 	#define WINTHREAD
 #endif
 
-#if OS == LINUX
-	#define NO_GETHOSTBYNAME2
+#ifndef WINSOCK
+	#include <arpa/inet.h>
 #endif
-
-#if OS == CYGWIN
-	#define FAST32_IS_LONG
-	#define INET_ADDRSTRLEN 16
-	#define NO_GETHOSTBYNAME2
-	#define NO_INET_NTOP
-	#define NO_INET_PTON
+#include <cassert>
+#include <cstdarg>
+#include <cstddef>
+#include <cstdio>
+#include <ctime>
+#include <iostream>
+#ifndef WINSOCK
+	#include <netdb.h>
 #endif
+#ifndef WINTHREAD
+	#include <pthread.h>
+#endif
+#include <stdint.h>  // TODO replace with Boost's version
+#include <string>
+#if defined WINSOCK || defined WINTHREAD
+	#include <windows.h>
+#endif
+using namespace std;
+#include "types.hpp"
 
 #endif  // LIBSOCKTHREAD_PLATFORM_HPP

apps/enclave/libsockthread/src/socket.cpp

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

apps/enclave/libsockthread/src/socket.hpp

@@ -26,38 +26,42 @@
  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $Id: socket.hpp,v 1.8 2004/07/22 22:08:20 mpc Exp $
  */
 
 #ifndef LIBSOCKTHREAD_SOCKET_HPP
 #define LIBSOCKTHREAD_SOCKET_HPP
 
 namespace Libsockthread {
-	class Socket_error : public runtime_error {
-		public:
-			Socket_error(const string& s)
-				: runtime_error(s) { }
-	};
 	class Socket {
 		public:
-			Socket(void);  // throws Socket_error
-			Socket(int domain, int type);  // throws Socket_error
-			~Socket(void);
+			#ifdef WINSOCK
+				typedef SOCKET socket_t;
+				enum { SERR = SOCKET_ERROR };
+			#else
+				typedef int socket_t;
+				enum { SERR = -1 };
+			#endif
 
-			void close(void);
+			Socket()
+				: addr(), sock(SERR) {}
+			Socket(Socket_addr& addr)  // throws Socket_error
+				: addr(addr), sock(SERR) { setup_socket(); }
+
+			void close();
+			size_t read(vector<uchar_t>& buf, size_t max = 0);
+			size_t read_until(vector<uchar_t>& buf, uchar_t delim = '\n');
+			void set_addr(Socket_addr& addr);  // throws Socket_error
+			void set_blocking(bool blocking);
+			size_t write(vector<uchar_t>& buf);
+			void write_all(vector<uchar_t>& buf);
+			size_t write_until(vector<uchar_t& buf, uchar_t delim = '\n');
 		private:
-#ifdef WINSOCK
-			typedef SOCKET socket_t;
-
-			void winsock_cleanup(void);
-			void winsock_startup(void);  // throws Socket_error
-			const char* winsock_strerror(int code);
-#else
-			typedef int socket_t;
-#endif
-			void create_socket(int domain, int type);  // throws Socket_error
+			void setup_socket();  // throws Socket_error
 
+			Socket_addr addr;
 			socket_t sock;
-			static size_t total;  // the total number of sockets in memory
 	};
 }
 

apps/enclave/libsockthread/src/socket_addr.cpp

@@ -26,58 +26,83 @@
  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $Id: socket_addr.cpp,v 1.4 2004/07/22 19:10:59 mpc Exp $
  */
 
-#include <arpa/inet.h>
-#include <cassert>
-using namespace std;
 #include "platform.hpp"
-#include "socket.hpp"
+#include "socket_error.hpp"
 #include "socket_addr.hpp"
 using namespace Libsockthread;
 
-Socket_addr::Socket_addr(int domain, const string& host, uint16_t port)
-	: domain(domain), host(host), port(port)
+Socket_addr::Socket_addr(Socket_addr& rhs)
 {
-	memset(&hostaddr, 0, sizeof hostaddr);
-	hostaddr.sin_family = domain;
-	hostaddr.sin_port = htons(port);
-	resolve(host.c_str(), ipaddr);
-	int rc;
-#ifdef NO_INET_ATON
-	rc = hostaddr.sin_addr.s_addr = inet_addr(ipaddr);
-#elif defined NO_INET_PTON
-	rc = inet_aton(ipaddr, &hostaddr.sin_addr);
-#else
-	rc = inet_pton(AF_INET, ipaddr, &hostaddr.sin_addr);
-#endif
-	assert(rc != 0 && rc != -1);
+	delete[] ip;
+	if (rhs.resolved) {
+		if (rhs.family == AF_INET) {
+			ip = new char[INET_ADDRSTRLEN];
+		else
+			ip = new char[INET6_ADDRSTRLEN];
+		strcpy(ip, rhs.ip);
+	}
+	family = rhs.family;
+	host = rhs.host;
+	port = rhs.port;
+	resolved = rhs.resolved;
+	type = rhs.type;
+}
+
+Socket_addr& Socket_addr::operator=(const Socket_addr& rhs)
+{
+	if (this == &rhs)  // check for self-assignment: a = a
+		return *this;
+
+	delete[] ip;
+	if (rhs.resolved) {
+		if (rhs.family == AF_INET)
+			ip = new char[INET_ADDRSTRLEN];
+		else
+			ip = new char[INET6_ADDRSTRLEN];
+		strcpy(ip, rhs.ip);
+	}
+	family = rhs.family;
+	host = rhs.host;
+	port = rhs.port;
+	type = rhs.type;
+
+	return *this;
 }
 
 /*
- * Performs a DNS lookup on `hostname' and puts the result in `ipaddr'
+ * Performs a DNS lookup
  */
-bool Socket::resolve(const char* hostname, char* ipaddr)
+void Socket_addr::resolve()
 {
-	struct hostent *h;
-#ifdef NO_GETHOSTBYNAME2
-	h = gethostbyname(hostname);
-#else
-	h = gethostbyname2(hostname, domain);
-#endif
-	if (h == 0) {
-		LWARN("DNS resolution failed for %s", hostname);
-		throw Socket_error("DNS resolution failed");
-	}
-	struct in_addr a;
-	a.s_addr = ((struct in_addr *)h->h_addr)->s_addr;
-#ifdef NO_INET_NTOP
-	char *tmp;
-	tmp = inet_ntoa(a);
-	assert(tmp != 0);
-	strlcpy(ipaddr, tmp, INET_ADDRSTRLEN);  // inet_ntoa() was very poorly designed
-#else
-	int rc = inet_ntop(domain, &a, ipaddr, INET_ADDRSTRLEN);
-	assert(rc != 0);
-#endif
+	resolved = false;  // in case they already had a host name but just set a
+					   // new one with set_host()
+	hostent* hent = gethostbyname(host.c_str());
+	if (hent == NULL)
+		throw Dns_error(hstrerror(h_errno));
+	assert(hent->h_addrtype == AF_INET || hent->h_addrtype == AF_INET6);
+	family = hent->h_addrtype;
+	delete[] ip;
+	if (family == AF_INET) {
+		ip = new char[INET_ADDRSTRLEN];
+	else
+		ip = new char[INET6_ADDRSTRLEN];
+	strcpy(ip, hent->h_addr_list[0]);
+	resolved = true;
+}
+
+bool Socket_addr::operator==(const Socket_addr& rhs)
+{
+	if (rhs.family == family
+			&& rhs.host == host
+			&& strcmp(rhs.ip, ip) == 0
+			&& rhs.port == port
+			&& rhs.resolved == resolved
+			&& rhs.type == type)
+		return true;
+	else
+		return false;
 }

apps/enclave/libsockthread/src/socket_addr.hpp

@@ -26,6 +26,8 @@
  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $Id: socket_addr.hpp,v 1.4 2004/07/22 19:10:59 mpc Exp $
  */
 
 #ifndef LIBSOCKTHREAD_SOCKET_ADDR_HPP
@@ -34,15 +36,42 @@
 namespace Libsockthread {
 	class Socket_addr {
 		public:
-			Socket_addr(int domain, const string& host, uint16_t port);
-		private:
-			bool resolve(const char* hostname, char* ipaddr);
+			Socket_addr()
+				: family(AF_INET), resolved(false) { }
+			Socket_addr(Socket_addr& rhs);
+			Socket_addr(int type, string& host, uint16_t port)
+				: family(AF_INET), host(host), type(type), port(port)
+				{ resolve(); }  // throws Dns_error
+			~Socket_addr()
+				{ delete[] ip; }
 
-			int domain;  // PF_INET or PF_INET6
+			int get_family() const
+				{ return family; }
+			const char* get_ip() const  // Warning!  This can be NULL!
+				{ return ip; }
+			uint16_t get_port() const
+				{ return port; }
+			int get_type() const
+				{ return type;
+			bool is_ready() const
+				{ return resolved; }
+			Socket_addr& operator=(const Socket_addr& rhs);
+			bool operator==(const Socket_addr& rhs);
+			void set_host(string& host)  // throws Dns_error
+				{ this->host = host; resolve(); }
+			void set_port(uint16_t port)
+				{ this->port = port; }
+			void set_type(int type)
+				{ this->type = type; }
+		private:
+			void resolve();  // throws Dns_error
+
+			int family;  // AF_INET or AF_INET6
 			string host;
-			char ipaddr[INET_ADDRSTRLEN];
-			struct sockaddr_in hostaddr;
+			char* ip;
 			uint16_t port;
+			bool resolved;
+			int type;  // SOCK_STREAM or SOCK_DGRAM
 	};
 }
 

apps/enclave/libsockthread/src/socket_connector.cpp

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

apps/enclave/libsockthread/src/socket_connector.hpp

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

apps/enclave/libsockthread/src/socket_error.hpp

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

apps/enclave/libsockthread/src/socket_listener.cpp

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

apps/enclave/libsockthread/src/socket_listener.hpp

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

apps/enclave/libsockthread/src/strl.c

@@ -12,6 +12,8 @@
  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * $Id$
  */
 
 #include <stddef.h>

apps/enclave/libsockthread/src/strl.h

@@ -26,6 +26,8 @@
  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $Id$
  */
 
 /*

apps/enclave/libsockthread/src/thread.cpp

@@ -26,18 +26,15 @@
  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $Id$
  */
 
-// Modelled after JThread by Jori Liesenborgs
+/*
+ * Modelled after JThread by Jori Liesenborgs
+ */
 
-#include <cassert>
 #include "platform.hpp"
-#ifdef WINTHREAD
-	#include <windows.h>
-#else
-	#include <pthread.h>
-#endif
-using namespace std;
 #include "mutex.hpp"
 #include "thread.hpp"
 using namespace Libsockthread;
@@ -45,12 +42,12 @@ using namespace Libsockthread;
 /*
  * Gets the return value of a finished thread
  */
-void* Thread::get_retval(void)
+void* Thread::get_retval()
 {
 	void* val;
 	running_m.lock();
 	if (running)
-		val = 0;
+		val = NULL;
 	else
 		val = retval;
 	running_m.unlock();
@@ -60,7 +57,7 @@ void* Thread::get_retval(void)
 /*
  * Checks whether the thread is running
  */
-bool Thread::is_running(void)
+bool Thread::is_running()
 {
 	running_m.lock();
 	bool r = running;
@@ -72,7 +69,7 @@ bool Thread::is_running(void)
  * Stops the thread
  * Generally NOT a good idea
  */
-void Thread::kill(void)
+void Thread::kill()
 {
 	running_m.lock();
 #ifndef NDEBUG
@@ -83,7 +80,7 @@ void Thread::kill(void)
 	}
 #endif
 #ifdef WINTHREAD
-	BOOL rc = TerminateThread(handle, 0);
+	BOOL rc = TerminateThread(handle, NULL);
 	assert(rc);
 #else
 	int rc = pthread_cancel(id);
@@ -96,7 +93,7 @@ void Thread::kill(void)
 /*
  * Starts the thread
  */
-void Thread::start(void)
+void Thread::start()
 {
 #ifndef NDEBUG
 	// check whether the thread is already running
@@ -106,8 +103,8 @@ void Thread::start(void)
 #endif
 	continue_m.lock();
 #ifdef WINTHREAD
-	handle = CreateThread(0, 0, &the_thread, this, 0, &id);
-	assert(handle != 0);
+	handle = CreateThread(NULL, 0, &the_thread, this, 0, &id);
+	assert(handle != NULL);
 #else
 	int rc = pthread_create(&id, 0, &the_thread, this);
 	assert(rc == 0);
@@ -145,10 +142,8 @@ void* Thread::the_thread(void *param)
 #ifdef UNIT_TEST
 // g++ -Wall -c mutex.cpp -o mutex.o
 // g++ -Wall -DUNIT_TEST -c thread.cpp -o thread.o
-// g++ -Wall -DUNIT_TEST mutex.o thread.o -o thread -lpthread
-#include <iostream>
-
-int main(void)
+// g++ -Wall -DUNIT_TEST mutex.o thread.o -o thread -pthread
+int main()
 {
 	class Thread_test : public Thread
 	{
@@ -156,15 +151,14 @@ int main(void)
 			Thread_test(int testval)
 				: testval(testval) { }
 
-			int get_testval(void)
+			int get_testval()
 			{
 				testval_m.lock();
 				int rc = testval;
 				testval_m.unlock();
 				return rc;
 			}
-
-			void *thread(void)
+			void *thread()
 			{
 				// just do something
 				while (true) {
@@ -174,6 +168,7 @@ int main(void)
 				}
 				return 0;
 			}
+
 		private:
 			int testval;
 			Mutex testval_m;

apps/enclave/libsockthread/src/thread.hpp

@@ -26,9 +26,13 @@
  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $Id$
  */
 
-// Modelled after JThread by Jori Liesenborgs
+/*
+ * Modelled after JThread by Jori Liesenborgs
+ */
 
 #ifndef LIBSOCKTHREAD_THREAD_HPP
 #define LIBSOCKTHREAD_THREAD_HPP
@@ -36,16 +40,16 @@
 namespace Libsockthread {
 	class Thread {
 		public:
-			Thread(void)
-				: retval(0), running(false) { }
-			virtual ~Thread(void)
+			Thread()
+				: retval(NULL), running(false) { }
+			virtual ~Thread()
 				{ kill(); }
 
-			void* get_retval(void);
-			bool is_running(void);
-			void kill(void);
-			void start(void);
-			virtual void *thread(void) = 0;
+			void* get_retval();
+			bool is_running();
+			void kill();
+			void start();
+			virtual void* thread() = 0;
 		private:
 #ifdef WINTHREAD
 			static DWORD WINAPI the_thread(void* param);
@@ -56,7 +60,7 @@ namespace Libsockthread {
 			pthread_t id;
 #endif
 			Mutex continue_m;
-			void *retval;
+			void* retval;
 			bool running;
 			Mutex running_m;
 	};

apps/enclave/libsockthread/src/time.cpp

@@ -26,68 +26,59 @@
  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $Id$
  */
 
-#include <ctime>
-#include <string>
-using namespace std;
+#include "platform.hpp"
 #include "time.hpp"
 using namespace Libsockthread;
 
 /*
- * Converts the time to an ISO 8601 standard time and date and puts it in a
- * string
+ * Converts the time to an ISO 8601 standard date and time
  * Example: 2004-07-01T19:03:47Z
  */
-string& Time::utc(string &s) const
+string& Time::utc()
 {
-	struct tm* tm;
-
-	tm = gmtime(&unixtime);
+	struct tm* tm = gmtime(&unixtime);
 	char t[21];
 	strftime(t, sizeof t, "%Y-%m-%dT%H:%M:%SZ", tm);
-	return s = t;
+	return formatted = t;
 }
 
 /*
- * Converts the time to an ISO 8601 standard date and puts it in a string
+ * Converts the time to an ISO 8601 standard date
  * Example: 2004-07-01Z
  */
-string& Time::utc_date(string &s) const
+string& Time::utc_date()
 {
-	struct tm* tm;
-
-	tm = gmtime(&unixtime);
+	struct tm* tm = gmtime(&unixtime);
 	char t[12];
 	strftime(t, sizeof t, "%Y-%m-%dZ", tm);
-	return s = t;
+	return formatted = t;
 }
 
 /*
- * Converts the time to an ISO 8601 standard time and puts it in a string
+ * Converts the time to an ISO 8601 standard time
  * Example: 19:03:47Z
  */
-string& Time::utc_time(string &s) const
+string& Time::utc_time()
 {
-	struct tm* tm;
-
-	tm = gmtime(&unixtime);
+	struct tm* tm = gmtime(&unixtime);
 	char t[10];
 	strftime(t, sizeof t, "%H:%M:%SZ", tm);
-	return s = t;
+	return formatted = t;
 }
 
 #ifdef UNIT_TEST
 // g++ -Wall -DUNIT_TEST time.cpp -o time
-#include <iostream>
-
-int main(void)
+int main()
 {
 	Time t;
-	string s;
-	cout << "Current date and time is " << t.utc(s) << '\n';
-	cout << "Current date is " << t.utc_date(s) << '\n';
-	cout << "Current time is " << t.utc_time(s) << '\n';
+	cout << "Current date and time is " << t.utc() << '\n';
+	cout << "Current date is " << t.utc_date() << '\n';
+	cout << "Current time is " << t.utc_time() << '\n';
+	cout << "Formatted time is " << t.get_formatted() << " (should be the same)\n";
 
 	return 0;
 }

apps/enclave/libsockthread/src/time.hpp

@@ -26,6 +26,8 @@
  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $Id$
  */
 
 #ifndef LIBSOCKTHREAD_TIME_HPP
@@ -34,13 +36,18 @@
 namespace Libsockthread {
 	class Time {
 		public:
-			Time(void) { now(); }
+			Time()
+				{ now(); }
 
-			void now(void) { unixtime = time(0); }
-			string& utc(string &s) const;
-			string& utc_date(string &s) const;
-			string& utc_time(string &s) const;
+			string& get_formatted()
+				{ return formatted; }
+			void now()
+				{ unixtime = time(0); }
+			string& utc();
+			string& utc_date();
+			string& utc_time();
 		private:
+			string formatted;
 			time_t unixtime;
 	};
 }

apps/enclave/libsockthread/src/types.hpp

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

apps/heartbeat/java/build.xml

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

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

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

apps/httptunnel/java/build.xml

@@ -11,7 +11,7 @@
         <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>

apps/i2ptunnel/java/build.xml

@@ -11,7 +11,7 @@
         <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>
@@ -22,6 +22,47 @@
                 <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" />

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

@@ -46,6 +46,7 @@ import java.util.HashSet;
 import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Properties;
 import java.util.Set;
 import java.util.StringTokenizer;
 
@@ -69,16 +70,17 @@ public class I2PTunnel implements Logging, EventDispatcher {
     private I2PAppContext _context;
     private static long __tunnelId = 0;
     private long _tunnelId;
+    private Properties _clientOptions;
 
     public static final int PACKET_DELAY = 100;
 
-    public static boolean ownDest = false;
+    public boolean ownDest = false;
 
-    public static String port = System.getProperty(I2PClient.PROP_TCP_PORT, "7654");
-    public static String host = System.getProperty(I2PClient.PROP_TCP_HOST, "127.0.0.1");
-    public static String listenHost = host;
+    public String port = System.getProperty(I2PClient.PROP_TCP_PORT, "7654");
+    public String host = System.getProperty(I2PClient.PROP_TCP_HOST, "127.0.0.1");
+    public String listenHost = host;
 
-    public static long readTimeout = -1;
+    public long readTimeout = -1;
 
     private static final String nocli_args[] = { "-nocli", "-die"};
 
@@ -104,6 +106,9 @@ public class I2PTunnel implements Logging, EventDispatcher {
         _tunnelId = ++__tunnelId;
         _log = _context.logManager().getLog(I2PTunnel.class);
         _event = new EventDispatcherImpl();
+        _clientOptions = new Properties();
+        _clientOptions.putAll(System.getProperties());
+        
         addConnectionEventListener(lsnr);
         boolean gui = true;
         boolean checkRunByE = true;
@@ -167,6 +172,8 @@ public class I2PTunnel implements Logging, EventDispatcher {
         }
     }
 
+    public Properties getClientOptions() { return _clientOptions; }
+    
     private void addtask(I2PTunnelTask tsk) {
         tsk.setTunnel(this);
         if (tsk.isOpen()) {
@@ -197,6 +204,8 @@ public class I2PTunnel implements Logging, EventDispatcher {
 
         if ("help".equals(cmdname)) {
             runHelp(l);
+        } else if ("clientoptions".equals(cmdname)) {
+            runClientOptions(args, l);
         } else if ("server".equals(cmdname)) {
             runServer(args, l);
         } else if ("textserver".equals(cmdname)) {
@@ -262,6 +271,29 @@ public class I2PTunnel implements Logging, EventDispatcher {
         l.log("list");
         l.log("run <commandfile>");
     }
+    
+    /**
+     * Configure the extra I2CP options to use in any subsequent I2CP sessions.
+     * Usage: "clientoptions[ key=value]*" .  
+     *
+     * Sets the event "clientoptions_onResult" = "ok" after completion.
+     *
+     * @param args each args[i] is a key=value pair to add to the options
+     * @param l logger to receive events and output
+     */
+    public void runClientOptions(String args[], Logging l) {
+        _clientOptions.clear();
+        if (args != null) {
+            for (int i = 0; i < args.length; i++) {
+                int index = args[i].indexOf('=');
+                if (index <= 0) continue;
+                String key = args[i].substring(0, index);
+                String val = args[i].substring(index+1);
+                _clientOptions.setProperty(key, val);
+            }
+        }
+        notifyEvent("clientoptions_onResult", "ok");
+    }
 
     /**
      * Run the server pointing at the host and port specified using the private i2p
@@ -304,7 +336,7 @@ public class I2PTunnel implements Logging, EventDispatcher {
                 notifyEvent("serverTaskId", new Integer(-1));
                 return;
             }
-            I2PTunnelServer serv = new I2PTunnelServer(serverHost, portNum, privKeyFile, args[2], l, (EventDispatcher) this);
+            I2PTunnelServer serv = new I2PTunnelServer(serverHost, portNum, privKeyFile, args[2], l, (EventDispatcher) this, this);
             serv.setReadTimeout(readTimeout);
             serv.startRunning();
             addtask(serv);
@@ -350,7 +382,7 @@ public class I2PTunnel implements Logging, EventDispatcher {
                 return;
             }
 
-            I2PTunnelServer serv = new I2PTunnelServer(serverHost, portNum, args[2], l, (EventDispatcher) this);
+            I2PTunnelServer serv = new I2PTunnelServer(serverHost, portNum, args[2], l, (EventDispatcher) this, this);
             serv.setReadTimeout(readTimeout);
             serv.startRunning();
             addtask(serv);
@@ -376,9 +408,9 @@ public class I2PTunnel implements Logging, EventDispatcher {
      */
     public void runClient(String args[], Logging l) {
         if (args.length == 2) {
-            int port = -1;
+            int portNum = -1;
             try {
-                port = Integer.parseInt(args[0]);
+                portNum = Integer.parseInt(args[0]);
             } catch (NumberFormatException nfe) {
                 l.log("invalid port");
                 _log.error(getPrefix() + "Port specified is not valid: " + args[0], nfe);
@@ -386,9 +418,15 @@ public class I2PTunnel implements Logging, EventDispatcher {
                 return;
             }
             I2PTunnelTask task;
-            task = new I2PTunnelClient(port, args[1], l, ownDest, (EventDispatcher) this);
-            addtask(task);
-            notifyEvent("clientTaskId", new Integer(task.getId()));
+            try {
+                task = new I2PTunnelClient(portNum, args[1], l, ownDest, (EventDispatcher) this, this);
+                addtask(task);
+                notifyEvent("clientTaskId", new Integer(task.getId()));
+            } catch (IllegalArgumentException iae) {
+                _log.error(getPrefix() + "Invalid I2PTunnel config to create a client [" + host + ":"+ port + "]", iae);
+                l.log("Invalid I2PTunnel configuration [" + host + ":" + port + "]");
+                notifyEvent("clientTaskId", new Integer(-1));
+            }
         } else {
             l.log("client <port> <pubkey>|file:<pubkeyfile>");
             l.log("  creates a client that forwards port to the pubkey.\n"
@@ -423,9 +461,15 @@ public class I2PTunnel implements Logging, EventDispatcher {
                 proxy = args[1];
             }
             I2PTunnelTask task;
-            task = new I2PTunnelHTTPClient(port, l, ownDest, proxy, (EventDispatcher) this);
-            addtask(task);
-            notifyEvent("httpclientTaskId", new Integer(task.getId()));
+            try {
+                task = new I2PTunnelHTTPClient(port, l, ownDest, proxy, (EventDispatcher) this, this);
+                addtask(task);
+                notifyEvent("httpclientTaskId", new Integer(task.getId()));
+            } catch (IllegalArgumentException iae) {
+                _log.error(getPrefix() + "Invalid I2PTunnel config to create an httpclient [" + host + ":"+ port + "]", iae);
+                l.log("Invalid I2PTunnel configuration [" + host + ":" + port + "]");
+                notifyEvent("httpclientTaskId", new Integer(-1));
+            }
         } else {
             l.log("httpclient <port> [<proxy>]");
             l.log("  creates a client that distributes HTTP requests.");
@@ -460,7 +504,7 @@ public class I2PTunnel implements Logging, EventDispatcher {
             }
 
             I2PTunnelTask task;
-            task = new I2PSOCKSTunnel(port, l, ownDest, (EventDispatcher) this);
+            task = new I2PSOCKSTunnel(port, l, ownDest, (EventDispatcher) this, this);
             addtask(task);
             notifyEvent("sockstunnelTaskId", new Integer(task.getId()));
         } else {
@@ -779,7 +823,7 @@ public class I2PTunnel implements Logging, EventDispatcher {
         if (allargs.length() != 0) {
             I2PTunnelTask task;
             // pings always use the main destination
-            task = new I2Ping(allargs, l, false, (EventDispatcher) this);
+            task = new I2Ping(allargs, l, false, (EventDispatcher) this, this);
             addtask(task);
             notifyEvent("pingTaskId", new Integer(task.getId()));
         } else {

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

@@ -19,8 +19,14 @@ public class I2PTunnelClient extends I2PTunnelClientBase {
     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");

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

@@ -60,8 +60,14 @@ public abstract class I2PTunnelClientBase extends I2PTunnelTask implements Runna
     //    I2PTunnelClientBase(localPort, ownDest, l, (EventDispatcher)null);
     //}
 
-    public I2PTunnelClientBase(int localPort, boolean ownDest, Logging l, EventDispatcher notifyThis, String handlerName) {
-        super(localPort + " (uninitialized)", notifyThis);
+    /**
+     * @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;
@@ -74,7 +80,10 @@ public abstract class I2PTunnelClientBase extends I2PTunnelTask implements Runna
                 sockMgr = getSocketManager();
             }
         }
-        if (sockMgr == null) throw new NullPointerException();
+        if (sockMgr == null) {
+            l.log("Invalid I2CP configuration");
+            throw new IllegalArgumentException("Socket manager could not be created");
+        }
         l.log("I2P session created");
 
         Thread t = new I2PThread(this);
@@ -103,17 +112,27 @@ public abstract class I2PTunnelClientBase extends I2PTunnelTask implements Runna
 
     private static I2PSocketManager socketManager;
 
-    protected static synchronized I2PSocketManager getSocketManager() {
+    protected synchronized I2PSocketManager getSocketManager() {
+        return getSocketManager(getTunnel());
+    }
+    protected static synchronized I2PSocketManager getSocketManager(I2PTunnel tunnel) {
         if (socketManager == null) {
-            socketManager = buildSocketManager();
+            socketManager = buildSocketManager(tunnel);
         }
         return socketManager;
     }
 
-    protected static I2PSocketManager buildSocketManager() {
+    protected I2PSocketManager buildSocketManager() {
+        return buildSocketManager(getTunnel());
+    }
+    protected static I2PSocketManager buildSocketManager(I2PTunnel tunnel) {
         Properties props = new Properties();
-        props.putAll(System.getProperties());
-        I2PSocketManager sockManager = I2PSocketManagerFactory.createManager(I2PTunnel.host, Integer.parseInt(I2PTunnel.port), props);
+        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;
     }
@@ -124,9 +143,9 @@ public abstract class I2PTunnelClientBase extends I2PTunnelTask implements Runna
 
     protected final InetAddress getListenHost(Logging l) {
         try {
-            return InetAddress.getByName(I2PTunnel.listenHost);
+            return InetAddress.getByName(getTunnel().listenHost);
         } catch (UnknownHostException uhe) {
-            l.log("Could not find listen host to bind to [" + I2PTunnel.host + "]");
+            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;
@@ -203,7 +222,7 @@ public abstract class I2PTunnelClientBase extends I2PTunnelTask implements Runna
                 localPort = ss.getLocalPort();
             }
             notifyEvent("clientLocalPort", new Integer(ss.getLocalPort()));
-            l.log("Listening for clients on port " + localPort + " of " + I2PTunnel.listenHost);
+            l.log("Listening for clients on port " + localPort + " of " + getTunnel().listenHost);
 
             // Notify constructor that port is ready
             synchronized (this) {

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

@@ -9,8 +9,12 @@ 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 net.i2p.I2PAppContext;
 import net.i2p.I2PException;
 import net.i2p.client.streaming.I2PSocket;
 import net.i2p.data.DataFormatException;
@@ -42,7 +46,7 @@ import net.i2p.util.Log;
 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 403 Access Denied\r\n"+
@@ -59,7 +63,7 @@ public class I2PTunnelHTTPClient extends I2PTunnelClientBase implements Runnable
          "Cache-control: no-cache\r\n"+
          "\r\n"+
          "<html><body><H1>I2P ERROR: DESTINATION NOT FOUND</H1>"+
-         "That I2P Desitination was not found. Perhaps you pasted in the "+
+         "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>.  "+
@@ -71,7 +75,7 @@ public class I2PTunnelHTTPClient extends I2PTunnelClientBase implements Runnable
          "Content-Type: text/html; charset=iso-8859-1\r\n"+
          "Cache-control: no-cache\r\n\r\n"+
          "<html><body><H1>I2P ERROR: TIMEOUT</H1>"+
-         "That Desitination was reachable, but timed out getting a "+
+         "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 "+
@@ -80,18 +84,29 @@ public class I2PTunnelHTTPClient extends I2PTunnelClientBase implements Runnable
 
     /** used to assign unique IDs to the threads / clients.  no logic or functionality */
     private static volatile long __clientId = 0;
-    
-    public I2PTunnelHTTPClient(int localPort, Logging l, boolean ownDest, String wwwProxy, EventDispatcher notifyThis) {
-        super(localPort, ownDest, l, notifyThis, "HTTPHandler " + (++__clientId));
+
+    /**
+     * @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);
 
         if (waitEventValue("openBaseClientResult").equals("error")) {
             notifyEvent("openHTTPClientResult", "error");
             return;
         }
 
-        this.wwwProxy = wwwProxy;
+        proxyList = new ArrayList();
+        if (wwwProxy != null) {
+            StringTokenizer tok = new StringTokenizer(wwwProxy, ",");
+            while (tok.hasMoreTokens())
+                proxyList.add(tok.nextToken().trim());
+        }
 
-        setName(getLocalPort() + " -> HTTPClient [WWW outproxy: " + this.wwwProxy + "]");
+        setName(getLocalPort() + " -> HTTPClient [WWW outproxy list: " + wwwProxy + "]");
 
         startRunning();
 
@@ -100,10 +115,20 @@ public class I2PTunnelHTTPClient extends I2PTunnelClientBase implements Runnable
 
     private String getPrefix() { return "Client[" + _clientId + "]: "; }
     
+    private String selectProxy() {
+        if (proxyList.size() <= 0) {
+            l.log("Proxy list is emtpy - no outproxy available");
+            return null;
+        }
+        int index = I2PAppContext.getGlobalContext().random().nextInt(proxyList.size());
+        return (String)proxyList.get(index);
+    }
+    
     protected void clientConnectionRun(Socket s) {
         OutputStream out = null;
         String targetRequest = null;
         boolean usingWWWProxy = false;
+        String currentProxy = null;
         InactivityTimeoutThread timeoutThread = null;
         try {
             out = s.getOutputStream();
@@ -127,7 +152,7 @@ public class I2PTunnelHTTPClient extends I2PTunnelClientBase implements Runnable
                     if (pos == -1) break;
                     method = line.substring(0, pos);
                     String request = line.substring(pos + 1);
-                    if (request.startsWith("/") && System.getProperty("i2ptunnel.noproxy") != null) {
+                    if (request.startsWith("/") && getTunnel().getClientOptions().getProperty("i2ptunnel.noproxy") != null) {
                         request = "http://i2p" + request;
                     }
                     pos = request.indexOf("//");
@@ -154,7 +179,8 @@ public class I2PTunnelHTTPClient extends I2PTunnelClientBase implements Runnable
                         line = method + " " + request.substring(pos);
                     } else if (host.indexOf(".") != -1) {
                         // The request must be forwarded to a WWW proxy
-                        destination = wwwProxy;
+                        currentProxy = selectProxy();
+                        destination = currentProxy;
                         usingWWWProxy = true;
                         if (_log.shouldLog(Log.DEBUG))
                             _log.debug(getPrefix() + "Host doesnt end with .i2p and it contains a period [" + host + "]: wwwProxy!");
@@ -236,25 +262,25 @@ public class I2PTunnelHTTPClient extends I2PTunnelClientBase implements Runnable
             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 = new InactivityTimeoutThread(runner, out, targetRequest, usingWWWProxy, currentProxy, s);
             timeoutThread.start();
         } catch (SocketException ex) {
             if (timeoutThread != null) timeoutThread.disable();
             _log.info(getPrefix() + "Error trying to connect", ex);
             l.log(ex.getMessage());
-            handleHTTPClientException(ex, out, targetRequest, usingWWWProxy, wwwProxy);
+            handleHTTPClientException(ex, out, targetRequest, usingWWWProxy, currentProxy);
             closeSocket(s);
         } catch (IOException ex) {
             if (timeoutThread != null) timeoutThread.disable();
             _log.info(getPrefix() + "Error trying to connect", ex);
             l.log(ex.getMessage());
-            handleHTTPClientException(ex, out, targetRequest, usingWWWProxy, wwwProxy);
+            handleHTTPClientException(ex, out, targetRequest, usingWWWProxy, currentProxy);
             closeSocket(s);
         } catch (I2PException ex) {
             if (timeoutThread != null) timeoutThread.disable();
             _log.info("getPrefix() + Error trying to connect", ex);
             l.log(ex.getMessage());
-            handleHTTPClientException(ex, out, targetRequest, usingWWWProxy, wwwProxy);
+            handleHTTPClientException(ex, out, targetRequest, usingWWWProxy, currentProxy);
             closeSocket(s);
         }
     }
@@ -269,16 +295,18 @@ public class I2PTunnelHTTPClient extends I2PTunnelClientBase implements Runnable
         private OutputStream _out;
         private String _targetRequest;
         private boolean _useWWWProxy;
+        private String _currentProxy;
         private boolean _disabled;
         private Object _disableLock = new Object();
 
         public InactivityTimeoutThread(I2PTunnelRunner runner, OutputStream out, String targetRequest,
-                                       boolean useWWWProxy, Socket s) {
+                                       boolean useWWWProxy, String currentProxy, Socket s) {
             this.s = s;
             _runner = runner;
             _out = out;
             _targetRequest = targetRequest;
             _useWWWProxy = useWWWProxy;
+            _currentProxy = currentProxy;
             _disabled = false;
             long timeoutId = ++__timeoutId;
             setName("InactivityThread " + getPrefix() + timeoutId);
@@ -328,7 +356,7 @@ public class I2PTunnelHTTPClient extends I2PTunnelClientBase implements Runnable
                     if (_runner.getLastActivityOn() > 0) {
                         // some  data has been sent, so don't 404 it
                     } else {
-                        writeErrorMessage(ERR_TIMEOUT, _out, _targetRequest, _useWWWProxy, wwwProxy);
+                        writeErrorMessage(ERR_TIMEOUT, _out, _targetRequest, _useWWWProxy, _currentProxy);
                     }
                 } catch (IOException ioe) {
                     _log.warn(getPrefix() + "Error writing out the 'timeout' message", ioe);

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

@@ -45,15 +45,15 @@ public class I2PTunnelServer extends I2PTunnelTask implements Runnable {
     /** default timeout to 3 minutes - override if desired */
     private long readTimeout = DEFAULT_READ_TIMEOUT;
 
-    public I2PTunnelServer(InetAddress host, int port, String privData, Logging l, EventDispatcher notifyThis) {
-        super(host + ":" + port + " <- " + privData, notifyThis);
+    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) {
-        super(host + ":" + port + " <- " + privkeyname, notifyThis);
+                           EventDispatcher notifyThis, I2PTunnel tunnel) {
+        super(host + ":" + port + " <- " + privkeyname, notifyThis, tunnel);
         try {
             init(host, port, new FileInputStream(privkey), privkeyname, l);
         } catch (IOException ioe) {
@@ -62,8 +62,8 @@ public class I2PTunnelServer extends I2PTunnelTask implements Runnable {
         }
     }
 
-    public I2PTunnelServer(InetAddress host, int port, InputStream privData, String privkeyname, Logging l,  EventDispatcher notifyThis) {
-        super(host + ":" + port + " <- " + privkeyname, notifyThis);
+    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);
     }
 
@@ -73,9 +73,9 @@ public class I2PTunnelServer extends I2PTunnelTask implements Runnable {
         this.remotePort = port;
         I2PClient client = I2PClientFactory.createClient();
         Properties props = new Properties();
-        props.putAll(System.getProperties());
+        props.putAll(getTunnel().getClientOptions());
         synchronized (slock) {
-            sockMgr = I2PSocketManagerFactory.createManager(privData, I2PTunnel.host, Integer.parseInt(I2PTunnel.port),
+            sockMgr = I2PSocketManagerFactory.createManager(privData, getTunnel().host, Integer.parseInt(getTunnel().port),
                                                             props);
 
         }

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

@@ -26,16 +26,19 @@ public abstract class I2PTunnelTask implements EventDispatcher {
     //	I2PTunnelTask(name, (EventDispatcher)null);
     //}
 
-    protected I2PTunnelTask(String name, EventDispatcher notifyThis) {
+    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;
     }
+    
+    public I2PTunnel getTunnel() { return tunnel; }
 
     public int getId() {
         return this.id;

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

@@ -47,15 +47,15 @@ public class I2Ping extends I2PTunnelTask implements Runnable {
     //	I2Ping(cmd, l, (EventDispatcher)null);
     //}
 
-    public I2Ping(String cmd, Logging l, boolean ownDest, EventDispatcher notifyThis) {
-        super("I2Ping [" + cmd + "]", notifyThis);
+    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();
+                sockMgr = I2PTunnelClient.buildSocketManager(tunnel);
             } else {
-                sockMgr = I2PTunnelClient.getSocketManager();
+                sockMgr = I2PTunnelClient.getSocketManager(tunnel);
             }
         }
         Thread t = new I2PThread(this);

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

@@ -0,0 +1,337 @@
+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 net.i2p.I2PAppContext;
+import net.i2p.I2PException;
+import net.i2p.client.I2PClient;
+import net.i2p.client.I2PClientFactory;
+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 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, false);
+    }
+    /**
+     * 
+     * @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)
+            createPrivateKey();
+    }
+    
+    private void createPrivateKey() {
+        I2PClient client = I2PClientFactory.createClient();
+        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() {
+        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.WARN))
+                _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);
+        _running = true;
+    }
+    
+    private void startClient() {
+        setI2CPOptions();
+        setSessionOptions();
+        setListenOn();
+        String listenPort = getListenPort(); 
+        String dest = getTargetDestination();
+        _tunnel.runClient(new String[] { listenPort, dest }, this);
+        _running = true;
+    }
+
+    private void startServer() {
+        setI2CPOptions();
+        setSessionOptions();
+        String targetHost = getTargetHost(); 
+        String targetPort = getTargetPort(); 
+        String privKeyFile = getPrivKeyFile(); 
+        _tunnel.runServer(new String[] { targetHost, targetPort, privKeyFile }, this);
+        _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);
+        _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 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");
+    }
+    
+    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,249 @@
+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.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.TreeMap;
+
+import net.i2p.I2PAppContext;
+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 List _controllers;
+    private static TunnelControllerGroup _instance = new TunnelControllerGroup();
+    public static TunnelControllerGroup getInstance() { return _instance; }
+    
+    private TunnelControllerGroup() { 
+        _log = I2PAppContext.getGlobalContext().logManager().getLog(TunnelControllerGroup.class);
+        _controllers = new ArrayList();
+    }
+    
+    /**
+     * 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);
+    }
+    
+    /**
+     * 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 given file
+     *
+     */
+    public void saveConfig(String 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; }
+}

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

@@ -0,0 +1,307 @@
+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... 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</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</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</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");
+    }
+
+    /**
+     * 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,348 @@
+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 _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;
+    }
+    
+    /**
+     * 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(WebStatusPageHelper.CONFIG_FILE);
+        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);
+            }
+        }
+
+        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,157 @@
+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;
+    private static boolean _configLoaded = false;
+    
+    static final String CONFIG_FILE = "i2ptunnel.cfg";
+    
+    public WebStatusPageHelper() {
+        _action = null;
+        _controllerNum = -1;
+        _log = I2PAppContext.getGlobalContext().logManager().getLog(WebStatusPageHelper.class);
+        synchronized (WebStatusPageHelper.class) {
+            if (!_configLoaded) {
+                reloadConfig();
+                _configLoaded = true;
+            }
+        }
+    }
+    
+    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() {
+        StringBuffer buf = new StringBuffer(4*1024);
+        buf.append("<ul>");
+        List tunnels = TunnelControllerGroup.getInstance().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() {
+        List msgs = TunnelControllerGroup.getInstance().stopAllControllers();
+        return getMessages(msgs);
+    }
+    private String startAll() {
+        List msgs = TunnelControllerGroup.getInstance().startAllControllers();
+        return getMessages(msgs);
+    }
+    private String restartAll() {
+        List msgs = TunnelControllerGroup.getInstance().restartAllControllers();
+        return getMessages(msgs);
+    }
+    private String reloadConfig() {
+        TunnelControllerGroup.getInstance().unloadControllers();
+        TunnelControllerGroup.getInstance().loadControllers(CONFIG_FILE);
+        return "Config reloaded";
+    }
+    private String start() {
+        if (_controllerNum < 0) return "Invalid tunnel";
+        List controllers = TunnelControllerGroup.getInstance().getControllers();
+        if (_controllerNum >= controllers.size()) return "Invalid tunnel";
+        TunnelController controller = (TunnelController)controllers.get(_controllerNum);
+        controller.startTunnel();
+        return getMessages(controller.clearMessages());
+    }
+    
+    private String stop() {
+        if (_controllerNum < 0) return "Invalid tunnel";
+        List controllers = TunnelControllerGroup.getInstance().getControllers();
+        if (_controllerNum >= controllers.size()) return "Invalid tunnel";
+        TunnelController controller = (TunnelController)controllers.get(_controllerNum);
+        controller.stopTunnel();
+        return getMessages(controller.clearMessages());
+    }
+    
+    private String getMessages() {
+        return getMessages(TunnelControllerGroup.getInstance().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,8 +27,8 @@ 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");

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,31 @@
+<%@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="*" />
+<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/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/I2PSocket.java

@@ -32,8 +32,18 @@ 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.
+     * 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
      */
@@ -41,7 +51,8 @@ public interface I2PSocket {
 
     /**
      * Define how long we will wait blocked on a read() operation (-1 will make
-     * the socket wait forever).
+     * the socket wait forever).  This is simply a helper to adjust the 
+     * I2PSocketOptions
      *
      */
     public void setReadTimeout(long ms);

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

@@ -9,6 +9,7 @@ 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;
 
@@ -40,6 +41,7 @@ class I2PSocketImpl implements I2PSocket {
     private long _createdOn;
     private long _closedOn;
     private long _remoteIdSetTime;
+    private I2PSocketOptions _options;
     private Object flagLock = new Object();
 
     /**
@@ -73,14 +75,17 @@ class I2PSocketImpl implements I2PSocket {
         remote = peer;
         _socketId = ++__socketId;
         local = mgr.getSession().getMyDestination();
-        in = new I2PInputStream();
-        I2PInputStream pin = new I2PInputStream();
+        String us = mgr.getSession().getMyDestination().calculateHash().toBase64().substring(0,4);
+        String name = us + (outgoing ? "->" : "<-") + peer.calculateHash().toBase64().subSequence(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();
     }
 
     /**
@@ -176,7 +181,11 @@ class I2PSocketImpl implements I2PSocket {
      */
     public void queueData(byte[] data) {
         _bytesRead += data.length;
-        in.queueData(data);
+        try {
+            in.queueData(data, false);
+        } catch (IOException ioe) {
+            _log.log(Log.CRIT, "wtf, we said DONT block, how can we timeout?", ioe);
+        }
     }
 
     /**
@@ -245,19 +254,36 @@ class I2PSocketImpl implements I2PSocket {
             return (byte)(I2PSocketManager.DATA_OUT + (byte)add);
     }
 
+    public void setOptions(I2PSocketOptions options) {
+        _options = options;
+        in.setReadTimeout(options.getReadTimeout());
+    }
+    
+    public I2PSocketOptions getOptions() { 
+        return _options;
+    }
+    
     /**
-     * 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
+     * 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 in.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;
     }
@@ -277,15 +303,24 @@ class I2PSocketImpl implements I2PSocket {
     
     //--------------------------------------------------
     private class I2PInputStream extends InputStream {
-
+        private String streamName;
         private ByteCollector bc = new ByteCollector();
+        private boolean inStreamClosed = false;
 
         private long readTimeout = -1;
 
+        public I2PInputStream(String name) {
+            streamName = name;
+        }
+        
         public long getReadTimeout() {
             return readTimeout;
         }
         
+        private String getStreamPrefix() { 
+            return getPrefix() + streamName + ": ";
+        }
+        
         public void setReadTimeout(long ms) {
             readTimeout = ms;
         }
@@ -300,12 +335,14 @@ class I2PSocketImpl implements I2PSocket {
 
         public int read(byte[] b, int off, int len) throws IOException {
             if (_log.shouldLog(Log.DEBUG))
-                _log.debug(getPrefix() + "Read called for " + len + " bytes (avail=" + bc.getCurrentSize() + "): " + this.hashCode());
+                _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;
 
@@ -313,7 +350,9 @@ class I2PSocketImpl implements I2PSocket {
                 synchronized (flagLock) {
                     if (closed) {
                         if (_log.shouldLog(Log.DEBUG))
-                            _log.debug(getPrefix() + "Closed is set after reading " + _bytesRead + " and writing " + _bytesWritten + ", so closing stream: " + hashCode());
+                            _log.debug(getStreamPrefix() + "Closed is set after reading " 
+                                       + _bytesRead + " and writing " + _bytesWritten 
+                                       + ", so closing stream: " + hashCode());
                         return -1;
                     }
                 }
@@ -329,18 +368,20 @@ class I2PSocketImpl implements I2PSocket {
 
                 if ((readTimeout >= 0)
                     && (System.currentTimeMillis() >= dieAfter)) {
-                    throw new InterruptedIOException(getPrefix() + "Timeout reading from I2PSocket (" + readTimeout + " msecs)");
+                    throw new InterruptedIOException(getStreamPrefix() + "Timeout reading from I2PSocket (" 
+                                                     + readTimeout + " msecs)");
                 }
 
                 synchronized (bc) {
                     read = bc.startToByteArray(len);
+                    bc.notifyAll();
                 }
             }
             if (read.length > len) throw new RuntimeException("BUG");
             System.arraycopy(read, 0, b, off, read.length);
 
             if (_log.shouldLog(Log.DEBUG)) {
-                _log.debug(getPrefix() + "Read from I2PInputStream " + hashCode() + " returned " 
+                _log.debug(getStreamPrefix() + "Read from I2PInputStream " + hashCode() + " returned " 
                            + read.length + " bytes");
             }
             //if (_log.shouldLog(Log.DEBUG)) {
@@ -357,14 +398,59 @@ class I2PSocketImpl implements I2PSocket {
             }
         }
 
-        public void queueData(byte[] data) {
-            queueData(data, 0, data.length);
+        /**
+         * 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);
         }
 
-        public void queueData(byte[] data, int off, int len) {
+        /**
+         * 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(getPrefix() + "Insert " + len + " bytes into queue: " + hashCode());
+                _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) {
@@ -381,6 +467,10 @@ class I2PSocketImpl implements I2PSocket {
         public void close() throws IOException {
             super.close();
             notifyClosed();
+            synchronized (bc) {
+                inStreamClosed = true;
+                bc.notifyAll();
+            }
         }
 
     }
@@ -399,7 +489,7 @@ class I2PSocketImpl implements I2PSocket {
 
         public void write(byte[] b, int off, int len) throws IOException {
             _bytesWritten += len;
-            sendTo.queueData(b, off, len);
+            sendTo.queueData(b, off, len, true);
         }
 
         public void close() {
@@ -454,9 +544,13 @@ class I2PSocketImpl implements I2PSocket {
                         _log.debug(getPrefix() + "Message size is: " + data.length);
                     boolean sent = sendBlock(data);
                     if (!sent) {
-                        _log.error(getPrefix() + "Error sending message to peer.  Killing socket runner");
+                        if (_log.shouldLog(Log.WARN))
+                            _log.warn(getPrefix() + "Error sending message to peer.  Killing socket runner");
                         errorOccurred();
                         return false;
+                    } else {
+                        if (_log.shouldLog(Log.DEBUG))
+                            _log.debug(getPrefix() + "Message sent to peer");
                     }
                 }
             }
@@ -475,9 +569,10 @@ class I2PSocketImpl implements I2PSocket {
                     packetsHandled++;
                 }
                 if ((bc.getCurrentSize() > 0) && (packetsHandled > 1)) {
-                    _log.error(getPrefix() + "A SCARY MONSTER HAS EATEN SOME DATA! " + "(input stream: " 
-                               + in.hashCode() + "; "
-                               + "queue size: " + bc.getCurrentSize() + ")");
+                    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;
@@ -492,7 +587,8 @@ class I2PSocketImpl implements I2PSocket {
                     byte[] packet = I2PSocketManager.makePacket(getMask(0x02), remoteID, new byte[0]);
                     boolean sent = manager.getSession().sendMessage(remote, packet);
                     if (!sent) {
-                        _log.error(getPrefix() + "Error sending close packet to peer");
+                        if (_log.shouldLog(Log.WARN))
+                            _log.warn(getPrefix() + "Error sending close packet to peer");
                         errorOccurred();
                     }
                 }

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

@@ -264,7 +264,8 @@ public class I2PSocketManager implements I2PSessionListener {
             s.queueData(payload);
             return;
         } else {
-            _log.error(getName() + ": Null socket with data available");
+            if (_log.shouldLog(Log.WARN))
+                _log.warn(getName() + ": Null socket with data available");
             throw new IllegalStateException("Null socket with data available");
         }
     }
@@ -376,7 +377,7 @@ public class I2PSocketManager implements I2PSessionListener {
      *
      * @throws IllegalStateException if the socket isn't open or isn't known
      */
-    private void sendIncoming(String id, byte payload[]) {
+    private void sendIncoming(String id, byte payload[]) throws IllegalStateException {
         I2PSocketImpl s = null;
         synchronized (lock) {
             s = (I2PSocketImpl) _inSockets.get(id);
@@ -468,7 +469,10 @@ public class I2PSocketManager implements I2PSessionListener {
                 _context.statManager().addRateData("streaming.synNoAck", 1, 1);
                 throw new I2PException("Error sending through I2P network");
             }
-            remoteID = s.getRemoteID(true, options.getConnectTimeout());
+            if (options != null)
+                remoteID = s.getRemoteID(true, options.getConnectTimeout());
+            else
+                remoteID = s.getRemoteID(true, getDefaultOptions().getConnectTimeout());
             
             if (remoteID == null) {
                 _context.statManager().addRateData("streaming.nackReceived", 1, 1);

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

@@ -30,7 +30,18 @@ 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());
     }
 
     /**
@@ -81,6 +92,7 @@ public class I2PSocketManagerFactory {
     private static I2PSocketManager createManager(I2PSession session) {
         I2PSocketManager mgr = new I2PSocketManager();
         mgr.setSession(session);
+        mgr.setDefaultOptions(new I2PSocketOptions());
         return mgr;
     }
 }

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

@@ -6,9 +6,18 @@ package net.i2p.client.streaming;
  */
 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;
+        _readTimeout = -1;
+        _writeTimeout = DEFAULT_WRITE_TIMEOUT;
+        _maxBufferSize = DEFAULT_BUFFER_SIZE;
     }
 
     /**
@@ -27,4 +36,65 @@ public class I2PSocketOptions {
     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,135 @@
+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 
+ * 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;
+
+    
+    /**
+     * 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) {
+        _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 = 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) {}
+                }   
+            }
+            long afterSending = System.currentTimeMillis();
+            System.out.println("Sent " + _sendSize + "KB in " + (afterSending-beforeSending) + "ms");
+            sock.close();
+        } 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 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[]) {
+        if (args.length != 3) {
+            System.out.println("Usage: StreamSinkClient sendSizeKB writeDelayMs serverDestFile");
+        } else {
+            int sendSizeKB = -1;
+            int writeDelayMs = -1;
+            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;
+            }
+            StreamSinkClient client = new StreamSinkClient(sendSizeKB, writeDelayMs, args[2]);
+            client.runClient();
+        }
+    }
+}

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

@@ -0,0 +1,135 @@
+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 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;
+    
+    /**
+     * 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) {
+        _sinkDir = sinkDir;
+        _destFile = ourDestFile;
+        _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 = 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);
+            } 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);
+                }
+            } catch (IOException ioe) {
+                _log.error("Error writing the sink", ioe);
+            } finally {
+                if (_fos != null) try { _fos.close(); } catch (IOException ioe) {}
+            }
+        }
+    }
+    
+    /**
+     * Fire up the streaming server.  <code>Usage: StreamSinkServer 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[]) {
+        if (args.length != 2) {
+            System.out.println("Usage: StreamSinkServer sinkDir ourDestFile");
+        } else {
+            StreamSinkServer server = new StreamSinkServer(args[0], args[1]);
+            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/netmonitor/java/build.xml

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

apps/netmonitor/java/src/net/i2p/netmonitor/DataHarvester.java

@@ -72,7 +72,7 @@ class DataHarvester {
      */
     private void harvestRankAs(NetMonitor monitor, RouterInfo peer) {
         int numFast = 0;
-        int numReliable = 0;
+        int numHighCapacity = 0;
         int numNotFailing = 0;
         int numFailing = 0;
         
@@ -81,10 +81,10 @@ class DataHarvester {
             String key = (String)iter.next();
             if (key.startsWith("profile.")) {
                 String val = (String)props.get(key);
-                if (val.indexOf("fastReliable") != -1)
+                if (val.indexOf("fast") != -1)
                     numFast++;
-                else if (val.indexOf("reliable") != -1)
-                    numReliable++;
+                else if (val.indexOf("highCapacity") != -1)
+                    numHighCapacity++;
                 else if (val.indexOf("notFailing") != -1)
                     numNotFailing++;
                 else if (val.indexOf("failing") != -1)
@@ -94,13 +94,13 @@ class DataHarvester {
         
         long rankAs[] = new long[4];
         rankAs[0] = numFast;
-        rankAs[1] = numReliable;
+        rankAs[1] = numHighCapacity;
         rankAs[2] = numNotFailing;
         rankAs[3] = numFailing;
         String description = "how we rank peers"; 
         String valDescr[] = new String[4];
         valDescr[0] = "# peers we rank as fast";
-        valDescr[1] = "# peers we rank as reliable";
+        valDescr[1] = "# peers we rank as high capacity";
         valDescr[2] = "# peers we rank as not failing";
         valDescr[3] = "# peers we rank as failing";
         monitor.addData(peer.getIdentity().getHash().toBase64(), "rankAs", description, valDescr, peer.getPublished(), rankAs);
@@ -115,7 +115,7 @@ class DataHarvester {
      */
     private void harvestRank(NetMonitor monitor, RouterInfo peer, List peers) {
         int numFast = 0;
-        int numReliable = 0;
+        int numHighCapacity = 0;
         int numNotFailing = 0;
         int numFailing = 0;
         
@@ -126,10 +126,10 @@ class DataHarvester {
             String prop = "profile." + peer.getIdentity().getHash().toBase64().replace('=', '_');
             String val = cur.getOptions().getProperty(prop);
             if ( (val == null) || (val.length() <= 0) ) continue;
-            if (val.indexOf("fastReliable") != -1)
+            if (val.indexOf("fast") != -1)
                 numFast++;
-            else if (val.indexOf("reliable") != -1)
-                numReliable++;
+            else if (val.indexOf("highCapacity") != -1)
+                numHighCapacity++;
             else if (val.indexOf("notFailing") != -1)
                 numNotFailing++;
             else if (val.indexOf("failing") != -1)
@@ -138,13 +138,13 @@ class DataHarvester {
         
         long rank[] = new long[4];
         rank[0] = numFast;
-        rank[1] = numReliable;
+        rank[1] = numHighCapacity;
         rank[2] = numNotFailing;
         rank[3] = numFailing;
         String description = "how peers rank us";
         String valDescr[] = new String[4];
         valDescr[0] = "# peers ranking us as fast";
-        valDescr[1] = "# peers ranking us as reliable";
+        valDescr[1] = "# peers ranking us as high capacity";
         valDescr[2] = "# peers ranking us as not failing";
         valDescr[3] = "# peers ranking us as failing";
         // we use the current date, not the published date, since this sample doesnt come from them
@@ -173,7 +173,6 @@ class DataHarvester {
         double values[] = harvestGroupValues(peer, group);
         if (values == null) return;
            
-        String description = "how long it takes to do an ElGamal encryption";
         String valDescr[] = new String[group.getStatCount()];
         for (int i = 0; i < group.getStatCount(); i++)
             valDescr[i] = group.getStat(i).getStatDescription();

apps/netmonitor/java/src/net/i2p/netmonitor/NetMonitor.java

@@ -18,7 +18,7 @@ import net.i2p.util.Log;
  * Main driver for the app that harvests data about the performance of the network,
  * building summaries for each peer that change over time. <p />
  *
- * Usage: <code>NetMonitor [configFilename] [--routers filename[,filename]*]</code> <p />
+ * Usage: <code>NetMonitor [configFilename] [--routers filename[,filename]*] [--netDbURL url] </code> <p />
  *
  *
  *
@@ -27,7 +27,7 @@ public class NetMonitor {
     private static final Log _log = new Log(NetMonitor.class);
     public static final String CONFIG_LOCATION_DEFAULT = "netmonitor.config";
     public static final String HARVEST_DELAY_PROP = "harvestDelaySeconds";
-    public static final int HARVEST_DELAY_DEFAULT = 60;
+    public static final int HARVEST_DELAY_DEFAULT = 5*60;
     public static final String EXPORT_DELAY_PROP = "exportDelaySeconds";
     public static final int EXPORT_DELAY_DEFAULT = 120;
     public static final String SUMMARY_DURATION_PROP = "summaryDurationHours";
@@ -41,20 +41,22 @@ public class NetMonitor {
     private int _exportDelay;
     private String _exportDir;
     private String _netDbDir;
+    private String _netDbURL;
     private String _explicitRouters;
     private int _summaryDurationHours;
     private boolean _isRunning;
     private Map _peerSummaries;
     
     public NetMonitor() {
-        this(CONFIG_LOCATION_DEFAULT, null);
+        this(CONFIG_LOCATION_DEFAULT, null, null);
     }
     public NetMonitor(String configLocation) {
-        this(configLocation, null);
+        this(configLocation, null, null);
     }
-    public NetMonitor(String configLocation, String explicitFilenames) {
+    public NetMonitor(String configLocation, String explicitFilenames, String url) {
         _configLocation = configLocation;
         _explicitRouters = explicitFilenames;
+        _netDbURL = url;
         _peerSummaries = new HashMap(32);
         loadConfig();
     }
@@ -127,6 +129,9 @@ public class NetMonitor {
     public String getNetDbDir() { return _netDbDir; }
     /** if specified, contains a set of filenames we want to harvest routerInfo data from */
     public String getExplicitRouters() { return _explicitRouters; }
+    /** if specified, contains a URL to fetch references from */
+    public String getNetDbURL() { return _netDbURL; }
+    
     /** 
      * what peers are we keeping track of?  
      *
@@ -212,11 +217,12 @@ public class NetMonitor {
     
     /**
      * main driver for the netMonitor.  the usage is:
-     * <code>NetMonitor [configFilename] [--routers filename[,filename]*]</code> 
+     * <code>NetMonitor [configFilename] [--routers filename[,filename]*] [--netDbURL url]</code> 
      */
     public static final void main(String args[]) {
         String cfgLocation = CONFIG_LOCATION_DEFAULT;
         String explicitFilenames = null;
+        String explicitURL = null;
         switch (args.length) {
             case 0:
                 break;
@@ -224,16 +230,22 @@ public class NetMonitor {
                 cfgLocation = args[0];
                 break;
             case 2:
-                explicitFilenames = args[1];
+                if ("--routers".equalsIgnoreCase(args[0]))
+                    explicitFilenames = args[1];
+                else
+                    explicitURL = args[1];
                 break;
             case 3:
                 cfgLocation = args[0];
-                explicitFilenames = args[2];
+                if ("--routers".equalsIgnoreCase(args[1]))
+                    explicitFilenames = args[2];
+                else
+                    explicitURL = args[2];
                 break;
             default:
-                System.err.println("Usage: NetMonitor [configFilename] [--routers filename[,filename]*]");
+                System.err.println("Usage: NetMonitor [configFilename] [--routers filename[,filename]*] [--netDbURL url]");
                 return;
         }
-        new NetMonitor(cfgLocation, explicitFilenames).startMonitor();
+        new NetMonitor(cfgLocation, explicitFilenames, explicitURL).startMonitor();
     }
 }

apps/netmonitor/java/src/net/i2p/netmonitor/NetMonitorRunner.java

@@ -1,12 +1,19 @@
 package net.i2p.netmonitor;
 
+import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.FilenameFilter;
 import java.io.IOException;
+import java.io.InputStream;
+import java.net.URL;
+import java.net.URLConnection;
 import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Iterator;
 import java.util.List;
+import java.util.Set;
 import java.util.StringTokenizer;
 
 import net.i2p.data.DataFormatException;
@@ -64,6 +71,9 @@ class NetMonitorRunner implements Runnable {
      *
      */
     private List getRouters() {
+        if (_monitor.getNetDbURL() != null)
+            return fetchRouters(_monitor.getNetDbURL());
+        
         File routers[] = listRouters();
         List rv = new ArrayList(64);
         if (routers != null) {
@@ -86,6 +96,65 @@ class NetMonitorRunner implements Runnable {
         return rv;
     }
     
+    
+    private List fetchRouters(String seedURL) {
+        List rv = new ArrayList();
+        try {
+            URL dir = new URL(seedURL);
+            String content = new String(readURL(dir));
+            Set urls = new HashSet();
+            int cur = 0;
+            while (true) {
+                int start = content.indexOf("href=\"routerInfo-", cur);
+                if (start < 0)
+                    break;
+
+                int end = content.indexOf(".dat\">", start);
+                String name = content.substring(start+"href=\"routerInfo-".length(), end);
+                urls.add(name);
+                cur = end + 1;
+            }
+
+            for (Iterator iter = urls.iterator(); iter.hasNext(); ) {
+                rv.add(fetchSeed((String)iter.next()));
+            }
+        } catch (Throwable t) {
+            _log.error("Error fetching routers from " + seedURL, t);
+        }
+        return rv;
+    }
+    
+    private RouterInfo fetchSeed(String peer) throws Exception {
+        URL url = new URL("http://i2p.net/i2pdb/routerInfo-" + peer + ".dat");
+        if (_log.shouldLog(Log.INFO))
+            _log.info("Fetching seed from " + url.toExternalForm());
+
+        byte data[] = readURL(url);
+        RouterInfo info = new RouterInfo();
+        try {
+            info.fromByteArray(data);
+            return info;
+        } catch (DataFormatException dfe) {
+            _log.error("Router data at " + url.toExternalForm() + " was corrupt", dfe);
+            return null;
+        }
+    }
+    
+    private byte[] readURL(URL url) throws Exception {
+        ByteArrayOutputStream baos = new ByteArrayOutputStream(1024);
+        URLConnection con = url.openConnection();
+        InputStream in = con.getInputStream();
+        byte buf[] = new byte[1024];
+        while (true) {
+            int read = in.read(buf);
+            if (read < 0)
+                break;
+            baos.write(buf, 0, read);
+        }
+        in.close();
+        return baos.toByteArray();
+    }
+    
     /**
      * dump the data to the filesystem
      */

apps/phttprelay/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:lib/javax.servlet.jar" />
+        <javac srcdir="./src" debug="true" source="1.3" target="1.3" deprecation="on" destdir="./build/obj" classpath="../../../core/java/build/i2p.jar:lib/javax.servlet.jar" />
     </target>
     <target name="jar" depends="compile">
         <war destfile="./build/phttprelay.war" webxml="web.xml">

apps/routerconsole/java/build.xml

@@ -0,0 +1,90 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project basedir="." default="all" name="routerconsole">
+    <target name="all" depends="clean, build" />
+    <target name="build" depends="builddep, jar" />
+    <target name="builddep">
+        <ant dir="../../../router/java/" target="build" />
+	<!-- router will build core -->
+    </target>
+    <target name="prepare">
+        <ant dir="../../jetty/" target="build" />
+    </target>
+    <target name="compile" depends="prepare">
+        <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:../../../router/java/build/router.jar:../../jetty/jettylib/org.mortbay.jetty-jdk1.2.jar" />
+    </target>
+    <target name="jar" depends="compile">
+        <jar destfile="./build/routerconsole.jar" basedir="./build/obj" includes="**/*.class">
+            <manifest>
+                <attribute name="Class-Path" value="i2p.jar router.jar" />
+            </manifest>
+        </jar>
+        <ant target="war" />
+    </target>
+    <target name="war" depends="precompilejsp">
+        <war destfile="build/routerconsole.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/routerconsole.jar" />
+            </classpath>
+            <arg value="-d" />
+            <arg value="../jsp/WEB-INF/classes" />
+            <arg value="-v9" />
+            <arg value="-p" />
+            <arg value="net.i2p.router.web.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/routerconsole.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" />
+        <mkdir dir="./build/javadoc" />
+        <javadoc 
+            sourcepath="./src:../../../core/java/src:../../router/java/src" destdir="./build/javadoc" 
+            packagenames="*" 
+            use="true" 
+            splitindex="true" 
+            windowtitle="Router Console" />
+    </target>
+    <target name="clean">
+        <delete dir="./build" />
+    </target>
+    <target name="cleandep" depends="clean">
+	<!-- router will clean core -->
+        <ant dir="../../../router/java/" target="distclean" />
+    </target>
+    <target name="distclean" depends="clean">
+	<!-- router will clean core -->
+        <ant dir="../../../router/java/" target="distclean" />
+    </target>
+</project>

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

@@ -0,0 +1,74 @@
+package net.i2p.router.web;
+
+import java.io.ByteArrayInputStream;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+/**
+ * Handler to deal with form submissions from the advanced config form and act
+ * upon the values.
+ *
+ */
+public class ConfigAdvancedHandler extends FormHandler {
+    private boolean _forceRestart;
+    private boolean _shouldSave;
+    private String _config;
+    
+    public void ConfigNetHandler() {
+        _shouldSave = false;
+        _forceRestart = false;
+    }
+    
+    protected void processForm() {
+        if (_shouldSave) {
+            saveChanges();
+        } else {
+            // noop
+        }
+    }
+    
+    public void setShouldsave(String moo) { _shouldSave = true; }
+    public void setRestart(String moo) { _forceRestart = true; }
+    
+    public void setConfig(String val) {
+        _config = val;
+    }
+    
+    /**
+     * The user made changes to the config and wants to save them, so
+     * lets go ahead and do so.
+     *
+     */
+    private void saveChanges() {
+        if (_config != null) {
+            BufferedReader reader = new BufferedReader(new InputStreamReader(new ByteArrayInputStream(_config.getBytes())));
+            String line = null;
+            try {
+                while ( (line = reader.readLine()) != null) {
+                    int eq = line.indexOf('=');
+                    if (eq == -1) continue;
+                    if (eq >= line.length() - 1) continue;
+                    String key = line.substring(0, eq).trim();
+                    String val = line.substring(eq + 1).trim();
+                    _context.router().setConfigSetting(key, val);
+                }
+            } catch (IOException ioe) {
+                addFormError("Error updating the configuration (IOERROR) - please see the error logs");
+                return;
+            }
+            
+            boolean saved = _context.router().saveConfig();
+            if (saved) 
+                addFormNotice("Configuration saved successfully");
+            else
+                addFormNotice("Error saving the configuration (applied but not saved) - please see the error logs");
+            
+            if (_forceRestart) {
+                addFormNotice("Performing a soft restart");
+                _context.router().restart();
+                addFormNotice("Soft restart complete");
+            }
+        }
+    }
+}

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

@@ -0,0 +1,38 @@
+package net.i2p.router.web;
+
+import java.util.Iterator;
+import java.util.Set;
+import java.util.TreeSet;
+
+import net.i2p.router.RouterContext;
+
+public class ConfigAdvancedHelper {
+    private RouterContext _context;
+    /**
+     * Configure this bean to query a particular router context
+     *
+     * @param contextId begging few characters of the routerHash, or null to pick
+     *                  the first one we come across.
+     */
+    public void setContextId(String contextId) {
+        try {
+            _context = ContextHelper.getContext(contextId);
+        } catch (Throwable t) {
+            t.printStackTrace();
+        }
+    }
+    
+    public ConfigAdvancedHelper() {}
+    
+    public String getSettings() {
+        StringBuffer buf = new StringBuffer(4*1024);
+        Set names = _context.router().getConfigSettings();
+        TreeSet sortedNames = new TreeSet(names);
+        for (Iterator iter = sortedNames.iterator(); iter.hasNext(); ) {
+            String name = (String)iter.next();
+            String val = _context.router().getConfigSetting(name);
+            buf.append(name).append('=').append(val).append('\n');
+        }
+        return buf.toString();
+    }
+}

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

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

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

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

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

@@ -0,0 +1,153 @@
+package net.i2p.router.web;
+
+import java.io.ByteArrayInputStream;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.Properties;
+import net.i2p.util.Log;
+
+/**
+ * Handler to deal with form submissions from the logging config form and act
+ * upon the values.
+ *
+ */
+public class ConfigLoggingHandler extends FormHandler {
+    private boolean _shouldSave;
+    private String _levels;
+    private String _defaultLevel;
+    private String _filename;
+    private String _recordFormat;
+    private String _dateFormat;
+    private String _fileSize;
+    
+    public void ConfigNetHandler() {
+        _shouldSave = false;
+    }
+    
+    protected void processForm() {
+        if (_shouldSave) {
+            saveChanges();
+        } else {
+            // noop
+        }
+    }
+    
+    public void setShouldsave(String moo) { _shouldSave = true; }
+    
+    public void setLevels(String levels) {
+        _levels = (levels != null ? levels.trim() : null);
+    }
+    public void setDefaultloglevel(String level) {
+        _defaultLevel = (level != null ? level.trim() : null);
+    }
+    public void setLogfilename(String filename) {
+        _filename = (filename != null ? filename.trim() : null);
+    }
+    public void setLogformat(String format) {
+        _recordFormat = (format != null ? format.trim() : null);
+    }
+    public void setLogdateformat(String format) {
+        _dateFormat = (format != null ? format.trim() : null);
+    }
+    public void setLogfilesize(String size) {
+        _fileSize = (size != null ? size.trim() : null);
+    }
+    
+    /**
+     * The user made changes to the config and wants to save them, so
+     * lets go ahead and do so.
+     *
+     */
+    private void saveChanges() {
+        boolean shouldSave = false;
+        
+        if (_levels != null) {
+            try {
+                Properties props = new Properties();
+                props.load(new ByteArrayInputStream(_levels.getBytes()));
+                _context.logManager().setLimits(props);
+                shouldSave = true;
+                addFormNotice("Log limits updated");
+            } catch (IOException ioe) {
+                _context.logManager().getLog(ConfigLoggingHandler.class).error("Error reading from the props?", ioe);
+                addFormError("Error updating the log limits - levels not valid");
+            }
+        } else {
+            _context.logManager().setLimits(null);
+            addFormNotice("Log limits cleared");
+        }
+          
+        if (_defaultLevel != null) {
+            String oldDefault = _context.logManager().getDefaultLimit();
+            if (_defaultLevel.equals(oldDefault)) {
+                // noop
+            } else {
+                shouldSave = true;
+                _context.logManager().setDefaultLimit(_defaultLevel);
+                addFormNotice("Default log level updated from " + oldDefault + " to " + _defaultLevel);
+            }
+        }
+        
+        if (_dateFormat != null) {
+            boolean valid = _context.logManager().setDateFormat(_dateFormat);
+            if (valid) {
+                shouldSave = true;
+                addFormNotice("Date format updated");
+            } else {
+                addFormError("Specified date format is not valid (" + _dateFormat + ") - not updated");
+            }
+        }
+        
+        if (_fileSize != null) {
+            int newBytes = _context.logManager().getFileSize(_fileSize);
+            int oldBytes = _context.logManager().getFileSize();
+            if (newBytes > 0) {
+                if (oldBytes != newBytes) {
+                    _context.logManager().setFileSize(newBytes);
+                    shouldSave = true;
+                    addFormNotice("File size updated");
+                } 
+            } else {
+                addFormError("Specified file size limit is not valid (" + _fileSize + ") - not updated");
+            }
+        }
+        
+        if ( (_filename != null) && (_filename.trim().length() > 0) ) {
+            _filename = _filename.trim();
+            String old = _context.logManager().getBaseLogfilename();
+            if ( (old != null) && (_filename.equals(old)) ) {
+                // noop - don't update since its the same
+            } else {
+                shouldSave = true;
+                _context.logManager().setBaseLogfilename(_filename);
+                addFormNotice("Log file name pattern updated to " + _filename 
+                              + " (note: will not take effect until next rotation)");
+            }
+        }
+        
+        if ( (_recordFormat != null) && (_recordFormat.trim().length() > 0) ) {
+            _recordFormat = _recordFormat.trim();
+            String old = new String(_context.logManager().getFormat());
+            if (_recordFormat.equalsIgnoreCase(old)) {
+                // noop - no change
+            } else {
+                char fmt[] = new char[_recordFormat.length()];
+                for (int i = 0; i < fmt.length; i++) 
+                    fmt[i] = _recordFormat.charAt(i);
+                _context.logManager().setFormat(fmt);
+                shouldSave = true;
+                addFormNotice("Log record format updated");
+            }
+        }
+        
+        if (shouldSave) {
+            boolean saved = _context.logManager().saveConfig();
+
+            if (saved) 
+                addFormNotice("Log configuration saved and applied successfully");
+            else
+                addFormNotice("Error saving the configuration (applied but not saved) - please see the error logs");
+        }
+    }
+}

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

@@ -0,0 +1,98 @@
+package net.i2p.router.web;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Properties;
+import java.util.TreeSet;
+
+import net.i2p.util.Log;
+
+import net.i2p.router.RouterContext;
+
+public class ConfigLoggingHelper {
+    private RouterContext _context;
+    /**
+     * Configure this bean to query a particular router context
+     *
+     * @param contextId begging few characters of the routerHash, or null to pick
+     *                  the first one we come across.
+     */
+    public void setContextId(String contextId) {
+        try {
+            _context = ContextHelper.getContext(contextId);
+        } catch (Throwable t) {
+            t.printStackTrace();
+        }
+    }
+    
+    public ConfigLoggingHelper() {}
+    
+    public String getLogFilePattern() {
+        return _context.logManager().getBaseLogfilename();
+    }
+    public String getRecordPattern() {
+        return new String(_context.logManager().getFormat());
+    }
+    public String getDatePattern() {
+        return _context.logManager().getDateFormatPattern();
+    }
+    public String getMaxFileSize() {
+        int bytes = _context.logManager().getFileSize();
+        if (bytes == 0) return "1m";
+        if (bytes > 1024*1024*1024)
+            return (bytes/(1024*1024*1024)) + "g";
+        else if (bytes > 1024*1024)
+            return (bytes/(1024*1024)) + "m";
+        else
+            return (bytes/(1024)) + "k";
+    }
+    public String getLogLevelTable() {
+        StringBuffer buf = new StringBuffer(32*1024);
+        Properties limits = _context.logManager().getLimits();
+        TreeSet sortedLogs = new TreeSet();
+        for (Iterator iter = limits.keySet().iterator(); iter.hasNext(); ) {
+            String prefix = (String)iter.next();
+            sortedLogs.add(prefix);
+        }
+        
+        buf.append("<textarea name=\"levels\" rows=\"20\" cols=\"70\">");
+        for (Iterator iter = sortedLogs.iterator(); iter.hasNext(); ) {
+            String prefix = (String)iter.next();
+            String level = limits.getProperty(prefix);
+            buf.append(prefix).append('=').append(level).append('\n');
+        }
+        buf.append("</textarea><br />\n");
+        buf.append("<i>Valid levels are DEBUG, INFO, WARN, ERROR, CRIT</i>\n");
+        return buf.toString();
+    }
+    public String getDefaultLogLevelBox() {
+        String cur = _context.logManager().getDefaultLimit();
+        StringBuffer buf = new StringBuffer(128);
+        buf.append("<select name=\"defaultloglevel\">\n");
+        
+        buf.append("<option value=\"DEBUG\" ");
+        if ("DEBUG".equals(cur)) buf.append(" selected=\"true\" ");
+        buf.append(">DEBUG</option>\n");
+        
+        buf.append("<option value=\"INFO\" ");
+        if ("INFO".equals(cur)) buf.append(" selected=\"true\" ");
+        buf.append(">INFO</option>\n");
+        
+        buf.append("<option value=\"WARN\" ");
+        if ("WARN".equals(cur)) buf.append(" selected=\"true\" ");
+        buf.append(">WARN</option>\n");
+        
+        buf.append("<option value=\"ERROR\" ");
+        if ("ERROR".equals(cur)) buf.append(" selected=\"true\" ");
+        buf.append(">ERROR</option>\n");
+        
+        buf.append("<option value=\"CRIT\" ");
+        if ("CRIT".equals(cur)) buf.append(" selected=\"true\" ");
+        buf.append(">CRIT</option>\n");
+        
+        buf.append("</select>\n");
+        return buf.toString();
+    }
+}

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

@@ -0,0 +1,292 @@
+package net.i2p.router.web;
+
+import java.io.BufferedReader;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.File;
+import java.io.FileOutputStream;
+
+import java.net.URL;
+import java.net.URLConnection;
+
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+
+import net.i2p.util.Log;
+
+import net.i2p.router.RouterContext;
+import net.i2p.router.ClientTunnelSettings;
+
+/**
+ * Handler to deal with form submissions from the main config form and act
+ * upon the values.
+ *
+ */
+public class ConfigNetHandler extends FormHandler {
+    private String _hostname;
+    private boolean _guessRequested;
+    private boolean _reseedRequested;
+    private boolean _saveRequested;
+    private boolean _timeSyncEnabled;
+    private String _port;
+    private String _inboundRate;
+    private String _inboundBurst;
+    private String _outboundRate;
+    private String _outboundBurst;
+    private String _reseedFrom;
+    
+    public void ConfigNetHandler() {
+        _guessRequested = false;
+        _reseedRequested = false;
+        _saveRequested = false;
+        _timeSyncEnabled = false;
+    }
+    
+    protected void processForm() {
+        if (_guessRequested) {
+            guessHostname();
+        } else if (_reseedRequested) {
+            reseed();
+        } else if (_saveRequested) {
+            saveChanges();
+        } else {
+            // noop
+        }
+    }
+    
+    public void setGuesshost(String moo) { _guessRequested = true; }
+    public void setReseed(String moo) { _reseedRequested = true; }
+    public void setSave(String moo) { _saveRequested = true; }
+    public void setEnabletimesync(String moo) { _timeSyncEnabled = true; }
+    
+    public void setHostname(String hostname) { 
+        _hostname = (hostname != null ? hostname.trim() : null); 
+    }
+    public void setPort(String port) { 
+        _port = (port != null ? port.trim() : null); 
+    }
+    public void setInboundrate(String rate) { 
+        _inboundRate = (rate != null ? rate.trim() : null); 
+    }
+    public void setInboundburstfactor(String factor) { 
+        _inboundBurst = (factor != null ? factor.trim() : null); 
+    }
+    public void setOutboundrate(String rate) { 
+        _outboundRate = (rate != null ? rate.trim() : null); 
+    }
+    public void setOutboundburstfactor(String factor) { 
+        _outboundBurst = (factor != null ? factor.trim() : null); 
+    }
+    public void setReseedfrom(String url) { 
+        _reseedFrom = (url != null ? url.trim() : null); 
+    }
+
+    private static final String IP_PREFIX = "<h1>Your IP is ";
+    private static final String IP_SUFFIX = " <br></h1>";
+    private void guessHostname() {
+        BufferedReader reader = null;
+        try {
+            URL url = new URL("http://www.whatismyip.com/");
+            URLConnection con = url.openConnection();
+            con.connect();
+            reader = new BufferedReader(new InputStreamReader(con.getInputStream()));
+            String line = null;
+            while ( (line = reader.readLine()) != null) {
+                if (line.startsWith(IP_PREFIX)) {
+                    int end = line.indexOf(IP_SUFFIX);
+                    if (end == -1) {
+                        addFormError("Unable to guess the host (BAD_SUFFIX)");
+                        return;
+                    }
+                    String ip = line.substring(IP_PREFIX.length(), end);
+                    addFormNotice("Host guess: " + ip);
+                    return;
+                }
+            }
+            addFormError("Unable to guess the host (NO_PREFIX)");
+        } catch (IOException ioe) {
+            addFormError("Unable to guess the host (IO_ERROR)");
+            _context.logManager().getLog(ConfigNetHandler.class).error("Unable to guess the host", ioe);
+        } finally {
+            if (reader != null) try { reader.close(); } catch (IOException ioe) {}
+        }
+    }
+    
+    private static final String DEFAULT_SEED_URL = "http://dev.i2p.net/i2pdb/";
+    /**
+     * Reseed has been requested, so lets go ahead and do it.  Fetch all of
+     * the routerInfo-*.dat files from the specified URL (or the default) and
+     * save them into this router's netDb dir.
+     *
+     */
+    private void reseed() {
+        String seedURL = DEFAULT_SEED_URL;
+        if (_reseedFrom != null)
+            seedURL = _reseedFrom;
+        try {
+            URL dir = new URL(seedURL);
+            String content = new String(readURL(dir));
+            Set urls = new HashSet();
+            int cur = 0;
+            while (true) {
+                int start = content.indexOf("href=\"routerInfo-", cur);
+                if (start < 0)
+                    break;
+
+                int end = content.indexOf(".dat\">", start);
+                String name = content.substring(start+"href=\"routerInfo-".length(), end);
+                urls.add(name);
+                cur = end + 1;
+            }
+
+            int fetched = 0;
+            for (Iterator iter = urls.iterator(); iter.hasNext(); ) {
+                fetchSeed(seedURL, (String)iter.next());
+                fetched++;
+            }
+            addFormNotice("Reseeded with " + fetched + " peers");
+        } catch (Throwable t) {
+            _context.logManager().getLog(ConfigNetHandler.class).error("Error reseeding", t);
+            addFormError("Error reseeding (RESEED_EXCEPTION)");
+        }
+    }
+    
+    private void fetchSeed(String seedURL, String peer) throws Exception {
+        URL url = new URL(seedURL + "/routerInfo-" + peer + ".dat");
+
+        byte data[] = readURL(url);
+        writeSeed(peer, data);
+    }
+    
+    private byte[] readURL(URL url) throws Exception {
+        ByteArrayOutputStream baos = new ByteArrayOutputStream(1024);
+        URLConnection con = url.openConnection();
+        InputStream in = con.getInputStream();
+        byte buf[] = new byte[1024];
+        while (true) {
+            int read = in.read(buf);
+            if (read < 0)
+                break;
+            baos.write(buf, 0, read);
+        }
+        in.close();
+        return baos.toByteArray();
+    }
+    
+    private void writeSeed(String name, byte data[]) throws Exception {
+        // props taken from KademliaNetworkDatabaseFacade...
+        String dirName = _context.getProperty("router.networkDatabase.dbDir", "netDb");
+        File netDbDir = new File(dirName);
+        if (!netDbDir.exists()) {
+            boolean ok = netDbDir.mkdirs();
+            if (ok)
+                addFormNotice("Network database directory created: " + dirName);
+            else
+                addFormNotice("Error creating network database directory: " + dirName);
+        }
+        FileOutputStream fos = new FileOutputStream(new File(netDbDir, "routerInfo-" + name + ".dat"));
+        fos.write(data);
+        fos.close();
+    }
+    
+    /**
+     * The user made changes to the network config and wants to save them, so
+     * lets go ahead and do so.
+     *
+     */
+    private void saveChanges() {
+        boolean restartRequired = false;
+        
+        if ( (_hostname != null) && (_hostname.length() > 0) ) {
+            String oldHost = _context.router().getConfigSetting(ConfigNetHelper.PROP_I2NP_TCP_HOSTNAME);
+            if ( (oldHost == null) || (!oldHost.equalsIgnoreCase(_hostname)) ) {
+                _context.router().setConfigSetting(ConfigNetHelper.PROP_I2NP_TCP_HOSTNAME, _hostname);
+                addFormNotice("Updating hostname from " + oldHost + " to " + _hostname);
+                restartRequired = true;
+            }
+        }
+        if ( (_port != null) && (_port.length() > 0) ) {
+            String oldPort = _context.router().getConfigSetting(ConfigNetHelper.PROP_I2NP_TCP_PORT);
+            if ( (oldPort == null) || (!oldPort.equalsIgnoreCase(_port)) ) {
+                _context.router().setConfigSetting(ConfigNetHelper.PROP_I2NP_TCP_PORT, _port);
+                addFormNotice("Updating TCP port from " + oldPort + " to " + _port);
+                restartRequired = true;
+            }
+        }
+        
+        updateRates();
+        
+        if (_timeSyncEnabled) {
+            System.setProperty("timestamper.enabled", "true");
+        } else {
+            System.setProperty("timestamper.enabled", "false");
+        }
+        
+        boolean saved = _context.router().saveConfig();
+        if (saved) 
+            addFormNotice("Configuration saved successfully");
+        else
+            addFormNotice("Error saving the configuration (applied but not saved) - please see the error logs");
+        
+        if (restartRequired) {
+            addFormNotice("Performing a soft restart");
+            _context.router().restart();
+            addFormNotice("Soft restart complete");
+        }
+    }
+    
+    private void updateRates() {
+        boolean updated = false;
+        if ( (_inboundRate != null) && (_inboundRate.length() > 0) ) {
+            _context.router().setConfigSetting(ConfigNetHelper.PROP_INBOUND_KBPS, _inboundRate);
+            updated = true;
+        }
+        if ( (_outboundRate != null) && (_outboundRate.length() > 0) ) {
+            _context.router().setConfigSetting(ConfigNetHelper.PROP_OUTBOUND_KBPS, _outboundRate);
+            updated = true;
+        }
+        
+        String inRate = _context.router().getConfigSetting(ConfigNetHelper.PROP_INBOUND_KBPS);
+        
+        if (_inboundBurst != null) {
+            int rateKBps = 0;
+            int burstSeconds = 0;
+            try {
+                rateKBps = Integer.parseInt(inRate);
+                burstSeconds = Integer.parseInt(_inboundBurst);
+            } catch (NumberFormatException nfe) {
+                // ignore
+            }
+            if ( (rateKBps > 0) && (burstSeconds > 0) ) {
+                int kb = rateKBps * burstSeconds;
+                _context.router().setConfigSetting(ConfigNetHelper.PROP_INBOUND_BURST, "" + kb);
+                updated = true;
+            }
+        }
+        
+        String outRate = _context.router().getConfigSetting(ConfigNetHelper.PROP_OUTBOUND_KBPS);
+        
+        if (_outboundBurst != null) {
+            int rateKBps = 0;
+            int burstSeconds = 0;
+            try {
+                rateKBps = Integer.parseInt(outRate);
+                burstSeconds = Integer.parseInt(_outboundBurst);
+            } catch (NumberFormatException nfe) {
+                // ignore
+            }
+            if ( (rateKBps > 0) && (burstSeconds > 0) ) {
+                int kb = rateKBps * burstSeconds;
+                _context.router().setConfigSetting(ConfigNetHelper.PROP_OUTBOUND_BURST, "" + kb);
+                updated = true;
+            }
+        }
+        
+        if (updated)
+            addFormNotice("Updated bandwidth limits");
+    }
+}

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

@@ -0,0 +1,135 @@
+package net.i2p.router.web;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.List;
+import java.util.Iterator;
+import java.util.TreeMap;
+
+import net.i2p.util.Log;
+
+import net.i2p.router.RouterContext;
+import net.i2p.router.ClientTunnelSettings;
+
+public class ConfigNetHelper {
+    private RouterContext _context;
+    /**
+     * Configure this bean to query a particular router context
+     *
+     * @param contextId begging few characters of the routerHash, or null to pick
+     *                  the first one we come across.
+     */
+    public void setContextId(String contextId) {
+        try {
+            _context = ContextHelper.getContext(contextId);
+        } catch (Throwable t) {
+            t.printStackTrace();
+        }
+    }
+
+    public ConfigNetHelper() {}
+    
+    /** copied from various private TCP components */
+    public final static String PROP_I2NP_TCP_HOSTNAME = "i2np.tcp.hostname";
+    public final static String PROP_I2NP_TCP_PORT = "i2np.tcp.port";
+    
+    public String getHostname() {
+        return _context.getProperty(PROP_I2NP_TCP_HOSTNAME);
+    }
+    public String getPort() {
+        int port = 8887;
+        String val = _context.getProperty(PROP_I2NP_TCP_PORT);
+        if (val != null) {
+            try {
+                port = Integer.parseInt(val);
+            } catch (NumberFormatException nfe) {
+                // ignore, use default from above
+            }
+        }
+        return "" + port;
+    }
+    
+    public String getEnableTimeSyncChecked() {
+        String enabled = System.getProperty("timestamper.enabled");
+        if ( (enabled == null) || (!"true".equals(enabled)) )
+            return "";
+        else
+            return " checked ";
+    }
+    
+    public static final String PROP_INBOUND_KBPS = "i2np.bandwidth.inboundKBytesPerSecond";
+    public static final String PROP_OUTBOUND_KBPS = "i2np.bandwidth.outboundKBytesPerSecond";
+    public static final String PROP_INBOUND_BURST = "i2np.bandwidth.inboundBurstKBytes";
+    public static final String PROP_OUTBOUND_BURST = "i2np.bandwidth.outboundBurstKBytes";
+
+    public String getInboundRate() {
+        String rate = _context.getProperty(PROP_INBOUND_KBPS);
+        if (rate != null)
+            return rate;
+        else
+            return "-1";
+    }
+    public String getOutboundRate() {
+        String rate = _context.getProperty(PROP_OUTBOUND_KBPS);
+        if (rate != null)
+            return rate;
+        else
+            return "-1";
+    }
+    public String getInboundBurstFactorBox() {
+        String rate = _context.getProperty(PROP_INBOUND_KBPS);
+        String burst = _context.getProperty(PROP_INBOUND_BURST);
+        int numSeconds = 1;
+        if ( (burst != null) && (rate != null) ) {
+            int rateKBps = 0;
+            int burstKB = 0;
+            try {
+                rateKBps = Integer.parseInt(rate);
+                burstKB = Integer.parseInt(burst);
+            } catch (NumberFormatException nfe) {
+                // ignore
+            }
+            if ( (rateKBps > 0) && (burstKB > 0) ) {
+                numSeconds = burstKB / rateKBps;
+            }
+        }
+        return getBurstFactor(numSeconds, "inboundburstfactor");
+    }
+    
+    public String getOutboundBurstFactorBox() {
+        String rate = _context.getProperty(PROP_OUTBOUND_KBPS);
+        String burst = _context.getProperty(PROP_OUTBOUND_BURST);
+        int numSeconds = 1;
+        if ( (burst != null) && (rate != null) ) {
+            int rateKBps = 0;
+            int burstKB = 0;
+            try {
+                rateKBps = Integer.parseInt(rate);
+                burstKB = Integer.parseInt(burst);
+            } catch (NumberFormatException nfe) {
+                // ignore
+            }
+            if ( (rateKBps > 0) && (burstKB > 0) ) {
+                numSeconds = burstKB / rateKBps;
+            }
+        }
+        return getBurstFactor(numSeconds, "outboundburstfactor");
+    }
+    
+    private static String getBurstFactor(int numSeconds, String name) {
+        StringBuffer buf = new StringBuffer(256);
+        buf.append("<select name=\"").append(name).append("\">\n");
+        for (int i = 1; i < 10; i++) {
+            buf.append("<option value=\"").append(i).append("\" ");
+            if ( (i == numSeconds) || (i == 10) )
+                buf.append("selected ");
+            buf.append(">");
+            if (i == 1)
+                buf.append("1 second (no burst)</option>\n");
+            else
+                buf.append(i).append(" seconds</option>\n");
+        }
+        buf.append("</select>\n");
+        return buf.toString();
+    }
+}

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

@@ -0,0 +1,24 @@
+package net.i2p.router.web;
+
+import java.util.List;
+import net.i2p.data.Hash;
+import net.i2p.router.RouterContext;
+
+class ContextHelper {
+    public static RouterContext getContext(String contextId) {
+        List contexts = RouterContext.listContexts();
+        if ( (contexts == null) || (contexts.size() <= 0) ) 
+            throw new IllegalStateException("No contexts?  wtf");
+        if ( (contextId == null) || (contextId.trim().length() <= 0) )
+            return (RouterContext)contexts.get(0);
+        for (int i = 0; i < contexts.size(); i++) {
+            RouterContext context = (RouterContext)contexts.get(i);
+            Hash hash = context.routerHash();
+            if (hash == null) continue;
+            if (hash.toBase64().startsWith(contextId))
+                return context;
+        }
+        // not found, so just give them the first we can find
+        return (RouterContext)contexts.get(0);
+    }
+}

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

@@ -0,0 +1,109 @@
+package net.i2p.router.web;
+
+import java.util.List;
+import java.util.ArrayList;
+
+import net.i2p.util.Log;
+
+import net.i2p.router.RouterContext;
+import net.i2p.router.ClientTunnelSettings;
+
+/**
+ * Simple form handler base class - does not depend on servlets or jsp,
+ * but instead the subclasses are populated with javabean properties.  e.g.
+ * <jsp:setProperty name="handler" property="*" />
+ *
+ * The form is "processed" after the properties are set and the first output
+ * property is retrieved - either getNotices() or getErrors().
+ *
+ */
+public class FormHandler {
+    protected RouterContext _context;
+    private List _errors;
+    private List _notices;
+    private boolean _processed;
+    
+    public FormHandler() {
+        _errors = new ArrayList();
+        _notices = new ArrayList();
+        _processed = false;
+    }
+    
+    /**
+     * Configure this bean to query a particular router context
+     *
+     * @param contextId begging few characters of the routerHash, or null to pick
+     *                  the first one we come across.
+     */
+    public void setContextId(String contextId) {
+        try {
+            _context = ContextHelper.getContext(contextId);
+        } catch (Throwable t) {
+            t.printStackTrace();
+        }
+    }
+
+    /**
+     * Override this to perform the final processing (in turn, adding formNotice
+     * and formError messages, etc)
+     *
+     */
+    protected void processForm() {}
+    
+    /**
+     * Add an error message to display
+     */
+    protected void addFormError(String errorMsg) {
+        if (errorMsg == null) return;
+        _errors.add(errorMsg);
+    }
+    
+    /**
+     * Add a non-error message to display
+     */
+    protected void addFormNotice(String msg) {
+        if (msg == null) return;
+        _notices.add(msg);
+    }
+    
+    /**
+     * Display any error messages (processing the form if it hasn't 
+     * been yet)
+     *
+     */
+    public String getErrors() { 
+        return render(_errors);
+    }
+    
+    /**
+     * Display any non-error messages (processing the form if it hasn't 
+     * been yet)
+     *
+     */
+    public String getNotices() { 
+        return render(_notices);
+    }
+    
+    private String render(List source) {
+        if (!_processed) {
+            processForm();
+            _processed = true;
+        }
+        if (source.size() <= 0) {
+            return "";
+        } else if (source.size() == 1) {
+            return (String)source.get(0);
+        } else {
+            StringBuffer buf = new StringBuffer(512);
+            buf.append("<ul>\n");
+            for (int i = 0; i < source.size(); i++) {
+                buf.append("<li>");
+                buf.append((String)source.get(i));
+                buf.append("</li>\n");
+            }
+            buf.append("</ul>\n");
+            return buf.toString();
+        }
+    }
+    
+}

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

@@ -0,0 +1,42 @@
+package net.i2p.router.web;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.List;
+
+import net.i2p.router.RouterContext;
+
+public class LogsHelper {
+    private RouterContext _context;
+    /**
+     * Configure this bean to query a particular router context
+     *
+     * @param contextId begging few characters of the routerHash, or null to pick
+     *                  the first one we come across.
+     */
+    public void setContextId(String contextId) {
+        try {
+            _context = ContextHelper.getContext(contextId);
+        } catch (Throwable t) {
+            t.printStackTrace();
+        }
+    }
+    
+    public LogsHelper() {}
+    
+    public String getLogs() {
+        List msgs = _context.logManager().getBuffer().getMostRecentMessages();
+        StringBuffer buf = new StringBuffer(16*1024); 
+        buf.append("<h2>Most recent console messages:</h2><ul>");
+        buf.append("<code>\n");
+        for (int i = 0; i < msgs.size(); i++) { 
+            String msg = (String)msgs.get(i);
+            buf.append("<li>");
+            buf.append(msg);
+            buf.append("</li>\n");
+        }
+        buf.append("</code></ul>\n");
+        
+        return buf.toString();
+    }
+}

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

@@ -0,0 +1,53 @@
+package net.i2p.router.web;
+
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+import net.i2p.router.RouterContext;
+
+public class NavHelper {
+    private static Map _apps = new HashMap();
+    private RouterContext _context;
+    /**
+     * Configure this bean to query a particular router context
+     *
+     * @param contextId begging few characters of the routerHash, or null to pick
+     *                  the first one we come across.
+     */
+    public void setContextId(String contextId) {
+        try {
+            _context = ContextHelper.getContext(contextId);
+        } catch (Throwable t) {
+            t.printStackTrace();
+        }
+    }
+    
+    public NavHelper() {}
+    
+    /**
+     * To register a new client application so that it shows up on the router
+     * console's nav bar, it should be registered with this singleton. 
+     *
+     * @param name pretty name the app will be called in the link
+     * @param path full path pointing to the application's root 
+     *             (e.g. /i2ptunnel/index.jsp)
+     */
+    public static void registerApp(String name, String path) {
+        _apps.put(name, path);
+    }
+    public static void unregisterApp(String name) {
+        _apps.remove(name);
+    }
+    
+    public String getClientAppLinks() {
+        StringBuffer buf = new StringBuffer(1024); 
+        for (Iterator iter = _apps.keySet().iterator(); iter.hasNext(); ) {
+            String name = (String)iter.next();
+            String path = (String)_apps.get(name);
+            buf.append("<a href=\"").append(path).append("\">");
+            buf.append(name).append("</a> |");
+        }
+        return buf.toString();
+    }
+}

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

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

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

@@ -0,0 +1,35 @@
+package net.i2p.router.web;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+
+import net.i2p.router.RouterContext;
+
+public class ProfilesHelper {
+    private RouterContext _context;
+    /**
+     * Configure this bean to query a particular router context
+     *
+     * @param contextId begging few characters of the routerHash, or null to pick
+     *                  the first one we come across.
+     */
+    public void setContextId(String contextId) {
+        try {
+            _context = ContextHelper.getContext(contextId);
+        } catch (Throwable t) {
+            t.printStackTrace();
+        }
+    }
+    
+    public ProfilesHelper() {}
+    
+    public String getProfileSummary() {
+        ByteArrayOutputStream baos = new ByteArrayOutputStream(16*1024);
+        try {
+            _context.profileOrganizer().renderStatusHTML(baos);
+        } catch (IOException ioe) {
+            ioe.printStackTrace();
+        }
+        return new String(baos.toByteArray());
+    }
+}

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

@@ -0,0 +1,50 @@
+package net.i2p.router.web;
+
+import java.io.IOException;
+import org.mortbay.jetty.Server;
+import org.mortbay.util.MultiException;
+
+public class RouterConsoleRunner {
+    private Server _server;
+    private String _listenPort = "7657";
+    private String _listenHost = "0.0.0.0";
+    private String _webAppsDir = "./webapps/";
+    
+    public RouterConsoleRunner(String args[]) {
+        if (args.length == 3) {
+            _listenPort = args[0].trim();
+            _listenHost = args[1].trim();
+            _webAppsDir = args[2].trim();
+        }
+    }
+    
+    public static void main(String args[]) {
+        RouterConsoleRunner runner = new RouterConsoleRunner(args);
+        runner.startConsole();
+    }
+    
+    public void startConsole() {
+        _server = new Server();
+        try {
+            _server.addListener(_listenHost + ':' + _listenPort);
+            _server.setRootWebApp("routerconsole");
+            _server.addWebApplications(_webAppsDir);
+        } catch (IOException ioe) {
+            ioe.printStackTrace();
+        }
+        try {
+            _server.start();
+        } catch (MultiException me) {
+            me.printStackTrace();
+        }
+    }
+    
+    public void stopConsole() {
+        try {
+            _server.stop();
+        } catch (InterruptedException ie) {
+            ie.printStackTrace();
+        }
+    }
+    
+}

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

@@ -0,0 +1,393 @@
+package net.i2p.router.web;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.text.DecimalFormat;
+
+import net.i2p.data.DataHelper;
+import net.i2p.stat.Rate;
+import net.i2p.stat.RateStat;
+import net.i2p.router.Router;
+import net.i2p.router.RouterContext;
+import net.i2p.router.RouterVersion;
+
+/**
+ * Simple helper to query the appropriate router for data necessary to render
+ * the summary sections on the router console.  
+ */
+public class SummaryHelper {
+    private RouterContext _context;
+    /**
+     * Configure this bean to query a particular router context
+     *
+     * @param contextId begging few characters of the routerHash, or null to pick
+     *                  the first one we come across.
+     */
+    public void setContextId(String contextId) {
+        try {
+            _context = ContextHelper.getContext(contextId);
+        } catch (Throwable t) {
+            t.printStackTrace();
+        }
+    }
+    
+    /**
+     * Retrieve the shortened 4 character ident for the router located within
+     * the current JVM at the given context.
+     *
+     */
+    public String getIdent() { 
+        if (_context == null) return "[no router]";
+        
+        if (_context.routerHash() != null)
+            return _context.routerHash().toBase64().substring(0, 4);
+        else
+            return "[unknown]";
+    }
+    /**
+     * Retrieve the version number of the router.
+     *
+     */
+    public String getVersion() { 
+        return RouterVersion.VERSION;
+    }
+    /**
+     * Retrieve a pretty printed uptime count (ala 4d or 7h or 39m)
+     *
+     */
+    public String getUptime() { 
+        if (_context == null) return "[no router]";
+        
+        Router router = _context.router();
+        if (router == null) 
+            return "[not up]";
+        else
+            return DataHelper.formatDuration(router.getUptime());
+    }
+    
+    /**
+     * How many active peers the router has.
+     *
+     */
+    public int getActivePeers() { 
+        if (_context == null) 
+            return 0;
+        else
+            return _context.profileOrganizer().countActivePeers();
+    }
+    /**
+     * How many active peers the router ranks as fast.
+     *
+     */
+    public int getFastPeers() { 
+        if (_context == null) 
+            return 0;
+        else
+            return _context.profileOrganizer().countFastPeers();
+    }
+    /**
+     * How many active peers the router ranks as having a high capacity.
+     *
+     */
+    public int getHighCapacityPeers() { 
+        if (_context == null) 
+            return 0;
+        else
+            return _context.profileOrganizer().countHighCapacityPeers();
+    }
+    /**
+     * How many active peers the router ranks as well integrated.
+     *
+     */
+    public int getWellIntegratedPeers() { 
+        if (_context == null) 
+            return 0;
+        else
+            return _context.profileOrganizer().countWellIntegratedPeers();
+    }
+    /**
+     * How many peers the router ranks as failing.
+     *
+     */
+    public int getFailingPeers() { 
+        if (_context == null) 
+            return 0;
+        else
+            return _context.profileOrganizer().countFailingPeers();
+    }
+    /**
+     * How many peers totally suck.
+     *
+     */
+    public int getShitlistedPeers() { 
+        if (_context == null) 
+            return 0;
+        else
+            return _context.shitlist().getRouterCount();
+    }
+ 
+    /**
+     * How fast we have been receiving data over the last minute (pretty printed
+     * string with 2 decimal places representing the KBps)
+     *
+     */
+    public String getInboundMinuteKBps() { 
+        if (_context == null) 
+            return "0.0";
+        
+        RateStat receiveRate = _context.statManager().getRate("transport.receiveMessageSize");
+        Rate rate = receiveRate.getRate(60*1000);
+        double bytes = rate.getLastTotalValue();
+        double bps = (bytes*1000.0d)/(rate.getPeriod()*1024.0d); 
+
+	DecimalFormat fmt = new DecimalFormat("##0.00");
+        return fmt.format(bps);
+    }
+    /**
+     * How fast we have been sending data over the last minute (pretty printed
+     * string with 2 decimal places representing the KBps)
+     *
+     */
+    public String getOutboundMinuteKBps() { 
+        if (_context == null) 
+            return "0.0";
+        
+        RateStat receiveRate = _context.statManager().getRate("transport.sendMessageSize");
+        Rate rate = receiveRate.getRate(60*1000);
+        double bytes = rate.getLastTotalValue();
+        double bps = (bytes*1000.0d)/(rate.getPeriod()*1024.0d); 
+
+	DecimalFormat fmt = new DecimalFormat("##0.00");
+        return fmt.format(bps);
+    }
+    
+    /**
+     * How fast we have been receiving data over the last 5 minutes (pretty printed
+     * string with 2 decimal places representing the KBps)
+     *
+     */
+    public String getInboundFiveMinuteKBps() {
+        if (_context == null) 
+            return "0.0";
+        
+        RateStat receiveRate = _context.statManager().getRate("transport.receiveMessageSize");
+        Rate rate = receiveRate.getRate(5*60*1000);
+        double bytes = rate.getLastTotalValue();
+        double bps = (bytes*1000.0d)/(rate.getPeriod()*1024.0d); 
+
+	DecimalFormat fmt = new DecimalFormat("##0.00");
+        return fmt.format(bps);
+    }
+    
+    /**
+     * How fast we have been sending data over the last 5 minutes (pretty printed
+     * string with 2 decimal places representing the KBps)
+     *
+     */
+    public String getOutboundFiveMinuteKBps() { 
+        if (_context == null) 
+            return "0.0";
+        
+        RateStat receiveRate = _context.statManager().getRate("transport.sendMessageSize");
+        Rate rate = receiveRate.getRate(5*60*1000);
+        double bytes = rate.getLastTotalValue();
+        double bps = (bytes*1000.0d)/(rate.getPeriod()*1024.0d); 
+
+	DecimalFormat fmt = new DecimalFormat("##0.00");
+        return fmt.format(bps);
+    }
+    
+    /**
+     * How fast we have been receiving data since the router started (pretty printed
+     * string with 2 decimal places representing the KBps)
+     *
+     */
+    public String getInboundLifetimeKBps() { 
+        if (_context == null) 
+            return "0.0";
+        
+        long received = _context.bandwidthLimiter().getTotalAllocatedInboundBytes();
+
+        DecimalFormat fmt = new DecimalFormat("##0.00");
+
+        // we use the unadjusted time, since thats what getWhenStarted is based off
+        long lifetime = _context.clock().now()-_context.clock().getOffset()
+                        - _context.router().getWhenStarted();
+        lifetime /= 1000;
+        if (received > 0) {
+            double receivedKBps = received / (lifetime*1024.0);
+            return fmt.format(receivedKBps);
+        } else {
+            return "0.0";
+        }
+    }
+    
+    /**
+     * How fast we have been sending data since the router started (pretty printed
+     * string with 2 decimal places representing the KBps)
+     *
+     */
+    public String getOutboundLifetimeKBps() { 
+        if (_context == null) 
+            return "0.0";
+        
+        long sent = _context.bandwidthLimiter().getTotalAllocatedOutboundBytes();
+
+        DecimalFormat fmt = new DecimalFormat("##0.00");
+
+        // we use the unadjusted time, since thats what getWhenStarted is based off
+        long lifetime = _context.clock().now()-_context.clock().getOffset() 
+                        - _context.router().getWhenStarted();
+        lifetime /= 1000;
+        if (sent > 0) {
+            double sendKBps = sent / (lifetime*1024.0);
+            return fmt.format(sendKBps);
+        } else {
+            return "0.0";
+        }
+    }
+    
+    /**
+     * How much data have we received since the router started (pretty printed
+     * string with 2 decimal places and the appropriate units - GB/MB/KB/bytes)
+     *
+     */
+    public String getInboundTransferred() { 
+        if (_context == null) 
+            return "0.0";
+        
+        long received = _context.bandwidthLimiter().getTotalAllocatedInboundBytes();
+
+        return getTransferred(received);
+    }
+    
+    /**
+     * How much data have we sent since the router started (pretty printed
+     * string with 2 decimal places and the appropriate units - GB/MB/KB/bytes)
+     *
+     */
+    public String getOutboundTransferred() { 
+        if (_context == null) 
+            return "0.0";
+        
+        long sent = _context.bandwidthLimiter().getTotalAllocatedOutboundBytes();
+        return getTransferred(sent);
+    }
+    
+    private static String getTransferred(long bytes) {
+        int scale = 0;
+        if (bytes > 1024*1024*1024) {
+            // gigs transferred
+            scale = 3; 
+            bytes /= (1024*1024*1024);
+        } else if (bytes > 1024*1024) {
+            // megs transferred
+            scale = 2;
+            bytes /= (1024*1024);
+        } else if (bytes > 1024) {
+            // kbytes transferred
+            scale = 1;
+            bytes /= 1024;
+        } else {
+            scale = 0;
+        }
+        
+        DecimalFormat fmt = new DecimalFormat("##0.00");
+
+        String str = fmt.format(bytes);
+        switch (scale) {
+            case 1: return str + "KB";
+            case 2: return str + "MB";
+            case 3: return str + "GB";
+            default: return bytes + "bytes";
+        }
+    }
+    
+    /**
+     * How many client destinations are connected locally.
+     *
+     * @return html section summary
+     */
+    public String getDestinations() {
+        ByteArrayOutputStream baos = new ByteArrayOutputStream(1024);
+        try {
+            _context.clientManager().renderStatusHTML(baos);
+            return new String(baos.toByteArray());
+        } catch (IOException ioe) {
+            _context.logManager().getLog(SummaryHelper.class).error("Error rendering client info", ioe);
+            return "";
+        }
+    }
+    
+    /**
+     * How many free inbound tunnels we have.
+     *
+     */
+    public int getInboundTunnels() { 
+        if (_context == null) 
+            return 0;
+        else
+            return _context.tunnelManager().getFreeTunnelCount();
+    }
+    
+    /**
+     * How many active outbound tunnels we have.
+     *
+     */
+    public int getOutboundTunnels() { 
+        if (_context == null) 
+            return 0;
+        else
+            return _context.tunnelManager().getOutboundTunnelCount();
+    }
+    
+    /**
+     * How many tunnels we are participating in.
+     *
+     */
+    public int getParticipatingTunnels() { 
+        if (_context == null) 
+            return 0;
+        else
+            return _context.tunnelManager().getParticipatingCount();
+    }
+ 
+    /**
+     * How lagged our job queue is over the last minute (pretty printed with
+     * the units attached)
+     *
+     */
+    public String getJobLag() { 
+        if (_context == null) 
+            return "0ms";
+        
+        Rate lagRate = _context.statManager().getRate("jobQueue.jobLag").getRate(60*1000);
+        return ((int)lagRate.getAverageValue()) + "ms";
+    }
+ 
+    /**
+     * How long it takes us to pump out a message, averaged over the last minute 
+     * (pretty printed with the units attached)
+     *
+     */   
+    public String getMessageDelay() { 
+        if (_context == null) 
+            return "0ms";
+        
+        Rate delayRate = _context.statManager().getRate("transport.sendProcessingTime").getRate(60*1000);
+        return ((int)delayRate.getAverageValue()) + "ms";
+    }
+    
+    /**
+     * How long it takes us to test our tunnels, averaged over the last 10 minutes
+     * (pretty printed with the units attached)
+     *
+     */
+    public String getTunnelLag() { 
+        if (_context == null) 
+            return "0ms";
+        
+        Rate lagRate = _context.statManager().getRate("tunnel.testSuccessTime").getRate(10*60*1000);
+        return ((int)lagRate.getAverageValue()) + "ms";
+    }
+}

apps/routerconsole/jsp/config.jsp

@@ -0,0 +1,65 @@
+<%@page contentType="text/html" %>
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+
+<html><head>
+<title>I2P Router Console - logs</title>
+<link rel="stylesheet" href="default.css" type="text/css" />
+</head><body>
+
+<%@include file="nav.jsp" %>
+<%@include file="summary.jsp" %>
+
+<jsp:useBean class="net.i2p.router.web.ConfigNetHelper" id="nethelper" scope="request" />
+<jsp:setProperty name="nethelper" property="contextId" value="<%=(String)session.getAttribute("i2p.contextId")%>" />
+
+<div class="main" id="main">
+ <%@include file="confignav.jsp" %>
+ 
+ <jsp:useBean class="net.i2p.router.web.ConfigNetHandler" id="formhandler" scope="request" />
+ <jsp:setProperty name="formhandler" property="*" />
+ <jsp:setProperty name="formhandler" property="contextId" value="<%=(String)session.getAttribute("i2p.contextId")%>" />
+ <font color="red"><jsp:getProperty name="formhandler" property="errors" /></font>
+ <i><jsp:getProperty name="formhandler" property="notices" /></i>
+
+ <form action="config.jsp" method="POST">
+ <b>External hostname/IP address:</b> 
+    <input name="hostname" type="text" size="32" value="<jsp:getProperty name="nethelper" property="hostname" />" />
+    <input type="submit" name="guesshost" value="Guess" /><br />
+ <b>Externally reachable TCP port:</b>
+     <input name="port" type="text" size="4" value="<jsp:getProperty name="nethelper" property="port" />" /> <br />
+ <i>The hostname/IP address and TCP port must be reachable from the outside world.  If
+ you are behind a firewall or NAT, this means you must poke a hole for this port.  If
+ you are using DHCP and do not have a static IP address, you must use a service like
+ <a href="http://dyndns.org/">dyndns</a>.  The "guess" functionality makes an HTTP request
+ to <a href="http://www.whatismyip.com/">www.whatismyip.com</a>.</i>
+ <hr />
+ <b>Enable internal time synchronization?</b> <input type="checkbox" <jsp:getProperty name="nethelper" property="enableTimeSyncChecked" /> name="enabletimesync" /><br />
+ <i>If disabled, your machine <b>must</b> be NTP synchronized.  This option only 
+    takes effect for the current run - if your machine is always synchronized within
+    (a few seconds), you can update your configuration so that it doesn't start the
+    "Timestamper" app (which would make this option irrelevent)</i>
+ <hr />
+ <b>Bandwidth limiter</b><br />
+ <b>Inbound rate</b>: 
+    <input name="inboundrate" type="text" size="2" value="<jsp:getProperty name="nethelper" property="inboundRate" />" /> KBytes per second<br />
+ <b>Inbound burst duration:</b>
+    <jsp:getProperty name="nethelper" property="inboundBurstFactorBox" /><br />
+ <b>Outbound rate:</b>
+    <input name="outboundrate" type="text" size="2" value="<jsp:getProperty name="nethelper" property="outboundRate" />" /> KBytes per second<br />
+ <b>Outbound burst duration:</b> 
+  <jsp:getProperty name="nethelper" property="outboundBurstFactorBox" /><br />
+ <i>A negative rate means there is no limit</i><br />
+ <hr />
+ <b>Reseed</b> (from <input name="reseedfrom" type="text" size="40" value="http://dev.i2p.net/i2pdb/" />): 
+               <input type="submit" name="reseed" value="now" /><br />
+ <i>May take some time to download the peer references</i>
+ <hr />
+ <input type="submit" name="save" value="Save changes" /> <input type="reset" value="Cancel" /><br />
+ <i>Changing the hostname or TCP port will force a 'soft restart' - dropping your connections 
+    and clients as if the router was stopped and restarted.  <b>Please be patient</b> - it may take
+    a few seconds to complete.</i>
+ </form>
+</div>
+
+</body>
+</html>

apps/routerconsole/jsp/configadvanced.jsp

@@ -0,0 +1,35 @@
+<%@page contentType="text/html"%>
+<%@page pageEncoding="UTF-8"%>
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+
+<html><head>
+<title>I2P Router Console - config advanced</title>
+<link rel="stylesheet" href="default.css" type="text/css" />
+</head><body>
+
+<%@include file="nav.jsp" %>
+<%@include file="summary.jsp" %>
+
+<jsp:useBean class="net.i2p.router.web.ConfigAdvancedHelper" id="advancedhelper" scope="request" />
+<jsp:setProperty name="advancedhelper" property="contextId" value="<%=(String)session.getAttribute("i2p.contextId")%>" />
+
+<div class="main" id="main">
+ <%@include file="confignav.jsp" %>
+ 
+ <jsp:useBean class="net.i2p.router.web.ConfigAdvancedHandler" id="formhandler" scope="request" />
+ <jsp:setProperty name="formhandler" property="*" />
+ <jsp:setProperty name="formhandler" property="contextId" value="<%=(String)session.getAttribute("i2p.contextId")%>" />
+ <font color="red"><jsp:getProperty name="formhandler" property="errors" /></font>
+ <i><jsp:getProperty name="formhandler" property="notices" /></i>
+ 
+ <form action="configadvanced.jsp" method="POST">
+ <textarea rows="20" cols="80" name="config"><jsp:getProperty name="advancedhelper" property="settings" /></textarea><br />
+ <input type="submit" name="shouldsave" value="Apply" /> <input type="reset" value="Cancel" /> <br />
+ <b>Force restart:</b> <input type="checkbox" name="restart" value="force" /> <i>(specify this
+ if the changes made above require the router to reset itself - e.g. you are updating TCP ports 
+ or hostnames, etc)</i>
+ </form>
+</div>
+
+</body>
+</html>

apps/routerconsole/jsp/configclients.jsp

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

apps/routerconsole/jsp/configlogging.jsp

@@ -0,0 +1,48 @@
+<%@page contentType="text/html"%>
+<%@page pageEncoding="UTF-8"%>
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+
+<html><head>
+<title>I2P Router Console - config clients</title>
+<link rel="stylesheet" href="default.css" type="text/css" />
+</head><body>
+<jsp:useBean class="net.i2p.router.web.ConfigLoggingHelper" id="logginghelper" scope="request" />
+<jsp:setProperty name="logginghelper" property="contextId" value="<%=(String)session.getAttribute("i2p.contextId")%>" />
+
+<%@include file="nav.jsp" %>
+<%@include file="summary.jsp" %>
+
+<div class="main" id="main">
+ <%@include file="confignav.jsp" %>
+ 
+ <jsp:useBean class="net.i2p.router.web.ConfigLoggingHandler" id="formhandler" scope="request" />
+ <jsp:setProperty name="formhandler" property="*" />
+ <jsp:setProperty name="formhandler" property="contextId" value="<%=(String)session.getAttribute("i2p.contextId")%>" />
+ <font color="red"><jsp:getProperty name="formhandler" property="errors" /></font>
+ <i><jsp:getProperty name="formhandler" property="notices" /></i>
+  
+ <form action="configlogging.jsp" method="POST">
+ <b>Logging filename:</b> 
+    <input type="text" name="logfilename" size="40" value="<jsp:getProperty name="logginghelper" property="logFilePattern" />" /><br />
+    <i>(the symbol '#' will be replaced during log rotation)</i><br />
+ <b>Log record format:</b>
+    <input type="text" name="logformat" size="20" value="<jsp:getProperty name="logginghelper" property="recordPattern" />" /><br />
+    <i>(use 'd' = date, 'c' = class, 't' = thread, 'p' = priority, 'm' = message)</i><br />
+ <b>Log date format:</b>
+    <input type="text" name="logdateformat" size="20" value="<jsp:getProperty name="logginghelper" property="datePattern" />" /><br />
+    <i>('MM' = month, 'dd' = day, 'HH' = hour, 'mm' = minute, 'ss' = second, 'SSS' = millisecond)</i><br />
+ <b>Max log file size:</b>
+    <input type="text" name="logfilesize" size="4" value="<jsp:getProperty name="logginghelper" property="maxFileSize" />" /><br />
+  <hr />
+  <b>Log levels:</b> <br />
+  <b>Default log level:</b>
+   <jsp:getProperty name="logginghelper" property="defaultLogLevelBox" /><br />
+   <jsp:getProperty name="logginghelper" property="logLevelTable" />
+ <hr />
+ <input type="submit" name="shouldsave" value="Save changes" /> 
+ <input type="reset" value="Cancel" />
+ </form>
+</div>
+
+</body>
+</html>

apps/routerconsole/jsp/confignav.jsp

@@ -0,0 +1,8 @@
+<h4><% if (request.getRequestURI().indexOf("config.jsp") != -1) { 
+ %>Network | <% } else { %><a href="config.jsp">Network</a> | <% }
+ if (request.getRequestURI().indexOf("configclients.jsp") != -1) {
+ %>Clients | <% } else { %><a href="configclients.jsp">Clients</a> | <% }
+ if (request.getRequestURI().indexOf("configlogging.jsp") != -1) {
+ %>Logging | <% } else { %><a href="configlogging.jsp">Logging</a> | <% }
+ if (request.getRequestURI().indexOf("configadvanced.jsp") != -1) {
+ %>Advanced | <% } else { %><a href="configadvanced.jsp">Advanced</a> | <% } %></h4>

apps/routerconsole/jsp/default.css

@@ -0,0 +1,60 @@
+body {
+	font-family: Verdana, Tahoma, Helvetica, sans-serif;
+	margin: 1em 0em;
+	padding: 0em;
+	text-align: center;
+	background-color: white;
+	color: black;
+}
+
+.hide {
+	display: none;
+}
+
+img {
+	border: none;
+}
+
+div.logo {
+	float: left;
+	left: 1em;
+	top: 1em;
+	margin: 0em;
+	padding: .5em;
+	text-align: left;
+}
+
+div.routersummary {
+	/* width: 8em; */
+	/* height: 5em; */
+	/* position: fixed; */
+	float: left;
+	/* left: 1em; */
+	/* top: 1em; */
+	margin: 0em;
+	padding: .5em;
+	text-align: left;
+	border: medium solid #efefff;
+	background-color: #fafaff;
+	color: inherit;
+	font-size: small;
+	clear: left; /* fixes a bug in Opera */
+}
+
+div.warning {
+	margin: 0em 1em 1em 12em;
+	padding: .5em 1em;
+	background-color: #ffefef;
+	border: medium solid #ffafaf;
+	text-align: left;
+	color: inherit;
+}
+
+div.main {
+	margin: 0em 1em 1em 12em;
+	padding: .5em 1em;
+	background-color: #ffffef;
+	border: medium solid #ffffd0;
+	text-align: left;
+	color: inherit;
+}

apps/routerconsole/jsp/help.jsp

@@ -0,0 +1,25 @@
+<%@page contentType="text/html"%>
+<%@page pageEncoding="UTF-8"%>
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+
+<html><head>
+<title>I2P Router Console - logs</title>
+<link rel="stylesheet" href="default.css" type="text/css" />
+</head><body>
+
+<%@include file="nav.jsp" %>
+<%@include file="summary.jsp" %>
+
+<div class="main" id="main">
+hmm.  we should probably have some help text here.<br />
+This "routerconsole" application runs on top of a trimmed down <a href="jetty.mortbay.com/jetty/index.html">Jetty</a>
+instance (trimmed down, as in, we do not include the demo apps or other add-ons), allowing you to deploy standard 
+JSP/Servlet web applications into your router.  Jetty in turn makes use of Apache's javax.servlet (javax.servlet.jar)
+implementation, as well as their xerces-j XML parser (xerces.jar).  Their XML parser requires the Sun XML
+APIs (JAXP) which is included in binary form (xml-apis.jar) as required by their binary code license.
+This product includes software developed by the Apache Software Foundation (http://www.apache.org/).  See the
+<a href="http://www.i2p.net/">I2P</a> site or the source for more license details.
+</div>
+
+</body>
+</html>

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

@@ -0,0 +1,18 @@
+<%@page contentType="text/html"%>
+<%@page pageEncoding="UTF-8"%>
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+
+<html><head>
+<title>I2P Router Console - home</title>
+<link rel="stylesheet" href="default.css" type="text/css" />
+</head><body>
+
+<%@include file="nav.jsp" %>
+<%@include file="summary.jsp" %>
+
+<div class="main" id="main">
+ <h2>Welcome to your router console</h2>
+</div>
+
+</body>
+</html>

apps/routerconsole/jsp/logs.jsp

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

apps/routerconsole/jsp/nav.jsp

@@ -0,0 +1,18 @@
+<% 
+   if (request.getParameter("i2p.contextId") != null) {
+       session.setAttribute("i2p.contextId", request.getParameter("i2p.contextId")); 
+   }%>
+
+<div class="logo">
+ <a href="index.jsp"><img src="i2plogo.png" alt="Router Console" width="187" height="35" /></a><br />
+ [<a href="config.jsp">configuration</a> | <a href="help.jsp">help</a>]
+</div>
+
+<h3>
+ <a href="profiles.jsp">Profiles</a> |
+ <a href="netdb.jsp">Network Database</a> |
+ <a href="logs.jsp">Logs</a> 
+ <jsp:useBean class="net.i2p.router.web.NavHelper" id="navhelper" scope="request" />
+ <jsp:setProperty name="navhelper" property="contextId" value="<%=(String)session.getAttribute("i2p.contextId")%>" />
+ <jsp:getProperty name="navhelper" property="clientAppLinks" />
+</h3>

apps/routerconsole/jsp/netdb.jsp

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

apps/routerconsole/jsp/profiles.jsp

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