* dropped httptunnel.jar and phttprelay.war from the dist (neither are used)

* automate the building of {lib,weblib,webapps}.tar.bz2 (even if i only run this one more time)

apps/bogobot/Bogobot.java

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

apps/bogobot/Bogoparser.java

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

apps/bogobot/LICENSE_log4j.txt

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

apps/bogobot/LICENSE_pircbot.txt

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

apps/bogobot/bogobot.bat

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

apps/bogobot/bogobot.config

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

apps/bogobot/bogobot.sh

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

apps/bogobot/build-eclipse.xml

@@ -0,0 +1,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, oOo                                     -->
+<!-- version 0.4                                                -->
+<!-- ********************************************************** -->
+
+<project basedir="." default="dist" name="Bogobot">
+
+    <!-- init:
+    Create distribution directory if missing and initialize time stamp for
+    archive naming -->
+    <target name="init">
+        <mkdir dir="dist" />
+        <tstamp>
+            <format pattern="yyyy-MM-dd" property="DSTAMP" />
+        </tstamp>
+    </target>
+
+    <!-- dist.bin:
+    Create the binary distribution archive -->
+    <target depends="init" description="Create the binary distribution archive" name="dist.bin">
+        <zip destfile="dist/Bogobot_${DSTAMP}.zip">
+            <zipfileset dir="${basedir}" includes="bogobot.bat bogobot.config Bogobot.class bogobot.sh Bogoparser.class LICENSE_log4j.txt LICENSE_pircbot.txt log4j-1.2.8.jar pircbot.jar" />
+        </zip>
+    </target>
+
+    <!-- dist.source:
+    Create the source distribution archive -->
+    <target depends="init" description="Create the source distribution archive" name="dist.source">
+        <zip destfile="dist/Bogobot_source_${DSTAMP}.zip">
+            <zipfileset dir="${basedir}" includes="bogobot.bat bogobot.config Bogobot.java bogobot.sh Bogoparser.java build.xml build_eclipse.xml LICENSE_log4j.txt LICENSE_pircbot.txt log4j-1.2.8.jar pircbot.jar" />
+        </zip>
+    </target>
+
+    <!-- dist:
+    Create both the binary and source distribution archives -->
+    <target depends="dist.bin,dist.source" description="Create both the binary and source distribution archives" name="dist">
+        <echo message="Successfully created binary and source distribution archives in directory &apos;dist&apos;." />
+    </target>
+
+    <!-- clean:
+    Delete all class files and temporary directories -->
+    <target description="Delete all class files and temporary directories" name="clean">
+        <delete>
+            <fileset dir="${basedir}" includes="**/*.class" />
+        </delete>
+        <echo message="Clean successful." />
+    </target>
+
+</project>

apps/bogobot/build.xml

@@ -0,0 +1,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, oOo                                     -->
+<!-- version 0.4                                                -->
+<!-- ********************************************************** -->
+
+<project basedir="." default="compile" name="Bogobot">
+
+    <!-- init:
+    Create distribution directory if missing and initialize time stamp for
+    archive naming -->
+    <target name="init">
+        <mkdir dir="dist" />
+        <tstamp>
+            <format pattern="yyyy-MM-dd" property="DSTAMP" />
+        </tstamp>
+    </target>
+
+    <!-- compile:
+    Compile source code -->
+    <target depends="init" description="Compile source code" name="compile">
+        <javac classpath="${basedir};log4j-1.2.8.jar;pircbot.jar" source="1.4" srcdir="." />
+    </target>
+
+    <!-- dist.bin:
+    Create the binary distribution archive -->
+    <target depends="init,compile" description="Create the binary distribution archive" name="dist.bin">
+        <zip destfile="dist/Bogobot_${DSTAMP}.zip">
+            <zipfileset dir="${basedir}" includes="bogobot.bat bogobot.config Bogobot.class Bogobot$BogobotTickTask.class bogobot.sh Bogoparser.class LICENSE_log4j.txt LICENSE_pircbot.txt log4j-1.2.8.jar pircbot.jar" />
+        </zip>
+    </target>
+
+    <!-- dist.source:
+    Create the source distribution archive -->
+    <target depends="init" description="Create the source distribution archive" name="dist.source">
+        <zip destfile="dist/Bogobot_source_${DSTAMP}.zip">
+            <zipfileset dir="${basedir}" includes="bogobot.bat bogobot.config Bogobot.java bogobot.sh Bogoparser.java build.xml build_eclipse.xml LICENSE_log4j.txt LICENSE_pircbot.txt log4j-1.2.8.jar pircbot.jar" />
+        </zip>
+    </target>
+
+    <!-- dist:
+    Create both the binary and source distribution archives -->
+    <target depends="dist.bin,dist.source" description="Create both the binary and source distribution archives" name="dist">
+        <echo message="Successfully created binary and source distribution archives in directory &apos;dist&apos;." />
+    </target>
+
+    <!-- clean:
+    Delete all class files and temporary directories -->
+    <target description="Delete all class files and temporary directories" name="clean">
+        <delete>
+            <fileset dir="${basedir}" includes="**/*.class" />
+        </delete>
+        <echo message="Clean successful." />
+    </target>
+
+</project>

apps/enclave/LICENSE

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

apps/enclave/Makefile.cygwin

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

apps/enclave/Makefile.linux

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

apps/enclave/Makefile.mingw

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

apps/enclave/cfg/enclave.cfg

@@ -0,0 +1,32 @@
+#
+# This is the Enclave configuration file.  Lines starting with # and blank lines
+# are ignored.
+#
+
+# The DNS name or IP address of the SAM server you will be using
+samhost=localhost
+
+# The TCP port the SAM server is listening on
+samport=7656
+
+# The destination name of this program.  This can be anything.  If you run
+# multiple copies of Enclave off the same SAM server then each one has to have a
+# unique name.
+samname=enclave
+
+# The depth used for incoming and outgoing I2P tunnels.  Using a depth of 2 is
+# the default and a good choice.  You can set it to 0 if you don't care about
+# anonymity and just want speed.
+tunneldepth=0
+
+# The location of the peer references file.  You can use an absolute or relative
+# path, but absolute paths are safer.
+references=cfg/peers.ref
+
+# Record every log message at or above this priority level
+# debug = 0, minor = 1, info = 2, warn = 3, error = 4
+loglevel=0
+
+# The location of the Enclave log file.  You can use an absolute or relative
+# path, but absolute paths are safer.
+logfile=log/enclave.log

apps/enclave/cfg/peers.ref

@@ -0,0 +1,2 @@
+4KpEG0uUvTM~IZKuWZZifdmh5UU6evIPG0tE3ppoqy37AY2NJrsM8BU0EkT1SG-g18qSW9UHDp7qs7m~WzeWTXyYggEb6k6-e0GYC2Cj8ED8JV58-2~cFZumVNJ2d1hns-MGX7RZv2lz3Cz2ZVhfZxSIw9UnpV-kwVn7sQ7PBCvJYE4INbp5OlRQH1-3lXiUheoJfeZpegGTUSHUwIRWglX7w87YF~LCbJMYXDgMyA3SaxsZaun7Wc8ku4bqtbmG9u15XlmqimLUUmDG0cw77HJzqxnR1C1hx0wf-9zgH6u4jwTWk92w5tZJZSv1SHKejlPkIbRNAhZv5wroyZsn6T0koV~kTVCvbUEwILho-rHn4A6C2jLQifwE9aucziBTVq3YLK2urf1wI1jLh98iFNav40S~B2w-4xZFAQ49bOdWzY4KmVIjocVhfGi~RLl5bHD1TEJS7nOaDhI8qCSe7mR0XzZgQ~iROR~XowlwKXBzNPjKED7yN8GgV2pWRGNYAAAA
+WiotuvEjGpSz7q14eZGYFpD0xNt3V~nxZdDDgKc~whkW-pardZyz~wZipHXLIOvniThDL2rxJ~OW7RxgUycCph4x--NL51kEJhMWZ~bgxPioxw-T4JGQ9LSNndt9xNOf6yhEqyokqyEOEeJjw6m2e7RX7mTRffmTlCdu6uH6rVEk22o4Uu5S26p6-LS2k9lRyMWitFd~t9cnOgLTZTE~h4d-UlAd1BGxpCTlGWcaynOQzKKtljZknZMF9Qv19MxT83t18~3IURb6aOLlC4oih9pMt1pHouZuOaStKA7cGLsXUAhSB31BvK8l4R7VhgcudwJ9EQZkZQee51hcng7K1Yqmd4lnjHHuf1mDk0YXBAWDZOM0-oEwkJWumGuYl0NUtLhNlFrBjenbjACx88qhfy6mkXfo8c-c2QqEXuD2xt4OVqrWxBTIrr1pR-E1NdIxzIvOlCbrRXaqxqu-wnrrG2vCO-1zu9NHacCVjXD7AR7p3T628wPdCUzj2~rZRcCkAAAA

apps/enclave/libsockthread/LICENSE

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

apps/enclave/libsockthread/src/logger.cpp

@@ -0,0 +1,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/bigint.cpp

@@ -0,0 +1,169 @@
+/*
+ * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the author nor the names of any contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "platform.hpp"
+#include "bigint.hpp"
+
+/******************************************************************************/
+// Note: All the const_casts below are necessary because libtomcrypt doesn't  //
+// have its arguments as const, even when they are not changed                //
+/******************************************************************************/
+
+Bigint::Bigint(const Bigint& bigint)
+{
+	init();
+	copyover_mp_int(bigint.mpi);
+}
+
+Bigint::Bigint(const uchar_t* data, size_t size)
+{
+	init();
+	import_uraw(data, size);
+}
+
+Bigint::Bigint(uint16_t i)
+{
+	init();
+	i = htons(i);
+	import_uraw(reinterpret_cast<uchar_t*>(&i), 2);
+}
+
+Bigint::Bigint(uint32_t i)
+{
+	init();
+	i = htonl(i);
+	import_uraw(reinterpret_cast<uchar_t*>(&i), 4);
+}
+
+/*
+ * Replaces our current mp_int with another one
+ * (just a wrapper for mp_copy)
+ */
+void Bigint::copyover_mp_int(const mp_int& i)
+{
+	int rc = mp_copy(const_cast<mp_int*>(&i), &mpi);
+	assert(rc == MP_OKAY);
+}
+
+/*
+ * Saves a Bigint to a raw unsigned big-endian integer
+ * Note that the result must be freed with delete[]
+ *
+ * size - filled with the size of the output
+ *
+ * Returns: binary data
+ */
+uchar_t* Bigint::export_uraw(size_t& size) const
+{
+	uchar_t* out;
+	size = mp_unsigned_bin_size(const_cast<mp_int*>(&mpi));
+	if (size != 0) {
+		out = new uchar_t[size];
+		int rc = mp_to_unsigned_bin(const_cast<mp_int*>(&mpi), out);
+		assert(rc == MP_OKAY);
+	} else {  // size == 0
+		size = 1;
+		out = new uchar_t[1];
+		out[0] = 0;
+	}
+	return out;
+}
+
+/*
+ * Loads a raw unsigned big-endian integer into Bigint
+ *
+ * data - binary data
+ * size - size of data
+ */
+void Bigint::import_uraw(const uchar_t* data, size_t size)
+{
+	uchar_t tmp[size];				// mp_read_unsigned_bin() arg 2 is not const
+	memcpy(tmp, data, sizeof tmp);	// I'm not taking any chances
+	int rc = mp_read_unsigned_bin(&mpi, tmp, sizeof tmp);
+	assert(rc == MP_OKAY);
+}
+
+/*
+ * Initialises the object
+ */
+void Bigint::init(void)
+{
+	int rc = mp_init(&mpi);
+	assert(rc == MP_OKAY);
+}
+
+bool Bigint::operator<(const Bigint& rhs) const
+{
+	int rc = mp_cmp(const_cast<mp_int*>(&mpi), const_cast<mp_int*>(&rhs.mpi));
+	if (rc == MP_LT)
+		return true;
+	else
+		return false;
+}
+
+Bigint& Bigint::operator=(const Bigint& rhs)
+{
+	if (this != &rhs)  // check for self-assignment: a = a
+		copyover_mp_int(rhs.mpi);
+	return *this;
+}
+
+bool Bigint::operator==(const Bigint& rhs) const
+{
+	int rc = mp_cmp(const_cast<mp_int*>(&mpi), const_cast<mp_int*>(&rhs.mpi));
+	if (rc == MP_EQ)
+		return true;
+	else
+		return false;
+}
+
+bool Bigint::operator>(const Bigint& rhs) const
+{
+	int rc = mp_cmp(const_cast<mp_int*>(&mpi), const_cast<mp_int*>(&rhs.mpi));
+	if (rc == MP_GT)
+		return true;
+	else
+		return false;
+}
+
+/*
+ * Xors another Bigint with this Bigint and puts the result in Bigint `result'.
+ * We can't name it "xor" because that word is reserved in C++ (see Appendex C,
+ * section 3.1 in TC++PL).
+ *
+ * rhs - the bigint to xor with
+ * result - will be filled with the result of the xor
+ */
+void Bigint::x_or(const Bigint& rhs, Bigint& result) const
+{
+	int rc = mp_xor(const_cast<mp_int*>(&mpi), const_cast<mp_int*>(&rhs.mpi),
+		&result.mpi);
+	assert(rc == MP_OKAY);
+}

apps/enclave/src/bigint.hpp

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

apps/enclave/src/chk.cpp

