only count locally generated lookup messages for detecting local DoS (duh)

stack traces (rather than "oh, we're doing it when... uh... writing to the socket")
* increase the throttle max, since we want to be able to send a few concurrent

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/Makefile.cygwin

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

apps/enclave/Makefile.linux

@@ -1,8 +1,13 @@
 #
-# This Makefile is compatible with GNU Make and should work on Linux
-# (Tested on Debian 3.0)
+# This Makefile is compatible with GNU Make and should work on Linux (generic)
 #
 
+#
+# Your operating environment
+#
+
+OS = LINUX
+
 #
 # Directories
 #
@@ -27,6 +32,7 @@ CC = g++
 #
 
 CFLAGS = -g -march=i486 -pipe -Wall
+CFLAGS += -DOS=$(OS)
 
 #
 # Libraries
@@ -34,7 +40,7 @@ CFLAGS = -g -march=i486 -pipe -Wall
 
 CFLAGS += -I$(SAMINCDIR) -I$(TOMCRYPTDIR)
 LDFLAGS = -L$(SAMLIBDIR) -L$(TOMCRYPTDIR)
-LIBS = -lsam -ltomcrypt
+LIBS = -lsam -ltomcrypt -lpthread
 
 #
 # Object files
@@ -45,11 +51,13 @@ OBJS =	$(OBJDIR)/bigint.o \
 		$(OBJDIR)/config.o \
 		$(OBJDIR)/logger.o \
 		$(OBJDIR)/main.o \
+		$(OBJDIR)/mutex.o \
 		$(OBJDIR)/peers.o \
 		$(OBJDIR)/random.o \
 		$(OBJDIR)/rpc.o \
 		$(OBJDIR)/sam.o \
-		$(OBJDIR)/sha1.o
+		$(OBJDIR)/sha1.o \
+		$(OBJDIR)/thread.o
 
 #
 # Build rules

apps/enclave/Makefile.mingw

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

apps/enclave/libsockthread/src/logger.cpp

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

apps/enclave/libsockthread/src/logger.hpp

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

apps/enclave/libsockthread/src/mutex.cpp

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

apps/enclave/libsockthread/src/mutex.hpp

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

apps/enclave/libsockthread/src/platform.hpp

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

apps/enclave/libsockthread/src/socket.cpp

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

apps/enclave/libsockthread/src/socket.hpp

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

apps/enclave/libsockthread/src/socket_addr.cpp

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

apps/enclave/libsockthread/src/socket_addr.hpp

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

apps/enclave/libsockthread/src/socket_connector.cpp

@@ -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

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

apps/enclave/libsockthread/src/strl.h

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

apps/enclave/libsockthread/src/thread.cpp

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

apps/enclave/libsockthread/src/thread.hpp

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

apps/enclave/libsockthread/src/time.cpp

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

apps/enclave/libsockthread/src/time.hpp

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

apps/enclave/libsockthread/src/types.hpp

@@ -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/enclave/src/logger.cpp

@@ -42,3 +42,20 @@ Logger::Logger(const string& file)
 		throw runtime_error("Error opening log file");
 	}
 }
+
+#ifdef WIN_STRERROR
+/*
+ * strerror() for primitive operating systems
+ */
+TCHAR* win_strerror(TCHAR* str, size_t size)
+{ 
+	LPVOID lpMsgBuf;
+	DWORD dw = GetLastError();
+	FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
+		NULL, dw, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpMsgBuf,
+		0, NULL);
+	snprintf(str, size, "%s", lpMsgBuf);
+	LocalFree(lpMsgBuf);
+	return str;
+}
+#endif

apps/enclave/src/logger.hpp

@@ -81,4 +81,8 @@ class Logger {
 		ofstream logf;
 };
 
+#ifdef WIN_STRERROR
+TCHAR* win_strerror(TCHAR* str, size_t size);
+#endif
+
 #endif  // LOGGER_HPP

apps/enclave/src/platform.hpp

@@ -39,6 +39,13 @@
 #define LINUX   2  // Linux
 #define CYGWIN  3  // Cygwin
 
+#if OS == MINGW
+	#define NO_SSIZE_T
+	#define WIN_STRERROR
+	#define WINSOCK
+	#define WINTHREADS
+#endif
+
 /*
  * System includes
  */
@@ -49,6 +56,11 @@
 #include <iostream>
 #include <list>
 #include <map>
+#ifdef WINTHREADS
+	#include <windows.h>
+#else
+	#include <pthread.h>
+#endif
 #include <stdexcept>
 #include <stdint.h>
 #include <string>
@@ -56,6 +68,10 @@
 
 using namespace std;
 
+#ifdef NO_SSIZE_T
+	typedef signed long ssize_t;
+#endif
+
 /*
  * Define this to '1' to cause the printing of source code file and line number
  * information with each log message.  Set it to '0' for simple logging.
@@ -71,6 +87,8 @@ using namespace std;
 /*
  * Local includes
  */
+#include "mutex.hpp"  // Mutex (for thread.hpp)
+#include "thread.hpp"  // Thread
 #include "logger.hpp"  // Logger
 #include "config.hpp"  // Config
 #include "sam_error.hpp"  // for sam.hpp

apps/enclave/src/sam.cpp

