* 2004-12-08 0.4.2.3 released

* Revised the buffering when reading from the SAM client and writing
      to the stream.  Also added a thread (sigh) so we don't block the
      SAM client from giving us more messages for abnormally long periods
      of time.
    * Display the router version in the logs on startup (oft requested)
    * Fix a race during the closing of a messageOutputStream

apps/bogobot/Bogobot.java

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

apps/bogobot/Bogoparser.java

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

apps/bogobot/LICENSE.log4j.txt

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

apps/bogobot/LICENSE.pircbot.txt

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

apps/bogobot/bogobot.bat

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

apps/bogobot/bogobot.config

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

apps/bogobot/bogobot.sh

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

apps/bogobot/build-eclipse.xml

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

apps/bogobot/build.xml

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

apps/enclave/LICENSE

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

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

apps/enclave/Makefile.linux

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

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

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

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

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

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

apps/enclave/libsockthread/src/logger.hpp

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

apps/enclave/libsockthread/src/mutex.cpp

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

apps/enclave/libsockthread/src/mutex.hpp

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

apps/enclave/libsockthread/src/platform.hpp

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

apps/enclave/libsockthread/src/socket.cpp

@@ -1,277 +0,0 @@
-/*
- * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *     * Neither the name of the author nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
- * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include <cassert>
-using namespace std;
-#include "platform.hpp"
-#include "socket.hpp"
-using namespace Libsockthread;
-
-size_t Socket::total = 0;  // the total number of sockets in use
-
-/*
- * Constructs an IPv4 TCP socket
- */
-Socket::Socket(void)
-{
-	++total;
-	try {
-#ifdef WINSOCK
-		if (total == 1)
-			winsock_startup();
-#endif
-		create_socket(PF_INET, SOCK_STREAM);
-	} catch (const Socket_error& x) {
-		--total;
-		throw;
-	}
-}
-
-/*
- * Constructs the socket
- *
- * domain - either PF_INET or PF_INET6
- * type - either SOCK_STREAM or SOCK_DGRAM
- */
-Socket::Socket(int domain, int type)
-{
-	++total;
-	try {
-#ifdef WINSOCK
-		if (total == 1)
-			winsock_startup();
-#endif
-		create_socket(domain, type);
-	} catch {const Socket_error& x) {
-		--total;
-		throw;
-	}
-}
-
-/*
- * Destroys the socket
- */
-Socket::~Socket(void)
-{
-	close();
-	--total;
-	assert(total >= 0);
-#ifdef WINSOCK
-	if (total == 0)
-		winsock_cleanup();
-#endif
-}
-
-/*
- * Closes the socket
- */
-void Socket::close(void)
-{
-#ifdef WINSOCK
-	if (closesocket(sock) == SOCKET_ERROR) {
-		LERROR("closesocket() failed: %s", winsock_strerror(WSAGetLastError()));
-	}
-#else
-	if (close(sock) == -1) {
-		LERROR("close() failed: %s", strerror(errno));
-	}
-#endif
-}
-
-/*
- * Creates the socket
- *
- * domain - either PF_INET or PF_INET6
- * type - either SOCK_STREAM or SOCK_DGRAM
- */
-void Socket::create_socket(int domain, int type)
-{
-	assert((domain == PF_INET || domain == PF_INET6) &&
-		(type == SOCK_STREAM || type == SOCK_DGRAM));
-	sock = socket(domain, type, 0);
-#ifdef WINSOCK
-	if (sock == INVALID_SOCKET)
-		throw Socket_error(sam_winsock_strerror(WSAGetLastError()));
-#else
-	if (sock == -1)
-		throw Socket_error(strerror(errno));
-#endif
-}
-
-#ifdef WINSOCK
-/*
- * Unloads the Winsock network subsystem
- */
-void Socket::winsock_cleanup(void)
-{
-	int rc = WSACleanup();
-	assert(rc != SOCKET_ERROR);
-}
-
-/*
- * Loads the Winsock network sucksystem
- */
-void Socket::winsock_startup(void)
-{
-	WORD wVersionRequested = MAKEWORD(2, 2);
-	WSADATA wsaData;
-	int rc = WSAStartup(wVersionRequested, &wsaData);
-	if (rc != 0)
-		throw Socket_error(winsock_strerror(rc));
-	if (LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 2) {
-		winsock_cleanup();
-		throw Socket_error("Bad Winsock version");
-	}
-}
-
-/*
- * Apparently Winsock does not have a strerror() equivalent for its functions
- *
- * code - code from WSAGetLastError()
- *
- * Returns: error string (from http://msdn.microsoft.com/library/default.asp?
- *		url=/library/en-us/winsock/winsock/windows_sockets_error_codes_2.asp)
- */
-const char* Socket::winsock_strerror(int code)
-{
-	switch (code) {
-		case WSAEINTR:
-			return "Interrupted function call";
-		case WSAEACCES:  // yes, that is the correct spelling
-			return "Permission denied";
-		case WSAEFAULT:
-			return "Bad address";
-		case WSAEINVAL:
-			return "Invalid argument";
-		case WSAEMFILE:
-			return "Too many open files";
-		case WSAEWOULDBLOCK:
-			return "Resource temporarily unavailable";
-		case WSAEINPROGRESS:
-			return "Operation now in progress";
-		case WSAEALREADY:
-			return "Operation already in progress";
-		case WSAENOTSOCK:
-			return "Socket operations on nonsocket";
-		case WSAEDESTADDRREQ:
-			return "Destination address required";
-		case WSAEMSGSIZE:
-			return "Message too long";
-		case WSAEPROTOTYPE:
-			return "Protocol wrong type for socket";
-		case WSAENOPROTOOPT:
-			return "Bad protocol option";
-		case WSAEPROTONOSUPPORT:
-			return "Protocol not supported";
-		case WSAESOCKTNOSUPPORT:
-			return "Socket type not supported";
-		case WSAEOPNOTSUPP:
-			return "Operation not supported";
-		case WSAEPFNOSUPPORT:
-			return "Protocol family not supported";
-		case WSAEAFNOSUPPORT:
-			return "Address family not supported by protocol family";
-		case WSAEADDRINUSE:
-			return "Address already in use";
-		case WSAEADDRNOTAVAIL:
-			return "Cannot assign requested address";
-		case WSAENETDOWN:
-			return "Network is down";
-		case WSAENETUNREACH:
-			return "Network is unreachable";
-		case WSAENETRESET:
-			return "Network dropped connection on reset";
-		case WSAECONNABORTED:
-			return "Software caused connection abort";
-		case WSAECONNRESET:
-			return "Connection reset by peer";
-		case WSAENOBUFS:
-			return "No buffer space available";
-		case WSAEISCONN:
-			return "Socket is already connected";
-		case WSAENOTCONN:
-			return "Socket is not connected";
-		case WSAESHUTDOWN:
-			return "Cannot send after socket shutdown";
-		case WSAETIMEDOUT:
-			return "Connection timed out";
-		case WSAECONNREFUSED:
-			return "Connection refused";
-		case WSAEHOSTDOWN:
-			return "Host is down";
-		case WSAEHOSTUNREACH:
-			return "No route to host";
-		case WSAEPROCLIM:
-			return "Too many processes";
-		case WSASYSNOTREADY:
-			return "Network subsystem is unavailable";
-		case WSAVERNOTSUPPORTED:
-			return "Winsock.dll version out of range";
-		case WSANOTINITIALISED:
-			return "Successful WSAStartup not yet performed";
-		case WSAEDISCON:
-			return "Graceful shutdown in progress";
-		case WSATYPE_NOT_FOUND:
-			return "Class type not found";
-		case WSAHOST_NOT_FOUND:
-			return "Host not found";
-		case WSATRY_AGAIN:
-			return "Nonauthoritative host not found";
-		case WSANO_RECOVERY:
-			return "This is a nonrecoverable error";
-		case WSANO_DATA:
-			return "Valid name, no data record of requested type";
-/* None of this shit compiles under Mingw - who knows why...
-		case WSA_INVALID_HANDLE:
-			return "Specified event object handle is invalid";
-		case WSA_INVALID_PARAMETER:
-			return "One or more parameters are invalid";
-		case WSA_IO_INCOMPLETE:
-			return "Overlapped I/O event object not in signaled state";
-		case WSA_IO_PENDING:
-			return "Overlapped operations will complete later";
-		case WSA_NOT_ENOUGH_MEMORY:
-			return "Insufficient memory available";
-		case WSA_OPERATION_ABORTED:
-			return "Overlapped operation aborted";
-		case WSAINVALIDPROCTABLE:
-			return "Invalid procedure table from service provider";
-		case WSAINVALIDPROVIDER:
-			return "Invalid service provider version number";
-		case WSAPROVIDERFAILEDINIT:
-			return "Unable to initialize a service provider";
-*/
-		case WSASYSCALLFAILURE:
-			return "System call failure";
-		default:
-			return "Unknown error";
-	}
-}
-#endif  // WINSOCK

apps/enclave/libsockthread/src/socket.hpp

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

apps/enclave/libsockthread/src/socket_addr.cpp

@@ -1,83 +0,0 @@
-/*
- * Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *     * Neither the name of the author nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
- * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include <arpa/inet.h>
-#include <cassert>
-using namespace std;
-#include "platform.hpp"
-#include "socket.hpp"
-#include "socket_addr.hpp"
-using namespace Libsockthread;
-
-Socket_addr::Socket_addr(int domain, const string& host, uint16_t port)
-	: domain(domain), host(host), port(port)
-{
-	memset(&hostaddr, 0, sizeof hostaddr);
-	hostaddr.sin_family = domain;
-	hostaddr.sin_port = htons(port);
-	resolve(host.c_str(), ipaddr);
-	int rc;
-#ifdef NO_INET_ATON
-	rc = hostaddr.sin_addr.s_addr = inet_addr(ipaddr);
-#elif defined NO_INET_PTON
-	rc = inet_aton(ipaddr, &hostaddr.sin_addr);
-#else
-	rc = inet_pton(AF_INET, ipaddr, &hostaddr.sin_addr);
-#endif
-	assert(rc != 0 && rc != -1);
-}
-
-/*
- * Performs a DNS lookup on `hostname' and puts the result in `ipaddr'
- */
-bool Socket::resolve(const char* hostname, char* ipaddr)
-{
-	struct hostent *h;
-#ifdef NO_GETHOSTBYNAME2
-	h = gethostbyname(hostname);
-#else
-	h = gethostbyname2(hostname, domain);
-#endif
-	if (h == 0) {
-		LWARN("DNS resolution failed for %s", hostname);
-		throw Socket_error("DNS resolution failed");
-	}
-	struct in_addr a;
-	a.s_addr = ((struct in_addr *)h->h_addr)->s_addr;
-#ifdef NO_INET_NTOP
-	char *tmp;
-	tmp = inet_ntoa(a);
-	assert(tmp != 0);
-	strlcpy(ipaddr, tmp, INET_ADDRSTRLEN);  // inet_ntoa() was very poorly designed
-#else
-	int rc = inet_ntop(domain, &a, ipaddr, INET_ADDRSTRLEN);
-	assert(rc != 0);
-#endif
-}

apps/enclave/libsockthread/src/socket_addr.hpp

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

apps/enclave/libsockthread/src/strl.c

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

apps/enclave/libsockthread/src/strl.h

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

apps/enclave/libsockthread/src/thread.cpp

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

apps/enclave/libsockthread/src/thread.hpp

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

apps/enclave/libsockthread/src/time.cpp

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

apps/enclave/libsockthread/src/time.hpp

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

apps/enclave/src/bigint.cpp

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,56 +0,0 @@
-/*
- * 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/src/net/i2p/heartbeat/PeerData.java

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

apps/i2ptunnel/java/build.xml

@@ -4,6 +4,7 @@
     <target name="build" depends="builddep, jar" />
     <target name="builddep">
         <ant dir="../../ministreaming/java/" target="build" />
+        <ant dir="../../jetty/" target="build" />
 	<!-- ministreaming will build core -->
     </target>
     <target name="compile">
@@ -15,13 +16,54 @@
             destdir="./build/obj" 
             classpath="../../../core/java/build/i2p.jar:../../ministreaming/java/build/mstreaming.jar" />
     </target>
-    <target name="jar" depends="compile">
+    <target name="jar" depends="builddep, compile">
         <jar destfile="./build/i2ptunnel.jar" basedir="./build/obj" includes="**/*.class">
             <manifest>
                 <attribute name="Main-Class" value="net.i2p.i2ptunnel.I2PTunnel" />
                 <attribute name="Class-Path" value="i2p.jar mstreaming.jar" />
             </manifest>
         </jar>
+        <ant target="war" />
+    </target>
+    <target name="war" depends="precompilejsp"> 
+        <war destfile="build/i2ptunnel.war" webxml="../jsp/web-out.xml"
+             basedir="../jsp/" excludes="web.xml, *.java, *.jsp">
+        </war>
+    </target>
+    <target name="precompilejsp">
+        <mkdir dir="../jsp/WEB-INF/" />
+        <mkdir dir="../jsp/WEB-INF/classes" />
+        <!-- there are various jspc ant tasks, but they all seem a bit flakey -->
+        <java classname="org.apache.jasper.JspC" fork="true" >
+            <classpath>
+                <pathelement location="../../jetty/jettylib/jasper-compiler.jar" />
+                <pathelement location="../../jetty/jettylib/jasper-runtime.jar" />
+                <pathelement location="../../jetty/jettylib/javax.servlet.jar" />
+                <pathelement location="../../jetty/jettylib/ant.jar" />
+                <pathelement location="build/i2ptunnel.jar" />
+            </classpath>
+            <arg value="-d" />
+            <arg value="../jsp/WEB-INF/classes" />
+            <arg value="-v9" />
+            <arg value="-p" />
+            <arg value="net.i2p.i2ptunnel.jsp" />
+            <arg value="-webinc" />
+            <arg value="../jsp/web-fragment.xml" />
+            <arg value="-webapp" />
+            <arg value="../jsp/" />
+        </java>
+        <javac destdir="../jsp/WEB-INF/classes/" srcdir="../jsp/WEB-INF/classes" includes="*.java">
+            <classpath>
+                <pathelement location="../../jetty/jettylib/jasper-runtime.jar" />
+                <pathelement location="../../jetty/jettylib/javax.servlet.jar" />
+                <pathelement location="build/i2ptunnel.jar" />
+            </classpath>
+        </javac>
+        <copy file="../jsp/web.xml" tofile="../jsp/web-out.xml" />
+        <loadfile property="jspc.web.fragment" srcfile="../jsp/web-fragment.xml" />
+        <replace file="../jsp/web-out.xml">
+            <replacefilter token="&lt;!-- precompiled servlets --&gt;" value="${jspc.web.fragment}" />
+        </replace>
     </target>
     <target name="javadoc">
         <mkdir dir="./build" />

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