@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the author nor the names of any contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "platform.hpp"
+#include "chk.hpp"
+
+Chk::Chk(const uchar_t* plaintext, size_t size, const string& mime_type)
+	: data_size(size), mime_type(mime_type)
+{
+	encrypt(plaintext);
+}
+
+void Chk::encrypt(const uchar_t *pt)
+{
+	int rc = register_cipher(&twofish_desc);
+	assert(rc != -1);
+
+	uchar_t key[CRYPT_KEY_SIZE], iv[CRYPT_BLOCK_SIZE];
+	prng->get_bytes(key, CRYPT_KEY_SIZE);
+	prng->get_bytes(iv, CRYPT_BLOCK_SIZE);	
+
+	symmetric_CTR ctr;
+	rc = ctr_start(find_cipher("twofish"), iv, key, CRYPT_KEY_SIZE, 0, &ctr);
+	assert(rc == CRYPT_OK);
+
+	ct = new uchar_t[data_size];
+	rc = ctr_encrypt(pt, ct, data_size, &ctr);
+	assert(rc == CRYPT_OK);
+}

apps/enclave/src/chk.hpp

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

apps/enclave/src/config.cpp

@@ -0,0 +1,148 @@
+/*
+ * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the author nor the names of any contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "platform.hpp"
+#include "bigint.hpp"
+
+Config::Config(const string& file)
+	: file(file)
+{
+	set_defaults();
+	parse();
+	configf.close();
+}
+
+/*
+ * Looks up a configuration option in the table and returns a constant value.
+ * This is the same as get_property() except the value returned is a constant.
+ *
+ * key - key to lookup
+ *
+ * Returns the value associated with the key
+ */
+const string& Config::get_cproperty(const string& key) const
+{
+	for (cfgmap_ci i = cfgmap.begin(); i != cfgmap.end(); i++) {
+		const string s = i->first;
+		if (s == key)
+			return i->second;
+	}
+	LERROR << "Tried to lookup an invalid property: " << key << '\n';
+	assert(false);
+	// this should never occur, it's just to silence a compiler warning
+	string* s = new string;
+	return *s;
+}
+
+/*
+ * Gets a property as an integer (they are all stored as strings)
+ *
+ * key - key to lookup
+ *
+ * Returns an integer of the value associated with the key
+ */
+int Config::get_iproperty(const string& key) const
+{
+	for (cfgmap_ci i = cfgmap.begin(); i != cfgmap.end(); i++) {
+		const string s = i->first;
+		if (s == key)
+			return atoi(i->second.c_str());
+	}
+	LERROR << "Tried to lookup an invalid property: " << key << '\n';
+	assert(false);
+	return 0;
+}
+
+/*
+ * Looks up a configuration option in the table and returns the value
+ *
+ * key - key to lookup
+ *
+ * Returns the value associated with the key
+ */
+string& Config::get_property(const string& key)
+{
+	for (cfgmap_i i = cfgmap.begin(); i != cfgmap.end(); i++) {
+		const string s = i->first;
+		if (s == key)
+			return i->second;
+	}
+	LERROR << "Tried to lookup an invalid property: " << key << '\n';
+	assert(false);
+	// this should never occur, it's just to silence a compiler warning
+	string* s = new string;
+	return *s;
+}
+
+/*
+ * Parses the configuration file, replacing default values with user defined
+ * values
+ */
+void Config::parse(void)
+{
+	configf.open(file.c_str());
+	if (!configf) {
+		cerr << "Error opening configuration file (" << file.c_str() << ")\n";
+		throw runtime_error("Error opening configuration file");
+	}
+	size_t line = 0;
+	string s;
+	for (getline(configf, s); configf; getline(configf, s)) {
+		line++;
+		if (s.size() == 0 || s[0] == '#')  // blank line or comment
+			continue;
+		size_t eqpos = s.find("=");
+		if (eqpos == string::npos) {
+			cerr << "Error parsing line #" << line << " in " << file << ": "
+				<< s << '\n';
+			continue;
+		}
+		string key = s.substr(0, eqpos);
+		string value = s.substr(eqpos + 1);
+		//cout << "Inserting key = " << key << " value = " << value << '\n';
+		cfgmap.erase(key);  // erase the default value created by set_defaults()
+		cfgmap.insert(make_pair(key, value));
+	}
+}
+
+/*
+ * If you (the programmer) add something to the config file you should also add
+ * it here, and vice versa
+ */
+void Config::set_defaults(void)
+{
+	cfgmap.insert(make_pair("samhost", "localhost"));
+	cfgmap.insert(make_pair("samport", "7656"));
+	cfgmap.insert(make_pair("samname", "enclave"));
+	cfgmap.insert(make_pair("tunneldepth", "2"));
+	cfgmap.insert(make_pair("references", "cfg/peers.ref"));
+	cfgmap.insert(make_pair("loglevel", "1"));
+	cfgmap.insert(make_pair("logfile", "log/enclave.log"));
+}

apps/enclave/src/config.hpp

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

apps/enclave/src/logger.cpp

@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the author nor the names of any contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "platform.hpp"
+#include "logger.hpp"
+
+Logger::Logger(const string& file)
+	: file(file)
+{
+	set_pri(debug);
+	set_loglevel(static_cast<priority_t>(config->get_iproperty("loglevel")));
+	logf.open(file.c_str(), ios::app);
+	if (!logf) {
+		cerr << "Error opening log file (" << file.c_str() << ")\n";
+		throw runtime_error("Error opening log file");
+	}
+}
+
+#ifdef WIN_STRERROR
+/*
+ * strerror() for primitive operating systems
+ */
+TCHAR* win_strerror(TCHAR* str, size_t size)
+{ 
+	LPVOID lpMsgBuf;
+	DWORD dw = GetLastError();
+	FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
+		NULL, dw, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpMsgBuf,
+		0, NULL);
+	snprintf(str, size, "%s", lpMsgBuf);
+	LocalFree(lpMsgBuf);
+	return str;
+}
+#endif

apps/enclave/src/logger.hpp

@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the author nor the names of any contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef LOGGER_HPP
+#define LOGGER_HPP
+
+/*
+ * LDEBUG - debugging messages
+ * LMINOR - unimportant messages
+ * LINFO - informational messages
+ * LWARN - errors we automatically recover from
+ * LERROR - major, important errors
+ */
+#if VERBOSE_LOGS
+	#define LDEBUG logger->set_pri(Logger::debug); (*logger) << "(D)" << __FILE__ << ':' << __LINE__ << ':' << __func__ << ": "
+	#define LMINOR logger->set_pri(Logger::minor); (*logger) << "(M)" << __FILE__ << ':' << __LINE__ << ':' << __func__ << ": "
+	#define LINFO  logger->set_pri(Logger::info);  (*logger) << "(I)" << __FILE__ << ':' << __LINE__ << ':' << __func__ << ": "
+	#define LWARN  logger->set_pri(Logger::warn);  (*logger) << "(W)" << __FILE__ << ':' << __LINE__ << ':' << __func__ << ": "
+	#define LERROR logger->set_pri(Logger::error); (*logger) << "(E)" << __FILE__ << ':' << __LINE__ << ':' << __func__ << ": "
+#else
+	#define LDEBUG logger->set_pri(Logger::debug); (*logger) << "(D)"
+	#define LMINOR logger->set_pri(Logger::minor); (*logger) << "(M)"
+	#define LINFO  logger->set_pri(Logger::info);  (*logger) << "(I)"
+	#define LWARN  logger->set_pri(Logger::warn);  (*logger) << "(W)"
+	#define LERROR logger->set_pri(Logger::error); (*logger) << "(E)"
+#endif
+
+class Logger {
+	public:
+		typedef enum {debug = 0, minor = 1, info = 2, warn = 3, error = 4}
+			priority_t;
+
+		Logger(const string& file);
+
+		void flush(void) { logf.flush(); }
+		priority_t get_loglevel(void) const { return loglevel; }
+		void set_loglevel(priority_t priority) { loglevel = priority; }
+		Logger& operator<<(char c)
+			{ if (priority >= loglevel) { logf << c; flush(); } return *this; }
+		Logger& operator<<(const char* c)
+			{ if (priority >= loglevel) { logf << c; flush(); } return *this; }
+		Logger& operator<<(int i)
+			{ if (priority >= loglevel) { logf << i; flush(); } return *this; }
+		Logger& operator<<(const string& s)
+			{ if (priority >= loglevel) { logf << s; flush(); } return *this; }
+		Logger& operator<<(unsigned int i)
+			{ if (priority >= loglevel) { logf << i; flush(); } return *this; }
+		void set_pri(priority_t priority) { this->priority = priority; }
+
+	private:
+		priority_t priority;  // importance of the following log message(s)
+		string file;
+		priority_t loglevel;  // write log messsages at or above this priority
+		ofstream logf;
+};
+
+#ifdef WIN_STRERROR
+TCHAR* win_strerror(TCHAR* str, size_t size);
+#endif
+
+#endif  // LOGGER_HPP

apps/enclave/src/main.cpp

@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the author nor the names of any contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "platform.hpp"
+#include "main.hpp"
+
+Config *config;  // Configuration options
+Logger *logger;  // Logging mechanism
+Random *prng;  // Random number generator
+Sam *sam;  // SAM connection
+
+int main(int argc, char* argv[])
+{
+	if (argc != 2) {  // put some getopts stuff in here later
+		cerr << "Please specify the configuration file location.\n" \
+			"e.g. 'bin/enclave cfg/enclave.cfg'\n";
+		return 1;
+	}
+
+	try {
+		config = new Config(argv[1]);
+	} catch (const runtime_error& x) {
+		return 0;
+	}
+	logger = new Logger(config->get_cproperty("logfile"));
+	LINFO << "Enclave DHT - Built on " << __DATE__ << ' ' << __TIME__ << '\n';
+	prng = new Random;
+	try {
+		sam = new Sam(config->get_cproperty("samhost"),
+			config->get_iproperty("samport"), config->get_cproperty("samname"),
+			config->get_iproperty("tunneldepth"));
+	} catch (const Sam_error& x) {
+		LERROR << "SAM error: " << x.what() << '\n';
+		cerr << "SAM error: " << x.what() << '\n';
+		if (x.code() == SAM_SOCKET_ERROR) {
+			LERROR << "Check whether you have specified the correct SAM host " \
+				"and port number, and that I2P is running.\n";
+			cerr << "Check whether you have specified the correct SAM host " \
+				"and port number, and that\nI2P is running.\n";
+		}
+		return 1;
+	}
+	sam->naming_lookup();
+	while (sam->get_my_dest() == "")
+		sam->read_buffer();  // wait until we get our own dest back from lookup
+
+	sam->peers->advertise_self();
+
+	while (true)
+		sam->read_buffer();
+
+	delete sam;
+	delete prng;
+	delete logger;
+	delete config;
+	return 0;
+}

apps/enclave/src/main.hpp

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

apps/enclave/src/near_peer.hpp

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

apps/enclave/src/peer.hpp

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

apps/enclave/src/peers.cpp

@@ -0,0 +1,220 @@
+/*
+ * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the author nor the names of any contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "platform.hpp"
+#include "near_peer.hpp"
+#include "rpc.hpp"
+#include "sha1.hpp"
+#include "peers.hpp"
+
+/*
+ * Inform other peers of our existence and collect the destination addresses of
+ * nearby peers
+ */
+void Peers::advertise_self(void)
+{
+	list<Near_peer> near_peers;
+	get_nearest(sam->get_my_sha1(), PAR_RPCS, near_peers);
+	for (list<Near_peer>::const_iterator i = near_peers.begin();
+			i != near_peers.end(); i++) {
+		Rpc rpc(i->get_peer());
+		rpc.find_peers(sam->get_my_sha1());
+	}
+}
+
+/*
+ * Find the `n' nearest peers by xoring a sha1 with a kaddr
+ *
+ * sha1 - sha1 to find nearness to
+ * n - number of peers to find
+ * near_peers - a list to put the found peers in
+ */
+void Peers::get_nearest(const Sha1& sha1, size_t n,	list<Near_peer>& near_peers)
+{
+	near_peers.clear();  // prevents duplicate peers in the list
+	for (peersmap_i i = peersmap.begin(); i != peersmap.end(); i++) {
+		const Sha1& kaddr = i->first;
+		Bigint distance;
+		sha1.x_or(kaddr, distance);
+		Near_peer np(distance, &(i->second));
+		near_peers.insert(near_peers.end(), np);
+	}
+	near_peers.sort();
+	while (near_peers.size() > n)
+		near_peers.pop_back();
+}
+
+Peer* Peers::get_peer_by_dest(const sam_pubkey_t dest)
+{
+	const string s = dest;
+	return get_peer_by_dest(s);
+}
+
+/*
+ * Gets a peer by its base 64 destination address
+ *
+ * dest - destination
+ *
+ * Returns: pointer to peer, or 0 if the peer wasn't found
+ */
+Peer* Peers::get_peer_by_dest(const string& dest)
+{
+	for (peersmap_i i = peersmap.begin(); i != peersmap.end(); i++) {
+		Peer& tmp = i->second;
+		if (tmp.get_dest() == dest)
+			return &(i->second);
+	}
+	return 0;
+}
+
+/*
+ * Gets a peer by its Kademlia address
+ *
+ * kaddr - Kademlia adddress
+ *
+ * Returns: pointer to peer, or 0 if the peer wasn't found
+ */
+Peer* Peers::get_peer_by_kaddr(const Sha1& kaddr)
+{
+	peersmap_i i = peersmap.find(kaddr);
+	if (i != peersmap.end())
+		return &(i->second);
+	else
+		return 0;
+}
+
+/*
+ * Loads peer addresses from a file
+ */
+void Peers::load(void)
+{
+	string dest;
+
+	ifstream peersf(file.c_str());
+	if (!peersf) {
+		LERROR << "Couldn't load peers reference file (" << file.c_str()
+			<< ")\n";
+		if (peersmap.size() > 0)
+			return;
+		else
+			throw runtime_error("No peer references in memory");
+	}
+
+	for (getline(peersf, dest); peersf; getline(peersf, dest))
+		new_peer(dest);
+
+	if (peersmap.size() > 0) {
+		LMINOR << peersmap.size() << " peer references in memory\n";
+	} else
+		throw runtime_error("No peer references in memory");
+}
+
+Peer* Peers::new_peer(const sam_pubkey_t dest)
+{
+	const string s = dest;
+	return new_peer(s);
+}
+
+/*
+ * Adds a newly discovered peer to the peers map
+ *
+ * dest - destination address of the peer
+ *
+ * Returns: pointer to the peer
+ */
+Peer* Peers::new_peer(const string& dest)
+{
+	// Check the destination address
+	if (!sam->valid_dest(dest)) {
+		LWARN << "Bad format in peer reference: " << dest.substr(0, 8) << '\n';
+		return 0;
+	}
+	// Never add our own peer to the peers we can connect to
+	if (dest == sam->get_my_dest()) {
+		LDEBUG << "Not adding my own peer reference: " << dest.substr(0, 8)
+			<< '\n';
+		return 0;
+	}
+	// Be sure that the peer is not already known to us
+	Peer *peer = get_peer_by_dest(dest);
+	if (peer != 0) {
+		LDEBUG << "Redundant peer reference: " << dest.substr(0, 8) << '\n';
+		return peer;
+	}
+
+	// Tests passed, add it
+	Sha1 sha1(dest);
+	pair<peersmap_i, bool> p = peersmap.insert(
+		make_pair(sha1, Peer(dest, sha1)));
+	assert(p.second);
+	LMINOR << "New peer reference: " << dest.substr(0, 8)
+		<< " (Kaddr: " << sha1.b64hash() << ")\n";
+	peer = &(p.first->second);
+	return peer;
+}
+
+/*
+ * Saves peer destinations to a file
+ *
+ * file - the file to save to
+ */
+void Peers::save(void)
+{
+	ofstream peersf(file.c_str());
+	if (!peersf) {
+		LERROR << "Error opening peers reference file (" << file.c_str()
+			<< ")\n";
+		return;
+	}
+
+	LDEBUG << "Saving " << peersmap.size() + 1 << " peer references\n";
+	peersf << sam->get_my_dest() << '\n';
+	for (peersmap_ci i = peersmap.begin(); i != peersmap.end(); i++) {
+		const Peer& tmp = i->second;
+		peersf << tmp.get_dest() << '\n';
+	}
+}
+
+/*
+ * Stores data on some peers
+ *
+ * sha1 - the sha1 value for the data
+ * data - the data
+ */
+void Peers::store(const Sha1& sha1)
+{
+	list<Near_peer> near_peers;
+	get_nearest(sam->get_my_sha1(), PAR_RPCS, near_peers);
+	for (list<Near_peer>::const_iterator i = near_peers.begin();
+			i != near_peers.end(); i++) {
+		Rpc rpc(i->get_peer());
+		rpc.store(sha1);
+	}
+}

