update version, add link to Packaging page

update the muwire icon which appears on the router console itself

See merge request zlatinb/muwire!48

.dockerignore

@@ -0,0 +1,12 @@
+# Dot directories
+.gradle/
+.idea/
+.git/
+
+# Build directories
+build/
+**/build/
+
+# We execute COPY . .
+# Modifying these files would unnecessarily invalidate the build context
+Dockerfile

.gitignore

@@ -2,5 +2,7 @@
 **/.settings
 **/build
 .gradle
-.project
-.classpath
+**/.project
+**/.classpath
+**/*.rej
+**/*.orig

.tx/config

@@ -0,0 +1,9 @@
+[main]
+host = https://www.transifex.com
+lang_map = he: iw, id: in, ru_RU: ru, sv_SE: sv, tr_TR: tr, uk_UA: uk, yi: ji, zh_CN: zh
+
+[I2P.MuWire]
+file_filter = webui/locale/messages_<lang>.po
+source_file = webui/locale/messages_en.po
+source_lang = en
+minimum_perc = 10

Dockerfile

@@ -0,0 +1,64 @@
+FROM jlesage/baseimage-gui:alpine-3.10-glibc
+
+# Docker image version is provided via build arg.
+ARG DOCKER_IMAGE_VERSION=unknown
+
+# JDK version
+ARG JDK=11
+
+# Important directories
+ARG TMP_DIR=/muwire-tmp
+ENV APP_HOME=/muwire
+
+# Define working directory.
+WORKDIR $TMP_DIR
+
+# Put sources into dir
+COPY . .
+
+# Install final dependencies
+RUN add-pkg openjdk${JDK}-jre
+
+# Build and untar in future distribution dir
+RUN add-pkg --virtual openjdk${JDK}-jdk \
+        && ./gradlew --no-daemon clean assemble \
+        && mkdir -p ${APP_HOME} \
+        # Extract to ${APP_HOME and ignore the first dir
+        # First dir in tar is the "MuWire-<version>"
+        && tar -C ${APP_HOME} --strip 1 -xvf gui/build/distributions/MuWire*.tar \
+        # Cleanup
+        && rm -rf "${TMP_DIR}" /root/.gradle /root/.java \
+        && del-pkg openjdk${JDK}-jdk
+
+WORKDIR ${APP_HOME}
+
+# Maximize only the main/initial window.
+RUN \
+    sed-patch 's/<application type="normal">/<application type="normal" title="MuWire">/' \
+        /etc/xdg/openbox/rc.xml
+
+# Generate and install favicons.
+RUN \
+    APP_ICON_URL=https://github.com/zlatinb/muwire/raw/master/gui/griffon-app/resources/MuWire-128x128.png && \
+    install_app_icon.sh "$APP_ICON_URL"
+
+# Add files.
+COPY docker/rootfs/ /
+
+# Set environment variables.
+ENV APP_NAME="MuWire" \
+    S6_KILL_GRACETIME=8000
+
+# Define mountable directories.
+VOLUME ["$APP_HOME/.MuWire"]
+VOLUME ["/incompletes"]
+VOLUME ["/output"]
+
+
+# Metadata.
+LABEL \
+      org.label-schema.name="muwire" \
+      org.label-schema.description="Docker container for MuWire" \
+      org.label-schema.version="$DOCKER_IMAGE_VERSION" \
+      org.label-schema.vcs-url="https://github.com/zlatinb/muwire" \
+      org.label-schema.schema-version="1.0"

README.md