@@ -54,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;
@@ -71,16 +72,17 @@ public class I2PTunnel implements Logging, EventDispatcher {
     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"};
 
@@ -108,6 +110,7 @@ public class I2PTunnel implements Logging, EventDispatcher {
         _event = new EventDispatcherImpl();
         _clientOptions = new Properties();
         _clientOptions.putAll(System.getProperties());
+        _sessions = new ArrayList(1);
         
         addConnectionEventListener(lsnr);
         boolean gui = true;
@@ -172,6 +175,24 @@ 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) {
@@ -263,7 +284,7 @@ public class I2PTunnel implements Logging, EventDispatcher {
         l.log("textserver <host> <port> <privkey>");
         l.log("genkeys <privkeyfile> [<pubkeyfile>]");
         l.log("gentextkeys");
-        l.log("client <port> <pubkey>|file:<pubkeyfile>");
+        l.log("client <port> <pubkey>[,<pubkey,...]|file:<pubkeyfile>");
         l.log("httpclient <port>");
         l.log("lookup <name>");
         l.log("quit");
@@ -408,9 +429,9 @@ public class I2PTunnel implements Logging, EventDispatcher {
      */
     public void runClient(String args[], Logging l) {
         if (args.length == 2) {
-            int port = -1;
+            int portNum = -1;
             try {
-                port = Integer.parseInt(args[0]);
+                portNum = Integer.parseInt(args[0]);
             } catch (NumberFormatException nfe) {
                 l.log("invalid port");
                 _log.error(getPrefix() + "Port specified is not valid: " + args[0], nfe);
@@ -418,13 +439,21 @@ public class I2PTunnel implements Logging, EventDispatcher {
                 return;
             }
             I2PTunnelTask task;
-            task = new I2PTunnelClient(port, args[1], l, ownDest, (EventDispatcher) this, 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("client <port> <pubkey>[,<pubkey>]|file:<pubkeyfile>");
             l.log("  creates a client that forwards port to the pubkey.\n"
-                  + "  use 0 as port to get a free port assigned.");
+                  + "  use 0 as port to get a free port assigned.  If you specify\n"
+                  + "  a comma delimited list of pubkeys, it will rotate among them\n"
+                  + "  randomlyl");
             notifyEvent("clientTaskId", new Integer(-1));
         }
     }
@@ -455,9 +484,15 @@ public class I2PTunnel implements Logging, EventDispatcher {
                 proxy = args[1];
             }
             I2PTunnelTask task;
-            task = new I2PTunnelHTTPClient(port, l, ownDest, proxy, (EventDispatcher) this, 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.");

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

@@ -4,7 +4,11 @@
 package net.i2p.i2ptunnel;
 
 import java.net.Socket;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.StringTokenizer;
 
+import net.i2p.I2PAppContext;
 import net.i2p.client.streaming.I2PSocket;
 import net.i2p.data.DataFormatException;
 import net.i2p.data.Destination;
@@ -15,11 +19,19 @@ public class I2PTunnelClient extends I2PTunnelClientBase {
 
     private static final Log _log = new Log(I2PTunnelClient.class);
 
-    protected Destination dest;
+    /** list of Destination objects that we point at */
+    protected List dests;
     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, I2PTunnel tunnel) {
+    /**
+     * @param destinations comma delimited list of peers we target
+     * @throws IllegalArgumentException if the I2PTunnel does not contain
+     *                                  valid config to contact the router
+     */
+    public I2PTunnelClient(int localPort, String destinations, Logging l, 
+                           boolean ownDest, EventDispatcher notifyThis, 
+                           I2PTunnel tunnel) throws IllegalArgumentException {
         super(localPort, ownDest, l, notifyThis, "SynSender", tunnel);
 
         if (waitEventValue("openBaseClientResult").equals("error")) {
@@ -27,19 +39,28 @@ public class I2PTunnelClient extends I2PTunnelClientBase {
             return;
         }
 
-        try {
-            dest = I2PTunnel.destFromName(destination);
-            if (dest == null) {
-                l.log("Could not resolve " + destination + ".");
-                return;
+        StringTokenizer tok = new StringTokenizer(destinations, ",");
+        dests = new ArrayList(1);
+        while (tok.hasMoreTokens()) {
+            String destination = tok.nextToken();
+            try {
+                Destination dest = I2PTunnel.destFromName(destination);
+                if (dest == null)
+                    l.log("Could not resolve " + destination);
+                else
+                    dests.add(dest);
+            } catch (DataFormatException dfe) {
+                l.log("Bad format parsing \"" + destination + "\"");
             }
-        } catch (DataFormatException e) {
-            l.log("Bad format in destination \"" + destination + "\".");
+        }
+
+        if (dests.size() <= 0) {
+            l.log("No target destinations found");
             notifyEvent("openClientResult", "error");
             return;
         }
 
-        setName(getLocalPort() + " -> " + destination);
+        setName(getLocalPort() + " -> " + destinations);
 
         startRunning();
 
@@ -50,14 +71,34 @@ public class I2PTunnelClient extends I2PTunnelClientBase {
     public long getReadTimeout() { return readTimeout; }
     
     protected void clientConnectionRun(Socket s) {
+        Destination dest = pickDestination();
+        I2PSocket i2ps = null;
         try {
-            I2PSocket i2ps = createI2PSocket(dest);
+            i2ps = createI2PSocket(dest);
             i2ps.setReadTimeout(readTimeout);
-            new I2PTunnelRunner(s, i2ps, sockLock, null);
+            new I2PTunnelRunner(s, i2ps, sockLock, null, mySockets);
         } catch (Exception ex) {
             _log.info("Error connecting", ex);
             l.log(ex.getMessage());
             closeSocket(s);
+            if (i2ps != null) {
+                synchronized (sockLock) {
+                    mySockets.remove(sockLock);
+                }
+            }
         }
     }
+    
+    private final Destination pickDestination() {
+        int size = dests.size();
+        if (size <= 0) {
+            if (_log.shouldLog(Log.ERROR))
+                _log.error("No client targets?!");
+            return null;
+        }
+        if (size == 1) // skip the rand in the most common case
+            return (Destination)dests.get(0);
+        int index = I2PAppContext.getGlobalContext().random().nextInt(size);
+        return (Destination)dests.get(index);
+    }
 }

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

@@ -17,6 +17,8 @@ import java.util.List;
 import java.util.Properties;
 
 import net.i2p.I2PException;
+import net.i2p.client.I2PSession;
+import net.i2p.client.I2PSessionException;
 import net.i2p.client.streaming.I2PSocket;
 import net.i2p.client.streaming.I2PSocketManager;
 import net.i2p.client.streaming.I2PSocketManagerFactory;
@@ -31,13 +33,13 @@ public abstract class I2PTunnelClientBase extends I2PTunnelTask implements Runna
     private static final Log _log = new Log(I2PTunnelClientBase.class);
     protected Logging l;
 
-    private static final long DEFAULT_CONNECT_TIMEOUT = 60 * 1000;
+    static final long DEFAULT_CONNECT_TIMEOUT = 60 * 1000;
 
     private static volatile long __clientId = 0;
     protected long _clientId;
     protected Object sockLock = new Object(); // Guards sockMgr and mySockets
-    private I2PSocketManager sockMgr;
-    private List mySockets = new ArrayList();
+    protected I2PSocketManager sockMgr;
+    protected List mySockets = new ArrayList();
 
     protected Destination dest = null;
     private int localPort;
@@ -55,12 +57,21 @@ public abstract class I2PTunnelClientBase extends I2PTunnelTask implements Runna
 
     private String handlerName;
 
+    private Object conLock = new Object();
+    private int pendingConnections = 0;
+    
     //public I2PTunnelClientBase(int localPort, boolean ownDest,
     //		       Logging l) {
     //    I2PTunnelClientBase(localPort, ownDest, l, (EventDispatcher)null);
     //}
 
-    public I2PTunnelClientBase(int localPort, boolean ownDest, Logging l, EventDispatcher notifyThis, String handlerName, I2PTunnel tunnel) {
+    /**
+     * @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;
@@ -74,16 +85,21 @@ 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;
         t.start();
         open = true;
         synchronized (this) {
-            while (!listenerReady) {
+            while (!listenerReady && open) {
                 try {
                     wait();
                 } catch (InterruptedException e) {
@@ -96,7 +112,7 @@ public abstract class I2PTunnelClientBase extends I2PTunnelTask implements Runna
             l.log("Ready! Port " + getLocalPort());
             notifyEvent("openBaseClientResult", "ok");
         } else {
-            l.log("Error!");
+            l.log("Error listening - please see the logs!");
             notifyEvent("openBaseClientResult", "error");
         }
     }
@@ -107,7 +123,16 @@ public abstract class I2PTunnelClientBase extends I2PTunnelTask implements Runna
         return getSocketManager(getTunnel());
     }
     protected static synchronized I2PSocketManager getSocketManager(I2PTunnel tunnel) {
-        if (socketManager == null) {
+        if (socketManager != null) {
+            I2PSession s = socketManager.getSession();
+            if ( (s == null) || (s.isClosed()) ) {
+                _log.info("Building a new socket manager since the old one closed [s=" + s + "]");
+                socketManager = buildSocketManager(tunnel);
+            } else {
+                _log.info("Not building a new socket manager since the old one is open [s=" + s + "]");
+            }
+        } else {
+            _log.info("Building a new socket manager since there is no other one");
             socketManager = buildSocketManager(tunnel);
         }
         return socketManager;
@@ -122,7 +147,8 @@ public abstract class I2PTunnelClientBase extends I2PTunnelTask implements Runna
             props.putAll(System.getProperties());
         else
             props.putAll(tunnel.getClientOptions());
-        I2PSocketManager sockManager = I2PSocketManagerFactory.createManager(I2PTunnel.host, Integer.parseInt(I2PTunnel.port), props);
+        I2PSocketManager sockManager = I2PSocketManagerFactory.createManager(tunnel.host, Integer.parseInt(tunnel.port), props);
+        if (sockManager == null) return null;
         sockManager.setName("Client");
         return sockManager;
     }
@@ -133,9 +159,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;
@@ -158,9 +184,24 @@ public abstract class I2PTunnelClientBase extends I2PTunnelTask implements Runna
      * create the default options (using the default timeout, etc)
      *
      */
-    private I2PSocketOptions getDefaultOptions() {
-        I2PSocketOptions opts = new I2PSocketOptions();
-        opts.setConnectTimeout(DEFAULT_CONNECT_TIMEOUT);
+    protected I2PSocketOptions getDefaultOptions() {
+        Properties defaultOpts = getTunnel().getClientOptions();
+        I2PSocketOptions opts = sockMgr.buildOptions(defaultOpts);
+        if (!defaultOpts.containsKey(I2PSocketOptions.PROP_CONNECT_TIMEOUT))
+            opts.setConnectTimeout(DEFAULT_CONNECT_TIMEOUT);
+        return opts;
+    }
+    
+    /** 
+     * create the default options (using the default timeout, etc)
+     *
+     */
+    protected I2PSocketOptions getDefaultOptions(Properties overrides) {
+        Properties defaultOpts = getTunnel().getClientOptions();
+        defaultOpts.putAll(overrides);
+        I2PSocketOptions opts = sockMgr.buildOptions(defaultOpts);
+        if (!defaultOpts.containsKey(I2PSocketOptions.PROP_CONNECT_TIMEOUT))
+            opts.setConnectTimeout(DEFAULT_CONNECT_TIMEOUT);
         return opts;
     }
 
@@ -204,7 +245,13 @@ public abstract class I2PTunnelClientBase extends I2PTunnelTask implements Runna
     public final void run() {
         try {
             InetAddress addr = getListenHost(l);
-            if (addr == null) return;
+            if (addr == null) {
+                open = false;
+                synchronized (this) {
+                    notifyAll();
+                }
+                return;
+            }
             ss = new ServerSocket(localPort, 0, addr);
 
             // If a free port was requested, find out what we got
@@ -212,7 +259,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) {
@@ -235,8 +282,15 @@ public abstract class I2PTunnelClientBase extends I2PTunnelTask implements Runna
                 manageConnection(s);
             }
         } catch (IOException ex) {
-            _log.error("Error listening for connections", ex);
+            _log.error("Error listening for connections on " + localPort, ex);
             notifyEvent("openBaseClientResult", "error");
+            synchronized (sockLock) {
+                mySockets.clear();
+            }
+            open = false;
+            synchronized (this) {
+                notifyAll();
+            }
         }
     }
 
@@ -246,7 +300,16 @@ public abstract class I2PTunnelClientBase extends I2PTunnelTask implements Runna
      * @param s Socket to take care of
      */
     protected void manageConnection(Socket s) {
-        new ClientConnectionRunner(s, handlerName);
+        boolean useBlocking = false;
+        synchronized (conLock) {
+            pendingConnections++;
+            if (pendingConnections > 5)
+                useBlocking = true;
+        }
+        if (useBlocking)
+            clientConnectionRun(s);
+        else
+            new ClientConnectionRunner(s, handlerName);
     }
 
     public boolean close(boolean forced) {
@@ -265,6 +328,10 @@ public abstract class I2PTunnelClientBase extends I2PTunnelTask implements Runna
                 }
                 return false;
             }
+            I2PSession session = sockMgr.getSession();
+            if (session != null) {
+                getTunnel().removeSession(session);
+            }
             l.log("Closing client " + toString());
             try {
                 if (ss != null) ss.close();
@@ -299,6 +366,9 @@ public abstract class I2PTunnelClientBase extends I2PTunnelTask implements Runna
 
         public void run() {
             clientConnectionRun(s);
+            synchronized (conLock) {
+                pendingConnections--;
+            }
         }
     }
 

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

@@ -9,10 +9,17 @@ import java.io.InputStreamReader;
 import java.io.OutputStream;
 import java.net.Socket;
 import java.net.SocketException;
+import java.util.ArrayList;
 import java.util.Date;
+import java.util.List;
+import java.util.StringTokenizer;
+import java.util.HashMap;
+import java.util.Properties;
 
+import net.i2p.I2PAppContext;
 import net.i2p.I2PException;
 import net.i2p.client.streaming.I2PSocket;
+import net.i2p.client.streaming.I2PSocketOptions;
 import net.i2p.data.DataFormatException;
 import net.i2p.data.Destination;
 import net.i2p.util.Clock;
@@ -42,7 +49,9 @@ 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 HashMap addressHelpers = new HashMap();
 
     private final static byte[] ERR_REQUEST_DENIED =
         ("HTTP/1.1 403 Access Denied\r\n"+
@@ -59,7 +68,7 @@ public class I2PTunnelHTTPClient extends I2PTunnelClientBase implements Runnable
          "Cache-control: no-cache\r\n"+
          "\r\n"+
          "<html><body><H1>I2P ERROR: DESTINATION NOT FOUND</H1>"+
-         "That I2P Desitination was not found. Perhaps you pasted in the "+
+         "That I2P Destination was not found. Perhaps you pasted in the "+
          "wrong BASE64 I2P Destination or the link you are following is "+
          "bad. The host (or the WWW proxy, if you're using one) could also "+
 	 "be temporarily offline.  You may want to <b>retry</b>.  "+
@@ -71,17 +80,33 @@ public class I2PTunnelHTTPClient extends I2PTunnelClientBase implements Runnable
          "Content-Type: text/html; charset=iso-8859-1\r\n"+
          "Cache-control: no-cache\r\n\r\n"+
          "<html><body><H1>I2P ERROR: TIMEOUT</H1>"+
-         "That Desitination was reachable, but timed out getting a "+
+         "That Destination was reachable, but timed out getting a "+
          "response.  This is likely a temporary error, so you should simply "+
          "try to refresh, though if the problem persists, the remote "+
          "destination may have issues.  Could not get a response from "+
          "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, I2PTunnel tunnel) {
+
+    /**
+     * @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")) {
@@ -89,22 +114,80 @@ public class I2PTunnelHTTPClient extends I2PTunnelClientBase implements Runnable
             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() { return "Client[" + _clientId + "]: "; }
+    private String getPrefix(long requestId) { return "Client[" + _clientId + "/" + requestId + "]: "; }
     
+    private String selectProxy() {
+        synchronized (proxyList) {
+            int size = proxyList.size();
+            if (size <= 0) {
+                if (_log.shouldLog(Log.INFO))
+                    _log.info("Proxy list is empty - no outproxy available");
+                l.log("Proxy list is emtpy - no outproxy available");
+                return null;
+            }
+            int index = I2PAppContext.getGlobalContext().random().nextInt(size);
+            String proxy = (String)proxyList.get(index);
+            return proxy;
+        }
+    }
+
+    private static final int DEFAULT_READ_TIMEOUT = 60*1000;
+    
+    
+    /** 
+     * create the default options (using the default timeout, etc)
+     *
+     */
+    protected I2PSocketOptions getDefaultOptions() {
+        Properties defaultOpts = getTunnel().getClientOptions();
+        if (!defaultOpts.contains(I2PSocketOptions.PROP_READ_TIMEOUT))
+            defaultOpts.setProperty(I2PSocketOptions.PROP_READ_TIMEOUT, ""+DEFAULT_READ_TIMEOUT);
+        if (!defaultOpts.contains("i2p.streaming.inactivityTimeout"))
+            defaultOpts.setProperty("i2p.streaming.inactivityTimeout", ""+DEFAULT_READ_TIMEOUT);
+        I2PSocketOptions opts = sockMgr.buildOptions(defaultOpts);
+        if (!defaultOpts.containsKey(I2PSocketOptions.PROP_CONNECT_TIMEOUT))
+            opts.setConnectTimeout(DEFAULT_CONNECT_TIMEOUT);
+        return opts;
+    }
+    
+    /** 
+     * create the default options (using the default timeout, etc)
+     *
+     */
+    protected I2PSocketOptions getDefaultOptions(Properties overrides) {
+        Properties defaultOpts = getTunnel().getClientOptions();
+        defaultOpts.putAll(overrides);
+        if (!defaultOpts.contains(I2PSocketOptions.PROP_READ_TIMEOUT))
+            defaultOpts.setProperty(I2PSocketOptions.PROP_READ_TIMEOUT, ""+DEFAULT_READ_TIMEOUT);
+        if (!defaultOpts.contains("i2p.streaming.inactivityTimeout"))
+            defaultOpts.setProperty("i2p.streaming.inactivityTimeout", ""+DEFAULT_READ_TIMEOUT);
+        I2PSocketOptions opts = sockMgr.buildOptions(defaultOpts);
+        if (!defaultOpts.containsKey(I2PSocketOptions.PROP_CONNECT_TIMEOUT))
+            opts.setConnectTimeout(DEFAULT_CONNECT_TIMEOUT);
+        return opts;
+    }
+
+    private static long __requestId = 0;
     protected void clientConnectionRun(Socket s) {
         OutputStream out = null;
         String targetRequest = null;
         boolean usingWWWProxy = false;
-        InactivityTimeoutThread timeoutThread = null;
+        String currentProxy = null;
+        long requestId = ++__requestId;
         try {
             out = s.getOutputStream();
             BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream(), "ISO-8859-1"));
@@ -112,7 +195,7 @@ public class I2PTunnelHTTPClient extends I2PTunnelClientBase implements Runnable
             StringBuffer newRequest = new StringBuffer();
             while ((line = br.readLine()) != null) {
                 if (_log.shouldLog(Log.DEBUG))
-                    _log.debug(getPrefix() + "Line=[" + line + "]");
+                    _log.debug(getPrefix(requestId) + "Line=[" + line + "]");
                 
                 if (line.startsWith("Connection: ") || 
                     line.startsWith("Keep-Alive: ") || 
@@ -121,7 +204,7 @@ public class I2PTunnelHTTPClient extends I2PTunnelClientBase implements Runnable
                 
                 if (method == null) { // first line (GET /base64/realaddr)
                     if (_log.shouldLog(Log.DEBUG))
-                        _log.debug(getPrefix() + "Method is null for [" + line + "]");
+                        _log.debug(getPrefix(requestId) + "Method is null for [" + line + "]");
                     
                     int pos = line.indexOf(" ");
                     if (pos == -1) break;
@@ -151,13 +234,73 @@ public class I2PTunnelHTTPClient extends I2PTunnelClientBase implements Runnable
                     if (host.toLowerCase().endsWith(".i2p")) {
                         destination = host;
                         host = getHostName(destination);
+                        if ( (host != null) && ("i2p".equals(host)) ) {
+                            int pos2;
+                            if ((pos2 = request.indexOf("?")) != -1) {
+                                // Try to find an address helper in the fragments
+                                // and split the request into it's component parts for rebuilding later
+                                String fragments = request.substring(pos2 + 1);
+                                String uriPath = request.substring(0, pos2);
+                                pos2 = fragments.indexOf(" ");
+                                String protocolVersion = fragments.substring(pos2 + 1);
+                                String urlEncoding = "";
+                                fragments = fragments.substring(0, pos2);
+                                fragments = fragments + "&";
+                                String fragment;
+                                while(fragments.length() > 0) {
+                                    pos2 = fragments.indexOf("&");
+                                    fragment = fragments.substring(0, pos2);
+                                    fragments = fragments.substring(pos2 + 1);
+                                    if (fragment.startsWith("i2paddresshelper")) {
+                                        pos2 = fragment.indexOf("=");
+                                        if (pos2 >= 0) {
+                                            addressHelpers.put(destination,fragment.substring(pos2 + 1));
+                                        }
+                                    } else {
+                                        // append each fragment unless it's the address helper
+                                        if ("".equals(urlEncoding)) {
+                                            urlEncoding = "?" + fragment;
+                                        } else {
+                                            urlEncoding = urlEncoding + "&" + fragment; 
+                                        }
+				    }
+                                }
+                                // reconstruct the request minus the i2paddresshelper GET var
+                                request = uriPath + urlEncoding + " " + protocolVersion;
+                            }
+
+                            String addressHelper = (String) addressHelpers.get(destination);
+                            if (addressHelper != null) {
+                                destination = addressHelper;
+                                host = getHostName(destination);
+                            }
+                        }
                         line = method + " " + request.substring(pos);
                     } else if (host.indexOf(".") != -1) {
                         // The request must be forwarded to a WWW proxy
-                        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(getPrefix() + "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("/");
@@ -167,31 +310,54 @@ public class I2PTunnelHTTPClient extends I2PTunnelClientBase implements Runnable
 
                     boolean isValid = usingWWWProxy || isSupportedAddress(host, protocol);
                     if (!isValid) {
-                        if (_log.shouldLog(Log.INFO)) _log.info(getPrefix() + "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(getPrefix() + "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(getPrefix() + "METHOD:" + method + ":");
-                        _log.debug(getPrefix() + "PROTOC:" + protocol + ":");
-                        _log.debug(getPrefix() + "HOST  :" + host + ":");
-                        _log.debug(getPrefix() + "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(getPrefix() + "Setting host = " + host);
+                            _log.info(getPrefix(requestId) + "Setting host = " + host);
+                    } else if (line.startsWith("User-Agent: ")) {
+                        // always stripped, added back at the end
+                        line = null;
+                        continue;
+                    } else if (line.startsWith("Accept")) {
+                        // strip the accept-blah headers, as they vary dramatically from
+                        // browser to browser
+                        line = null;
+                        continue;
+                    } else if (line.startsWith("Referer: ")) {
+                        // Shouldn't we be more specific, like accepting in-site referers ?
+                        //line = "Referer: i2p";
+                        line = null;
+                        continue; // completely strip the line
+                    } else if (line.startsWith("Via: ")) {
+                        //line = "Via: i2p";
+                        line = null;
+                        continue; // completely strip the line
+                    } else if (line.startsWith("From: ")) {
+                        //line = "From: i2p";
+                        line = null;
+                        continue; // completely strip the line
                     }
                 }
                 
                 if (line.length() == 0) {
+                    newRequest.append("User-Agent: MYOB/6.66 (AN/ON)\r\n");
                     newRequest.append("Connection: close\r\n\r\n");
                     break;
                 } else {
@@ -199,7 +365,7 @@ public class I2PTunnelHTTPClient extends I2PTunnelClientBase implements Runnable
                 }
             }
             if (_log.shouldLog(Log.DEBUG))
-                _log.debug(getPrefix() + "NewRequest header: [" + newRequest.toString() + "]");
+                _log.debug(getPrefix(requestId) + "NewRequest header: [" + newRequest.toString() + "]");
             
             while (br.ready()) { // empty the buffer (POST requests)
                 int i = br.read();
@@ -221,7 +387,7 @@ public class I2PTunnelHTTPClient extends I2PTunnelClientBase implements Runnable
             }
             
             if (_log.shouldLog(Log.DEBUG))
-                _log.debug(getPrefix() + "Destination: " + destination);
+                _log.debug(getPrefix(requestId) + "Destination: " + destination);
             
             Destination dest = I2PTunnel.destFromName(destination);
             if (dest == null) {
@@ -233,114 +399,35 @@ public class I2PTunnelHTTPClient extends I2PTunnelClientBase implements Runnable
                 return;
             }
             String remoteID;
-            I2PSocket i2ps = createI2PSocket(dest);
+            
+            Properties opts = new Properties();
+            opts.setProperty("i2p.streaming.inactivityTimeout", ""+120*1000);
+            // 1 == disconnect.  see ConnectionOptions in the new streaming lib, which i
+            // dont want to hard link to here
+            opts.setProperty("i2p.streaming.inactivityTimeoutAction", ""+1);
+            I2PSocket i2ps = createI2PSocket(dest, getDefaultOptions(opts));
             byte[] data = newRequest.toString().getBytes("ISO-8859-1");
-            I2PTunnelRunner runner = new I2PTunnelRunner(s, i2ps, sockLock, data);
-            timeoutThread = new InactivityTimeoutThread(runner, out, targetRequest, usingWWWProxy, s);
-            timeoutThread.start();
+            I2PTunnelRunner runner = new I2PTunnelRunner(s, i2ps, sockLock, data, mySockets);
         } catch (SocketException ex) {
-            if (timeoutThread != null) timeoutThread.disable();
-            _log.info(getPrefix() + "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(getPrefix() + "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("getPrefix() + Error trying to connect", ex);
+            _log.info("getPrefix(requestId) + Error trying to connect", ex);
             l.log(ex.getMessage());
-            handleHTTPClientException(ex, out, targetRequest, usingWWWProxy, wwwProxy);
-            closeSocket(s);
-        }
-    }
-
-    private static final long INACTIVITY_TIMEOUT = 120 * 1000;
-    private static volatile long __timeoutId = 0;
-
-    private class InactivityTimeoutThread extends I2PThread {
-
-        private Socket s;
-        private I2PTunnelRunner _runner;
-        private OutputStream _out;
-        private String _targetRequest;
-        private boolean _useWWWProxy;
-        private boolean _disabled;
-        private Object _disableLock = new Object();
-
-        public InactivityTimeoutThread(I2PTunnelRunner runner, OutputStream out, String targetRequest,
-                                       boolean useWWWProxy, Socket s) {
-            this.s = s;
-            _runner = runner;
-            _out = out;
-            _targetRequest = targetRequest;
-            _useWWWProxy = useWWWProxy;
-            _disabled = false;
-            long timeoutId = ++__timeoutId;
-            setName("InactivityThread " + getPrefix() + timeoutId);
-        }
-
-        public void disable() {
-            _disabled = true;
-            synchronized (_disableLock) {
-                _disableLock.notifyAll();
-            }
-        }
-
-        public void run() {
-            while (!_disabled) {
-                if (_runner.isFinished()) {
-                    if (_log.shouldLog(Log.INFO)) _log.info(getPrefix() + "HTTP client request completed prior to timeout");
-                    return;
-                }
-                if (_runner.getLastActivityOn() < Clock.getInstance().now() - INACTIVITY_TIMEOUT) {
-                    if (_runner.getStartedOn() < Clock.getInstance().now() - INACTIVITY_TIMEOUT) {
-                        if (_log.shouldLog(Log.WARN))
-                            _log.warn(getPrefix() + "HTTP client request timed out (lastActivity: "
-                                      + new Date(_runner.getLastActivityOn()) + ", startedOn: "
-                                      + new Date(_runner.getStartedOn()) + ")");
-                        timeout();
-                        return;
-                    } else {
-                        // runner hasn't been going to long enough
-                    }
-                } else {
-                    // there has been activity in the period
-                }
-                synchronized (_disableLock) {
-                    try {
-                        _disableLock.wait(INACTIVITY_TIMEOUT);
-                    } catch (InterruptedException ie) {
-                    }
-                }
-            }
-        }
-
-        private void timeout() {
-            _log.info(getPrefix() + "Inactivity timeout reached");
-            l.log("Inactivity timeout reached");
-            if (_out != null) {
-                try {
-                    if (_runner.getLastActivityOn() > 0) {
-                        // some  data has been sent, so don't 404 it
-                    } else {
-                        writeErrorMessage(ERR_TIMEOUT, _out, _targetRequest, _useWWWProxy, wwwProxy);
-                    }
-                } catch (IOException ioe) {
-                    _log.warn(getPrefix() + "Error writing out the 'timeout' message", ioe);
-                }
-            } else {
-                _log.warn(getPrefix() + "Client disconnected before we could say we timed out");
-            }
+            handleHTTPClientException(ex, out, targetRequest, usingWWWProxy, currentProxy, requestId);
             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";
@@ -366,18 +453,18 @@ public class I2PTunnelHTTPClient extends I2PTunnelClientBase implements Runnable
     }
 
     private void handleHTTPClientException(Exception ex, OutputStream out, String targetRequest,
-                                                  boolean usingWWWProxy, String wwwProxy) {
+                                                  boolean usingWWWProxy, String wwwProxy, long requestId) {
                                                       
         if (_log.shouldLog(Log.WARN))
-            _log.warn("Error sending to " + wwwProxy + " (proxy? " + usingWWWProxy + ", request: " + targetRequest, ex);
+            _log.warn(getPrefix(requestId) + "Error sending to " + wwwProxy + " (proxy? " + usingWWWProxy + ", request: " + targetRequest, ex);
         if (out != null) {
             try {
                 writeErrorMessage(ERR_DESTINATION_UNKNOWN, out, targetRequest, usingWWWProxy, wwwProxy);
             } catch (IOException ioe) {
-                _log.warn(getPrefix() + "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(getPrefix() + "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

@@ -11,9 +11,11 @@ import java.io.OutputStream;
 import java.net.Socket;
 import java.net.SocketException;
 import java.util.HashMap;
+import java.util.List;
 
-import net.i2p.client.I2PSession;
 import net.i2p.client.streaming.I2PSocket;
+import net.i2p.data.ByteArray;
+import net.i2p.util.ByteCache;
 import net.i2p.util.Clock;
 import net.i2p.util.I2PThread;
 import net.i2p.util.Log;
@@ -38,14 +40,17 @@ public class I2PTunnelRunner extends I2PThread implements I2PSocket.SocketErrorL
     Object slock, finishLock = new Object();
     boolean finished = false;
     HashMap ostreams, sockets;
-    I2PSession session;
     byte[] initialData;
     /** when the last data was sent/received (or -1 if never) */
     private long lastActivityOn;
     /** when the runner started up */
     private long startedOn;
+    private List sockList;
 
-    public I2PTunnelRunner(Socket s, I2PSocket i2ps, Object slock, byte[] initialData) {
+    private volatile long __forwarderId;
+    
+    public I2PTunnelRunner(Socket s, I2PSocket i2ps, Object slock, byte[] initialData, List sockList) {
+        this.sockList = sockList;
         this.s = s;
         this.i2ps = i2ps;
         this.slock = slock;
@@ -55,6 +60,7 @@ public class I2PTunnelRunner extends I2PThread implements I2PSocket.SocketErrorL
         if (_log.shouldLog(Log.INFO))
             _log.info("I2PTunnelRunner started");
         _runnerId = ++__runnerId;
+        __forwarderId = i2ps.hashCode();
         setName("I2PTunnelRunner " + _runnerId);
         start();
     }
@@ -91,50 +97,68 @@ public class I2PTunnelRunner extends I2PThread implements I2PSocket.SocketErrorL
     }
 
     public void run() {
+        boolean closedCleanly = false;
         try {
             InputStream in = s.getInputStream();
-            OutputStream out = new BufferedOutputStream(s.getOutputStream(), NETWORK_BUFFER_SIZE);
+            OutputStream out = s.getOutputStream(); // = new BufferedOutputStream(s.getOutputStream(), NETWORK_BUFFER_SIZE);
             i2ps.setSocketErrorListener(this);
             InputStream i2pin = i2ps.getInputStream();
-            OutputStream i2pout = new BufferedOutputStream(i2ps.getOutputStream(), MAX_PACKET_SIZE);
+            OutputStream i2pout = i2ps.getOutputStream(); //new BufferedOutputStream(i2ps.getOutputStream(), MAX_PACKET_SIZE);
             if (initialData != null) {
                 synchronized (slock) {
                     i2pout.write(initialData);
-                    i2pout.flush();
+                    //i2pout.flush();
                 }
             }
-            Thread t1 = new StreamForwarder(in, i2pout);
-            Thread t2 = new StreamForwarder(i2pin, out);
+            if (_log.shouldLog(Log.DEBUG))
+                _log.debug("Initial data " + (initialData != null ? initialData.length : 0) 
+                           + " written, starting forwarders");
+            Thread t1 = new StreamForwarder(in, i2pout, "toI2P");
+            Thread t2 = new StreamForwarder(i2pin, out, "fromI2P");
             synchronized (finishLock) {
                 while (!finished) {
                     finishLock.wait();
                 }
             }
+            if (_log.shouldLog(Log.DEBUG))
+                _log.debug("At least one forwarder completed, closing and joining");
             // now one connection is dead - kill the other as well.
             s.close();
-            s = null;
             i2ps.close();
-            i2ps = null;
-            t1.join();
-            t2.join();
+            t1.join(30*1000);
+            t2.join(30*1000);
+            closedCleanly = true;
         } catch (InterruptedException ex) {
-            _log.error("Interrupted", ex);
+            if (_log.shouldLog(Log.ERROR))
+                _log.error("Interrupted", ex);
         } catch (IOException ex) {
-            ex.printStackTrace();
-            _log.debug("Error forwarding", ex);
+            if (_log.shouldLog(Log.DEBUG))
+                _log.debug("Error forwarding", ex);
         } catch (Exception e) {
-            _log.error("Internal error", e);
+            if (_log.shouldLog(Log.ERROR))
+                _log.error("Internal error", e);
         } finally {
+            removeRef();
             try {
-                if (s != null) s.close();
-                if (i2ps != null) i2ps.close();
+                if ( (s != null) && (!closedCleanly) )
+                    s.close();
             } catch (IOException ex) {
-                ex.printStackTrace();
-                _log.error("Could not close socket", ex);
+                if (_log.shouldLog(Log.ERROR))
+                    _log.error("Could not close java socket", ex);
+            }
+            try {
+                if (i2ps != null) {
+                    if (!closedCleanly)
+                        i2ps.close();
+                    i2ps.setSocketErrorListener(null);
+                }
+            } catch (IOException ex) {
+                if (_log.shouldLog(Log.ERROR))
+                    _log.error("Could not close I2PSocket", ex);
             }
         }
     }
-
+    
     public void errorOccurred() {
         synchronized (finishLock) {
             finished = true;
@@ -142,22 +166,43 @@ public class I2PTunnelRunner extends I2PThread implements I2PSocket.SocketErrorL
         }
     }
     
-    private volatile long __forwarderId = 0;
+    private void removeRef() {
+        if (sockList != null) {
+            synchronized (slock) {
+                boolean removed = sockList.remove(i2ps);
+                //System.out.println("Removal of i2psocket " + i2ps + " successful? " 
+                //                   + removed + " remaining: " + sockList.size());
+            }
+        }
+    }
     
     private class StreamForwarder extends I2PThread {
 
         InputStream in;
         OutputStream out;
+        String direction;
+        private ByteCache _cache;
 
-        private StreamForwarder(InputStream in, OutputStream out) {
+        private StreamForwarder(InputStream in, OutputStream out, String dir) {
             this.in = in;
             this.out = out;
+            direction = dir;
+            _cache = ByteCache.getInstance(256, NETWORK_BUFFER_SIZE);
             setName("StreamForwarder " + _runnerId + "." + (++__forwarderId));
             start();
         }
 
         public void run() {
-            byte[] buffer = new byte[NETWORK_BUFFER_SIZE];
+            String from = i2ps.getThisDestination().calculateHash().toBase64().substring(0,6);
+            String to = i2ps.getPeerDestination().calculateHash().toBase64().substring(0,6);
+
+            if (_log.shouldLog(Log.DEBUG)) {
+                _log.debug(direction + ": Forwarding between " 
+                           + from + " and " + to);
+            }
+            
+            ByteArray ba = _cache.acquire();
+            byte[] buffer = ba.getData(); // new byte[NETWORK_BUFFER_SIZE];
             try {
                 int len;
                 while ((len = in.read(buffer)) != -1) {
@@ -166,45 +211,65 @@ public class I2PTunnelRunner extends I2PThread implements I2PSocket.SocketErrorL
                     if (len > 0) updateActivity();
 
                     if (in.available() == 0) {
+                        //if (_log.shouldLog(Log.DEBUG))
+                        //    _log.debug("Flushing after sending " + len + " bytes through");
+                        if (_log.shouldLog(Log.DEBUG))
+                            _log.debug(direction + ": " + len + " bytes flushed through to " 
+                                       + i2ps.getPeerDestination().calculateHash().toBase64().substring(0,6));
                         try {
                             Thread.sleep(I2PTunnel.PACKET_DELAY);
                         } catch (InterruptedException e) {
                             e.printStackTrace();
                         }
-                    }
-                    if (in.available() == 0) {
-                        out.flush(); // make sure the data get though
+                        
+                        if (in.available() <= 0)
+                            out.flush(); // make sure the data get though
                     }
                 }
+                //out.flush(); // close() flushes
             } catch (SocketException ex) {
                 // this *will* occur when the other threads closes the socket
                 synchronized (finishLock) {
                     if (!finished) {
-                        _log.debug("Socket closed - error reading and writing",
-                                   ex);
+                        if (_log.shouldLog(Log.DEBUG))
+                            _log.debug(direction + ": Socket closed - error reading and writing",
+                                       ex);
                     }
                 }
             } catch (InterruptedIOException ex) {
-                _log.warn("Closing connection due to timeout (error: \""
-                          + ex.getMessage() + "\")");
+                if (_log.shouldLog(Log.WARN))
+                    _log.warn(direction + ": Closing connection due to timeout (error: \""
+                              + ex.getMessage() + "\")");
             } catch (IOException ex) {
-                if (!finished)
-                    _log.error("Error forwarding", ex);
-                else
-                    _log.warn("You may ignore this", ex);
+                if (!finished) {
+                    if (_log.shouldLog(Log.WARN))
+                        _log.warn(direction + ": Error forwarding", ex);
+                }
+                //else
+                //    _log.warn("You may ignore this", ex);
             } finally {
+                if (_log.shouldLog(Log.INFO)) {
+                    _log.info(direction + ": done forwarding between " 
+                              + from + " and " + to);
+                }
                 try {
-                    out.close();
                     in.close();
                 } catch (IOException ex) {
                     if (_log.shouldLog(Log.WARN))
-                        _log.warn("Error closing streams", ex);
+                        _log.warn(direction + ": Error closing input stream", ex);
+                }
+                try {
+                    out.close();
+                } catch (IOException ex) {
+                    if (_log.shouldLog(Log.WARN))
+                        _log.warn(direction + ": Error closing output stream", ex);
                 }
                 synchronized (finishLock) {
                     finished = true;
                     finishLock.notifyAll();
                     // the main thread will close sockets etc. now
                 }
+                _cache.release(ba);
             }
         }
     }

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

@@ -75,11 +75,12 @@ public class I2PTunnelServer extends I2PTunnelTask implements Runnable {
         Properties props = new Properties();
         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;
@@ -130,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);
@@ -146,6 +148,7 @@ public class I2PTunnelServer extends I2PTunnelTask implements Runnable {
             I2PServerSocket i2pss = sockMgr.getServerSocket();
             while (true) {
                 I2PSocket i2ps = i2pss.accept();
+                if (i2ps == null) throw new I2PException("I2PServerSocket closed");
                 I2PThread t = new I2PThread(new Handler(i2ps));
                 t.start();
             }
@@ -176,7 +179,7 @@ public class I2PTunnelServer extends I2PTunnelTask implements Runnable {
                 _handleSocket.setReadTimeout(readTimeout);
                 Socket s = new Socket(remoteHost, remotePort);
                 afterSocket = I2PAppContext.getGlobalContext().clock().now();
-                new I2PTunnelRunner(s, _handleSocket, slock, null);
+                new I2PTunnelRunner(s, _handleSocket, slock, null, null);
             } catch (SocketException ex) {
                 try {
                     _handleSocket.close();

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

@@ -64,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/TunnelController.java

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

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

@@ -0,0 +1,358 @@
+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.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.Set;
+import java.util.TreeMap;
+
+import net.i2p.I2PAppContext;
+import net.i2p.client.I2PSession;
+import net.i2p.client.I2PSessionException;
+import net.i2p.data.DataHelper;
+import net.i2p.util.I2PThread;
+import net.i2p.util.Log;
+
+/**
+ * Coordinate a set of tunnels within the JVM, loading and storing their config
+ * to disk, and building new ones as requested.
+ *
+ */
+public class TunnelControllerGroup {
+    private Log _log;
+    private static TunnelControllerGroup _instance;
+    static final String DEFAULT_CONFIG_FILE = "i2ptunnel.config";
+    
+    private List _controllers;
+    private String _configFile = DEFAULT_CONFIG_FILE;
+    
+    /** 
+     * Map of I2PSession to a Set of TunnelController objects 
+     * using the session (to prevent closing the session until
+     * no more tunnels are using it)
+     *
+     */
+    private Map _sessions;
+    
+    public static TunnelControllerGroup getInstance() { 
+        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 = Collections.synchronizedList(new ArrayList());
+        _configFile = configFile;
+        _sessions = new HashMap(4);
+        loadControllers(_configFile);
+    }
+
+    public static void main(String args[]) {
+        synchronized (TunnelControllerGroup.class) {
+            if (_instance != null) return; // already loaded through the web
+            
+            if ( (args == null) || (args.length <= 0) ) {
+                _instance = new TunnelControllerGroup(DEFAULT_CONFIG_FILE);
+            } else if (args.length == 1) {
+                _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++;
+        }
+        I2PThread startupThread = new I2PThread(new StartControllers(), "Startup tunnels");
+        startupThread.start();
+        
+        if (_log.shouldLog(Log.INFO))
+            _log.info(i + " controllers loaded from " + configFile);
+    }
+    
+    private class StartControllers implements Runnable {
+        public void run() {
+            for (int i = 0; i < _controllers.size(); i++) {
+                TunnelController controller = (TunnelController)_controllers.get(i);
+                if (controller.getStartOnLoad())
+                    controller.startTunnel();
+            }
+        }
+    }
+    
+    
+    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();
+        try {
+            DataHelper.loadProps(props, cfgFile);
+            return props;
+        } catch (IOException ioe) {
+            if (_log.shouldLog(Log.ERROR))
+                _log.error("Error reading the controllers from " + configFile, ioe);
+            return null;
+        }
+    }
+    
+    /**
+     * Retrieve a list of tunnels known
+     *
+     * @return list of TunnelController objects
+     */
+    public List getControllers() { return _controllers; }
+    
+    
+    /** 
+     * Note the fact that the controller is using the session so that
+     * it isn't destroyed prematurely.
+     *
+     */
+    void acquire(TunnelController controller, I2PSession session) {
+        synchronized (_sessions) {
+            Set owners = (Set)_sessions.get(session);
+            if (owners == null) {
+                owners = new HashSet(1);
+                _sessions.put(session, owners);
+            }
+            owners.add(controller);
+        }
+        if (_log.shouldLog(Log.INFO))
+            _log.info("Acquiring session " + session + " for " + controller);
+
+    }
+    
+    /** 
+     * Note the fact that the controller is no longer using the session, and if
+     * no other controllers are using it, destroy the session.
+     *
+     */
+    void release(TunnelController controller, I2PSession session) {
+        boolean shouldClose = false;
+        synchronized (_sessions) {
+            Set owners = (Set)_sessions.get(session);
+            if (owners != null) {
+                owners.remove(controller);
+                if (owners.size() <= 0) {
+                    if (_log.shouldLog(Log.INFO))
+                        _log.info("After releasing session " + session + " by " + controller + ", no more owners remain");
+                    shouldClose = true;
+                    _sessions.remove(session);
+                } else {
+                    if (_log.shouldLog(Log.INFO))
+                        _log.info("After releasing session " + session + " by " + controller + ", " + owners.size() + " owners remain");
+                    shouldClose = false;
+                }
+            } else {
+                if (_log.shouldLog(Log.WARN))
+                    _log.warn("After releasing session " + session + " by " + controller + ", no owners were even known?!");
+                shouldClose = true;
+            }
+        }
+        if (shouldClose) {
+            try {
+                session.destroySession();
+                if (_log.shouldLog(Log.INFO))
+                    _log.info("Session destroyed: " + session);
+            } catch (I2PSessionException ise) {
+                _log.error("Error closing the client session", ise);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,337 @@
+package net.i2p.i2ptunnel;
+
+import java.io.File;
+
+import java.util.Iterator;
+import java.util.Properties;
+import java.util.Random;
+import java.util.StringTokenizer;
+
+/**
+ * Uuuugly code to generate the edit/add forms for the various 
+ * I2PTunnel types (httpclient/client/server)
+ *
+ */
+class WebEditPageFormGenerator {
+    private static final String SELECT_TYPE_FORM =
+      "<form action=\"edit.jsp\"> Type of tunnel: <select name=\"type\">" +
+      "<option value=\"httpclient\">HTTP proxy</option>" +
+      "<option value=\"client\">Client tunnel</option>" +
+      "<option value=\"server\">Server tunnel</option>" +
+      "</select> <input type=\"submit\" value=\"GO\" />" +
+      "</form>\n";
+    
+    /**
+     * Retrieve the form requested
+     *
+     */
+    public static String getForm(WebEditPageHelper helper) {
+        TunnelController controller = helper.getTunnelController();
+
+        if ( (helper.getType() == null) && (controller == null) )
+            return SELECT_TYPE_FORM;
+        
+        String id = helper.getNum();
+        String type = helper.getType();
+        if (controller != null)
+            type = controller.getType();
+        
+        if ("httpclient".equals(type))
+            return getEditHttpClientForm(controller, id);
+        else if ("client".equals(type))
+            return getEditClientForm(controller, id);
+        else if ("server".equals(type))
+            return getEditServerForm(controller, id);
+        else
+            return "WTF, unknown type [" + type + "]";
+    }
+    
+    private static String getEditHttpClientForm(TunnelController controller, String id) {
+        StringBuffer buf = new StringBuffer(1024);
+        addGeneral(buf, controller, id);
+        buf.append("<b>Type:</b> <i>HTTP proxy</i><input type=\"hidden\" name=\"type\" value=\"httpclient\" /><br />\n");
+        
+        addListeningOn(buf, controller, 4444);
+        
+        buf.append("<b>Outproxies:</b> <input type=\"text\" name=\"proxyList\" size=\"20\" ");
+        if ( (controller != null) && (controller.getProxyList() != null) )
+            buf.append("value=\"").append(controller.getProxyList()).append("\" ");
+        else
+            buf.append("value=\"squid.i2p\" ");
+        buf.append("/><br />\n");
+        
+        buf.append("<hr />Note: the following options are shared across all client tunnels and");
+        buf.append(" HTTP proxies<br />\n");
+        
+        addOptions(buf, controller);
+        buf.append("<input type=\"submit\" name=\"action\" value=\"Save\">\n");
+        buf.append("<input type=\"submit\" name=\"action\" value=\"Remove\">\n");
+        buf.append(" <i>confirm removal:</i> <input type=\"checkbox\" name=\"removeConfirm\" value=\"true\" />\n");
+        buf.append("</form>\n");
+        return buf.toString();
+    }
+    
+    private static String getEditClientForm(TunnelController controller, String id) {
+        StringBuffer buf = new StringBuffer(1024);
+        addGeneral(buf, controller, id);
+        buf.append("<b>Type:</b> <i>Client tunnel</i><input type=\"hidden\" name=\"type\" value=\"client\" /><br />\n");
+        
+        addListeningOn(buf, controller, 2025 + new Random().nextInt(1000)); // 2025 since nextInt can be negative
+
+        buf.append("<b>Target:</b> <input type=\"text\" size=\"40\" name=\"targetDestination\" ");
+        if ( (controller != null) && (controller.getTargetDestination() != null) )
+            buf.append("value=\"").append(controller.getTargetDestination()).append("\" ");
+        buf.append(" /> (either the hosts.txt name or the full base64 destination)<br />\n");
+        
+        buf.append("<hr />Note: the following options are shared across all client tunnels and");
+        buf.append(" HTTP proxies<br />\n");
+        
+        addOptions(buf, controller);
+        buf.append("<input type=\"submit\" name=\"action\" value=\"Save\"><br />\n");
+        buf.append("<input type=\"submit\" name=\"action\" value=\"Remove\">\n");
+        buf.append(" <i>confirm removal:</i> <input type=\"checkbox\" name=\"removeConfirm\" value=\"true\" />\n");
+        buf.append("</form>\n");
+        return buf.toString();
+    }
+    
+    private static String getEditServerForm(TunnelController controller, String id) {
+        StringBuffer buf = new StringBuffer(1024);
+        addGeneral(buf, controller, id);
+        buf.append("<b>Type:</b> <i>Server tunnel</i><input type=\"hidden\" name=\"type\" value=\"server\" /><br />\n");
+        
+        buf.append("<b>Target host:</b> <input type=\"text\" size=\"40\" name=\"targetHost\" ");
+        if ( (controller != null) && (controller.getTargetHost() != null) )
+            buf.append("value=\"").append(controller.getTargetHost()).append("\" ");
+        else
+            buf.append("value=\"localhost\" ");
+        buf.append(" /><br />\n");
+        
+        buf.append("<b>Target port:</b> <input type=\"text\" size=\"4\" name=\"targetPort\" ");
+        if ( (controller != null) && (controller.getTargetPort() != null) )
+            buf.append("value=\"").append(controller.getTargetPort()).append("\" ");
+        else
+            buf.append("value=\"80\" ");
+        buf.append(" /><br />\n");
+        
+        buf.append("<b>Private key file:</b> <input type=\"text\" name=\"privKeyFile\" value=\"");
+        if ( (controller != null) && (controller.getPrivKeyFile() != null) ) {
+            buf.append(controller.getPrivKeyFile()).append("\" /><br />");
+        } else {
+            buf.append("myServer.privKey\" /><br />");
+            buf.append("<input type=\"hidden\" name=\"privKeyGenerate\" value=\"true\" />");
+        }
+        
+        addOptions(buf, controller);
+        buf.append("<input type=\"submit\" name=\"action\" value=\"Save\">\n");
+        buf.append("<input type=\"submit\" name=\"action\" value=\"Remove\">\n");
+        buf.append(" <i>confirm removal:</i> <input type=\"checkbox\" name=\"removeConfirm\" value=\"true\" />\n");
+        buf.append("</form>\n");
+        return buf.toString();
+    }
+    
+    /**
+     * Start off the form and add some common fields (name, num, description)
+     *
+     * @param buf where to shove the form
+     * @param controller tunnel in question, or null if we're creating a new tunnel
+     * @param id index into the current list of tunnelControllerGroup.getControllers() list
+     *           (or null if we are generating an 'add' form)
+     */
+    private static void addGeneral(StringBuffer buf, TunnelController controller, String id) {
+        buf.append("<form action=\"edit.jsp\">");
+        if (id != null)
+            buf.append("<input type=\"hidden\" name=\"num\" value=\"").append(id).append("\" />");
+            
+        buf.append("<b>Name:</b> <input type=\"text\" name=\"name\" size=\"20\" ");
+        if ( (controller != null) && (controller.getName() != null) )
+            buf.append("value=\"").append(controller.getName()).append("\" ");
+        buf.append("/><br />\n");
+        
+        buf.append("<b>Description:</b> <input type=\"text\" name=\"description\" size=\"60\" ");
+        if ( (controller != null) && (controller.getDescription() != null) )
+            buf.append("value=\"").append(controller.getDescription()).append("\" ");
+        buf.append("/><br />\n");
+        
+        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");
+    }
+
+    /**
+     * 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;
+        int connectDelay = 0;
+        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;
+                }
+            }
+            String delay = opts.getProperty("i2p.streaming.connectDelay");
+            if (delay != null) {
+                try {
+                    connectDelay = Integer.parseInt(delay);
+                } catch (NumberFormatException nfe) {
+                    connectDelay = 0;
+                }
+            }
+        }
+        
+        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>Delay connection briefly? </b> ");
+        buf.append("<input type=\"checkbox\" name=\"connectDelay\" value=\"");
+        buf.append((connectDelay > 0 ? connectDelay : 1000)).append("\" ");
+        if (connectDelay > 0)
+            buf.append("checked=\"true\" ");
+        buf.append("/> (useful for brief request/response connections)<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 ("i2p.streaming.connectDelay".equals(key)) continue;
+                if (i != 0) buf.append(' ');
+                buf.append(key).append('=').append(val);
+                i++;
+            }
+        }
+        buf.append("\" /><br />\n");
+    }
+
+    /**
+     * Retrieve the client options from the tunnel
+     *
+     * @return map of name=val to be used as I2P session options
+     */
+    private static Properties getOptions(TunnelController controller) {
+        if (controller == null) return null;
+        String opts = controller.getClientOptions();
+        StringTokenizer tok = new StringTokenizer(opts);
+        Properties props = new Properties();
+        while (tok.hasMoreTokens()) {
+            String pair = tok.nextToken();
+            int eq = pair.indexOf('=');
+            if ( (eq <= 0) || (eq >= pair.length()) )
+                continue;
+            String key = pair.substring(0, eq);
+            String val = pair.substring(eq+1);
+            props.setProperty(key, val);
+        }
+        return props;
+    }
+}

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

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

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

@@ -47,7 +47,7 @@ public class I2PSOCKSTunnel extends I2PTunnelClientBase {
             SOCKSServer serv = SOCKSServerFactory.createSOCKSServer(s);
             Socket clientSock = serv.getClientSocket();
             I2PSocket destSock = serv.getDestinationI2PSocket();
-            new I2PTunnelRunner(clientSock, destSock, sockLock, null);
+            new I2PTunnelRunner(clientSock, destSock, sockLock, null, mySockets);
         } catch (SOCKSException e) {
             _log.error("Error from SOCKS connection: " + e.getMessage());
             closeSocket(s);

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

@@ -81,7 +81,7 @@ public abstract class SOCKSServer {
             if (connHostName.toLowerCase().endsWith(".i2p")) {
                 _log.debug("connecting to " + connHostName + "...");
                 I2PSocketManager sm = I2PSocketManagerFactory.createManager();
-                destSock = sm.connect(I2PTunnel.destFromName(connHostName), new I2PSocketOptions());
+                destSock = sm.connect(I2PTunnel.destFromName(connHostName), null);
                 confirmConnection();
                 _log.debug("connection confirmed - exchanging data...");
             } else {

apps/i2ptunnel/jsp/edit.jsp

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

apps/i2ptunnel/jsp/index.html

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

apps/i2ptunnel/jsp/index.jsp

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

apps/i2ptunnel/jsp/web.xml

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

apps/jetty/build.xml

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

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

@@ -5,7 +5,7 @@ package net.i2p.client.streaming;
  * so care should be taken when using in a multithreaded environment.
  *
  */
-public class ByteCollector {
+class ByteCollector {
     byte[] contents;
     int size;
 

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

@@ -32,8 +32,18 @@ public interface I2PSocket {
      */
     public OutputStream getOutputStream() throws IOException;
 
+    /** 
+     * Retrieve this socket's configuration
+     */
+    public I2PSocketOptions getOptions();
+    /** 
+     * Configure the socket
+     */
+    public void setOptions(I2PSocketOptions options);
+    
     /**
-     * How long we will wait blocked on a read() operation.
+     * How long we will wait blocked on a read() operation.  This is simply a
+     * helper to query the I2PSocketOptions
      *
      * @return milliseconds to wait, or -1 if we will wait indefinitely
      */
@@ -41,7 +51,8 @@ public interface I2PSocket {
 
     /**
      * Define how long we will wait blocked on a read() operation (-1 will make
-     * the socket wait forever).
+     * the socket wait forever).  This is simply a helper to adjust the 
+     * I2PSocketOptions
      *
      */
     public void setReadTimeout(long ms);

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

@@ -9,6 +9,7 @@ import net.i2p.I2PAppContext;
 import net.i2p.I2PException;
 import net.i2p.client.I2PSessionException;
 import net.i2p.data.Destination;
+import net.i2p.util.Clock;
 import net.i2p.util.I2PThread;
 import net.i2p.util.Log;
 
@@ -23,7 +24,7 @@ class I2PSocketImpl implements I2PSocket {
     public static final int MAX_PACKET_SIZE = 1024 * 32;
     public static final int PACKET_DELAY = 100;
 
-    private I2PSocketManager manager;
+    private I2PSocketManagerImpl manager;
     private Destination local;
     private Destination remote;
     private String localID;
@@ -40,6 +41,7 @@ class I2PSocketImpl implements I2PSocket {
     private long _createdOn;
     private long _closedOn;
     private long _remoteIdSetTime;
+    private I2PSocketOptions _options;
     private Object flagLock = new Object();
 
     /**
@@ -67,20 +69,23 @@ class I2PSocketImpl implements I2PSocket {
      * @param outgoing did we initiate the connection (true) or did we receive it (false)?
      * @param localID what is our half of the socket ID?
      */
-    public I2PSocketImpl(Destination peer, I2PSocketManager mgr, boolean outgoing, String localID) {
+    public I2PSocketImpl(Destination peer, I2PSocketManagerImpl mgr, boolean outgoing, String localID) {
         this.outgoing = outgoing;
         manager = mgr;
         remote = peer;
         _socketId = ++__socketId;
         local = mgr.getSession().getMyDestination();
-        in = new I2PInputStream();
-        I2PInputStream pin = new I2PInputStream();
+        String us = mgr.getSession().getMyDestination().calculateHash().toBase64().substring(0,4);
+        String name = us + (outgoing ? "->" : "<-") + peer.calculateHash().toBase64().substring(0,4);
+        in = new I2PInputStream(name + " in");
+        I2PInputStream pin = new I2PInputStream(name + " out");
         out = new I2POutputStream(pin);
         new I2PSocketRunner(pin);
         this.localID = localID;
         _createdOn = I2PAppContext.getGlobalContext().clock().now();
         _remoteIdSetTime = -1;
         _closedOn = -1;
+        _options = mgr.getDefaultOptions();
     }
 
     /**
@@ -152,7 +157,7 @@ class I2PSocketImpl implements I2PSocket {
              
                 if (_log.shouldLog(Log.DEBUG))
                     _log.debug("TIMING: RemoteID set to " 
-                               + I2PSocketManager.getReadableForm(remoteID) + " for "
+                               + I2PSocketManagerImpl.getReadableForm(remoteID) + " for "
                                + this.hashCode());
             }
             return remoteID;
@@ -176,7 +181,11 @@ class I2PSocketImpl implements I2PSocket {
      */
     public void queueData(byte[] data) {
         _bytesRead += data.length;
-        in.queueData(data);
+        try {
+            in.queueData(data, false);
+        } catch (IOException ioe) {
+            _log.log(Log.CRIT, "wtf, we said DONT block, how can we timeout?", ioe);
+        }
     }
 
     /**
@@ -225,7 +234,7 @@ class I2PSocketImpl implements I2PSocket {
     }
 
     /**
-     * Close the socket from the I2P side, e. g. by a close packet.
+     * Close the socket from the I2P side (by a close packet)
      */
     protected void internalClose() {
         synchronized (flagLock) {
@@ -240,24 +249,41 @@ class I2PSocketImpl implements I2PSocket {
 
     private byte getMask(int add) {
         if (outgoing)
-            return (byte)(I2PSocketManager.DATA_IN + (byte)add);
+            return (byte)(I2PSocketManagerImpl.DATA_IN + (byte)add);
         else
-            return (byte)(I2PSocketManager.DATA_OUT + (byte)add);
+            return (byte)(I2PSocketManagerImpl.DATA_OUT + (byte)add);
+    }
+
+    public void setOptions(I2PSocketOptions options) {
+        _options = options;
+        in.setReadTimeout(options.getReadTimeout());
+    }
+    
+    public I2PSocketOptions getOptions() { 
+        return _options;
+    }
+    
+    /**
+     * How long we will wait blocked on a read() operation.  This is simply a
+     * helper to query the I2PSocketOptions
+     *
+     * @return milliseconds to wait, or -1 if we will wait indefinitely
+     */
+    public long getReadTimeout() {
+        return _options.getReadTimeout();
     }
 
     /**
-     * What is the longest we'll block on the input stream while waiting
-     * for more data?  If this value is exceeded, the read() throws 
-     * InterruptedIOException
+     * Define how long we will wait blocked on a read() operation (-1 will make
+     * the socket wait forever).  This is simply a helper to adjust the 
+     * I2PSocketOptions
+     *
      */
-    public long getReadTimeout() {
-        return in.getReadTimeout();
-    }
-
     public void setReadTimeout(long ms) {
+        _options.setReadTimeout(ms);
         in.setReadTimeout(ms);
     }
-
+    
     public void setSocketErrorListener(SocketErrorListener lsnr) {
         _socketErrorListener = lsnr;
     }
@@ -277,15 +303,24 @@ class I2PSocketImpl implements I2PSocket {
     
     //--------------------------------------------------
     private class I2PInputStream extends InputStream {
-
+        private String streamName;
         private ByteCollector bc = new ByteCollector();
+        private boolean inStreamClosed = false;
 
         private long readTimeout = -1;
 
+        public I2PInputStream(String name) {
+            streamName = name;
+        }
+        
         public long getReadTimeout() {
             return readTimeout;
         }
         
+        private String getStreamPrefix() { 
+            return getPrefix() + streamName + ": ";
+        }
+        
         public void setReadTimeout(long ms) {
             readTimeout = ms;
         }
@@ -300,20 +335,24 @@ class I2PSocketImpl implements I2PSocket {
 
         public int read(byte[] b, int off, int len) throws IOException {
             if (_log.shouldLog(Log.DEBUG))
-                _log.debug(getPrefix() + "Read called for " + len + " bytes (avail=" + bc.getCurrentSize() + "): " + this.hashCode());
+                _log.debug(getStreamPrefix() + "Read called for " + len + " bytes (avail=" 
+                           + bc.getCurrentSize() + "): " + this.hashCode());
             if (len == 0) return 0;
             long dieAfter = System.currentTimeMillis() + readTimeout;
             byte[] read = null;
             synchronized (bc) {
                 read = bc.startToByteArray(len);
+                bc.notifyAll();
             }
             boolean timedOut = false;
 
-            while (read.length == 0) {
+            while ( (read.length == 0) && (!inStreamClosed) ) {
                 synchronized (flagLock) {
                     if (closed) {
                         if (_log.shouldLog(Log.DEBUG))
-                            _log.debug(getPrefix() + "Closed is set after reading " + _bytesRead + " and writing " + _bytesWritten + ", so closing stream: " + hashCode());
+                            _log.debug(getStreamPrefix() + "Closed is set after reading " 
+                                       + _bytesRead + " and writing " + _bytesWritten 
+                                       + ", so closing stream: " + hashCode());
                         return -1;
                     }
                 }
@@ -329,18 +368,23 @@ class I2PSocketImpl implements I2PSocket {
 
                 if ((readTimeout >= 0)
                     && (System.currentTimeMillis() >= dieAfter)) {
-                    throw new InterruptedIOException(getPrefix() + "Timeout reading from I2PSocket (" + readTimeout + " msecs)");
+                    throw new InterruptedIOException(getStreamPrefix() + "Timeout reading from I2PSocket (" 
+                                                     + readTimeout + " msecs)");
                 }
 
                 synchronized (bc) {
                     read = bc.startToByteArray(len);
+                    bc.notifyAll();
                 }
             }
             if (read.length > len) throw new RuntimeException("BUG");
+            if ( (inStreamClosed) && ( (read == null) || (read.length <= 0) ) )
+                return -1;
+            
             System.arraycopy(read, 0, b, off, read.length);
 
             if (_log.shouldLog(Log.DEBUG)) {
-                _log.debug(getPrefix() + "Read from I2PInputStream " + hashCode() + " returned " 
+                _log.debug(getStreamPrefix() + "Read from I2PInputStream " + hashCode() + " returned " 
                            + read.length + " bytes");
             }
             //if (_log.shouldLog(Log.DEBUG)) {
@@ -357,19 +401,66 @@ class I2PSocketImpl implements I2PSocket {
             }
         }
 
-        public void queueData(byte[] data) {
-            queueData(data, 0, data.length);
+        /**
+         * Add the data to the queue
+         *
+         * @param allowBlock if true, we will block if the buffer and the socket options
+         *                   say so, otherwise we simply take the data regardless.
+         * @throws InterruptedIOException if the queue's buffer is full, the socket has
+         *                                a write timeout, and that timeout is exceeded
+         * @throws IOException if the connection was closed while queueing up the data
+         */
+        void queueData(byte[] data, boolean allowBlock) throws InterruptedIOException, IOException {
+            queueData(data, 0, data.length, allowBlock);
         }
 
-        public void queueData(byte[] data, int off, int len) {
+        /**
+         * Add the data to the queue
+         *
+         * @param allowBlock if true, we will block if the buffer and the socket options
+         *                   say so, otherwise we simply take the data regardless.
+         * @throws InterruptedIOException if the queue's buffer is full, the socket has
+         *                                a write timeout, and that timeout is exceeded
+         * @throws IOException if the connection was closed while queueing up the data
+         */
+        public void queueData(byte[] data, int off, int len, boolean allowBlock) throws InterruptedIOException, IOException {
             if (_log.shouldLog(Log.DEBUG))
-                _log.debug(getPrefix() + "Insert " + len + " bytes into queue: " + hashCode());
+                _log.debug(getStreamPrefix() + "Insert " + len + " bytes into queue: " + hashCode());
+            Clock clock = I2PAppContext.getGlobalContext().clock();
+            long endAfter = clock.now() + _options.getWriteTimeout();
             synchronized (bc) {
+                if (allowBlock) {
+                    if (_options.getMaxBufferSize() > 0) {
+                        while (bc.getCurrentSize() > _options.getMaxBufferSize()) {
+                            if (_log.shouldLog(Log.DEBUG))
+                                _log.debug(getStreamPrefix() + "Buffer size exceeded: pending " 
+                                           + bc.getCurrentSize() + " limit " + _options.getMaxBufferSize());
+                            if (_options.getWriteTimeout() > 0) {
+                                long timeLeft = endAfter - clock.now();
+                                if (timeLeft <= 0) {
+                                    long waited = _options.getWriteTimeout() - timeLeft;
+                                    throw new InterruptedIOException(getStreamPrefix() + "Waited too long (" 
+                                                                     + waited + "ms) to write " 
+                                                                     + len + " with a buffer at " + bc.getCurrentSize());
+                                }
+                            }
+                            if (inStreamClosed)
+                                throw new IOException(getStreamPrefix() + "Stream closed while writing");
+                            if (_closedOn > 0)
+                                throw new IOException(getStreamPrefix() + "I2PSocket closed while writing");
+                            try {
+                                bc.wait(1000);
+                            } catch (InterruptedException ie) {}
+                        }
+                    }
+                }
                 bc.append(data, off, len);
             }
             synchronized (I2PInputStream.this) {
                 I2PInputStream.this.notifyAll();
             }
+            if (_log.shouldLog(Log.DEBUG))
+                _log.debug(getStreamPrefix() + "After insert " + len + " bytes into queue: " + hashCode());
         }
 
         public void notifyClosed() {
@@ -381,6 +472,12 @@ class I2PSocketImpl implements I2PSocket {
         public void close() throws IOException {
             super.close();
             notifyClosed();
+            synchronized (bc) {
+                inStreamClosed = true;
+                bc.notifyAll();
+            }
+            if (_log.shouldLog(Log.DEBUG))
+                _log.debug(getStreamPrefix() + "After close");
         }
 
     }
@@ -399,7 +496,7 @@ class I2PSocketImpl implements I2PSocket {
 
         public void write(byte[] b, int off, int len) throws IOException {
             _bytesWritten += len;
-            sendTo.queueData(b, off, len);
+            sendTo.queueData(b, off, len, true);
         }
 
         public void close() {
@@ -428,10 +525,21 @@ class I2PSocketImpl implements I2PSocket {
          */
         private boolean handleNextPacket(ByteCollector bc, byte buffer[]) 
                                          throws IOException, I2PSessionException {
+            if (_log.shouldLog(Log.DEBUG))
+                _log.debug(getPrefix() + ":" + Thread.currentThread().getName() + "handleNextPacket");
             int len = in.read(buffer);
-            int bcsize = bc.getCurrentSize();
+            int bcsize = 0;
+            synchronized (bc) {
+                bcsize = bc.getCurrentSize();
+            }
+
+            if (_log.shouldLog(Log.DEBUG))
+                _log.debug(getPrefix() + ":" + Thread.currentThread().getName() + "handleNextPacket len=" + len + " bcsize=" + bcsize);
+
             if (len != -1) {
-                bc.append(buffer, len);
+                synchronized (bc) {
+                    bc.append(buffer, len);
+                }
             } else if (bcsize == 0) {
                 // nothing left in the buffer, and read(..) got EOF (-1).
                 // the bart the
@@ -439,7 +547,7 @@ class I2PSocketImpl implements I2PSocket {
             }
             if ((bcsize < MAX_PACKET_SIZE) && (in.available() == 0)) {
                 if (_log.shouldLog(Log.DEBUG))
-                    _log.debug(getPrefix() + "Runner Point d: " + hashCode());
+                    _log.debug(getPrefix() + ":" + Thread.currentThread().getName() + "Runner Point d: " + hashCode());
 
                 try {
                     Thread.sleep(PACKET_DELAY);
@@ -448,15 +556,22 @@ class I2PSocketImpl implements I2PSocket {
                 }
             }
             if ((bcsize >= MAX_PACKET_SIZE) || (in.available() == 0)) {
-                byte[] data = bc.startToByteArray(MAX_PACKET_SIZE);
+                byte data[] = null;
+                synchronized (bc) {
+                    data = bc.startToByteArray(MAX_PACKET_SIZE);
+                }
                 if (data.length > 0) {
                     if (_log.shouldLog(Log.DEBUG))
-                        _log.debug(getPrefix() + "Message size is: " + data.length);
+                        _log.debug(getPrefix() + ":" + Thread.currentThread().getName() + "Message size is: " + data.length);
                     boolean sent = sendBlock(data);
                     if (!sent) {
-                        _log.error(getPrefix() + "Error sending message to peer.  Killing socket runner");
+                        if (_log.shouldLog(Log.WARN))
+                            _log.warn(getPrefix() + ":" + Thread.currentThread().getName() + "Error sending message to peer.  Killing socket runner");
                         errorOccurred();
                         return false;
+                    } else {
+                        if (_log.shouldLog(Log.DEBUG))
+                            _log.debug(getPrefix() + ":" + Thread.currentThread().getName() + "Message sent to peer");
                     }
                 }
             }
@@ -473,11 +588,19 @@ class I2PSocketImpl implements I2PSocket {
                 while (keepHandling) {
                     keepHandling = handleNextPacket(bc, buffer);
                     packetsHandled++;
+                    if (_log.shouldLog(Log.DEBUG))
+                        _log.debug(getPrefix() + ":" + Thread.currentThread().getName() 
+                                   + "Packets handled: " + packetsHandled);
                 }
+                if (_log.shouldLog(Log.INFO))
+                    _log.info(getPrefix() + ":" + Thread.currentThread().getName() 
+                               + "After handling packets, we're done.  Packets handled: " + packetsHandled);
+                
                 if ((bc.getCurrentSize() > 0) && (packetsHandled > 1)) {
-                    _log.error(getPrefix() + "A SCARY MONSTER HAS EATEN SOME DATA! " + "(input stream: " 
-                               + in.hashCode() + "; "
-                               + "queue size: " + bc.getCurrentSize() + ")");
+                    if (_log.shouldLog(Log.WARN))
+                        _log.warn(getPrefix() + "We lost some data queued up due to a network send error (input stream: " 
+                                  + in.hashCode() + "; "
+                                  + "queue size: " + bc.getCurrentSize() + ")");
                 }
                 synchronized (flagLock) {
                     closed2 = true;
@@ -488,15 +611,20 @@ class I2PSocketImpl implements I2PSocket {
                 } // FIXME: Race here?
                 if (sc) {
                     if (_log.shouldLog(Log.INFO))
-                        _log.info(getPrefix() + "Sending close packet: (we started? " + outgoing + ") after reading " + _bytesRead + " and writing " + _bytesWritten);
-                    byte[] packet = I2PSocketManager.makePacket(getMask(0x02), remoteID, new byte[0]);
+                        _log.info(getPrefix() + ":" + Thread.currentThread().getName() 
+                                  + "Sending close packet: (we started? " + outgoing 
+                                  + ") after reading " + _bytesRead + " and writing " + _bytesWritten);
+                    byte[] packet = I2PSocketManagerImpl.makePacket(getMask(0x02), remoteID, new byte[0]);
                     boolean sent = manager.getSession().sendMessage(remote, packet);
                     if (!sent) {
-                        _log.error(getPrefix() + "Error sending close packet to peer");
+                        if (_log.shouldLog(Log.WARN))
+                            _log.warn(getPrefix() + ":" + Thread.currentThread().getName() 
+                                      + "Error sending close packet to peer");
                         errorOccurred();
                     }
                 }
                 manager.removeSocket(I2PSocketImpl.this);
+                internalClose();
             } catch (InterruptedIOException ex) {
                 _log.error(getPrefix() + "BUG! read() operations should not timeout!", ex);
             } catch (IOException ex) {
@@ -517,7 +645,7 @@ class I2PSocketImpl implements I2PSocket {
                 _log.error(getPrefix() + "NULL REMOTEID");
                 return false;
             }
-            byte[] packet = I2PSocketManager.makePacket(getMask(0x00), remoteID, data);
+            byte[] packet = I2PSocketManagerImpl.makePacket(getMask(0x00), remoteID, data);
             boolean sent;
             synchronized (flagLock) {
                 if (closed2) return false;

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

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

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

@@ -4,8 +4,10 @@ import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
+import java.util.Iterator;
 import java.util.Properties;
 
+import net.i2p.I2PAppContext;
 import net.i2p.I2PException;
 import net.i2p.client.I2PClient;
 import net.i2p.client.I2PClientFactory;
@@ -23,6 +25,10 @@ import net.i2p.util.Log;
 public class I2PSocketManagerFactory {
     private final static Log _log = new Log(I2PSocketManagerFactory.class);
 
+    public static final String PROP_MANAGER = "i2p.streaming.manager";
+    //public static final String DEFAULT_MANAGER = "net.i2p.client.streaming.I2PSocketManagerImpl";
+    public static final String DEFAULT_MANAGER = "net.i2p.client.streaming.I2PSocketManagerFull";
+    
     /**
      * Create a socket manager using a brand new destination connected to the
      * I2CP router on the local machine on the default port (7654).
@@ -30,7 +36,18 @@ public class I2PSocketManagerFactory {
      * @return the newly created socket manager, or null if there were errors
      */
     public static I2PSocketManager createManager() {
-        return createManager("localhost", 7654, new Properties());
+        String i2cpHost = System.getProperty(I2PClient.PROP_TCP_HOST, "localhost");
+        int i2cpPort = 7654;
+        String i2cpPortStr = System.getProperty(I2PClient.PROP_TCP_PORT);
+        if (i2cpPortStr != null) {
+            try {
+                i2cpPort = Integer.parseInt(i2cpPortStr);
+            } catch (NumberFormatException nfe) {
+                // gobble gobble
+            }
+        }
+
+        return createManager(i2cpHost, i2cpPort, System.getProperties());
     }
 
     /**
@@ -65,22 +82,75 @@ public class I2PSocketManagerFactory {
     public static I2PSocketManager createManager(InputStream myPrivateKeyStream, String i2cpHost, int i2cpPort,
                                                  Properties opts) {
         I2PClient client = I2PClientFactory.createClient();
-        opts.setProperty(I2PClient.PROP_RELIABILITY, I2PClient.PROP_RELIABILITY_GUARANTEED);
-        opts.setProperty(I2PClient.PROP_TCP_HOST, i2cpHost);
+        if (opts == null)
+            opts = new Properties();
+        for (Iterator iter = System.getProperties().keySet().iterator(); iter.hasNext(); ) {
+            String name = (String)iter.next();
+            if (!opts.containsKey(name))
+                opts.setProperty(name, System.getProperty(name));
+        }
+        boolean oldLib = DEFAULT_MANAGER.equals(opts.getProperty(PROP_MANAGER, DEFAULT_MANAGER));
+        if (oldLib && false) {
+            // for the old streaming lib
+            opts.setProperty(I2PClient.PROP_RELIABILITY, I2PClient.PROP_RELIABILITY_GUARANTEED);
+            //opts.setProperty("tunnels.depthInbound", "0");
+        } else {
+            // for new streaming lib:
+            opts.setProperty(I2PClient.PROP_RELIABILITY, I2PClient.PROP_RELIABILITY_BEST_EFFORT);
+            //p.setProperty("tunnels.depthInbound", "0");
+        }
+
+        if (i2cpHost != null)
+            opts.setProperty(I2PClient.PROP_TCP_HOST, i2cpHost);
         opts.setProperty(I2PClient.PROP_TCP_PORT, "" + i2cpPort);
+        
         try {
             I2PSession session = client.createSession(myPrivateKeyStream, opts);
             session.connect();
-            return createManager(session);
+            I2PSocketManager sockMgr = createManager(session, opts, "manager");
+            if (sockMgr != null)
+                sockMgr.setDefaultOptions(sockMgr.buildOptions(opts));
+            return sockMgr;
         } catch (I2PSessionException ise) {
             _log.error("Error creating session for socket manager", ise);
             return null;
         }
     }
 
-    private static I2PSocketManager createManager(I2PSession session) {
-        I2PSocketManager mgr = new I2PSocketManager();
-        mgr.setSession(session);
-        return mgr;
+    private static I2PSocketManager createManager(I2PSession session, Properties opts, String name) {
+        if (false) {
+            I2PSocketManagerImpl mgr = new I2PSocketManagerImpl();
+            mgr.setSession(session);
+            //mgr.setDefaultOptions(new I2PSocketOptions());
+            return mgr;
+        } else {
+            String classname = opts.getProperty(PROP_MANAGER, DEFAULT_MANAGER);
+            if (classname != null) {
+                try {
+                    Class cls = Class.forName(classname);
+                    Object obj = cls.newInstance();
+                    if (obj instanceof I2PSocketManager) {
+                        I2PSocketManager mgr = (I2PSocketManager)obj;
+                        I2PAppContext context = I2PAppContext.getGlobalContext();
+                        mgr.init(context, session, opts, name);
+                        return mgr;
+                    } else {
+                        throw new IllegalStateException("Invalid manager class [" + classname + "]");
+                    }
+                } catch (ClassNotFoundException cnfe) {
+                    _log.error("Error loading " + classname, cnfe);
+                    throw new IllegalStateException("Invalid manager class [" + classname + "] - not found");
+                } catch (InstantiationException ie) {
+                    _log.error("Error loading " + classname, ie);
+                    throw new IllegalStateException("Invalid manager class [" + classname + "] - unable to instantiate");
+                } catch (IllegalAccessException iae) {
+                    _log.error("Error loading " + classname, iae);
+                    throw new IllegalStateException("Invalid manager class [" + classname + "] - illegal access");
+                }
+            } else {
+                throw new IllegalStateException("No manager class specified");
+            }
+        }
+        
     }
 }

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

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

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

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

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

@@ -0,0 +1,136 @@
+package net.i2p.client.streaming;
+
+import java.util.Iterator;
+import java.util.Properties;
+
+/**
+ * Define the configuration for streaming and verifying data on the socket.
+ *
+ */
+class I2PSocketOptionsImpl implements I2PSocketOptions {
+    private long _connectTimeout;
+    private long _readTimeout;
+    private long _writeTimeout;
+    private int _maxBufferSize;
+    
+    public static final int DEFAULT_BUFFER_SIZE = 1024*64;
+    public static final int DEFAULT_WRITE_TIMEOUT = 60*1000;
+    public static final int DEFAULT_CONNECT_TIMEOUT = 60*1000;
+    
+    public I2PSocketOptionsImpl() {
+        this(System.getProperties());
+    }
+    
+    public I2PSocketOptionsImpl(I2PSocketOptions opts) {
+        this(System.getProperties());
+        if (opts != null) {
+            _connectTimeout = opts.getConnectTimeout();
+            _readTimeout = opts.getReadTimeout();
+            _writeTimeout = opts.getWriteTimeout();
+            _maxBufferSize = opts.getMaxBufferSize();
+        }
+    }
+
+    public I2PSocketOptionsImpl(Properties opts) {
+        init(opts);
+    }
+    
+    protected void init(Properties opts) {
+        _maxBufferSize = getInt(opts, PROP_BUFFER_SIZE, DEFAULT_BUFFER_SIZE);
+        _connectTimeout = getInt(opts, PROP_CONNECT_TIMEOUT, DEFAULT_CONNECT_TIMEOUT);
+        _readTimeout = getInt(opts, PROP_READ_TIMEOUT, -1);
+        _writeTimeout = getInt(opts, PROP_WRITE_TIMEOUT, DEFAULT_WRITE_TIMEOUT);
+    }
+    
+    protected int getInt(Properties opts, String name, int defaultVal) {
+        if (opts == null) return defaultVal;
+        String val = opts.getProperty(name);
+        if (val == null) {
+            return defaultVal;
+        } else {
+            try {
+                return Integer.parseInt(val);
+            } catch (NumberFormatException nfe) {
+                return defaultVal;
+            }
+        }
+    }
+    
+    /**
+     * How long we will wait for the ACK from a SYN, in milliseconds.
+     *
+     * @return milliseconds to wait, or -1 if we will wait indefinitely
+     */
+    public long getConnectTimeout() {
+        return _connectTimeout;
+    }
+
+    /**
+     * Define how long we will wait for the ACK from a SYN, in milliseconds.
+     *
+     */
+    public void setConnectTimeout(long ms) {
+        _connectTimeout = ms;
+    }
+    
+    /**
+     * What is the longest we'll block on the input stream while waiting
+     * for more data.  If this value is exceeded, the read() throws 
+     * InterruptedIOException
+     */
+    public long getReadTimeout() {
+        return _readTimeout;
+    }
+
+    /**
+     * What is the longest we'll block on the input stream while waiting
+     * for more data.  If this value is exceeded, the read() throws 
+     * InterruptedIOException
+     */
+    public void setReadTimeout(long ms) {
+        _readTimeout = ms;
+    }
+    
+    /**
+     * How much data will we accept that hasn't been written out yet.  After 
+     * this amount has been exceeded, subsequent .write calls will block until
+     * either some data is removed or the connection is closed.  If this is 
+     * less than or equal to zero, there is no limit (warning: can eat ram)
+     *
+     * @return buffer size limit, in bytes
+     */
+    public int getMaxBufferSize() {
+        return _maxBufferSize; 
+    }
+    
+    /**
+     * How much data will we accept that hasn't been written out yet.  After 
+     * this amount has been exceeded, subsequent .write calls will block until
+     * either some data is removed or the connection is closed.  If this is 
+     * less than or equal to zero, there is no limit (warning: can eat ram)
+     *
+     */
+    public void setMaxBufferSize(int numBytes) {
+        _maxBufferSize = numBytes; 
+    }
+    
+    /**
+     * What is the longest we'll block on the output stream while waiting
+     * for the data to flush.  If this value is exceeded, the write() throws 
+     * InterruptedIOException.  If this is less than or equal to zero, there 
+     * is no timeout.
+     */
+    public long getWriteTimeout() {
+        return _writeTimeout;
+    }
+
+    /**
+     * What is the longest we'll block on the output stream while waiting
+     * for the data to flush.  If this value is exceeded, the write() throws 
+     * InterruptedIOException.  If this is less than or equal to zero, there 
+     * is no timeout.
+     */
+    public void setWriteTimeout(long ms) {
+        _writeTimeout = ms;
+    }
+}

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

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

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

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

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

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

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

@@ -0,0 +1,218 @@
+package net.i2p.client.streaming;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.FileInputStream;
+import java.io.OutputStream;
+import java.net.Socket;
+
+import java.util.Map;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Properties;
+import java.util.StringTokenizer;
+
+import net.i2p.I2PAppContext;
+import net.i2p.client.I2PClientFactory;
+import net.i2p.data.DataHelper;
+import net.i2p.data.Destination;
+import net.i2p.util.Log;
+import net.i2p.util.I2PThread;
+
+/**
+ * Sit around on a destination, receiving lots of data and sending lots of
+ * data to whomever talks to us.
+ *
+ * Usage: TestSwarm myKeyFile [peerDestFile ]*
+ *
+ */
+public class TestSwarm {
+    private I2PAppContext _context;
+    private Log _log;
+    private String _destFile;
+    private String _peerDestFiles[];
+    private String _conOptions;
+    private I2PSocketManager _manager;
+    private boolean _dead;
+    
+    public static void main(String args[]) {
+        if (args.length < 1) {
+            System.err.println("Usage: TestSwarm myDestFile [peerDestFile ]*");
+            return;
+        }
+        I2PAppContext ctx = new I2PAppContext();
+        String files[] = new String[args.length - 1];
+        System.arraycopy(args, 1, files, 0, files.length);
+        TestSwarm swarm = new TestSwarm(ctx, args[0], files);
+        swarm.startup();
+    }
+    
+    public TestSwarm(I2PAppContext ctx, String destFile, String peerDestFiles[]) {
+        _context = ctx;
+        _log = ctx.logManager().getLog(TestSwarm.class);
+        _dead = false;
+        _destFile = destFile;
+        _peerDestFiles = peerDestFiles;
+        _conOptions = "";
+    }
+    
+    public void startup() {
+        _log.debug("Starting up");
+        File keys = new File(_destFile);
+        if (!keys.exists()) {
+            try {
+                I2PClientFactory.createClient().createDestination(new FileOutputStream(keys));
+            } catch (Exception e) {
+                _log.error("Error creating a new destination on " + keys, e);
+                return;
+            }
+        }
+        try {
+            _manager = I2PSocketManagerFactory.createManager(new FileInputStream(_destFile), "localhost", 10001, null);
+        } catch (Exception e) {
+            _log.error("Error creatign the manager", e);
+            return;
+        }
+
+        I2PThread listener = new I2PThread(new Listener(), "Listener");
+        listener.start();
+        
+        connectWithPeers();
+    }
+    
+    
+    private void connectWithPeers() {
+        if (_peerDestFiles != null) {
+            for (int i = 0; i < _peerDestFiles.length; i++) {
+                try {
+                    FileInputStream fin = new FileInputStream(_peerDestFiles[i]);
+                    Destination dest = new Destination();
+                    dest.readBytes(fin);
+                    
+                    I2PThread flooder = new I2PThread(new Flooder(dest), "Flooder+" + dest.calculateHash().toBase64().substring(0,4));
+                    flooder.start();
+                } catch (Exception e) {
+                    _log.error("Unable to read the peer from " + _peerDestFiles[i], e);
+                }
+            }
+        }
+    }
+    
+    private class Listener implements Runnable {
+        public void run() {
+            try {
+                I2PServerSocket ss = _manager.getServerSocket();
+                I2PSocket s = null;
+                while ( (s = ss.accept()) != null) {
+                    I2PThread flooder = new I2PThread(new Flooder(s), "Flooder-" + s.getPeerDestination().calculateHash().toBase64().substring(0,4));
+                    flooder.start();
+                }
+            } catch (Exception e) {
+                _log.error("Error listening", e);
+            }
+        }
+    }
+    
+    private static volatile long __conId = 0;
+    private class Flooder implements Runnable {
+        private Destination _remoteDestination;
+        private I2PSocket _socket;
+        private boolean _closed;
+        private long _started;
+        private long _totalSent;
+        private long _totalReceived;
+        private long _lastReceived;
+        private long _lastReceivedOn;
+        private long _connectionId;
+        
+        public Flooder(Destination dest) {
+            _socket = null;
+            _remoteDestination = dest;
+            _connectionId = ++__conId;
+            _closed = false;
+            _lastReceived = -1;
+            _lastReceivedOn = _context.clock().now();
+            _context.statManager().createRateStat("swarm." + _connectionId + ".totalReceived", "Data size received", "swarm", new long[] { 30*1000, 60*1000, 5*60*1000 });
+            _context.statManager().createRateStat("swarm." + _connectionId + ".totalSent", "Data size sent", "swarm", new long[] { 30*1000, 60*1000, 5*60*1000 });
+            _context.statManager().createRateStat("swarm." + _connectionId + ".started", "When we start", "swarm", new long[] { 5*60*1000 });
+            _context.statManager().createRateStat("swarm." + _connectionId + ".lifetime", "How long we talk to a peer", "swarm", new long[] { 5*60*1000 });
+        }
+        
+        public Flooder(I2PSocket socket) {
+            _socket = socket;
+            _remoteDestination = socket.getPeerDestination();
+            _connectionId = ++__conId;
+            _closed = false;
+            _lastReceived = -1;
+            _lastReceivedOn = _context.clock().now();
+            _context.statManager().createRateStat("swarm." + _connectionId + ".totalReceived", "Data size received", "swarm", new long[] { 30*1000, 60*1000, 5*60*1000 });
+            _context.statManager().createRateStat("swarm." + _connectionId + ".totalSent", "Data size sent", "swarm", new long[] { 30*1000, 60*1000, 5*60*1000 });
+            _context.statManager().createRateStat("swarm." + _connectionId + ".started", "When we start", "swarm", new long[] { 5*60*1000 });
+            _context.statManager().createRateStat("swarm." + _connectionId + ".lifetime", "How long we talk to a peer", "swarm", new long[] { 5*60*1000 });
+        }
+        
+        public long getConnectionId() { return _connectionId; }
+        public Destination getDestination() { return _remoteDestination; }
+        
+        public void run() {
+            _started = _context.clock().now();
+            _context.statManager().addRateData("swarm." + _connectionId + ".started", 1, 0);
+            byte data[] = new byte[32*1024];
+            long value = 0;
+            long lastSend = _context.clock().now();
+            if (_socket == null) {
+                try {
+                    _socket = _manager.connect(_remoteDestination);
+                } catch (Exception e) {
+                    _log.error("Error connecting to " + _remoteDestination.calculateHash().toBase64().substring(0,4));
+                    return;
+                }
+            }
+            
+            I2PThread floodListener = new I2PThread(new FloodListener(), "FloodListener" + _connectionId);
+            floodListener.start();
+            
+            try {
+                OutputStream out = _socket.getOutputStream();
+                while (!_closed) {
+                    out.write(data);
+                    // out.flush();
+                    _totalSent += data.length;
+                    _context.statManager().addRateData("swarm." + _connectionId + ".totalSent", _totalSent, 0);
+                    //try { Thread.sleep(100); } catch (InterruptedException ie) {}
+                    long now = _context.clock().now();
+                    _log.debug("Sending " + _connectionId + " after " + (now-lastSend));
+                    lastSend = now;
+                    try { Thread.sleep(20); } catch (InterruptedException ie) {}
+                }
+            } catch (Exception e) {
+                _log.error("Error sending", e);
+            }
+        }
+        
+        private class FloodListener implements Runnable {
+            public void run() {
+                long lastRead = System.currentTimeMillis();
+                long now = lastRead;
+                try {
+                    InputStream in = _socket.getInputStream();
+                    byte buf[] = new byte[32*1024];
+                    int read = 0;
+                    while ( (read = in.read(buf)) != -1) {
+                        now = System.currentTimeMillis();
+                        _totalReceived += read;
+                        _context.statManager().addRateData("swarm." + getConnectionId() + ".totalReceived", _totalReceived, 0);
+                        _log.debug("Receiving " + _connectionId + " with " + read + " after " + (now-lastRead));
+                        lastRead = now;
+                    }
+                } catch (Exception e) {
+                    _log.error("Error listening to the flood", e);
+                }
+            }
+        }
+    }
+}

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

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

apps/myi2p/java/build.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<project basedir="." default="all" name="time">
+<project basedir="." default="all" name="myi2p">
     <target name="all" depends="clean, build" />
     <target name="build" depends="builddep, jar" />
     <target name="builddep">
@@ -8,32 +8,30 @@
     <target name="compile">
         <mkdir dir="./build" />
         <mkdir dir="./build/obj" />
-        <javac srcdir="./src" debug="true" source="1.3" target="1.3" deprecation="on" destdir="./build/obj" includes="**/*.java" classpath="../../../core/java/build/i2p.jar" />
+        <javac 
+            srcdir="./src" 
+            debug="true" deprecation="on" source="1.3" target="1.3" 
+            destdir="./build/obj" 
+            classpath="../../../core/java/build/i2p.jar" />
     </target>
     <target name="jar" depends="compile">
-        <jar destfile="./build/timestamper.jar" basedir="./build/obj" includes="**/*.class">
-            <manifest>
-                <attribute name="Main-Class" value="net.i2p.time.Timestamper" />
-                <attribute name="Class-Path" value="i2p.jar timestamper.jar" />
-            </manifest>
-        </jar>
+        <jar destfile="./build/myi2p.jar" basedir="./build/obj" includes="**/*.class" />
     </target>
     <target name="javadoc">
         <mkdir dir="./build" />
         <mkdir dir="./build/javadoc" />
         <javadoc 
-            sourcepath="./src:../../../core/java/src:../../../core/java/test" destdir="./build/javadoc" 
+            sourcepath="./src:../../../core/java/src" destdir="./build/javadoc" 
             packagenames="*" 
             use="true" 
-            access="package"
             splitindex="true" 
-            windowtitle="I2P timestamper" />
+            windowtitle="MyI2P" />
     </target>
     <target name="clean">
         <delete dir="./build" />
     </target>
     <target name="cleandep" depends="clean">
-        <ant dir="../../../core/java/" target="cleandep" />
+        <ant dir="../../../core/java/" target="distclean" />
     </target>
     <target name="distclean" depends="clean">
         <ant dir="../../../core/java/" target="distclean" />

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

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

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

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

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

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

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

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

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

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

apps/myi2p/java/src/net/i2p/myi2p/address/AddressBook.java

@@ -0,0 +1,126 @@
+package net.i2p.myi2p.address;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import net.i2p.I2PAppContext;
+import net.i2p.data.DataHelper;
+import net.i2p.data.DataFormatException;
+
+/**
+ * Main lookup component for maintaining references to other I2P destinations.
+ *
+ */
+public class AddressBook {
+    private I2PAppContext _context;
+    /** Name (String) to AddressBookEntry */
+    private Map _entries;
+    /** 
+     * List of NameReference that has been received but whose preferred 
+     * name conflicts with an existing entry.
+     */
+    private List _conflictingReferences;
+    
+    public AddressBook(I2PAppContext context) {
+        _context = context;
+        _entries = new HashMap(16);
+        _conflictingReferences = new ArrayList(0);
+    }
+    
+    /** retrieve a list of entry names (strings) */
+    public Set getEntryNames() { 
+        synchronized (_entries) { 
+            return new HashSet(_entries.keySet()); 
+        }
+    }
+    public AddressBookEntry getEntry(String name) { 
+        synchronized (_entries) {
+            return (AddressBookEntry)_entries.get(name); 
+        }
+    }
+    public AddressBookEntry addEntry(AddressBookEntry entry) {
+        synchronized (_entries) {
+            return (AddressBookEntry)_entries.put(entry.getLocalName(), entry);
+        }
+    }
+    public void removeEntry(String name) { 
+        synchronized (_entries) {
+            _entries.remove(name); 
+        }
+    }
+    
+    public int getConflictingReferenceCount() { 
+        synchronized (_conflictingReferences) {
+            return _conflictingReferences.size(); 
+        }
+    }
+    public NameReference getConflictingReference(int index) { 
+        synchronized (_conflictingReferences) {
+            return (NameReference)_conflictingReferences.get(index); 
+        }
+    }
+    public void addConflictingReference(NameReference ref) { 
+        synchronized (_conflictingReferences) {
+            _conflictingReferences.add(ref); 
+        }
+    }
+    public void removeConflictingReference(int index) { 
+        synchronized (_conflictingReferences) {
+            _conflictingReferences.remove(index);
+        }
+    }
+    
+    public void read(InputStream in) throws IOException {
+        try {
+            int numEntries = (int)DataHelper.readLong(in, 2);
+            if (numEntries < 0) throw new IOException("Corrupt AddressBook - " + numEntries + " entries?");
+            for (int i = 0; i < numEntries; i++) {
+                AddressBookEntry entry = new AddressBookEntry(_context);
+                entry.read(in);
+                addEntry(entry);
+            }
+            int numConflicting = (int)DataHelper.readLong(in, 2);
+            if (numConflicting < 0) throw new IOException("Corrupt AddressBook - " + numConflicting + " conflicting?");
+            for (int i = 0; i < numConflicting; i++) {
+                NameReference ref = new NameReference(_context);
+                ref.read(in);
+                addConflictingReference(ref);
+            }
+        } catch (DataFormatException dfe) {
+            throw new IOException("Corrupt address book - " + dfe.getMessage());
+        }
+    }
+    public void write(OutputStream out) throws IOException {
+        try {
+            synchronized (_entries) {
+                DataHelper.writeLong(out, 2, _entries.size());
+                for (Iterator iter = _entries.values().iterator(); iter.hasNext(); ) {
+                    AddressBookEntry entry = (AddressBookEntry)iter.next();
+                    entry.write(out);
+                }
+            }
+            synchronized (_conflictingReferences) {
+                DataHelper.writeLong(out, 2, _conflictingReferences.size());
+                for (int i = 0; i < _conflictingReferences.size(); i++) {
+                    NameReference ref = (NameReference)_conflictingReferences.get(i);
+                    ref.write(out);
+                }
+            }
+        } catch (DataFormatException dfe) {
+            throw new IOException("Corrupt address book - " + dfe.getMessage());
+        }
+    }
+    
+    public String toString() {
+        return "Entries: " + _entries.size() + " conflicting: " + _conflictingReferences.size();
+    }
+}

apps/myi2p/java/src/net/i2p/myi2p/address/AddressBookEntry.java

@@ -0,0 +1,142 @@
+package net.i2p.myi2p.address;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+import java.util.Date;
+import java.util.Properties;
+
+import net.i2p.I2PAppContext;
+import net.i2p.data.DataHelper;
+import net.i2p.data.DataFormatException;
+
+/**
+ * Implements a local address book entry, pointing at a known secure 
+ * NameReference as well as an optional Subscription.
+ *
+ */
+public class AddressBookEntry {
+    private I2PAppContext _context;
+    private String _localName;
+    private Properties _options;
+    private NameReference _reference;
+    private Subscription _subscription;
+    private long _addedOn;
+    
+    public AddressBookEntry(I2PAppContext context) {
+        _context = context;
+        _localName = null;
+        _options = new Properties();
+        _reference = null;
+        _subscription = null;
+        _addedOn = context.clock().now();
+    }
+    
+    /** Local (unique) name we use to reference the given destination */
+    public String getLocalName() { return _localName; }
+    public void setLocalName(String name) { _localName = name; }
+    
+    public Properties getOptions() { 
+        synchronized (_options) {
+            return new Properties(_options);
+        }
+    }
+    public void setOptions(Properties props) { 
+        synchronized (_options) {
+            _options.clear();
+            if (props != null)
+                _options.putAll(props);
+        }
+    }
+    
+    /** Secure name reference, provided by the destination */
+    public NameReference getNameReference() { return _reference; }
+    public void setNameReference(NameReference ref) { _reference = ref; }
+    
+    /** 
+     * If specified, the details of our subscription to the MyI2P address
+     * book at the referenced destination.
+     *
+     */
+    public Subscription getSubscription() { return _subscription; }
+    public void setSubscription(Subscription sub) { _subscription = sub; }
+    
+    /** When this entry was added */
+    public long getAddedOn() { return _addedOn; }
+    public void setAddedOn(long when) { _addedOn = when; }
+    
+    /** load the data from the stream */
+    public void read(InputStream in) throws IOException {
+        try {
+            Boolean localNameDefined = DataHelper.readBoolean(in);
+            if ( (localNameDefined != null) && (localNameDefined.booleanValue()) ) 
+                _localName = DataHelper.readString(in);
+            else
+                _localName = null;
+            
+            Date when = DataHelper.readDate(in);
+            if (when == null)
+                _addedOn = -1;
+            else
+                _addedOn = when.getTime();
+            
+            Properties props = DataHelper.readProperties(in);
+            setOptions(props);
+            
+            Boolean refDefined = DataHelper.readBoolean(in);
+            if ( (refDefined != null) && (refDefined.booleanValue()) ) {
+                _reference = new NameReference(_context);
+                _reference.read(in);
+            } else {
+                _reference = null;
+            }
+            
+            Boolean subDefined = DataHelper.readBoolean(in);
+            if ( (subDefined != null) && (subDefined.booleanValue()) ) {
+                Subscription sub = new Subscription(_context);
+                sub.read(in);
+                _subscription = sub;
+            } else {
+                _subscription = null;
+            }
+            
+        } catch (DataFormatException dfe) {
+            throw new IOException("Corrupt subscription: " + dfe.getMessage());
+        }
+    }
+    
+    /** persist the data to the stream */
+    public void write(OutputStream out) throws IOException {
+        try {
+            if ( (_localName != null) && (_localName.trim().length() > 0) ) {
+                DataHelper.writeBoolean(out, Boolean.TRUE);
+                DataHelper.writeString(out, _localName);
+            } else {
+                DataHelper.writeBoolean(out, Boolean.FALSE);
+            }
+            
+            DataHelper.writeDate(out, new Date(_addedOn));
+            
+            synchronized (_options) {
+                DataHelper.writeProperties(out, _options);
+            }
+            
+            if (_reference != null) {
+                DataHelper.writeBoolean(out, Boolean.TRUE);
+                _reference.write(out);
+            } else {
+                DataHelper.writeBoolean(out, Boolean.FALSE);
+            }
+            
+            if (_subscription != null) {
+                DataHelper.writeBoolean(out, Boolean.TRUE);
+                _subscription.write(out);
+            } else {
+                DataHelper.writeBoolean(out, Boolean.FALSE);
+            }
+        } catch (DataFormatException dfe) {
+            throw new IOException("Corrupt subscription: " + dfe.getMessage());
+        }
+    }
+}

apps/myi2p/java/src/net/i2p/myi2p/address/AddressBookService.java

@@ -0,0 +1,90 @@
+package net.i2p.myi2p.address;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+
+import net.i2p.data.DataHelper;
+import net.i2p.data.DataFormatException;
+import net.i2p.util.Log;
+
+import net.i2p.myi2p.Service;
+import net.i2p.myi2p.ServiceImpl;
+import net.i2p.myi2p.Node;
+import net.i2p.myi2p.MyI2PMessage;
+
+/**
+ * Main service handler / coordinator for the MyI2P address book.
+ *
+ */
+public class AddressBookService extends ServiceImpl {
+    private Log _log;
+    private AddressBook _addressBook;
+    /** contains a mapping of event time (Long) to description (String) */
+    private Map _activityLog;
+    private String _addressBookFile;
+    
+    private static String PROP_ADDRESSBOOK_FILE = "datafile";
+    private static String DEFAULT_ADDRESSBOOK_FILE = "addressbook.dat";
+    
+    public static final String SERVICE_TYPE = "AddressBook";
+    public String getType() { return SERVICE_TYPE; }
+    
+    public void startup() {
+        _log = getContext().logManager().getLog(AddressBookService.class);
+        
+        _addressBookFile = getOptions().getProperty(PROP_ADDRESSBOOK_FILE, DEFAULT_ADDRESSBOOK_FILE);
+        File file = new File(_addressBookFile);
+    
+        if (file.exists()) {
+            loadData(file);
+        } else {
+            _addressBook = new AddressBook(getContext());
+            _activityLog = new HashMap(16);
+        }
+    }
+    
+    public void shutdown() {
+        File file = new File(_addressBookFile);
+        storeData(file);
+    }
+    
+    public void receiveMessage(MyI2PMessage msg) {
+        _log.info("Received a " + msg.getMessageType() + " from " 
+                  + msg.getPeer().calculateHash().toBase64() 
+                  + new String(msg.getPayload()));
+    }
+    
+    /** load everything from disk */
+    private void loadData(File dataFile) {
+        AddressBookServiceData data = new AddressBookServiceData(getContext());
+        data.load(dataFile);
+        if (data.getErrorMessage() != null) {
+            _log.warn(data.getErrorMessage(), data.getError());
+            _addressBook = new AddressBook(getContext());
+            _activityLog = new HashMap(16);
+        } else {
+            _addressBook = data.getAddressBook();
+            _activityLog = data.getActivityLog();
+        }
+    }
+    
+    /** persist everything to disk */
+    private void storeData(File dataFile) {
+        AddressBookServiceData data = new AddressBookServiceData(getContext());
+        data.setActivityLog(_activityLog);
+        data.setAddressBook(_addressBook);
+        data.store(dataFile);
+        if (data.getErrorMessage() != null) {
+            _log.warn(data.getErrorMessage(), data.getError());
+        }
+    }
+}