apps/enclave/src/peers.hpp

@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the author nor the names of any contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef PEERS_HPP
+#define PEERS_HPP
+
+class Peers {
+	public:
+		static const int PAR_RPCS = 3;  // The number of parallel RPCs to send
+		static const int RET_REFS = 20;  // The number of peer refs to return on
+										 // failed requests
+		Peers(const string& file)
+			: file(file)
+			{ load(); }
+		~Peers(void) { save(); }
+
+		void advertise_self(void);
+		void get_nearest(const Sha1& sha1, size_t n,
+			list<Near_peer>& near_peers);
+		Peer* get_peer_by_dest(const sam_pubkey_t dest);
+		Peer* get_peer_by_dest(const string& dest);
+		Peer* get_peer_by_kaddr(const Sha1& kaddr);
+		Peer* new_peer(const sam_pubkey_t dest);
+		Peer* new_peer(const string& dest);
+		void store(const Sha1& sha1);
+
+	private:
+		typedef map<const Sha1, Peer>::const_iterator peersmap_ci;
+		typedef map<const Sha1, Peer>::iterator peersmap_i;
+
+		void load(void);
+		void save(void);
+
+		const string file;
+		map<const Sha1, Peer> peersmap;
+};
+
+#endif  // PEERS_HPP

apps/enclave/src/platform.hpp

@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the author nor the names of any contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef PLATFORM_HPP
+#define PLATFORM_HPP
+
+/*
+ * Operating system
+ */
+#define FREEBSD 0  // FreeBSD (untested)
+#define MINGW   1  // Windows native (Mingw)
+#define LINUX   2  // Linux
+#define CYGWIN  3  // Cygwin
+
+#if OS == MINGW
+	#define NO_SSIZE_T
+	#define WIN_STRERROR
+	#define WINSOCK
+	#define WINTHREADS
+#endif
+
+/*
+ * System includes
+ */
+#include <arpa/inet.h>
+#include <cstdlib>
+#include <cstring>
+#include <fstream>
+#include <iostream>
+#include <list>
+#include <map>
+#ifdef WINTHREADS
+	#include <windows.h>
+#else
+	#include <pthread.h>
+#endif
+#include <stdexcept>
+#include <stdint.h>
+#include <string>
+#include <time.h>
+
+using namespace std;
+
+#ifdef NO_SSIZE_T
+	typedef signed long ssize_t;
+#endif
+
+/*
+ * Define this to '1' to cause the printing of source code file and line number
+ * information with each log message.  Set it to '0' for simple logging.
+ */
+#define VERBOSE_LOGS 0
+
+/*
+ * Library includes
+ */
+#include "mycrypt.h"  // LibTomCrypt
+#include "sam.h"  // LibSAM
+
+/*
+ * Local includes
+ */
+#include "mutex.hpp"  // Mutex (for thread.hpp)
+#include "thread.hpp"  // Thread
+#include "logger.hpp"  // Logger
+#include "config.hpp"  // Config
+#include "sam_error.hpp"  // for sam.hpp
+#include "bigint.hpp"  // for sha1.hpp
+#include "sha1.hpp"  // for peers.hpp
+#include "peer.hpp"  // for peers.hpp
+#include "near_peer.hpp"  // for peers.hpp
+#include "peers.hpp" // for sam.hpp
+#include "sam.hpp"  // SAM
+#include "random.hpp"  // Random
+
+/*
+ * Global variables
+ */
+extern Config *config;  // Configuration options
+extern Logger *logger;  // Logging mechanism
+extern Random *prng;  // Random number generator
+extern Sam *sam;  // Sam connection
+
+#endif  // PLATFORM_HPP

apps/enclave/src/random.cpp

@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the author nor the names of any contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "platform.hpp"
+#include "random.hpp"
+
+/*
+ * Prepares the Yarrow PRNG for use
+ */
+Random::Random(void)
+{
+	LMINOR << "Initalising PRNG\n";
+
+	int rc = yarrow_start(&prng);
+	assert(rc == CRYPT_OK);
+
+	uchar_t entropy[ENTROPY_SIZE];
+	size_t sz = rng_get_bytes(entropy, ENTROPY_SIZE, NULL);
+	assert(sz == ENTROPY_SIZE);
+
+	rc = yarrow_add_entropy(entropy, ENTROPY_SIZE, &prng);
+	assert(rc == CRYPT_OK);
+
+	rc = yarrow_ready(&prng);
+	assert(rc == CRYPT_OK);
+}
+
+/*
+ * Gets `size' random bytes from the PRNG
+ *
+ * random - space to fill with random bytes
+ * size - size of `random'
+ */
+void Random::get_bytes(uchar_t* random, size_t size)
+{
+	size_t sz = yarrow_read(random, size, &prng);
+	assert(sz == size);
+}

apps/enclave/src/random.hpp

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

apps/enclave/src/rpc.cpp

@@ -0,0 +1,233 @@
+/*
+ * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the author nor the names of any contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "platform.hpp"
+#include "rpc.hpp"
+
+// These can't be 'const' because I have to make them big-endian first
+uint16_t Rpc::VERSION = htons(1);
+uint16_t Rpc::OLDEST_GOOD_VERSION = htons(1);
+
+/*
+ * Requests a peer to find the addresses of the closest peers to the specified
+ * sha1 and return them
+ *
+ * sha1 - closeness to this sha1
+ */
+void Rpc::find_peers(const Sha1& sha1)
+{
+	LDEBUG << "To: " << peer->get_sdest() << " [" << peer->get_b64kaddr()
+		<< "] Msg: FIND_PEERS\n";
+
+	// VERSION + command + bin sha1
+	const size_t len = sizeof VERSION + 1 + Sha1::SHA1BIN_LEN;
+	uchar_t buf[len];
+	uchar_t* p = static_cast<uchar_t*>(memcpy(buf, &VERSION, sizeof VERSION));
+	p += sizeof VERSION;
+	*p = FIND_PEERS;
+	p++;
+	memcpy(p, sha1.binhash(), Sha1::SHA1BIN_LEN);
+	sam->send_dgram(peer->get_dest(), buf, len);
+}
+
+/*
+ * Returns the closest peer references to a Sha1
+ *
+ * sha1 - sha1 to test nearness to
+ */
+void Rpc::found_peers(const Sha1& sha1)
+{
+	list<Near_peer> near_peers;
+	sam->peers->get_nearest(sha1, Peers::RET_REFS, near_peers);
+	LDEBUG << "To: " << peer->get_sdest() << " [" << peer->get_b64kaddr()
+		<< "] Msg: FOUND_PEERS (" << near_peers.size() << " peers)\n";
+
+	// VERSION + command + number of sha1s (0-255) + bin sha1s
+	const size_t len = sizeof VERSION + 1 + 1 +
+		(near_peers.size() * (SAM_PUBKEY_LEN - 1));
+	assert(near_peers.size() <= 255);
+	uchar_t buf[len];
+	uchar_t* p = static_cast<uchar_t*>(memcpy(buf, &VERSION, sizeof VERSION));
+	p += sizeof VERSION;
+	*p = FOUND_PEERS;
+	p++;
+	*p = near_peers.size();
+	p++;
+	for (list<Near_peer>::const_iterator i = near_peers.begin();
+			i != near_peers.end(); i++) {
+		const Peer* peer = i->get_peer();
+		memcpy(p, peer->get_dest().c_str(), (SAM_PUBKEY_LEN - 1));
+		p += SAM_PUBKEY_LEN - 1;
+	}
+	sam->send_dgram(peer->get_dest(), buf, len);
+}
+
+/*
+ * Parse incoming data and invoke the appropriate RPC
+ *
+ * data - the data
+ * size - the size of `data'
+ */
+void Rpc::parse(const void* data, size_t size)
+{
+	uint16_t his_ver;
+
+	memcpy(&his_ver, data, sizeof VERSION);
+	if (ntohs(his_ver) < ntohs(VERSION)) {
+		LMINOR << "Ignored RPC from " << peer->get_sdest() << " ["
+			<< peer->get_b64kaddr() << "] using obsolete protocol version "
+			<< ntohs(his_ver) << '\n';
+		return;
+	} else if (size <= 4) {
+		LWARN << "RPC too small from " << peer->get_sdest() << " ["
+			<< peer->get_b64kaddr() << "]\n";
+		return;
+	}
+	const uchar_t* p = static_cast<const uchar_t*>(data);
+
+	if (p[2] == PING) {  //-----------------------------------------------------
+		LDEBUG << "From: " << peer->get_sdest() << " [" << peer->get_b64kaddr()
+			<< "] Msg: PING\n";
+		uint32_t ptime;
+		if (size != sizeof VERSION + 1 + sizeof ptime) {
+			LWARN << "Malformed PING RPC from " << peer->get_sdest()
+				<< " [" << peer->get_b64kaddr() << "]\n";
+			return;
+		}
+		p += sizeof VERSION + 1;
+		memcpy(&ptime, p, sizeof ptime);
+		pong(ptime); // no need to ntohl() it here because we're just copying it
+		return;
+
+	} else if (p[2] == PONG) {  //----------------------------------------------
+		LDEBUG << "From: " << peer->get_sdest() << " [" << peer->get_b64kaddr()
+			<< "] Msg: PONG\n";
+		uint32_t ptime;
+		if (size != sizeof VERSION + 1 + sizeof ptime) {
+			LWARN << "Malformed PONG RPC from " << peer->get_sdest()
+				<< " [" << peer->get_b64kaddr() << "]\n";
+			return;
+		}
+		p += sizeof VERSION + 1;
+		memcpy(&ptime, p, sizeof ptime);
+		ptime = ntohl(ptime);
+		uint32_t now = time(NULL);
+		peer->set_lag(now - ptime);
+		LDEBUG << "Lag is " << peer->get_lag() << " seconds\n";
+		return;
+
+	} else if (p[2] == FIND_PEERS) {  //----------------------------------------
+		if (size != sizeof VERSION + 1 + Sha1::SHA1BIN_LEN) {
+			LWARN << "Malformed FIND_PEERS RPC from " << peer->get_sdest()
+				<< " [" << peer->get_b64kaddr() << "]\n";
+			return;
+		}
+		LDEBUG << "From: " << peer->get_sdest() << " [" << peer->get_b64kaddr()
+			<< "] Msg: FIND_PEERS\n";
+		found_peers(Sha1(p + 4));
+		return;
+
+	} else if (p[2] == FOUND_PEERS) {  //---------------------------------------
+		const size_t refs = p[3];
+		if (size != sizeof VERSION + 1 + 1 + (refs * (SAM_PUBKEY_LEN - 1))) {
+			LWARN << "Malformed FOUND_PEERS RPC from " << peer->get_sdest()
+				<< " [" << peer->get_b64kaddr() << "]\n";
+			return;
+		}
+		LDEBUG << "From: " << peer->get_sdest() << " [" << peer->get_b64kaddr()
+			<< "] Msg: FOUND_PEERS (" << refs << " peers)\n";
+		p += sizeof VERSION + 1 + 1;
+		for (size_t i = 1; i <= refs; i++) {
+			sam_pubkey_t dest;
+			memcpy(dest, p, SAM_PUBKEY_LEN - 1);  // - 1 == no NUL in RPC
+			dest[SAM_PUBKEY_LEN - 1] = '\0';
+			//LDEBUG << "Message had: " << dest << '\n';
+			sam->peers->new_peer(dest);
+			p += SAM_PUBKEY_LEN - 1;
+		}
+		return;
+
+	} else  //------------------------------------------------------------------
+		LWARN << "Unknown RPC #" << static_cast<int>(p[2]) << " from "
+			<< peer->get_sdest() << " [" << peer->get_b64kaddr() << "]\n";
+}
+
+/*
+ * Sends a ping to someone
+ */
+void Rpc::ping(void)
+{
+	LDEBUG << "To: " << peer->get_sdest() << " [" << peer->get_b64kaddr()
+		<< "] Msg: PING\n";
+
+	uint32_t now = htonl(time(NULL));
+	// VERSION + command + seconds since 1970
+	const size_t len = sizeof VERSION + 1 + sizeof now;
+	uchar_t buf[len];
+	uchar_t* p = static_cast<uchar_t*>(memcpy(buf, &VERSION, sizeof VERSION));
+	p += sizeof VERSION;
+	*p = PING;
+	p++;
+	memcpy(p, &now, sizeof now);
+	sam->send_dgram(peer->get_dest(), buf, len);
+}
+
+/*
+ * Sends a ping reply to someone
+ *
+ * ptime - the time the peer sent us (we echo the same time back)
+ */
+void Rpc::pong(uint32_t ptime)
+{
+	LDEBUG << "To: " << peer->get_sdest() << " [" << peer->get_b64kaddr()
+		<< "] Msg: PONG\n";
+
+	// VERSION + command + pinger's seconds since 1970 echoed back
+	const size_t len = sizeof VERSION + 1 + sizeof ptime;
+	uchar_t buf[len];
+	uchar_t* p = static_cast<uchar_t*>(memcpy(buf, &VERSION, sizeof VERSION));
+	p += sizeof VERSION;
+	*p = PONG;
+	p++;
+	memcpy(p, &ptime, sizeof ptime);
+	sam->send_dgram(peer->get_dest(), buf, len);
+}
+
+/*
+ * Tells a peer to store some data
+ *
+ * sha1 - sha1 value for the data
+ * data - the data
+ */
+void Rpc::store(const Sha1& sha1)
+{
+	LDEBUG << "To: " << peer->get_sdest() << " [" << peer->get_b64kaddr()
+		<< "] Msg: STORE\n";
+}