@@ -71,7 +71,7 @@ Sam::Sam(const string& samhost, uint16_t samport, const string& destname,
 Sam::~Sam(void)
 {
 	delete peers;  // this must be before set_connected(false)!
-	if (get_connected()) {
+	if (is_connected()) {
 		sam_close();
 		set_connected(false);
 	}
@@ -89,7 +89,7 @@ Sam::~Sam(void)
 void Sam::connect(const char* samhost, uint16_t samport, const char* destname,
 	uint_t tunneldepth)
 {
-	assert(!get_connected());
+	assert(!is_connected());
 	LMINOR << "Connecting to SAM as '" << destname << "'\n";
 	samerr_t rc = sam_connect(samhost, samport, destname, SAM_DGRAM, tunneldepth);
 	if (rc == SAM_OK)
@@ -114,7 +114,7 @@ void Sam::load_peers(void)
  */
 void Sam::naming_lookup(const string& name) const
 {
-	assert(get_connected());
+	assert(is_connected());
 	sam_naming_lookup(name.c_str());
 }
 
@@ -127,7 +127,7 @@ void Sam::naming_lookup(const string& name) const
  */
 void Sam::parse_dgram(const string& dest, void* data, size_t size)
 {
-	assert(get_connected());
+	assert(is_connected());
 	Peer* peer = peers->new_peer(dest);
 	Rpc rpc(peer);
 	rpc.parse(data, size);
@@ -140,7 +140,7 @@ void Sam::parse_dgram(const string& dest, void* data, size_t size)
  */
 void Sam::read_buffer(void)
 {
-	assert(get_connected());
+	assert(is_connected());
 	sam_read_buffer();
 }
 
@@ -153,6 +153,7 @@ void Sam::read_buffer(void)
  */
 void Sam::send_dgram(const string& dest, uchar_t *data, size_t size)
 {
+	assert(is_connected());
 	samerr_t rc = sam_dgram_send(dest.c_str(), data, size);
 	assert(rc == SAM_OK);  // i.e. not SAM_TOO_BIG
 }
@@ -189,10 +190,10 @@ bool Sam::valid_dest(const string& dest)
 {
 	if (dest.size() != 516)
 		return false;
-	if (dest.substr(512, 4) == "AAAA")  // note this AAAA signifies a null
-		return true;					// certificate - may not be true in the
-	else								// future
-		return false;
+	if (dest.substr(512, 4) == "AAAA")  // Note this AAAA signifies a null
+		return true;					// certificate and doesn't actually have
+	else								// any bearing on validity, but we'll
+		return false;					// keep this check here for now anyway
 }
 
 /*

apps/enclave/src/sam.hpp

@@ -55,7 +55,7 @@ class Sam {
 	private:
 		void connect(const char* samhost, uint16_t samport,
 			const char* destname, uint_t tunneldepth);
-		bool get_connected(void) const { return connected; }
+		bool is_connected(void) const { return connected; }
 
 		bool connected;
 		static bool exists;

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/ClientConfig.java

@@ -358,7 +358,7 @@ public class ClientConfig {
             int sendFreq = getInt(sendFrequencyVal);
             int sendSize = getInt(sendSizeVal);
 
-            if ((duration <= 0) || (statFreq <= 0) || (sendFreq <= 0) || (sendSize <= 0)) {
+            if ((duration <= 0) || (statFreq <= 0) || (sendFreq < 0) || (sendSize <= 0)) {
                 if (_log.shouldLog(Log.WARN)) {
                     _log.warn("Invalid client config: duration [" + statDurationVal + "] stat frequency ["
                               + statFrequencyVal + "] send frequency [" + sendFrequencyVal + "] send size ["
@@ -424,7 +424,7 @@ public class ClientConfig {
      * @return true if it was stored correctly, false if there were errors
      */
     public boolean store(Properties clientConfig, int peerNum) {
-        if ((_peer == null) || (_sendFrequency <= 0) || (_sendSize <= 0) || (_statDuration <= 0)
+        if ((_peer == null) || (_sendFrequency < 0) || (_sendSize <= 0) || (_statDuration <= 0)
             || (_statFrequency <= 0) || (_statFile == null)) { return false; }
 
         String comment = _comment;

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

@@ -90,7 +90,7 @@ class ClientEngine {
     /** our actual heartbeat pumper - this drives the test */
     private class ClientRunner implements Runnable {
 
-        /* (non-Javadoc)
+        /**
          * @see java.lang.Runnable#run()
          */
         public void run() {
@@ -120,9 +120,12 @@ class ClientEngine {
 
                 _data.cleanup();
 
-                try {
-                    Thread.sleep(1000);
-                } catch (InterruptedException ie) {
+                long timeToWait = nextSend - Clock.getInstance().now();
+                if (timeToWait > 0) {
+                    try {
+                        Thread.sleep(timeToWait);
+                    } catch (InterruptedException ie) {
+                    }
                 }
             }
         }

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

@@ -157,7 +157,7 @@ public class Heartbeat {
     }
 
     /** disconnect from the network */
-    private void disconnect() {
+    private void disconnect() { /* UNUSED */
         _adapter.disconnect();
     }
 

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

@@ -6,12 +6,11 @@ import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
-import java.util.Arrays;
 import java.util.Date;
 import java.util.Properties;
 
-import net.i2p.I2PException;
 import net.i2p.I2PAppContext;
+import net.i2p.I2PException;
 import net.i2p.client.I2PClient;
 import net.i2p.client.I2PClientFactory;
 import net.i2p.client.I2PSession;
@@ -47,7 +46,7 @@ class I2PAdapter {
     /** how do we talk to the router */
     private I2PSession _session;
     /** object that receives our i2cp notifications from the session and tells us */
-    private I2PListener _i2pListener;
+    private I2PListener _i2pListener; /* UNUSED */
 
     /** 
      * This config property tells us where the private destination data for our 
@@ -579,14 +578,14 @@ class I2PAdapter {
          * @see net.i2p.client.I2PSessionListener#errorOccurred(net.i2p.client.I2PSession, java.lang.String, java.lang.Throwable)
          */
         public void errorOccurred(I2PSession session, String message, Throwable error) {
-            if (_log.shouldLog(Log.ERROR)) _log.error("Error occurred", error);
+            if (_log.shouldLog(Log.ERROR)) _log.error("Error occurred: " + message, error);
         }
 
         /* (non-Javadoc)
          * @see net.i2p.client.I2PSessionListener#reportAbuse(net.i2p.client.I2PSession, int)
          */
         public void reportAbuse(I2PSession session, int severity) {
-            if (_log.shouldLog(Log.ERROR)) _log.error("Abuse reported");
+            if (_log.shouldLog(Log.ERROR)) _log.error("Abuse reported with severity " + String.valueOf(severity));
         }
 
         /* (non-Javadoc)

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;
@@ -103,6 +103,11 @@ public class PeerData {
      * @return when the test began  
      */
     public long getSessionStart() { return _sessionStart; }
+    
+    /**
+     * sets when the test began
+     * @param when when it began
+     */
     public void setSessionStart(long when) { _sessionStart = when; }
 
     /**
@@ -203,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);
@@ -332,6 +355,11 @@ public class PeerData {
          * @return the time the ping was sent
          */
         public long getPingSent() { return _pingSent; }
+        
+        /**
+         * sets when we sent this ping
+         * @param when when we sent the ping
+         */
         public void setPingSent(long when) { _pingSent = when; }
 
         /**

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

@@ -114,7 +114,7 @@ public class PeerDataWriter {
         return buf.toString();
     }
 
-    private static final SimpleDateFormat _fmt = new SimpleDateFormat("yyyyMMdd.HH:mm:ss.SSS", Locale.UK);
+    private final SimpleDateFormat _fmt = new SimpleDateFormat("yyyyMMdd.HH:mm:ss.SSS", Locale.UK);
 
     /**
      * Converts a time (long) to text
@@ -127,7 +127,7 @@ public class PeerDataWriter {
         }
     }
 
-    private static final DecimalFormat _numFmt = new DecimalFormat("#0", new DecimalFormatSymbols(Locale.UK));
+    private final DecimalFormat _numFmt = new DecimalFormat("#0", new DecimalFormatSymbols(Locale.UK));
 
     /**
      * Converts a number (double) to text

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

@@ -21,7 +21,7 @@ class HeartbeatControlPane extends JPanel {
     private HeartbeatMonitorGUI _gui;
     private JTabbedPane _configPane;
     private final static Color WHITE = new Color(255, 255, 255);
-    private final static Color LIGHT_BLUE = new Color(180, 180, 255);
+    private final static Color LIGHT_BLUE = new Color(180, 180, 255); /* UNUSED */
     private final static Color BLACK = new Color(0, 0, 0);
     private Color _background = WHITE;
     private Color _foreground = BLACK;

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

@@ -88,7 +88,9 @@ public class HeartbeatMonitor implements PeerPlotStateFetcher.FetchStateReceptor
         _gui.stateUpdated();
     }
     
-    /** store the config defining what peer tests we are monitoring (and how to render) */
+    /**
+     *  store the config defining what peer tests we are monitoring (and how to render) 
+     */
     void storeConfig() {}
     
     /**
@@ -103,6 +105,10 @@ public class HeartbeatMonitor implements PeerPlotStateFetcher.FetchStateReceptor
             new HeartbeatMonitor().runMonitor();
     }
     
+    /**
+     * Called when the config is updated
+     * @param config the updated config
+     */
     public void configUpdated(PeerPlotConfig config) { 
         _log.debug("Config updated, revamping the gui");
         _gui.stateUpdated(); 

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

@@ -19,7 +19,7 @@ import net.i2p.heartbeat.PeerData;
 import net.i2p.util.Log;
 
 class JFreeChartAdapter {
-    private final static Log _log = new Log(JFreeChartAdapter.class);
+    private final static Log _log = new Log(JFreeChartAdapter.class); /* UNUSED */
     private final static Color WHITE = new Color(255, 255, 255);
     
     ChartPanel createPanel(HeartbeatMonitorState state) {
@@ -45,7 +45,7 @@ class JFreeChartAdapter {
         updateLines(plot, state);
     }
     
-    private long getFirst(HeartbeatMonitorState state) {
+    private long getFirst(HeartbeatMonitorState state) { /* UNUSED */
         long first = -1;
         for (int i = 0; i < state.getTestCount(); i++) {
             List dataPoints = state.getTest(i).getCurrentData().getDataPoints();
@@ -116,6 +116,7 @@ class JFreeChartAdapter {
     }
     
     /**
+     * @param col the collection of xy series to add to
      * @param config preferences for how to display this test
      * @param lineName minimal name of the test (e.g. "jxHa.32KB.60s")
      * @param data List of PeerData.EventDataPoint describing all of the events in the test
@@ -144,6 +145,7 @@ class JFreeChartAdapter {
     /**
      * Add a data series for each average that we're configured to render
      *
+     * @param col the collection of xy series to add to
      * @param config preferences for how to display this test
      * @param lineName minimal name of the test (e.g. "jxHa.32KB.60s")
      * @param data List of PeerData.EventDataPoint describing all of the events in the test

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

@@ -14,14 +14,21 @@ import net.i2p.util.Log;
  *
  */
 class JFreeChartHeartbeatPlotPane extends HeartbeatPlotPane {
-    private final static Log _log = new Log(JFreeChartHeartbeatPlotPane.class);
+    private final static Log _log = new Log(JFreeChartHeartbeatPlotPane.class); /* UNUSED */
     private ChartPanel _panel;
     private JFreeChartAdapter _adapter;
-        
+
+    /**
+     * Creates a JFreeChart plot pane for the given gui
+     * @param gui the heartbeat monitor gui
+     */
     public JFreeChartHeartbeatPlotPane(HeartbeatMonitorGUI gui) {
         super(gui);
     }
     
+    /**
+     * Called when the state is updated
+     */
     public void stateUpdated() {
         if (_panel == null) {
             remove(0); // remove the dummy

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

@@ -18,7 +18,7 @@ import net.i2p.util.Log;
  * Configure how we want to render a particular clientConfig in the GUI
  */
 class PeerPlotConfig {
-    private final static Log _log = new Log(PeerPlotConfig.class);
+    private final static Log _log = new Log(PeerPlotConfig.class); /* UNUSED */
     /** where can we find the current state/data (either as a filename or a URL)? */
     private String _location;
     /** what test are we defining the plot data for? */
@@ -170,8 +170,8 @@ class PeerPlotConfig {
         Destination peer = getClientConfig().getPeer();
         if (peer == null) 
             return "????";
-        else
-            return peer.calculateHash().toBase64().substring(0, 4);
+
+        return peer.calculateHash().toBase64().substring(0, 4);
     }
 
     /**
@@ -196,8 +196,8 @@ class PeerPlotConfig {
         int bytes = getClientConfig().getSendSize();
         if (bytes < 1024)
             return bytes + "b";
-        else 
-            return bytes/1024 + "kb";
+
+        return bytes/1024 + "kb";
     }
 
     /** 

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

@@ -243,6 +243,7 @@ class PeerPlotConfigPane extends JPanel implements PeerPlotConfig.UpdateListener
             _minutes = minutes; 
             _button = button;
         }
+
         /* (non-Javadoc)
          * @see java.awt.event.ActionListener#actionPerformed(java.awt.event.ActionEvent)
          */

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

@@ -326,7 +326,7 @@ class PeerPlotStateFetcher {
             }
         }
         
-        private void fakeRun() {
+        private void fakeRun() { /* UNUSED */
             try {
                 Destination peer = new Destination();
                 Destination us = new Destination();

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

@@ -94,8 +94,8 @@ class StaticPeerData extends PeerData {
         Integer i = (Integer)_averageSendTimes.get(new Integer(period));
         if (i == null)
             return -1;
-        else
-            return i.doubleValue();
+
+        return i.doubleValue();
     }
     
     
@@ -109,8 +109,8 @@ class StaticPeerData extends PeerData {
         Integer i = (Integer)_averageReceiveTimes.get(new Integer(period));
         if (i == null)
             return -1;
-        else
-            return i.doubleValue();
+
+        return i.doubleValue();
     }
        
     /** 
@@ -123,8 +123,8 @@ class StaticPeerData extends PeerData {
         Integer i = (Integer)_lostMessages.get(new Integer(period));
         if (i == null)
             return -1;
-        else
-            return i.doubleValue();
+
+        return i.doubleValue();
     }
         
     /* (non-Javadoc)

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/httptunnel/java/src/net/i2p/httptunnel/HTTPListener.java

@@ -57,14 +57,14 @@ public class HTTPListener extends Thread {
      * @return Whether this is the first proxy use, no doubt.
      */
     public boolean firstProxyUse() {
-        // FIXME: check a config option here
-        if (true) return false;
+        if (true) return false; // FIXME: check a config option here
+        
         if (proxyUsed) {
             return false;
-        } else {
-            proxyUsed = true;
-            return true;
         }
+
+        proxyUsed = true;
+        return true;
     }
 
     /**

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

@@ -12,7 +12,7 @@ import net.i2p.util.Log;
  */
 public class ErrorHandler {
 
-    private static final Log _log = new Log(ErrorHandler.class);
+    private static final Log _log = new Log(ErrorHandler.class); /* UNUSED */
 
     /* package private */ErrorHandler() {
 

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

@@ -13,7 +13,7 @@ import net.i2p.util.Log;
  */
 public class LocalHandler {
 
-    private static final Log _log = new Log(LocalHandler.class);
+    private static final Log _log = new Log(LocalHandler.class); /* UNUSED */
 
     /* package private */LocalHandler() {
     }

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

@@ -18,7 +18,7 @@ import net.i2p.util.Log;
  */
 public class ProxyHandler extends EepHandler {
 
-    private static final Log _log = new Log(ErrorHandler.class);
+    private static final Log _log = new Log(ErrorHandler.class); /* UNUSED */
     private static I2PAppContext _context = new I2PAppContext();
 
     /* package private */ProxyHandler(ErrorHandler eh) {

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

@@ -12,7 +12,7 @@ import net.i2p.util.Log;
  */
 public class RootHandler {
 
-    private static final Log _log = new Log(RootHandler.class);
+    private static final Log _log = new Log(RootHandler.class); /* UNUSED */
 
     private RootHandler() {
         errorHandler = new ErrorHandler();
@@ -60,26 +60,24 @@ public class RootHandler {
             url = url.substring(7);
             pos = url.indexOf("/");
             String host;
-            String rest;
+
             if (pos == -1) {
                 errorHandler.handle(req, httpl, out, "No host end in URL");
                 return;
+            }
+            
+            host = url.substring(0, pos);
+            url = url.substring(pos);
+            if ("i2p".equals(host) || "i2p.i2p".equals(host)) {
+                // normal request; go on below...
+            } else if (host.endsWith(".i2p")) {
+                // "old" service request, send a redirect...
+                out.write(("HTTP/1.1 302 Moved\r\nLocation: " + "http://i2p.i2p/" + host + url + "\r\n\r\n").getBytes("ISO-8859-1"));
+                return;
             } else {
-                host = url.substring(0, pos);
-                url = url.substring(pos);
-                if ("i2p".equals(host) || "i2p.i2p".equals(host)) {
-                    // normal request; go on below...
-                } else if (host.endsWith(".i2p")) {
-                    // "old" service request, send a redirect...
-                    out
-                       .write(("HTTP/1.1 302 Moved\r\nLocation: " + "http://i2p.i2p/" + host + url + "\r\n\r\n")
-                                                                                                                .getBytes("ISO-8859-1"));
-                    return;
-                } else {
-                    // this is for proxying to the real web
-                    proxyHandler.handle(req, httpl, out /*, true */);
-                    return;
-                }
+                // this is for proxying to the real web
+                proxyHandler.handle(req, httpl, out /*, true */);
+                return;
             }
         }
         if (url.equals("/")) { // main page

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/BufferLogger.java

@@ -17,6 +17,9 @@ class BufferLogger implements Logging {
     private ByteArrayOutputStream _baos;
     private boolean _ignore;
 
+    /**
+     * Constructs a buffered logger.
+     */
     public BufferLogger() {
         _baos = new ByteArrayOutputStream(512);
         _ignore = false;
@@ -24,11 +27,15 @@ class BufferLogger implements Logging {
 
     private final static String EMPTY = "";
 
+    /**
+     * Retrieves the buffer
+     * @return the buffer
+     */
     public String getBuffer() {
         if (_ignore)
             return EMPTY;
-        else
-            return new String(_baos.toByteArray());
+
+        return new String(_baos.toByteArray());
     }
 
     /**

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,29 @@ 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());
-        return 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;
     }
 
     public final int getLocalPort() {
@@ -122,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;
@@ -201,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!");
@@ -226,6 +252,8 @@ public class I2PTunnelHTTPClient extends I2PTunnelClientBase implements Runnable
             Destination dest = I2PTunnel.destFromName(destination);
             if (dest == null) {
                 l.log("Could not resolve " + destination + ".");
+                if (_log.shouldLog(Log.WARN))
+                    _log.warn("Unable to resolve " + destination + " (proxy? " + usingWWWProxy + ", request: " + targetRequest);
                 writeErrorMessage(ERR_DESTINATION_UNKNOWN, out, targetRequest, usingWWWProxy, destination);
                 s.close();
                 return;
@@ -234,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);
         }
     }
@@ -267,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);
@@ -326,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);
@@ -365,6 +395,9 @@ public class I2PTunnelHTTPClient extends I2PTunnelClientBase implements Runnable
 
     private void handleHTTPClientException(Exception ex, OutputStream out, String targetRequest,
                                                   boolean usingWWWProxy, String wwwProxy) {
+                                                      
+        if (_log.shouldLog(Log.WARN))
+            _log.warn("Error sending to " + wwwProxy + " (proxy? " + usingWWWProxy + ", request: " + targetRequest, ex);
         if (out != null) {
             try {
                 writeErrorMessage(ERR_DESTINATION_UNKNOWN, out, targetRequest, usingWWWProxy, wwwProxy);

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,12 +73,13 @@ 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);
 
         }
+        sockMgr.setName("Server");
         l.log("Ready!");
         notifyEvent("openServerResult", "ok");
         open = true;

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/ByteCollector.java

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

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

@@ -5,12 +5,15 @@ import java.io.InputStream;
 import java.io.InterruptedIOException;
 import java.io.OutputStream;
 
+import net.i2p.I2PAppContext;
 import net.i2p.I2PException;
 import net.i2p.client.I2PSessionException;
 import net.i2p.data.Destination;
+import net.i2p.util.Clock;
 import net.i2p.util.I2PThread;
 import net.i2p.util.Log;
 
+
 /**
  * Initial stub implementation for the socket
  *
@@ -35,6 +38,10 @@ class I2PSocketImpl implements I2PSocket {
     private static long __socketId = 0;
     private long _bytesRead = 0;
     private long _bytesWritten = 0;
+    private long _createdOn;
+    private long _closedOn;
+    private long _remoteIdSetTime;
+    private I2PSocketOptions _options;
     private Object flagLock = new Object();
 
     /**
@@ -68,11 +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();
     }
 
     /**
@@ -89,6 +102,7 @@ class I2PSocketImpl implements I2PSocket {
     public void setRemoteID(String id) {
         synchronized (remoteIDWaiter) {
             remoteID = id;
+            _remoteIdSetTime = System.currentTimeMillis();
             remoteIDWaiter.notifyAll();
         }
     }
@@ -123,16 +137,23 @@ class I2PSocketImpl implements I2PSocket {
         long dieAfter = System.currentTimeMillis() + maxWait;
         synchronized (remoteIDWaiter) {
             if (wait) {
-                try {
-                    if (maxWait >= 0)
-                        remoteIDWaiter.wait(maxWait);
-                    else
-                        remoteIDWaiter.wait();
-                } catch (InterruptedException ex) {
+                if (remoteID == null) {
+                    try {
+                        if (maxWait >= 0)
+                            remoteIDWaiter.wait(maxWait);
+                        else
+                            remoteIDWaiter.wait();
+                    } catch (InterruptedException ex) {
+                    }
                 }
 
-                if ((maxWait >= 0) && (System.currentTimeMillis() >= dieAfter))
-                    throw new InterruptedIOException("Timed out waiting for remote ID");
+                long now = System.currentTimeMillis();
+                if ((maxWait >= 0) && (now >= dieAfter)) {
+                    long waitedExcess = now - dieAfter;
+                    throw new InterruptedIOException("Timed out waiting for remote ID (waited " + waitedExcess 
+                                                     + "ms too long [" + maxWait + "ms, remId " + remoteID
+                                                     + ", remId set " + (now-_remoteIdSetTime) + "ms ago])");
+                }
              
                 if (_log.shouldLog(Log.DEBUG))
                     _log.debug("TIMING: RemoteID set to " 
@@ -160,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);
+        }
     }
 
     /**
@@ -199,8 +224,10 @@ class I2PSocketImpl implements I2PSocket {
      */
     public void close() throws IOException {
         synchronized (flagLock) {
-            _log.debug("Closing connection");
+            if (_log.shouldLog(Log.DEBUG))
+                _log.debug("Closing connection");
             closed = true;
+            _closedOn = I2PAppContext.getGlobalContext().clock().now();
         }
         out.close();
         in.notifyClosed();
@@ -214,6 +241,7 @@ class I2PSocketImpl implements I2PSocket {
             closed = true;
             closed2 = true;
             sendClose = false;
+            _closedOn = I2PAppContext.getGlobalContext().clock().now();
         }
         out.close();
         in.notifyClosed();
@@ -226,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;
     }
@@ -248,19 +293,34 @@ class I2PSocketImpl implements I2PSocket {
             _socketErrorListener.errorOccurred();
     }
     
+    public long getBytesSent() { return _bytesWritten; }
+    public long getBytesReceived() { return _bytesRead; }
+    public long getCreatedOn() { return _createdOn; }
+    public long getClosedOn() { return _closedOn; }
+    
+    
     private String getPrefix() { return "[" + _socketId + "]: "; }
     
     //--------------------------------------------------
     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;
         }
@@ -273,42 +333,55 @@ class I2PSocketImpl implements I2PSocket {
             throw new RuntimeException("Incorrect read() result");
         }
 
-        public synchronized int read(byte[] b, int off, int len) throws IOException {
+        public int read(byte[] b, int off, int len) throws IOException {
             if (_log.shouldLog(Log.DEBUG))
-                _log.debug(getPrefix() + "Read called: " + 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 = bc.startToByteArray(len);
+            byte[] read = null;
+            synchronized (bc) {
+                read = bc.startToByteArray(len);
+                bc.notifyAll();
+            }
             boolean timedOut = false;
 
             while (read.length == 0) {
                 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;
                     }
                 }
                 try {
-                    if (readTimeout >= 0) {
-                        wait(readTimeout);
-                    } else {
-                        wait();
+                    synchronized (I2PSocketImpl.I2PInputStream.this) {
+                        if (readTimeout >= 0) {
+                            wait(readTimeout);
+                        } else {
+                            wait();
+                        }
                     }
                 } catch (InterruptedException ex) {}
 
                 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)");
                 }
 
-                read = bc.startToByteArray(len);
+                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)) {
@@ -320,27 +393,84 @@ class I2PSocketImpl implements I2PSocket {
         }
 
         public int available() {
-            return bc.getCurrentSize();
+            synchronized (bc) {
+                return bc.getCurrentSize();
+            }
         }
 
-        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 synchronized 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());
-            bc.append(data, off, len);
-            notifyAll();
+                _log.debug(getStreamPrefix() + "Insert " + len + " bytes into queue: " + hashCode());
+            Clock clock = I2PAppContext.getGlobalContext().clock();
+            long endAfter = clock.now() + _options.getWriteTimeout();
+            synchronized (bc) {
+                if (allowBlock) {
+                    if (_options.getMaxBufferSize() > 0) {
+                        while (bc.getCurrentSize() > _options.getMaxBufferSize()) {
+                            if (_log.shouldLog(Log.DEBUG))
+                                _log.debug(getStreamPrefix() + "Buffer size exceeded: pending " 
+                                           + bc.getCurrentSize() + " limit " + _options.getMaxBufferSize());
+                            if (_options.getWriteTimeout() > 0) {
+                                long timeLeft = endAfter - clock.now();
+                                if (timeLeft <= 0) {
+                                    long waited = _options.getWriteTimeout() - timeLeft;
+                                    throw new InterruptedIOException(getStreamPrefix() + "Waited too long (" 
+                                                                     + waited + "ms) to write " 
+                                                                     + len + " with a buffer at " + bc.getCurrentSize());
+                                }
+                            }
+                            if (inStreamClosed)
+                                throw new IOException(getStreamPrefix() + "Stream closed while writing");
+                            if (_closedOn > 0)
+                                throw new IOException(getStreamPrefix() + "I2PSocket closed while writing");
+                            try {
+                                bc.wait(1000);
+                            } catch (InterruptedException ie) {}
+                        }
+                    }
+                }
+                bc.append(data, off, len);
+            }
+            synchronized (I2PInputStream.this) {
+                I2PInputStream.this.notifyAll();
+            }
         }
 
-        public synchronized void notifyClosed() {
-            I2PInputStream.this.notifyAll();
+        public void notifyClosed() {
+            synchronized (I2PInputStream.this) {
+                I2PInputStream.this.notifyAll();
+            }
         }
         
         public void close() throws IOException {
             super.close();
             notifyClosed();
+            synchronized (bc) {
+                inStreamClosed = true;
+                bc.notifyAll();
+            }
         }
 
     }
@@ -359,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() {
@@ -414,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");
                     }
                 }
             }
@@ -435,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;
@@ -452,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

@@ -15,6 +15,7 @@ import java.util.HashSet;
 import java.util.Iterator;
 import java.util.Set;
 
+import net.i2p.I2PAppContext;
 import net.i2p.I2PException;
 import net.i2p.client.I2PSession;
 import net.i2p.client.I2PSessionException;
@@ -24,6 +25,7 @@ import net.i2p.data.DataFormatException;
 import net.i2p.data.Destination;
 import net.i2p.util.Log;
 
+
 /**
  * Centralize the coordination and multiplexing of the local client's streaming.
  * There should be one I2PSocketManager for each I2PSession, and if an application
@@ -33,7 +35,8 @@ import net.i2p.util.Log;
  *
  */
 public class I2PSocketManager implements I2PSessionListener {
-    private final static Log _log = new Log(I2PSocketManager.class);
+    private I2PAppContext _context;
+    private Log _log;
     private I2PSession _session;
     private I2PServerSocketImpl _serverSocket = null;
     private Object lock = new Object(); // for locking socket lists
@@ -41,6 +44,8 @@ public class I2PSocketManager implements I2PSessionListener {
     private HashMap _inSockets;
     private I2PSocketOptions _defaultOptions;
     private long _acceptTimeout;
+    private String _name;
+    private static int __managerId = 0;
     
     public static final short ACK = 0x51;
     public static final short CLOSE_OUT = 0x52;
@@ -57,10 +62,24 @@ public class I2PSocketManager implements I2PSessionListener {
     private static final long ACCEPT_TIMEOUT_DEFAULT = 5*1000;
     
     public I2PSocketManager() {
+        this("SocketManager " + (++__managerId));
+    }
+    public I2PSocketManager(String name) {
+        _name = name;
         _session = null;
         _inSockets = new HashMap(16);
         _outSockets = new HashMap(16);
         _acceptTimeout = ACCEPT_TIMEOUT_DEFAULT;
+        _context = I2PAppContext.getGlobalContext();
+        _log = _context.logManager().getLog(I2PSocketManager.class);
+        _context.statManager().createRateStat("streaming.lifetime", "How long before the socket is closed?", "streaming", new long[] { 10*60*1000, 60*60*1000, 24*60*60*1000 });
+        _context.statManager().createRateStat("streaming.sent", "How many bytes are sent in the stream?", "streaming", new long[] { 10*60*1000, 60*60*1000, 24*60*60*1000 });
+        _context.statManager().createRateStat("streaming.received", "How many bytes are received in the stream?", "streaming", new long[] { 10*60*1000, 60*60*1000, 24*60*60*1000 });
+        _context.statManager().createRateStat("streaming.transferBalance", "How many streams send more than they receive (positive means more sent, negative means more received)?", "streaming", new long[] { 10*60*1000, 60*60*1000, 24*60*60*1000 });
+        _context.statManager().createRateStat("streaming.synNoAck", "How many times have we sent a SYN but not received an ACK?", "streaming", new long[] { 10*60*1000, 60*60*1000, 24*60*60*1000 });
+        _context.statManager().createRateStat("streaming.ackSendFailed", "How many times have we tried to send an ACK to a SYN and failed?", "streaming", new long[] { 10*60*1000, 60*60*1000, 24*60*60*1000 });
+        _context.statManager().createRateStat("streaming.nackSent", "How many times have we refused a SYN with a NACK?", "streaming", new long[] { 10*60*1000, 60*60*1000, 24*60*60*1000 });
+        _context.statManager().createRateStat("streaming.nackReceived", "How many times have we received a NACK to our SYN?", "streaming", new long[] { 10*60*1000, 60*60*1000, 24*60*60*1000 });
     }
 
     public I2PSession getSession() {
@@ -82,12 +101,12 @@ public class I2PSocketManager implements I2PSessionListener {
     public long getAcceptTimeout() { return _acceptTimeout; }
 
     public void disconnected(I2PSession session) {
-        _log.info("Disconnected from the session");
+        _log.info(getName() + ": Disconnected from the session");
         destroySocketManager();
     }
 
     public void errorOccurred(I2PSession session, String message, Throwable error) {
-        _log.error("Error occurred: [" + message + "]", error);
+        _log.error(getName() + ": Error occurred: [" + message + "]", error);
     }
     
     public void messageAvailable(I2PSession session, int msgId, long size) {
@@ -95,11 +114,11 @@ public class I2PSocketManager implements I2PSessionListener {
             I2PSocketImpl s;
             byte msg[] = session.receiveMessage(msgId);
             if (msg.length == 1 && msg[0] == -1) {
-                _log.debug("Ping received");
+                _log.debug(getName() + ": Ping received");
                 return;
             }
             if (msg.length < 4) {
-                _log.error("==== packet too short ====");
+                _log.error(getName() + ": ==== packet too short ====");
                 return;
             }
             int type = msg[0] & 0xff;
@@ -107,7 +126,7 @@ public class I2PSocketManager implements I2PSessionListener {
             byte[] payload = new byte[msg.length - 4];
             System.arraycopy(msg, 4, payload, 0, payload.length);
             if (_log.shouldLog(Log.DEBUG))
-                _log.debug("Message read: type = [" + Integer.toHexString(type) 
+                _log.debug(getName() + ": Message read: type = [" + Integer.toHexString(type) 
                            + "] id = [" + getReadableForm(id)
                            + "] payload length: [" + payload.length + "]");
             switch (type) {
@@ -136,9 +155,9 @@ public class I2PSocketManager implements I2PSessionListener {
                     return;
             }
         } catch (I2PException ise) {
-            _log.error("Error processing", ise);
+            _log.error(getName() + ": Error processing", ise);
         } catch (IllegalStateException ise) {
-            _log.debug("Error processing", ise);
+            _log.debug(getName() + ": Error processing", ise);
         }
     }
     
@@ -150,30 +169,45 @@ public class I2PSocketManager implements I2PSessionListener {
      *
      */
     private void ackAvailable(String id, byte payload[]) {
+        long begin = _context.clock().now();
         I2PSocketImpl s = null;
         synchronized (lock) {
             s = (I2PSocketImpl) _outSockets.get(id);
         }
 
         if (s == null) {
-            _log.warn("No socket responsible for ACK packet");
+            _log.warn(getName() + ": No socket responsible for ACK packet");
             return;
         }
 
+        long socketRetrieved = _context.clock().now();
+        
         String remoteId = null;
         remoteId = s.getRemoteID(false); 
 
         if ( (payload.length == 3) && (remoteId == null) ) {
             String newID = toString(payload);
+            long beforeSetRemId = _context.clock().now();
             s.setRemoteID(newID);
+            if (_log.shouldLog(Log.DEBUG)) {
+                _log.debug(getName() + ": ackAvailable - socket retrieval took " 
+                           + (socketRetrieved-begin) + "ms, getRemoteId took "
+                           + (beforeSetRemId-socketRetrieved) + "ms, setRemoteId took "
+                           + (_context.clock().now()-beforeSetRemId) + "ms");
+            }
             return;
         } else {
             // (payload.length != 3 || getRemoteId != null)
             if (_log.shouldLog(Log.WARN)) {
                 if (payload.length != 3)
-                    _log.warn("Ack packet had " + payload.length + " bytes");
+                    _log.warn(getName() + ": Ack packet had " + payload.length + " bytes");
                 else
-                    _log.warn("Remote ID already exists? " + remoteId);
+                    _log.warn(getName() + ": Remote ID already exists? " + remoteId);
+            }
+            if (_log.shouldLog(Log.DEBUG)) {
+                _log.debug(getName() + ": invalid ack - socket retrieval took " 
+                           + (socketRetrieved-begin) + "ms, overall took "
+                           + (_context.clock().now()-begin) + "ms");
             }
             return;
         }
@@ -189,11 +223,11 @@ public class I2PSocketManager implements I2PSessionListener {
             s = (I2PSocketImpl) _outSockets.get(id);
         }
         
-        _log.debug("*Disconnect outgoing for socket " + s);
+        _log.debug(getName() + ": *Disconnect outgoing for socket " + s);
         try {
             if (s != null) {
                 if (payload.length > 0) {
-                    _log.debug("Disconnect packet had "
+                    _log.debug(getName() + ": Disconnect packet had "
                                + payload.length + " bytes");
                 }
                 if (s.getRemoteID(false) == null) {
@@ -207,7 +241,7 @@ public class I2PSocketManager implements I2PSessionListener {
             }
             return;
         } catch (Exception t) {
-            _log.error("Ignoring error on disconnect for socket " + s, t);
+            _log.error(getName() + ": Ignoring error on disconnect for socket " + s, t);
         }
     }
     
@@ -225,12 +259,13 @@ public class I2PSocketManager implements I2PSessionListener {
 
         // packet send outgoing
         if (_log.shouldLog(Log.DEBUG))
-            _log.debug("*Packet send outgoing [" + payload.length + "] for socket " + s);
+            _log.debug(getName() + ": *Packet send outgoing [" + payload.length + "] for socket " + s);
         if (s != null) {
             s.queueData(payload);
             return;
         } else {
-            _log.error("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");
         }
     }
@@ -258,7 +293,7 @@ public class I2PSocketManager implements I2PSessionListener {
                 s.setRemoteID(id);
             }
         }    
-        _log.debug("*Syn! for socket " + s);
+        _log.debug(getName() + ": *Syn! for socket " + s);
         
         if (!acceptConnections) {
             // The app did not instantiate an I2PServerSocket
@@ -268,10 +303,11 @@ public class I2PSocketManager implements I2PSessionListener {
                 replySentOk = _session.sendMessage(d, packet);
             }
             if (!replySentOk) {
-                _log.error("Error sending close to " + d.calculateHash().toBase64()
+                _log.error(getName() + ": Error sending close to " + d.calculateHash().toBase64()
                            + " in response to a new con message", 
                            new Exception("Failed creation"));
             }
+            _context.statManager().addRateData("streaming.nackSent", 1, 1);
             return;
         }
 
@@ -282,10 +318,11 @@ public class I2PSocketManager implements I2PSessionListener {
             replySentOk = _session.sendMessage(d, packet);
             if (!replySentOk) {
                 if (_log.shouldLog(Log.WARN))
-                    _log.warn("Error sending reply to " + d.calculateHash().toBase64()
+                    _log.warn(getName() + ": Error sending reply to " + d.calculateHash().toBase64()
                                + " in response to a new con message for socket " + s,
                                new Exception("Failed creation"));
                 s.internalClose();
+                _context.statManager().addRateData("streaming.ackSendFailed", 1, 1);
             }
         } else {
             // timed out or serverSocket closed
@@ -293,9 +330,10 @@ public class I2PSocketManager implements I2PSessionListener {
             packet[0] = CLOSE_OUT;
             boolean nackSent = session.sendMessage(d, packet);
             if (!nackSent) {
-                _log.warn("Error sending NACK for session creation for socket " + s);
+                _log.warn(getName() + ": Error sending NACK for session creation for socket " + s);
             }
             s.internalClose();
+            _context.statManager().addRateData("streaming,nackSent", 1, 1);
         }
         return;
     }
@@ -314,7 +352,7 @@ public class I2PSocketManager implements I2PSessionListener {
             }
         }
         
-        _log.debug("*Disconnect incoming for socket " + s);
+        _log.debug(getName() + ": *Disconnect incoming for socket " + s);
         
         try {
             if (payload.length == 0 && s != null) {
@@ -322,13 +360,13 @@ public class I2PSocketManager implements I2PSessionListener {
                 return;
             } else {
                 if ( (payload.length > 0) && (_log.shouldLog(Log.ERROR)) )
-                    _log.error("Disconnect packet had " + payload.length + " bytes");
+                    _log.error(getName() + ": Disconnect packet had " + payload.length + " bytes");
                 if (s != null) 
                     s.internalClose();
                 return;
             }
         } catch (Exception t) {
-            _log.error("Ignoring error on disconnect", t);
+            _log.error(getName() + ": Ignoring error on disconnect", t);
             return;
         }
     }
@@ -339,20 +377,20 @@ 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);
         }
 
         if (_log.shouldLog(Log.DEBUG))
-            _log.debug("*Packet send incoming [" + payload.length + "] for socket " + s);
+            _log.debug(getName() + ": *Packet send incoming [" + payload.length + "] for socket " + s);
         
         if (s != null) {
             s.queueData(payload);
             return;
         } else {
-            _log.info("Null socket with data available");
+            _log.info(getName() + ": Null socket with data available");
             throw new IllegalStateException("Null socket with data available");
         }
     }
@@ -362,7 +400,7 @@ public class I2PSocketManager implements I2PSessionListener {
      *
      */
     private void handleUnknown(int type, String id, byte payload[]) {
-        _log.error("\n\n=============== Unknown packet! " + "============" 
+        _log.error(getName() + ": \n\n=============== Unknown packet! " + "============" 
                    + "\nType: " + (int) type
                    + "\nID:   " + getReadableForm(id) 
                    + "\nBase64'ed Data: " + Base64.encode(payload)
@@ -376,7 +414,7 @@ public class I2PSocketManager implements I2PSessionListener {
     }
     
     public void reportAbuse(I2PSession session, int severity) {
-        _log.error("Abuse reported [" + severity + "]");
+        _log.error(getName() + ": Abuse reported [" + severity + "]");
     }
 
     public void setDefaultOptions(I2PSocketOptions options) {
@@ -424,31 +462,40 @@ public class I2PSocketManager implements I2PSessionListener {
             boolean sent = false;
             sent = _session.sendMessage(peer, packet);
             if (!sent) {
-                _log.info("Unable to send & receive ack for SYN packet for socket " + s);
+                _log.info(getName() + ": Unable to send & receive ack for SYN packet for socket " + s);
                 synchronized (lock) {
                     _outSockets.remove(s.getLocalID());
                 }
+                _context.statManager().addRateData("streaming.synNoAck", 1, 1);
                 throw new I2PException("Error sending through I2P network");
             }
-            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) 
+            if (remoteID == null) {
+                _context.statManager().addRateData("streaming.nackReceived", 1, 1);
                 throw new ConnectException("Connection refused by peer for socket " + s);
-            if ("".equals(remoteID)) 
+            }
+            if ("".equals(remoteID)) {
+                _context.statManager().addRateData("streaming.synNoAck", 1, 1);
                 throw new NoRouteToHostException("Unable to reach peer for socket " + s);
+            }
             if (_log.shouldLog(Log.DEBUG))
-                _log.debug("TIMING: s given out for remoteID " 
+                _log.debug(getName() + ": TIMING: s given out for remoteID " 
                            + getReadableForm(remoteID) + " for socket " + s);
             
             return s;
         } catch (InterruptedIOException ioe) {
             if (_log.shouldLog(Log.ERROR))
-                _log.error("Timeout waiting for ack from syn for id " 
+                _log.error(getName() + ": Timeout waiting for ack from syn for id " 
                            + getReadableForm(lcID) + " for socket " + s, ioe);
             synchronized (lock) {
                 _outSockets.remove(s.getLocalID());
             }
             s.internalClose();
+            _context.statManager().addRateData("streaming.synNoAck", 1, 1);
             throw new InterruptedIOException("Timeout waiting for ack");
         } catch (ConnectException ex) {
             s.internalClose();
@@ -458,7 +505,7 @@ public class I2PSocketManager implements I2PSessionListener {
             throw ex;
         } catch (IOException ex) {
             if (_log.shouldLog(Log.ERROR))
-                _log.error("Error sending syn on id " + getReadableForm(lcID) + " for socket " + s, ex);
+                _log.error(getName() + ": Error sending syn on id " + getReadableForm(lcID) + " for socket " + s, ex);
             synchronized (lock) {
                 _outSockets.remove(s.getLocalID());
             }
@@ -466,7 +513,7 @@ public class I2PSocketManager implements I2PSessionListener {
             throw new I2PException("Unhandled IOException occurred");
         } catch (I2PException ex) {
             if (_log.shouldLog(Log.INFO))
-                _log.info("Error sending syn on id " + getReadableForm(lcID) + " for socket " + s, ex);
+                _log.info(getName() + ": Error sending syn on id " + getReadableForm(lcID) + " for socket " + s, ex);
             synchronized (lock) {
                 _outSockets.remove(s.getLocalID());
             }
@@ -474,7 +521,7 @@ public class I2PSocketManager implements I2PSessionListener {
             throw ex;
         } catch (Exception e) {
             s.internalClose();
-            _log.error("Unhandled error connecting", e);
+            _log.error(getName() + ": Unhandled error connecting", e);
             throw new ConnectException("Unhandled error connecting: " + e.getMessage());
         }
     }
@@ -515,7 +562,7 @@ public class I2PSocketManager implements I2PSessionListener {
                 id = (String)iter.next();
                 sock = (I2PSocketImpl)_inSockets.get(id);
                 if (_log.shouldLog(Log.DEBUG))
-                    _log.debug("Closing inSocket \""
+                    _log.debug(getName() + ": Closing inSocket \""
                                + getReadableForm(sock.getLocalID()) + "\"");
                 sock.internalClose();
             }
@@ -525,13 +572,13 @@ public class I2PSocketManager implements I2PSessionListener {
                 id = (String)iter.next();
                 sock = (I2PSocketImpl)_outSockets.get(id);
                 if (_log.shouldLog(Log.DEBUG))
-                    _log.debug("Closing outSocket \""
+                    _log.debug(getName() + ": Closing outSocket \""
                                + getReadableForm(sock.getLocalID()) + "\"");
                 sock.internalClose();
             }            
         }
 
-        _log.debug("Waiting for all open sockets to really close...");
+        _log.debug(getName() + ": Waiting for all open sockets to really close...");
         synchronized (lock) {
             while ((_inSockets.size() != 0) || (_outSockets.size() != 0)) {
                 try {
@@ -541,11 +588,11 @@ public class I2PSocketManager implements I2PSessionListener {
         }
 
         try {
-            _log.debug("Destroying I2P session...");
+            _log.debug(getName() + ": Destroying I2P session...");
             _session.destroySession();
-            _log.debug("I2P session destroyed");
+            _log.debug(getName() + ": I2P session destroyed");
         } catch (I2PSessionException e) {
-            _log.error("Error destroying I2P session", e);
+            _log.error(getName() + ": Error destroying I2P session", e);
         }
     }
 
@@ -571,21 +618,47 @@ public class I2PSocketManager implements I2PSessionListener {
         try {
             return _session.sendMessage(peer, new byte[] { (byte) CHAFF});
         } catch (I2PException ex) {
-            _log.error("I2PException:", ex);
+            _log.error(getName() + ": I2PException:", ex);
             return false;
         }
     }
 
     public void removeSocket(I2PSocketImpl sock) {
         synchronized (lock) {
-            if (_log.shouldLog(Log.DEBUG))
-                _log.debug("Removing socket \"" + getReadableForm(sock.getLocalID()) + "\" [" + sock + "]");
             _inSockets.remove(sock.getLocalID());
             _outSockets.remove(sock.getLocalID());
             lock.notify();
         }
+
+        long now = _context.clock().now();
+        long lifetime = now - sock.getCreatedOn();
+        long timeSinceClose = now - sock.getClosedOn();
+        long sent = sock.getBytesSent();
+        long recv = sock.getBytesReceived();
+
+        if (_log.shouldLog(Log.DEBUG)) {
+            _log.debug(getName() + ": Removing socket \"" + getReadableForm(sock.getLocalID()) + "\" [" + sock 
+                       + ", send: " + sent + ", recv: " + recv
+                       + ", lifetime: " + lifetime + "ms, time since close: " + timeSinceClose + ")]",
+                       new Exception("removeSocket called"));
+        }
+
+        _context.statManager().addRateData("streaming.lifetime", lifetime, lifetime);
+        _context.statManager().addRateData("streaming.sent", sent, lifetime);
+        _context.statManager().addRateData("streaming.received", recv, lifetime);
+        
+        if (sent > recv) {
+            _context.statManager().addRateData("streaming.transferBalance", 1, lifetime);
+        } else if (recv > sent) {
+            _context.statManager().addRateData("streaming.transferBalance", -1, lifetime);
+        } else {
+            // noop
+        }
     }
 
+    public String getName() { return _name; }
+    public void setName(String name) { _name = name; }
+    
     public static String getReadableForm(String id) {
         if (id == null) return "(null)";
         if (id.length() != 3) return "Bogus";

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,93 @@
+<?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, web-fragment.xml">
+        </war>
+    </target>
+    <target name="precompilejsp">
+        <delete dir="../jsp/WEB-INF/" />
+        <delete dir="../jsp/web-fragment.xml" />
+        <delete dir="../jsp/web-out.xml" />
+        <mkdir dir="../jsp/WEB-INF/" />
+        <mkdir dir="../jsp/WEB-INF/classes" />
+        <!-- there are various jspc ant tasks, but they all seem a bit flakey -->
+        <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");
+            }
+        }
+    }
+}