@@ -1,14 +1,16 @@
+The GitHub repo is mirrored from the in-I2P GitLab repo.  Please open PRs and issues at http://git.idk.i2p/zlatinb/muwire
+
 # MuWire - Easy Anonymous File-Sharing
 
 MuWire is an easy to use file-sharing program which offers anonymity using [I2P technology](http://geti2p.net).  It works on any platform Java works on, including Windows,MacOS,Linux.
 
-It is inspired by the LimeWire Gnutella client and developped by a former LimeWire developer.
+The current stable release - 0.7.4 is avaiable for download at https://muwire.com.  The latest plugin build and instructions how to install the plugin are available inside I2P at http://muwire.i2p.  
 
-The current stable release - 0.4.6 is avaiable for download at https://muwire.com.  You can find technical documentation in the "doc" folder.
+You can find technical documentation in the [doc] folder.  Also check out the [Wiki] for various other documentation.
 
-### Building
+## Building
 
-You need JRE 8 or newer.  After installing that and setting up the appropriate paths, just type
+You need JDK 9 or newer.  After installing that and setting up the appropriate paths, just type
 
 ```
 ./gradlew clean assemble
@@ -19,19 +21,41 @@ If you want to run the unit tests, type
 ./gradlew clean build
 ```
 
-Some of the UI tests will fail because they haven't been written yet :-/
+If you want to build binary bundles that do not depend on Java or I2P, see the [muwire-pkg] project.  If you want to package MuWire for a Linux distribution, see the [Packaging] wiki page.
 
-### Running
+## Running the GUI
 
-After you build the application, look inside `gui/build/distributions`.  Untar/unzip one of the `shadow` files and then run the jar contained inside by typing `java -jar MuWire-x.y.z.jar` in a terminal or command prompt.
+Type
+```
+./gradlew gui:run
+```
 
-If you have an I2P router running on the same machine that is all you need to do.  If you use a custom I2CP host and port, create a file `i2p.properties` and put `i2cp.tcp.host=<host>` and `i2cp.tcp.port=<port>` in there.  On Windows that file should go into `%HOME%\AppData\Roaming\MuWire`, on Mac into `$HOME/Library/Application Support/MuWire` and on Linux `$HOME/.MuWire`
+The setup wizard will ask you for the host and port of an I2P or I2Pd router.
 
-[Default I2CP port]\: `7654`
+## Running the CLI
 
-If you do not have an I2P router, pass the following switch to the Java process: `-DembeddedRouter=true`.  This will launch MuWire's embedded router.  Be aware that this causes startup to take a lot longer.
+Look inside `cli-lanterna/build/distributions`.  Untar/unzip one of the `shadow` files and then run the jar contained inside by typing `java -jar cli-lanterna-x.y.z-all.jar` in a terminal.  The CLI will ask you about the router host and port on startup, no need to edit any files.  However, the CLI does not have an options window yet, so if you need to change any options you will need to edit the configuration files.  The CLI options are documented here [cli options]
 
-### GPG Fingerprint
+The CLI is under active development and doesn't have all the features of the GUI.
+
+## Running the Web UI / Plugin
+
+There is a Web-based UI under development.  It is intended to be run as a plugin to the Java I2P router.  Instructions how to build it are available at the wiki [Plugin] page.
+
+## Docker
+
+MuWire is available as a Docker image.  For more information see the [Docker] page.
+
+## Translations
+If you want to help translate MuWire, instructions are on the wiki https://github.com/zlatinb/muwire/wiki/Translate
+
+## Related Projects
+### MuWire Tracker Daemon
+The MuWire Tracker Daemon (or mwtrackerd for short) is a project to bring functionality similar to BitTorrent tracking to MuWire.  For more info see the [Tracker] page.
+### MuCats
+MuCats is a project to create a website for hosting hashes of files shared on the MuWire network.  For more info see the [MuCats] project.
+
+## GPG Fingerprint
 
 ```
 471B 9FD4 5517 A5ED 101F  C57D A728 3207 2D52 5E41
@@ -41,3 +65,14 @@ You can find the full key at https://keybase.io/zlatinb
 
 
 [Default I2CP port]: https://geti2p.net/en/docs/ports
+[Wiki]: https://github.com/zlatinb/muwire/wiki
+[doc]: https://github.com/zlatinb/muwire/tree/master/doc
+[muwire-pkg]: https://github.com/zlatinb/muwire-pkg 
+[Packaging]: https://github.com/zlatinb/muwire/wiki/Packaging
+[cli options]: https://github.com/zlatinb/muwire/wiki/CLI-Configuration-Options
+[I2P Github]: https://github.com/i2p/i2p.i2p
+[Plugin]: https://github.com/zlatinb/muwire/wiki/Plugin
+[Docker]: https://github.com/zlatinb/muwire/wiki/Docker
+[jlesage/docker-baseimage-gui]: https://github.com/jlesage/docker-baseimage-gui
+[Tracker]: https://github.com/zlatinb/muwire/wiki/Tracker-Daemon
+[MuCats]: https://github.com/zlatinb/mucats

TODO.md

@@ -1,8 +1,6 @@
 # TODO List
 
-Not in any particular order yet
-
-### Big Items
+### Network
 
 ##### Bloom Filters
 
@@ -12,20 +10,36 @@ This reduces query traffic by not sending last hop queries to peers that definit
 
 This helps with scalability
 
-##### Content Control Panel
+### Core
 
-To allow every user to not route queries for content they do not like.  This is mostly GUI work, the backend part is simple
+* Metadata parsing and search
+* Automatic adjustment of number of I2P tunnels
+* Persist trust immediately
+* Enum i18n
+* Ability to share trust list only with trusted users
+* Confidential files visible only to certain users
+* Download queue with priorities 
+* Use tracker pings - either embedded logic or external mwtrackerd to add more sources to downloads
 
-##### Web UI, REST Interface, etc.
+### Chat
+* break up lines on CR/LF, send multiple messages
+* enforce # in room names or ignore it
+* auto-create/join channel on server start
+* jump from notification window to room with message
 
-Basically any non-gui non-cli user interface
+### Swing GUI
+* I2P Status panel - display message when connected to external router
+* Search box - left identation
+* Ability to disable switching of tabs on actions
 
-##### Metadata editing and search
+### Web UI/Plugin
+* HTML 5 media players
+* Remove versions from jar names
+* Security: POST nonces, CSP headers
+* Upload files from browser to plugin via drag-and-drop
+* Check permissions, display better errors when sharing local folders
 
-To enable parsing of metadata from known file types and the user editing it or adding manual metadata
-
-### Small Items
-
-* Wrapper of some kind for in-place upgrades
-* Download file sequentially
-* Multiple-selection download, Ctrl-A
+### mwtrackerd
+* `save` and `load` JSON-RPC commands that save and load swarm state respectively
+* load-test with many many hashes (1M?)
+* evaluate other usage scenarios besides website backend 

build.gradle

@@ -2,12 +2,26 @@ subprojects {
     apply plugin: 'groovy'
 
     dependencies {
-        compile 'net.i2p:i2p:0.9.41'
-        compile 'org.codehaus.groovy:groovy-all:2.4.15'
+        compile "org.codehaus.groovy:groovy:${groovyVersion}"
+        compile "org.codehaus.groovy:groovy-jsr223:${groovyVersion}"
+        compile "org.codehaus.groovy:groovy-json:${groovyVersion}"
     }
 
     compileGroovy {
-        groovyOptions.optimizationOptions.indy = true
+        groovyOptions.optimizationOptions.indy = false
+        sourceCompatibility = project.sourceCompatibility
+        targetCompatibility = project.targetCompatibility
+        options.compilerArgs += project.compilerArgs
+        options.deprecation = true
+        options.encoding = 'UTF-8'
+    }
+
+    compileJava {
+        sourceCompatibility = project.sourceCompatibility
+        targetCompatibility = project.targetCompatibility
+        options.compilerArgs += project.compilerArgs
+        options.deprecation = true
+        options.encoding = 'UTF-8'
     }
 
     repositories {

cli-lanterna/build.gradle

@@ -0,0 +1,27 @@
+buildscript {
+
+    repositories {
+        jcenter()
+        mavenLocal()
+    }
+
+    dependencies {
+        classpath 'com.github.jengelman.gradle.plugins:shadow:5.2.0'
+    }
+}
+
+apply plugin : 'application'
+application {
+    mainClassName = 'com.muwire.clilanterna.CliLanterna'
+    applicationDefaultJvmArgs = ['-Djava.util.logging.config.file=logging.properties','-Xmx256M']
+    applicationName = 'MuWire-cli'
+}
+
+apply plugin : 'com.github.johnrengelman.shadow'
+
+
+dependencies {
+    compile project(":core")
+    compile 'com.googlecode.lanterna:lanterna:3.0.1'
+}
+

cli-lanterna/src/main/groovy/com/muwire/clilanterna/AddCommentView.groovy

@@ -0,0 +1,73 @@
+package com.muwire.clilanterna
+
+import com.googlecode.lanterna.gui2.TextBox
+import com.googlecode.lanterna.gui2.TextGUI
+import com.googlecode.lanterna.gui2.Window
+import com.googlecode.lanterna.gui2.dialogs.MessageDialog
+import com.googlecode.lanterna.gui2.dialogs.MessageDialogButton
+import com.googlecode.lanterna.TerminalSize
+import com.googlecode.lanterna.gui2.BasicWindow
+import com.googlecode.lanterna.gui2.Button
+import com.googlecode.lanterna.gui2.GridLayout
+import com.googlecode.lanterna.gui2.GridLayout.Alignment
+import com.googlecode.lanterna.gui2.LayoutData
+import com.googlecode.lanterna.gui2.Panel
+import com.muwire.core.Constants
+import com.muwire.core.Core
+import com.muwire.core.SharedFile
+import com.muwire.core.files.UICommentEvent
+import com.muwire.core.util.DataUtil
+
+import net.i2p.data.Base64
+
+class AddCommentView extends BasicWindow {
+    private final TextGUI textGUI
+    private final Core core
+    private final TextBox textBox
+    private final LayoutData layoutData = GridLayout.createLayoutData(Alignment.CENTER, Alignment.CENTER)
+      
+    AddCommentView(TextGUI textGUI, Core core, SharedFile sharedFile, TerminalSize terminalSize) {
+        super("Add Comment To "+sharedFile.getFile().getName())
+        this.textGUI = textGUI
+        this.core = core
+        
+        setHints([Window.Hint.CENTERED])
+
+        Panel contentPanel = new Panel()
+        contentPanel.setLayoutManager(new GridLayout(1))
+                
+        String oldComment = sharedFile.getComment()
+        if (oldComment == null)
+            oldComment = ""
+        else
+            oldComment = DataUtil.readi18nString(Base64.decode(oldComment))
+            
+        TerminalSize boxSize = new TerminalSize((terminalSize.getColumns() / 2).toInteger(), (terminalSize.getRows() / 2).toInteger())
+        textBox = new TextBox(boxSize,oldComment,TextBox.Style.MULTI_LINE)    
+        contentPanel.addComponent(textBox, layoutData)
+        
+        Panel buttonsPanel = new Panel()
+        buttonsPanel.setLayoutManager(new GridLayout(2))
+        contentPanel.addComponent(buttonsPanel, layoutData)
+        
+        Button saveButton = new Button("Save", {
+            String newComment = textBox.getText()
+            if (newComment.length() > Constants.MAX_COMMENT_LENGTH) {
+                String error = "Your comment is too long - ${newComment.length()} bytes.  Maximum is $Constants.MAX_COMMENT_LENGTH bytes"
+                MessageDialog.showMessageDialog(textGUI, "Comment Too Long", error, MessageDialogButton.Close)
+            } else {
+                newComment = Base64.encode(DataUtil.encodei18nString(newComment))
+                String encodedOldComment = sharedFile.getComment()
+                sharedFile.setComment(newComment)
+                core.eventBus.publish(new UICommentEvent(sharedFile : sharedFile, oldComment : encodedOldComment))
+                close()
+            }
+        })
+        Button cancelButton = new Button("Cancel", {close()})
+        
+        buttonsPanel.addComponent(saveButton, layoutData)
+        buttonsPanel.addComponent(cancelButton, layoutData)
+        
+        setComponent(contentPanel)
+    }
+}

cli-lanterna/src/main/groovy/com/muwire/clilanterna/BrowseModel.groovy

@@ -0,0 +1,98 @@
+package com.muwire.clilanterna
+
+import com.googlecode.lanterna.gui2.Label
+import com.googlecode.lanterna.gui2.TextGUIThread
+import com.googlecode.lanterna.gui2.table.TableModel
+import com.muwire.core.Core
+import com.muwire.core.Persona
+import com.muwire.core.search.BrowseStatus
+import com.muwire.core.search.BrowseStatusEvent
+import com.muwire.core.search.UIBrowseEvent
+import com.muwire.core.search.UIResultEvent
+
+import net.i2p.data.Base64
+import net.i2p.data.DataHelper
+
+class BrowseModel {
+    private final Persona persona
+    private final Core core
+    private final TextGUIThread guiThread
+    private final TableModel model = new TableModel("Name","Size","Hash","Comment","Certificates")
+    private Map<String, UIResultEvent> rootToResult = new HashMap<>()
+    
+    private int totalResults
+    
+    private Label status
+    private Label percentage
+    
+    BrowseModel(Persona persona, Core core, TextGUIThread guiThread) {
+        this.persona = persona
+        this.core = core
+        this.guiThread = guiThread
+        
+        core.eventBus.register(BrowseStatusEvent.class, this)
+        core.eventBus.register(UIResultEvent.class, this)
+        core.eventBus.publish(new UIBrowseEvent(host : persona))
+    }
+    
+    void unregister() {
+        core.eventBus.unregister(BrowseStatusEvent.class, this)
+        core.eventBus.unregister(UIResultEvent.class, this)
+    }
+    
+    void onBrowseStatusEvent(BrowseStatusEvent e) {
+        guiThread.invokeLater {
+            status.setText(e.status.toString())
+            if (e.status == BrowseStatus.FETCHING)
+                totalResults = e.totalResults
+        }
+    }
+    
+    void onUIResultEvent(UIResultEvent e) {
+        guiThread.invokeLater {
+            String size = DataHelper.formatSize2Decimal(e.size, false) + "B"
+            String infoHash = Base64.encode(e.infohash.getRoot())
+            String comment = String.valueOf(e.comment != null)
+            model.addRow(e.name, size, infoHash, comment, e.certificates)
+            rootToResult.put(infoHash, e)
+            
+            String percentageString = ""
+            if (totalResults != 0) {
+                double percentage = Math.round( (model.getRowCount() * 100 / totalResults).toDouble() )
+                percentageString = String.valueOf(percentage)+"%"
+            }
+            percentage.setText(percentageString)
+        }
+    }
+    
+    void setStatusLabel(Label status) {
+        this.status = status
+    }
+    
+    void setPercentageLabel(Label percentage) {
+        this.percentage = percentage
+    }
+    
+    void sort(SortType type) {
+        Comparator<UIResultEvent> chosen
+        switch(type) {
+            case SortType.NAME_ASC : chosen = ResultComparators.NAME_ASC; break
+            case SortType.NAME_DESC : chosen = ResultComparators.NAME_DESC; break
+            case SortType.SIZE_ASC : chosen = ResultComparators.SIZE_ASC; break
+            case SortType.SIZE_DESC : chosen = ResultComparators.SIZE_DESC; break
+        }
+        
+        List<UIResultEvent> l = new ArrayList<>(rootToResult.values())
+        Collections.sort(l, chosen)
+        
+        int rowCount = model.getRowCount()
+        rowCount.times { model.removeRow(0) }
+        
+        l.each { e ->
+            String size = DataHelper.formatSize2Decimal(e.size, false) + "B"
+            String infoHash = Base64.encode(e.infohash.getRoot())
+            String comment = String.valueOf(e.comment != null)
+            model.addRow(e.name, size, infoHash, comment, e.certificates)
+        }
+    }
+}

cli-lanterna/src/main/groovy/com/muwire/clilanterna/BrowseView.groovy

@@ -0,0 +1,136 @@
+package com.muwire.clilanterna
+
+import com.googlecode.lanterna.TerminalSize
+import com.googlecode.lanterna.gui2.BasicWindow
+import com.googlecode.lanterna.gui2.Button
+import com.googlecode.lanterna.gui2.GridLayout
+import com.googlecode.lanterna.gui2.GridLayout.Alignment
+import com.googlecode.lanterna.gui2.Label
+import com.googlecode.lanterna.gui2.LayoutData
+import com.googlecode.lanterna.gui2.Panel
+import com.googlecode.lanterna.gui2.TextGUI
+import com.googlecode.lanterna.gui2.Window
+import com.googlecode.lanterna.gui2.dialogs.MessageDialog
+import com.googlecode.lanterna.gui2.dialogs.MessageDialogButton
+import com.googlecode.lanterna.gui2.table.Table
+import com.muwire.core.Core
+import com.muwire.core.download.UIDownloadEvent
+import com.muwire.core.search.UIResultEvent
+
+
+class BrowseView extends BasicWindow {
+    private final BrowseModel model
+    private final TextGUI textGUI
+    private final Core core
+    private final Table table
+    private final TerminalSize terminalSize
+    private final LayoutData layoutData = GridLayout.createLayoutData(Alignment.CENTER, Alignment.CENTER, true, false) 
+    
+    BrowseView(BrowseModel model, TextGUI textGUI, Core core, TerminalSize terminalSize) {
+        super("Browse "+model.persona.getHumanReadableName())
+        this.model = model
+        this.textGUI = textGUI
+        this.core = core
+        this.terminalSize = terminalSize
+        
+        setHints([Window.Hint.EXPANDED])
+        
+        Panel contentPanel = new Panel()
+        contentPanel.setLayoutManager(new GridLayout(1))
+        
+        Label statusLabel = new Label("")
+        Label percentageLabel = new Label("")
+        model.setStatusLabel(statusLabel)
+        model.setPercentageLabel(percentageLabel)
+        
+        Panel topPanel = new Panel()
+        topPanel.setLayoutManager(new GridLayout(2))
+        topPanel.addComponent(statusLabel, layoutData)
+        topPanel.addComponent(percentageLabel, layoutData)
+        contentPanel.addComponent(topPanel, layoutData)
+        
+        table = new Table("Name","Size","Hash","Comment","Certificates")
+        table.with { 
+            setCellSelection(false)
+            setTableModel(model.model)
+            setVisibleRows(terminalSize.getRows())
+            setSelectAction({rowSelected()})
+        }
+        contentPanel.addComponent(table, layoutData)
+        
+        Panel buttonsPanel = new Panel()
+        buttonsPanel.setLayoutManager(new GridLayout(2))
+        Button sortButton = new Button("Sort...", {sort()})
+        Button closeButton = new Button("Close",{
+            model.unregister()
+            close()
+        })
+        buttonsPanel.addComponent(sortButton, layoutData)
+        buttonsPanel.addComponent(closeButton, layoutData)
+        
+        contentPanel.addComponent(buttonsPanel, layoutData)
+        setComponent(contentPanel)
+        
+    }
+    
+    private void rowSelected() {
+        int selectedRow = table.getSelectedRow()
+        def row = model.model.getRow(selectedRow)
+        String infoHash = row[2]
+        boolean comment = Boolean.parseBoolean(row[3]) 
+        boolean certificates = row[4] > 0
+        if (comment || certificates) {
+            Window prompt = new BasicWindow("Download Or View Comment")
+            prompt.setHints([Window.Hint.CENTERED])
+            Panel contentPanel = new Panel()
+            contentPanel.setLayoutManager(new GridLayout(4))
+            Button downloadButton = new Button("Download", {download(infoHash)})
+            Button viewButton = new Button("View Comment", {viewComment(infoHash)})
+            Button viewCertificate = new Button("View Certificates",{viewCertificates(infoHash)})
+            Button closeButton = new Button("Cancel", {prompt.close()})
+            
+            contentPanel.with { 
+                addComponent(downloadButton, layoutData)
+                if (comment)
+                    addComponent(viewButton, layoutData)
+                if (certificates)
+                    addComponent(viewCertificate, layoutData)
+                addComponent(closeButton, layoutData)
+            }
+            
+            prompt.setComponent(contentPanel)
+            downloadButton.takeFocus()
+            textGUI.addWindowAndWait(prompt)
+        } else {
+            download(infoHash)
+        }
+    }
+    
+    private void download(String infoHash) {
+        UIResultEvent result = model.rootToResult[infoHash]
+        def file = new File(core.muOptions.downloadLocation, result.name)
+        core.eventBus.publish(new UIDownloadEvent(result : [result], sources : result.sources,
+            target : file, sequential : false))
+        MessageDialog.showMessageDialog(textGUI, "Download started", "Started download of "+result.name, MessageDialogButton.OK)
+    }
+    
+    private void viewComment(String infoHash) {
+        UIResultEvent result = model.rootToResult[infoHash]
+        ViewCommentView view = new ViewCommentView(result.comment, result.name, terminalSize)
+        textGUI.addWindowAndWait(view)
+    }
+    
+    private void viewCertificates(String infoHash) {
+        UIResultEvent result = model.rootToResult[infoHash]
+        ViewCertificatesModel model = new ViewCertificatesModel(result, core, textGUI.getGUIThread())
+        ViewCertificatesView view = new ViewCertificatesView(model, textGUI, core, terminalSize)
+        textGUI.addWindowAndWait(view)
+    }
+    
+    private void sort() {
+        SortPrompt prompt = new SortPrompt(textGUI)
+        SortType type = prompt.prompt()
+        if (type != null)
+            model.sort(type)
+    }
+}

cli-lanterna/src/main/groovy/com/muwire/clilanterna/CertificateWrapper.groovy

@@ -0,0 +1,14 @@
+package com.muwire.clilanterna
+
+import com.muwire.core.filecert.Certificate
+
+class CertificateWrapper {
+    private final Certificate certificate
+    CertificateWrapper(Certificate certificate) {
+        this.certificate = certificate
+    }
+    
+    public String toString() {
+        certificate.issuer.getHumanReadableName()
+    }
+}

cli-lanterna/src/main/groovy/com/muwire/clilanterna/ChatConsoleModel.groovy

@@ -0,0 +1,88 @@
+package com.muwire.clilanterna
+
+import com.googlecode.lanterna.gui2.TextBox
+import com.googlecode.lanterna.gui2.TextGUIThread
+import com.muwire.core.Core
+import com.muwire.core.Persona
+import com.muwire.core.chat.ChatConnectionEvent
+import com.muwire.core.chat.ChatLink
+import com.muwire.core.chat.ChatMessageEvent
+import com.muwire.core.chat.UIConnectChatEvent
+
+import net.i2p.data.DataHelper
+
+class ChatConsoleModel {
+    private final Core core
+    private final TextGUIThread guiThread
+    
+    volatile ChatLink link
+    volatile Thread poller
+    volatile boolean running
+    
+    volatile TextBox textBox
+    
+    
+    ChatConsoleModel(Core core, TextGUIThread guiThread) {
+        this.core = core
+        this.guiThread = guiThread
+    }
+    
+    void start() {
+        if (running)
+            return
+        running = true
+        core.chatServer.start()
+        core.eventBus.with { 
+            register(ChatConnectionEvent.class, this)
+            publish(new UIConnectChatEvent(host : core.me))
+        }
+    }
+    
+    void onChatConnectionEvent(ChatConnectionEvent e) {
+        if (e.persona != core.me)
+            return // can't really happen
+        
+        link = e.connection
+        poller = new Thread({eventLoop()} as Runnable)
+        poller.setDaemon(true)
+        poller.start()
+    }
+    
+    void stop() {
+        if (!running)
+            return
+        running = false
+        core.chatServer.stop()
+        poller?.interrupt()
+        link = null
+    }
+    
+    private void eventLoop() {
+        Thread.sleep(1000)
+        while(running) {
+            ChatLink link = this.link
+            if (link == null || !link.isUp()) {
+                Thread.sleep(100)
+                continue
+            }
+                
+            Object event = link.nextEvent()
+            if (event instanceof ChatMessageEvent)
+                handleChatMessage(event)
+            else if (event instanceof Persona)
+                handleLeave(event)
+            else
+                throw new IllegalArgumentException("unknown event type $event")
+        }
+    }
+    
+    private void handleChatMessage(ChatMessageEvent e) {
+        String text = DataHelper.formatTime(e.timestamp)+" <"+e.sender.getHumanReadableName()+ "> ["+
+            e.room+"] "+e.payload
+        guiThread.invokeLater({textBox.addLine(text)})
+    }
+    
+    private void handleLeave(Persona p) {
+        guiThread.invokeLater({textBox.addLine(p.getHumanReadableName()+ " disconnected")})
+    }
+}

cli-lanterna/src/main/groovy/com/muwire/clilanterna/ChatConsoleView.groovy

@@ -0,0 +1,116 @@
+package com.muwire.clilanterna
+
+import com.googlecode.lanterna.TerminalSize
+import com.googlecode.lanterna.gui2.BasicWindow
+import com.googlecode.lanterna.gui2.Button
+import com.googlecode.lanterna.gui2.GridLayout
+import com.googlecode.lanterna.gui2.GridLayout.Alignment
+import com.googlecode.lanterna.gui2.Label
+import com.googlecode.lanterna.gui2.LayoutData
+import com.googlecode.lanterna.gui2.Panel
+import com.googlecode.lanterna.gui2.TextBox
+import com.googlecode.lanterna.gui2.TextGUI
+import com.googlecode.lanterna.gui2.Window
+import com.muwire.core.Core
+import com.muwire.core.chat.ChatCommand
+import com.muwire.core.chat.ChatConnection
+import com.muwire.core.chat.ChatMessageEvent
+import com.muwire.core.chat.ChatServer
+
+import net.i2p.data.DataHelper
+
+class ChatConsoleView extends BasicWindow {
+    private final TextGUI textGUI
+    private final ChatConsoleModel model
+    private final Core core
+    
+    private final LayoutData layoutData = GridLayout.createLayoutData(Alignment.CENTER, Alignment.CENTER, true, false)
+    private final LayoutData layoutDataFill = GridLayout.createLayoutData(Alignment.FILL, Alignment.FILL, true, false)
+    
+    private final TextBox textBox
+    private final TextBox sayField
+    private final TextBox roomField
+    
+    ChatConsoleView(Core core, ChatConsoleModel model, TextGUI textGUI, TerminalSize terminalSize) {
+        super("Chat Server Console")
+        this.core = core
+        this.model = model
+        this.textGUI = textGUI
+        TextBox textBox = model.textBox == null ? new TextBox(terminalSize,"", TextBox.Style.MULTI_LINE) : model.textBox 
+        this.textBox = textBox
+        model.textBox = textBox
+        model.start()
+        TerminalSize textFieldSize = new TerminalSize((terminalSize.getColumns() / 2).toInteger(), 1)
+        this.sayField = new TextBox(textFieldSize,"", TextBox.Style.SINGLE_LINE)
+        this.roomField = new TextBox(textFieldSize,"__CONSOLE__", TextBox.Style.SINGLE_LINE)
+        
+        
+        setHints([Window.Hint.EXPANDED])
+        
+        Panel contentPanel = new Panel()
+        contentPanel.setLayoutManager(new GridLayout(1))
+        contentPanel.addComponent(textBox, layoutData)
+        
+        Panel inputPanel = new Panel()
+        inputPanel.with { 
+            setLayoutManager(new GridLayout(2))
+            addComponent(new Label("Say something here"), layoutData)
+            addComponent(sayField, layoutDataFill)
+            addComponent(new Label("In room:"), layoutData)
+            addComponent(roomField, layoutDataFill)
+        }
+        contentPanel.addComponent(inputPanel, layoutData)
+        
+        Panel bottomPanel = new Panel()
+        bottomPanel.setLayoutManager(new GridLayout(5))
+        
+        Button sayButton = new Button("Say",{say()})
+        Button startButton = new Button("Start Server",{model.start()})
+        Button stopButton = new Button("Stop Server", {model.stop()})
+        Button clearButton = new Button("Clear",{textBox.setText("")})
+        Button closeButton = new Button("Close",{close()})    
+        
+        bottomPanel.with { 
+            addComponent(sayButton, layoutData)
+            addComponent(startButton, layoutData)
+            addComponent(stopButton, layoutData)
+            addComponent(clearButton, layoutData)
+            addComponent(closeButton, layoutData)
+        }    
+        contentPanel.addComponent(bottomPanel, layoutData)
+        setComponent(contentPanel)
+    }
+    
+    private void say() {
+        String command = sayField.getText()
+        sayField.setText("")
+        
+        ChatCommand chatCommand
+        try {
+            chatCommand = new ChatCommand(command)
+        } catch (Exception e) {
+            chatCommand = new ChatCommand("/SAY $command")
+        }
+        command = chatCommand.source
+        
+        String room = roomField.getText()
+        
+        UUID uuid = UUID.randomUUID()
+        long now = System.currentTimeMillis()
+        
+        String toAppend = DataHelper.formatTime(now) + " <" + core.me.getHumanReadableName() + "> [$room] " + command
+        textBox.addLine(toAppend)
+        
+        byte[] sig = ChatConnection.sign(uuid, now, room, command, core.me, core.me, core.spk)
+        
+        def event = new ChatMessageEvent( uuid : uuid,
+            payload : command,
+            sender : core.me,
+            host : core.me,
+            room : room,
+            chatTime : now,
+            sig : sig
+            )
+        core.eventBus.publish(event)
+    }
+}

cli-lanterna/src/main/groovy/com/muwire/clilanterna/CliLanterna.groovy

@@ -0,0 +1,193 @@
+package com.muwire.clilanterna
+
+import java.nio.charset.StandardCharsets
+import java.util.concurrent.CountDownLatch
+import java.util.logging.Level
+import java.util.logging.LogManager
+
+import com.googlecode.lanterna.gui2.BasicWindow
+import com.googlecode.lanterna.gui2.Border
+import com.googlecode.lanterna.gui2.BorderLayout
+import com.googlecode.lanterna.gui2.Borders
+import com.googlecode.lanterna.gui2.Button
+import com.googlecode.lanterna.gui2.GridLayout
+import com.googlecode.lanterna.gui2.Label
+import com.googlecode.lanterna.gui2.MultiWindowTextGUI
+import com.googlecode.lanterna.gui2.Panel
+import com.googlecode.lanterna.gui2.SeparateTextGUIThread
+import com.googlecode.lanterna.gui2.Window
+import com.googlecode.lanterna.gui2.WindowBasedTextGUI
+import com.googlecode.lanterna.gui2.GridLayout.Alignment
+import com.googlecode.lanterna.gui2.dialogs.MessageDialog
+import com.googlecode.lanterna.gui2.dialogs.MessageDialogButton
+import com.googlecode.lanterna.gui2.dialogs.TextInputDialog
+import com.googlecode.lanterna.gui2.dialogs.TextInputDialogBuilder
+import com.googlecode.lanterna.gui2.dialogs.WaitingDialog
+import com.googlecode.lanterna.screen.Screen
+import com.googlecode.lanterna.terminal.DefaultTerminalFactory
+import com.googlecode.lanterna.terminal.Terminal
+import com.muwire.core.Core
+import com.muwire.core.MuWireSettings
+import com.muwire.core.UILoadedEvent
+import com.muwire.core.files.AllFilesLoadedEvent
+
+class CliLanterna {
+    private static final String MW_VERSION = "0.7.4"
+    
+    private static volatile Core core
+    
+    private static WindowBasedTextGUI textGUI
+    
+    public static void main(String[] args) {
+        if (System.getProperty("java.util.logging.config.file") == null) {
+            def names = LogManager.getLogManager().getLoggerNames()
+            while(names.hasMoreElements()) {
+                def name = names.nextElement()
+                LogManager.getLogManager().getLogger(name).setLevel(Level.SEVERE)
+            }
+        }
+        
+        def home = System.getProperty("user.home") + File.separator + ".MuWire"
+        home = new File(home)
+        if (!home.exists())
+            home.mkdirs()
+
+        def propsFile = new File(home,"MuWire.properties")
+        
+        
+        DefaultTerminalFactory terminalFactory = new DefaultTerminalFactory()
+        Screen screen = terminalFactory.createScreen()
+        textGUI = new MultiWindowTextGUI( new SeparateTextGUIThread.Factory(), screen)
+        textGUI.getGUIThread().start()
+        screen.startScreen()
+
+        def props
+        if (!propsFile.exists()) {
+            String nickname = TextInputDialog.showDialog(textGUI, "Select a nickname", "", "")
+            String defaultDownloadLocation = System.getProperty("user.home")+File.separator+"Downloads"
+            String downloadLocation = TextInputDialog.showDialog(textGUI, "Select download location", "", defaultDownloadLocation)
+            String defaultIncompletesLocation = System.getProperty("user.home")+File.separator+".MuWire"+File.separator+"incompletes"
+            String incompletesLocation = TextInputDialog.showDialog(textGUI, "Select incompletes location", "", defaultIncompletesLocation)
+            
+            
+            File downloadLocationFile = new File(downloadLocation)
+            if (!downloadLocationFile.exists())
+                downloadLocationFile.mkdirs()
+            File incompletesLocationFile = new File(incompletesLocation)
+            if (!incompletesLocationFile.exists())
+                incompletesLocationFile.mkdirs()
+            
+            props = new MuWireSettings()
+            props.setNickname(nickname)
+            props.setDownloadLocation(downloadLocationFile)
+            props.incompleteLocation = incompletesLocationFile
+            
+            propsFile.withPrintWriter("UTF-8", { 
+                props.write(it)
+            })
+        } else {
+            props = new Properties()
+            propsFile.withReader("UTF-8", { 
+                props.load(it)
+            })
+            props = new MuWireSettings(props)
+        }
+        props.updateType = "cli-lanterna"
+                
+        def i2pPropsFile = new File(home, "i2p.properties")
+        if (!i2pPropsFile.exists()) {
+            String i2pHost = TextInputDialog.showDialog(textGUI, "I2P router host", "Specifiy the host I2P router is on", "127.0.0.1")
+            int i2pPort = TextInputDialog.showNumberDialog(textGUI, "I2CP port", "Specify the I2CP port", "7654").toInteger()
+            
+            Properties i2pProps = new Properties()
+            i2pProps["i2cp.tcp.host"] = i2pHost
+            i2pProps["i2cp.tcp.port"] = String.valueOf(i2pPort)
+            i2pPropsFile.withOutputStream { i2pProps.store(it, "") }
+        }
+ 
+        def cliProps 
+        def cliPropsFile = new File(home, "cli.properties")
+        if (cliPropsFile.exists()) {
+            Properties p = new Properties()
+            cliPropsFile.withInputStream { 
+                p.load(it)
+            }
+            cliProps = new CliSettings(p)
+        } else
+            cliProps = new CliSettings(new Properties())
+               
+
+        Window window = new BasicWindow("MuWire "+ MW_VERSION)
+        window.setHints([Window.Hint.CENTERED])
+        Panel contentPanel = new Panel()
+        contentPanel.withBorder(Borders.doubleLine())
+        BorderLayout layout = new BorderLayout()
+        contentPanel.setLayoutManager(layout)
+        
+        Panel welcomeNamePanel = new Panel()
+        contentPanel.addComponent(welcomeNamePanel, BorderLayout.Location.CENTER)
+        welcomeNamePanel.setLayoutManager(new GridLayout(1))
+        Label welcomeLabel = new Label("Welcome to MuWire "+ props.nickname)
+        welcomeNamePanel.addComponent(welcomeLabel, GridLayout.createLayoutData(Alignment.CENTER, Alignment.CENTER))
+        
+
+        Panel connectButtonPanel = new Panel()
+        contentPanel.addComponent(connectButtonPanel, BorderLayout.Location.BOTTOM)
+        connectButtonPanel.setLayoutManager(new GridLayout(1))
+        Button connectButton = new Button("Connect", {
+            
+            WaitingDialog waiting = new WaitingDialog("Connecting", "Please wait")
+            waiting.showDialog(textGUI, false)
+            
+            CountDownLatch latch = new CountDownLatch(1)
+            Thread connector = new Thread({
+                try {
+                    core = new Core(props, home, MW_VERSION)
+                } finally {
+                    latch.countDown()
+                }
+            })
+            connector.start()
+            while(latch.getCount() > 0) {
+                textGUI.updateScreen()
+                Thread.sleep(10)
+            }
+            waiting.close()
+            window.close()
+        } as Runnable)
+        welcomeNamePanel.addComponent(connectButton, GridLayout.createLayoutData(Alignment.CENTER, Alignment.CENTER))
+        
+        
+        window.setComponent(contentPanel)
+        textGUI.addWindowAndWait(window)
+
+        if (core == null) {
+            MessageDialog.showMessageDialog(textGUI, "Failed", "MuWire failed to load", MessageDialogButton.Close)
+            System.exit(1)
+        }        
+        
+        window = new MainWindowView("MuWire "+MW_VERSION, core, textGUI, screen, cliProps)
+        core.startServices()
+        
+        core.eventBus.publish(new UILoadedEvent())
+        textGUI.addWindowAndWait(window)
+        
+        CountDownLatch latch = new CountDownLatch(1)
+        Thread stopper = new Thread({
+            core.shutdown()
+            latch.countDown()
+        } as Runnable)
+        WaitingDialog waitingForShutdown = new WaitingDialog("MuWire is shutting down","Please wait")
+        waitingForShutdown.setHints([Window.Hint.CENTERED])
+        waitingForShutdown.showDialog(textGUI, false)
+        stopper.start()
+        while(latch.getCount() > 0) {
+            textGUI.updateScreen()
+            Thread.sleep(10)
+        }
+        waitingForShutdown.close()
+        
+        screen.stopScreen()
+        System.exit(0)
+    }
+}

cli-lanterna/src/main/groovy/com/muwire/clilanterna/CliSettings.groovy

@@ -0,0 +1,25 @@
+package com.muwire.clilanterna
+
+class CliSettings {
+    
+    boolean clearCancelledDownloads
+    boolean clearFinishedDownloads
+    boolean clearUploads
+    
+    CliSettings(Properties props) {
+        clearCancelledDownloads = Boolean.parseBoolean(props.getProperty("clearCancelledDownloads","true"))
+        clearFinishedDownloads = Boolean.parseBoolean(props.getProperty("clearFinishedDownloads", "false"))
+        clearUploads = Boolean.parseBoolean(props.getProperty("clearUploads", "false"))
+    }
+    
+    void write(OutputStream os) {
+        Properties props = new Properties()
+        props.with { 
+            setProperty("clearCancelledDownloads", String.valueOf(clearCancelledDownloads))
+            setProperty("clearFinishedDownloads", String.valueOf(clearFinishedDownloads))
+            setProperty("clearUploads", String.valueOf(clearUploads))
+            
+            store(os, "CLI Properties")
+        }
+    }
+}

cli-lanterna/src/main/groovy/com/muwire/clilanterna/DownloadDetailsView.groovy

@@ -0,0 +1,67 @@
+package com.muwire.clilanterna
+
+import com.googlecode.lanterna.gui2.BasicWindow
+import com.googlecode.lanterna.gui2.Button
+import com.googlecode.lanterna.gui2.GridLayout
+import com.googlecode.lanterna.gui2.GridLayout.Alignment
+import com.googlecode.lanterna.gui2.Label
+import com.googlecode.lanterna.gui2.LayoutData
+import com.googlecode.lanterna.gui2.Panel
+import com.googlecode.lanterna.gui2.TextGUIThread
+import com.googlecode.lanterna.gui2.Window
+import com.muwire.core.download.Downloader
+
+
+class DownloadDetailsView extends BasicWindow {
+    private final Downloader downloader
+    private final LayoutData layoutData = GridLayout.createLayoutData(Alignment.CENTER, Alignment.CENTER)
+    
+    private Label knownSources, activeSources, donePieces
+    DownloadDetailsView(Downloader downloader) {
+        super("Download details for "+downloader.file.getName())
+        this.downloader = downloader
+        
+        setHints([Window.Hint.CENTERED])
+        
+        Panel contentPanel = new Panel()
+        contentPanel.setLayoutManager(new GridLayout(2))
+        
+        knownSources = new Label("0")
+        activeSources = new Label("0")
+        donePieces = new Label("0")
+        refresh()
+        
+        Button refreshButton = new Button("Refresh",{refresh()})
+        Button closeButton = new Button("Close", {close()})
+        
+        contentPanel.with { 
+            addComponent(new Label("Target Location"), layoutData)
+            addComponent(new Label(downloader.file.getAbsolutePath()), layoutData)
+            addComponent(new Label("Piece Size"), layoutData)
+            addComponent(new Label(String.valueOf(downloader.pieceSize)), layoutData)
+            addComponent(new Label("Total Pieces"), layoutData)
+            addComponent(new Label(String.valueOf(downloader.nPieces)), layoutData)
+            addComponent(new Label("Done Pieces"), layoutData)
+            addComponent(donePieces, layoutData)
+            addComponent(new Label("Known Sources"), layoutData)
+            addComponent(knownSources, layoutData)
+            addComponent(new Label("Active Sources"), layoutData)
+            addComponent(activeSources, layoutData)
+            addComponent(refreshButton, layoutData)
+            addComponent(closeButton, layoutData)
+        }
+        
+        setComponent(contentPanel)
+        
+    }
+    
+    private void refresh() {
+        int done = downloader.donePieces()
+        int known = downloader.activeWorkers.size()
+        int active = downloader.activeWorkers()
+        
+        knownSources.setText(String.valueOf(known))
+        activeSources.setText(String.valueOf(active))
+        donePieces.setText(String.valueOf(done))
+    }
+}

cli-lanterna/src/main/groovy/com/muwire/clilanterna/DownloaderWrapper.groovy

@@ -0,0 +1,15 @@
+package com.muwire.clilanterna
+
+import com.muwire.core.download.Downloader
+
+class DownloaderWrapper {
+    final Downloader downloader
+    DownloaderWrapper(Downloader downloader) {
+        this.downloader = downloader
+    }
+    
+    @Override
+    public String toString() {
+        downloader.file.getName()
+    }
+}

cli-lanterna/src/main/groovy/com/muwire/clilanterna/DownloadsModel.groovy

@@ -0,0 +1,100 @@
+package com.muwire.clilanterna
+
+import com.googlecode.lanterna.gui2.TextGUIThread
+import com.googlecode.lanterna.gui2.table.TableModel
+
+import com.muwire.core.Core
+import com.muwire.core.download.DownloadStartedEvent
+import com.muwire.core.download.Downloader
+import com.muwire.core.files.FileDownloadedEvent
+
+import net.i2p.data.DataHelper
+
+class DownloadsModel {
+    private final TextGUIThread guiThread
+    private final Core core
+    private final CliSettings props
+    private final List<Downloader> downloaders = new ArrayList<>()
+    private final TableModel model = new TableModel("Name", "Status", "Progress", "Speed", "ETA")
+    
+    
+    private long lastRetryTime
+    
+    DownloadsModel(TextGUIThread guiThread, Core core, CliSettings props) {
+        this.guiThread = guiThread
+        this.core = core
+        this.props = props
+        
+        core.eventBus.register(DownloadStartedEvent.class, this)
+        Timer timer = new Timer(true)
+        Runnable guiRunnable = {
+            refreshModel()
+            resumeDownloads()
+        }
+        timer.schedule({
+            if (core.shutdown.get())
+                return
+            guiThread.invokeLater(guiRunnable)
+        } as TimerTask, 1000,1000)
+    }
+    
+    void onDownloadStartedEvent(DownloadStartedEvent e) {
+        guiThread.invokeLater({
+            downloaders.add(e.downloader)
+            refreshModel()
+        })
+    }
+    
+    private void refreshModel() {
+        int rowCount = model.getRowCount()
+        rowCount.times { model.removeRow(0) }
+        
+        if (props.clearCancelledDownloads) {
+            downloaders.removeAll { it.cancelled }
+        }
+        if (props.clearFinishedDownloads) {
+            downloaders.removeAll { it.getCurrentState() == Downloader.DownloadState.FINISHED }
+        }
+        
+        downloaders.each { 
+            String status = it.getCurrentState().toString()
+            int speedInt = it.speed()
+            String speed = DataHelper.formatSize2Decimal(speedInt, false) + "B/sec"
+            
+            int pieces = it.nPieces
+            int done = it.donePieces()
+            int percent = -1
+            if (pieces != 0)
+                percent = (done * 100 / pieces)
+            String totalSize = DataHelper.formatSize2Decimal(it.length, false) + "B"
+            String progress = (String.format("%2d", percent) + "% of ${totalSize}".toString())
+            
+            String ETA
+            if (speedInt == 0)
+                ETA = "Unknown"
+            else {
+                long remaining = (pieces - done) * it.pieceSize / speedInt
+                ETA = DataHelper.formatDuration(remaining * 1000)
+            }
+
+            model.addRow([new DownloaderWrapper(it), status, progress, speed, ETA])
+        }
+        
+    }
+    
+    private void resumeDownloads() {
+        int retryInterval = core.muOptions.downloadRetryInterval
+        if (retryInterval == 0)
+            return
+        retryInterval *= 1000
+        long now = System.currentTimeMillis()
+        if (now - lastRetryTime > retryInterval) {
+            lastRetryTime = now
+            downloaders.each { 
+                def state = it.getCurrentState()
+                if (state == Downloader.DownloadState.FAILED || state == Downloader.DownloadState.DOWNLOADING)
+                    it.resume()
+            }
+        }
+    }
+}

cli-lanterna/src/main/groovy/com/muwire/clilanterna/DownloadsView.groovy

@@ -0,0 +1,94 @@
+package com.muwire.clilanterna
+
+import com.googlecode.lanterna.TerminalSize
+import com.googlecode.lanterna.gui2.BasicWindow
+import com.googlecode.lanterna.gui2.Button
+import com.googlecode.lanterna.gui2.GridLayout
+import com.googlecode.lanterna.gui2.GridLayout.Alignment
+import com.googlecode.lanterna.gui2.LayoutData
+import com.googlecode.lanterna.gui2.Panel
+import com.googlecode.lanterna.gui2.TextGUI
+import com.googlecode.lanterna.gui2.Window
+import com.googlecode.lanterna.gui2.dialogs.MessageDialog
+import com.googlecode.lanterna.gui2.dialogs.MessageDialogButton
+import com.googlecode.lanterna.gui2.table.Table
+import com.muwire.core.Core
+import com.muwire.core.download.Downloader
+import com.muwire.core.download.UIDownloadCancelledEvent
+
+class DownloadsView extends BasicWindow {
+    private final Core core
+    private final DownloadsModel model
+    private final TextGUI textGUI
+    private final Table table
+    
+    DownloadsView(Core core, DownloadsModel model, TextGUI textGUI, TerminalSize terminalSize) {
+        this.core = core
+        this.model = model
+        this.textGUI = textGUI
+        
+        setHints([Window.Hint.EXPANDED])
+        LayoutData layoutData = GridLayout.createLayoutData(Alignment.CENTER, Alignment.CENTER, true, false)
+        
+        Panel contentPanel = new Panel()
+        contentPanel.setLayoutManager(new GridLayout(1))
+        table = new Table("Name","Status","Progress","Speed","ETA")
+        table.setCellSelection(false)
+        table.setSelectAction({rowSelected()})
+        table.setTableModel(model.model)
+        table.setVisibleRows(terminalSize.getRows())
+        contentPanel.addComponent(table, layoutData)
+
+        Panel buttonsPanel = new Panel()
+        buttonsPanel.setLayoutManager(new GridLayout(2))
+        
+        Button clearButton = new Button("Clear Done",{clearDone()})
+        buttonsPanel.addComponent(clearButton, layoutData)
+                
+        Button closeButton = new Button("Close",{close()})
+        buttonsPanel.addComponent(closeButton, layoutData)
+        
+        contentPanel.addComponent(buttonsPanel, layoutData)
+        
+        setComponent(contentPanel)
+        closeButton.takeFocus()
+    }
+    
+    private void rowSelected() {
+        int selectedRow = table.getSelectedRow()
+        def row = model.model.getRow(selectedRow)
+        Downloader downloader = row[0].downloader
+        
+        Window prompt = new BasicWindow("Kill Download?")
+        prompt.setHints([Window.Hint.CENTERED])
+        Panel contentPanel = new Panel()
+        contentPanel.setLayoutManager(new GridLayout(3))
+        LayoutData layoutData = GridLayout.createLayoutData(Alignment.CENTER, Alignment.CENTER)
+        
+        Button killDownload = new Button("Kill Download", {
+            downloader.cancel()
+            core.eventBus.publish(new UIDownloadCancelledEvent(downloader : downloader))
+            MessageDialog.showMessageDialog(textGUI, "Download Killed", downloader.file.getName()+ " has been killed", MessageDialogButton.OK)
+        })
+        Button viewDetails = new Button("View Details", {
+            textGUI.addWindowAndWait(new DownloadDetailsView(downloader))
+        })
+        Button close = new Button("Close", {
+            prompt.close()  
+        })
+        
+        contentPanel.addComponent(killDownload,layoutData)
+        contentPanel.addComponent(viewDetails, layoutData)
+        contentPanel.addComponent(close, layoutData)
+        prompt.setComponent(contentPanel)
+        close.takeFocus()
+        textGUI.addWindowAndWait(prompt)
+    }
+    
+    private void clearDone() {
+        model.downloaders.removeAll {
+            def state = it.getCurrentState() 
+            state == Downloader.DownloadState.CANCELLED || state == Downloader.DownloadState.FINISHED
+        }
+    }
+}

cli-lanterna/src/main/groovy/com/muwire/clilanterna/FilesModel.groovy

@@ -0,0 +1,100 @@
+package com.muwire.clilanterna
+
+import com.googlecode.lanterna.gui2.TextGUIThread
+import com.googlecode.lanterna.gui2.table.TableModel
+import com.muwire.core.Core
+import com.muwire.core.InfoHash
+import com.muwire.core.SharedFile
+import com.muwire.core.files.AllFilesLoadedEvent
+import com.muwire.core.files.DirectoryWatchedEvent
+import com.muwire.core.files.FileHashedEvent
+import com.muwire.core.files.FileLoadedEvent
+import com.muwire.core.files.FileSharedEvent
+import com.muwire.core.files.FileUnsharedEvent
+import com.muwire.core.trust.TrustSubscriptionEvent
+
+import net.i2p.data.DataHelper
+
+class FilesModel {
+    private final TextGUIThread guiThread
+    private final Core core
+    private final List<SharedFile> sharedFiles = new ArrayList<>()
+    private final TableModel model = new TableModel("Name","Size","Comment","Certified","Search Hits","Downloaders")
+    
+    FilesModel(TextGUIThread guiThread, Core core) {
+        this.guiThread = guiThread
+        this.core = core
+        
+        core.eventBus.register(FileLoadedEvent.class, this)
+        core.eventBus.register(FileUnsharedEvent.class, this)
+        core.eventBus.register(FileHashedEvent.class, this)
+        
+        Runnable refreshModel = {refreshModel()}
+        Timer timer = new Timer(true)
+        timer.schedule({
+            guiThread.invokeLater(refreshModel)
+        } as TimerTask, 1000,1000)
+        
+    }
+    
+    void onFileLoadedEvent(FileLoadedEvent e) {
+        guiThread.invokeLater {
+            sharedFiles.add(e.loadedFile)
+        }
+    }
+    
+    void onFileHashedEvent(FileHashedEvent e) {
+        guiThread.invokeLater {
+            if (e.sharedFile != null)
+                sharedFiles.add(e.sharedFile)
+        }
+    }
+    
+    void onFileUnsharedEvent(FileUnsharedEvent e) {
+        guiThread.invokeLater {
+            sharedFiles.remove(e.unsharedFile)
+        }
+    }
+    
+    private void refreshModel() {
+        int rowCount = model.getRowCount()
+        rowCount.times { model.removeRow(0) }
+        
+        sharedFiles.each { 
+            long size = it.getCachedLength()
+            boolean comment = it.comment != null
+            boolean certified = core.certificateManager.hasLocalCertificate(new InfoHash(it.getRoot()))
+            String hits = String.valueOf(it.getHits())
+            String downloaders = String.valueOf(it.getDownloaders().size())
+            model.addRow(new SharedFileWrapper(it), DataHelper.formatSize2(size, false)+"B", comment, certified, hits, downloaders)
+        }
+    }
+    
+    private void sort(SortType type) {
+        Comparator<SharedFile> chosen
+        switch(type) {
+            case SortType.NAME_ASC : chosen = NAME_ASC; break
+            case SortType.NAME_DESC : chosen = NAME_DESC; break
+            case SortType.SIZE_ASC : chosen = SIZE_ASC; break
+            case SortType.SIZE_DESC : chosen = SIZE_DESC; break
+        }
+        
+        Collections.sort(sharedFiles, chosen)
+    }
+    
+    private static final Comparator<SharedFile> NAME_ASC = new Comparator<SharedFile>() {
+        public int compare(SharedFile a, SharedFile b) {
+            a.getFile().getName().compareTo(b.getFile().getName())
+        }
+    }
+    
+    private static final Comparator<SharedFile> NAME_DESC = NAME_ASC.reversed()
+    
+    private static final Comparator<SharedFile> SIZE_ASC = new Comparator<SharedFile>() {
+        public int compare(SharedFile a, SharedFile b) {
+            Long.compare(a.getCachedLength(), b.getCachedLength())
+        }
+    }
+    
+    private static final Comparator<SharedFile> SIZE_DESC = SIZE_ASC.reversed()
+}

cli-lanterna/src/main/groovy/com/muwire/clilanterna/FilesView.groovy

@@ -0,0 +1,144 @@
+package com.muwire.clilanterna
+
+
+import com.googlecode.lanterna.TerminalSize
+import com.googlecode.lanterna.gui2.BasicWindow
+import com.googlecode.lanterna.gui2.Button
+import com.googlecode.lanterna.gui2.GridLayout
+import com.googlecode.lanterna.gui2.GridLayout.Alignment
+import com.googlecode.lanterna.gui2.LayoutData
+import com.googlecode.lanterna.gui2.Panel
+import com.googlecode.lanterna.gui2.TextGUI
+import com.googlecode.lanterna.gui2.Window
+import com.googlecode.lanterna.gui2.dialogs.FileDialog
+import com.googlecode.lanterna.gui2.dialogs.MessageDialog
+import com.googlecode.lanterna.gui2.dialogs.MessageDialogButton
+import com.googlecode.lanterna.gui2.dialogs.TextInputDialog
+import com.googlecode.lanterna.gui2.table.Table
+import com.muwire.core.Core
+import com.muwire.core.SharedFile
+import com.muwire.core.filecert.UICreateCertificateEvent
+import com.muwire.core.files.DirectoryUnsharedEvent
+import com.muwire.core.files.FileSharedEvent
+import com.muwire.core.files.FileUnsharedEvent
+
+class FilesView extends BasicWindow {
+    private final FilesModel model
+    private final TextGUI textGUI
+    private final Core core
+    private final Table table
+    private final TerminalSize terminalSize
+    
+    FilesView(FilesModel model, TextGUI textGUI, Core core, TerminalSize terminalSize) {
+        super("Shared Files")
+        this.model = model
+        this.core = core
+        this.textGUI = textGUI
+        this.terminalSize = terminalSize
+        
+        setHints([Window.Hint.EXPANDED])
+        
+        Panel contentPanel = new Panel()
+        contentPanel.setLayoutManager(new GridLayout(1))
+        LayoutData layoutData = GridLayout.createLayoutData(Alignment.CENTER, Alignment.CENTER, true, false)
+        
+        table = new Table("Name","Size","Comment","Certified","Search Hits","Downloaders")
+        table.setCellSelection(false)
+        table.setTableModel(model.model)
+        table.setSelectAction({rowSelected()})
+        table.setVisibleRows(terminalSize.getRows())
+        contentPanel.addComponent(table, layoutData)
+        
+        Panel buttonsPanel = new Panel()
+        buttonsPanel.setLayoutManager(new GridLayout(5))
+        
+        Button shareFile = new Button("Share File", {shareFile()})
+        Button shareDirectory = new Button("Share Directory", {shareDirectory()})
+        Button unshareDirectory = new Button("Unshare Directory",{unshareDirectory()})
+        Button sort = new Button("Sort...",{sort()})
+        Button close = new Button("Close", {close()})
+        
+        buttonsPanel.with { 
+            addComponent(shareFile, layoutData)
+            addComponent(shareDirectory, layoutData)
+            addComponent(unshareDirectory, layoutData)
+            addComponent(sort, layoutData)
+            addComponent(close, layoutData)
+        }
+        
+        contentPanel.addComponent(buttonsPanel, layoutData)
+        setComponent(contentPanel)
+        close.takeFocus()
+    }
+    
+    private void rowSelected() {
+        int selectedRow = table.getSelectedRow()
+        def row = model.model.getRow(selectedRow)
+        SharedFile sf = row[0].sharedFile
+        
+        Window prompt = new BasicWindow("Unshare or add comment to "+sf.getFile().getName()+" ?")
+        prompt.setHints([Window.Hint.CENTERED])
+        Panel contentPanel = new Panel()
+        contentPanel.setLayoutManager(new GridLayout(4))
+        
+        Button unshareButton = new Button("Unshare", {
+            core.eventBus.publish(new FileUnsharedEvent(unsharedFile : sf))
+            MessageDialog.showMessageDialog(textGUI, "File Unshared", "Unshared "+sf.getFile().getName(), MessageDialogButton.OK)
+        } )
+        Button addCommentButton = new Button("Add Comment", {
+            AddCommentView view = new AddCommentView(textGUI, core, sf, terminalSize)
+            textGUI.addWindowAndWait(view)
+        })
+        Button certifyButton = new Button("Certify", {
+            core.eventBus.publish(new UICreateCertificateEvent(sharedFile : sf))
+            MessageDialog.showMessageDialog(textGUI, "Certificate Created", "Certificate has been issued", MessageDialogButton.OK)  
+        })
+        Button closeButton = new Button("Close", {prompt.close()})
+        
+        LayoutData layoutData = GridLayout.createLayoutData(Alignment.CENTER, Alignment.CENTER)
+        contentPanel.addComponent(unshareButton, layoutData)
+        contentPanel.addComponent(addCommentButton, layoutData)
+        contentPanel.addComponent(certifyButton, layoutData)
+        contentPanel.addComponent(closeButton, layoutData)
+        
+        prompt.setComponent(contentPanel)
+        textGUI.addWindowAndWait(prompt)
+    }
+    
+    
+    private void shareFile() {
+        TerminalSize terminalSize = new TerminalSize(terminalSize.getColumns() - 10, terminalSize.getRows() - 10)
+        FileDialog fileDialog = new FileDialog("Share File", "Select a file to share", "Share", terminalSize, false, null)
+        File f = fileDialog.showDialog(textGUI)
+        f = f.getCanonicalFile()
+        core.eventBus.publish(new FileSharedEvent(file : f))
+        MessageDialog.showMessageDialog(textGUI, "File Shared", f.getName()+" has been shared", MessageDialogButton.OK)
+    }
+    
+    private void shareDirectory() {
+        String directoryName = TextInputDialog.showDialog(textGUI, "Share a directory", "Enter the directory to share", "")
+        if (directoryName == null)
+            return
+        File directory = new File(directoryName)
+        directory = directory.getCanonicalFile()
+        core.eventBus.publish(new FileSharedEvent(file : directory))
+        MessageDialog.showMessageDialog(textGUI, "Directory Shared", directory.getName()+" has been shared", MessageDialogButton.OK)
+    }
+    
+    private void unshareDirectory() {
+        String directoryName = TextInputDialog.showDialog(textGUI, "Unshare a directory", "Enter the directory to unshare", "")
+        if (directoryName == null)
+            return
+        File directory = new File(directoryName)
+        directory = directory.getCanonicalFile()
+        core.eventBus.publish(new DirectoryUnsharedEvent(directory : directory))
+        MessageDialog.showMessageDialog(textGUI, "Directory Unshared", directory.getName()+" has been unshared", MessageDialogButton.OK)
+    }
+    
+    private void sort() {
+        SortPrompt prompt = new SortPrompt(textGUI)
+        SortType type = prompt.prompt()
+        if (type != null)
+            model.sort(type)
+    }
+}

cli-lanterna/src/main/groovy/com/muwire/clilanterna/MainWindowView.groovy

@@ -0,0 +1,321 @@
+package com.muwire.clilanterna
+
+import com.googlecode.lanterna.TerminalPosition
+import com.googlecode.lanterna.TerminalSize
+import com.googlecode.lanterna.gui2.BasicWindow
+import com.googlecode.lanterna.gui2.BorderLayout
+import com.googlecode.lanterna.gui2.Borders
+import com.googlecode.lanterna.gui2.Button
+import com.googlecode.lanterna.gui2.GridLayout
+import com.googlecode.lanterna.gui2.GridLayout.Alignment
+import com.googlecode.lanterna.gui2.dialogs.MessageDialog
+import com.googlecode.lanterna.gui2.dialogs.MessageDialogButton
+import com.googlecode.lanterna.gui2.Label
+import com.googlecode.lanterna.gui2.LayoutData
+import com.googlecode.lanterna.gui2.Panel
+import com.googlecode.lanterna.gui2.Panels
+import com.googlecode.lanterna.gui2.TextGUI
+import com.googlecode.lanterna.gui2.Window
+import com.googlecode.lanterna.screen.Screen
+import com.googlecode.lanterna.gui2.TextBox
+import com.muwire.core.Core
+import com.muwire.core.DownloadedFile
+import com.muwire.core.connection.ConnectionEvent
+import com.muwire.core.files.FileDownloadedEvent
+import com.muwire.core.files.FileHashedEvent
+import com.muwire.core.files.FileLoadedEvent
+import com.muwire.core.files.FileUnsharedEvent
+import com.muwire.core.hostcache.HostDiscoveredEvent
+import com.muwire.core.update.UpdateAvailableEvent
+import com.muwire.core.update.UpdateDownloadedEvent
+
+import net.i2p.data.Base64
+import net.i2p.data.DataHelper
+
+class MainWindowView extends BasicWindow {
+    
+    private final Core core
+    private final TextGUI textGUI
+    private final Screen screen
+
+    private final TextBox searchTextBox
+    
+    private final DownloadsModel downloadsModel
+    private final UploadsModel uploadsModel
+    private final FilesModel filesModel
+    private final TrustModel trustModel
+    private final ChatConsoleModel chatModel
+    
+    private final Label connectionCount, incoming, outgoing
+    private final Label known, failing, hopeless
+    private final Label sharedFiles
+    private final Label timesBrowsed
+    private final Label updateStatus
+    private final Label usedRam, totalRam, maxRam
+    
+    public MainWindowView(String title, Core core, TextGUI textGUI, Screen screen, CliSettings props) {
+        super(title);
+        
+        this.core = core
+        this.textGUI = textGUI
+        this.screen = screen
+        
+        downloadsModel = new DownloadsModel(textGUI.getGUIThread(),core, props)
+        uploadsModel = new UploadsModel(textGUI.getGUIThread(), core, props)
+        filesModel = new FilesModel(textGUI.getGUIThread(),core)
+        trustModel = new TrustModel(textGUI.getGUIThread(), core)
+        chatModel = new ChatConsoleModel(core, textGUI.getGUIThread())
+        if (core.muOptions.startChatServer)
+            core.chatServer.start()
+        
+        setHints([Window.Hint.EXPANDED])
+        Panel contentPanel = new Panel()
+        setComponent(contentPanel)
+        
+        BorderLayout borderLayout = new BorderLayout()
+        contentPanel.setLayoutManager(borderLayout)
+        
+        Panel buttonsPanel = new Panel()
+        contentPanel.addComponent(buttonsPanel, BorderLayout.Location.TOP)
+        
+        GridLayout gridLayout = new GridLayout(8)
+        buttonsPanel.setLayoutManager(gridLayout)
+        
+        searchTextBox = new TextBox(new TerminalSize(40, 1))
+        Button searchButton = new Button("Search", { search() })
+        Button downloadsButton = new Button("Downloads", {download()})
+        Button uploadsButton = new Button("Uploads", {upload()})
+        Button filesButton = new Button("Files", { files() })
+        Button trustButton = new Button("Trust", {trust()})
+        Button chatButton = new Button("Chat", {chat()})
+        Button quitButton = new Button("Quit", {close()})
+        
+        LayoutData layoutData = GridLayout.createLayoutData(Alignment.CENTER, Alignment.CENTER)
+        
+        buttonsPanel.with { 
+            addComponent(searchTextBox, layoutData)
+            addComponent(searchButton, layoutData)
+            addComponent(downloadsButton, layoutData)
+            addComponent(uploadsButton, layoutData)
+            addComponent(filesButton, layoutData)
+            addComponent(trustButton, layoutData)
+            addComponent(chatButton, layoutData)
+            addComponent(quitButton, layoutData)
+        }
+        
+        Panel bottomPanel = new Panel()
+        contentPanel.addComponent(bottomPanel, BorderLayout.Location.BOTTOM)
+        BorderLayout bottomLayout = new BorderLayout()
+        bottomPanel.setLayoutManager(bottomLayout)
+        
+        Label persona = new Label(core.me.getHumanReadableName())
+        bottomPanel.addComponent(persona, BorderLayout.Location.LEFT)
+        
+        
+        Panel connectionsPanel = new Panel()
+        connectionsPanel.setLayoutManager(new GridLayout(2))
+        Label connections = new Label("Connections:")
+        connectionsPanel.addComponent(connections, GridLayout.createLayoutData(Alignment.CENTER, Alignment.CENTER))
+        connectionCount = new Label("0")
+        connectionsPanel.addComponent(connectionCount, GridLayout.createLayoutData(Alignment.CENTER, Alignment.CENTER))
+        
+        bottomPanel.addComponent(connectionsPanel, BorderLayout.Location.RIGHT)
+
+        
+        Panel centralPanel = new Panel()
+        centralPanel.setLayoutManager(new GridLayout(1))
+        contentPanel.addComponent(centralPanel, BorderLayout.Location.CENTER)
+        Panel statusPanel = new Panel()
+        statusPanel.setLayoutManager(new GridLayout(2))
+        statusPanel.withBorder(Borders.doubleLine("Stats"))
+        centralPanel.addComponent(statusPanel, GridLayout.createLayoutData(Alignment.CENTER, Alignment.CENTER, true, true))
+
+        incoming = new Label("0")
+        outgoing = new Label("0")
+        known = new Label("0")
+        failing = new Label("0")
+        hopeless = new Label("0")
+        sharedFiles = new Label("0")
+        timesBrowsed = new Label("0")
+        updateStatus = new Label("Unknown")
+        usedRam = new Label("0")
+        maxRam = new Label("0")
+        totalRam = new Label("0")
+                
+        statusPanel.with { 
+            addComponent(new Label("Incoming Connections: "), layoutData)
+            addComponent(incoming, layoutData)
+            addComponent(new Label("Outgoing Connections: "), layoutData)
+            addComponent(outgoing, layoutData)
+            addComponent(new Label("Known Hosts: "), layoutData)
+            addComponent(known, layoutData)
+            addComponent(new Label("Failing Hosts: "), layoutData)
+            addComponent(failing, layoutData)
+            addComponent(new Label("Hopeless Hosts: "), layoutData)
+            addComponent(hopeless, layoutData)
+            addComponent(new Label("Shared Files: "), layoutData)
+            addComponent(sharedFiles, layoutData)
+            addComponent(new Label("Times Browsed: "), layoutData)
+            addComponent(timesBrowsed, layoutData)
+            addComponent(new Label("Update Status: "), layoutData)
+            addComponent(updateStatus, layoutData)
+            addComponent(new Label("Java Version: "), layoutData)
+            addComponent(new Label(System.getProperty("java.vendor")+ " " + System.getProperty("java.version")), layoutData)
+            addComponent(new Label("Used Memory: "), layoutData)
+            addComponent(usedRam, layoutData)
+            addComponent(new Label("Total Memory: "), layoutData)
+            addComponent(totalRam, layoutData)
+            addComponent(new Label("Maximum Memory: "), layoutData)
+            addComponent(maxRam, layoutData)
+        }
+        
+        refreshStats()
+        
+        searchButton.takeFocus()
+        core.eventBus.register(ConnectionEvent.class, this)
+        core.eventBus.register(HostDiscoveredEvent.class, this)
+        core.eventBus.register(FileLoadedEvent.class, this)
+        core.eventBus.register(FileHashedEvent.class, this)
+        core.eventBus.register(FileUnsharedEvent.class, this)
+        core.eventBus.register(FileDownloadedEvent.class, this)
+        core.eventBus.register(UpdateAvailableEvent.class, this)
+        core.eventBus.register(UpdateDownloadedEvent.class, this)
+    }
+    
+    void onConnectionEvent(ConnectionEvent e) {
+        textGUI.getGUIThread().invokeLater {
+            connectionCount.setText(String.valueOf(core.connectionManager.connections.size()))
+            refreshStats()
+        }
+    }
+    
+    void onHostDiscoveredEvent(HostDiscoveredEvent e) {
+        textGUI.getGUIThread().invokeLater {
+            refreshStats()
+        }
+    }
+    
+    void onFileLoadedEvent(FileLoadedEvent e) {
+        textGUI.getGUIThread().invokeLater {
+            refreshStats()
+        }
+    }
+    
+    void onFileHashedEvent(FileHashedEvent e) {
+        textGUI.getGUIThread().invokeLater {
+            refreshStats()
+        }
+    }
+    
+    void onFileUnsharedEvent(FileUnsharedEvent e) {
+        textGUI.getGUIThread().invokeLater {
+            refreshStats()
+        }
+    }
+    
+    void onFileDownloadedEvent(FileDownloadedEvent e) {
+        textGUI.getGUIThread().invokeLater {
+            refreshStats()
+        }
+    }
+    
+    void onUpdateAvailableEvent(UpdateAvailableEvent e) {
+        textGUI.getGUIThread().invokeLater {
+            String label = "$e.version is available with hash $e.infoHash"
+            updateStatus.setText(label)
+            String message = "Version $e.version is available, with hash $e.infoHash .  Show details?"
+            def button = MessageDialog.showMessageDialog(textGUI, "Update Available", message, MessageDialogButton.Yes, MessageDialogButton.No)
+            if (button == MessageDialogButton.No)
+                return
+            textGUI.addWindowAndWait(new UpdateTextView(e.text, sizeForTables()))
+        }
+    }
+    
+    void onUpdateDownloadedEvent(UpdateDownloadedEvent e) {
+        textGUI.getGUIThread().invokeLater {
+            String label = "$e.version downloaded"
+            updateStatus.setText(label)
+            String message = "MuWire version $e.version has been downloaded.  Show details?."
+            def button = MessageDialog.showMessageDialog(textGUI, "Update Available", message, MessageDialogButton.Yes, MessageDialogButton.No)
+            if (button == MessageDialogButton.No)
+                return
+            textGUI.addWindowAndWait(new UpdateTextView(e.text, sizeForTables()))
+        }
+    }
+    
+    private TerminalSize sizeForTables() {
+        TerminalSize full = screen.getTerminalSize()
+        return new TerminalSize(full.getColumns(), full.getRows() - 10)
+    }
+    
+    private void search() {
+        String query = searchTextBox.getText()
+        query = query.trim()
+        if (query.length() == 0)
+            return
+        if (query.length() > 128)
+            query = query.substring(0, 128)
+        
+        SearchModel model = new SearchModel(query, core, textGUI.getGUIThread())
+        textGUI.addWindowAndWait(new SearchView(model,core, textGUI, sizeForTables()))
+    }
+    
+    
+    private void download() {
+        textGUI.addWindowAndWait(new DownloadsView(core, downloadsModel, textGUI, sizeForTables()))
+    }
+    
+    private void upload() {
+        textGUI.addWindowAndWait(new UploadsView(uploadsModel, sizeForTables()))
+    }
+    
+    private void files() {
+        textGUI.addWindowAndWait(new FilesView(filesModel, textGUI, core, sizeForTables()))
+    }
+    
+    private void trust() {
+        textGUI.addWindowAndWait(new TrustView(trustModel, textGUI, core, sizeForTables()))
+    }
+    
+    private void chat() {
+        textGUI.addWindowAndWait(new ChatConsoleView(core, chatModel, textGUI, sizeForTables()))
+    }
+    
+    private void refreshStats() {
+        int inCon = 0
+        int outCon = 0
+        core.connectionManager.getConnections().each { 
+            if (it.isIncoming())
+                inCon++
+            else
+                outCon++
+        }
+        int knownHosts = core.hostCache.hosts.size()
+        int failingHosts = core.hostCache.countFailingHosts()
+        int hopelessHosts = core.hostCache.countHopelessHosts()
+        int shared = core.fileManager.fileToSharedFile.size()
+        int browsed = core.connectionAcceptor.browsed
+        long freeMemL = Runtime.getRuntime().freeMemory()
+        long totalMemL = Runtime.getRuntime().totalMemory()
+        String usedMem = DataHelper.formatSize2Decimal(freeMemL, false) + "B"
+        String totalMem = DataHelper.formatSize2Decimal(totalMemL, false)+"B"
+        String maxMem
+        long maxMemL = Runtime.getRuntime().maxMemory()
+        if (maxMemL >= Long.MAX_VALUE / 2)
+            maxMem = "Unlimited"
+        else
+            maxMem = DataHelper.formatSize2Decimal(maxMemL, false) + "B"
+            
+        
+        incoming.setText(String.valueOf(inCon))
+        outgoing.setText(String.valueOf(outCon))
+        known.setText(String.valueOf(knownHosts))
+        failing.setText(String.valueOf(failingHosts))
+        hopeless.setText(String.valueOf(hopelessHosts))
+        sharedFiles.setText(String.valueOf(shared))
+        timesBrowsed.setText(String.valueOf(browsed))
+        usedRam.setText(usedMem)
+        totalRam.setText(totalMem)
+        maxRam.setText(maxMem)
+    }
+}

cli-lanterna/src/main/groovy/com/muwire/clilanterna/PersonaWrapper.groovy

@@ -0,0 +1,15 @@
+package com.muwire.clilanterna
+
+import com.muwire.core.Persona
+
+class PersonaWrapper {
+    private final Persona persona
+    PersonaWrapper(Persona persona) {
+        this.persona = persona
+    }
+    
+    @Override
+    public String toString() {
+        persona.getHumanReadableName()
+    }
+}

cli-lanterna/src/main/groovy/com/muwire/clilanterna/ResultComparators.groovy

@@ -0,0 +1,21 @@
+package com.muwire.clilanterna
+
+import com.muwire.core.search.UIResultEvent
+
+class ResultComparators {
+    public static final Comparator<UIResultEvent> NAME_ASC = new Comparator<UIResultEvent>() {
+        public int compare(UIResultEvent a, UIResultEvent b) {
+            a.name.compareTo(b.name)
+        }
+    }
+    
+    public static final Comparator<UIResultEvent> NAME_DESC = NAME_ASC.reversed()
+    
+    public static final Comparator<UIResultEvent> SIZE_ASC = new Comparator<UIResultEvent>() {
+        public int compare(UIResultEvent a, UIResultEvent b) {
+            Long.compare(a.size, b.size)
+        }
+    }
+    
+    public static final Comparator<UIResultEvent> SIZE_DESC = SIZE_ASC.reversed()
+}

cli-lanterna/src/main/groovy/com/muwire/clilanterna/ResultsModel.groovy

@@ -0,0 +1,48 @@
+package com.muwire.clilanterna
+
+import com.muwire.core.search.UIResultBatchEvent
+import com.muwire.core.search.UIResultEvent
+
+import net.i2p.data.Base64
+import net.i2p.data.DataHelper
+
+import com.googlecode.lanterna.gui2.table.TableModel
+
+class ResultsModel {
+    private final UIResultBatchEvent results
+    final TableModel model
+    final Map<String, UIResultEvent> rootToResult = new HashMap<>()
+    
+    ResultsModel(UIResultBatchEvent results) {
+        this.results = results
+        model = new TableModel("Name","Size","Hash","Sources","Comment","Certificates")
+        updateModel()
+    }
+    
+    void sort(SortType type) {
+        Comparator<UIResultEvent> chosen
+        switch(type) {
+            case SortType.NAME_ASC : chosen = ResultComparators.NAME_ASC; break
+            case SortType.NAME_DESC : chosen = ResultComparators.NAME_DESC; break
+            case SortType.SIZE_ASC : chosen = ResultComparators.SIZE_ASC; break
+            case SortType.SIZE_DESC : chosen = ResultComparators.SIZE_DESC; break
+        }
+
+        Arrays.sort(results.results, chosen)
+        updateModel()
+    }
+    
+    private void updateModel() {
+        int rowCount = model.getRowCount()
+        rowCount.times { model.removeRow(0) }
+        
+        results.results.each {
+            String size = DataHelper.formatSize2Decimal(it.size, false) + "B"
+            String infoHash = Base64.encode(it.infohash.getRoot())
+            String sources = String.valueOf(it.sources.size())
+            String comment = String.valueOf(it.comment != null)
+            model.addRow(it.name, size, infoHash, sources, comment, it.certificates)
+            rootToResult.put(infoHash, it)
+        }
+    }
+}

cli-lanterna/src/main/groovy/com/muwire/clilanterna/ResultsView.groovy

@@ -0,0 +1,124 @@
+package com.muwire.clilanterna
+
+import com.googlecode.lanterna.TerminalSize
+import com.googlecode.lanterna.gui2.BasicWindow
+import com.googlecode.lanterna.gui2.Button
+import com.googlecode.lanterna.gui2.GridLayout
+import com.googlecode.lanterna.gui2.LayoutData
+import com.googlecode.lanterna.gui2.GridLayout.Alignment
+import com.googlecode.lanterna.gui2.Panel
+import com.googlecode.lanterna.gui2.TextGUI
+import com.googlecode.lanterna.gui2.Window
+import com.googlecode.lanterna.gui2.dialogs.MessageDialog
+import com.googlecode.lanterna.gui2.dialogs.MessageDialogButton
+import com.googlecode.lanterna.gui2.table.Table
+
+import com.muwire.core.Core
+import com.muwire.core.download.UIDownloadEvent
+import com.muwire.core.search.UIResultEvent
+
+class ResultsView extends BasicWindow {
+    
+    private final ResultsModel model
+    private final TextGUI textGUI
+    private final Core core
+    private final Table table
+    private final TerminalSize terminalSize
+    
+    ResultsView(ResultsModel model, Core core, TextGUI textGUI, TerminalSize terminalSize) {
+        super(model.results.results[0].sender.getHumanReadableName() + " Results")
+        this.model = model
+        this.core = core
+        this.textGUI = textGUI
+        this.terminalSize = terminalSize
+        
+        setHints([Window.Hint.EXPANDED])
+        
+        Panel contentPanel = new Panel()
+        contentPanel.setLayoutManager(new GridLayout(1))
+        
+        table = new Table("Name","Size","Hash","Sources","Comment","Certificates")
+        table.setCellSelection(false)
+        table.setSelectAction({rowSelected()})
+        table.setTableModel(model.model)
+        table.setVisibleRows(terminalSize.getRows())
+        contentPanel.addComponent(table, GridLayout.createLayoutData(Alignment.CENTER, Alignment.CENTER, true, false))
+
+        Panel buttonsPanel = new Panel()
+        buttonsPanel.setLayoutManager(new GridLayout(2))
+        Button sortButton = new Button("Sort...",{sort()})
+        buttonsPanel.addComponent(sortButton)        
+        Button closeButton = new Button("Close", {close()})
+        buttonsPanel.addComponent(closeButton)
+        contentPanel.addComponent(buttonsPanel, GridLayout.createLayoutData(Alignment.CENTER, Alignment.CENTER, true, false))
+        
+        setComponent(contentPanel)
+        closeButton.takeFocus()    
+    }
+    
+    private void rowSelected() {
+        int selectedRow = table.getSelectedRow()
+        def rows = model.model.getRow(selectedRow)
+        boolean comment = Boolean.parseBoolean(rows[4])
+        boolean certificates = rows[5] > 0
+        if (comment || certificates) {
+            LayoutData layoutData = GridLayout.createLayoutData(Alignment.CENTER, Alignment.CENTER)
+            
+            Window prompt = new BasicWindow("Download Or View Comment/Certificates")
+            prompt.setHints([Window.Hint.CENTERED])
+            Panel contentPanel = new Panel()
+            contentPanel.setLayoutManager(new GridLayout(4))
+            Button downloadButton = new Button("Download", {download(rows[2])})
+            contentPanel.addComponent(downloadButton, layoutData)
+            
+            
+            if (comment) { 
+                Button viewButton = new Button("View Comment", {viewComment(rows[2])})
+                contentPanel.addComponent(viewButton, layoutData)
+            }
+            if (certificates) {
+                Button certsButton = new Button("View Certificates", {viewCertificates(rows[2])})
+                contentPanel.addComponent(certsButton, layoutData)
+            }
+                
+            Button closeButton = new Button("Cancel", {prompt.close()})
+            
+            contentPanel.addComponent(closeButton, layoutData)
+            prompt.setComponent(contentPanel)
+            downloadButton.takeFocus()
+            textGUI.addWindowAndWait(prompt)    
+        } else {
+            download(rows[2])
+        }
+
+    }
+    
+    private void download(String infohash) {
+        UIResultEvent result = model.rootToResult[infohash]
+        def file = new File(core.muOptions.downloadLocation, result.name)
+        
+        core.eventBus.publish(new UIDownloadEvent(result : [result], sources : result.sources,
+            target : file, sequential : false))
+        MessageDialog.showMessageDialog(textGUI, "Download Started", "Started download of "+result.name, MessageDialogButton.OK)
+    }
+    
+    private void viewComment(String infohash) {
+        UIResultEvent result = model.rootToResult[infohash]
+        ViewCommentView view = new ViewCommentView(result.comment, result.name, terminalSize)
+        textGUI.addWindowAndWait(view)
+    }
+    
+    private void viewCertificates(String infohash) {
+        UIResultEvent result = model.rootToResult[infohash]
+        ViewCertificatesModel model = new ViewCertificatesModel(result, core, textGUI.getGUIThread())
+        ViewCertificatesView view = new ViewCertificatesView(model, textGUI, core, terminalSize)
+        textGUI.addWindowAndWait(view)
+    }
+    
+    private void sort() {
+        SortPrompt prompt = new SortPrompt(textGUI)
+        SortType type = prompt.prompt()
+        if (type != null)
+            model.sort(type)
+    }
+}

cli-lanterna/src/main/groovy/com/muwire/clilanterna/SearchModel.groovy

@@ -0,0 +1,87 @@
+package com.muwire.clilanterna
+
+import com.muwire.core.Core
+import com.muwire.core.Persona
+import com.muwire.core.SplitPattern
+import com.muwire.core.search.QueryEvent
+import com.muwire.core.search.SearchEvent
+import com.muwire.core.search.UIResultBatchEvent
+import com.muwire.core.search.UIResultEvent
+import com.muwire.core.util.DataUtil
+
+import net.i2p.crypto.DSAEngine
+import net.i2p.data.Base64
+import net.i2p.data.Signature
+
+import java.nio.charset.StandardCharsets
+
+import com.googlecode.lanterna.gui2.TextGUIThread
+import com.googlecode.lanterna.gui2.table.TableModel
+class SearchModel {
+    private final TextGUIThread guiThread
+    private final String query
+    private final Core core
+    final TableModel model
+        
+    private final Map<Persona, UIResultBatchEvent> resultsPerSender = new HashMap<>()
+    
+    SearchModel(String query, Core core, TextGUIThread guiThread) {
+        this.query = query
+        this.core = core
+        this.guiThread = guiThread
+        this.model = new TableModel("Sender","Results","Browse","Trust")
+        core.eventBus.register(UIResultBatchEvent.class, this)
+        
+        
+        boolean hashSearch = false
+        byte [] root = null
+        if (query.length() == 44 && query.indexOf(" ") < 0) {
+            try {
+                root = Base64.decode(query)
+                hashSearch = true
+            } catch (Exception e) {
+                // not  hash search
+            }
+        }
+        
+        def searchEvent
+        byte [] payload
+        UUID uuid = UUID.randomUUID()
+        long timestamp = System.currentTimeMillis()
+        byte [] sig2 = DataUtil.signUUID(uuid, timestamp, core.spk)
+        if (hashSearch) {
+            searchEvent = new SearchEvent(searchHash : root, uuid : uuid, oobInfohash : true, compressedResults : true)
+            payload = root
+        } else {
+            def nonEmpty = SplitPattern.termify(query)
+            payload = String.join(" ", nonEmpty).getBytes(StandardCharsets.UTF_8)
+            searchEvent = new SearchEvent(searchTerms : nonEmpty, uuid : uuid, oobInfohash: true,
+            searchComments : core.muOptions.searchComments, compressedResults : true)
+        }
+        
+        boolean firstHop = core.muOptions.allowUntrusted || core.muOptions.searchExtraHop
+        
+        Signature sig = DSAEngine.getInstance().sign(payload, core.spk)
+        
+        core.eventBus.publish(new QueryEvent(searchEvent : searchEvent, firstHop : firstHop,
+            replyTo: core.me.destination, receivedOn: core.me.destination,
+            originator : core.me, sig: sig.data, queryTime : timestamp, sig2 : sig2))
+    }
+    
+    void unregister() {
+        core.eventBus.unregister(UIResultBatchEvent.class, this)
+    }
+    
+    void onUIResultBatchEvent(UIResultBatchEvent e) {
+        guiThread.invokeLater {
+            Persona sender = e.results[0].sender
+
+            resultsPerSender.put(sender, e)
+
+            String browse = String.valueOf(e.results[0].browse)
+            String results = String.valueOf(e.results.length)
+            String trust = core.trustService.getLevel(sender.destination).toString()
+            model.addRow([new PersonaWrapper(sender), results, browse, trust])
+        }
+    }
+}

cli-lanterna/src/main/groovy/com/muwire/clilanterna/SearchView.groovy

@@ -0,0 +1,113 @@
+package com.muwire.clilanterna
+
+import com.googlecode.lanterna.TerminalSize
+import com.googlecode.lanterna.gui2.BasicWindow
+import com.googlecode.lanterna.gui2.Button
+import com.googlecode.lanterna.gui2.GridLayout
+import com.googlecode.lanterna.gui2.GridLayout.Alignment
+import com.googlecode.lanterna.gui2.LayoutData
+import com.googlecode.lanterna.gui2.Panel
+import com.googlecode.lanterna.gui2.TextGUI
+import com.googlecode.lanterna.gui2.Window
+import com.googlecode.lanterna.gui2.dialogs.MessageDialog
+import com.googlecode.lanterna.gui2.dialogs.MessageDialogButton
+import com.googlecode.lanterna.gui2.table.Table
+
+import com.muwire.core.Core
+import com.muwire.core.Persona
+import com.muwire.core.trust.TrustEvent
+import com.muwire.core.trust.TrustLevel
+
+class SearchView extends BasicWindow {
+    private final Core core
+    private final SearchModel model
+    private final Table table
+    private final TextGUI textGUI
+    private final TerminalSize terminalSize
+    
+    SearchView(SearchModel model, Core core, TextGUI textGUI, TerminalSize terminalSize) {
+        super(model.query)
+        this.core = core
+        this.model = model
+        this.textGUI = textGUI
+        this.terminalSize = terminalSize
+        
+        setHints([Window.Hint.EXPANDED])
+        
+        Panel contentPanel = new Panel()
+        contentPanel.setLayoutManager(new GridLayout(1))
+    
+        table = new Table("Sender","Results","Browse","Trust") 
+        table.setCellSelection(false)
+        table.setSelectAction({rowSelected()})
+        table.setTableModel(model.model)   
+        table.setVisibleRows(terminalSize.getRows())
+        contentPanel.addComponent(table, GridLayout.createLayoutData(Alignment.CENTER, Alignment.CENTER, true, false))
+        
+        Button closeButton = new Button("Close", {
+            model.unregister()
+            close()
+        })
+        contentPanel.addComponent(closeButton, GridLayout.createLayoutData(Alignment.CENTER, Alignment.CENTER, true, false))
+        
+        setComponent(contentPanel)
+        closeButton.takeFocus()
+    }
+    
+    private void rowSelected() {
+        int selectedRow = table.getSelectedRow()
+        def rows = model.model.getRow(selectedRow)
+        Persona persona = rows[0].persona
+        boolean browse = Boolean.parseBoolean(rows[2])
+        Window prompt = new BasicWindow("Show Or Browse "+rows[0]+"?")
+        prompt.setHints([Window.Hint.CENTERED])
+        Panel contentPanel = new Panel()
+        contentPanel.setLayoutManager(new GridLayout(6))
+        LayoutData layoutData = GridLayout.createLayoutData(Alignment.CENTER, Alignment.CENTER)
+        Button showResults = new Button("Show Results", {
+            showResults(persona)
+        })
+        Button browseHost = new Button("Browse Host", {
+            BrowseModel model = new BrowseModel(persona, core, textGUI.getGUIThread())
+            BrowseView view = new BrowseView(model, textGUI, core, terminalSize)
+            textGUI.addWindowAndWait(view)
+        }) 
+        Button trustHost = new Button("Trust",{
+            core.eventBus.publish(new TrustEvent(persona : persona, level : TrustLevel.TRUSTED))
+            MessageDialog.showMessageDialog(textGUI, "Marked Trusted", persona.getHumanReadableName() + " has been marked trusted",
+                    MessageDialogButton.OK)
+        })
+        Button neutralHost = new Button("Neutral",{
+            core.eventBus.publish(new TrustEvent(persona : persona, level : TrustLevel.NEUTRAL))
+            MessageDialog.showMessageDialog(textGUI, "Marked Neutral", persona.getHumanReadableName() + " has been marked neutral",
+                    MessageDialogButton.OK)
+        })
+        Button distrustHost = new Button("Distrust", {
+            core.eventBus.publish(new TrustEvent(persona : persona, level : TrustLevel.DISTRUSTED))
+            MessageDialog.showMessageDialog(textGUI, "Marked Distrusted", persona.getHumanReadableName() + " has been marked distrusted",
+                    MessageDialogButton.OK)
+        })
+        Button closePrompt = new Button("Close", {prompt.close()})
+
+        contentPanel.with {
+            addComponent(showResults, layoutData)
+            if (browse)
+                addComponent(browseHost, layoutData)
+            addComponent(trustHost, layoutData)
+            addComponent(neutralHost, layoutData)
+            addComponent(distrustHost, layoutData)
+            addComponent(closePrompt, layoutData)
+        }
+
+        prompt.setComponent(contentPanel)
+        showResults.takeFocus()
+        textGUI.addWindowAndWait(prompt)
+    }
+    
+    private void showResults(Persona persona) {
+        def results = model.resultsPerSender.get(persona)
+        ResultsModel resultsModel = new ResultsModel(results)
+        ResultsView resultsView = new ResultsView(resultsModel, core, textGUI, terminalSize)
+        textGUI.addWindowAndWait(resultsView)
+    }
+}

cli-lanterna/src/main/groovy/com/muwire/clilanterna/SharedFileWrapper.groovy

@@ -0,0 +1,16 @@
+package com.muwire.clilanterna
+
+import com.muwire.core.SharedFile
+
+class SharedFileWrapper {
+    private final SharedFile sharedFile
+    
+    SharedFileWrapper(SharedFile sharedFile) {
+        this.sharedFile = sharedFile
+    }
+    
+    @Override
+    public String toString() {
+        sharedFile.getCachedPath()
+    }
+}

cli-lanterna/src/main/groovy/com/muwire/clilanterna/SortPrompt.groovy

@@ -0,0 +1,57 @@
+package com.muwire.clilanterna
+
+import com.googlecode.lanterna.gui2.BasicWindow
+import com.googlecode.lanterna.gui2.Button
+import com.googlecode.lanterna.gui2.GridLayout
+import com.googlecode.lanterna.gui2.GridLayout.Alignment
+import com.googlecode.lanterna.gui2.LayoutData
+import com.googlecode.lanterna.gui2.Panel
+import com.googlecode.lanterna.gui2.TextGUI
+import com.googlecode.lanterna.gui2.Window
+
+class SortPrompt extends BasicWindow {
+    private final TextGUI textGUI
+    private SortType type
+    SortPrompt(TextGUI textGUI) {
+        super("Select what to sort by")
+        this.textGUI = textGUI
+    }
+    
+    SortType prompt() {
+        setHints([Window.Hint.CENTERED])
+        Panel contentPanel = new Panel()
+        contentPanel.setLayoutManager(new GridLayout(5))
+        
+        LayoutData layoutData = GridLayout.createLayoutData(Alignment.CENTER, Alignment.CENTER)
+        
+        Button nameAsc = new Button("Name (ascending)",{
+            type = SortType.NAME_ASC
+            close()  
+        })
+        Button nameDesc = new Button("Name (descending)",{
+            type = SortType.NAME_DESC
+            close()
+        })
+        Button sizeAsc = new Button("Size (ascending)",{
+            type = SortType.SIZE_ASC
+            close()
+        })
+        Button sizeDesc = new Button("Size (descending)",{
+            type = SortType.SIZE_DESC
+            close()
+        })
+        Button close = new Button("Cancel",{close()})
+        
+        contentPanel.with { 
+            addComponent(nameAsc, layoutData)
+            addComponent(nameDesc, layoutData)
+            addComponent(sizeAsc, layoutData)
+            addComponent(sizeDesc, layoutData)
+            addComponent(close, layoutData)
+        }
+        
+        setComponent(contentPanel)
+        textGUI.addWindowAndWait(this)
+        type
+    }
+}

cli-lanterna/src/main/groovy/com/muwire/clilanterna/SortType.java

@@ -0,0 +1,5 @@
+package com.muwire.clilanterna;
+
+public enum SortType {
+    NAME_ASC,NAME_DESC,SIZE_ASC,SIZE_DESC
+}

cli-lanterna/src/main/groovy/com/muwire/clilanterna/TrustEntryWrapper.groovy

@@ -0,0 +1,7 @@
+package com.muwire.clilanterna
+
+import com.muwire.core.trust.TrustService
+
+class TrustEntryWrapper {
+    TrustService.TrustEntry entry
+}

cli-lanterna/src/main/groovy/com/muwire/clilanterna/TrustListModel.groovy

@@ -0,0 +1,49 @@
+package com.muwire.clilanterna
+
+import com.googlecode.lanterna.gui2.TextGUIThread
+import com.googlecode.lanterna.gui2.table.TableModel
+import com.muwire.core.Core
+import com.muwire.core.trust.RemoteTrustList
+import com.muwire.core.trust.TrustEvent
+
+class TrustListModel {
+    private final TextGUIThread guiThread
+    private final RemoteTrustList trustList
+    private final Core core
+    private final TableModel trustedTableModel, distrustedTableModel
+    
+    TrustListModel(RemoteTrustList trustList, Core core) {
+        this.trustList = trustList
+        this.core = core
+        
+        trustedTableModel = new TableModel("Trusted User","Reason","Your Trust")
+        distrustedTableModel = new TableModel("Distrusted User", "Reason", "Your Trust")
+        refreshModels()
+        
+        core.eventBus.register(TrustEvent.class, this)
+    }
+    
+    void onTrustEvent(TrustEvent e) {
+        guiThread.invokeLater {
+            refreshModels()
+        }
+    }
+    
+    private void refreshModels() {
+        int trustRows = trustedTableModel.getRowCount()
+        trustRows.times { trustedTableModel.removeRow(0) }
+        int distrustRows = distrustedTableModel.getRowCount()
+        distrustRows.times { distrustedTableModel.removeRow(0) }
+        
+        trustList.good.each { 
+            trustedTableModel.addRow(new PersonaWrapper(it.persona),it.reason, core.trustService.getLevel(it.persona.destination))
+        }
+        trustList.bad.each { 
+            distrustedTableModel.addRow(new PersonaWrapper(it.persona),it.reason, core.trustService.getLevel(it.persona.destination))
+        }
+    }
+    
+    void unregister() {
+        core.eventBus.unregister(TrustEvent.class, this)
+    }
+}

cli-lanterna/src/main/groovy/com/muwire/clilanterna/TrustListView.groovy

@@ -0,0 +1,121 @@
+package com.muwire.clilanterna
+
+import com.googlecode.lanterna.TerminalSize
+import com.googlecode.lanterna.gui2.BasicWindow
+import com.googlecode.lanterna.gui2.Button
+import com.googlecode.lanterna.gui2.GridLayout
+import com.googlecode.lanterna.gui2.GridLayout.Alignment
+import com.googlecode.lanterna.gui2.Label
+import com.googlecode.lanterna.gui2.LayoutData
+import com.googlecode.lanterna.gui2.Panel
+import com.googlecode.lanterna.gui2.TextGUI
+import com.googlecode.lanterna.gui2.Window
+import com.googlecode.lanterna.gui2.dialogs.MessageDialog
+import com.googlecode.lanterna.gui2.dialogs.MessageDialogButton
+import com.googlecode.lanterna.gui2.dialogs.TextInputDialog
+import com.googlecode.lanterna.gui2.table.Table
+import com.muwire.core.Core
+import com.muwire.core.Persona
+import com.muwire.core.trust.TrustEvent
+import com.muwire.core.trust.TrustLevel
+
+class TrustListView extends BasicWindow {
+    private final TrustListModel model
+    private final TextGUI textGUI
+    private final Core core
+    private final TerminalSize terminalSize
+    private final Table trusted, distrusted
+    
+    TrustListView(TrustListModel model, TextGUI textGUI, Core core, TerminalSize terminalSize) {
+        this.model = model
+        this.textGUI = textGUI
+        this.core = core
+        this.terminalSize = terminalSize
+        
+        int tableSize = terminalSize.getRows() - 10
+        
+        setHints([Window.Hint.EXPANDED])
+        
+        Panel contentPanel = new Panel()
+        contentPanel.setLayoutManager(new GridLayout(1))
+        LayoutData layoutData = GridLayout.createLayoutData(Alignment.CENTER, Alignment.CENTER, true, false)
+        
+        Label nameLabel = new Label("Trust list for "+model.trustList.persona.getHumanReadableName())
+        Label lastUpdatedLabel = new Label("Last updated "+new Date(model.trustList.timestamp))
+        contentPanel.addComponent(nameLabel, layoutData)
+        contentPanel.addComponent(lastUpdatedLabel, layoutData)
+        
+        
+        Panel topPanel = new Panel()
+        topPanel.setLayoutManager(new GridLayout(2))
+        
+        trusted = new Table("Trusted User","Reason","Your Trust")
+        trusted.with {
+            setCellSelection(false)
+            setTableModel(model.trustedTableModel)
+            setVisibleRows(tableSize)
+        }
+        trusted.setSelectAction({ actionsForUser(true) })
+        topPanel.addComponent(trusted, layoutData)
+        
+        distrusted = new Table("Distrusted User","Reason", "Your Trust")
+        distrusted.with { 
+            setCellSelection(false)
+            setTableModel(model.distrustedTableModel)
+            setVisibleRows(tableSize)
+        }
+        distrusted.setSelectAction({actionsForUser(false)}) 
+        topPanel.addComponent(distrusted, layoutData)
+
+        Button closeButton = new Button("Close",{close()})
+        
+        contentPanel.addComponent(topPanel, layoutData)
+        contentPanel.addComponent(closeButton, layoutData)
+        
+        setComponent(contentPanel)        
+    }
+
+    private void actionsForUser(boolean trustedUser) {
+        def table = trustedUser ? trusted : distrusted
+        def model = trustedUser ? model.trustedTableModel : model.distrustedTableModel
+        
+        int selectedRow = table.getSelectedRow()
+        def row = model.getRow(selectedRow)
+        
+        Persona persona = row[0].persona
+        
+        Window prompt = new BasicWindow("Actions for "+persona.getHumanReadableName())
+        prompt.setHints([Window.Hint.CENTERED])
+        Panel contentPanel = new Panel()
+        contentPanel.setLayoutManager(new GridLayout(4))
+        LayoutData layoutData = GridLayout.createLayoutData(Alignment.CENTER, Alignment.CENTER)
+        
+        Button trustButton = new Button("Trust",{
+            String reason = TextInputDialog.showDialog(textGUI, "Reason", "Enter reason (optional)", "")
+            core.eventBus.publish(new TrustEvent(persona : persona, level : TrustLevel.TRUSTED, reason : reason))
+            MessageDialog.showMessageDialog(textGUI, "Marked Trusted", persona.getHumanReadableName() + "has been marked trusted",
+                MessageDialogButton.OK)
+        })
+        Button neutralButton = new Button("Neutral",{
+            core.eventBus.publish(new TrustEvent(persona : persona, level : TrustLevel.NEUTRAL))
+            MessageDialog.showMessageDialog(textGUI, "Marked Neutral", persona.getHumanReadableName() + "has been marked neutral",
+                MessageDialogButton.OK)
+        })
+        Button distrustButton = new Button("Distrust",{
+            String reason = TextInputDialog.showDialog(textGUI, "Reason", "Enter reason (optional)", "")
+            core.eventBus.publish(new TrustEvent(persona : persona, level : TrustLevel.DISTRUSTED, reason : reason))
+            MessageDialog.showMessageDialog(textGUI, "Marked Distrusted", persona.getHumanReadableName() + "has been marked distrusted",
+                MessageDialogButton.OK)
+        })
+        Button closeButton = new Button("Close",{prompt.close()})
+        
+        contentPanel.with { 
+            addComponent(trustButton,layoutData)
+            addComponent(neutralButton, layoutData)
+            addComponent(distrustButton, layoutData)
+            addComponent(closeButton, layoutData)
+        }
+        prompt.setComponent(contentPanel)
+        textGUI.addWindowAndWait(prompt)
+    }    
+}

cli-lanterna/src/main/groovy/com/muwire/clilanterna/TrustListWrapper.groovy

@@ -0,0 +1,15 @@
+package com.muwire.clilanterna
+
+import com.muwire.core.trust.RemoteTrustList
+
+class TrustListWrapper {
+    private final RemoteTrustList trustList
+    TrustListWrapper(RemoteTrustList trustList) {
+        this.trustList = trustList
+    }
+    
+    @Override
+    public String toString() {
+        trustList.persona.getHumanReadableName()
+    }
+}

cli-lanterna/src/main/groovy/com/muwire/clilanterna/TrustModel.groovy

@@ -0,0 +1,78 @@
+package com.muwire.clilanterna
+
+import com.googlecode.lanterna.gui2.TextGUIThread
+import com.googlecode.lanterna.gui2.table.TableModel
+import com.muwire.core.Core
+import com.muwire.core.files.AllFilesLoadedEvent
+import com.muwire.core.trust.TrustEvent
+import com.muwire.core.trust.TrustSubscriptionEvent
+import com.muwire.core.trust.TrustSubscriptionUpdatedEvent
+
+class TrustModel {
+    private final TextGUIThread guiThread
+    private final Core core
+    private final TableModel modelTrusted, modelDistrusted, modelSubscriptions
+    
+    TrustModel(TextGUIThread guiThread, Core core) {
+        this.guiThread = guiThread
+        this.core = core
+        
+        modelTrusted = new TableModel("Trusted Users","Reason")
+        modelDistrusted = new TableModel("Distrusted Users","Reason")
+        modelSubscriptions = new TableModel("Name","Trusted","Distrusted","Status","Last Updated")
+        
+        core.eventBus.register(TrustEvent.class, this)
+        core.eventBus.register(AllFilesLoadedEvent.class, this)
+        core.eventBus.register(TrustSubscriptionUpdatedEvent.class, this)
+        
+    }
+    
+    void onTrustEvent(TrustEvent e) {
+        guiThread.invokeLater {
+            refreshModels()
+        }
+    }
+    
+    void onTrustSubscriptionUpdatedEvent(TrustSubscriptionUpdatedEvent e) {
+        guiThread.invokeLater {
+            refreshModels()
+        }
+    }
+    
+    void onAllFilesLoadedEvent(AllFilesLoadedEvent e) {
+        guiThread.invokeLater {
+            refreshModels()
+        }
+        core.muOptions.trustSubscriptions.each {
+            core.eventBus.publish(new TrustSubscriptionEvent(persona : it, subscribe : true))
+        }
+    }
+    
+    private void refreshModels() {
+        int trustedRows = modelTrusted.getRowCount()
+        trustedRows.times { modelTrusted.removeRow(0) }
+        int distrustedRows = modelDistrusted.getRowCount()
+        distrustedRows.times { modelDistrusted.removeRow(0) }
+        int subsRows = modelSubscriptions.getRowCount()
+        subsRows.times { modelSubscriptions.removeRow(0) }
+        
+        core.trustService.good.values().each { 
+            modelTrusted.addRow(new PersonaWrapper(it.persona),it.reason)
+        }
+        
+        core.trustService.bad.values().each { 
+            modelDistrusted.addRow(new PersonaWrapper(it.persona),it.reason)
+        }
+        
+        core.trustSubscriber.remoteTrustLists.values().each { 
+            def name = new TrustListWrapper(it)
+            String trusted = String.valueOf(it.good.size())
+            String distrusted = String.valueOf(it.bad.size())
+            String status = it.status
+            String lastUpdated = it.timestamp == 0 ? "Never" : new Date(it.timestamp)
+            
+            modelSubscriptions.addRow(name, trusted, distrusted, status, lastUpdated)
+        }
+        
+    }
+}

cli-lanterna/src/main/groovy/com/muwire/clilanterna/TrustView.groovy

@@ -0,0 +1,207 @@
+package com.muwire.clilanterna
+
+import com.googlecode.lanterna.TerminalSize
+import com.googlecode.lanterna.gui2.BasicWindow
+import com.googlecode.lanterna.gui2.Button
+import com.googlecode.lanterna.gui2.GridLayout
+import com.googlecode.lanterna.gui2.LayoutData
+import com.googlecode.lanterna.gui2.Panel
+import com.googlecode.lanterna.gui2.TextGUI
+import com.googlecode.lanterna.gui2.Window
+import com.googlecode.lanterna.gui2.dialogs.MessageDialog
+import com.googlecode.lanterna.gui2.dialogs.MessageDialogBuilder
+import com.googlecode.lanterna.gui2.dialogs.MessageDialogButton
+import com.googlecode.lanterna.gui2.dialogs.TextInputDialog
+import com.googlecode.lanterna.gui2.GridLayout.Alignment
+import com.googlecode.lanterna.gui2.Label
+import com.googlecode.lanterna.gui2.table.Table
+import com.muwire.core.Core
+import com.muwire.core.Persona
+import com.muwire.core.trust.TrustEvent
+import com.muwire.core.trust.TrustLevel
+import com.muwire.core.trust.TrustSubscriptionEvent
+
+class TrustView extends BasicWindow {
+    private final TrustModel model
+    private final TextGUI textGUI
+    private final Core core
+    private final TerminalSize terminalSize
+    private final Table trusted, distrusted, subscriptions
+    
+    TrustView(TrustModel model, TextGUI textGUI, Core core, TerminalSize terminalSize) {
+        this.model = model
+        this.textGUI = textGUI
+        this.core = core
+        this.terminalSize = terminalSize
+        
+        int tableSize = (terminalSize.getRows() / 2 - 10).toInteger()
+        
+        setHints([Window.Hint.EXPANDED])
+        
+        Panel contentPanel = new Panel()
+        contentPanel.setLayoutManager(new GridLayout(1))
+        LayoutData layoutData = GridLayout.createLayoutData(Alignment.CENTER, Alignment.CENTER, true, false)
+        
+        Panel topPanel = new Panel()
+        topPanel.setLayoutManager(new GridLayout(2))
+        
+        trusted = new Table("Trusted Users","Reason")
+        trusted.setCellSelection(false)
+        trusted.setSelectAction({trustedActions()})
+        trusted.setTableModel(model.modelTrusted)
+        trusted.setVisibleRows(tableSize)
+        topPanel.addComponent(trusted, layoutData)
+        
+        distrusted = new Table("Distrusted users","Reason")
+        distrusted.setCellSelection(false)
+        distrusted.setSelectAction({distrustedActions()})
+        distrusted.setTableModel(model.modelDistrusted)
+        distrusted.setVisibleRows(tableSize)
+        topPanel.addComponent(distrusted, layoutData)
+        
+        Panel bottomPanel = new Panel()
+        bottomPanel.setLayoutManager(new GridLayout(1))
+        
+        Label tableName = new Label("Trust List Subscriptions")
+        bottomPanel.addComponent(tableName, layoutData)
+        
+        subscriptions = new Table("Name","Trusted","Distrusted","Status","Last Updated")
+        subscriptions.setCellSelection(false)
+        subscriptions.setSelectAction({trustListActions()})
+        subscriptions.setTableModel(model.modelSubscriptions)
+        subscriptions.setVisibleRows(tableSize)
+        bottomPanel.addComponent(subscriptions, layoutData)
+        
+        Button closeButton = new Button("Close", {close()})
+        
+        contentPanel.addComponent(topPanel, layoutData)
+        contentPanel.addComponent(bottomPanel, layoutData)
+        contentPanel.addComponent(closeButton, layoutData)
+        
+        setComponent(contentPanel)
+    }
+    
+    private void trustedActions() {
+        int selectedRow = trusted.getSelectedRow()
+        def row = model.modelTrusted.getRow(selectedRow)
+        Persona persona = row[0].persona
+        
+        Window prompt = new BasicWindow("Change Trust For "+persona.getHumanReadableName())
+        prompt.setHints([Window.Hint.CENTERED])
+        Panel contentPanel = new Panel()
+        contentPanel.setLayoutManager(new GridLayout(4))
+        LayoutData layoutData = GridLayout.createLayoutData(Alignment.CENTER, Alignment.CENTER)
+        
+        Button subscribe = new Button("Subscribe", {
+            core.muOptions.trustSubscriptions.add(persona)
+            saveMuSettings()
+            core.eventBus.publish(new TrustSubscriptionEvent(persona : persona, subscribe : true))
+            MessageDialog.showMessageDialog(textGUI, "Subscribed", "Subscribed from trust list of " + persona.getHumanReadableName(),
+                MessageDialogButton.OK)
+           model.refreshModels()
+            
+        })
+        Button markNeutral = new Button("Mark Neutral", {
+            core.eventBus.publish(new TrustEvent(persona : persona, level : TrustLevel.NEUTRAL))
+            MessageDialog.showMessageDialog(textGUI, "Marked Neutral", persona.getHumanReadableName() + "has been marked neutral",
+                 MessageDialogButton.OK)  
+        })
+        Button markDistrusted = new Button("Mark Distrusted", {
+            String reason = TextInputDialog.showDialog(textGUI, "Reason", "Enter reason (optional)", "")
+            core.eventBus.publish(new TrustEvent(persona : persona, level : TrustLevel.DISTRUSTED, reason : reason))
+            MessageDialog.showMessageDialog(textGUI, "Marked Distrusted", persona.getHumanReadableName() + "has been marked distrusted",
+                 MessageDialogButton.OK)
+        })
+        Button closeButton = new Button("Close", {prompt.close()})
+        contentPanel.with {
+            addComponent(subscribe, layoutData) 
+            addComponent(markNeutral, layoutData)
+            addComponent(markDistrusted, layoutData)
+            addComponent(closeButton, layoutData)
+        }
+        prompt.setComponent(contentPanel)
+        textGUI.addWindowAndWait(prompt)
+    }
+    
+    private void distrustedActions() {
+        int selectedRow = distrusted.getSelectedRow()
+        def row = model.modelDistrusted.getRow(selectedRow)
+        Persona persona = row[0].persona
+        
+        Window prompt = new BasicWindow("Change Trust For "+persona.getHumanReadableName())
+        prompt.setHints([Window.Hint.CENTERED])
+        Panel contentPanel = new Panel()
+        contentPanel.setLayoutManager(new GridLayout(3))
+        LayoutData layoutData = GridLayout.createLayoutData(Alignment.CENTER, Alignment.CENTER)
+        
+        Button markNeutral = new Button("Mark Neutral", {
+            core.eventBus.publish(new TrustEvent(persona : persona, level : TrustLevel.NEUTRAL))
+            MessageDialog.showMessageDialog(textGUI, "Marked Neutral", persona.getHumanReadableName() + "has been marked neutral",
+                 MessageDialogButton.OK)
+        })
+        Button markDistrusted = new Button("Mark Trusted", {
+            String reason = TextInputDialog.showDialog(textGUI, "Reason", "Enter reason (optional)", "")
+            core.eventBus.publish(new TrustEvent(persona : persona, level : TrustLevel.TRUSTED, reason : reason))
+            MessageDialog.showMessageDialog(textGUI, "Marked Trusted", persona.getHumanReadableName() + "has been marked trusted",
+                 MessageDialogButton.OK)
+        })
+        Button closeButton = new Button("Close", {prompt.close()})
+        contentPanel.with {
+            addComponent(markDistrusted, layoutData)
+            addComponent(markNeutral, layoutData)
+            addComponent(closeButton, layoutData)
+        }
+        prompt.setComponent(contentPanel)
+        textGUI.addWindowAndWait(prompt)
+    }
+    
+    private void trustListActions() {
+        int selectedRow = subscriptions.getSelectedRow()
+        def row = model.modelSubscriptions.getRow(selectedRow)
+        
+        def trustList = row[0].trustList
+        Persona persona = trustList.persona
+        
+        Window prompt = new BasicWindow("Trust List Actions")
+        prompt.setHints([Window.Hint.CENTERED])
+        Panel contentPanel = new Panel()
+        contentPanel.setLayoutManager(new GridLayout(4))
+        LayoutData layoutData = GridLayout.createLayoutData(Alignment.CENTER, Alignment.CENTER)
+        
+        Button reviewButton = new Button("Review",{review(trustList)})
+        Button updateButton = new Button("Update",{
+            core.eventBus.publish(new TrustSubscriptionEvent(persona : persona, subscribe : true))
+            MessageDialog.showMessageDialog(textGUI, "Updating...", "Trust list will update soon", MessageDialogButton.OK)
+        })
+        Button unsubscribeButton = new Button("Unsubscribe", {
+            core.muOptions.trustSubscriptions.remove(persona)
+            saveMuSettings()
+            core.eventBus.publish(new TrustSubscriptionEvent(persona : persona, subscribe : false))
+            MessageDialog.showMessageDialog(textGUI, "Unsubscribed", "Unsubscribed from trust list of " + persona.getHumanReadableName(),
+                 MessageDialogButton.OK)
+            model.refreshModels()
+        })
+        Button closeButton = new Button("Close", {prompt.close()})
+        
+        contentPanel.with { 
+            addComponent(reviewButton, layoutData)
+            addComponent(updateButton, layoutData)
+            addComponent(unsubscribeButton, layoutData)
+            addComponent(closeButton, layoutData)
+        }
+        prompt.setComponent(contentPanel)
+        textGUI.addWindowAndWait(prompt)
+    }
+    
+    private void review(def trustList) {
+        TrustListModel model = new TrustListModel(trustList, core)
+        TrustListView view = new TrustListView(model, textGUI, core, terminalSize)
+        textGUI.addWindowAndWait(view)
+        model.unregister()
+    }
+    
+    private void saveMuSettings() {
+        File settingsFile = new File(core.home,"MuWire.properties")
+        settingsFile.withPrintWriter("UTF-8",{ core.muOptions.write(it) })
+    }
+}

cli-lanterna/src/main/groovy/com/muwire/clilanterna/UpdateTextView.groovy

@@ -0,0 +1,34 @@
+package com.muwire.clilanterna
+
+import com.googlecode.lanterna.TerminalSize
+import com.googlecode.lanterna.gui2.BasicWindow
+import com.googlecode.lanterna.gui2.Button
+import com.googlecode.lanterna.gui2.GridLayout
+import com.googlecode.lanterna.gui2.GridLayout.Alignment
+import com.googlecode.lanterna.gui2.LayoutData
+import com.googlecode.lanterna.gui2.Panel
+import com.googlecode.lanterna.gui2.TextBox
+import com.googlecode.lanterna.gui2.Window
+
+class UpdateTextView extends BasicWindow {
+    private final TextBox textBox
+    private final LayoutData layoutData = GridLayout.createLayoutData(Alignment.CENTER, Alignment.CENTER)
+    
+    UpdateTextView(String text, TerminalSize terminalSize) {
+        super("Update Details")
+        
+        setHints([Window.Hint.CENTERED])
+        
+        Panel contentPanel = new Panel()
+        contentPanel.setLayoutManager(new GridLayout(1))
+        
+        TerminalSize boxSize = new TerminalSize((terminalSize.getColumns() / 2).toInteger(), (terminalSize.getRows() / 2).toInteger())
+        textBox = new TextBox(boxSize, text, TextBox.Style.MULTI_LINE)
+        contentPanel.addComponent(textBox, layoutData)
+        
+        Button closeButton = new Button("Close", {close()})
+        contentPanel.addComponent(closeButton, layoutData)
+        
+        setComponent(contentPanel)
+    }
+}

cli-lanterna/src/main/groovy/com/muwire/clilanterna/UploadsModel.groovy

@@ -0,0 +1,107 @@
+package com.muwire.clilanterna
+
+import com.googlecode.lanterna.gui2.TextGUIThread
+import com.googlecode.lanterna.gui2.table.TableModel
+
+import com.muwire.core.Core
+import com.muwire.core.upload.UploadEvent
+import com.muwire.core.upload.UploadFinishedEvent
+import com.muwire.core.upload.Uploader
+
+import net.i2p.data.DataHelper
+
+class UploadsModel {
+    private final TextGUIThread guiThread
+    private final Core core
+    private CliSettings props
+    private final List<UploaderWrapper> uploaders = new ArrayList<>()
+    private final TableModel model = new TableModel("Name","Progress","Downloader","Remote Pieces", "Speed")
+    
+    UploadsModel(TextGUIThread guiThread, Core core, CliSettings props) {
+        this.guiThread = guiThread
+        this.core = core
+        this.props = props
+        
+        core.eventBus.register(UploadEvent.class, this)
+        core.eventBus.register(UploadFinishedEvent.class, this)
+        
+        Timer timer = new Timer(true)
+        Runnable refreshModel = {refreshModel()}
+        timer.schedule({
+            guiThread.invokeLater(refreshModel)
+        } as TimerTask, 1000, 1000)
+        
+    }
+    
+    void onUploadEvent(UploadEvent e) {
+        guiThread.invokeLater {
+            UploaderWrapper found = null
+            uploaders.each { 
+                if (it.uploader == e.uploader) {
+                    found = it
+                    return
+                }
+            }
+            if (found != null) {
+                found.uploader = e.uploader
+                found.finished = false
+            } else
+                uploaders << new UploaderWrapper(uploader : e.uploader)
+        }
+    }
+    
+    void onUploadFinishedEvent(UploadFinishedEvent e) {
+        guiThread.invokeLater {
+            uploaders.each { 
+                if (it.uploader == e.uploader) {
+                    it.finished = true
+                    return
+                }
+            }
+        }
+    }
+    
+    private void refreshModel() {
+        int uploadersSize = model.getRowCount()
+        uploadersSize.times { model.removeRow(0) }
+
+        if (props.clearUploads) {
+            uploaders.removeAll { it.finished }
+        }
+                
+        uploaders.each { 
+            String name = it.uploader.getName()
+            int percent = it.uploader.getProgress()
+            String percentString = "$percent% of piece".toString()
+            String downloader = it.uploader.getDownloader()
+            
+            int pieces = it.uploader.getTotalPieces()
+            int done = it.uploader.getDonePieces()
+            if (percent == 100)
+                done++
+            int percentTotal = -1
+            if (pieces != 0)
+                percentTotal = (done * 100) / pieces
+            long size = it.uploader.getTotalSize()
+            String totalSize = ""
+            if (size > 0)
+                totalSize = " of " + DataHelper.formatSize2Decimal(size, false) + "B"
+            String remotePieces = String.format("%02d", percentTotal) + "% ${totalSize} ($done/$pieces) pcs".toString()
+            
+            String speed = DataHelper.formatSize2Decimal(it.uploader.speed(), false) + "B/sec"
+            
+            
+            model.addRow([name, percentString, downloader, remotePieces, speed])
+        }
+    }
+    
+    private static class UploaderWrapper {
+        Uploader uploader
+        boolean finished
+        
+        @Override
+        public String toString() {
+            uploader.getName()
+        }
+    }
+}

cli-lanterna/src/main/groovy/com/muwire/clilanterna/UploadsView.groovy

@@ -0,0 +1,49 @@
+package com.muwire.clilanterna
+
+import com.googlecode.lanterna.TerminalSize
+import com.googlecode.lanterna.gui2.BasicWindow
+import com.googlecode.lanterna.gui2.Button
+import com.googlecode.lanterna.gui2.GridLayout
+import com.googlecode.lanterna.gui2.GridLayout.Alignment
+import com.googlecode.lanterna.gui2.LayoutData
+import com.googlecode.lanterna.gui2.Panel
+import com.googlecode.lanterna.gui2.TextGUI
+import com.googlecode.lanterna.gui2.Window
+import com.googlecode.lanterna.gui2.table.Table
+
+class UploadsView extends BasicWindow {
+    private final UploadsModel model
+    private final Table table
+    
+    UploadsView(UploadsModel model, TerminalSize terminalSize) {
+        this.model = model
+        
+        setHints([Window.Hint.EXPANDED])
+        
+        Panel contentPanel = new Panel()
+        contentPanel.setLayoutManager(new GridLayout(1))
+        LayoutData layoutData = GridLayout.createLayoutData(Alignment.CENTER, Alignment.CENTER, true, false)
+        
+        table = new Table("Name","Progress","Downloader","Remote Pieces","Speed")
+        table.setCellSelection(false)
+        table.setTableModel(model.model)
+        table.setVisibleRows(terminalSize.getRows())
+        contentPanel.addComponent(table, layoutData)
+
+        Panel buttonsPanel = new Panel()
+        buttonsPanel.setLayoutManager(new GridLayout(2))
+        
+        Button clearDoneButton = new Button("Clear Finished",{
+            model.uploaders.removeAll { it.finished }
+        })        
+        Button closeButton = new Button("Close",{close()})
+        
+        buttonsPanel.addComponent(clearDoneButton, layoutData)
+        buttonsPanel.addComponent(closeButton, layoutData)
+        
+        contentPanel.addComponent(buttonsPanel, layoutData)
+        
+        setComponent(contentPanel)
+        closeButton.takeFocus()
+    }
+}

cli-lanterna/src/main/groovy/com/muwire/clilanterna/ViewCertificatesModel.groovy

@@ -0,0 +1,74 @@
+package com.muwire.clilanterna
+
+import com.googlecode.lanterna.gui2.Label
+import com.googlecode.lanterna.gui2.TextGUIThread
+import com.googlecode.lanterna.gui2.table.TableModel
+import com.muwire.core.Core
+import com.muwire.core.Persona
+import com.muwire.core.filecert.Certificate
+import com.muwire.core.filecert.CertificateFetchEvent
+import com.muwire.core.filecert.CertificateFetchStatus
+import com.muwire.core.filecert.CertificateFetchedEvent
+import com.muwire.core.filecert.UIFetchCertificatesEvent
+import com.muwire.core.search.UIResultEvent
+
+class ViewCertificatesModel {
+    private final UIResultEvent result
+    private final Core core
+    private final TextGUIThread guiThread
+    
+    private final TableModel model = new TableModel("Issuer","Trust Status","File Name","Comment","Timestamp")
+    
+    private int totalCerts
+    
+    private Label status
+    private Label percentage
+    
+    ViewCertificatesModel(UIResultEvent result, Core core, TextGUIThread guiThread) {
+        this.result = result
+        this.core = core
+        this.guiThread = guiThread
+        
+        core.eventBus.with { 
+            register(CertificateFetchEvent.class,this)
+            register(CertificateFetchedEvent.class, this)
+            publish(new UIFetchCertificatesEvent(host : result.sender, infoHash : result.infohash))
+        }
+    }
+    
+    void unregister() {
+        core.eventBus.unregister(CertificateFetchEvent.class, this)
+        core.eventBus.unregister(CertificateFetchedEvent.class, this)
+    }
+    
+    void onCertificateFetchEvent(CertificateFetchEvent e) {
+        guiThread.invokeLater {
+            status.setText(e.status.toString())
+            if (e.status == CertificateFetchStatus.FETCHING)
+                totalCerts = e.count
+        }
+    }
+    
+    void onCertificateFetchedEvent(CertificateFetchedEvent e) {
+        guiThread.invokeLater {
+            Date date = new Date(e.certificate.timestamp)
+            model.addRow(new CertificateWrapper(e.certificate), core.trustService.getLevel(e.certificate.issuer.destination),
+                e.certificate.name.name, e.certificate.comment != null, date)
+            
+            String percentageString = ""
+            if (totalCerts > 0) {
+                double percentage = Math.round((model.getRowCount() * 100 / totalCerts).toDouble())
+                percentageString = String.valueOf(percentage) + "%"
+            }
+            percentage.setText(percentageString)
+        }
+    }
+    
+    void setStatusLabel(Label status) {
+        this.status = status
+    }
+    
+    void setPercentageLabel(Label percentage) {
+        this.percentage = percentage
+    }
+}

cli-lanterna/src/main/groovy/com/muwire/clilanterna/ViewCertificatesView.groovy

@@ -0,0 +1,103 @@
+package com.muwire.clilanterna
+
+import com.googlecode.lanterna.TerminalSize
+import com.googlecode.lanterna.gui2.BasicWindow
+import com.googlecode.lanterna.gui2.Button
+import com.googlecode.lanterna.gui2.GridLayout
+import com.googlecode.lanterna.gui2.LayoutData
+import com.googlecode.lanterna.gui2.Panel
+import com.googlecode.lanterna.gui2.TextGUI
+import com.googlecode.lanterna.gui2.Window
+import com.googlecode.lanterna.gui2.dialogs.MessageDialog
+import com.googlecode.lanterna.gui2.dialogs.MessageDialogButton
+import com.googlecode.lanterna.gui2.GridLayout.Alignment
+import com.googlecode.lanterna.gui2.Label
+import com.googlecode.lanterna.gui2.table.Table
+import com.muwire.core.Core
+import com.muwire.core.Persona
+import com.muwire.core.filecert.Certificate
+import com.muwire.core.filecert.UIImportCertificateEvent
+
+class ViewCertificatesView extends BasicWindow {
+    private final ViewCertificatesModel model
+    private final TextGUI textGUI
+    private final Core core
+    private final Table table
+    private final TerminalSize terminalSize
+    private final LayoutData layoutData = GridLayout.createLayoutData(Alignment.CENTER, Alignment.CENTER, true, false)
+    
+    ViewCertificatesView(ViewCertificatesModel model, TextGUI textGUI, Core core, TerminalSize terminalSize) {
+        super("Certificates")
+        this.model = model
+        this.core = core
+        this.textGUI = textGUI
+        this.terminalSize = terminalSize
+        
+        setHints([Window.Hint.EXPANDED])
+        
+        Panel contentPanel = new Panel()
+        contentPanel.setLayoutManager(new GridLayout(1))
+        
+        Label statusLabel = new Label("")
+        Label percentageLabel = new Label("")
+        model.setStatusLabel(statusLabel)
+        model.setPercentageLabel(percentageLabel)
+        
+        Panel topPanel = new Panel()
+        topPanel.setLayoutManager(new GridLayout(2))
+        topPanel.addComponent(statusLabel, layoutData)
+        topPanel.addComponent(percentageLabel, layoutData)
+        contentPanel.addComponent(topPanel, layoutData)
+        
+        table = new Table("Issuer","Trust Status","File Name","Comment","Timestamp")
+        table.with { 
+            setCellSelection(false)
+            setTableModel(model.model)
+            setVisibleRows(terminalSize.getRows())
+            setSelectAction({rowSelected()})
+        }
+        contentPanel.addComponent(table, layoutData)
+        
+        Button closeButton = new Button("Close",{
+            model.unregister()
+            close()
+        })
+        contentPanel.addComponent(closeButton, layoutData)
+        setComponent(contentPanel)
+    }
+    
+    private void rowSelected() {
+        int selectedRow = table.getSelectedRow()
+        def row = model.model.getRow(selectedRow)
+        Certificate certificate = row[0].certificate
+        
+        Window prompt = new BasicWindow("Import Certificate?")
+        prompt.setHints([Window.Hint.CENTERED])
+        
+        Panel contentPanel = new Panel()
+        contentPanel.setLayoutManager(new GridLayout(3))
+        Button importButton = new Button("Import", {importCert(certificate)})
+        
+        Button viewCommentButton = new Button("View Comment", {viewComment(certificate)})
+        
+        Button closeButton = new Button("Close", {prompt.close()})
+        contentPanel.addComponent(importButton, layoutData)
+        if (certificate.comment != null)
+            contentPanel.addComponent(viewCommentButton, layoutData)
+        contentPanel.addComponent(closeButton, layoutData)
+        
+        prompt.setComponent(contentPanel)
+        importButton.takeFocus()
+        textGUI.addWindowAndWait(prompt)
+    }
+    
+    private void importCert(Certificate certificate) {
+        core.eventBus.publish(new UIImportCertificateEvent(certificate : certificate))
+        MessageDialog.showMessageDialog(textGUI, "Certificate(s) Imported", "", MessageDialogButton.OK)
+    }
+    
+    private void viewComment(Certificate certificate) {
+        ViewCommentView view = new ViewCommentView(certificate.comment.name, "Certificate Comment", terminalSize)
+        textGUI.addWindowAndWait(view)
+    }
+}

cli-lanterna/src/main/groovy/com/muwire/clilanterna/ViewCommentView.groovy

@@ -0,0 +1,39 @@
+package com.muwire.clilanterna
+
+import com.googlecode.lanterna.TerminalSize
+import com.googlecode.lanterna.gui2.BasicWindow
+import com.googlecode.lanterna.gui2.Button
+import com.googlecode.lanterna.gui2.GridLayout
+import com.googlecode.lanterna.gui2.GridLayout.Alignment
+import com.googlecode.lanterna.gui2.LayoutData
+import com.googlecode.lanterna.gui2.Panel
+import com.googlecode.lanterna.gui2.TextBox
+import com.googlecode.lanterna.gui2.Window
+import com.muwire.core.SharedFile
+import com.muwire.core.search.UIResultEvent
+import com.muwire.core.util.DataUtil
+
+import net.i2p.data.Base64
+
+class ViewCommentView extends BasicWindow {
+    private final TextBox textBox
+    private final LayoutData layoutData = GridLayout.createLayoutData(Alignment.CENTER, Alignment.CENTER)
+    
+    ViewCommentView(String text, String title, TerminalSize terminalSize) {
+        super("View Comments For "+title)
+        
+        setHints([Window.Hint.CENTERED])
+        
+        Panel contentPanel = new Panel()
+        contentPanel.setLayoutManager(new GridLayout(1))
+        
+        TerminalSize boxSize = new TerminalSize((terminalSize.getColumns() / 2).toInteger(), (terminalSize.getRows() / 2).toInteger())
+        textBox = new TextBox(boxSize, text, TextBox.Style.MULTI_LINE)
+        contentPanel.addComponent(textBox, layoutData)
+        
+        Button closeButton = new Button("Close", {close()})
+        contentPanel.addComponent(closeButton, layoutData)
+        
+        setComponent(contentPanel)
+    }
+}

cli/build.gradle

@@ -6,7 +6,7 @@ buildscript {
     }
 
     dependencies {
-        classpath 'com.github.jengelman.gradle.plugins:shadow:2.0.4'
+        classpath 'com.github.jengelman.gradle.plugins:shadow:5.2.0'
     }
 }
 

cli/src/main/groovy/com/muwire/cli/Cli.groovy

@@ -35,7 +35,7 @@ class Cli {
 
         Core core
         try {
-            core = new Core(props, home, "0.4.11")
+            core = new Core(props, home, "0.5.3")
         } catch (Exception bad) {
             bad.printStackTrace(System.out)
             println "Failed to initialize core, exiting"

cli/src/main/groovy/com/muwire/cli/CliDownloader.groovy

@@ -53,7 +53,7 @@ class CliDownloader {
 
         Core core
         try {
-            core = new Core(props, home, "0.4.11")
+            core = new Core(props, home, "0.5.3")
         } catch (Exception bad) {
             bad.printStackTrace(System.out)
             println "Failed to initialize core, exiting"

core/build.gradle

@@ -1,11 +1,42 @@
-apply plugin : 'application'
-mainClassName = 'com.muwire.core.Core'
-applicationDefaultJvmArgs = ['-Djava.util.logging.config.file=logging.properties']
-dependencies {
-    compile 'net.i2p:router:0.9.41'
-    compile 'net.i2p.client:mstreaming:0.9.41'
-    compile 'net.i2p.client:streaming:0.9.41'
 
-    testCompile 'org.junit.jupiter:junit-jupiter-api:5.4.2'    
-    testCompile 'junit:junit:4.12'
+plugins {
+    id 'java-library'
+    id 'maven-publish'
+}
+
+dependencies {
+    api "net.i2p:i2p:${i2pVersion}"
+    api "net.i2p:router:${i2pVersion}"
+    api "net.i2p.client:mstreaming:${i2pVersion}"
+    implementation "net.i2p.client:streaming:${i2pVersion}"
+
+    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.4.2'    
+    testImplementation 'junit:junit:4.12'
+    testImplementation 'org.codehaus.groovy:groovy-all:3.0.4'
+}
+
+
+// this is necessary because applying both groovy and java-library doesn't work well
+configurations {
+    apiElements.outgoing.variants {
+        classes {
+            artifact file: compileGroovy.destinationDir, builtBy: compileGroovy
+        }
+    }
+}
+
+configurations.testImplementation {
+        exclude group:'org.codehaus.groovy', module:'groovy-testng'
+}
+
+// publish core to local maven repo for sister projects
+publishing {
+    publications {
+        muCore(MavenPublication) {
+            from components.java
+        }
+    }
+    repositories {
+        mavenLocal()
+    }
 }

core/src/main/groovy/com/muwire/core/Constants.groovy

@@ -1,13 +0,0 @@
-package com.muwire.core
-
-import net.i2p.crypto.SigType
-
-class Constants {
-    public static final byte PERSONA_VERSION = (byte)1
-    public static final SigType SIG_TYPE = SigType.EdDSA_SHA512_Ed25519
-
-    public static final int MAX_HEADER_SIZE = 0x1 << 14
-    public static final int MAX_HEADERS = 16
-
-    public static final String SPLIT_PATTERN = "[\\*\\+\\-,\\.:;\\(\\)=_/\\\\\\!\\\"\\\'\\\$%\\|\\[\\]\\{\\}\\?]"
-}

core/src/main/groovy/com/muwire/core/Core.groovy

@@ -1,8 +1,19 @@
 package com.muwire.core
 
+import com.muwire.core.files.PersisterDoneEvent
+import com.muwire.core.files.PersisterFolderService
+
 import java.nio.charset.StandardCharsets
 import java.util.concurrent.atomic.AtomicBoolean
+import java.util.logging.Level
+import java.util.zip.ZipException
 
+import com.muwire.core.chat.ChatDisconnectionEvent
+import com.muwire.core.chat.ChatManager
+import com.muwire.core.chat.ChatMessageEvent
+import com.muwire.core.chat.ChatServer
+import com.muwire.core.chat.UIConnectChatEvent
+import com.muwire.core.chat.UIDisconnectChatEvent
 import com.muwire.core.connection.ConnectionAcceptor
 import com.muwire.core.connection.ConnectionEstablisher
 import com.muwire.core.connection.ConnectionEvent
@@ -12,15 +23,31 @@ import com.muwire.core.connection.I2PAcceptor
 import com.muwire.core.connection.I2PConnector
 import com.muwire.core.connection.LeafConnectionManager
 import com.muwire.core.connection.UltrapeerConnectionManager
+import com.muwire.core.download.DownloadHopelessEvent
 import com.muwire.core.download.DownloadManager
 import com.muwire.core.download.SourceDiscoveredEvent
+import com.muwire.core.download.SourceVerifiedEvent
 import com.muwire.core.download.UIDownloadCancelledEvent
 import com.muwire.core.download.UIDownloadEvent
 import com.muwire.core.download.UIDownloadPausedEvent
 import com.muwire.core.download.UIDownloadResumedEvent
+import com.muwire.core.filecert.CertificateClient
+import com.muwire.core.filecert.CertificateManager
+import com.muwire.core.filecert.UICreateCertificateEvent
+import com.muwire.core.filecert.UIFetchCertificatesEvent
+import com.muwire.core.filecert.UIImportCertificateEvent
+import com.muwire.core.filefeeds.FeedClient
+import com.muwire.core.filefeeds.FeedFetchEvent
+import com.muwire.core.filefeeds.FeedItemFetchedEvent
+import com.muwire.core.filefeeds.FeedManager
+import com.muwire.core.filefeeds.UIDownloadFeedItemEvent
+import com.muwire.core.filefeeds.UIFilePublishedEvent
+import com.muwire.core.filefeeds.UIFeedConfigurationEvent
+import com.muwire.core.filefeeds.UIFeedDeletedEvent
+import com.muwire.core.filefeeds.UIFeedUpdateEvent
+import com.muwire.core.filefeeds.UIFileUnpublishedEvent
 import com.muwire.core.files.FileDownloadedEvent
 import com.muwire.core.files.FileHashedEvent
-import com.muwire.core.files.FileHashingEvent
 import com.muwire.core.files.FileHasher
 import com.muwire.core.files.FileLoadedEvent
 import com.muwire.core.files.FileManager
@@ -28,18 +55,29 @@ import com.muwire.core.files.FileSharedEvent
 import com.muwire.core.files.FileUnsharedEvent
 import com.muwire.core.files.HasherService
 import com.muwire.core.files.PersisterService
+import com.muwire.core.files.SideCarFileEvent
+import com.muwire.core.files.UICommentEvent
+import com.muwire.core.files.directories.UISyncDirectoryEvent
+import com.muwire.core.files.directories.WatchedDirectoryConfigurationEvent
+import com.muwire.core.files.directories.WatchedDirectoryConvertedEvent
+import com.muwire.core.files.directories.WatchedDirectoryConverter
+import com.muwire.core.files.directories.WatchedDirectoryManager
 import com.muwire.core.files.AllFilesLoadedEvent
 import com.muwire.core.files.DirectoryUnsharedEvent
+import com.muwire.core.files.DirectoryWatchedEvent
 import com.muwire.core.files.DirectoryWatcher
 import com.muwire.core.hostcache.CacheClient
 import com.muwire.core.hostcache.HostCache
 import com.muwire.core.hostcache.HostDiscoveredEvent
 import com.muwire.core.mesh.MeshManager
+import com.muwire.core.search.BrowseManager
 import com.muwire.core.search.QueryEvent
+import com.muwire.core.search.ResponderCache
 import com.muwire.core.search.ResultsEvent
 import com.muwire.core.search.ResultsSender
 import com.muwire.core.search.SearchEvent
 import com.muwire.core.search.SearchManager
+import com.muwire.core.search.UIBrowseEvent
 import com.muwire.core.search.UIResultBatchEvent
 import com.muwire.core.trust.TrustEvent
 import com.muwire.core.trust.TrustService
@@ -50,6 +88,7 @@ import com.muwire.core.upload.UploadManager
 import com.muwire.core.util.MuWireLogManager
 import com.muwire.core.content.ContentControlEvent
 import com.muwire.core.content.ContentManager
+import com.muwire.core.tracker.TrackerResponder
 
 import groovy.util.logging.Log
 import net.i2p.I2PAppContext
@@ -57,10 +96,8 @@ import net.i2p.client.I2PClientFactory
 import net.i2p.client.I2PSession
 import net.i2p.client.streaming.I2PSocketManager
 import net.i2p.client.streaming.I2PSocketManagerFactory
-import net.i2p.client.streaming.I2PSocketOptions
 import net.i2p.client.streaming.I2PSocketManager.DisconnectListener
 import net.i2p.crypto.DSAEngine
-import net.i2p.crypto.SigType
 import net.i2p.data.Destination
 import net.i2p.data.PrivateKey
 import net.i2p.data.Signature
@@ -74,68 +111,93 @@ public class Core {
 
     final EventBus eventBus
     final Persona me
+    final String version;
     final File home
     final Properties i2pOptions
     final MuWireSettings muOptions
 
-    private final TrustService trustService
-    private final TrustSubscriber trustSubscriber
+    final I2PSession i2pSession;
+    private I2PSocketManager i2pSocketManager
+    final TrustService trustService
+    final TrustSubscriber trustSubscriber
     private final PersisterService persisterService
-    private final HostCache hostCache
-    private final ConnectionManager connectionManager
+    private final PersisterFolderService persisterFolderService
+    final HostCache hostCache
+    final ConnectionManager connectionManager
     private final CacheClient cacheClient
     private final UpdateClient updateClient
-    private final ConnectionAcceptor connectionAcceptor
+    final ConnectionAcceptor connectionAcceptor
     private final ConnectionEstablisher connectionEstablisher
     private final HasherService hasherService
-    private final DownloadManager downloadManager
+    final DownloadManager downloadManager
     private final DirectoryWatcher directoryWatcher
     final FileManager fileManager
     final UploadManager uploadManager
     final ContentManager contentManager
+    final CertificateManager certificateManager
+    final ChatServer chatServer
+    final ChatManager chatManager
+    final FeedManager feedManager
+    private final FeedClient feedClient
+    private final WatchedDirectoryConverter watchedDirectoryConverter
+    final WatchedDirectoryManager watchedDirectoryManager
+    private final TrackerResponder trackerResponder
 
     private final Router router
 
     final AtomicBoolean shutdown = new AtomicBoolean()
+    
+    final SigningPrivateKey spk
 
     public Core(MuWireSettings props, File home, String myVersion) {
         this.home = home
+        this.version = myVersion
         this.muOptions = props
 
         i2pOptions = new Properties()
-        def i2pOptionsFile = new File(home,"i2p.properties")
+        // Read defaults
+        def defaultI2PFile = getClass()
+                .getClassLoader().getResource("defaults/i2p.properties");
+        try {
+            defaultI2PFile.withInputStream { i2pOptions.load(it) }
+        } catch (ZipException mystery) {
+            log.log(Level.SEVERE, "couldn't load default i2p properties", mystery)
+        }
+
+        def i2pOptionsFile = new File(home, "i2p.properties")
         if (i2pOptionsFile.exists()) {
             i2pOptionsFile.withInputStream { i2pOptions.load(it) }
 
             if (!i2pOptions.containsKey("inbound.nickname"))
                 i2pOptions["inbound.nickname"] = "MuWire"
-                if (!i2pOptions.containsKey("outbound.nickname"))
-                    i2pOptions["outbound.nickname"] = "MuWire"
-        } else {
-            i2pOptions["inbound.nickname"] = "MuWire"
-            i2pOptions["outbound.nickname"] = "MuWire"
-            i2pOptions["inbound.length"] = "3"
-            i2pOptions["inbound.quantity"] = "4"
-            i2pOptions["outbound.length"] = "3"
-            i2pOptions["outbound.quantity"] = "4"
-            i2pOptions["i2cp.tcp.host"] = "127.0.0.1"
-            i2pOptions["i2cp.tcp.port"] = "7654"
+            if (!i2pOptions.containsKey("outbound.nickname"))
+                i2pOptions["outbound.nickname"] = "MuWire"
+        }
+        if (!(i2pOptions.containsKey("i2np.ntcp.port")
+                && i2pOptions.containsKey("i2np.udp.port")
+        )) {
             Random r = new Random()
-            int port = r.nextInt(60000) + 4000
+            int port = 9151 + r.nextInt(1 + 30777 - 9151)  // this range matches what the i2p router would choose
             i2pOptions["i2np.ntcp.port"] = String.valueOf(port)
             i2pOptions["i2np.udp.port"] = String.valueOf(port)
             i2pOptionsFile.withOutputStream { i2pOptions.store(it, "") }
         }
+        
+        i2pOptions['i2cp.leaseSetEncType']='4,0'
 
         if (!props.embeddedRouter) {
-            log.info "Initializing I2P context"
-            I2PAppContext.getGlobalContext().logManager()
-            I2PAppContext.getGlobalContext()._logManager = new MuWireLogManager()
-            router = null
+            if (!(I2PAppContext.getGlobalContext() instanceof RouterContext)) {
+                log.info "Initializing I2P context"
+                I2PAppContext.getGlobalContext().logManager()
+                I2PAppContext.getGlobalContext()._logManager = new MuWireLogManager()
+                router = null
+            }
         } else {
             log.info("launching embedded router")
             Properties routerProps = new Properties()
+            routerProps.setProperty("i2p.dir.base", home.getAbsolutePath())
             routerProps.setProperty("i2p.dir.config", home.getAbsolutePath())
+            routerProps.setProperty("geoip.dir", home.getAbsolutePath() + File.separator + "geoip")
             routerProps.setProperty("router.excludePeerCaps", "KLM")
             routerProps.setProperty("i2np.inboundKBytesPerSecond", String.valueOf(props.inBw))
             routerProps.setProperty("i2np.outboundKBytesPerSecond", String.valueOf(props.outBw))
@@ -162,18 +224,16 @@ public class Core {
 
 
         // options like tunnel length and quantity
-        I2PSession i2pSession
-        I2PSocketManager socketManager
         keyDat.withInputStream {
-            socketManager = new I2PSocketManagerFactory().createManager(it, i2pOptions["i2cp.tcp.host"], i2pOptions["i2cp.tcp.port"].toInteger(), i2pOptions)
+            i2pSocketManager = new I2PSocketManagerFactory().createDisconnectedManager(it, i2pOptions["i2cp.tcp.host"], i2pOptions["i2cp.tcp.port"].toInteger(), i2pOptions)
         }
-        socketManager.getDefaultOptions().setReadTimeout(60000)
-        socketManager.getDefaultOptions().setConnectTimeout(30000)
-        socketManager.addDisconnectListener({eventBus.publish(new RouterDisconnectedEvent())} as DisconnectListener)
-        i2pSession = socketManager.getSession()
+        i2pSocketManager.getDefaultOptions().setReadTimeout(60000)
+        i2pSocketManager.getDefaultOptions().setConnectTimeout(30000)
+        i2pSocketManager.addDisconnectListener({eventBus.publish(new RouterDisconnectedEvent())} as DisconnectListener)
+        i2pSession = i2pSocketManager.getSession()
 
         def destination = new Destination()
-        def spk = new SigningPrivateKey(Constants.SIG_TYPE)
+        spk = new SigningPrivateKey(Constants.SIG_TYPE)
         keyDat.withInputStream {
             destination.readBytes(it)
             def privateKey = new PrivateKey()
@@ -184,8 +244,9 @@ public class Core {
         def baos = new ByteArrayOutputStream()
         def daos = new DataOutputStream(baos)
         daos.write(Constants.PERSONA_VERSION)
-        daos.writeShort((short)props.getNickname().length())
-        daos.write(props.getNickname().getBytes(StandardCharsets.UTF_8))
+        byte [] name = props.getNickname().getBytes(StandardCharsets.UTF_8)
+        daos.writeShort((short)name.length)
+        daos.write(name)
         destination.writeBytes(daos)
         daos.flush()
         byte [] payload = baos.toByteArray()
@@ -199,6 +260,12 @@ public class Core {
 
         eventBus = new EventBus()
 
+        log.info("initializing certificate manager")
+        certificateManager = new CertificateManager(eventBus, home, me, spk)
+        eventBus.register(UICreateCertificateEvent.class, certificateManager)
+        eventBus.register(UIImportCertificateEvent.class, certificateManager)
+        
+        
         log.info("initializing trust service")
         File goodTrust = new File(home, "trusted")
         File badTrust = new File(home, "distrusted")
@@ -214,25 +281,46 @@ public class Core {
         eventBus.register(FileUnsharedEvent.class, fileManager)
         eventBus.register(SearchEvent.class, fileManager)
         eventBus.register(DirectoryUnsharedEvent.class, fileManager)
+        eventBus.register(UICommentEvent.class, fileManager)
+        eventBus.register(SideCarFileEvent.class, fileManager)
 
         log.info("initializing mesh manager")
         MeshManager meshManager = new MeshManager(fileManager, home, props)
         eventBus.register(SourceDiscoveredEvent.class, meshManager)
+        eventBus.register(SourceVerifiedEvent.class, meshManager)
 
         log.info "initializing persistence service"
         persisterService = new PersisterService(new File(home, "files.json"), eventBus, 60000, fileManager)
         eventBus.register(UILoadedEvent.class, persisterService)
 
+        log.info "initializing folder persistence service"
+        persisterFolderService = new PersisterFolderService(this, new File(home, "files"), eventBus)
+        eventBus.register(PersisterDoneEvent.class, persisterFolderService)
+        eventBus.register(FileDownloadedEvent.class, persisterFolderService)
+        eventBus.register(FileLoadedEvent.class, persisterFolderService)
+        eventBus.register(FileHashedEvent.class, persisterFolderService)
+        eventBus.register(FileUnsharedEvent.class, persisterFolderService)
+        eventBus.register(UICommentEvent.class, persisterFolderService)
+        eventBus.register(UIFilePublishedEvent.class, persisterFolderService)
+        eventBus.register(UIFileUnpublishedEvent.class, persisterFolderService)
+
         log.info("initializing host cache")
         File hostStorage = new File(home, "hosts.json")
         hostCache = new HostCache(trustService,hostStorage, 30000, props, i2pSession.getMyDestination())
         eventBus.register(HostDiscoveredEvent.class, hostCache)
         eventBus.register(ConnectionEvent.class, hostCache)
 
+        
+        log.info("initializing responder cache")
+        ResponderCache responderCache = new ResponderCache(props.responderCacheSize)
+        eventBus.register(UIResultBatchEvent.class, responderCache)
+        eventBus.register(SourceVerifiedEvent.class, responderCache)
+        
+        
         log.info("initializing connection manager")
         connectionManager = props.isLeaf() ?
             new LeafConnectionManager(eventBus, me, 3, hostCache, props) :
-            new UltrapeerConnectionManager(eventBus, me, 512, 512, hostCache, trustService, props)
+            new UltrapeerConnectionManager(eventBus, me, props.peerConnections, props.leafConnections, hostCache, responderCache, trustService, props)
         eventBus.register(TrustEvent.class, connectionManager)
         eventBus.register(ConnectionEvent.class, connectionManager)
         eventBus.register(DisconnectionEvent.class, connectionManager)
@@ -241,52 +329,92 @@ public class Core {
         log.info("initializing cache client")
         cacheClient = new CacheClient(eventBus,hostCache, connectionManager, i2pSession, props, 10000)
 
+        if (!(props.plugin || props.disableUpdates)) {
         log.info("initializing update client")
-        updateClient = new UpdateClient(eventBus, i2pSession, myVersion, props, fileManager, me)
-        eventBus.register(FileDownloadedEvent.class, updateClient)
-        eventBus.register(UIResultBatchEvent.class, updateClient)
+            updateClient = new UpdateClient(eventBus, i2pSession, myVersion, props, fileManager, me, spk)
+            eventBus.register(FileDownloadedEvent.class, updateClient)
+            eventBus.register(UIResultBatchEvent.class, updateClient)
+        } else
+            log.info("running as plugin or updates disabled, not initializing update client")
 
         log.info("initializing connector")
-        I2PConnector i2pConnector = new I2PConnector(socketManager)
+        I2PConnector i2pConnector = new I2PConnector(i2pSocketManager)
 
+        log.info("initializing certificate client")
+        CertificateClient certificateClient = new CertificateClient(eventBus, i2pConnector)
+        eventBus.register(UIFetchCertificatesEvent.class, certificateClient)
+        
+        log.info("initializing chat server")
+        chatServer = new ChatServer(eventBus, props, trustService, me, spk)
+        eventBus.with {
+            register(ChatMessageEvent.class, chatServer)
+            register(ChatDisconnectionEvent.class, chatServer)
+            register(TrustEvent.class, chatServer)
+        }
+        
+        log.info("initializing feed manager")
+        feedManager = new FeedManager(eventBus, home)
+        eventBus.with { 
+            register(FeedItemFetchedEvent.class, feedManager)
+            register(FeedFetchEvent.class, feedManager)
+            register(UIFeedConfigurationEvent.class, feedManager)
+            register(UIFeedDeletedEvent.class, feedManager)
+        }
+        
+        log.info("initializing feed client")
+        feedClient = new FeedClient(i2pConnector, eventBus, me, feedManager)
+        eventBus.register(UIFeedUpdateEvent.class, feedClient)
+        
         log.info "initializing results sender"
-        ResultsSender resultsSender = new ResultsSender(eventBus, i2pConnector, me)
+        ResultsSender resultsSender = new ResultsSender(eventBus, i2pConnector, me, props, certificateManager, chatServer)
 
         log.info "initializing search manager"
         SearchManager searchManager = new SearchManager(eventBus, me, resultsSender)
         eventBus.register(QueryEvent.class, searchManager)
         eventBus.register(ResultsEvent.class, searchManager)
 
+        log.info("initializing chat manager")
+        chatManager = new ChatManager(eventBus, me, i2pConnector, trustService, props)
+        eventBus.with { 
+            register(UIConnectChatEvent.class, chatManager)
+            register(UIDisconnectChatEvent.class, chatManager)
+            register(ChatMessageEvent.class, chatManager)
+            register(ChatDisconnectionEvent.class, chatManager)
+        }
+        
         log.info("initializing download manager")
-        downloadManager = new DownloadManager(eventBus, trustService, meshManager, props, i2pConnector, home, me)
+        downloadManager = new DownloadManager(eventBus, trustService, meshManager, props, i2pConnector, home, me, chatServer)
         eventBus.register(UIDownloadEvent.class, downloadManager)
+        eventBus.register(UIDownloadFeedItemEvent.class, downloadManager)
         eventBus.register(UILoadedEvent.class, downloadManager)
         eventBus.register(FileDownloadedEvent.class, downloadManager)
         eventBus.register(UIDownloadCancelledEvent.class, downloadManager)
         eventBus.register(SourceDiscoveredEvent.class, downloadManager)
         eventBus.register(UIDownloadPausedEvent.class, downloadManager)
         eventBus.register(UIDownloadResumedEvent.class, downloadManager)
+        eventBus.register(DownloadHopelessEvent.class, downloadManager)
 
         log.info("initializing upload manager")
-        uploadManager = new UploadManager(eventBus, fileManager, meshManager, downloadManager)
+        uploadManager = new UploadManager(eventBus, fileManager, meshManager, downloadManager, persisterFolderService, props)
+        
+        log.info("initializing tracker responder")
+        trackerResponder = new TrackerResponder(i2pSession, props, fileManager, downloadManager, meshManager, trustService, me)
 
         log.info("initializing connection establisher")
         connectionEstablisher = new ConnectionEstablisher(eventBus, i2pConnector, props, connectionManager, hostCache)
 
         log.info("initializing acceptor")
-        I2PAcceptor i2pAcceptor = new I2PAcceptor(socketManager)
+        I2PAcceptor i2pAcceptor = new I2PAcceptor(i2pSocketManager)
         connectionAcceptor = new ConnectionAcceptor(eventBus, connectionManager, props,
-            i2pAcceptor, hostCache, trustService, searchManager, uploadManager, connectionEstablisher)
+            i2pAcceptor, hostCache, trustService, searchManager, uploadManager, fileManager, connectionEstablisher,
+            certificateManager, chatServer)
 
-        log.info("initializing directory watcher")
-        directoryWatcher = new DirectoryWatcher(eventBus, fileManager)
-        eventBus.register(FileSharedEvent.class, directoryWatcher)
-        eventBus.register(AllFilesLoadedEvent.class, directoryWatcher)
-        eventBus.register(DirectoryUnsharedEvent.class, directoryWatcher)
 
         log.info("initializing hasher service")
-        hasherService = new HasherService(new FileHasher(), eventBus, fileManager)
+        hasherService = new HasherService(new FileHasher(), eventBus, fileManager, props)
         eventBus.register(FileSharedEvent.class, hasherService)
+        eventBus.register(FileUnsharedEvent.class, hasherService)
+        eventBus.register(DirectoryUnsharedEvent.class, hasherService)
 
         log.info("initializing trust subscriber")
         trustSubscriber = new TrustSubscriber(eventBus, i2pConnector, props)
@@ -297,9 +425,37 @@ public class Core {
         contentManager = new ContentManager()
         eventBus.register(ContentControlEvent.class, contentManager)
         eventBus.register(QueryEvent.class, contentManager)
+        
+        log.info("initializing browse manager")
+        BrowseManager browseManager = new BrowseManager(i2pConnector, eventBus, me)
+        eventBus.register(UIBrowseEvent.class, browseManager)
+        
+        log.info("initializing watched directory converter")
+        watchedDirectoryConverter = new WatchedDirectoryConverter(this)
+        eventBus.register(AllFilesLoadedEvent.class, watchedDirectoryConverter)
+        
+        log.info("initializing watched directory manager")
+        watchedDirectoryManager = new WatchedDirectoryManager(home, eventBus, fileManager)
+        eventBus.with { 
+            register(WatchedDirectoryConfigurationEvent.class, watchedDirectoryManager)
+            register(WatchedDirectoryConvertedEvent.class, watchedDirectoryManager)
+            register(FileSharedEvent.class, watchedDirectoryManager)
+            register(DirectoryUnsharedEvent.class, watchedDirectoryManager)
+            register(UISyncDirectoryEvent.class, watchedDirectoryManager)
+        }
+        
+        log.info("initializing directory watcher")
+        directoryWatcher = new DirectoryWatcher(eventBus, fileManager, home, watchedDirectoryManager)
+        eventBus.with {
+            register(DirectoryWatchedEvent.class, directoryWatcher)
+            register(WatchedDirectoryConvertedEvent.class, directoryWatcher)
+            register(DirectoryUnsharedEvent.class, directoryWatcher)
+            register(WatchedDirectoryConfigurationEvent.class, directoryWatcher)
+        }
     }
 
     public void startServices() {
+        i2pSession.connect()
         hasherService.start()
         trustService.start()
         trustService.waitForLoad()
@@ -309,7 +465,10 @@ public class Core {
         connectionAcceptor.start()
         connectionEstablisher.start()
         hostCache.waitForLoad()
-        updateClient.start()
+        updateClient?.start()
+        feedManager.start()
+        feedClient.start()
+        trackerResponder.start()
     }
 
     public void shutdown() {
@@ -317,24 +476,65 @@ public class Core {
             log.info("already shutting down")
             return
         }
+        log.info("saving settings")
+        saveMuSettings()
+        log.info("shutting down host cache")
+        hostCache.stop()
         log.info("shutting down trust subscriber")
         trustSubscriber.stop()
-        log.info("shutting down download manageer")
+        log.info("shutting down trust service")
+        trustService.stop()
+        log.info("shutting down persister service")
+        persisterService.stop()
+        log.info("shutting down persisterFolder service")
+        persisterFolderService.stop()
+        log.info("shutting down download manager")
         downloadManager.shutdown()
-        log.info("shutting down connection acceeptor")
+        log.info("shutting down connection acceptor")
         connectionAcceptor.stop()
         log.info("shutting down connection establisher")
         connectionEstablisher.stop()
         log.info("shutting down directory watcher")
         directoryWatcher.stop()
+        log.info("shutting down watch directory manager")
+        watchedDirectoryManager.shutdown()
         log.info("shutting down cache client")
         cacheClient.stop()
+        log.info("shutting down chat server")
+        chatServer.stop()
+        log.info("shutting down chat manager")
+        chatManager.shutdown()
+        log.info("shutting down feed manager")
+        feedManager.stop()
+        log.info("shutting down feed client")
+        feedClient.stop()
+        log.info("shutting down tracker responder")
+        trackerResponder.stop()
         log.info("shutting down connection manager")
         connectionManager.shutdown()
+        if (updateClient != null) {
+            log.info("shutting down update client")
+            updateClient.stop()
+        }
+        log.info("killing socket manager")
+        i2pSocketManager.destroySocketManager()
         if (router != null) {
             log.info("shutting down embedded router")
             router.shutdown(0)
         }
+        log.info("shutting down event bus");
+        eventBus.shutdown()
+        log.info("shutdown complete")
+    }
+    
+    public void saveMuSettings() {
+        File f = new File(home, "MuWire.properties")
+        f.withPrintWriter("UTF-8", { muOptions.write(it) })
+    }
+    
+    public void saveI2PSettings() {
+        File f = new File(home, "i2p.properties")
+        f.withOutputStream { i2pOptions.store(it, "I2P Options") }
     }
 
     static main(args) {
@@ -361,7 +561,7 @@ public class Core {
             }
         }
 
-        Core core = new Core(props, home, "0.4.11")
+        Core core = new Core(props, home, "0.7.4")
         core.startServices()
 
         // ... at the end, sleep or execute script

core/src/main/groovy/com/muwire/core/EventBus.groovy

@@ -2,6 +2,7 @@ package com.muwire.core
 
 import java.util.concurrent.CopyOnWriteArrayList
 import java.util.concurrent.Executor
+import java.util.concurrent.ExecutorService
 import java.util.concurrent.Executors
 import java.util.logging.Level
 
@@ -12,7 +13,7 @@ import groovy.util.logging.Log
 class EventBus {
 
     private Map handlers = new HashMap()
-    private final Executor executor = Executors.newSingleThreadExecutor {r ->
+    private final ExecutorService executor = Executors.newSingleThreadExecutor {r ->
         def rv = new Thread(r)
         rv.setDaemon(true)
         rv.setName("event-bus")
@@ -53,4 +54,8 @@ class EventBus {
         log.info("Unregistering $handler for type $eventType")
         handlers[eventType]?.remove(handler)
     }
+    
+    void shutdown() {
+        executor.shutdownNow()
+    }
 }

core/src/main/groovy/com/muwire/core/MuWireSettings.groovy

@@ -6,30 +6,62 @@ import com.muwire.core.hostcache.CrawlerResponse
 import com.muwire.core.util.DataUtil
 
 import net.i2p.data.Base64
+import net.i2p.util.ConcurrentHashSet
 
 class MuWireSettings {
 
     final boolean isLeaf
     boolean allowUntrusted
+    boolean searchExtraHop
     boolean allowTrustLists
     int trustListInterval
     Set<Persona> trustSubscriptions
-    int downloadRetryInterval
+    int downloadRetryInterval, downloadMaxFailures
+    int totalUploadSlots
+    int uploadSlotsPerUser
     int updateCheckInterval
+    long lastUpdateCheck
     boolean autoDownloadUpdate
     String updateType
     String nickname
     File downloadLocation
+    File incompleteLocation
     CrawlerResponse crawlerResponse
     boolean shareDownloadedFiles
+    boolean shareHiddenFiles
+    boolean searchComments
+    boolean browseFiles
+    boolean allowTracking
+    
+    boolean fileFeed
+    boolean advertiseFeed
+    boolean autoPublishSharedFiles
+    boolean defaultFeedAutoDownload
+    long defaultFeedUpdateInterval
+    int defaultFeedItemsToKeep
+    boolean defaultFeedSequential
+    
+    int peerConnections
+    int leafConnections
+    
+    int responderCacheSize
+    
+    boolean startChatServer
+    int maxChatConnections
+    boolean advertiseChat
+    File chatWelcomeFile
     Set<String> watchedDirectories
     float downloadSequentialRatio
-    int hostClearInterval
+    int hostClearInterval, hostHopelessInterval, hostRejectInterval, hostHopelessPurgeInterval
     int meshExpiration
+    int speedSmoothSeconds
     boolean embeddedRouter
+    boolean plugin
+    boolean disableUpdates
     int inBw, outBw
     Set<String> watchedKeywords
     Set<String> watchedRegexes
+    Set<String> negativeFileTree
 
     MuWireSettings() {
         this(new Properties())
@@ -38,27 +70,69 @@ class MuWireSettings {
     MuWireSettings(Properties props) {
         isLeaf = Boolean.valueOf(props.get("leaf","false"))
         allowUntrusted = Boolean.valueOf(props.getProperty("allowUntrusted","true"))
+        searchExtraHop = Boolean.valueOf(props.getProperty("searchExtraHop","false"))
         allowTrustLists = Boolean.valueOf(props.getProperty("allowTrustLists","true"))
         trustListInterval = Integer.valueOf(props.getProperty("trustListInterval","1"))
         crawlerResponse = CrawlerResponse.valueOf(props.get("crawlerResponse","REGISTERED"))
         nickname = props.getProperty("nickname","MuWireUser")
         downloadLocation = new File((String)props.getProperty("downloadLocation",
             System.getProperty("user.home")))
-        downloadRetryInterval = Integer.parseInt(props.getProperty("downloadRetryInterval","1"))
+        String incompleteLocationProp = props.getProperty("incompleteLocation")
+        if (incompleteLocationProp != null)
+            incompleteLocation = new File(incompleteLocationProp)
+        downloadRetryInterval = Integer.parseInt(props.getProperty("downloadRetryInterval","60"))
+        downloadMaxFailures = Integer.parseInt(props.getProperty("downloadMaxFailures","10"))
         updateCheckInterval = Integer.parseInt(props.getProperty("updateCheckInterval","24"))
+        lastUpdateCheck = Long.parseLong(props.getProperty("lastUpdateChec","0"))
         autoDownloadUpdate = Boolean.parseBoolean(props.getProperty("autoDownloadUpdate","true"))
         updateType = props.getProperty("updateType","jar")
         shareDownloadedFiles = Boolean.parseBoolean(props.getProperty("shareDownloadedFiles","true"))
+        shareHiddenFiles = Boolean.parseBoolean(props.getProperty("shareHiddenFiles","false"))
         downloadSequentialRatio = Float.valueOf(props.getProperty("downloadSequentialRatio","0.8"))
-        hostClearInterval = Integer.valueOf(props.getProperty("hostClearInterval","60"))
+        hostClearInterval = Integer.valueOf(props.getProperty("hostClearInterval","15"))
+        hostHopelessInterval = Integer.valueOf(props.getProperty("hostHopelessInterval", "60"))
+        hostRejectInterval = Integer.valueOf(props.getProperty("hostRejectInterval", "1"))
+        hostHopelessPurgeInterval = Integer.valueOf(props.getProperty("hostHopelessPurgeInterval","1440"))
         meshExpiration = Integer.valueOf(props.getProperty("meshExpiration","60"))
         embeddedRouter = Boolean.valueOf(props.getProperty("embeddedRouter","false"))
+        plugin = Boolean.valueOf(props.getProperty("plugin","false"))
+        disableUpdates = Boolean.valueOf(props.getProperty("disableUpdates","false"))
         inBw = Integer.valueOf(props.getProperty("inBw","256"))
         outBw = Integer.valueOf(props.getProperty("outBw","128"))
-
-        watchedDirectories = readEncodedSet(props, "watchedDirectories")
-        watchedKeywords = readEncodedSet(props, "watchedKeywords")
-        watchedRegexes = readEncodedSet(props, "watchedRegexes")
+        searchComments = Boolean.valueOf(props.getProperty("searchComments","true"))
+        browseFiles = Boolean.valueOf(props.getProperty("browseFiles","true"))
+        allowTracking = Boolean.valueOf(props.getProperty("allowTracking","true"))
+        
+        // feed settings
+        fileFeed = Boolean.valueOf(props.getProperty("fileFeed","true"))
+        advertiseFeed = Boolean.valueOf(props.getProperty("advertiseFeed","true"))
+        autoPublishSharedFiles = Boolean.valueOf(props.getProperty("autoPublishSharedFiles", "false"))
+        defaultFeedAutoDownload = Boolean.valueOf(props.getProperty("defaultFeedAutoDownload", "false"))
+        defaultFeedItemsToKeep = Integer.valueOf(props.getProperty("defaultFeedItemsToKeep", "1000"))
+        defaultFeedSequential = Boolean.valueOf(props.getProperty("defaultFeedSequential", "false"))
+        defaultFeedUpdateInterval = Long.valueOf(props.getProperty("defaultFeedUpdateInterval", "3600000"))
+        
+        // ultrapeer connection settings
+        leafConnections = Integer.valueOf(props.getProperty("leafConnections","512"))
+        peerConnections = Integer.valueOf(props.getProperty("peerConnections","128"))
+        
+        // responder cache settings
+        responderCacheSize = Integer.valueOf(props.getProperty("responderCacheSize","32"))
+        
+        speedSmoothSeconds = Integer.valueOf(props.getProperty("speedSmoothSeconds","10"))
+        totalUploadSlots = Integer.valueOf(props.getProperty("totalUploadSlots","-1"))
+        uploadSlotsPerUser = Integer.valueOf(props.getProperty("uploadSlotsPerUser","-1"))
+        startChatServer = Boolean.valueOf(props.getProperty("startChatServer","false"))
+        maxChatConnections = Integer.valueOf(props.get("maxChatConnections", "-1"))
+        advertiseChat = Boolean.valueOf(props.getProperty("advertiseChat","true"))
+        String chatWelcomeProp = props.getProperty("chatWelcomeFile")
+        if (chatWelcomeProp != null)
+            chatWelcomeFile = new File(chatWelcomeProp)
+        
+        watchedDirectories = DataUtil.readEncodedSet(props, "watchedDirectories")
+        watchedKeywords = DataUtil.readEncodedSet(props, "watchedKeywords")
+        watchedRegexes = DataUtil.readEncodedSet(props, "watchedRegexes")
+        negativeFileTree = DataUtil.readEncodedSet(props, "negativeFileTree")
 
         trustSubscriptions = new HashSet<>()
         if (props.containsKey("trustSubscriptions")) {
@@ -70,30 +144,70 @@ class MuWireSettings {
         
     }
 
-    void write(OutputStream out) throws IOException {
+    void write(Writer out) throws IOException {
         Properties props = new Properties()
         props.setProperty("leaf", isLeaf.toString())
         props.setProperty("allowUntrusted", allowUntrusted.toString())
+        props.setProperty("searchExtraHop", String.valueOf(searchExtraHop))
         props.setProperty("allowTrustLists", String.valueOf(allowTrustLists))
         props.setProperty("trustListInterval", String.valueOf(trustListInterval))
         props.setProperty("crawlerResponse", crawlerResponse.toString())
         props.setProperty("nickname", nickname)
         props.setProperty("downloadLocation", downloadLocation.getAbsolutePath())
+        if (incompleteLocation != null)
+            props.setProperty("incompleteLocation", incompleteLocation.getAbsolutePath())
         props.setProperty("downloadRetryInterval", String.valueOf(downloadRetryInterval))
+        props.setProperty("downloadMaxFailures", String.valueOf(downloadMaxFailures))
         props.setProperty("updateCheckInterval", String.valueOf(updateCheckInterval))
+        props.setProperty("lastUpdateCheck", String.valueOf(lastUpdateCheck))
         props.setProperty("autoDownloadUpdate", String.valueOf(autoDownloadUpdate))
         props.setProperty("updateType",String.valueOf(updateType))
         props.setProperty("shareDownloadedFiles", String.valueOf(shareDownloadedFiles))
+        props.setProperty("shareHiddenFiles", String.valueOf(shareHiddenFiles))
         props.setProperty("downloadSequentialRatio", String.valueOf(downloadSequentialRatio))
         props.setProperty("hostClearInterval", String.valueOf(hostClearInterval))
+        props.setProperty("hostHopelessInterval", String.valueOf(hostHopelessInterval))
+        props.setProperty("hostRejectInterval", String.valueOf(hostRejectInterval))
+        props.setProperty("hostHopelessPurgeInterval", String.valueOf(hostHopelessPurgeInterval))
         props.setProperty("meshExpiration", String.valueOf(meshExpiration))
         props.setProperty("embeddedRouter", String.valueOf(embeddedRouter))
+        props.setProperty("plugin", String.valueOf(plugin))
+        props.setProperty("disableUpdates", String.valueOf(disableUpdates))
         props.setProperty("inBw", String.valueOf(inBw))
         props.setProperty("outBw", String.valueOf(outBw))
+        props.setProperty("searchComments", String.valueOf(searchComments))
+        props.setProperty("browseFiles", String.valueOf(browseFiles))
+        props.setProperty("allowTracking", String.valueOf(allowTracking))
+        
+        // feed settings
+        props.setProperty("fileFeed", String.valueOf(fileFeed))
+        props.setProperty("advertiseFeed", String.valueOf(advertiseFeed))
+        props.setProperty("autoPublishSharedFiles", String.valueOf(autoPublishSharedFiles))
+        props.setProperty("defaultFeedAutoDownload", String.valueOf(defaultFeedAutoDownload))
+        props.setProperty("defaultFeedItemsToKeep", String.valueOf(defaultFeedItemsToKeep))
+        props.setProperty("defaultFeedSequential", String.valueOf(defaultFeedSequential))
+        props.setProperty("defaultFeedUpdateInterval", String.valueOf(defaultFeedUpdateInterval))
+        
+        // ultrapeer connection settings
+        props.setProperty("peerConnections", String.valueOf(peerConnections))
+        props.setProperty("leafConnections", String.valueOf(leafConnections))
+        
+        // responder cache settings
+        props.setProperty("responderCacheSize", String.valueOf(responderCacheSize))
+        
+        props.setProperty("speedSmoothSeconds", String.valueOf(speedSmoothSeconds))
+        props.setProperty("totalUploadSlots", String.valueOf(totalUploadSlots))
+        props.setProperty("uploadSlotsPerUser", String.valueOf(uploadSlotsPerUser))
+        props.setProperty("startChatServer", String.valueOf(startChatServer))
+        props.setProperty("maxChatConnectios", String.valueOf(maxChatConnections))
+        props.setProperty("advertiseChat", String.valueOf(advertiseChat))
+        if (chatWelcomeFile != null)
+            props.setProperty("chatWelcomeFile", chatWelcomeFile.getAbsolutePath())
 
-        writeEncodedSet(watchedDirectories, "watchedDirectories", props)
-        writeEncodedSet(watchedKeywords, "watchedKeywords", props)
-        writeEncodedSet(watchedRegexes, "watchedRegexes", props)
+        DataUtil.writeEncodedSet(watchedDirectories, "watchedDirectories", props)
+        DataUtil.writeEncodedSet(watchedKeywords, "watchedKeywords", props)
+        DataUtil.writeEncodedSet(watchedRegexes, "watchedRegexes", props)
+        DataUtil.writeEncodedSet(negativeFileTree, "negativeFileTree", props)
 
         if (!trustSubscriptions.isEmpty()) {
             String encoded = trustSubscriptions.stream().
@@ -102,25 +216,7 @@ class MuWireSettings {
             props.setProperty("trustSubscriptions", encoded)
         }
 
-        props.store(out, "")
-    }
-    
-    private static Set<String> readEncodedSet(Properties props, String property) {
-        Set<String> rv = new HashSet<>()
-        if (props.containsKey(property)) {
-            String[] encoded = props.getProperty(property).split(",")
-            encoded.each { rv << DataUtil.readi18nString(Base64.decode(it)) }
-        }
-        rv
-    }
-    
-    private static void writeEncodedSet(Set<String> set, String property, Properties props) {
-        if (set.isEmpty())
-            return
-        String encoded = set.stream().
-            map({Base64.encode(DataUtil.encodei18nString(it))}).
-            collect(Collectors.joining(","))
-        props.setProperty(property, encoded)
+        props.store(out, "This file is UTF-8")
     }
 
     boolean isLeaf() {

core/src/main/groovy/com/muwire/core/Name.groovy

@@ -1,45 +0,0 @@
-package com.muwire.core
-
-import java.nio.charset.StandardCharsets
-
-/**
- * A name of persona, file or search term
- */
-public class Name {
-    final String name
-
-    Name(String name) {
-        this.name = name
-    }
-
-    Name(InputStream nameStream) throws IOException {
-        DataInputStream dis = new DataInputStream(nameStream)
-        int length = dis.readUnsignedShort()
-        byte [] nameBytes = new byte[length]
-        dis.readFully(nameBytes)
-        this.name = new String(nameBytes, StandardCharsets.UTF_8)
-    }
-
-    public void write(OutputStream out) throws IOException {
-        DataOutputStream dos = new DataOutputStream(out)
-        dos.writeShort(name.length())
-        dos.write(name.getBytes(StandardCharsets.UTF_8))
-    }
-
-    public getName() {
-        name
-    }
-
-    @Override
-    public int hashCode() {
-        name.hashCode()
-    }
-
-    @Override
-    public boolean equals(Object o) {
-        if (!(o instanceof Name))
-            return false
-        Name other = (Name)o
-        name.equals(other.name)
-    }
-}

core/src/main/groovy/com/muwire/core/Persona.groovy

@@ -1,94 +0,0 @@
-package com.muwire.core
-
-import net.i2p.crypto.DSAEngine
-import net.i2p.crypto.SigType
-import net.i2p.data.Base64
-import net.i2p.data.Destination
-import net.i2p.data.Signature
-import net.i2p.data.SigningPublicKey
-
-public class Persona {
-    private static final int SIG_LEN = Constants.SIG_TYPE.getSigLen()
-
-    private final byte version
-    private final Name name
-    private final Destination destination
-    private final byte[] sig
-    private volatile String humanReadableName
-    private volatile String base64
-    private volatile byte[] payload
-
-    public Persona(InputStream personaStream) throws IOException, InvalidSignatureException {
-        version = (byte) (personaStream.read() & 0xFF)
-        if (version != Constants.PERSONA_VERSION)
-            throw new IOException("Unknown version "+version)
-
-        name = new Name(personaStream)
-        destination = Destination.create(personaStream)
-        sig = new byte[SIG_LEN]
-        DataInputStream dis = new DataInputStream(personaStream)
-        dis.readFully(sig)
-        if (!verify(version, name, destination, sig))
-            throw new InvalidSignatureException(getHumanReadableName() + " didn't verify")
-    }
-
-    private static boolean verify(byte version, Name name, Destination destination, byte [] sig) {
-        ByteArrayOutputStream baos = new ByteArrayOutputStream()
-        baos.write(version)
-        name.write(baos)
-        destination.writeBytes(baos)
-        byte[] payload = baos.toByteArray()
-        SigningPublicKey spk = destination.getSigningPublicKey()
-        Signature signature = new Signature(Constants.SIG_TYPE, sig)
-        DSAEngine.getInstance().verifySignature(signature, payload, spk)
-    }
-
-    public void write(OutputStream out) throws IOException {
-        if (payload == null) {
-            ByteArrayOutputStream baos = new ByteArrayOutputStream()
-            baos.write(version)
-            name.write(baos)
-            destination.writeBytes(baos)
-            baos.write(sig)
-            payload = baos.toByteArray()
-        }
-        out.write(payload)
-    }
-
-    public String getHumanReadableName() {
-        if (humanReadableName == null)
-            humanReadableName = name.getName() + "@" + destination.toBase32().substring(0,32)
-        humanReadableName
-    }
-
-    public String toBase64() {
-        if (base64 == null) {
-            def baos = new ByteArrayOutputStream()
-            write(baos)
-            base64 = Base64.encode(baos.toByteArray())
-        }
-        base64
-    }
-
-    @Override
-    public int hashCode() {
-        name.hashCode() ^ destination.hashCode()
-    }
-
-    @Override
-    public boolean equals(Object o) {
-        if (!(o instanceof Persona))
-            return false
-        Persona other = (Persona)o
-        name.equals(other.name) && destination.equals(other.destination)
-    }
-
-    public static void main(String []args) {
-        if (args.length != 1) {
-            println "This utility decodes a bas64-encoded persona"
-            System.exit(1)
-        }
-        Persona p = new Persona(new ByteArrayInputStream(Base64.decode(args[0])))
-        println p.getHumanReadableName()
-    }
-}

core/src/main/groovy/com/muwire/core/SplitPattern.groovy

@@ -0,0 +1,91 @@
+package com.muwire.core
+
+class SplitPattern {
+    
+    public static final String SPLIT_PATTERN = "[\\*\\+\\-,\\.:;\\(\\)=_/\\\\\\!\\\"\\\'\\\$%\\|\\[\\]\\{\\}\\?\r\n]";
+ 
+    private static final Set<Character> SPLIT_CHARS = new HashSet<>()
+    static {
+        SPLIT_CHARS.with { 
+            add(' '.toCharacter())
+            add('*'.toCharacter())
+            add('+'.toCharacter())
+            add('-'.toCharacter())
+            add(','.toCharacter())
+            add('.'.toCharacter())
+            add(':'.toCharacter())
+            add(';'.toCharacter())
+            add('('.toCharacter())
+            add(')'.toCharacter())
+            add('='.toCharacter())
+            add('_'.toCharacter())
+            add('/'.toCharacter())
+            add('\\'.toCharacter())
+            add('!'.toCharacter())
+            add('\''.toCharacter())
+            add('$'.toCharacter())
+            add('%'.toCharacter())
+            add('|'.toCharacter())
+            add('['.toCharacter())
+            add(']'.toCharacter())
+            add('{'.toCharacter())
+            add('}'.toCharacter())
+            add('?'.toCharacter())
+        }
+    }
+    
+    public static String[] termify(final String source) {
+        String lowercase = source.toLowerCase().trim()
+        
+        def rv = []
+        int pos = 0
+        int quote = -1
+        
+        StringBuilder tmp = new StringBuilder()
+        while(pos < lowercase.length()) {
+            char c = lowercase.charAt(pos++)
+            if (quote < 0 && c == '"') {
+                quote = pos - 1
+                continue
+            }
+            if (quote >= 0) {
+                if (c == '"') {
+                    quote = -1
+                    if (tmp.length() != 0) {
+                        rv << tmp.toString()
+                        tmp = new StringBuilder()
+                    }
+                } else
+                    tmp.append(c)
+            } else if (SPLIT_CHARS.contains(c)) {
+                if (tmp.length() != 0) {
+                    rv << tmp.toString()
+                    tmp = new StringBuilder()
+                }
+            } else
+                tmp.append c
+        }
+        
+        // check if odd number of quotes and re-tokenize from last quote
+        if (quote >= 0) {
+            tmp = new StringBuilder()
+            pos = quote + 1
+            while(pos < lowercase.length()) {
+                char c = lowercase.charAt(pos++)
+                if (SPLIT_CHARS.contains(c)) {
+                    if (tmp.length() > 0) {
+                        rv << tmp.toString()
+                        tmp = new StringBuilder()
+                    }
+                } else
+                    tmp.append(c)
+            }
+        }
+        
+        if (tmp.length() > 0)
+            rv << tmp.toString()
+        
+        rv
+    }   
+    
+}

core/src/main/groovy/com/muwire/core/chat/ChatAction.java

@@ -0,0 +1,24 @@
+package com.muwire.core.chat;
+
+enum ChatAction {
+    JOIN(true, false, true, false), 
+    LEAVE(false, false, true, false), 
+    SAY(false, false, true, false), 
+    LIST(true, true, true, false), 
+    HELP(true, true, true, false),
+    INFO(true, true, true, false),
+    JOINED(true, true, false, false),
+    TRUST(true, false, true, true),
+    DISTRUST(true, false, true, true);
+    
+    final boolean console;
+    final boolean stateless;
+    final boolean user;
+    final boolean local;
+    ChatAction(boolean console, boolean stateless, boolean user, boolean local) {
+        this.console = console;
+        this.stateless = stateless;
+        this.user = user;
+        this.local = local;
+    }
+}

core/src/main/groovy/com/muwire/core/chat/ChatClient.groovy

@@ -0,0 +1,141 @@
+package com.muwire.core.chat
+
+import java.nio.charset.StandardCharsets
+import java.util.concurrent.Executor
+import java.util.concurrent.Executors
+
+import com.muwire.core.Constants
+import com.muwire.core.EventBus
+import com.muwire.core.MuWireSettings
+import com.muwire.core.Persona
+import com.muwire.core.connection.Endpoint
+import com.muwire.core.connection.I2PConnector
+import com.muwire.core.trust.TrustService
+import com.muwire.core.util.DataUtil
+
+import groovy.util.logging.Log
+
+@Log
+class ChatClient implements Closeable {
+    
+    private static final long REJECTION_BACKOFF = 60 * 1000
+    
+    private static final Executor CONNECTOR = Executors.newCachedThreadPool()
+    
+    private final I2PConnector connector
+    private final EventBus eventBus
+    private final Persona host, me
+    private final TrustService trustService
+    private final MuWireSettings settings
+    
+    private ChatConnection connection
+    private boolean connectInProgress
+    private long lastRejectionTime
+    private Thread connectThread
+    
+    ChatClient(I2PConnector connector, EventBus eventBus, Persona host, Persona me, TrustService trustService,
+        MuWireSettings settings) {
+        this.connector = connector
+        this.eventBus = eventBus
+        this.host = host
+        this.me = me
+        this.trustService = trustService
+        this.settings = settings
+    }
+    
+    synchronized void connectIfNeeded() {
+        if (connection != null || connectInProgress || (System.currentTimeMillis() - lastRejectionTime < REJECTION_BACKOFF))
+            return
+        connectInProgress = true
+        CONNECTOR.execute({connect()})
+    }
+    
+    private void connect() {
+        synchronized(this) {
+            if (!connectInProgress)
+                return
+            connectThread = Thread.currentThread()
+        }
+        Endpoint endpoint = null
+        try {
+            eventBus.publish(new ChatConnectionEvent(status : ChatConnectionAttemptStatus.CONNECTING, persona : host))
+            endpoint = connector.connect(host.destination)
+            DataOutputStream dos = new DataOutputStream(endpoint.getOutputStream())
+            DataInputStream dis = new DataInputStream(endpoint.getInputStream())
+            
+            dos.with {
+                write("IRC\r\n".getBytes(StandardCharsets.US_ASCII))
+                write("Version:${Constants.CHAT_VERSION}\r\n".getBytes(StandardCharsets.US_ASCII))
+                write("Persona:${me.toBase64()}\r\n".getBytes(StandardCharsets.US_ASCII))
+                write("\r\n".getBytes(StandardCharsets.US_ASCII))
+                flush()
+            }
+                
+            String codeString = DataUtil.readTillRN(dis)
+            int code = Integer.parseInt(codeString.split(" ")[0])
+            
+            if (code == 429) {
+                eventBus.publish(new ChatConnectionEvent(status : ChatConnectionAttemptStatus.REJECTED, persona : host))
+                try { dos.close() } catch (IOException ignore) {}
+                endpoint.close()
+                synchronized(this) {
+                    lastRejectionTime = System.currentTimeMillis()
+                }
+                return
+            }
+            
+            if (code != 200) 
+                throw new Exception("unknown code $code")
+
+            Map<String,String> headers = DataUtil.readAllHeaders(dis)
+            if (!headers.containsKey('Version'))
+                throw new Exception("Version header missing")
+            
+            int version = Integer.parseInt(headers['Version'])
+            if (version != Constants.CHAT_VERSION)
+                throw new Exception("Unknown chat version $version")
+            
+            synchronized(this) {
+                if (!connectInProgress)
+                    return
+                connection = new ChatConnection(eventBus, endpoint, host, false, trustService, settings)
+                connection.start()
+            }
+            eventBus.publish(new ChatConnectionEvent(status : ChatConnectionAttemptStatus.SUCCESSFUL, persona : host, 
+                connection : connection))
+        } catch (Exception e) {
+            log.log(java.util.logging.Level.WARNING, "connect failed", e)
+            eventBus.publish(new ChatConnectionEvent(status : ChatConnectionAttemptStatus.FAILED, persona : host))
+            if (endpoint != null) {
+                try {endpoint.getOutputStream().close() } catch (IOException ignore) {}
+                endpoint.close()
+            }
+        } finally {
+            synchronized(this) {
+                connectInProgress = false
+                connectThread = null
+            }
+        }
+    }
+    
+    synchronized void disconnected() {
+        connectInProgress = false
+        connection = null
+    }
+    
+    @Override
+    synchronized public void close() {
+        connectInProgress = false
+        connectThread?.interrupt()
+        connection?.close()
+        eventBus.publish(new ChatConnectionEvent(status : ChatConnectionAttemptStatus.DISCONNECTED, persona : host))
+    }
+    
+    synchronized void ping() {
+        connection?.sendPing()
+    }
+    
+    synchronized void sendChat(ChatMessageEvent e) {
+        connection?.sendChat(e)
+    }
+}

core/src/main/groovy/com/muwire/core/chat/ChatCommand.groovy

@@ -0,0 +1,28 @@
+package com.muwire.core.chat
+
+class ChatCommand {
+    private final ChatAction action
+    private final String payload
+    final String source
+    ChatCommand(String source) {
+        if (source.charAt(0) != '/')
+            throw new Exception("command doesn't start with / $source")
+        
+        int position = 1
+        StringBuilder sb = new StringBuilder()
+        while(position < source.length()) {
+            char c = source.charAt(position)
+            if (c == ' ')
+                break
+            sb.append(c)
+            position++    
+        }
+        String command = sb.toString().toUpperCase()
+        action = ChatAction.valueOf(command)
+        if (position < source.length())
+            payload = source.substring(position + 1)
+        else
+            payload = ""
+        this.source = source
+    }
+}

core/src/main/groovy/com/muwire/core/chat/ChatConnection.groovy

@@ -0,0 +1,280 @@
+package com.muwire.core.chat
+
+import java.nio.charset.StandardCharsets
+import java.util.concurrent.BlockingQueue
+import java.util.concurrent.LinkedBlockingQueue
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.logging.Level
+
+import com.muwire.core.Constants
+import com.muwire.core.EventBus
+import com.muwire.core.MuWireSettings
+import com.muwire.core.Persona
+import com.muwire.core.connection.Endpoint
+import com.muwire.core.trust.TrustLevel
+import com.muwire.core.trust.TrustService
+
+import groovy.json.JsonOutput
+import groovy.json.JsonSlurper
+import groovy.util.logging.Log
+import net.i2p.crypto.DSAEngine
+import net.i2p.data.Base64
+import net.i2p.data.Signature
+import net.i2p.data.SigningPrivateKey
+
+@Log
+class ChatConnection implements ChatLink {
+    
+    private static final long PING_INTERVAL = 20000
+    private static final long MAX_CHAT_AGE = 5 * 60 * 1000
+    
+    private final EventBus eventBus
+    private final Endpoint endpoint
+    private final Persona persona
+    private final boolean incoming
+    private final TrustService trustService
+    private final MuWireSettings settings
+    
+    private final AtomicBoolean running = new AtomicBoolean()
+    private final BlockingQueue messages = new LinkedBlockingQueue()
+    private final Thread reader, writer
+    private final LinkedList<Long> timestamps = new LinkedList<>()
+    private final BlockingQueue incomingEvents = new LinkedBlockingQueue()
+    
+    private final DataInputStream dis
+    private final DataOutputStream dos
+    
+    private final JsonSlurper slurper = new JsonSlurper()
+    
+    private volatile long lastPingSentTime
+    
+    ChatConnection(EventBus eventBus, Endpoint endpoint, Persona persona, boolean incoming,
+        TrustService trustService, MuWireSettings settings) {
+        this.eventBus = eventBus
+        this.endpoint = endpoint
+        this.persona = persona
+        this.incoming = incoming
+        this.trustService = trustService
+        this.settings = settings
+        
+        this.dis = new DataInputStream(endpoint.getInputStream())
+        this.dos = new DataOutputStream(endpoint.getOutputStream())
+
+        this.reader = new Thread({readLoop()} as Runnable)
+        this.reader.setName("reader-${persona.getHumanReadableName()}")
+        this.reader.setDaemon(true)
+        
+        this.writer = new Thread({writeLoop()} as Runnable)
+        this.writer.setName("writer-${persona.getHumanReadableName()}")
+        this.writer.setDaemon(true)        
+    }
+    
+    void start() {
+        if (!running.compareAndSet(false, true)) {
+            log.log(Level.WARNING,"${persona.getHumanReadableName()} already running", new Exception())
+            return
+        }
+        reader.start()
+        writer.start()
+    }
+    
+    @Override
+    public boolean isUp() {
+        running.get()
+    }
+    
+    @Override
+    public Persona getPersona() {
+        persona
+    }
+    
+    @Override
+    public void close() {
+        if (!running.compareAndSet(true, false)) {
+            log.log(Level.WARNING,"${persona.getHumanReadableName()} already closed", new Exception())
+            return
+        }
+        log.info("Closing "+persona.getHumanReadableName())
+        reader.interrupt()
+        writer.interrupt()
+        endpoint.close()
+        eventBus.publish(new ChatDisconnectionEvent(persona : persona))
+    }
+    
+    private void readLoop() {
+        try {
+            while(running.get())
+                read()
+        } catch( InterruptedException | SocketTimeoutException ignored) {
+        } catch (Exception e) {
+          log.log(Level.WARNING,"unhandled exception in reader", e)  
+        } finally {
+            try {endpoint.getOutputStream().close()} catch (IOException ignore) {}
+            close()
+        }
+    }
+    
+    private void writeLoop() {
+        try {
+            while(running.get()) {
+                def message = messages.take()
+                write(message)
+            }
+        } catch (InterruptedException ignore) {
+        } catch (Exception e) {
+            log.log(Level.WARNING,"unhandled exception in writer",e)
+        } finally {
+            try {endpoint.getOutputStream().close()} catch (IOException ignore) {}
+            close()
+        }
+    }
+    
+    private void read() {
+        int length = dis.readUnsignedShort()
+        byte [] payload = new byte[length]
+        dis.readFully(payload)
+        def json = slurper.parse(payload)
+        if (json.type == null)
+            throw new Exception("missing json type")
+        switch(json.type) {
+            case "Ping" : break // just ignore
+            case "Chat" : handleChat(json); break
+            case "Leave": handleLeave(json); break
+            default :
+                throw new Exception("unknown json type ${json.type}")
+        }
+    }
+    
+    private void write(Object message) {
+        byte [] payload = JsonOutput.toJson(message).bytes
+        dos.with {
+            writeShort(payload.length)
+            write(payload)
+            flush()
+        }
+    }
+    
+    void sendPing() {
+        long now = System.currentTimeMillis()
+        if (now - lastPingSentTime < PING_INTERVAL)
+            return
+        def ping = [:]
+        ping.type = "Ping"
+        ping.version = 1
+        messages.put(ping)
+        lastPingSentTime = now
+    }
+    
+    private void handleChat(def json) {
+        UUID uuid = UUID.fromString(json.uuid)
+        Persona host = fromString(json.host)
+        Persona sender = fromString(json.sender)
+        long chatTime = json.chatTime
+        String room = json.room
+        String payload = json.payload
+        byte [] sig = Base64.decode(json.sig)
+        
+        if (!verify(uuid,host,sender,chatTime,room,payload,sig)) {
+            log.warning("chat didn't verify")
+            return
+        }
+        if (incoming) {
+            if (sender.destination != endpoint.destination) {
+                log.warning("Sender destination mismatch, dropping message")
+                return
+            }
+        } else {
+            if (host.destination != endpoint.destination) {
+                log.warning("Host destination mismatch, dropping message")
+                return
+            }
+        }
+        if (System.currentTimeMillis() - chatTime > MAX_CHAT_AGE) {
+            log.warning("Chat too old, dropping")
+            return
+        }
+        switch(trustService.getLevel(sender.destination)) {
+            case TrustLevel.TRUSTED : break
+            case TrustLevel.NEUTRAL :
+                if (!settings.allowUntrusted) 
+                    return
+                else
+                    break
+            case TrustLevel.DISTRUSTED :
+                return
+        }
+        def event = new ChatMessageEvent( uuid : uuid, payload : payload, sender : sender,
+            host : host, room : room, chatTime : chatTime, sig : sig)
+        eventBus.publish(event)
+        if (!incoming)
+            incomingEvents.put(event)
+    }
+    
+    private void handleLeave(def json) {
+        Persona leaver = fromString(json.persona)
+        eventBus.publish(new UserDisconnectedEvent(user : leaver, host : persona))
+        incomingEvents.put(leaver)
+    }
+    
+    private static Persona fromString(String base64) {
+        new Persona(new ByteArrayInputStream(Base64.decode(base64)))
+    }
+    
+    private static boolean verify(UUID uuid, Persona host, Persona sender, long chatTime, 
+        String room, String payload, byte []sig) {
+        ByteArrayOutputStream baos = new ByteArrayOutputStream()
+        DataOutputStream daos = new DataOutputStream(baos)
+        daos.write(uuid.toString().bytes)
+        host.write(daos)
+        sender.write(daos)
+        daos.writeLong(chatTime)
+        daos.write(room.getBytes(StandardCharsets.UTF_8))
+        daos.write(payload.getBytes(StandardCharsets.UTF_8))
+        daos.close()
+        byte [] signed = baos.toByteArray()
+        def spk = sender.destination.getSigningPublicKey()
+        def signature = new Signature(spk.getType(), sig)
+        DSAEngine.getInstance().verifySignature(signature, signed, spk)
+    }
+    
+    public static byte[] sign(UUID uuid, long chatTime, String room, String words, Persona sender, Persona host, SigningPrivateKey spk) {
+        ByteArrayOutputStream baos = new ByteArrayOutputStream()
+        DataOutputStream daos = new DataOutputStream(baos)
+        daos.with {
+            write(uuid.toString().bytes)
+            host.write(daos)
+            sender.write(daos)
+            writeLong(chatTime)
+            write(room.getBytes(StandardCharsets.UTF_8))
+            write(words.getBytes(StandardCharsets.UTF_8))
+            close()
+        }
+        byte [] payload = baos.toByteArray()
+        Signature sig = DSAEngine.getInstance().sign(payload, spk)
+        sig.getData()
+    }
+    
+    void sendChat(ChatMessageEvent e) {
+        def chat = [:]
+        chat.type = "Chat"
+        chat.uuid = e.uuid.toString()
+        chat.host = e.host.toBase64()
+        chat.sender = e.sender.toBase64()
+        chat.chatTime = e.chatTime
+        chat.room = e.room
+        chat.payload = e.payload
+        chat.sig = Base64.encode(e.sig)
+        messages.put(chat)
+    }
+    
+    void sendLeave(Persona p) {
+        def leave = [:]
+        leave.type = "Leave"
+        leave.persona = p.toBase64()
+        messages.put(leave)
+    }
+    
+    public Object nextEvent() {
+        incomingEvents.take()
+    }
+}

core/src/main/groovy/com/muwire/core/chat/ChatConnectionAttemptStatus.java

@@ -0,0 +1,5 @@
+package com.muwire.core.chat;
+
+public enum ChatConnectionAttemptStatus {
+    CONNECTING, SUCCESSFUL, REJECTED, FAILED, DISCONNECTED
+}

core/src/main/groovy/com/muwire/core/chat/ChatConnectionEvent.groovy

@@ -0,0 +1,14 @@
+package com.muwire.core.chat
+
+import com.muwire.core.Event
+import com.muwire.core.Persona
+
+class ChatConnectionEvent extends Event {
+    ChatConnectionAttemptStatus status
+    Persona persona
+    ChatLink connection
+    
+    public String toString() {
+        super.toString() + " " + persona.getHumanReadableName() + " " + status.toString()
+    }
+}

core/src/main/groovy/com/muwire/core/chat/ChatDisconnectionEvent.groovy

@@ -0,0 +1,8 @@
+package com.muwire.core.chat
+
+import com.muwire.core.Event
+import com.muwire.core.Persona
+
+class ChatDisconnectionEvent extends Event {
+    Persona persona
+}

core/src/main/groovy/com/muwire/core/chat/ChatLink.java

@@ -0,0 +1,14 @@
+package com.muwire.core.chat;
+
+import java.io.Closeable;
+
+import com.muwire.core.Persona;
+
+public interface ChatLink extends Closeable {
+    public Persona getPersona();
+    public boolean isUp();
+    public void sendChat(ChatMessageEvent e);
+    public void sendLeave(Persona p);
+    public void sendPing();
+    public Object nextEvent() throws InterruptedException;
+}

core/src/main/groovy/com/muwire/core/chat/ChatManager.groovy

@@ -0,0 +1,77 @@
+package com.muwire.core.chat
+
+import java.util.concurrent.ConcurrentHashMap
+
+import com.muwire.core.EventBus
+import com.muwire.core.MuWireSettings
+import com.muwire.core.Persona
+import com.muwire.core.connection.I2PConnector
+import com.muwire.core.trust.TrustService
+
+class ChatManager {
+    private final EventBus eventBus
+    private final Persona me
+    private final I2PConnector connector
+    private final TrustService trustService
+    private final MuWireSettings settings
+    
+    private final Map<Persona, ChatClient> clients = new ConcurrentHashMap<>()
+    
+    ChatManager(EventBus eventBus, Persona me, I2PConnector connector, TrustService trustService, 
+        MuWireSettings settings) {
+        this.eventBus = eventBus
+        this.me = me
+        this.connector = connector
+        this.trustService = trustService
+        this.settings = settings
+        
+        Timer timer = new Timer("chat-connector", true)
+        timer.schedule({connect()} as TimerTask, 1000, 1000)
+    }
+    
+    boolean isConnected(Persona p) {
+        clients.containsKey(p)
+    }
+    
+    void onUIConnectChatEvent(UIConnectChatEvent e) {
+        if (e.host == me) { 
+            eventBus.publish(new ChatConnectionEvent(status : ChatConnectionAttemptStatus.SUCCESSFUL, 
+                persona : me, connection : LocalChatLink.INSTANCE))
+        } else {
+            ChatClient client = new ChatClient(connector, eventBus, e.host, me, trustService, settings)
+            clients.put(e.host, client)
+        }
+    }
+    
+    void onUIDisconnectChatEvent(UIDisconnectChatEvent e) {
+        if (e.host == me)
+            return
+        ChatClient client = clients.remove(e.host)
+        client?.close()
+    }
+    
+    void onChatMessageEvent(ChatMessageEvent e) {
+        if (e.host == me) 
+            return
+        if (e.sender != me)
+            return
+        clients[e.host]?.sendChat(e)
+    }
+    
+    void onChatDisconnectionEvent(ChatDisconnectionEvent e) {
+        clients[e.persona]?.disconnected()
+    }
+    
+    private void connect() {
+        clients.each { k, v -> 
+            v.connectIfNeeded()
+            v.ping() 
+        }
+    }
+    
+    void shutdown() {
+        clients.each { k, v ->
+            v.close() 
+        }
+    }
+}

core/src/main/groovy/com/muwire/core/chat/ChatMessageEvent.groovy

@@ -0,0 +1,13 @@
+package com.muwire.core.chat
+
+import com.muwire.core.Event
+import com.muwire.core.Persona
+
+class ChatMessageEvent extends Event {
+    UUID uuid
+    String payload
+    Persona sender, host
+    String room
+    long chatTime
+    byte [] sig
+}

core/src/main/groovy/com/muwire/core/chat/ChatServer.groovy

@@ -0,0 +1,344 @@
+package com.muwire.core.chat
+
+import java.nio.charset.StandardCharsets
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.logging.Level
+import java.util.stream.Collectors
+
+import com.muwire.core.Constants
+import com.muwire.core.EventBus
+import com.muwire.core.MuWireSettings
+import com.muwire.core.Persona
+import com.muwire.core.connection.Endpoint
+import com.muwire.core.trust.TrustEvent
+import com.muwire.core.trust.TrustLevel
+import com.muwire.core.trust.TrustService
+import com.muwire.core.util.DataUtil
+
+import groovy.util.logging.Log
+import net.i2p.data.Base64
+import net.i2p.data.Destination
+import net.i2p.data.SigningPrivateKey
+import net.i2p.util.ConcurrentHashSet
+
+@Log
+class ChatServer {
+    public static final String CONSOLE = "__CONSOLE__"
+    private static final String DEFAULT_WELCOME = "Welcome to my chat server!  Type /HELP for list of available commands"
+    
+    private final EventBus eventBus
+    private final MuWireSettings settings
+    private final TrustService trustService
+    private final Persona me
+    private final SigningPrivateKey spk
+    
+    private final Map<Destination, ChatLink> connections = new ConcurrentHashMap()
+    private final Map<String, Set<Persona>> rooms = new ConcurrentHashMap<>()
+    private final Map<Persona, Set<String>> memberships = new ConcurrentHashMap<>()
+    private final Map<String, Persona> shortNames = new ConcurrentHashMap<>()
+    
+    private final AtomicBoolean running = new AtomicBoolean()
+    
+    ChatServer(EventBus eventBus, MuWireSettings settings, TrustService trustService, Persona me, SigningPrivateKey spk) {
+        this.eventBus = eventBus
+        this.settings = settings
+        this.trustService = trustService
+        this.me = me
+        this.spk = spk
+        
+        Timer timer = new Timer("chat-server-pinger", true)
+        timer.schedule({sendPings()} as TimerTask, 1000, 1000)
+    }
+    
+    public void start() {
+        if (!running.compareAndSet(false, true))
+            return
+        connections.put(me.destination, LocalChatLink.INSTANCE)
+        joinRoom(me, CONSOLE)
+        shortNames.put(me.getHumanReadableName(), me)
+        echo(getWelcome(),me.destination)
+    }
+    
+    public boolean isRunning() {
+        running.get()
+    }
+    
+    private String getWelcome() {
+        String welcome = DEFAULT_WELCOME
+        if (settings.chatWelcomeFile != null)
+            welcome = settings.chatWelcomeFile.text
+        "/SAY $welcome"
+    }
+    
+    private void sendPings() {
+        connections.each { k,v -> 
+            v.sendPing()
+        }
+    }
+    
+    public void handle(Endpoint endpoint) {
+        InputStream is = endpoint.getInputStream()
+        OutputStream os = endpoint.getOutputStream()
+        
+        Map<String, String> headers = DataUtil.readAllHeaders(is)
+        
+        if (!headers.containsKey("Version"))
+            throw new Exception("Version header missing")
+        
+        int version = Integer.parseInt(headers['Version'])
+        if (version != Constants.CHAT_VERSION)
+            throw new Exception("Unknown chat version $version")
+        
+        if (!headers.containsKey('Persona'))
+            throw new Exception("Persona header missing")
+        
+        Persona client = new Persona(new ByteArrayInputStream(Base64.decode(headers['Persona'])))
+        if (client.destination != endpoint.destination)
+            throw new Exception("Client destination mismatch")
+        
+        if (!running.get()) {
+            os.write("400 Chat Not Enabled\r\n\r\n".getBytes(StandardCharsets.US_ASCII))
+            os.close()
+            endpoint.close()
+            return
+        }
+        
+        if (connections.containsKey(client.destination) || connections.size() == settings.maxChatConnections) {
+            os.write("429 Rejected\r\n\r\n".getBytes(StandardCharsets.US_ASCII))
+            os.close()
+            endpoint.close()
+            return
+        }
+        
+        os.with { 
+            write("200 OK\r\n".getBytes(StandardCharsets.US_ASCII))
+            write("Version:${Constants.CHAT_VERSION}\r\n".getBytes(StandardCharsets.US_ASCII))
+            write("\r\n".getBytes(StandardCharsets.US_ASCII))
+            flush()
+        }
+        
+        ChatConnection connection = new ChatConnection(eventBus, endpoint, client, true, trustService, settings)
+        connections.put(endpoint.destination, connection)
+        joinRoom(client, CONSOLE)
+        shortNames.put(client.getHumanReadableName(), client)
+        connection.start()
+        echo(getWelcome(),connection.endpoint.destination)
+    }
+    
+    void onChatDisconnectionEvent(ChatDisconnectionEvent e) {
+        ChatConnection con = connections.remove(e.persona.destination)
+        if (con == null)
+            return
+            
+        Set<String> rooms = memberships.get(e.persona)
+        if (rooms != null) {
+            rooms.each { 
+                leaveRoom(e.persona, it)
+            }
+        }
+        shortNames.remove(e.persona.getHumanReadableName())
+        connections.each { k, v ->
+            v.sendLeave(e.persona)
+        }
+    }
+    
+    void onTrustEvent(TrustEvent e) {
+        if (e.level == TrustLevel.TRUSTED)
+            return
+        if (settings.allowUntrusted && e.level == TrustLevel.NEUTRAL)
+            return
+        
+        ChatConnection connection = connections.get(e.persona.destination)
+        connection?.close()
+    }
+    
+    private void joinRoom(Persona p, String room) {
+        Set<Persona> existing = rooms.get(room)
+        if (existing == null) {
+            existing = new ConcurrentHashSet<>()
+            rooms.put(room, existing)
+        }
+        existing.add(p)
+        
+        Set<String> membership = memberships.get(p)
+        if (membership == null) {
+            membership = new ConcurrentHashSet<>()
+            memberships.put(p, membership)
+        }
+        membership.add(room)
+    }
+    
+    private void leaveRoom(Persona p, String room) {
+        Set<Persona> existing = rooms.get(room)
+        if (existing == null) {
+            log.warning(p.getHumanReadableName() + " leaving room they hadn't joined")
+            return
+        }
+        existing.remove(p)
+        if (existing.isEmpty())
+            rooms.remove(room)
+            
+        Set<String> membership = memberships.get(p)
+        if (membership == null) {
+            log.warning(p.getHumanReadableName() + " didn't have any memberships")
+            return
+        }
+        membership.remove(room)
+        if (membership.isEmpty())
+            memberships.remove(p)
+    }
+    
+    void onChatMessageEvent(ChatMessageEvent e) {
+        if (e.host != me)
+            return
+        
+        ChatCommand command
+        try {
+            command = new ChatCommand(e.payload)
+        } catch (Exception badCommand) {
+            log.log(Level.WARNING, "bad chat command",badCommand)
+            return
+        }
+
+        if (command.action.console && e.room != CONSOLE) {
+            echo("/SAY ERROR: You can only execute that command in the chat console, not in a chat room.",
+                    e.sender.destination, e.room)
+            return
+        }
+        
+        if (!command.action.console && e.room == CONSOLE) {
+            echo("/SAY ERROR: You need to be in a chat room.  Type /LIST for list of rooms or /JOIN to join or create a room.",
+                    e.sender.destination)
+            return
+        }
+        
+        if (!command.action.user)
+            return
+        
+        if (command.action.local && e.sender != me)
+            return
+            
+        switch(command.action) {
+            case ChatAction.JOIN : processJoin(command.payload, e); break
+            case ChatAction.LEAVE : processLeave(e); break
+            case ChatAction.SAY : processSay(e); break
+            case ChatAction.LIST : processList(e.sender.destination); break
+            case ChatAction.INFO : processInfo(e.sender.destination); break
+            case ChatAction.HELP : processHelp(e.sender.destination); break
+            case ChatAction.TRUST : processTrust(command.payload, TrustLevel.TRUSTED); break
+            case ChatAction.DISTRUST : processTrust(command.payload, TrustLevel.DISTRUSTED); break
+        }
+    }
+    
+    private void processJoin(String room, ChatMessageEvent e) {
+        joinRoom(e.sender, room)
+        rooms[room].each { 
+            if (it == e.sender)
+                return
+            connections[it.destination].sendChat(e)
+        }
+        String payload = rooms[room].stream().filter({it != e.sender}).map({it.toBase64()})
+            .collect(Collectors.joining(","))
+        if (payload.length() == 0) {
+            return
+        }
+        payload = "/JOINED $payload"
+        long now = System.currentTimeMillis()
+        UUID uuid = UUID.randomUUID()
+        byte [] sig = ChatConnection.sign(uuid, now, room, payload, me, me, spk)
+        ChatMessageEvent echo = new ChatMessageEvent(
+            uuid : uuid,
+            payload : payload,
+            sender : me,
+            host : me,
+            room : room,
+            chatTime : now,
+            sig : sig
+            )
+        connections[e.sender.destination].sendChat(echo)
+    }
+    
+    private void processLeave(ChatMessageEvent e) {
+        leaveRoom(e.sender, e.room)
+        rooms.getOrDefault(e.room, []).each { 
+            if (it == e.sender)
+                return
+            connections[it.destination].sendChat(e)
+        }
+    }
+    
+    private void processSay(ChatMessageEvent e) {
+        if (rooms.containsKey(e.room)) {
+            // not a private message
+            rooms[e.room].each { 
+                if (it == e.sender)
+                    return
+                connections[it.destination].sendChat(e)
+            }
+        } else {
+            Persona target = new Persona(new ByteArrayInputStream(Base64.decode(e.room)))
+            connections[target.destination]?.sendChat(e)
+        }
+    }
+    
+    private void processList(Destination d) {
+        String roomList = rooms.keySet().stream().filter({it != CONSOLE}).collect(Collectors.joining("\n"))
+        roomList = "/SAY \nRoom List:\n"+roomList
+        echo(roomList, d)
+    }
+    
+    private void processInfo(Destination d) {
+        String info = "/SAY \nThe address of this server is\n========\n${me.toBase64()}\n========\nCopy/paste the above and share it\n"
+        String connectedUsers = memberships.keySet().stream().map({it.getHumanReadableName()}).collect(Collectors.joining("\n"))
+        info = "${info}\nConnected Users:\n$connectedUsers\n======="
+        echo(info, d)
+    }
+    
+    private void processHelp(Destination d) {
+        String help = """/SAY 
+            Available commands: /JOIN /LEAVE /SAY /LIST /INFO /TRUST /DISTRUST /HELP
+            /JOIN <room name>  - joins a room, or creates one if it does not exist.  You must type this in the console
+            /LEAVE             - leaves a room.  You must type this in the room you want to leave
+            /SAY               - optional, says something in the room you're in
+            /LIST              - lists the existing rooms on this server.  You must type this in the console
+            /INFO              - shows information about this server.  You must type this in the console
+            /TRUST <user>      - marks user as trusted.  This is only available to the server owner
+            /DISTRUST <user>   - marks user as distrusted.  This is only available to the server owner
+            /HELP              - prints this help message
+            """
+        echo(help, d)
+    }
+    
+    private void echo(String payload, Destination d, String room = CONSOLE) {
+        log.info "echoing $payload"
+        UUID uuid = UUID.randomUUID()
+        long now = System.currentTimeMillis()
+        byte [] sig = ChatConnection.sign(uuid, now, room, payload, me, me, spk)
+        ChatMessageEvent echo = new ChatMessageEvent(
+            uuid : uuid,
+            payload : payload,
+            sender : me,
+            host : me,
+            room : room,
+            chatTime : now,
+            sig : sig
+            )
+        connections[d]?.sendChat(echo)
+    }
+    
+    private void processTrust(String shortName, TrustLevel level) {
+        Persona p = shortNames.get(shortName)
+        if (p == null)
+            return
+        eventBus.publish(new TrustEvent(persona : p, level : level))
+    }
+    
+    void stop() {
+        if (running.compareAndSet(true, false)) {
+            connections.each { k, v ->
+                v.close()
+            }
+        }
+    }
+}

core/src/main/groovy/com/muwire/core/chat/LocalChatLink.groovy

@@ -0,0 +1,49 @@
+package com.muwire.core.chat
+
+import java.util.concurrent.BlockingQueue
+import java.util.concurrent.LinkedBlockingQueue
+
+import com.muwire.core.Persona
+
+import groovy.util.logging.Log
+
+@Log
+class LocalChatLink implements ChatLink {
+    
+    public static final LocalChatLink INSTANCE = new LocalChatLink()
+    
+    private final BlockingQueue messages = new LinkedBlockingQueue()
+
+    private LocalChatLink() {}
+    
+    @Override
+    public void close() throws IOException {
+    }
+
+    @Override
+    public void sendChat(ChatMessageEvent e) {
+        messages.put(e)
+    }
+
+    @Override
+    public void sendLeave(Persona p) {
+        messages.put(p)
+    }
+
+    @Override
+    public void sendPing() {}
+    
+    @Override
+    public Object nextEvent() {
+        messages.take()
+    }
+
+    @Override
+    public boolean isUp() {
+        true
+    }
+    
+    public Persona getPersona() {
+        null
+    }
+}

core/src/main/groovy/com/muwire/core/chat/UIConnectChatEvent.groovy

@@ -0,0 +1,8 @@
+package com.muwire.core.chat
+
+import com.muwire.core.Event
+import com.muwire.core.Persona
+
+class UIConnectChatEvent extends Event {
+    Persona host
+}

core/src/main/groovy/com/muwire/core/chat/UIDisconnectChatEvent.groovy

@@ -0,0 +1,8 @@
+package com.muwire.core.chat
+
+import com.muwire.core.Event
+import com.muwire.core.Persona
+
+class UIDisconnectChatEvent extends Event {
+    Persona host
+}

core/src/main/groovy/com/muwire/core/chat/UserDisconnectedEvent.groovy

@@ -0,0 +1,9 @@
+package com.muwire.core.chat
+
+import com.muwire.core.Event
+import com.muwire.core.Persona
+
+class UserDisconnectedEvent extends Event {
+    Persona user
+    Persona host
+}

core/src/main/groovy/com/muwire/core/connection/Connection.groovy

@@ -1,10 +1,17 @@
 package com.muwire.core.connection
 
+import java.nio.charset.StandardCharsets
 import java.util.concurrent.BlockingQueue
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.ExecutorService
+import java.util.concurrent.Executors
 import java.util.concurrent.LinkedBlockingQueue
+import java.util.concurrent.ThreadFactory
+import java.util.concurrent.TimeUnit
 import java.util.concurrent.atomic.AtomicBoolean
 import java.util.logging.Level
 
+import com.muwire.core.Constants
 import com.muwire.core.EventBus
 import com.muwire.core.MuWireSettings
 import com.muwire.core.Persona
@@ -16,12 +23,14 @@ import com.muwire.core.trust.TrustLevel
 import com.muwire.core.trust.TrustService
 
 import groovy.util.logging.Log
+import net.i2p.crypto.DSAEngine
 import net.i2p.data.Base64
 import net.i2p.data.Destination
+import net.i2p.data.Signature
 
 @Log
 abstract class Connection implements Closeable {
-
+    
     private static final int SEARCHES = 10
     private static final long INTERVAL = 1000
 
@@ -40,6 +49,8 @@ abstract class Connection implements Closeable {
     protected final String name
 
     long lastPingSentTime, lastPongReceivedTime
+    
+    private volatile UUID lastPingUUID
 
     Connection(EventBus eventBus, Endpoint endpoint, boolean incoming,
         HostCache hostCache, TrustService trustService, MuWireSettings settings) {
@@ -83,6 +94,7 @@ abstract class Connection implements Closeable {
         reader.interrupt()
         writer.interrupt()
         endpoint.close()
+        log.info("closed $name")
         eventBus.publish(new DisconnectionEvent(destination: endpoint.destination))
     }
 
@@ -91,6 +103,7 @@ abstract class Connection implements Closeable {
             while(running.get()) {
                 read()
             }
+        } catch (InterruptedException ok) {
         } catch (SocketTimeoutException e) {
         } catch (Exception e) {
             log.log(Level.WARNING,"unhandled exception in reader",e)
@@ -107,6 +120,7 @@ abstract class Connection implements Closeable {
                 def message = messages.take()
                 write(message)
             }
+        } catch (InterruptedException ok) {
         } catch (Exception e) {
             log.log(Level.WARNING, "unhandled exception in writer",e)
         } finally {
@@ -120,6 +134,8 @@ abstract class Connection implements Closeable {
         def ping = [:]
         ping.type = "Ping"
         ping.version = 1
+        lastPingUUID = UUID.randomUUID()
+        ping.uuid = lastPingUUID.toString()
         messages.put(ping)
         lastPingSentTime = System.currentTimeMillis()
     }
@@ -132,20 +148,30 @@ abstract class Connection implements Closeable {
         query.firstHop = e.firstHop
         query.keywords = e.searchEvent.getSearchTerms()
         query.oobInfohash = e.searchEvent.oobInfohash
+        query.searchComments = e.searchEvent.searchComments
+        query.compressedResults = e.searchEvent.compressedResults
         if (e.searchEvent.searchHash != null)
             query.infohash = Base64.encode(e.searchEvent.searchHash)
         query.replyTo = e.replyTo.toBase64()
         if (e.originator != null)
             query.originator = e.originator.toBase64()
+        if (e.sig != null)
+            query.sig = Base64.encode(e.sig)
+        if (e.queryTime > 0)
+            query.queryTime = e.queryTime
+        if (e.sig2 != null)
+            query.sig2 = Base64.encode(e.sig2)
         messages.put(query)
     }
 
-    protected void handlePing() {
+    protected void handlePing(def ping) {
         log.fine("$name received ping")
         def pong = [:]
         pong.type = "Pong"
         pong.version = 1
-        pong.pongs = hostCache.getGoodHosts(10).collect { d -> d.toBase64() }
+        if (ping.uuid != null)
+            pong.uuid = ping.uuid
+        pong.pongs = hostCache.getGoodHosts(2).collect { d -> d.toBase64() }
         messages.put(pong)
     }
 
@@ -154,7 +180,23 @@ abstract class Connection implements Closeable {
         lastPongReceivedTime = System.currentTimeMillis()
         if (pong.pongs == null)
             throw new Exception("Pong doesn't have pongs")
-        pong.pongs.each {
+            
+        if (lastPingUUID == null) {
+            log.fine "$name received an unexpected pong"
+            return
+        }
+        if (pong.uuid == null) {
+            log.fine "$name pong doesn't have uuid"
+            return
+        }
+        UUID pongUUID = UUID.fromString(pong.uuid)
+        if (pongUUID != lastPingUUID) {
+            log.fine "$name ping/pong uuid mismatch"
+            return
+        }
+        lastPingUUID = null
+        
+        pong.pongs.stream().limit(2).forEach {
             def dest = new Destination(it)
             eventBus.publish(new HostDiscoveredEvent(destination: dest))
         }
@@ -209,16 +251,74 @@ abstract class Connection implements Closeable {
         boolean oob = false
         if (search.oobInfohash != null)
             oob = search.oobInfohash
+        boolean searchComments = false
+        if (search.searchComments != null)
+            searchComments = search.searchComments
+        boolean compressedResults = false
+        if (search.compressedResults != null)
+            compressedResults = search.compressedResults
+        byte[] sig = null
+        if (search.sig != null) {
+            sig = Base64.decode(search.sig)
+            byte [] payload 
+            if (infohash != null)
+                payload = infohash
+            else 
+                payload =  String.join(" ",search.keywords).getBytes(StandardCharsets.UTF_8)
+            def spk = originator.destination.getSigningPublicKey()
+            def signature = new Signature(spk.getType(), sig)
+            if (!DSAEngine.getInstance().verifySignature(signature, payload, spk)) {
+                log.info("signature didn't match keywords")
+                return
+            } else
+                log.info("query signature verified")
+        } else {
+            log.info("no signature in query")
+            return
+        }
+        
+        byte[] sig2 = null        
+        long queryTime = 0
+        if (search.sig2 != null) {
+            if (search.queryTime == null) {
+                log.info("extended signature but no timestamp")
+                return
+            }
+            sig2 = Base64.decode(search.sig2)
+            queryTime = search.queryTime
+            byte [] payload = (search.uuid + String.valueOf(queryTime)).getBytes(StandardCharsets.US_ASCII)
+            def spk = originator.destination.getSigningPublicKey()
+            def signature = new Signature(spk.getType(), sig2)
+            if (!DSAEngine.getInstance().verifySignature(signature, payload, spk)) {
+                log.info("extended signature didn't match uuid and timestamp")
+                return
+            } else {
+                log.info("extended query signature verified")
+                if (queryTime < System.currentTimeMillis() - Constants.MAX_QUERY_AGE) {
+                    log.info("query too old")
+                    return
+                }
+            }
+        } else {
+            log.info("no extended signature in query")
+            return
+        }
 
         SearchEvent searchEvent = new SearchEvent(searchTerms : search.keywords,
                                             searchHash : infohash,
                                             uuid : uuid,
-                                            oobInfohash : oob)
+                                            oobInfohash : oob,
+                                            searchComments : searchComments,
+                                            compressedResults : compressedResults,
+                                            persona : originator)
         QueryEvent event = new QueryEvent ( searchEvent : searchEvent,
                                             replyTo : replyTo,
                                             originator : originator,
                                             receivedOn : endpoint.destination,
-                                            firstHop : search.firstHop )
+                                            firstHop : search.firstHop,
+                                            sig : sig,
+                                            queryTime : queryTime,
+                                            sig2 : sig2 )
         eventBus.publish(event)
 
     }

core/src/main/groovy/com/muwire/core/connection/ConnectionAcceptor.groovy

@@ -1,15 +1,26 @@
 package com.muwire.core.connection
 
 import java.nio.charset.StandardCharsets
+import java.nio.file.attribute.DosFileAttributes
 import java.util.concurrent.ExecutorService
 import java.util.concurrent.Executors
 import java.util.logging.Level
 import java.util.zip.DeflaterOutputStream
+import java.util.zip.GZIPInputStream
+import java.util.zip.GZIPOutputStream
 import java.util.zip.InflaterInputStream
 
+import com.muwire.core.Constants
 import com.muwire.core.EventBus
+import com.muwire.core.InfoHash
 import com.muwire.core.MuWireSettings
 import com.muwire.core.Persona
+import com.muwire.core.SharedFile
+import com.muwire.core.chat.ChatServer
+import com.muwire.core.filecert.Certificate
+import com.muwire.core.filecert.CertificateManager
+import com.muwire.core.filefeeds.FeedItems
+import com.muwire.core.files.FileManager
 import com.muwire.core.hostcache.HostCache
 import com.muwire.core.trust.TrustLevel
 import com.muwire.core.trust.TrustService
@@ -17,6 +28,7 @@ import com.muwire.core.upload.UploadManager
 import com.muwire.core.util.DataUtil
 import com.muwire.core.search.InvalidSearchResultException
 import com.muwire.core.search.ResultsParser
+import com.muwire.core.search.ResultsSender
 import com.muwire.core.search.SearchManager
 import com.muwire.core.search.UIResultBatchEvent
 import com.muwire.core.search.UIResultEvent
@@ -25,6 +37,7 @@ import com.muwire.core.search.UnexpectedResultsException
 import groovy.json.JsonOutput
 import groovy.json.JsonSlurper
 import groovy.util.logging.Log
+import net.i2p.data.Base64
 
 @Log
 class ConnectionAcceptor {
@@ -37,17 +50,23 @@ class ConnectionAcceptor {
     final TrustService trustService
     final SearchManager searchManager
     final UploadManager uploadManager
+    final FileManager fileManager
     final ConnectionEstablisher establisher
+    final CertificateManager certificateManager
+    final ChatServer chatServer
 
     final ExecutorService acceptorThread
     final ExecutorService handshakerThreads
 
     private volatile shutdown
+    
+    volatile int browsed
 
     ConnectionAcceptor(EventBus eventBus, UltrapeerConnectionManager manager,
         MuWireSettings settings, I2PAcceptor acceptor, HostCache hostCache,
         TrustService trustService, SearchManager searchManager, UploadManager uploadManager,
-        ConnectionEstablisher establisher) {
+        FileManager fileManager, ConnectionEstablisher establisher, CertificateManager certificateManager,
+        ChatServer chatServer) {
         this.eventBus = eventBus
         this.manager = manager
         this.settings = settings
@@ -55,8 +74,11 @@ class ConnectionAcceptor {
         this.hostCache = hostCache
         this.trustService = trustService
         this.searchManager = searchManager
+        this.fileManager = fileManager
         this.uploadManager = uploadManager
         this.establisher = establisher
+        this.certificateManager = certificateManager
+        this.chatServer = chatServer
 
         acceptorThread = Executors.newSingleThreadExecutor { r ->
             def rv = new Thread(r)
@@ -126,14 +148,32 @@ class ConnectionAcceptor {
                 case (byte)'P':
                     processPOST(e)
                     break
+                case (byte)'R':
+                    processRESULTS(e)
+                    break
                 case (byte)'T':
                     processTRUST(e)
                     break
+                case (byte)'B':
+                    processBROWSE(e)
+                    break
+                case (byte)'C':
+                    processCERTIFICATES(e)
+                    break
+                case (byte)'I':
+                    processIRC(e)
+                    break
+                case (byte)'F':
+                    processFEED(e)
+                    break
                 default:
                     throw new Exception("Invalid read $read")
             }
         } catch (Exception ex) {
             log.log(Level.WARNING, "incoming connection failed",ex)
+            try {
+                e.getOutputStream().close()
+            } catch (Exception ignore) {}
             e.close()
             eventBus.publish new ConnectionEvent(endpoint: e, incoming: true, leaf: null, status: ConnectionAttemptStatus.FAILED)
         }
@@ -182,7 +222,9 @@ class ConnectionAcceptor {
                 os.writeShort(json.bytes.length)
                 os.write(json.bytes)
             }
-            e.outputStream.flush()
+            try {
+                e.outputStream.close()
+            } catch (Exception ignored) {}
             e.close()
             eventBus.publish(new ConnectionEvent(endpoint: e, incoming: true, leaf: leaf, status: ConnectionAttemptStatus.REJECTED))
         }
@@ -229,7 +271,7 @@ class ConnectionAcceptor {
 
             Persona sender = new Persona(dis)
             if (sender.destination != e.getDestination())
-                throw new IOException("Sender destination mismatch expected $e.getDestination(), got $sender.destination")
+                throw new IOException("Sender destination mismatch expected ${e.getDestination()}, got $sender.destination")
             int nResults = dis.readUnsignedShort()
             UIResultEvent[] results = new UIResultEvent[nResults]
             for (int i = 0; i < nResults; i++) {
@@ -246,44 +288,306 @@ class ConnectionAcceptor {
             e.close()
         }
     }
+    
+    private void processRESULTS(Endpoint e) {
+        InputStream is = e.getInputStream()
+        DataInputStream dis = new DataInputStream(is)
+        byte[] esults = new byte[7]
+        dis.readFully(esults)
+        if (esults != "ESULTS ".getBytes(StandardCharsets.US_ASCII))
+            throw new IOException("Invalid RESULTS connection")
+            
+        JsonSlurper slurper = new JsonSlurper()
+        try {
+            String uuid = DataUtil.readTillRN(dis)
+            UUID resultsUUID = UUID.fromString(uuid)
+            if (!searchManager.hasLocalSearch(resultsUUID))
+                throw new UnexpectedResultsException(resultsUUID.toString())
+            
+            // parse all headers
+            Map<String,String> headers = DataUtil.readAllHeaders(is);
+            
+            if (!headers.containsKey("Sender"))
+                throw new IOException("No Sender header")
+            if (!headers.containsKey("Count"))
+                throw new IOException("No Count header")
+            
+            boolean chat = false
+            if (headers.containsKey('Chat'))
+                chat = Boolean.parseBoolean(headers['Chat'])
+            boolean feed = false
+            if (headers.containsKey('Feed'))
+                feed = Boolean.parseBoolean(headers['Feed'])
+                
+            byte [] personaBytes = Base64.decode(headers['Sender'])
+            Persona sender = new Persona(new ByteArrayInputStream(personaBytes))
+            if (sender.destination != e.getDestination())
+                throw new IOException("Sender destination mismatch expected ${e.getDestination()}, got $sender.destination")
+                
+            int nResults = Integer.parseInt(headers['Count'])
+            if (nResults > Constants.MAX_RESULTS)
+                throw new IOException("too many results $nResults")
+                
+            dis = new DataInputStream(new GZIPInputStream(dis))
+            UIResultEvent[] results = new UIResultEvent[nResults]
+            for (int i = 0; i < nResults; i++) {
+                int jsonSize = dis.readUnsignedShort()
+                byte [] payload = new byte[jsonSize]
+                dis.readFully(payload)
+                def json = slurper.parse(payload)
+                results[i] = ResultsParser.parse(sender, resultsUUID, json)
+                results[i].chat = chat
+                results[i].feed = feed
+            }
+            eventBus.publish(new UIResultBatchEvent(uuid: resultsUUID, results: results))
+        } catch (IOException bad) {
+            log.log(Level.WARNING, "failed to process RESULTS", bad)
+        } finally {
+            e.close()
+        }
+            
+    }
+    
+    private void processBROWSE(Endpoint e) {
+        try {
+            byte [] rowse = new byte[7]
+            DataInputStream dis = new DataInputStream(e.getInputStream())
+            dis.readFully(rowse)
+            if (rowse != "ROWSE\r\n".getBytes(StandardCharsets.US_ASCII))
+                throw new IOException("Invalid BROWSE connection")
+                
+            Persona browser = null
+            Map<String,String> headers = DataUtil.readAllHeaders(dis);
+            if (headers.containsKey('Persona')) { 
+                browser = new Persona(new ByteArrayInputStream(Base64.decode(headers['Persona'])))
+                if (browser.destination != e.destination)
+                    throw new IOException("browser persona mismatch")
+            }
+
+            OutputStream os = e.getOutputStream()
+            if (!settings.browseFiles) {
+                os.write("403 Not Allowed\r\n\r\n".getBytes(StandardCharsets.US_ASCII))
+                os.flush()
+                e.close()
+                return
+            }
+
+            browsed++
+            
+            os.write("200 OK\r\n".getBytes(StandardCharsets.US_ASCII))
+
+            def sharedFiles = fileManager.getSharedFiles().values()
+
+            os.write("Count: ${sharedFiles.size()}\r\n".getBytes(StandardCharsets.US_ASCII))
+            
+            boolean chat = chatServer.isRunning() && settings.advertiseChat
+            os.write("Chat: ${chat}\r\n".getBytes(StandardCharsets.US_ASCII))
+            
+            boolean feed = settings.fileFeed && settings.advertiseFeed
+            os.write("Feed: ${feed}\r\n".getBytes(StandardCharsets.US_ASCII))
+            
+            os.write("\r\n".getBytes(StandardCharsets.US_ASCII))
+
+            DataOutputStream dos = new DataOutputStream(new GZIPOutputStream(os))
+            JsonOutput jsonOutput = new JsonOutput()
+            sharedFiles.each {
+                it.hit(browser, System.currentTimeMillis(), "Browse Host");
+                int certificates = certificateManager.getByInfoHash(new InfoHash(it.getRoot())).size()
+                def obj = ResultsSender.sharedFileToObj(it, false, certificates)
+                def json = jsonOutput.toJson(obj)
+                dos.writeShort((short)json.length())
+                dos.write(json.getBytes(StandardCharsets.US_ASCII))
+            }
+            dos.flush()
+            dos.close()
+        } finally {
+            e.close()
+        }
+    }
 
     private void processTRUST(Endpoint e) {
-        byte[] RUST = new byte[6]
-        DataInputStream dis = new DataInputStream(e.getInputStream())
-        dis.readFully(RUST)
-        if (RUST != "RUST\r\n".getBytes(StandardCharsets.US_ASCII))
-            throw new IOException("Invalid TRUST connection")
-        String header
-        while ((header = DataUtil.readTillRN(dis)) != ""); // ignore headers for now
+        try {
+            byte[] RUST = new byte[6]
+            DataInputStream dis = new DataInputStream(e.getInputStream())
+            dis.readFully(RUST)
+            if (RUST != "RUST\r\n".getBytes(StandardCharsets.US_ASCII))
+                throw new IOException("Invalid TRUST connection")
+            
+            Map<String,String> headers = DataUtil.readAllHeaders(dis)
+            
+            OutputStream os = e.getOutputStream()
+            if (!settings.allowTrustLists) {
+                os.write("403 Not Allowed\r\n\r\n".getBytes(StandardCharsets.US_ASCII))
+                os.flush()
+                e.close()
+                return
+            }
 
-        OutputStream os = e.getOutputStream()
-        if (!settings.allowTrustLists) {
-            os.write("403 Not Allowed\r\n\r\n".getBytes(StandardCharsets.US_ASCII))
-            os.flush()
+            os.write("200 OK\r\n".getBytes(StandardCharsets.US_ASCII))
+            
+            boolean json = headers.containsKey('Json') && Boolean.parseBoolean(headers['Json'])
+            
+            List<TrustService.TrustEntry> good = new ArrayList<>(trustService.good.values())
+            List<TrustService.TrustEntry> bad = new ArrayList<>(trustService.bad.values())
+            DataOutputStream dos = new DataOutputStream(os)
+
+            if (!json) {
+                os.write("\r\n".getBytes(StandardCharsets.US_ASCII))
+                int size = Math.min(Short.MAX_VALUE * 2, good.size())
+                good = good.subList(0, size)
+                dos.writeShort(size)
+                good.each {
+                    it.persona.write(dos)
+                }
+
+                size = Math.min(Short.MAX_VALUE * 2, bad.size())
+                bad = bad.subList(0, size)
+                dos.writeShort(size)
+                bad.each {
+                    it.persona.write(dos)
+                }
+            } else {
+                dos.write("Json: true\r\n".getBytes(StandardCharsets.US_ASCII))
+                dos.write("Good:${good.size()}\r\n".getBytes(StandardCharsets.US_ASCII))
+                dos.write("Bad:${bad.size()}\r\n".getBytes(StandardCharsets.US_ASCII))
+                dos.write("\r\n".getBytes(StandardCharsets.US_ASCII))
+                
+                good.each { 
+                    def obj = [:]
+                    obj.persona = it.persona.toBase64()
+                    obj.reason = it.reason
+                    String toJson = JsonOutput.toJson(obj)
+                    byte [] payload = toJson.getBytes(StandardCharsets.US_ASCII)
+                    dos.writeShort(payload.length)
+                    dos.write(payload)   
+                }
+                bad.each {
+                    def obj = [:]
+                    obj.persona = it.persona.toBase64()
+                    obj.reason = it.reason
+                    String toJson = JsonOutput.toJson(obj)
+                    byte [] payload = toJson.getBytes(StandardCharsets.US_ASCII)
+                    dos.writeShort(payload.length)
+                    dos.write(payload)
+                }
+            }
+
+            dos.flush()
+        } finally {
             e.close()
-            return
         }
+    }
+    
+    private void processCERTIFICATES(Endpoint e) {
+        try {
+            byte [] ERTIFICATES = new byte[12]
+            DataInputStream dis = new DataInputStream(e.getInputStream())
+            dis.readFully(ERTIFICATES)
+            if (ERTIFICATES != "ERTIFICATES ".getBytes(StandardCharsets.US_ASCII))
+                throw new IOException("Invalid CERTIFICATES connection")
+            
+            byte [] infoHashStringBytes = new byte[44]
+            dis.readFully(infoHashStringBytes)
+            String infoHashString = new String(infoHashStringBytes, StandardCharsets.US_ASCII)
 
-        os.write("200 OK\r\n\r\n".getBytes(StandardCharsets.US_ASCII))
-        List<Persona> good = new ArrayList<>(trustService.good.values())
-        int size = Math.min(Short.MAX_VALUE * 2, good.size())
-        good = good.subList(0, size)
-        DataOutputStream dos = new DataOutputStream(os)
-        dos.writeShort(size)
-        good.each {
-            it.write(dos)
+            byte[] rn = new byte[2]
+            dis.readFully(rn)
+            if (rn != "\r\n".getBytes(StandardCharsets.US_ASCII))
+                throw new IOException("Malformed CERTIFICATES request")            
+            
+            String header
+            while ((header = DataUtil.readTillRN(dis)) != ""); // ignore headers for now
+            
+            log.info("responding to certificates request for $infoHashString")
+            byte [] root = Base64.decode(infoHashString)
+            
+            Set<Certificate> certs = certificateManager.getByInfoHash(new InfoHash(root))
+            if (certs.isEmpty()) {
+                log.info("certs not found")
+                e.getOutputStream().write("404 Certs Not Found\r\n\r\n".getBytes(StandardCharsets.US_ASCII))
+                e.getOutputStream().flush()
+                return
+            }
+            
+            OutputStream os = e.getOutputStream()
+            os.write("200 OK\r\n".getBytes(StandardCharsets.US_ASCII))
+            os.write("Count: ${certs.size()}\r\n".getBytes(StandardCharsets.US_ASCII))
+            os.write("\r\n".getBytes(StandardCharsets.US_ASCII))
+            
+            DataOutputStream dos = new DataOutputStream(os)
+            certs.each { 
+                ByteArrayOutputStream baos = new ByteArrayOutputStream()
+                it.write(baos)
+                byte [] payload = baos.toByteArray()
+                dos.writeShort(payload.length)
+                dos.write(payload)
+            }
+            dos.close()
+        } finally {
+            e.close()
         }
+    }
+    
+    private void processIRC(Endpoint e) {
+        byte[] IRC = new byte[4]
+        DataInputStream dis = new DataInputStream(e.getInputStream())
+        dis.readFully(IRC)
+        if (IRC != "RC\r\n".getBytes(StandardCharsets.US_ASCII))
+            throw new Exception("Invalid IRC connection")
+        chatServer.handle(e)
+    }
+    
+    private void processFEED(Endpoint e) {
+        try {
+            byte[] EED = new byte[5];
+            DataInputStream dis = new DataInputStream(e.getInputStream())
+            dis.readFully(EED);
+            if (EED != "EED\r\n".getBytes(StandardCharsets.US_ASCII))
+                throw new Exception("Invalid FEED connection")
 
-        List<Persona> bad = new ArrayList<>(trustService.bad.values())
-        size = Math.min(Short.MAX_VALUE * 2, bad.size())
-        bad = bad.subList(0, size)
-        dos.writeShort(size)
-        bad.each {
-            it.write(dos)
+            OutputStream os = e.getOutputStream()
+
+            Map<String, String> headers = DataUtil.readAllHeaders(dis)
+            if (!headers.containsKey("Persona"))
+                throw new Exception("Persona header missing")
+            Persona requestor = new Persona(new ByteArrayInputStream(Base64.decode(headers['Persona'])))
+            if (requestor.destination != e.destination)
+                throw new Exception("Requestor persona mismatch")
+
+            if (!settings.fileFeed) {
+                os.write("403 Not Allowed\r\n\r\n".getBytes(StandardCharsets.US_ASCII))
+                os.flush()
+                e.close()
+                return
+            }
+
+            long timestamp = 0
+            if (headers.containsKey("Timestamp")) {
+                timestamp = Long.parseLong(headers['Timestamp'])
+            }
+
+            List<SharedFile> published = fileManager.getPublishedSince(timestamp)
+
+            os.write("200 OK\r\n".getBytes(StandardCharsets.US_ASCII))
+            os.write("Count: ${published.size()}\r\n".getBytes(StandardCharsets.US_ASCII));
+            os.write("\r\n".getBytes(StandardCharsets.US_ASCII))
+
+            DataOutputStream dos = new DataOutputStream(new GZIPOutputStream(os))
+            JsonOutput jsonOutput = new JsonOutput()
+            final long now = System.currentTimeMillis();
+            published.each {
+                it.hit(requestor, now, "Feed Update");
+                int certificates = certificateManager.getByInfoHash(new InfoHash(it.getRoot())).size()
+                def obj = FeedItems.sharedFileToObj(it, certificates)
+                def json = jsonOutput.toJson(obj)
+                dos.writeShort((short)json.length())
+                dos.write(json.getBytes(StandardCharsets.US_ASCII))
+            }
+            dos.flush()
+            dos.close()
+        } finally {
+            e.close()
         }
-
-        dos.flush()
-        e.close()
     }
 
 }

core/src/main/groovy/com/muwire/core/connection/ConnectionEstablisher.groovy

@@ -31,9 +31,11 @@ class ConnectionEstablisher {
     final HostCache hostCache
 
     final Timer timer
-    final ExecutorService executor
+    final ExecutorService executor, closer
 
     final Set inProgress = new ConcurrentHashSet()
+    
+    private volatile boolean shutdown
 
     ConnectionEstablisher(){}
 
@@ -51,6 +53,8 @@ class ConnectionEstablisher {
             rv.setName("connector-${System.currentTimeMillis()}")
             rv
         } as ThreadFactory)
+        
+        closer = Executors.newSingleThreadExecutor()
     }
 
     void start() {
@@ -58,11 +62,15 @@ class ConnectionEstablisher {
     }
 
     void stop() {
+        shutdown = true
         timer.cancel()
         executor.shutdownNow()
+        closer.shutdownNow()
     }
 
     private void connectIfNeeded() {
+        if (shutdown)
+            return
         if (!connectionManager.needsConnections())
             return
         if (inProgress.size() >= CONCURRENT)
@@ -86,6 +94,8 @@ class ConnectionEstablisher {
     }
 
     private void connect(Destination toTry) {
+        if (shutdown)
+            return
         log.info("starting connect to ${toTry.toBase32()}")
         try {
             def endpoint = i2pConnector.connect(toTry)
@@ -120,8 +130,14 @@ class ConnectionEstablisher {
     }
 
     private void fail(Endpoint endpoint) {
-        endpoint.close()
-        eventBus.publish(new ConnectionEvent(endpoint: endpoint, incoming: false, leaf: false, status: ConnectionAttemptStatus.FAILED))
+        if (shutdown)
+            return
+        if (!closer.isShutdown()) {
+            closer.execute {
+                endpoint.close()
+                eventBus.publish(new ConnectionEvent(endpoint: endpoint, incoming: false, leaf: false, status: ConnectionAttemptStatus.FAILED))
+            } as Runnable
+        }
     }
 
     private void readK(Endpoint e) {
@@ -175,7 +191,7 @@ class ConnectionEstablisher {
             log.log(Level.WARNING,"Problem parsing post-rejection payload",ignore)
         } finally {
             // the end
-            e.close()
+            closer.execute({e.close()} as Runnable)
         }
     }
 

core/src/main/groovy/com/muwire/core/connection/ConnectionManager.groovy

@@ -36,9 +36,8 @@ abstract class ConnectionManager {
         timer.schedule({sendPings()} as TimerTask, 1000,1000)
     }
 
-    void stop() {
+    void shutdown() {
         timer.cancel()
-        getConnections().each { it.close() }
     }
 
     void onTrustEvent(TrustEvent e) {
@@ -62,8 +61,6 @@ abstract class ConnectionManager {
 
     abstract void onDisconnectionEvent(DisconnectionEvent e)
 
-    abstract void shutdown()
-
     protected void sendPings() {
         final long now = System.currentTimeMillis()
         getConnections().each {

core/src/main/groovy/com/muwire/core/connection/Endpoint.groovy

@@ -31,9 +31,6 @@ class Endpoint implements Closeable {
         if (inputStream != null) {
             try {inputStream.close()} catch (Exception ignore) {}
         }
-        if (outputStream != null) {
-            try {outputStream.close()} catch (Exception ignore) {}
-        }
         if (toClose != null) {
             try {toClose.reset()} catch (Exception ignore) {}
         }

core/src/main/groovy/com/muwire/core/connection/PeerConnection.groovy

@@ -53,7 +53,7 @@ class PeerConnection extends Connection {
             if (json.type == null)
                 throw new Exception("missing json type")
             switch(json.type) {
-                case "Ping" : handlePing(); break;
+                case "Ping" : handlePing(json); break;
                 case "Pong" : handlePong(json); break;
                 case "Search": handleSearch(json); break
                 default :

core/src/main/groovy/com/muwire/core/connection/UltrapeerConnectionManager.groovy

@@ -8,6 +8,7 @@ import com.muwire.core.MuWireSettings
 import com.muwire.core.Persona
 import com.muwire.core.hostcache.HostCache
 import com.muwire.core.search.QueryEvent
+import com.muwire.core.search.ResponderCache
 import com.muwire.core.trust.TrustService
 
 import groovy.util.logging.Log
@@ -18,18 +19,22 @@ class UltrapeerConnectionManager extends ConnectionManager {
 
     final int maxPeers, maxLeafs
     final TrustService trustService
+    final ResponderCache responderCache
 
     final Map<Destination, PeerConnection> peerConnections = new ConcurrentHashMap()
     final Map<Destination, LeafConnection> leafConnections = new ConcurrentHashMap()
+    
+    private final Random random = new Random()
 
     UltrapeerConnectionManager() {}
 
     public UltrapeerConnectionManager(EventBus eventBus, Persona me, int maxPeers, int maxLeafs,
-        HostCache hostCache, TrustService trustService, MuWireSettings settings) {
+        HostCache hostCache, ResponderCache responderCache, TrustService trustService, MuWireSettings settings) {
         super(eventBus, me, hostCache, settings)
         this.maxPeers = maxPeers
         this.maxLeafs = maxLeafs
         this.trustService = trustService
+        this.responderCache = responderCache
     }
     @Override
     public void drop(Destination d) {
@@ -44,8 +49,18 @@ class UltrapeerConnectionManager extends ConnectionManager {
         if (e.replyTo != me.destination && e.receivedOn != me.destination &&
             !leafConnections.containsKey(e.receivedOn))
             e.firstHop = false
+        final int connCount = peerConnections.size()
+        if (connCount == 0)
+            return
+        final int treshold = (int)(Math.sqrt(connCount)) + 1
         peerConnections.values().each {
-            if (e.getReceivedOn() != it.getEndpoint().getDestination())
+            // 1. do not send query back to originator
+            // 2. if firstHop forward to everyone
+            // 3. otherwise to everyone who has recently responded/transferred to us + randomized sqrt of neighbors
+            if (e.getReceivedOn() != it.getEndpoint().getDestination() &&
+                (e.firstHop || 
+                    responderCache.hasResponded(it.endpoint.destination) ||
+                    random.nextInt(connCount) < treshold))
                 it.sendQuery(e)
         }
     }
@@ -104,8 +119,9 @@ class UltrapeerConnectionManager extends ConnectionManager {
 
     @Override
     void shutdown() {
-        peerConnections.values().stream().parallel().forEach({v -> v.close()})
-        leafConnections.values().stream().parallel().forEach({v -> v.close()})
+        super.shutdown()
+        peerConnections.values().stream().forEach({v -> v.close()})
+        leafConnections.values().stream().forEach({v -> v.close()})
         peerConnections.clear()
         leafConnections.clear()
     }

core/src/main/groovy/com/muwire/core/download/DownloadHopelessEvent.groovy

@@ -0,0 +1,7 @@
+package com.muwire.core.download
+
+import com.muwire.core.Event
+
+class DownloadHopelessEvent extends Event {
+    Downloader downloader
+}

core/src/main/groovy/com/muwire/core/download/DownloadManager.groovy

@@ -1,6 +1,7 @@
 package com.muwire.core.download
 
 import com.muwire.core.connection.I2PConnector
+import com.muwire.core.filefeeds.UIDownloadFeedItemEvent
 import com.muwire.core.files.FileDownloadedEvent
 import com.muwire.core.files.FileHasher
 import com.muwire.core.mesh.Mesh
@@ -12,6 +13,7 @@ import com.muwire.core.util.DataUtil
 import groovy.json.JsonBuilder
 import groovy.json.JsonOutput
 import groovy.json.JsonSlurper
+import groovy.util.logging.Log
 import net.i2p.data.Base64
 import net.i2p.data.Destination
 import net.i2p.util.ConcurrentHashSet
@@ -21,36 +23,39 @@ import com.muwire.core.InfoHash
 import com.muwire.core.MuWireSettings
 import com.muwire.core.Persona
 import com.muwire.core.UILoadedEvent
+import com.muwire.core.chat.ChatManager
+import com.muwire.core.chat.ChatServer
 
 import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.Executor
 import java.util.concurrent.Executors
+import java.util.logging.Level
 
+@Log
 public class DownloadManager {
 
     private final EventBus eventBus
     private final TrustService trustService
     private final MeshManager meshManager
-    private final MuWireSettings muSettings
+    final MuWireSettings muSettings
     private final I2PConnector connector
     private final Executor executor
-    private final File incompletes, home
+    private final File home
     private final Persona me
+    private final ChatServer chatServer
 
     private final Map<InfoHash, Downloader> downloaders = new ConcurrentHashMap<>()
 
     public DownloadManager(EventBus eventBus, TrustService trustService, MeshManager meshManager, MuWireSettings muSettings,
-        I2PConnector connector, File home, Persona me) {
+        I2PConnector connector, File home, Persona me, ChatServer chatServer) {
         this.eventBus = eventBus
         this.trustService = trustService
         this.meshManager = meshManager
         this.muSettings = muSettings
         this.connector = connector
-        this.incompletes = new File(home,"incompletes")
         this.home = home
         this.me = me
-
-        incompletes.mkdir()
+        this.chatServer = chatServer
 
         this.executor = Executors.newCachedThreadPool({ r ->
             Thread rv = new Thread(r)
@@ -62,7 +67,7 @@ public class DownloadManager {
 
 
     public void onUIDownloadEvent(UIDownloadEvent e) {
-
+        
         def size = e.result[0].size
         def infohash = e.result[0].infohash
         def pieceSize = e.result[0].pieceSize
@@ -74,12 +79,29 @@ public class DownloadManager {
         destinations.addAll(e.sources)
         destinations.remove(me.destination)
 
-        Pieces pieces = getPieces(infohash, size, pieceSize)
+        doDownload(infohash, e.target, size, pieceSize, e.sequential, destinations)
 
-        def downloader = new Downloader(eventBus, this, me, e.target, size,
-            infohash, pieceSize, connector, destinations,
-            incompletes, pieces)
-        downloaders.put(infohash, downloader)
+    }
+    
+    public void onUIDownloadFeedItemEvent(UIDownloadFeedItemEvent e) {
+        Set<Destination> singleSource = new HashSet<>()
+        singleSource.add(e.item.getPublisher().getDestination())
+        doDownload(e.item.getInfoHash(), e.target, e.item.getSize(), e.item.getPieceSize(), 
+            e.sequential, singleSource)
+    }
+    
+    private void doDownload(InfoHash infoHash, File target, long size, int pieceSize, 
+        boolean sequential, Set<Destination> destinations) {
+        File incompletes = muSettings.incompleteLocation
+        if (incompletes == null)
+            incompletes = new File(home, "incompletes")
+        incompletes.mkdirs()
+        
+        Pieces pieces = getPieces(infoHash, size, pieceSize, sequential)
+        def downloader = new Downloader(eventBus, this, chatServer, me, target, size,
+                infoHash, pieceSize, connector, destinations,
+                incompletes, pieces, muSettings.downloadMaxFailures)
+        downloaders.put(infoHash, downloader)
         persistDownloaders()
         executor.execute({downloader.download()} as Runnable)
         eventBus.publish(new DownloadStartedEvent(downloader : downloader))
@@ -90,6 +112,11 @@ public class DownloadManager {
         persistDownloaders()
     }
 
+    public void onDownloadHopelessEvent(DownloadHopelessEvent e) {
+        downloaders.remove(e.downloader.infoHash)
+        persistDownloaders()
+    }
+    
     public void onUIDownloadPausedEvent(UIDownloadPausedEvent e) {
         persistDownloaders()
     }
@@ -122,27 +149,48 @@ public class DownloadManager {
                 byte [] root = Base64.decode(json.hashRoot)
                 infoHash = new InfoHash(root)
             }
+            
+            boolean sequential = false
+            if (json.sequential != null)
+                sequential = json.sequential
+                
+            File incompletes
+            if (json.incompletes != null) 
+                incompletes = new File(DataUtil.readi18nString(Base64.decode(json.incompletes)))
+            else
+                incompletes = new File(home, "incompletes")
 
-            Pieces pieces = getPieces(infoHash, (long)json.length, json.pieceSizePow2)
+            if (json.pieceSizePow2 == null || json.pieceSizePow2 == 0) {
+                log.warning("Skipping $file because pieceSizePow2=$json.pieceSizePow2")
+                return // skip this download as it's corrupt anyway
+            }
+                
+            Pieces pieces = getPieces(infoHash, (long)json.length, json.pieceSizePow2, sequential)
 
-            def downloader = new Downloader(eventBus, this, me, file, (long)json.length,
-                infoHash, json.pieceSizePow2, connector, destinations, incompletes, pieces)
+            def downloader = new Downloader(eventBus, this, chatServer, me, file, (long)json.length,
+                infoHash, json.pieceSizePow2, connector, destinations, incompletes, pieces, muSettings.downloadMaxFailures)
             if (json.paused != null)
                 downloader.paused = json.paused
-            downloaders.put(infoHash, downloader)
-            downloader.readPieces()
-            if (!downloader.paused)
-                downloader.download()
-            eventBus.publish(new DownloadStartedEvent(downloader : downloader))
+                
+            try {
+                downloader.readPieces()
+                if (!downloader.paused)
+                    downloader.download()
+                downloaders.put(infoHash, downloader)
+                eventBus.publish(new DownloadStartedEvent(downloader : downloader))
+            } catch (IllegalArgumentException bad) {
+                log.log(Level.WARNING,"cannot start downloader, skipping", bad)
+                return
+            }
         }
     }
 
-    private Pieces getPieces(InfoHash infoHash, long length, int pieceSizePow2) {
-        int pieceSize = 0x1 << pieceSizePow2
+    private Pieces getPieces(InfoHash infoHash, long length, int pieceSizePow2, boolean sequential) {
+        long pieceSize = 0x1L << pieceSizePow2
         int nPieces = (int)(length / pieceSize)
         if (length % pieceSize != 0)
             nPieces++
-        Mesh mesh = meshManager.getOrCreate(infoHash, nPieces)
+        Mesh mesh = meshManager.getOrCreate(infoHash, nPieces, sequential)
         mesh.pieces
     }
 
@@ -188,6 +236,11 @@ public class DownloadManager {
                         json.hashRoot = Base64.encode(infoHash.getRoot())
 
                     json.paused = downloader.paused
+                    
+                    json.sequential = downloader.pieces.ratio == 0f
+                    
+                    json.incompletes = Base64.encode(DataUtil.encodei18nString(downloader.incompletes.getAbsolutePath()))
+                    
                     writer.println(JsonOutput.toJson(json))
                 }
             }
@@ -198,4 +251,8 @@ public class DownloadManager {
         downloaders.values().each { it.stop() }
         Downloader.executorService.shutdownNow()
     }
+    
+    public boolean isDownloading(InfoHash infoHash) {
+        downloaders.containsKey(infoHash)
+    }
 }

core/src/main/groovy/com/muwire/core/download/DownloadSession.groovy

@@ -21,6 +21,7 @@ import java.nio.file.Files
 import java.nio.file.StandardOpenOption
 import java.security.MessageDigest
 import java.security.NoSuchAlgorithmException
+import java.util.concurrent.atomic.AtomicLong
 import java.util.logging.Level
 
 @Log
@@ -36,14 +37,15 @@ class DownloadSession {
     private final long fileLength
     private final Set<Integer> available
     private final MessageDigest digest
+    private final boolean browse, feed, chat
 
-    private long lastSpeedRead = System.currentTimeMillis()
-    private long dataSinceLastRead
+    private final AtomicLong dataSinceLastRead
 
     private MappedByteBuffer mapped
 
     DownloadSession(EventBus eventBus, String meB64, Pieces pieces, InfoHash infoHash, Endpoint endpoint, File file,
-        int pieceSize, long fileLength, Set<Integer> available) {
+        int pieceSize, long fileLength, Set<Integer> available, AtomicLong dataSinceLastRead,
+        boolean browse, boolean feed, boolean chat) {
         this.eventBus = eventBus
         this.meB64 = meB64
         this.pieces = pieces
@@ -53,6 +55,10 @@ class DownloadSession {
         this.pieceSize = pieceSize
         this.fileLength = fileLength
         this.available = available
+        this.dataSinceLastRead = dataSinceLastRead
+        this.browse = browse
+        this.feed = feed
+        this.chat = chat
         try {
             digest = MessageDigest.getInstance("SHA-256")
         } catch (NoSuchAlgorithmException impossible) {
@@ -93,6 +99,12 @@ class DownloadSession {
             os.write("GET $root\r\n".getBytes(StandardCharsets.US_ASCII))
             os.write("Range: $start-$end\r\n".getBytes(StandardCharsets.US_ASCII))
             os.write("X-Persona: $meB64\r\n".getBytes(StandardCharsets.US_ASCII))
+            if (browse)
+                os.write("Browse: true\r\n".getBytes(StandardCharsets.US_ASCII))
+            if (feed)
+                os.write("Feed: true\r\n".getBytes(StandardCharsets.US_ASCII))
+            if (chat)
+                os.write("Chat: true\r\n".getBytes(StandardCharsets.US_ASCII))
             String xHave = DataUtil.encodeXHave(pieces.getDownloaded(), pieces.nPieces)
             os.write("X-Have: $xHave\r\n\r\n".getBytes(StandardCharsets.US_ASCII))
             os.flush()
@@ -141,6 +153,8 @@ class DownloadSession {
             // parse X-Have if present
             if (headers.containsKey("X-Have")) {
                 DataUtil.decodeXHave(headers["X-Have"]).each {
+                    if (it >= pieces.nPieces)
+                        throw new IOException("Invalid X-Have header, available piece $it/$pieces.nPieces")
                     available.add(it)
                 }
                 if (!available.contains(piece))
@@ -180,15 +194,14 @@ class DownloadSession {
                 mapped.position(position)
 
                 byte[] tmp = new byte[0x1 << 13]
+                DataInputStream dis = new DataInputStream(is)
                 while(mapped.hasRemaining()) {
                     if (mapped.remaining() < tmp.length)
                         tmp = new byte[mapped.remaining()]
-                    int read = is.read(tmp)
-                    if (read == -1)
-                        throw new IOException()
+                    dis.readFully(tmp)
                     synchronized(this) {
-                        mapped.put(tmp, 0, read)
-                        dataSinceLastRead += read
+                        mapped.put(tmp)
+                        dataSinceLastRead.addAndGet(tmp.length)
                         pieces.markPartial(piece, mapped.position())
                     }
                 }
@@ -202,6 +215,8 @@ class DownloadSession {
                     pieces.markPartial(piece, 0)
                     throw new BadHashException("bad hash on piece $piece")
                 }
+                
+                eventBus.publish(new SourceVerifiedEvent(infoHash : infoHash, source : endpoint.destination))
             } finally {
                 try { channel?.close() } catch (IOException ignore) {}
                 DataUtil.tryUnmap(mapped)
@@ -220,13 +235,4 @@ class DownloadSession {
             return 0
         mapped.position()
     }
-
-    synchronized int speed() {
-        final long now = System.currentTimeMillis()
-        long interval = Math.max(1000, now - lastSpeedRead)
-        lastSpeedRead = now;
-        int rv = (int) (dataSinceLastRead * 1000.0 / interval)
-        dataSinceLastRead = 0
-        rv
-    }
 }

core/src/main/groovy/com/muwire/core/download/Downloader.groovy

@@ -2,6 +2,8 @@ package com.muwire.core.download
 
 import com.muwire.core.InfoHash
 import com.muwire.core.Persona
+import com.muwire.core.chat.ChatManager
+import com.muwire.core.chat.ChatServer
 import com.muwire.core.connection.Endpoint
 
 import java.nio.file.AtomicMoveNotSupportedException
@@ -12,6 +14,7 @@ import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.ExecutorService
 import java.util.concurrent.Executors
 import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.atomic.AtomicLong
 import java.util.logging.Level
 
 import com.muwire.core.Constants
@@ -27,7 +30,8 @@ import net.i2p.util.ConcurrentHashSet
 
 @Log
 public class Downloader {
-    public enum DownloadState { CONNECTING, HASHLIST, DOWNLOADING, FAILED, CANCELLED, PAUSED, FINISHED }
+    
+    public enum DownloadState { CONNECTING, HASHLIST, DOWNLOADING, FAILED, HOPELESS, CANCELLED, PAUSED, FINISHED }
     private enum WorkerState { CONNECTING, HASHLIST, DOWNLOADING, FINISHED}
 
     private static final ExecutorService executorService = Executors.newCachedThreadPool({r ->
@@ -39,6 +43,7 @@ public class Downloader {
 
     private final EventBus eventBus
     private final DownloadManager downloadManager
+    private final ChatServer chatServer
     private final Persona me
     private final File file
     private final Pieces pieces
@@ -48,49 +53,70 @@ public class Downloader {
     private final I2PConnector connector
     private final Set<Destination> destinations
     private final int nPieces
+    private final File incompletes
     private final File piecesFile
     private final File incompleteFile
     final int pieceSizePow2
     private final Map<Destination, DownloadWorker> activeWorkers = new ConcurrentHashMap<>()
     private final Set<Destination> successfulDestinations = new ConcurrentHashSet<>()
+    /** LOCKING: itself */
+    private final Map<Destination, Integer> failingDestinations = new HashMap<>()
+    private final int maxFailures
 
 
     private volatile boolean cancelled, paused
     private final AtomicBoolean eventFired = new AtomicBoolean()
+    private final AtomicBoolean hopelessEventFired = new AtomicBoolean()
     private boolean piecesFileClosed
 
+    private final AtomicLong dataSinceLastRead = new AtomicLong(0)
+    private volatile long lastSpeedRead = System.currentTimeMillis()
     private ArrayList speedArr = new ArrayList<Integer>()
     private int speedPos = 0
     private int speedAvg = 0
-    private long timestamp = Instant.now().toEpochMilli()
 
-    public Downloader(EventBus eventBus, DownloadManager downloadManager,
+    public Downloader(EventBus eventBus, DownloadManager downloadManager, ChatServer chatServer,
         Persona me, File file, long length, InfoHash infoHash,
         int pieceSizePow2, I2PConnector connector, Set<Destination> destinations,
-        File incompletes, Pieces pieces) {
+        File incompletes, Pieces pieces, int maxFailures) {
         this.eventBus = eventBus
         this.me = me
         this.downloadManager = downloadManager
+        this.chatServer = chatServer
         this.file = file
         this.infoHash = infoHash
         this.length = length
         this.connector = connector
         this.destinations = destinations
+        this.incompletes = incompletes
         this.piecesFile = new File(incompletes, file.getName()+".pieces")
         this.incompleteFile = new File(incompletes, file.getName()+".part")
         this.pieceSizePow2 = pieceSizePow2
         this.pieceSize = 1 << pieceSizePow2
         this.pieces = pieces
         this.nPieces = pieces.nPieces
-
-        // default size suitable for an average of 5 seconds / 5 elements / 5 interval units
-        // it's easily adjustable by resizing the size of speedArr
-        this.speedArr = [ 0, 0, 0, 0, 0 ]
+        this.maxFailures = maxFailures
     }
 
     public synchronized InfoHash getInfoHash() {
         infoHash
     }
+    
+    public File getFile() {
+        file
+    }
+    
+    public int getNPieces() {
+        nPieces
+    }
+
+    public int getPieceSize() {
+        pieceSize
+    }    
+    
+    public long getLength() {
+        length
+    }
 
     private synchronized void setInfoHash(InfoHash infoHash) {
         this.infoHash = infoHash
@@ -99,7 +125,7 @@ public class Downloader {
     void download() {
         readPieces()
         destinations.each {
-            if (it != me.destination) {
+            if (it != me.destination && !isHopeless(it)) {
                 def worker = new DownloadWorker(it)
                 activeWorkers.put(it, worker)
                 executorService.submit(worker)
@@ -140,10 +166,17 @@ public class Downloader {
     public int speed() {
         int currSpeed = 0
         if (getCurrentState() == DownloadState.DOWNLOADING) {
-            activeWorkers.values().each {
-                if (it.currentState == WorkerState.DOWNLOADING)
-                    currSpeed += it.speed()
-            }
+            long dataRead = dataSinceLastRead.getAndSet(0)
+            long now = System.currentTimeMillis()
+            if (now > lastSpeedRead)
+                currSpeed = (int) (dataRead * 1000.0d / (now - lastSpeedRead))
+            lastSpeedRead = now
+        }
+        
+        if (speedArr.size() != downloadManager.muSettings.speedSmoothSeconds) {
+            speedArr.clear()
+            downloadManager.muSettings.speedSmoothSeconds.times { speedArr.add(0) }
+            speedPos = 0
         }
 
         // normalize to speedArr.size
@@ -182,6 +215,8 @@ public class Downloader {
         if (allFinished) {
             if (pieces.isComplete())
                 return DownloadState.FINISHED
+            if (!hasLiveSources())
+                return DownloadState.HOPELESS
             return DownloadState.FAILED
         }
 
@@ -241,11 +276,26 @@ public class Downloader {
         }
         active
     }
+    
+    public int getTotalWorkers() {
+        return activeWorkers.size();
+    }
+    
+    public int countHopelessSources() {
+        synchronized(failingDestinations) {
+            return destinations.count { isHopeless(it)}
+        }
+    }
+    
+    private boolean hasLiveSources() {
+        destinations.size() > countHopelessSources()
+    }
 
     public void resume() {
         paused = false
         readPieces()
-        destinations.each { destination ->
+        destinations.stream().filter({!isHopeless(it)}).forEach { destination ->
+            log.fine("resuming source ${destination.toBase32()}")
             def worker = activeWorkers.get(destination)
             if (worker != null) {
                 if (worker.currentState == WorkerState.FINISHED) {
@@ -262,12 +312,86 @@ public class Downloader {
     }
 
     void addSource(Destination d) {
-        if (activeWorkers.containsKey(d))
+        if (activeWorkers.containsKey(d) || isHopeless(d))
             return
+        destinations.add(d)
         DownloadWorker newWorker = new DownloadWorker(d)
         activeWorkers.put(d, newWorker)
         executorService.submit(newWorker)
     }
+    
+    boolean isSequential() {
+        pieces.ratio == 0f
+    }
+    
+    File generatePreview() {
+        int lastCompletePiece = pieces.firstIncomplete() - 1
+        if (lastCompletePiece == -1)
+            return null
+        if (lastCompletePiece < -1)
+            return file
+        long previewableLength = (lastCompletePiece + 1) * ((long)pieceSize)
+        
+        // generate name
+        long now = System.currentTimeMillis()
+        File previewFile
+        File parentFile = file.getParentFile()
+        int lastDot = file.getName().lastIndexOf('.')
+        if (lastDot < 0) 
+            previewFile = new File(parentFile, file.getName() + "." + String.valueOf(now) + ".mwpreview")
+        else {
+            String name = file.getName().substring(0, lastDot)
+            String extension = file.getName().substring(lastDot + 1)
+            String previewName = name + "." + String.valueOf(now) + ".mwpreview."+extension
+            previewFile = new File(parentFile, previewName)
+        }
+        
+        // copy
+        InputStream is = null
+        OutputStream os = null
+        try {
+            is = new BufferedInputStream(new FileInputStream(incompleteFile))
+            os = new BufferedOutputStream(new FileOutputStream(previewFile))
+            byte [] tmp = new byte[0x1 << 13]
+            long totalCopied = 0
+            while(totalCopied < previewableLength) {
+                int read = is.read(tmp, 0, (int)Math.min(tmp.length, previewableLength - totalCopied))
+                if (read < 0)
+                    throw new IOException("EOF?")
+                os.write(tmp, 0, read)
+                totalCopied += read
+            }
+            return previewFile
+        } catch (IOException bad) {
+            log.log(Level.WARNING,"Preview failed",bad)
+            return null
+        } finally {
+            try {is?.close() } catch (IOException ignore) {}
+            try {os?.close() } catch (IOException ignore) {}
+        }
+    }
+    
+    private boolean isHopeless(Destination d) {
+        if (maxFailures < 0)
+            return false
+        synchronized(failingDestinations) {
+            return !successfulDestinations.contains(d) &&
+                    failingDestinations.containsKey(d) &&
+                    failingDestinations[d] >= maxFailures
+        }
+    }
+    
+    private void markFailed(Destination d) {
+        log.fine("marking failed ${d.toBase32()}")
+        synchronized(failingDestinations) {
+            Integer count = failingDestinations.get(d)
+            if (count == null) {
+                failingDestinations.put(d, 1)
+            } else {
+                failingDestinations.put(d, count + 1)
+            }
+        }
+    }
 
     class DownloadWorker implements Runnable {
         private final Destination destination
@@ -294,10 +418,16 @@ public class Downloader {
                     setInfoHash(received)
                 }
                 currentState = WorkerState.DOWNLOADING
+                
+                boolean browse = downloadManager.muSettings.browseFiles
+                boolean feed = downloadManager.muSettings.fileFeed && downloadManager.muSettings.advertiseFeed
+                boolean chat = chatServer.isRunning() && downloadManager.muSettings.advertiseChat
+                
                 boolean requestPerformed
                 while(!pieces.isComplete()) {
                     currentSession = new DownloadSession(eventBus, me.toBase64(), pieces, getInfoHash(),
-                        endpoint, incompleteFile, pieceSize, length, available)
+                        endpoint, incompleteFile, pieceSize, length, available, dataSinceLastRead,
+                        browse, feed, chat)
                     requestPerformed = currentSession.request()
                     if (!requestPerformed)
                         break
@@ -306,6 +436,9 @@ public class Downloader {
                 }
             } catch (Exception bad) {
                 log.log(Level.WARNING,"Exception while downloading",DataUtil.findRoot(bad))
+                markFailed(destination)
+                if (!hasLiveSources() && hopelessEventFired.compareAndSet(false, true)) 
+                    eventBus.publish(new DownloadHopelessEvent(downloader : Downloader.this))
             } finally {
                 writePieces()
                 currentState = WorkerState.FINISHED
@@ -326,20 +459,15 @@ public class Downloader {
                     }
                     eventBus.publish(
                         new FileDownloadedEvent(
-                            downloadedFile : new DownloadedFile(file.getCanonicalFile(), getInfoHash(), pieceSizePow2, successfulDestinations),
-                        downloader : Downloader.this))
+                            downloadedFile : new DownloadedFile(file.getCanonicalFile(), getInfoHash().getRoot(), pieceSizePow2, successfulDestinations),
+                        downloader : Downloader.this,
+                        infoHash: getInfoHash()))
 
                 }
                 endpoint?.close()
             }
         }
 
-        int speed() {
-            if (currentSession == null)
-                return 0
-            currentSession.speed()
-        }
-
         void cancel() {
             downloadThread?.interrupt()
         }

core/src/main/groovy/com/muwire/core/download/Pieces.groovy

@@ -2,10 +2,11 @@ package com.muwire.core.download
 
 class Pieces {
     private final BitSet done, claimed
-    private final int nPieces
+    final int nPieces
     private final float ratio
     private final Random random = new Random()
     private final Map<Integer,Integer> partials = new HashMap<>()
+    private int cachedDone;
 
     Pieces(int nPieces) {
         this(nPieces, 1.0f)
@@ -17,7 +18,7 @@ class Pieces {
         done = new BitSet(nPieces)
         claimed = new BitSet(nPieces)
     }
-
+    
     synchronized int[] claim() {
         int claimedCardinality = claimed.cardinality()
         if (claimedCardinality == nPieces) {
@@ -30,7 +31,7 @@ class Pieces {
         }
 
         // if fuller than ratio just do sequential
-        if ( (1.0f * claimedCardinality) / nPieces > ratio) {
+        if ( (1.0f * claimedCardinality) / nPieces >= ratio) {
             int rv = claimed.nextClearBit(0)
             claimed.set(rv)
             return [rv, partials.getOrDefault(rv, 0), 0]
@@ -59,7 +60,8 @@ class Pieces {
             return [rv, partials.getOrDefault(rv, 0), 1]
         }
         List<Integer> toList = availableCopy.toList()
-        Collections.shuffle(toList)
+        if (ratio > 0f)
+            Collections.shuffle(toList)
         int rv = toList[0]
         claimed.set(rv)
         [rv, partials.getOrDefault(rv, 0), 0]
@@ -74,7 +76,10 @@ class Pieces {
     }
 
     synchronized void markDownloaded(int piece) {
+        if (piece >= nPieces)
+            throw new IllegalArgumentException("invalid piece marked as downloaded? $piece/$nPieces")
         done.set(piece)
+        cachedDone = done.cardinality();
         claimed.set(piece)
         partials.remove(piece)
     }
@@ -88,11 +93,11 @@ class Pieces {
     }
 
     synchronized boolean isComplete() {
-        done.cardinality() == nPieces
+        cachedDone == nPieces
     }
 
     synchronized int donePieces() {
-        done.cardinality()
+        cachedDone
     }
 
     synchronized boolean isDownloaded(int piece) {
@@ -101,10 +106,15 @@ class Pieces {
 
     synchronized void clearAll() {
         done.clear()
+        cachedDone = 0
         claimed.clear()
         partials.clear()
     }
     
+    synchronized int firstIncomplete() {
+        done.nextClearBit(0)
+    }
+    
     synchronized void write(PrintWriter writer) {
         for (int i = done.nextSetBit(0); i >= 0; i = done.nextSetBit(i+1)) {
             writer.println(i)

core/src/main/groovy/com/muwire/core/download/SourceVerifiedEvent.groovy

@@ -0,0 +1,11 @@
+package com.muwire.core.download
+
+import com.muwire.core.Event
+import com.muwire.core.InfoHash
+
+import net.i2p.data.Destination
+
+class SourceVerifiedEvent extends Event {
+    InfoHash infoHash
+    Destination source
+}

core/src/main/groovy/com/muwire/core/download/UIDownloadEvent.groovy

@@ -10,4 +10,5 @@ class UIDownloadEvent extends Event {
     UIResultEvent[] result
     Set<Destination> sources
     File target
+    boolean sequential
 }

core/src/main/groovy/com/muwire/core/filecert/Certificate.groovy

@@ -0,0 +1,164 @@
+package com.muwire.core.filecert
+
+import com.muwire.core.Constants
+import com.muwire.core.InfoHash
+import com.muwire.core.InvalidSignatureException
+import com.muwire.core.Name
+import com.muwire.core.Persona
+
+import net.i2p.crypto.DSAEngine
+import net.i2p.data.Signature
+import net.i2p.data.SigningPrivateKey
+import net.i2p.data.SigningPublicKey
+import net.i2p.data.Base64
+
+class Certificate {
+    private final byte version
+    private final InfoHash infoHash
+    final Name name, comment
+    final long timestamp
+    final Persona issuer
+    private final byte[] sig
+    
+    private volatile byte [] payload
+    
+    private String base64;
+    
+    Certificate(InputStream is) {
+        version = (byte) (is.read() & 0xFF)
+        if (version > Constants.FILE_CERT_VERSION)
+            throw new IOException("Unknown version $version")
+        
+        DataInputStream dis = new DataInputStream(is)
+        timestamp = dis.readLong()
+        
+        byte [] root = new byte[InfoHash.SIZE]
+        dis.readFully(root)
+        infoHash = new InfoHash(root)
+        
+        name = new Name(dis)
+        
+        issuer = new Persona(dis)
+        if (version == 2) {
+            byte present = (byte)(dis.read() & 0xFF)
+            if (present != 0) {
+                comment = new Name(dis)
+            }
+        }
+        
+        sig = new byte[Constants.SIG_TYPE.getSigLen()]
+        dis.readFully(sig)
+        
+        if (!verify(version, infoHash, name, timestamp, issuer, comment, sig))
+            throw new InvalidSignatureException("certificate for $name.name from ${issuer.getHumanReadableName()} didn't verify")
+    }
+    
+    Certificate(InfoHash infoHash, String name, long timestamp, Persona issuer, String comment, SigningPrivateKey spk) {
+        this.version = Constants.FILE_CERT_VERSION
+        this.infoHash = infoHash
+        this.name = new Name(name)
+        if (comment != null)
+            this.comment = new Name(comment)
+        else
+            this.comment = null
+        this.timestamp = timestamp
+        this.issuer = issuer
+        
+        ByteArrayOutputStream baos = new ByteArrayOutputStream()
+        DataOutputStream daos = new DataOutputStream(baos)
+        
+        daos.write(version)
+        daos.writeLong(timestamp)
+        daos.write(infoHash.getRoot())
+        this.name.write(daos)
+        issuer.write(daos)
+        if (this.comment == null) {
+            daos.write((byte) 0)
+        } else {
+            daos.write((byte) 1)
+            this.comment.write(daos)
+        }
+        daos.close()
+        
+        byte[] payload = baos.toByteArray()
+        Signature signature = DSAEngine.getInstance().sign(payload, spk)
+        this.sig = signature.getData()
+    }
+    
+    private static boolean verify(byte version, InfoHash infoHash, Name name, long timestamp, Persona issuer, Name comment, byte[] sig) {
+        ByteArrayOutputStream baos = new ByteArrayOutputStream()
+        DataOutputStream daos = new DataOutputStream(baos)
+        daos.write(version)
+        daos.writeLong(timestamp)
+        daos.write(infoHash.getRoot())
+        name.write(daos)
+        issuer.write(daos)
+        if (version == 2) {
+            if (comment == null) {
+                daos.write((byte)0)
+            } else {
+                daos.write((byte)1)
+                comment.write(daos)
+            }
+        }
+        daos.close()
+        
+        byte [] payload = baos.toByteArray()
+        SigningPublicKey spk = issuer.destination.getSigningPublicKey()
+        Signature signature = new Signature(spk.getType(), sig)
+        DSAEngine.getInstance().verifySignature(signature, payload, spk)
+    }
+    
+    public void write(OutputStream os) {
+        if (payload == null) {
+            ByteArrayOutputStream baos = new ByteArrayOutputStream()
+            DataOutputStream daos = new DataOutputStream(baos)
+            daos.write(version)
+            daos.writeLong(timestamp)
+            daos.write(infoHash.getRoot())
+            name.write(daos)
+            issuer.write(daos)
+            if (version == 2) {
+                if (comment == null)
+                    daos.write((byte) 0)
+                else {
+                    daos.write((byte) 1)
+                    comment.write(daos)
+                }
+            }
+            daos.write(sig)
+            daos.close()
+            
+            payload = baos.toByteArray()
+        }
+        os.write(payload)
+    }
+    
+    public String toBase64() {
+        if (base64 == null) {
+            ByteArrayOutputStream baos = new ByteArrayOutputStream()
+            write(baos)
+            base64 = Base64.encode(baos.toByteArray())
+        }
+        return base64;
+    }
+    
+    @Override
+    public int hashCode() {
+        version.hashCode() ^ infoHash.hashCode() ^ timestamp.hashCode() ^ name.hashCode() ^ issuer.hashCode() ^ Objects.hashCode(comment)
+    }
+    
+    @Override
+    public boolean equals(Object o) {
+        if (!(o instanceof Certificate))
+            return false
+        Certificate other = (Certificate)o
+        
+        version == other.version &&
+            infoHash == other.infoHash &&
+            timestamp == other.timestamp &&
+            name == other.name &&
+            issuer == other.issuer &&
+            comment == other.comment
+    }
+}

core/src/main/groovy/com/muwire/core/filecert/CertificateClient.groovy

@@ -0,0 +1,95 @@
+package com.muwire.core.filecert
+
+import java.nio.charset.StandardCharsets
+import java.util.concurrent.ExecutorService
+import java.util.concurrent.Executors
+import java.util.logging.Level
+
+import net.i2p.data.Base64
+
+import com.muwire.core.Constants
+import com.muwire.core.EventBus
+import com.muwire.core.InvalidSignatureException
+import com.muwire.core.connection.Endpoint
+import com.muwire.core.connection.I2PConnector
+import com.muwire.core.util.DataUtil
+
+import groovy.util.logging.Log
+
+@Log
+class CertificateClient {
+    private final EventBus eventBus
+    private final I2PConnector connector
+    
+    private final ExecutorService fetcherThread = Executors.newSingleThreadExecutor()
+    
+    CertificateClient(EventBus eventBus, I2PConnector connector) {
+        this.eventBus = eventBus
+        this.connector = connector
+    }
+    
+    void onUIFetchCertificatesEvent(UIFetchCertificatesEvent e) {
+        fetcherThread.execute({
+            Endpoint endpoint = null
+            try {
+                eventBus.publish(new CertificateFetchEvent(status : CertificateFetchStatus.CONNECTING,
+                    user : e.host, infoHash : e.infoHash))
+                endpoint = connector.connect(e.host.destination)
+                
+                String infoHashString = Base64.encode(e.infoHash.getRoot())
+                OutputStream os = endpoint.getOutputStream()
+                os.write("CERTIFICATES ${infoHashString}\r\n\r\n".getBytes(StandardCharsets.US_ASCII))
+                
+                InputStream is = endpoint.getInputStream()
+                String code = DataUtil.readTillRN(is)
+                if (!code.startsWith("200"))
+                    throw new IOException("invalid code $code")
+
+                // parse all headers
+                Map<String,String> headers = new HashMap<>()
+                String header
+                while((header = DataUtil.readTillRN(is)) != "" && headers.size() < Constants.MAX_HEADERS) {
+                    int colon = header.indexOf(':')
+                    if (colon == -1 || colon == header.length() - 1)
+                        throw new IOException("invalid header $header")
+                    String key = header.substring(0, colon)
+                    String value = header.substring(colon + 1)
+                    headers[key] = value.trim()
+                }
+
+                if (!headers.containsKey("Count"))
+                    throw new IOException("No count header")
+                
+                int count = Integer.parseInt(headers['Count'])
+                
+                // start pulling the certs
+                eventBus.publish(new CertificateFetchEvent(status : CertificateFetchStatus.FETCHING, count : count,
+                    user : e.host, infoHash : e.infoHash))
+                
+                DataInputStream dis = new DataInputStream(is)
+                for (int i = 0; i < count; i++) {
+                    int size = dis.readUnsignedShort()
+                    byte [] tmp = new byte[size]
+                    dis.readFully(tmp)
+                    Certificate cert = null
+                    try {
+                        cert = new Certificate(new ByteArrayInputStream(tmp))
+                    } catch (IOException | InvalidSignatureException ignore) {
+                        log.log(Level.WARNING, "certificate creation failed",ignore)
+                        continue
+                    }
+                    if (cert.infoHash == e.infoHash)
+                        eventBus.publish(new CertificateFetchedEvent(certificate : cert, user : e.host, infoHash : e.infoHash))
+                }
+                eventBus.publish(new CertificateFetchEvent(status : CertificateFetchStatus.DONE, count : count,
+                    user : e.host, infoHash : e.infoHash))
+            } catch (Exception bad) {
+                log.log(Level.WARNING,"Fetching certificates failed", bad)
+                eventBus.publish(new CertificateFetchEvent(status : CertificateFetchStatus.FAILED,
+                    user : e.host, infoHash : e.infoHash))
+            } finally {
+                endpoint?.close()
+            }
+        })
+    }
+}

core/src/main/groovy/com/muwire/core/filecert/CertificateCreatedEvent.groovy

@@ -0,0 +1,7 @@
+package com.muwire.core.filecert
+
+import com.muwire.core.Event
+
+class CertificateCreatedEvent extends Event {
+    Certificate certificate
+}

core/src/main/groovy/com/muwire/core/filecert/CertificateFetchEvent.groovy

@@ -0,0 +1,12 @@
+package com.muwire.core.filecert
+
+import com.muwire.core.Event
+import com.muwire.core.InfoHash
+import com.muwire.core.Persona
+
+class CertificateFetchEvent extends Event {
+    CertificateFetchStatus status
+    int count
+    Persona user
+    InfoHash infoHash
+}

core/src/main/groovy/com/muwire/core/filecert/CertificateFetchStatus.java

@@ -0,0 +1,5 @@
+package com.muwire.core.filecert;
+
+public enum CertificateFetchStatus {
+    CONNECTING, FETCHING, DONE, FAILED
+}

core/src/main/groovy/com/muwire/core/filecert/CertificateFetchedEvent.groovy

@@ -0,0 +1,11 @@
+package com.muwire.core.filecert
+
+import com.muwire.core.Event
+import com.muwire.core.InfoHash
+import com.muwire.core.Persona
+
+class CertificateFetchedEvent extends Event {
+    Certificate certificate
+    Persona user
+    InfoHash infoHash
+}

core/src/main/groovy/com/muwire/core/filecert/CertificateManager.groovy

@@ -0,0 +1,146 @@
+package com.muwire.core.filecert
+
+import java.util.concurrent.ConcurrentHashMap
+import java.util.logging.Level
+
+import com.muwire.core.EventBus
+import com.muwire.core.InfoHash
+import com.muwire.core.InvalidSignatureException
+import com.muwire.core.Name
+import com.muwire.core.Persona
+import com.muwire.core.util.DataUtil
+
+import groovy.util.logging.Log
+import net.i2p.data.Base64
+import net.i2p.data.SigningPrivateKey
+import net.i2p.util.ConcurrentHashSet
+
+@Log
+class CertificateManager {
+    
+    private final EventBus eventBus
+    private final File certDir
+    private final Persona me
+    private final SigningPrivateKey spk
+    
+    final Map<InfoHash, Set<Certificate>> byInfoHash = new ConcurrentHashMap()
+    final Map<Persona, Set<Certificate>> byIssuer = new ConcurrentHashMap()
+    
+    CertificateManager(EventBus eventBus, File home, Persona me, SigningPrivateKey spk) {
+        this.eventBus = eventBus
+        this.me = me
+        this.spk = spk
+        this.certDir = new File(home, "filecerts")
+        if (!certDir.exists())
+            certDir.mkdirs()
+        else
+            loadCertificates()
+    }
+    
+    private void loadCertificates() {
+        certDir.listFiles({ dir, name ->
+            name.endsWith("mwcert")
+        } as FilenameFilter).each { certFile ->
+            Certificate cert = null
+            try {
+                certFile.withInputStream {
+                    cert = new Certificate(it)
+                }
+            } catch (IOException | InvalidSignatureException ignore) {
+                log.log(Level.WARNING, "Certificate failed to load from $certFile", ignore)
+                return
+            }
+            
+            Set<Certificate> existing = byInfoHash.get(cert.infoHash)
+            if (existing == null) {
+                existing = new ConcurrentHashSet<>()
+                byInfoHash.put(cert.infoHash, existing)
+            }
+            existing.add(cert)
+            
+            existing = byIssuer.get(cert.issuer)
+            if (existing == null) {
+                existing = new ConcurrentHashSet<>()
+                byIssuer.put(cert.issuer, existing)
+            }
+            existing.add(cert)
+            
+            eventBus.publish(new CertificateCreatedEvent(certificate : cert))
+        }
+    }
+    
+    void onUICreateCertificateEvent(UICreateCertificateEvent e) {
+        InfoHash infoHash = new InfoHash(e.sharedFile.getRoot())
+        String name = e.sharedFile.getFile().getName()
+        long timestamp = System.currentTimeMillis()
+        
+        String comment = null
+        if (e.sharedFile.getComment() != null)
+            comment = DataUtil.readi18nString(Base64.decode(e.sharedFile.getComment()))
+        
+        Certificate cert = new Certificate(infoHash, name, timestamp, me, comment, spk)
+        
+        
+        if (addToMaps(cert)) {
+            saveCert(cert)
+            eventBus.publish(new CertificateCreatedEvent(certificate : cert))
+        }
+    }
+    
+    void onUIImportCertificateEvent(UIImportCertificateEvent e) {
+        Certificate cert = e.certificate
+        if (!addToMaps(cert))
+            return
+        saveCert(cert)
+    }
+
+    private void saveCert(Certificate cert) {
+        String infoHashString = Base64.encode(cert.infoHash.getRoot())
+        File certFile = new File(certDir, "${infoHashString}_${cert.issuer.getHumanReadableName()}_${cert.timestamp}.mwcert")
+        certFile.withOutputStream { cert.write(it) }
+    }
+    
+    private boolean addToMaps(Certificate cert) {
+        boolean added = true
+
+        Set<Certificate> existing = byInfoHash.get(cert.infoHash)
+        if (existing == null) {
+            existing = new ConcurrentHashSet<>()
+            byInfoHash.put(cert.infoHash, existing)
+        }
+        added &= existing.add(cert)
+
+        existing = byIssuer.get(cert.issuer)
+        if (existing == null) {
+            existing = new ConcurrentHashSet<>()
+            byIssuer.put(cert.issuer, existing)
+        }
+        added &= existing.add(cert)
+        added
+    }
+    
+    public boolean hasLocalCertificate(InfoHash infoHash) {
+        if (!byInfoHash.containsKey(infoHash))
+            return false
+        Set<Certificate> set = byInfoHash.get(infoHash)
+        for (Certificate cert : set) {
+            if (cert.issuer == me)
+                return true
+        }
+        return false
+    }
+    
+    public boolean isImported(Certificate certificate) {
+        Set<Certificate> forInfoHash = byInfoHash.get(certificate.infoHash)
+        if (forInfoHash == null)
+            return false
+        forInfoHash.contains(certificate)
+    }
+    
+    Set<Certificate> getByInfoHash(InfoHash infoHash) {
+        Set<Certificate> rv = new HashSet<>()
+        if (byInfoHash.containsKey(infoHash))
+            rv.addAll(byInfoHash.get(infoHash))
+        rv
+    }    
+}

core/src/main/groovy/com/muwire/core/filecert/UICreateCertificateEvent.groovy

@@ -0,0 +1,8 @@
+package com.muwire.core.filecert
+
+import com.muwire.core.Event
+import com.muwire.core.SharedFile
+
+class UICreateCertificateEvent extends Event {
+    SharedFile sharedFile
+}

core/src/main/groovy/com/muwire/core/filecert/UIFetchCertificatesEvent.groovy

@@ -0,0 +1,10 @@
+package com.muwire.core.filecert
+
+import com.muwire.core.Event
+import com.muwire.core.InfoHash
+import com.muwire.core.Persona
+
+class UIFetchCertificatesEvent extends Event {
+    Persona host
+    InfoHash infoHash
+}

core/src/main/groovy/com/muwire/core/filecert/UIImportCertificateEvent.groovy

@@ -0,0 +1,7 @@
+package com.muwire.core.filecert
+
+import com.muwire.core.Event
+
+class UIImportCertificateEvent extends Event {
+    Certificate certificate
+}

core/src/main/groovy/com/muwire/core/filefeeds/FeedClient.groovy

@@ -0,0 +1,110 @@
+package com.muwire.core.filefeeds
+
+import java.util.logging.Level
+import java.nio.charset.StandardCharsets
+import java.util.concurrent.Executor
+import java.util.concurrent.ExecutorService
+import java.util.concurrent.Executors
+import java.util.zip.GZIPInputStream
+
+import com.muwire.core.EventBus
+import com.muwire.core.Persona
+import com.muwire.core.connection.Endpoint
+import com.muwire.core.connection.I2PConnector
+import com.muwire.core.util.DataUtil
+
+import groovy.json.JsonSlurper
+import groovy.util.logging.Log
+
+@Log
+class FeedClient {
+    
+    private final I2PConnector connector
+    private final EventBus eventBus
+    private final Persona me
+    private final FeedManager feedManager
+    
+    private final ExecutorService feedFetcher = Executors.newCachedThreadPool() 
+    private final Timer feedUpdater = new Timer("feed-updater", true)
+    
+    FeedClient(I2PConnector connector, EventBus eventBus, Persona me, FeedManager feedManager) {
+        this.connector = connector
+        this.eventBus = eventBus
+        this.me = me
+        this.feedManager = feedManager
+    }
+    
+    private void start() {
+        feedUpdater.schedule({updateAnyFeeds()} as TimerTask, 60000, 60000)
+    }
+    
+    private void stop() {
+        feedUpdater.cancel()
+        feedFetcher.shutdown()
+    }
+    
+    private void updateAnyFeeds() {
+        feedManager.getFeedsToUpdate().each { feed ->
+            feedFetcher.execute({updateFeed(feed)} as Runnable)
+        }
+    }
+    
+    void onUIFeedUpdateEvent(UIFeedUpdateEvent e) {
+        Feed feed = feedManager.getFeed(e.host)
+        if (feed == null) {
+            log.severe("UI request to update non-existent feed " + e.host.getHumanReadableName())
+            return
+        }
+        
+        feedFetcher.execute({updateFeed(feed)} as Runnable)
+    }
+    
+    private void updateFeed(Feed feed) {
+        log.info("updating feed " + feed.getPublisher().getHumanReadableName())
+        Endpoint endpoint = null
+        try {
+            eventBus.publish(new FeedFetchEvent(host : feed.getPublisher(), status : FeedFetchStatus.CONNECTING))
+            feed.setLastUpdateAttempt(System.currentTimeMillis())
+            endpoint = connector.connect(feed.getPublisher().getDestination())
+            OutputStream os = endpoint.getOutputStream()
+            os.write("FEED\r\n".getBytes(StandardCharsets.US_ASCII))
+            os.write("Persona:${me.toBase64()}\r\n".getBytes(StandardCharsets.US_ASCII))
+            os.write("Timestamp:${feed.getLastUpdated()}\r\n".getBytes(StandardCharsets.US_ASCII))
+            os.write("\r\n".getBytes(StandardCharsets.US_ASCII))
+            os.flush()
+            
+            InputStream is = endpoint.getInputStream()
+            String code = DataUtil.readTillRN(is)
+            if (!code.startsWith("200"))
+                throw new IOException("Invalid code $code")
+                
+            // parse all headers
+            Map<String,String> headers = DataUtil.readAllHeaders(is)
+            
+            if (!headers.containsKey("Count"))
+                throw new IOException("No count header")
+            
+            int items = Integer.parseInt(headers['Count'])
+            
+            eventBus.publish(new FeedFetchEvent(host : feed.getPublisher(), status : FeedFetchStatus.FETCHING, totalItems: items))
+            
+            JsonSlurper slurper = new JsonSlurper()
+            DataInputStream dis = new DataInputStream(new GZIPInputStream(is))
+            for (int i = 0; i < items; i++) {
+                int size = dis.readUnsignedShort()
+                byte [] tmp = new byte[size]
+                dis.readFully(tmp)
+                def json = slurper.parse(tmp)
+                FeedItem item = FeedItems.objToFeedItem(json, feed.getPublisher())
+                eventBus.publish(new FeedItemFetchedEvent(item: item))
+            }
+            
+            eventBus.publish(new FeedFetchEvent(host : feed.getPublisher(), status : FeedFetchStatus.FINISHED))
+        } catch (Exception bad) {
+            log.log(Level.WARNING, "Feed update failed", bad)
+            eventBus.publish(new FeedFetchEvent(host : feed.getPublisher(), status : FeedFetchStatus.FAILED)) 
+        } finally {
+            endpoint?.close()
+        }
+    }
+}

core/src/main/groovy/com/muwire/core/filefeeds/FeedFetchEvent.groovy

@@ -0,0 +1,10 @@
+package com.muwire.core.filefeeds
+
+import com.muwire.core.Event
+import com.muwire.core.Persona
+
+class FeedFetchEvent extends Event {
+    Persona host
+    FeedFetchStatus status
+    int totalItems
+}

core/src/main/groovy/com/muwire/core/filefeeds/FeedItemFetchedEvent.groovy

@@ -0,0 +1,7 @@
+package com.muwire.core.filefeeds
+
+import com.muwire.core.Event
+
+class FeedItemFetchedEvent extends Event {
+    FeedItem item
+}

core/src/main/groovy/com/muwire/core/filefeeds/FeedItemLoadedEvent.groovy

@@ -0,0 +1,7 @@
+package com.muwire.core.filefeeds
+
+import com.muwire.core.Event
+
+class FeedItemLoadedEvent extends Event {
+    FeedItem item
+}

core/src/main/groovy/com/muwire/core/filefeeds/FeedItems.groovy

@@ -0,0 +1,79 @@
+package com.muwire.core.filefeeds
+
+import com.muwire.core.InfoHash
+import com.muwire.core.Persona
+import com.muwire.core.SharedFile
+import com.muwire.core.files.FileHasher
+import com.muwire.core.util.DataUtil
+
+import net.i2p.data.Base64
+
+class FeedItems {
+    
+    public static def sharedFileToObj(SharedFile sf, int certificates) {
+        def json = [:]
+        json.type = "FeedItem"
+        json.version = 1
+        json.name = Base64.encode(DataUtil.encodei18nString(sf.getFile().getName()))
+        json.infoHash = Base64.encode(sf.getRoot())
+        json.size = sf.getCachedLength()
+        json.pieceSize = sf.getPieceSize()
+        
+        if (sf.getComment() != null)
+            json.comment = sf.getComment()
+        
+        json.certificates = certificates
+        
+        json.timestamp = sf.getPublishedTimestamp()
+        
+        json
+    } 
+    
+    public static FeedItem objToFeedItem(def obj, Persona publisher) throws InvalidFeedItemException {
+        if (obj.timestamp == null)
+            throw new InvalidFeedItemException("No timestamp");
+        if (obj.name == null)
+            throw new InvalidFeedItemException("No name");
+        if (obj.size == null || obj.size <= 0 || obj.size > FileHasher.MAX_SIZE)
+            throw new InvalidFeedItemException("length missing or invalid ${obj.size}")
+        if (obj.pieceSize == null || obj.pieceSize < FileHasher.MIN_PIECE_SIZE_POW2 || obj.pieceSize > FileHasher.MAX_PIECE_SIZE_POW2)
+            throw new InvalidFeedItemException("piece size missing or invalid ${obj.pieceSize}")
+        if (obj.infoHash == null)
+            throw new InvalidFeedItemException("Infohash missing")
+        
+            
+        InfoHash infoHash
+        try {
+            infoHash = new InfoHash(Base64.decode(obj.infoHash))
+        } catch (Exception bad) {
+            throw new InvalidFeedItemException("Invalid infohash", bad)
+        }
+        
+        String name
+        try {
+            name = DataUtil.readi18nString(Base64.decode(obj.name))
+        } catch (Exception bad) {
+            throw new InvalidFeedItemException("Invalid name", bad)
+        }
+        
+        int certificates = 0
+        if (obj.certificates != null)
+            certificates = obj.certificates
+        
+        new FeedItem(publisher, obj.timestamp, name, obj.size, obj.pieceSize, infoHash, certificates, obj.comment)
+    }
+    
+    public static def feedItemToObj(FeedItem item) {
+        def json = [:]
+        json.type = "FeedItem"
+        json.version = 1
+        json.name = Base64.encode(DataUtil.encodei18nString(item.getName()))
+        json.infoHash = Base64.encode(item.getInfoHash().getRoot())
+        json.size = item.getSize()
+        json.pieceSize = item.getPieceSize()
+        json.timestamp = item.getTimestamp()
+        json.certificates = item.getCertificates()
+        json.comment = item.getComment()
+        json
+    }
+}

core/src/main/groovy/com/muwire/core/filefeeds/FeedLoadedEvent.groovy

@@ -0,0 +1,7 @@
+package com.muwire.core.filefeeds
+
+import com.muwire.core.Event
+
+class FeedLoadedEvent extends Event {
+    Feed feed
+}