apps/enclave/src/rpc.hpp

@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the author nor the names of any contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef RPC_HPP
+#define RPC_HPP
+
+class Rpc {
+	public:
+		// The PROTOCOL version we are using
+		static uint16_t VERSION;
+		// The oldest version we will talk to
+		static uint16_t OLDEST_GOOD_VERSION;
+		// RPC identifiers (0-255)
+		typedef enum {
+			PING = 0,
+			PONG = 1,
+			FIND_PEERS = 2,
+			FOUND_PEERS = 3,
+			STORE = 4
+		} rpc_t;
+
+		Rpc(Peer* peer)
+			: peer(peer) {};
+
+		void find_peers(const Sha1& sha1);
+		void parse(const void* data, size_t size);
+		void ping(void);
+		void store(const Sha1& sha1);
+
+	private:
+		void found_peers(const Sha1& sha1);
+		void pong(uint32_t ptime);
+
+		Peer* peer;
+		basic_string<uchar_t> data;
+};
+
+#endif  // RPC_HPP

apps/enclave/src/sam.cpp

@@ -0,0 +1,249 @@
+/*
+ * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the author nor the names of any contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "platform.hpp"
+#include "rpc.hpp"
+#include "sam.hpp"
+
+extern "C" {
+	/*
+	 * Assorted callbacks required by LibSAM - ugly, but it works
+	 */
+	static void dgramback(sam_pubkey_t dest, void* data, size_t size);
+	static void diedback(void);
+	static void logback(char* str);
+	static void namingback(char* name, sam_pubkey_t pubkey, samerr_t result);
+}
+
+/*
+ * Prevents more than one Sam object from existing in the program at a time
+ * (LibSAM limitation)
+ */
+bool Sam::exists = false;
+
+Sam::Sam(const string& samhost, uint16_t samport, const string& destname,
+	uint_t tunneldepth)
+{
+	// Only allow one Sam object to exist at a time
+	assert(!exists);
+	exists = true;
+
+	// hook up callbacks
+	sam_dgramback = &dgramback;
+	sam_diedback = &diedback;
+	sam_logback = &logback;
+	sam_namingback = &namingback;
+
+	// we haven't connected to SAM yet
+	set_connected(false);
+
+	// now try to connect to SAM
+	connect(samhost.c_str(), samport, destname.c_str(), tunneldepth);
+}
+
+Sam::~Sam(void)
+{
+	delete peers;  // this must be before set_connected(false)!
+	if (is_connected()) {
+		sam_close();
+		set_connected(false);
+	}
+	exists = false;
+}
+
+/*
+ * Connects to the SAM host
+ *
+ * samhost - host that SAM is running on (hostname or IP address)
+ * samport - port number that SAM is running own
+ * destname - the destination name of this program
+ * tunneldepth - how long the tunnels should be
+ */
+void Sam::connect(const char* samhost, uint16_t samport, const char* destname,
+	uint_t tunneldepth)
+{
+	assert(!is_connected());
+	LMINOR << "Connecting to SAM as '" << destname << "'\n";
+	samerr_t rc = sam_connect(samhost, samport, destname, SAM_DGRAM, tunneldepth);
+	if (rc == SAM_OK)
+		set_connected(true);
+	else
+		throw Sam_error(rc);
+}
+
+/*
+ * Loads peer references from disk
+ * Note: this can only be called after my_dest has been set
+ */
+void Sam::load_peers(void)
+{
+	peers = new Peers(config->get_cproperty("references"));
+}
+
+/*
+ * Converts `name' to a base 64 destination
+ *
+ * name - name to lookup
+ */
+void Sam::naming_lookup(const string& name) const
+{
+	assert(is_connected());
+	sam_naming_lookup(name.c_str());
+}
+
+/*
+ * Parses an incoming datagram
+ *
+ * dest - source destination address
+ * data - datagram payload
+ * size - size of `data'
+ */
+void Sam::parse_dgram(const string& dest, void* data, size_t size)
+{
+	assert(is_connected());
+	Peer* peer = peers->new_peer(dest);
+	Rpc rpc(peer);
+	rpc.parse(data, size);
+	rpc.ping();
+	free(data);
+}
+
+/*
+ * Checks the SAM connection for incoming commands and invokes callbacks
+ */
+void Sam::read_buffer(void)
+{
+	assert(is_connected());
+	sam_read_buffer();
+}
+
+/*
+ * Sends a datagram to a destination
+ *
+ * dest - destination to send to
+ * data - data to send
+ * size - size of `data'
+ */
+void Sam::send_dgram(const string& dest, uchar_t *data, size_t size)
+{
+	assert(is_connected());
+	samerr_t rc = sam_dgram_send(dest.c_str(), data, size);
+	assert(rc == SAM_OK);  // i.e. not SAM_TOO_BIG
+}
+
+/*
+ * Sets the connection status
+ *
+ * connected - true for connected, false for disconnected
+ */
+void Sam::set_connected(bool connected)
+{
+	if (!connected)
+		my_dest = "";
+	this->connected = connected;
+}
+
+/*
+ * Sets my destination address
+ *
+ * pubkey - the base 64 destination
+ */
+void Sam::set_my_dest(const sam_pubkey_t pubkey)
+{
+	my_dest = pubkey;
+	my_sha1 = Sha1(my_dest);
+}
+
+/*
+ * Checks whether the destination specified is of a valid base 64 syntax
+ *
+ * Returns: true if it is valid, false if it isn't
+ */
+bool Sam::valid_dest(const string& dest)
+{
+	if (dest.size() != 516)
+		return false;
+	if (dest.substr(512, 4) == "AAAA")  // Note this AAAA signifies a null
+		return true;					// certificate and doesn't actually have
+	else								// any bearing on validity, but we'll
+		return false;					// keep this check here for now anyway
+}
+
+/*
+ * * * * Callbacks * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Unfortunately these aren't part of the "Sam" object because they are function
+ * pointers to _C_ functions.  As a hack, we just have them call the global Sam
+ * object.
+ */
+
+/*
+ * Callback: A datagram was received
+ */
+static void dgramback(sam_pubkey_t dest, void* data, size_t size)
+{
+	sam->parse_dgram(dest, data, size);
+}
+
+/*
+ * Callback: The connection to SAM has failed
+ */
+static void diedback(void)
+{
+	LERROR << "Connection to SAM lost!\n";
+	sam->set_connected(false);
+	throw Sam_error(SAM_SOCKET_ERROR);
+}
+
+/*
+ * Callback: A log message has been sent from LibSAM
+ */
+static void logback(char* str)
+{
+	LINFO << "LibSAM: " << str << '\n';
+}
+
+/*
+ * Callback: A naming lookup has completed
+ */
+static void namingback(char* name, sam_pubkey_t pubkey, samerr_t result)
+{
+	Sam_error res(result);
+	if (res.code() == SAM_OK) {
+		if (strcmp(name, "ME") == 0) {
+			sam->set_my_dest(pubkey);
+			sam->load_peers();
+		} else {
+			assert(false);
+		}
+	} else {
+		LERROR << "Naming look failed for '" << name << "': " << res.what()
+			<< '\n';
+	}
+}

apps/enclave/src/sam.hpp

@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the author nor the names of any contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef SAM_HPP
+#define SAM_HPP
+
+class Sam {
+	public:
+		Sam(const string& samhost, uint16_t samport, const string& destname,
+			uint_t tunneldepth);
+		~Sam(void);
+
+		const string& get_my_dest(void) const { return my_dest; }
+		const Sha1& get_my_sha1(void) const { return my_sha1; }
+		void naming_lookup(const string& name = "ME") const;
+		void read_buffer(void);
+		void send_dgram(const string& dest, uchar_t *data, size_t size);
+		bool valid_dest(const string& dest);
+
+		Peers* peers;
+
+	//callback-private:
+		void load_peers(void);
+		void parse_dgram(const string& dest, void* data, size_t size);
+		void set_connected(bool connected);
+		void set_my_dest(const sam_pubkey_t pubkey);
+
+	private:
+		void connect(const char* samhost, uint16_t samport,
+			const char* destname, uint_t tunneldepth);
+		bool is_connected(void) const { return connected; }
+
+		bool connected;
+		static bool exists;
+		string my_dest;
+		Sha1 my_sha1;
+};
+
+#endif  // SAM_HPP

apps/enclave/src/sam_error.hpp

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

apps/enclave/src/sha1.cpp

@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the author nor the names of any contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "platform.hpp"
+#include "sha1.hpp"
+
+Sha1::Sha1(void)
+{
+	b64hashed = "No value!";
+	memset(binhashed, 0, sizeof binhashed);
+}
+
+Sha1::Sha1(const string& data)
+{
+	/* Hash it */
+	hash_state md;
+	sha1_init(&md);
+	int rc = sha1_process(&md, reinterpret_cast<const uchar_t*>(data.c_str()),
+		data.size());
+	assert(rc == CRYPT_OK);
+	rc = sha1_done(&md, binhashed);
+	assert(rc == CRYPT_OK);
+	b64();
+}
+
+/*
+ * Initialises the Sha1 object from a binary hash
+ */
+Sha1::Sha1(const uchar_t binary[SHA1BIN_LEN])
+{
+	memcpy(binhashed, binary, sizeof binhashed);
+	b64();
+}
+
+/*
+ * Base 64 the binary hash
+ */
+void Sha1::b64(void)
+{
+	ulong_t outlen = 29;
+	char tmp[outlen];
+	// b64 FIXME: replace + with ~, and / with - to be like freenet
+	int rc = base64_encode(binhashed, sizeof binhashed, reinterpret_cast<uchar_t*>(tmp), &outlen);
+	assert(rc == CRYPT_OK);
+	b64hashed = tmp;
+}
+
+/*
+ * Compares two Sha1s, returning true if the this one is less than the right one
+ */
+bool Sha1::operator<(const Sha1& rhs) const
+{
+	Bigint lhsnum(binhashed, SHA1BIN_LEN);
+	Bigint rhsnum(rhs.binhash(), SHA1BIN_LEN);
+	if (lhsnum < rhsnum)
+		return true;
+	else
+		return false;
+}
+
+/*
+ * Assigns a value from another Sha1 to this one
+ */
+Sha1& Sha1::operator=(const Sha1& rhs)
+{
+	if (this != &rhs) {  // check for self-assignment: a = a
+		b64hashed = rhs.b64hash();
+		memcpy(binhashed, rhs.binhash(), sizeof binhashed);
+	}
+	return *this;
+}
+
+/*
+ * Compares Sha1s for equality
+ */
+bool Sha1::operator==(const Sha1& rhs) const
+{
+	if (memcmp(binhashed, rhs.binhash(), sizeof binhashed) == 0)
+		return true;
+	else
+		return false;
+}
+
+/*
+ * Xors this Sha1 with another, and stores the result in a Bigint
+ *
+ * rhs - sha1 to xor this one with
+ * result - will be filled with the result
+ */
+void Sha1::x_or(const Sha1& rhs, Bigint& result) const
+{
+	Bigint lhsnum(binhashed, SHA1BIN_LEN);
+	Bigint rhsnum(rhs.binhash(), SHA1BIN_LEN);
+	lhsnum.x_or(rhsnum, result);
+}

apps/enclave/src/sha1.hpp

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

apps/heartbeat/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,10 +6,10 @@ 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.I2PAppContext;
 import net.i2p.I2PException;
 import net.i2p.client.I2PClient;
 import net.i2p.client.I2PClientFactory;
@@ -46,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 
@@ -219,7 +219,8 @@ class I2PAdapter {
             DataHelper.writeDate(baos, new Date(now));
             int padding = size - baos.size();
             byte paddingData[] = new byte[padding];
-            Arrays.fill(paddingData, (byte) 0x2A);
+            I2PAppContext.getGlobalContext().random().nextBytes(paddingData);
+            //Arrays.fill(paddingData, (byte) 0x2A);
             DataHelper.writeLong(baos, 2, padding);
             baos.write(paddingData);
             boolean sent = _session.sendMessage(peer, baos.toByteArray());
@@ -577,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)
@@ -600,4 +601,4 @@ class I2PAdapter {
             }
         }
     }
-}
+}

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

@@ -2,11 +2,11 @@ package net.i2p.heartbeat;
 
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
-import java.util.Set;
-import java.util.HashSet;
 import java.util.Map;
+import java.util.Set;
 import java.util.TreeMap;
 
 import net.i2p.stat.Rate;
@@ -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

@@ -11,14 +11,14 @@ import java.util.Set;
 import java.util.TreeMap;
 
 import net.i2p.data.Destination;
-import net.i2p.util.Log;
 import net.i2p.heartbeat.ClientConfig;
+import net.i2p.util.Log;
 
 /**
  * Configure how we want to render a particular clientConfig in the GUI
  */
 class PeerPlotConfig {
-    private final static Log _log = new Log(PeerPlotConfig.class);
+    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/EepHandler.java

@@ -7,8 +7,8 @@ import java.io.InputStream;
 import java.io.OutputStream;
 import java.net.SocketException;
 
+import net.i2p.I2PAppContext;
 import net.i2p.I2PException;
-import net.i2p.client.naming.NamingService;
 import net.i2p.client.streaming.I2PSocket;
 import net.i2p.client.streaming.I2PSocketManager;
 import net.i2p.client.streaming.I2PSocketOptions;
@@ -19,7 +19,6 @@ import net.i2p.httptunnel.SocketManagerProducer;
 import net.i2p.httptunnel.filter.Filter;
 import net.i2p.httptunnel.filter.NullFilter;
 import net.i2p.util.Log;
-import net.i2p.I2PAppContext;
 
 /**
  * Handler for browsing Eepsites.

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

@@ -3,7 +3,7 @@ package net.i2p.httptunnel.handler;
 import java.io.IOException;
 import java.io.OutputStream;
 
-import net.i2p.client.naming.NamingService;
+import net.i2p.I2PAppContext;
 import net.i2p.client.streaming.I2PSocketManager;
 import net.i2p.data.Destination;
 import net.i2p.httptunnel.HTTPListener;
@@ -12,14 +12,13 @@ import net.i2p.httptunnel.SocketManagerProducer;
 import net.i2p.httptunnel.filter.Filter;
 import net.i2p.httptunnel.filter.NullFilter;
 import net.i2p.util.Log;
-import net.i2p.I2PAppContext;
 
 /**
  * Handler for proxying "normal" HTTP requests.
  */
 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;
 
@@ -53,6 +54,7 @@ import net.i2p.I2PAppContext;
 import net.i2p.I2PException;
 import net.i2p.client.I2PClient;
 import net.i2p.client.I2PClientFactory;
+import net.i2p.client.I2PSession;
 import net.i2p.client.naming.NamingService;
 import net.i2p.data.Base64;
 import net.i2p.data.DataFormatException;
@@ -67,16 +69,20 @@ public class I2PTunnel implements Logging, EventDispatcher {
     private Log _log;
     private EventDispatcherImpl _event;
     private I2PAppContext _context;
+    private static long __tunnelId = 0;
+    private long _tunnelId;
+    private Properties _clientOptions;
+    private List _sessions;
 
     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"};
 
@@ -98,9 +104,14 @@ public class I2PTunnel implements Logging, EventDispatcher {
     }
 
     public I2PTunnel(String[] args, ConnectionEventListener lsnr) {
-        _context = new I2PAppContext();
+        _context = I2PAppContext.getGlobalContext(); // new I2PAppContext();
+        _tunnelId = ++__tunnelId;
         _log = _context.logManager().getLog(I2PTunnel.class);
         _event = new EventDispatcherImpl();
+        _clientOptions = new Properties();
+        _clientOptions.putAll(System.getProperties());
+        _sessions = new ArrayList(1);
+        
         addConnectionEventListener(lsnr);
         boolean gui = true;
         boolean checkRunByE = true;
@@ -114,7 +125,7 @@ public class I2PTunnel implements Logging, EventDispatcher {
                 checkRunByE = false;
             } else if (args[i].equals("-nogui")) {
                 gui = false;
-                _log.warn("The `-nogui' option of I2PTunnel is deprecated.\n"
+                _log.warn(getPrefix() + "The `-nogui' option of I2PTunnel is deprecated.\n"
                           + "Use `-cli', `-nocli' (aka `-wait') or `-die' instead.");
             } else if (args[i].equals("-cli")) {
                 gui = false;
@@ -164,6 +175,26 @@ public class I2PTunnel implements Logging, EventDispatcher {
         }
     }
 
+    List getSessions() { 
+        synchronized (_sessions) {
+            return new ArrayList(_sessions); 
+        }
+    }
+    void addSession(I2PSession session) { 
+        if (session == null) return;
+        synchronized (_sessions) {
+            _sessions.add(session);
+        }
+    }
+    void removeSession(I2PSession session) { 
+        if (session == null) return;
+        synchronized (_sessions) {
+            _sessions.remove(session);
+        }
+    }
+    
+    public Properties getClientOptions() { return _clientOptions; }
+    
     private void addtask(I2PTunnelTask tsk) {
         tsk.setTunnel(this);
         if (tsk.isOpen()) {
@@ -194,6 +225,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)) {
@@ -259,6 +292,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
@@ -280,7 +336,7 @@ public class I2PTunnel implements Logging, EventDispatcher {
                 serverHost = InetAddress.getByName(args[0]);
             } catch (UnknownHostException uhe) {
                 l.log("unknown host");
-                _log.error("Error resolving " + args[0], uhe);
+                _log.error(getPrefix() + "Error resolving " + args[0], uhe);
                 notifyEvent("serverTaskId", new Integer(-1));
                 return;
             }
@@ -289,7 +345,7 @@ public class I2PTunnel implements Logging, EventDispatcher {
                 portNum = Integer.parseInt(args[1]);
             } catch (NumberFormatException nfe) {
                 l.log("invalid port");
-                _log.error("Port specified is not valid: " + args[1], nfe);
+                _log.error(getPrefix() + "Port specified is not valid: " + args[1], nfe);
                 notifyEvent("serverTaskId", new Integer(-1));
                 return;
             }
@@ -297,11 +353,11 @@ public class I2PTunnel implements Logging, EventDispatcher {
             privKeyFile = new File(args[2]);
             if (!privKeyFile.canRead()) {
                 l.log("private key file does not exist");
-                _log.error("Private key file does not exist or is not readable: " + args[2]);
+                _log.error(getPrefix() + "Private key file does not exist or is not readable: " + args[2]);
                 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);
@@ -333,7 +389,7 @@ public class I2PTunnel implements Logging, EventDispatcher {
                 serverHost = InetAddress.getByName(args[0]);
             } catch (UnknownHostException uhe) {
                 l.log("unknown host");
-                _log.error("Error resolving " + args[0], uhe);
+                _log.error(getPrefix() + "Error resolving " + args[0], uhe);
                 notifyEvent("serverTaskId", new Integer(-1));
                 return;
             }
@@ -342,12 +398,12 @@ public class I2PTunnel implements Logging, EventDispatcher {
                 portNum = Integer.parseInt(args[1]);
             } catch (NumberFormatException nfe) {
                 l.log("invalid port");
-                _log.error("Port specified is not valid: " + args[1], nfe);
+                _log.error(getPrefix() + "Port specified is not valid: " + args[1], nfe);
                 notifyEvent("serverTaskId", new Integer(-1));
                 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);
@@ -373,19 +429,25 @@ 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("Port specified is not valid: " + args[0], nfe);
+                _log.error(getPrefix() + "Port specified is not valid: " + args[0], nfe);
                 notifyEvent("clientTaskId", new Integer(-1));
                 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"
@@ -410,7 +472,7 @@ public class I2PTunnel implements Logging, EventDispatcher {
                 port = Integer.parseInt(args[0]);
             } catch (NumberFormatException nfe) {
                 l.log("invalid port");
-                _log.error("Port specified is not valid: " + args[0], nfe);
+                _log.error(getPrefix() + "Port specified is not valid: " + args[0], nfe);
                 notifyEvent("httpclientTaskId", new Integer(-1));
                 return;
             }
@@ -420,9 +482,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.");
@@ -451,13 +519,13 @@ public class I2PTunnel implements Logging, EventDispatcher {
                 port = Integer.parseInt(args[0]);
             } catch (NumberFormatException nfe) {
                 l.log("invalid port");
-                _log.error("Port specified is not valid: " + args[0], nfe);
+                _log.error(getPrefix() + "Port specified is not valid: " + args[0], nfe);
                 notifyEvent("sockstunnelTaskId", new Integer(-1));
                 return;
             }
 
             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 {
@@ -565,7 +633,7 @@ public class I2PTunnel implements Logging, EventDispatcher {
                 pubdest = new FileOutputStream(args[1]);
             } catch (IOException ioe) {
                 l.log("Error opening output stream");
-                _log.error("Error generating keys to out", ioe);
+                _log.error(getPrefix() + "Error generating keys to out", ioe);
                 notifyEvent("genkeysResult", "error");
                 return;
             }
@@ -588,7 +656,7 @@ public class I2PTunnel implements Logging, EventDispatcher {
         } catch (IOException ioe) {
             l.log("Error generating keys - " + ioe.getMessage());
             notifyEvent("genkeysResult", "error");
-            _log.error("Error generating keys", ioe);
+            _log.error(getPrefix() + "Error generating keys", ioe);
         }
     }
 
@@ -722,7 +790,7 @@ public class I2PTunnel implements Logging, EventDispatcher {
                 notifyEvent("runResult", "ok");
             } catch (IOException ioe) {
                 l.log("IO error running the file");
-                _log.error("Error running the file", ioe);
+                _log.error(getPrefix() + "Error running the file", ioe);
                 notifyEvent("runResult", "error");
             }
         } else {
@@ -776,7 +844,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 {
@@ -796,12 +864,12 @@ public class I2PTunnel implements Logging, EventDispatcher {
     private boolean closetask(int num, boolean forced, Logging l) {
         boolean closed = false;
 
-        _log.debug("closetask(): looking for task " + num);
+        _log.debug(getPrefix() + "closetask(): looking for task " + num);
         synchronized (tasks) {
             for (Iterator it = tasks.iterator(); it.hasNext();) {
                 I2PTunnelTask t = (I2PTunnelTask) it.next();
                 int id = t.getId();
-                _log.debug("closetask(): parsing task " + id + " (" + t.toString() + ")");
+                _log.debug(getPrefix() + "closetask(): parsing task " + id + " (" + t.toString() + ")");
                 if (id == num) {
                     closed = closetask(t, forced, l);
                     break;
@@ -836,7 +904,7 @@ public class I2PTunnel implements Logging, EventDispatcher {
             for (Iterator it = tasks.iterator(); it.hasNext();) {
                 I2PTunnelTask t = (I2PTunnelTask) it.next();
                 if (!t.isOpen()) {
-                    _log.debug("Purging inactive tunnel: [" + t.getId() + "] " + t.toString());
+                    _log.debug(getPrefix() + "Purging inactive tunnel: [" + t.getId() + "] " + t.toString());
                     it.remove();
                 }
             }
@@ -849,7 +917,7 @@ public class I2PTunnel implements Logging, EventDispatcher {
      */
     public void log(String s) {
         System.out.println(s);
-        _log.info("Display: " + s);
+        _log.info(getPrefix() + "Display: " + s);
     }
 
     /**
@@ -982,6 +1050,8 @@ public class I2PTunnel implements Logging, EventDispatcher {
             listeners.remove(lsnr);
         }
     }
+    
+    private String getPrefix() { return '[' + _tunnelId + "]: "; }
 
     /**
      * Call this whenever we lose touch with the router involuntarily (aka the router
@@ -989,7 +1059,7 @@ public class I2PTunnel implements Logging, EventDispatcher {
      *
      */
     void routerDisconnected() {
-        _log.error("Router disconnected - firing notification events");
+        _log.error(getPrefix() + "Router disconnected - firing notification events");
         synchronized (listeners) {
             for (Iterator iter = listeners.iterator(); iter.hasNext();) {
                 ConnectionEventListener lsnr = (ConnectionEventListener) iter.next();

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

@@ -5,7 +5,6 @@ package net.i2p.i2ptunnel;
 
 import java.net.Socket;
 
-import net.i2p.I2PException;
 import net.i2p.client.streaming.I2PSocket;
 import net.i2p.data.DataFormatException;
 import net.i2p.data.Destination;
@@ -20,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

@@ -34,7 +34,7 @@ public abstract class I2PTunnelClientBase extends I2PTunnelTask implements Runna
     private static final long DEFAULT_CONNECT_TIMEOUT = 60 * 1000;
 
     private static volatile long __clientId = 0;
-    private long _clientId;
+    protected long _clientId;
     protected Object sockLock = new Object(); // Guards sockMgr and mySockets
     private I2PSocketManager sockMgr;
     private List mySockets = new ArrayList();
@@ -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,9 +80,14 @@ 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");
 
+        getTunnel().addSession(sockMgr.getSession());
+        
         Thread t = new I2PThread(this);
         t.setName("Client " + _clientId);
         listenerReady = false;
@@ -103,17 +114,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 +145,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 +224,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) {
@@ -254,6 +277,7 @@ public abstract class I2PTunnelClientBase extends I2PTunnelTask implements Runna
                 }
                 return false;
             }
+            getTunnel().removeSession(sockMgr.getSession());
             l.log("Closing client " + toString());
             try {
                 if (ss != null) ss.close();

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

@@ -9,11 +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.ArrayList;
 import java.util.StringTokenizer;
 
+import net.i2p.I2PAppContext;
 import net.i2p.I2PException;
 import net.i2p.client.streaming.I2PSocket;
 import net.i2p.data.DataFormatException;
@@ -45,10 +46,10 @@ 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 404 Not Found\r\n"+
+        ("HTTP/1.1 403 Access Denied\r\n"+
          "Content-Type: text/html; charset=iso-8859-1\r\n"+
          "Cache-control: no-cache\r\n"+
          "\r\n"+
@@ -57,55 +58,98 @@ public class I2PTunnelHTTPClient extends I2PTunnelClientBase implements Runnable
         .getBytes();
     
     private final static byte[] ERR_DESTINATION_UNKNOWN =
-        ("HTTP/1.1 404 Not Found\r\n"+
+        ("HTTP/1.1 503 Service Unavailable\r\n"+
          "Content-Type: text/html; charset=iso-8859-1\r\n"+
          "Cache-control: no-cache\r\n"+
          "\r\n"+
-         "<html><body><H1>I2P ERROR: NOT FOUND</H1>"+
-         "That Desitination was not found. Perhaps you pasted in the wrong "+
-         "BASE64 I2P Destination or the link you are following is bad.  "+
-         "The host (or the WWW proxy, if you're using one) could also be "+
-         "temporarily offline.  You may want to <b>retry</b>.  "+
+         "<html><body><H1>I2P ERROR: DESTINATION NOT FOUND</H1>"+
+         "That I2P Destination was not found. Perhaps you pasted in the "+
+         "wrong BASE64 I2P Destination or the link you are following is "+
+         "bad. The host (or the WWW proxy, if you're using one) could also "+
+	 "be temporarily offline.  You may want to <b>retry</b>.  "+
          "Could not find the following Destination:<BR><BR>")
         .getBytes();
     
     private final static byte[] ERR_TIMEOUT =
-        ("HTTP/1.1 404 Not Found\r\n"+
+        ("HTTP/1.1 504 Gateway Timeout\r\n"+
          "Content-Type: text/html; charset=iso-8859-1\r\n"+
          "Cache-control: no-cache\r\n\r\n"+
          "<html><body><H1>I2P ERROR: TIMEOUT</H1>"+
-         "That Desitination was reachable, but timed out getting a "+
+         "That Destination was reachable, but timed out getting a "+
          "response.  This is likely a temporary error, so you should simply "+
          "try to refresh, though if the problem persists, the remote "+
          "destination may have issues.  Could not get a response from "+
          "the following Destination:<BR><BR>")
         .getBytes();
 
+    private final static byte[] ERR_NO_OUTPROXY =
+        ("HTTP/1.1 503 Service Unavailable\r\n"+
+         "Content-Type: text/html; charset=iso-8859-1\r\n"+
+         "Cache-control: no-cache\r\n"+
+         "\r\n"+
+         "<html><body><H1>I2P ERROR: No outproxy found</H1>"+
+         "Your request was for a site outside of I2P, but you have no "+
+         "HTTP outproxy configured.  Please configure an outproxy in I2PTunnel")
+         .getBytes();
+    
     /** used to assign unique IDs to the threads / clients.  no logic or functionality */
     private static volatile long __clientId = 0;
-    
-    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();
 
         notifyEvent("openHTTPClientResult", "ok");
     }
 
+    private String getPrefix(long requestId) { return "Client[" + _clientId + "/" + requestId + "]: "; }
+    
+    private String selectProxy() {
+        synchronized (proxyList) {
+            int size = proxyList.size();
+            if (size <= 0) {
+                if (_log.shouldLog(Log.INFO))
+                    _log.info("Proxy list is empty - no outproxy available");
+                l.log("Proxy list is emtpy - no outproxy available");
+                return null;
+            }
+            int index = I2PAppContext.getGlobalContext().random().nextInt(size);
+            if (index >= size) index = size - 1;
+            if (index < 0) return null;
+            String proxy = (String)proxyList.get(index);
+            return proxy;
+        }
+    }
+    
+    private static long __requestId = 0;
     protected void clientConnectionRun(Socket s) {
         OutputStream out = null;
         String targetRequest = null;
         boolean usingWWWProxy = false;
+        String currentProxy = null;
         InactivityTimeoutThread timeoutThread = null;
+        long requestId = ++__requestId;
         try {
             out = s.getOutputStream();
             BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream(), "ISO-8859-1"));
@@ -113,7 +157,7 @@ public class I2PTunnelHTTPClient extends I2PTunnelClientBase implements Runnable
             StringBuffer newRequest = new StringBuffer();
             while ((line = br.readLine()) != null) {
                 if (_log.shouldLog(Log.DEBUG))
-                    _log.debug("Line=[" + line + "]");
+                    _log.debug(getPrefix(requestId) + "Line=[" + line + "]");
                 
                 if (line.startsWith("Connection: ") || 
                     line.startsWith("Keep-Alive: ") || 
@@ -122,13 +166,13 @@ public class I2PTunnelHTTPClient extends I2PTunnelClientBase implements Runnable
                 
                 if (method == null) { // first line (GET /base64/realaddr)
                     if (_log.shouldLog(Log.DEBUG))
-                        _log.debug("Method is null for [" + line + "]");
+                        _log.debug(getPrefix(requestId) + "Method is null for [" + line + "]");
                     
                     int pos = line.indexOf(" ");
                     if (pos == -1) break;
                     method = line.substring(0, pos);
                     String request = line.substring(pos + 1);
-                    if (request.startsWith("/") && System.getProperty("i2ptunnel.noproxy") != null) {
+                    if (request.startsWith("/") && getTunnel().getClientOptions().getProperty("i2ptunnel.noproxy") != null) {
                         request = "http://i2p" + request;
                     }
                     pos = request.indexOf("//");
@@ -155,10 +199,29 @@ 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;
+                        if (_log.shouldLog(Log.DEBUG))
+                            _log.debug("Before selecting outproxy for " + host);
+                        currentProxy = selectProxy();
+                        if (_log.shouldLog(Log.DEBUG))
+                            _log.debug("After selecting outproxy for " + host + ": " + currentProxy);
+                        if (currentProxy == null) {
+                            if (_log.shouldLog(Log.WARN))
+                                _log.warn(getPrefix(requestId) + "Host wants to be outproxied, but we dont have any!");
+                            l.log("No HTTP outproxy found for the request.");
+                            if (out != null) {
+                                out.write(ERR_NO_OUTPROXY);
+                                out.write("<p /><i>Generated on: ".getBytes());
+                                out.write(new Date().toString().getBytes());
+                                out.write("</i></body></html>\n".getBytes());
+                                out.flush();
+                            }
+                            s.close();
+                            return;
+                        }
+                        destination = currentProxy;
                         usingWWWProxy = true;
                         if (_log.shouldLog(Log.DEBUG))
-                            _log.debug("Host doesnt end with .i2p and it contains a period [" + host + "]: wwwProxy!");
+                            _log.debug(getPrefix(requestId) + "Host doesnt end with .i2p and it contains a period [" + host + "]: wwwProxy!");
                     } else {
                         request = request.substring(pos + 1);
                         pos = request.indexOf("/");
@@ -168,27 +231,27 @@ public class I2PTunnelHTTPClient extends I2PTunnelClientBase implements Runnable
 
                     boolean isValid = usingWWWProxy || isSupportedAddress(host, protocol);
                     if (!isValid) {
-                        if (_log.shouldLog(Log.INFO)) _log.info("notValid(" + host + ")");
+                        if (_log.shouldLog(Log.INFO)) _log.info(getPrefix(requestId) + "notValid(" + host + ")");
                         method = null;
                         destination = null;
                         break;
                     } else if (!usingWWWProxy) {
-                        if (_log.shouldLog(Log.INFO)) _log.info("host=getHostName(" + destination + ")");
+                        if (_log.shouldLog(Log.INFO)) _log.info(getPrefix(requestId) + "host=getHostName(" + destination + ")");
                         host = getHostName(destination); // hide original host
                     }
 
                     if (_log.shouldLog(Log.DEBUG)) {
-                        _log.debug("METHOD:" + method + ":");
-                        _log.debug("PROTOC:" + protocol + ":");
-                        _log.debug("HOST  :" + host + ":");
-                        _log.debug("DEST  :" + destination + ":");
+                        _log.debug(getPrefix(requestId) + "METHOD:" + method + ":");
+                        _log.debug(getPrefix(requestId) + "PROTOC:" + protocol + ":");
+                        _log.debug(getPrefix(requestId) + "HOST  :" + host + ":");
+                        _log.debug(getPrefix(requestId) + "DEST  :" + destination + ":");
                     }
                     
                 } else {
                     if (line.startsWith("Host: ") && !usingWWWProxy) {
                         line = "Host: " + host;
                         if (_log.shouldLog(Log.INFO)) 
-                            _log.info("Setting host = " + host);
+                            _log.info(getPrefix(requestId) + "Setting host = " + host);
                     }
                 }
                 
@@ -200,7 +263,7 @@ public class I2PTunnelHTTPClient extends I2PTunnelClientBase implements Runnable
                 }
             }
             if (_log.shouldLog(Log.DEBUG))
-                _log.debug("NewRequest header: [" + newRequest.toString() + "]");
+                _log.debug(getPrefix(requestId) + "NewRequest header: [" + newRequest.toString() + "]");
             
             while (br.ready()) { // empty the buffer (POST requests)
                 int i = br.read();
@@ -222,11 +285,13 @@ public class I2PTunnelHTTPClient extends I2PTunnelClientBase implements Runnable
             }
             
             if (_log.shouldLog(Log.DEBUG))
-                _log.debug("Destination: " + destination);
+                _log.debug(getPrefix(requestId) + "Destination: " + destination);
             
             Destination dest = I2PTunnel.destFromName(destination);
             if (dest == null) {
                 l.log("Could not resolve " + destination + ".");
+                if (_log.shouldLog(Log.WARN))
+                    _log.warn("Unable to resolve " + destination + " (proxy? " + usingWWWProxy + ", request: " + targetRequest);
                 writeErrorMessage(ERR_DESTINATION_UNKNOWN, out, targetRequest, usingWWWProxy, destination);
                 s.close();
                 return;
@@ -235,25 +300,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, requestId);
             timeoutThread.start();
         } catch (SocketException ex) {
             if (timeoutThread != null) timeoutThread.disable();
-            _log.info("Error trying to connect", ex);
+            _log.info(getPrefix(requestId) + "Error trying to connect", ex);
             l.log(ex.getMessage());
-            handleHTTPClientException(ex, out, targetRequest, usingWWWProxy, wwwProxy);
+            handleHTTPClientException(ex, out, targetRequest, usingWWWProxy, currentProxy, requestId);
             closeSocket(s);
         } catch (IOException ex) {
             if (timeoutThread != null) timeoutThread.disable();
-            _log.info("Error trying to connect", ex);
+            _log.info(getPrefix(requestId) + "Error trying to connect", ex);
             l.log(ex.getMessage());
-            handleHTTPClientException(ex, out, targetRequest, usingWWWProxy, wwwProxy);
+            handleHTTPClientException(ex, out, targetRequest, usingWWWProxy, currentProxy, requestId);
             closeSocket(s);
         } catch (I2PException ex) {
             if (timeoutThread != null) timeoutThread.disable();
-            _log.info("Error trying to connect", ex);
+            _log.info("getPrefix(requestId) + Error trying to connect", ex);
             l.log(ex.getMessage());
-            handleHTTPClientException(ex, out, targetRequest, usingWWWProxy, wwwProxy);
+            handleHTTPClientException(ex, out, targetRequest, usingWWWProxy, currentProxy, requestId);
             closeSocket(s);
         }
     }
@@ -262,25 +327,29 @@ public class I2PTunnelHTTPClient extends I2PTunnelClientBase implements Runnable
     private static volatile long __timeoutId = 0;
 
     private class InactivityTimeoutThread extends I2PThread {
-
+        
         private Socket s;
         private I2PTunnelRunner _runner;
         private OutputStream _out;
         private String _targetRequest;
         private boolean _useWWWProxy;
+        private String _currentProxy;
+        private long _requestId;
         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, long requestId) {
             this.s = s;
             _runner = runner;
             _out = out;
             _targetRequest = targetRequest;
             _useWWWProxy = useWWWProxy;
+            _currentProxy = currentProxy;
             _disabled = false;
+            _requestId = requestId;
             long timeoutId = ++__timeoutId;
-            setName("InactivityThread " + timeoutId);
+            setName("InactivityThread " + getPrefix(requestId) + timeoutId);
         }
 
         public void disable() {
@@ -293,15 +362,15 @@ public class I2PTunnelHTTPClient extends I2PTunnelClientBase implements Runnable
         public void run() {
             while (!_disabled) {
                 if (_runner.isFinished()) {
-                    if (_log.shouldLog(Log.INFO)) _log.info("HTTP client request completed prior to timeout");
+                    if (_log.shouldLog(Log.INFO)) _log.info(getPrefix(_requestId) + "HTTP client request completed prior to timeout");
                     return;
                 }
                 if (_runner.getLastActivityOn() < Clock.getInstance().now() - INACTIVITY_TIMEOUT) {
                     if (_runner.getStartedOn() < Clock.getInstance().now() - INACTIVITY_TIMEOUT) {
                         if (_log.shouldLog(Log.WARN))
-                            _log.warn("HTTP client request timed out (lastActivity: "
+                            _log.warn(getPrefix(_requestId) + "HTTP client request timed out (lastActivity: "
                                       + new Date(_runner.getLastActivityOn()) + ", startedOn: "
-                                      + new Date(_runner.getLastActivityOn()) + ")");
+                                      + new Date(_runner.getStartedOn()) + ")");
                         timeout();
                         return;
                     } else {
@@ -320,26 +389,27 @@ public class I2PTunnelHTTPClient extends I2PTunnelClientBase implements Runnable
         }
 
         private void timeout() {
-            _log.info("Inactivity timeout reached");
+            _log.info(getPrefix(_requestId) + "Inactivity timeout reached");
             l.log("Inactivity timeout reached");
             if (_out != null) {
                 try {
                     if (_runner.getLastActivityOn() > 0) {
                         // some  data has been sent, so don't 404 it
                     } else {
-                        writeErrorMessage(ERR_TIMEOUT, _out, _targetRequest, _useWWWProxy, wwwProxy);
+                        writeErrorMessage(ERR_TIMEOUT, _out, _targetRequest, _useWWWProxy, _currentProxy);
                     }
                 } catch (IOException ioe) {
-                    _log.warn("Error writing out the 'timeout' message", ioe);
+                    _log.warn(getPrefix(_requestId) + "Error writing out the 'timeout' message", ioe);
                 }
             } else {
-                _log.warn("Client disconnected before we could say we timed out");
+                _log.warn(getPrefix(_requestId) + "Client disconnected before we could say we timed out");
             }
             closeSocket(s);
         }
     }
 
     private final static String getHostName(String host) {
+        if (host == null) return null;
         try {
             Destination dest = I2PTunnel.destFromName(host);
             if (dest == null) return "i2p";
@@ -364,16 +434,19 @@ public class I2PTunnelHTTPClient extends I2PTunnelClientBase implements Runnable
         }
     }
 
-    private static void handleHTTPClientException(Exception ex, OutputStream out, String targetRequest,
-                                                  boolean usingWWWProxy, String wwwProxy) {
+    private void handleHTTPClientException(Exception ex, OutputStream out, String targetRequest,
+                                                  boolean usingWWWProxy, String wwwProxy, long requestId) {
+                                                      
+        if (_log.shouldLog(Log.WARN))
+            _log.warn(getPrefix(requestId) + "Error sending to " + wwwProxy + " (proxy? " + usingWWWProxy + ", request: " + targetRequest, ex);
         if (out != null) {
             try {
                 writeErrorMessage(ERR_DESTINATION_UNKNOWN, out, targetRequest, usingWWWProxy, wwwProxy);
             } catch (IOException ioe) {
-                _log.warn("Error writing out the 'destination was unknown' " + "message", ioe);
+                _log.warn(getPrefix(requestId) + "Error writing out the 'destination was unknown' " + "message", ioe);
             }
         } else {
-            _log.warn("Client disconnected before we could say that destination " + "was unknown", ex);
+            _log.warn(getPrefix(requestId) + "Client disconnected before we could say that destination " + "was unknown", ex);
         }
     }
 

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

@@ -18,7 +18,7 @@ import net.i2p.util.Clock;
 import net.i2p.util.I2PThread;
 import net.i2p.util.Log;
 
-public class I2PTunnelRunner extends I2PThread {
+public class I2PTunnelRunner extends I2PThread implements I2PSocket.SocketErrorListener {
     private final static Log _log = new Log(I2PTunnelRunner.class);
 
     private static volatile long __runnerId;
@@ -51,8 +51,9 @@ public class I2PTunnelRunner extends I2PThread {
         this.slock = slock;
         this.initialData = initialData;
         lastActivityOn = -1;
-        startedOn = -1;
-        _log.info("I2PTunnelRunner started");
+        startedOn = Clock.getInstance().now();
+        if (_log.shouldLog(Log.INFO))
+            _log.info("I2PTunnelRunner started");
         _runnerId = ++__runnerId;
         setName("I2PTunnelRunner " + _runnerId);
         start();
@@ -90,10 +91,10 @@ public class I2PTunnelRunner extends I2PThread {
     }
 
     public void run() {
-        startedOn = Clock.getInstance().now();
         try {
             InputStream in = s.getInputStream();
             OutputStream out = new BufferedOutputStream(s.getOutputStream(), NETWORK_BUFFER_SIZE);
+            i2ps.setSocketErrorListener(this);
             InputStream i2pin = i2ps.getInputStream();
             OutputStream i2pout = new BufferedOutputStream(i2ps.getOutputStream(), MAX_PACKET_SIZE);
             if (initialData != null) {
@@ -121,6 +122,8 @@ public class I2PTunnelRunner extends I2PThread {
         } catch (IOException ex) {
             ex.printStackTrace();
             _log.debug("Error forwarding", ex);
+        } catch (Exception e) {
+            _log.error("Internal error", e);
         } finally {
             try {
                 if (s != null) s.close();
@@ -132,6 +135,13 @@ public class I2PTunnelRunner extends I2PThread {
         }
     }
 
+    public void errorOccurred() {
+        synchronized (finishLock) {
+            finished = true;
+            finishLock.notifyAll();
+        }
+    }
+    
     private volatile long __forwarderId = 0;
     
     private class StreamForwarder extends I2PThread {
@@ -187,7 +197,8 @@ public class I2PTunnelRunner extends I2PThread {
                     out.close();
                     in.close();
                 } catch (IOException ex) {
-                    _log.error("Error closing streams", ex);
+                    if (_log.shouldLog(Log.WARN))
+                        _log.warn("Error closing streams", ex);
                 }
                 synchronized (finishLock) {
                     finished = true;

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

@@ -14,6 +14,7 @@ import java.net.SocketException;
 import java.util.Iterator;
 import java.util.Properties;
 
+import net.i2p.I2PAppContext;
 import net.i2p.I2PException;
 import net.i2p.client.I2PClient;
 import net.i2p.client.I2PClientFactory;
@@ -44,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) {
@@ -61,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);
     }
 
@@ -72,12 +73,14 @@ 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");
+        getTunnel().addSession(sockMgr.getSession());
         l.log("Ready!");
         notifyEvent("openServerResult", "ok");
         open = true;
@@ -128,6 +131,7 @@ public class I2PTunnelServer extends I2PTunnelTask implements Runnable {
             l.log("Shutting down server " + toString());
             try {
                 if (i2pss != null) i2pss.close();
+                getTunnel().removeSession(sockMgr.getSession());
                 sockMgr.getSession().destroySession();
             } catch (I2PException ex) {
                 _log.error("Error destroying the session", ex);
@@ -144,15 +148,8 @@ public class I2PTunnelServer extends I2PTunnelTask implements Runnable {
             I2PServerSocket i2pss = sockMgr.getServerSocket();
             while (true) {
                 I2PSocket i2ps = i2pss.accept();
-                //local is fast, so synchronously. Does not need that many
-                //threads.
-                try {
-                    i2ps.setReadTimeout(readTimeout);
-                    Socket s = new Socket(remoteHost, remotePort);
-                    new I2PTunnelRunner(s, i2ps, slock, null);
-                } catch (SocketException ex) {
-                    i2ps.close();
-                }
+                I2PThread t = new I2PThread(new Handler(i2ps));
+                t.start();
             }
         } catch (I2PException ex) {
             _log.error("Error while waiting for I2PConnections", ex);
@@ -160,5 +157,43 @@ public class I2PTunnelServer extends I2PTunnelTask implements Runnable {
             _log.error("Error while waiting for I2PConnections", ex);
         }
     }
+    
+    /**
+     * Async handler to keep .accept() from blocking too long.  
+     * todo: replace with a thread pool so we dont get overrun by threads if/when
+     * receiving a lot of connection requests concurrently.
+     *
+     */
+    private class Handler implements Runnable { 
+        private I2PSocket _handleSocket;
+        public Handler(I2PSocket socket) {
+            _handleSocket = socket;
+        }
+        public void run() {
+            long afterAccept = I2PAppContext.getGlobalContext().clock().now();
+            long afterSocket = -1;
+            //local is fast, so synchronously. Does not need that many
+            //threads.
+            try {
+                _handleSocket.setReadTimeout(readTimeout);
+                Socket s = new Socket(remoteHost, remotePort);
+                afterSocket = I2PAppContext.getGlobalContext().clock().now();
+                new I2PTunnelRunner(s, _handleSocket, slock, null);
+            } catch (SocketException ex) {
+                try {
+                    _handleSocket.close();
+                } catch (IOException ioe) {
+                    _log.error("Error while closing the received i2p con", ex);
+                }
+            } catch (IOException ex) {
+                _log.error("Error while waiting for I2PConnections", ex);
+            }
+            
+            long afterHandle = I2PAppContext.getGlobalContext().clock().now();
+            long timeToHandle = afterHandle - afterAccept;
+            if (timeToHandle > 1000)
+                _log.warn("Took a while to handle the request [" + timeToHandle + ", socket create: " + (afterSocket-afterAccept) + "]");
+        }
+    }
 }
 

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

@@ -26,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;
@@ -61,6 +64,7 @@ public abstract class I2PTunnelTask implements EventDispatcher {
 
     public void disconnected(I2PSession session) {
         routerDisconnected();
+        getTunnel().removeSession(session);
     }
 
     public void errorOccurred(I2PSession session, String message, Throwable error) {

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,365 @@
+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.client.I2PSession;
+import net.i2p.data.Destination;
+import net.i2p.util.Log;
+
+/**
+ * Coordinate the runtime operation and configuration of a tunnel.  
+ * These objects are bundled together under a TunnelControllerGroup where the
+ * entire group is stored / loaded from a single config file.
+ *
+ */
+public class TunnelController implements Logging {
+    private Log _log;
+    private Properties _config;
+    private I2PTunnel _tunnel;
+    private List _messages;
+    private boolean _running;
+    
+    /**
+     * Create a new controller for a tunnel out of the specific config options.
+     * The config may contain a large number of options - only ones that begin in
+     * the prefix should be used (and, in turn, that prefix should be stripped off
+     * before being interpreted by this controller)
+     * 
+     * @param config original key=value mapping
+     * @param prefix beginning of key values that are relevent to this tunnel
+     */
+    public TunnelController(Properties config, String prefix) {
+        this(config, prefix, true);
+    }
+    /**
+     * 
+     * @param createKey for servers, whether we want to create a brand new destination
+     *                  with private keys at the location specified or not (does not
+     *                  overwrite existing ones)
+     */
+    public TunnelController(Properties config, String prefix, boolean createKey) {
+        _tunnel = new I2PTunnel();
+        _log = I2PAppContext.getGlobalContext().logManager().getLog(TunnelController.class);
+        setConfig(config, prefix);
+        _messages = new ArrayList(4);
+        _running = false;
+        if (createKey && ("server".equals(getType())) )
+            createPrivateKey();
+        if (getStartOnLoad())
+            startTunnel();
+    }
+    
+    private void createPrivateKey() {
+        I2PClient client = I2PClientFactory.createClient();
+        String filename = getPrivKeyFile();
+        if ( (filename == null) || (filename.trim().length() <= 0) ) {
+            log("No filename specified for the private key");
+            return;
+        }
+        
+        File keyFile = new File(getPrivKeyFile());
+        if (keyFile.exists()) {
+            log("Not overwriting existing private keys in " + keyFile.getAbsolutePath());
+            return;
+        } else {
+            File parent = keyFile.getParentFile();
+            if ( (parent != null) && (!parent.exists()) )
+                parent.mkdirs();
+        }
+        FileOutputStream fos = null;
+        try {
+            fos = new FileOutputStream(keyFile);
+            Destination dest = client.createDestination(fos);
+            String destStr = dest.toBase64();
+            log("Private key created and saved in " + keyFile.getAbsolutePath());
+            log("New destination: " + destStr);
+        } catch (I2PException ie) {
+            if (_log.shouldLog(Log.ERROR))
+                _log.error("Error creating new destination", ie);
+            log("Error creating new destination: " + ie.getMessage());
+        } catch (IOException ioe) {
+            if (_log.shouldLog(Log.ERROR))
+                _log.error("Error creating writing the destination to " + keyFile.getAbsolutePath(), ioe);
+            log("Error writing the keys to " + keyFile.getAbsolutePath());
+        } finally {
+            if (fos != null) try { fos.close(); } catch (IOException ioe) {}
+        }
+    }
+    
+    /**
+     * Start up the tunnel (if it isn't already running)
+     *
+     */
+    public void startTunnel() {
+        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 getStartOnLoad() { return "true".equalsIgnoreCase(_config.getProperty("startOnLoad", "true")); }
+    
+    public boolean getIsRunning() { return _running; }
+    
+    public void getSummary(StringBuffer buf) {
+        String type = getType();
+        if ("httpclient".equals(type))
+            getHttpClientSummary(buf);
+        else if ("client".equals(type))
+            getClientSummary(buf);
+        else if ("server".equals(type))
+            getServerSummary(buf);
+        else
+            buf.append("Unknown type ").append(type);
+    }
+    
+    private void getHttpClientSummary(StringBuffer buf) {
+        String description = getDescription();
+        if ( (description != null) && (description.trim().length() > 0) )
+            buf.append("<i>").append(description).append("</i><br />\n");
+        buf.append("HTTP proxy listening on port ").append(getListenPort());
+        String listenOn = getListenOnInterface();
+        if ("0.0.0.0".equals(listenOn)) 
+            buf.append(" (reachable by any machine)");
+        else if ("127.0.0.1".equals(listenOn))
+            buf.append(" (reachable locally only)");
+        else
+            buf.append(" (reachable at the ").append(listenOn).append(" interface)");
+        buf.append("<br />\n");
+        String proxies = getProxyList();
+        if ( (proxies == null) || (proxies.trim().length() <= 0) )
+            buf.append("Outproxy: default [squid.i2p]<br />\n");
+        else
+            buf.append("Outproxy: ").append(proxies).append("<br />\n");
+        getOptionSummary(buf);
+    }
+    
+    private void getClientSummary(StringBuffer buf) {
+        String description = getDescription();
+        if ( (description != null) && (description.trim().length() > 0) )
+            buf.append("<i>").append(description).append("</i><br />\n");
+        buf.append("Client tunnel listening on port ").append(getListenPort());
+        buf.append(" pointing at ").append(getTargetDestination());
+        String listenOn = getListenOnInterface();
+        if ("0.0.0.0".equals(listenOn)) 
+            buf.append(" (reachable by any machine)");
+        else if ("127.0.0.1".equals(listenOn))
+            buf.append(" (reachable locally only)");
+        else
+            buf.append(" (reachable at the ").append(listenOn).append(" interface)");
+        buf.append("<br />\n");
+        getOptionSummary(buf);
+    }
+    
+    private void getServerSummary(StringBuffer buf) {
+        String description = getDescription();
+        if ( (description != null) && (description.trim().length() > 0) )
+            buf.append("<i>").append(description).append("</i><br />\n");
+        buf.append("Server tunnel pointing at port ").append(getTargetPort());
+        buf.append(" on ").append(getTargetHost());
+        buf.append("<br />\n");
+        buf.append("Private destination loaded from ").append(getPrivKeyFile()).append("<br />\n");
+        getOptionSummary(buf);
+    }
+    
+    private void getOptionSummary(StringBuffer buf) {
+        String opts = getClientOptions();
+        if ( (opts != null) && (opts.length() > 0) )
+            buf.append("Network options: ").append(opts).append("<br />\n");
+        if (_running) {
+            List sessions = _tunnel.getSessions();
+            for (int i = 0; i < sessions.size(); i++) {
+                I2PSession session = (I2PSession)sessions.get(i);
+                Destination dest = session.getMyDestination();
+                if (dest != null) {
+                    buf.append("Destination hash: ").append(dest.calculateHash().toBase64()).append("<br />\n");
+                    buf.append("Full destination: ");
+                    buf.append("<input type=\"text\" size=\"10\" onclick=\"this.select();\" ");
+                    buf.append("value=\"").append(dest.toBase64()).append("\" />\n");
+                    if ("server".equals(getType())) {
+                        buf.append(" Give that out to people so they can view your service.");
+                        buf.append(" If you are going to share it on irc, be sure to split it on two lines");
+                    }
+                    buf.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,290 @@
+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 static TunnelControllerGroup _instance;
+    static final String DEFAULT_CONFIG_FILE = "i2ptunnel.config";
+    
+    private List _controllers;
+    private String _configFile = DEFAULT_CONFIG_FILE;
+    
+    public static TunnelControllerGroup getInstance() { 
+        synchronized (TunnelControllerGroup.class) {
+            if (_instance == null)
+                _instance = new TunnelControllerGroup(DEFAULT_CONFIG_FILE);
+            return _instance; 
+        }
+    }
+
+    private TunnelControllerGroup(String configFile) { 
+        _log = I2PAppContext.getGlobalContext().logManager().getLog(TunnelControllerGroup.class);
+        _controllers = new ArrayList();
+        _configFile = configFile;
+        loadControllers(_configFile);
+    }
+    
+    public static void main(String args[]) {
+        if ( (args == null) || (args.length <= 0) ) {
+            _instance = getInstance();
+        } else if (args.length == 1) {
+            if (DEFAULT_CONFIG_FILE.equals(args[0]))
+                _instance = getInstance();
+            else
+                _instance = new TunnelControllerGroup(args[0]);
+        } else {
+            System.err.println("Usage: TunnelControllerGroup [filename]");
+            return;
+        }
+    }
+    
+    /**
+     * Load up all of the tunnels configured in the given file (but do not start
+     * them)
+     *
+     */
+    public void loadControllers(String configFile) {
+        Properties cfg = loadConfig(configFile);
+        if (cfg == null) {
+            if (_log.shouldLog(Log.WARN))
+                _log.warn("Unable to load the config from " + configFile);
+            return;
+        }
+        int i = 0; 
+        while (true) {
+            String type = cfg.getProperty("tunnel." + i + ".type");
+            if (type == null) 
+                break;
+            TunnelController controller = new TunnelController(cfg, "tunnel." + i + ".");
+            _controllers.add(controller);
+            i++;
+        }
+        if (_log.shouldLog(Log.INFO))
+            _log.info(i + " controllers loaded from " + configFile);
+    }
+    
+    public void reloadControllers() {
+        unloadControllers();
+        loadControllers(_configFile);
+    }
+    
+    /**
+     * Stop and remove reference to all known tunnels (but dont delete any config
+     * file or do other silly things)
+     *
+     */
+    public void unloadControllers() {
+        stopAllControllers();
+        _controllers.clear();
+        if (_log.shouldLog(Log.INFO))
+            _log.info("All controllers stopped and unloaded");
+    }
+    
+    /**
+     * Add the given tunnel to the set of known controllers (but dont add it to
+     * a config file or start it or anything)
+     *
+     */
+    public void addController(TunnelController controller) { _controllers.add(controller); }
+    
+    /**
+     * Stop and remove the given tunnel
+     *
+     * @return list of messages from the controller as it is stopped
+     */
+    public List removeController(TunnelController controller) {
+        if (controller == null) return new ArrayList();
+        controller.stopTunnel();
+        List msgs = controller.clearMessages();
+        _controllers.remove(controller);
+        msgs.add("Tunnel " + controller.getName() + " removed");
+        return msgs;
+    }
+    
+    /**
+     * Stop all tunnels
+     *
+     * @return list of messages the tunnels generate when stopped
+     */
+    public List stopAllControllers() {
+        List msgs = new ArrayList();
+        for (int i = 0; i < _controllers.size(); i++) {
+            TunnelController controller = (TunnelController)_controllers.get(i);
+            controller.stopTunnel();
+            msgs.addAll(controller.clearMessages());
+        }
+        
+        if (_log.shouldLog(Log.INFO))
+            _log.info(_controllers.size() + " controllers stopped");
+        return msgs;
+    }
+    
+    /**
+     * Start all tunnels
+     *
+     * @return list of messages the tunnels generate when started
+     */
+    public List startAllControllers() {
+        List msgs = new ArrayList();
+        for (int i = 0; i < _controllers.size(); i++) {
+            TunnelController controller = (TunnelController)_controllers.get(i);
+            controller.startTunnel();
+            msgs.addAll(controller.clearMessages());
+        }
+        
+        if (_log.shouldLog(Log.INFO))
+            _log.info(_controllers.size() + " controllers started");
+        return msgs;
+    }
+    
+    /**
+     * Restart all tunnels
+     *
+     * @return list of messages the tunnels generate when restarted
+     */
+    public List restartAllControllers() {
+        List msgs = new ArrayList();
+        for (int i = 0; i < _controllers.size(); i++) {
+            TunnelController controller = (TunnelController)_controllers.get(i);
+            controller.restartTunnel();
+            msgs.addAll(controller.clearMessages());
+        }
+        if (_log.shouldLog(Log.INFO))
+            _log.info(_controllers.size() + " controllers restarted");
+        return msgs;
+    }
+    
+    /**
+     * Fetch all outstanding messages from any of the known tunnels
+     *
+     * @return list of messages the tunnels have generated
+     */
+    public List clearAllMessages() {
+        List msgs = new ArrayList();
+        for (int i = 0; i < _controllers.size(); i++) {
+            TunnelController controller = (TunnelController)_controllers.get(i);
+            msgs.addAll(controller.clearMessages());
+        }
+        return msgs;
+    }
+    
+    /**
+     * Save the configuration of all known tunnels to the default config 
+     * file
+     *
+     */
+    public void saveConfig() {
+        saveConfig(_configFile);
+    }
+    /**
+     * Save the configuration of all known tunnels to the given file
+     *
+     */
+    public void saveConfig(String configFile) {
+        _configFile = configFile;
+        File cfgFile = new File(configFile);
+        File parent = cfgFile.getParentFile();
+        if ( (parent != null) && (!parent.exists()) )
+            parent.mkdirs();
+        
+        
+        TreeMap map = new TreeMap();
+        for (int i = 0; i < _controllers.size(); i++) {
+            TunnelController controller = (TunnelController)_controllers.get(i);
+            Properties cur = controller.getConfig("tunnel." + i + ".");
+            map.putAll(cur);
+        }
+        
+        StringBuffer buf = new StringBuffer(1024);
+        for (Iterator iter = map.keySet().iterator(); iter.hasNext(); ) {
+            String key = (String)iter.next();
+            String val = (String)map.get(key);
+            buf.append(key).append('=').append(val).append('\n');
+        }
+        
+        FileOutputStream fos = null;
+        try {
+            fos = new FileOutputStream(cfgFile);
+            fos.write(buf.toString().getBytes());
+            if (_log.shouldLog(Log.INFO))
+                _log.info("Config written to " + cfgFile.getPath());
+        } catch (IOException ioe) {
+            _log.error("Error writing out the config");
+        } finally {
+            if (fos != null) try { fos.close(); } catch (IOException ioe) {}
+        }
+    }
+    
+    /**
+     * Load up the config data from the file
+     *
+     * @return properties loaded or null if there was an error
+     */
+    private Properties loadConfig(String configFile) {
+        File cfgFile = new File(configFile);
+        if (!cfgFile.exists()) {
+            if (_log.shouldLog(Log.ERROR))
+                _log.error("Unable to load the controllers from " + configFile);
+            return null;
+        }
+        
+        Properties props = new Properties();
+        FileInputStream fis = null;
+        try {
+            fis = new FileInputStream(cfgFile);
+            BufferedReader in = new BufferedReader(new InputStreamReader(fis));
+            String line = null;
+            while ( (line = in.readLine()) != null) {
+                line = line.trim();
+                if (line.length() <= 0) continue;
+                if (line.startsWith("#") || line.startsWith(";"))
+                    continue;
+                int eq = line.indexOf('=');
+                if ( (eq <= 0) || (eq >= line.length() - 1) )
+                    continue;
+                String key = line.substring(0, eq);
+                String val = line.substring(eq+1);
+                props.setProperty(key, val);
+            }
+            
+            if (_log.shouldLog(Log.INFO))
+                _log.info("Props loaded with " + props.size() + " lines");
+            return props;
+        } catch (IOException ioe) {
+            if (_log.shouldLog(Log.ERROR))
+                _log.error("Error reading the controllers from " + configFile, ioe);
+            return null;
+        } finally {
+            if (fis != null) try { fis.close(); } catch (IOException ioe) {}
+        }
+    }
+    
+    /**
+     * Retrieve a list of tunnels known
+     *
+     * @return list of TunnelController objects
+     */
+    public List getControllers() { return _controllers; }
+    
+}

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

@@ -0,0 +1,313 @@
+package net.i2p.i2ptunnel;
+
+import java.io.File;
+
+import java.util.Iterator;
+import java.util.Properties;
+import java.util.Random;
+import java.util.StringTokenizer;
+
+/**
+ * Uuuugly... 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");
+        buf.append("<b>Start automatically?</b> \n");
+        buf.append("<input type=\"checkbox\" name=\"startOnLoad\" value=\"true\" ");
+        if ( (controller != null) && (controller.getStartOnLoad()) )
+            buf.append(" checked=\"true\" />\n<br />\n");
+        else
+            buf.append(" />\n<br />\n");
+    }
+
+    /**
+     * Retrieve the client options from the tunnel
+     *
+     * @return map of name=val to be used as I2P session options
+     */
+    private static Properties getOptions(TunnelController controller) {
+        if (controller == null) return null;
+        String opts = controller.getClientOptions();
+        StringTokenizer tok = new StringTokenizer(opts);
+        Properties props = new Properties();
+        while (tok.hasMoreTokens()) {
+            String pair = tok.nextToken();
+            int eq = pair.indexOf('=');
+            if ( (eq <= 0) || (eq >= pair.length()) )
+                continue;
+            String key = pair.substring(0, eq);
+            String val = pair.substring(eq+1);
+            props.setProperty(key, val);
+        }
+        return props;
+    }
+}

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

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

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

@@ -0,0 +1,147 @@
+package net.i2p.i2ptunnel;
+
+import java.util.List;
+import net.i2p.I2PAppContext;
+import net.i2p.util.Log;
+
+/**
+ * Ugly hack to let the web interface access the list of known tunnels and
+ * control their operation.  Any data submitted by setting properties are 
+ * acted upon by calling getActionResults() (which returns any messages
+ * generated).  In addition, the getSummaryList() generates the html for
+ * summarizing all of the tunnels known, including both their status and the
+ * links to edit, stop, or start them.
+ *
+ */
+public class WebStatusPageHelper {
+    private Log _log;
+    private String _action;
+    private int _controllerNum;
+    
+    public WebStatusPageHelper() {
+        _action = null;
+        _controllerNum = -1;
+        _log = I2PAppContext.getGlobalContext().logManager().getLog(WebStatusPageHelper.class);
+    }
+    
+    public void setAction(String action) {
+        _action = action;
+    }
+    public void setNum(String num) {
+        if (num != null) {
+            try {
+                _controllerNum = Integer.parseInt(num);
+            } catch (NumberFormatException nfe) {
+                _controllerNum = -1;
+            }
+        }
+    }
+    
+    public String getActionResults() {
+        try {
+            return processAction();
+        } catch (Throwable t) {
+            _log.log(Log.CRIT, "Internal error processing web status", t);
+            return "Internal error processing request - " + t.getMessage();
+        }
+    }
+    
+    public String getSummaryList() {
+        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().reloadControllers();
+        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();
+        }
+    }
+}