Release 0.5.2

Add info about the default I2CP port to README.md

README.md

@@ -4,11 +4,11 @@ MuWire is an easy to use file-sharing program which offers anonymity using [I2P
 
 It is inspired by the LimeWire Gnutella client and developped by a former LimeWire developer.
 
-The current stable release - 0.2.5 is avaiable for download at http://muwire.com.  You can find technical documentation in the "doc" folder.
+The current stable release - 0.4.15 is avaiable for download at https://muwire.com.  You can find technical documentation in the "doc" folder.
 
 ### Building
 
-You need JRE 8 or newer.  After installing that and setting up the appropriate paths, just type
+You need JDK 8 or newer.  After installing that and setting up the appropriate paths, just type
 
 ```
 ./gradlew clean assemble
@@ -19,38 +19,23 @@ 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 https://github.com/zlatinb/muwire-pkg project
 
 ### Running
 
-You need to have an I2P router up and running on the same machine.  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.  If you use a custom I2CP host and port, create a file $HOME/.MuWire/i2p.properties and put "i2cp.tcp.host=<host>" and "i2cp.tcp.port=<port>" in there.
+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 gui-x.y.z.jar` in a terminal or command prompt.
 
-The first time you run MuWire it will ask you to select a nickname.  This nickname will be displayed with search results, so that others can verify the file was shared by you.  It is best to leave MuWire running all the time, just like I2P.
+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`
+
+[Default I2CP port]\: `7654`
+
+### GPG Fingerprint
+
+```
+471B 9FD4 5517 A5ED 101F  C57D A728 3207 2D52 5E41
+```
+
+You can find the full key at https://keybase.io/zlatinb
 
 
-### Known bugs and limitations
-
-* Many UI features you would expect are not there yet
-
-### Quick FAQ
-
-* why is MuWire slow ?
-  
-  - too few sources you're downloading from
-  - you can increase the number of tunnels by using more tunnels via Options->I2P Inbound/Outbound Quantity 
-    the default is 4 and you could raise up to as high as 16 ( Caution !!!!)
-
-* my search is not returning (enough) results !
-
-  - search is keyword or hash based
-  - keywords and hash(es) are NOT regexed or wildcarded so they have to be complete
-    so searching for 'musi' will not return results with 'music' - you have to search for 'music'
-  - ALL keywords have to match 
-  - only use space for keyword separation
-  - if you already have the file in question it is not displayed ( can be changed via Options )
-
-* what's this right click -> 'Copy hash to clipboard' for ?
-
-  - if you have a specific file you wish to share or download you can use the hash as a unique identifier
-    to make sure you have exactly the right file.
-  - you can share this hash with others to ensure they are getting the right file
+[Default I2CP port]: https://geti2p.net/en/docs/ports

TODO.md

@@ -12,18 +12,6 @@ This reduces query traffic by not sending last hop queries to peers that definit
 
 This helps with scalability
 
-##### Trust List Sharing
-
-For helping users make better decisions whom to trust
-
-##### Content Control Panel
-
-To allow every user to not route queries for content they do not like.  This is mostly GUI work, the backend part is simple
-
-##### Packaging With JRE, Embedded Router
-
-For ease of deployment for new users, and so that users do not need to run a separate I2P router
-
 ##### Web UI, REST Interface, etc.
 
 Basically any non-gui non-cli user interface
@@ -35,7 +23,4 @@ To enable parsing of metadata from known file types and the user editing it or a
 ### Small Items
 
 * Wrapper of some kind for in-place upgrades
-* Download file sequentially
-* Unsharing of files
-* Multiple-selection download, Ctrl-A
-* Pause/Resume downloads
+* Automatic adjustment of number of I2P tunnels

build.gradle

@@ -2,7 +2,7 @@ subprojects {
     apply plugin: 'groovy'
 
     dependencies {
-        compile 'net.i2p:i2p:0.9.40'
+        compile "net.i2p:i2p:${i2pVersion}"
         compile 'org.codehaus.groovy:groovy-all:2.4.15'
     }
 

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

@@ -35,7 +35,7 @@ class Cli {
 
         Core core
         try {
-            core = new Core(props, home, "0.3.6")
+            core = new Core(props, home, "0.5.2")
         } 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.3.6")
+            core = new Core(props, home, "0.5.2")
         } catch (Exception bad) {
             bad.printStackTrace(System.out)
             println "Failed to initialize core, exiting"

core/build.gradle

@@ -2,8 +2,9 @@ apply plugin : 'application'
 mainClassName = 'com.muwire.core.Core'
 applicationDefaultJvmArgs = ['-Djava.util.logging.config.file=logging.properties']
 dependencies {
-    compile 'net.i2p.client:mstreaming:0.9.40'
-    compile 'net.i2p.client:streaming:0.9.40'
+    compile "net.i2p:router:${i2pVersion}"
+    compile "net.i2p.client:mstreaming:${i2pVersion}"
+    compile "net.i2p.client:streaming:${i2pVersion}"
 
     testCompile 'org.junit.jupiter:junit-jupiter-api:5.4.2'    
     testCompile 'junit:junit:4.12'

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

@@ -1,15 +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 float DOWNLOAD_SEQUENTIAL_RATIO = 0.8f
-    
-    public static final String SPLIT_PATTERN = "[\\+\\-,\\.:;\\(\\)=_/\\\\\\!\\\"\\\'\\\$%\\|]"
-}

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

@@ -20,6 +20,7 @@ import com.muwire.core.download.UIDownloadPausedEvent
 import com.muwire.core.download.UIDownloadResumedEvent
 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
@@ -27,21 +28,32 @@ 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.UICommentEvent
+import com.muwire.core.files.UIPersistFilesEvent
+import com.muwire.core.files.AllFilesLoadedEvent
+import com.muwire.core.files.DirectoryUnsharedEvent
 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.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
+import com.muwire.core.trust.TrustSubscriber
+import com.muwire.core.trust.TrustSubscriptionEvent
 import com.muwire.core.update.UpdateClient
 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 groovy.util.logging.Log
 import net.i2p.I2PAppContext
@@ -58,6 +70,9 @@ import net.i2p.data.PrivateKey
 import net.i2p.data.Signature
 import net.i2p.data.SigningPrivateKey
 
+import net.i2p.router.Router
+import net.i2p.router.RouterContext
+
 @Log
 public class Core {
 
@@ -68,6 +83,7 @@ public class Core {
     final MuWireSettings muOptions
 
     private final TrustService trustService
+    private final TrustSubscriber trustSubscriber
     private final PersisterService persisterService
     private final HostCache hostCache
     private final ConnectionManager connectionManager
@@ -79,25 +95,16 @@ public class Core {
     private final DownloadManager downloadManager
     private final DirectoryWatcher directoryWatcher
     final FileManager fileManager
+    final UploadManager uploadManager
+    final ContentManager contentManager
+
+    private final Router router
 
     final AtomicBoolean shutdown = new AtomicBoolean()
 
     public Core(MuWireSettings props, File home, String myVersion) {
         this.home = home
         this.muOptions = props
-        log.info "Initializing I2P context"
-        I2PAppContext.getGlobalContext().logManager()
-        I2PAppContext.getGlobalContext()._logManager = new MuWireLogManager()
-        
-		log.info("initializing I2P socket manager")
-		def i2pClient = new I2PClientFactory().createClient()
-		File keyDat = new File(home, "key.dat")
-		if (!keyDat.exists()) {
-			log.info("Creating new key.dat")
-			keyDat.withOutputStream { 
-				i2pClient.createDestination(it, Constants.SIG_TYPE)
-			}
-		}
 
         i2pOptions = new Properties()
         def i2pOptionsFile = new File(home,"i2p.properties")
@@ -117,8 +124,48 @@ public class Core {
             i2pOptions["outbound.quantity"] = "4"
             i2pOptions["i2cp.tcp.host"] = "127.0.0.1"
             i2pOptions["i2cp.tcp.port"] = "7654"
+            Random r = new Random()
+            int port = r.nextInt(60000) + 4000
+            i2pOptions["i2np.ntcp.port"] = String.valueOf(port)
+            i2pOptions["i2np.udp.port"] = String.valueOf(port)
+            i2pOptionsFile.withOutputStream { i2pOptions.store(it, "") }
         }
 
+        if (!props.embeddedRouter) {
+            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("router.excludePeerCaps", "KLM")
+            routerProps.setProperty("i2np.inboundKBytesPerSecond", String.valueOf(props.inBw))
+            routerProps.setProperty("i2np.outboundKBytesPerSecond", String.valueOf(props.outBw))
+            routerProps.setProperty("i2cp.disableInterface", "true")
+            routerProps.setProperty("i2np.ntcp.port", i2pOptions["i2np.ntcp.port"])
+            routerProps.setProperty("i2np.udp.port", i2pOptions["i2np.udp.port"])
+            routerProps.setProperty("i2np.udp.internalPort", i2pOptions["i2np.udp.port"])
+            router = new Router(routerProps)
+            router.getContext().setLogManager(new MuWireLogManager())
+            router.runRouter()
+            while(!router.isRunning())
+                Thread.sleep(100)
+        }
+
+        log.info("initializing I2P socket manager")
+        def i2pClient = new I2PClientFactory().createClient()
+        File keyDat = new File(home, "key.dat")
+        if (!keyDat.exists()) {
+            log.info("Creating new key.dat")
+            keyDat.withOutputStream {
+                i2pClient.createDestination(it, Constants.SIG_TYPE)
+            }
+        }
+
+
         // options like tunnel length and quantity
         I2PSession i2pSession
         I2PSocketManager socketManager
@@ -171,14 +218,17 @@ public class Core {
         eventBus.register(FileDownloadedEvent.class, fileManager)
         eventBus.register(FileUnsharedEvent.class, fileManager)
         eventBus.register(SearchEvent.class, fileManager)
+        eventBus.register(DirectoryUnsharedEvent.class, fileManager)
+        eventBus.register(UICommentEvent.class, fileManager)
 
         log.info("initializing mesh manager")
-        MeshManager meshManager = new MeshManager(fileManager)
+        MeshManager meshManager = new MeshManager(fileManager, home, props)
         eventBus.register(SourceDiscoveredEvent.class, meshManager)
 
         log.info "initializing persistence service"
-		persisterService = new PersisterService(new File(home, "files.json"), eventBus, 15000, fileManager)
+        persisterService = new PersisterService(new File(home, "files.json"), eventBus, 60000, fileManager)
         eventBus.register(UILoadedEvent.class, persisterService)
+        eventBus.register(UIPersistFilesEvent.class, persisterService)
 
         log.info("initializing host cache")
         File hostStorage = new File(home, "hosts.json")
@@ -199,13 +249,15 @@ public class Core {
         cacheClient = new CacheClient(eventBus,hostCache, connectionManager, i2pSession, props, 10000)
 
         log.info("initializing update client")
-        updateClient = new UpdateClient(eventBus, i2pSession, myVersion, props)
+        updateClient = new UpdateClient(eventBus, i2pSession, myVersion, props, fileManager, me)
+        eventBus.register(FileDownloadedEvent.class, updateClient)
+        eventBus.register(UIResultBatchEvent.class, updateClient)
 
         log.info("initializing connector")
         I2PConnector i2pConnector = new I2PConnector(socketManager)
 
         log.info "initializing results sender"
-		ResultsSender resultsSender = new ResultsSender(eventBus, i2pConnector, me)
+        ResultsSender resultsSender = new ResultsSender(eventBus, i2pConnector, me, props)
 
         log.info "initializing search manager"
         SearchManager searchManager = new SearchManager(eventBus, me, resultsSender)
@@ -223,7 +275,7 @@ public class Core {
         eventBus.register(UIDownloadResumedEvent.class, downloadManager)
 
         log.info("initializing upload manager")
-        UploadManager uploadManager = new UploadManager(eventBus, fileManager, meshManager, downloadManager)
+        uploadManager = new UploadManager(eventBus, fileManager, meshManager, downloadManager)
 
         log.info("initializing connection establisher")
         connectionEstablisher = new ConnectionEstablisher(eventBus, i2pConnector, props, connectionManager, hostCache)
@@ -231,20 +283,38 @@ public class Core {
         log.info("initializing acceptor")
         I2PAcceptor i2pAcceptor = new I2PAcceptor(socketManager)
         connectionAcceptor = new ConnectionAcceptor(eventBus, connectionManager, props,
-            i2pAcceptor, hostCache, trustService, searchManager, uploadManager, connectionEstablisher)
+            i2pAcceptor, hostCache, trustService, searchManager, uploadManager, fileManager, connectionEstablisher)
 
         log.info("initializing directory watcher")
-        directoryWatcher = new DirectoryWatcher(eventBus, fileManager)
+        directoryWatcher = new DirectoryWatcher(eventBus, fileManager, home, props)
         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)
+        eventBus.register(UILoadedEvent.class, trustSubscriber)
+        eventBus.register(TrustSubscriptionEvent.class, trustSubscriber)
+        
+        log.info("initializing content manager")
+        contentManager = new ContentManager()
+        eventBus.register(ContentControlEvent.class, contentManager)
+        eventBus.register(QueryEvent.class, contentManager)
+        
+        log.info("initializing browse manager")
+        BrowseManager browseManager = new BrowseManager(i2pConnector, eventBus)
+        eventBus.register(UIBrowseEvent.class, browseManager)
+        
     }
 
     public void startServices() {
         hasherService.start()
-        directoryWatcher.start()
         trustService.start()
         trustService.waitForLoad()
         hostCache.start()
@@ -261,6 +331,8 @@ public class Core {
             log.info("already shutting down")
             return
         }
+        log.info("shutting down trust subscriber")
+        trustSubscriber.stop()
         log.info("shutting down download manageer")
         downloadManager.shutdown()
         log.info("shutting down connection acceeptor")
@@ -269,8 +341,14 @@ public class Core {
         connectionEstablisher.stop()
         log.info("shutting down directory watcher")
         directoryWatcher.stop()
+        log.info("shutting down cache client")
+        cacheClient.stop()
         log.info("shutting down connection manager")
         connectionManager.shutdown()
+        if (router != null) {
+            log.info("shutting down embedded router")
+            router.shutdown(0)
+        }
     }
 
     static main(args) {
@@ -297,7 +375,7 @@ public class Core {
             }
         }
 
-        Core core = new Core(props, home, "0.3.6")
+        Core core = new Core(props, home, "0.5.2")
         core.startServices()
 
         // ... at the end, sleep or execute script

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

@@ -48,4 +48,9 @@ class EventBus {
         }
         currentHandlers.add handler
     }
+    
+    synchronized void unregister(Class<? extends Event> eventType, def handler) {
+        log.info("Unregistering $handler for type $eventType")
+        handlers[eventType]?.remove(handler)
+    }
 }

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

@@ -6,18 +6,37 @@ 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 updateCheckInterval
+    boolean autoDownloadUpdate
+    String updateType
     String nickname
     File downloadLocation
+    File incompleteLocation
     CrawlerResponse crawlerResponse
     boolean shareDownloadedFiles
+    boolean shareHiddenFiles
+    boolean searchComments
+    boolean browseFiles
     Set<String> watchedDirectories
+    float downloadSequentialRatio
+    int hostClearInterval, hostHopelessInterval, hostRejectInterval
+    int meshExpiration
+    int speedSmoothSeconds
+    boolean embeddedRouter
+    int inBw, outBw
+    Set<String> watchedKeywords
+    Set<String> watchedRegexes
 
     MuWireSettings() {
         this(new Properties())
@@ -25,20 +44,46 @@ class MuWireSettings {
 
     MuWireSettings(Properties props) {
         isLeaf = Boolean.valueOf(props.get("leaf","false"))
-		allowUntrusted = Boolean.valueOf(props.get("allowUntrusted","true"))
+        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"))
         updateCheckInterval = Integer.parseInt(props.getProperty("updateCheckInterval","24"))
+        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","15"))
+        hostHopelessInterval = Integer.valueOf(props.getProperty("hostHopelessInterval", "1440"))
+        hostRejectInterval = Integer.valueOf(props.getProperty("hostRejectInterval", "1"))
+        meshExpiration = Integer.valueOf(props.getProperty("meshExpiration","60"))
+        embeddedRouter = Boolean.valueOf(props.getProperty("embeddedRouter","false"))
+        inBw = Integer.valueOf(props.getProperty("inBw","256"))
+        outBw = Integer.valueOf(props.getProperty("outBw","128"))
+        searchComments = Boolean.valueOf(props.getProperty("searchComments","true"))
+        browseFiles = Boolean.valueOf(props.getProperty("browseFiles","true"))
+        speedSmoothSeconds = Integer.valueOf(props.getProperty("speedSmoothSeconds","60"))
 
-        watchedDirectories = new HashSet<>()
-        if (props.containsKey("watchedDirectories")) {
-            String[] encoded = props.getProperty("watchedDirectories").split(",")
-            encoded.each { watchedDirectories << DataUtil.readi18nString(Base64.decode(it)) }
+        watchedDirectories = readEncodedSet(props, "watchedDirectories")
+        watchedKeywords = readEncodedSet(props, "watchedKeywords")
+        watchedRegexes = readEncodedSet(props, "watchedRegexes")
+
+        trustSubscriptions = new HashSet<>()
+        if (props.containsKey("trustSubscriptions")) {
+            props.getProperty("trustSubscriptions").split(",").each {
+                trustSubscriptions.add(new Persona(new ByteArrayInputStream(Base64.decode(it))))
             }
+        }
+        
         
     }
 
@@ -46,23 +91,64 @@ class MuWireSettings {
         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("updateCheckInterval", String.valueOf(updateCheckInterval))
+        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("meshExpiration", String.valueOf(meshExpiration))
+        props.setProperty("embeddedRouter", String.valueOf(embeddedRouter))
+        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("speedSmoothSeconds", String.valueOf(speedSmoothSeconds))
 
-        if (!watchedDirectories.isEmpty()) {
-            String encoded = watchedDirectories.stream().
-                map({Base64.encode(DataUtil.encodei18nString(it))}).
+        writeEncodedSet(watchedDirectories, "watchedDirectories", props)
+        writeEncodedSet(watchedKeywords, "watchedKeywords", props)
+        writeEncodedSet(watchedRegexes, "watchedRegexes", props)
+
+        if (!trustSubscriptions.isEmpty()) {
+            String encoded = trustSubscriptions.stream().
+                map({it.toBase64()}).
                 collect(Collectors.joining(","))
-            props.setProperty("watchedDirectories", encoded)
+            props.setProperty("trustSubscriptions", encoded)
         }
 
         props.store(out, "")
     }
     
+    private static Set<String> readEncodedSet(Properties props, String property) {
+        Set<String> rv = new ConcurrentHashSet<>()
+        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)
+    }
+
     boolean isLeaf() {
         isLeaf
     }

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

@@ -82,4 +82,13 @@ public class Persona {
         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,7 @@
+package com.muwire.core
+
+class SplitPattern {
+    
+    public static final String SPLIT_PATTERN = "[\\*\\+\\-,\\.:;\\(\\)=_/\\\\\\!\\\"\\\'\\\$%\\|\\[\\]\\{\\}\\?]";
+    
+}

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

@@ -22,6 +22,9 @@ import net.i2p.data.Destination
 @Log
 abstract class Connection implements Closeable {
 
+    private static final int SEARCHES = 10
+    private static final long INTERVAL = 1000
+
     final EventBus eventBus
     final Endpoint endpoint
     final boolean incoming
@@ -32,6 +35,7 @@ abstract class Connection implements Closeable {
     private final AtomicBoolean running = new AtomicBoolean()
     private final BlockingQueue messages = new LinkedBlockingQueue()
     private final Thread reader, writer
+    private final LinkedList<Long> searchTimestamps = new LinkedList<>()
 
     protected final String name
 
@@ -128,6 +132,8 @@ 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()
@@ -156,7 +162,25 @@ abstract class Connection implements Closeable {
         }
     }
 
+    private boolean throttleSearch() {
+        final long now = System.currentTimeMillis()
+        if (searchTimestamps.size() < SEARCHES) {
+            searchTimestamps.addLast(now)
+            return false
+        }
+        Long oldest = searchTimestamps.getFirst()
+        if (now - oldest.longValue() < INTERVAL)
+            return true
+        searchTimestamps.addLast(now)
+        searchTimestamps.removeFirst()
+        false
+    }
+
     protected void handleSearch(def search) {
+        if (throttleSearch()) {
+            log.info("dropping excessive search")
+            return
+        }
         UUID uuid = UUID.fromString(search.uuid)
         byte [] infohash = null
         if (search.infohash != null) {
@@ -187,11 +211,19 @@ 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
 
         SearchEvent searchEvent = new SearchEvent(searchTerms : search.keywords,
                                             searchHash : infohash,
                                             uuid : uuid,
-                                            oobInfohash : oob)
+                                            oobInfohash : oob,
+                                            searchComments : searchComments,
+                                            compressedResults : compressedResults)
         QueryEvent event = new QueryEvent ( searchEvent : searchEvent,
                                             replyTo : replyTo,
                                             originator : originator,

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

@@ -5,17 +5,23 @@ 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.MuWireSettings
 import com.muwire.core.Persona
+import com.muwire.core.files.FileManager
 import com.muwire.core.hostcache.HostCache
 import com.muwire.core.trust.TrustLevel
 import com.muwire.core.trust.TrustService
 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
@@ -24,6 +30,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 {
@@ -36,6 +43,7 @@ class ConnectionAcceptor {
     final TrustService trustService
     final SearchManager searchManager
     final UploadManager uploadManager
+    final FileManager fileManager
     final ConnectionEstablisher establisher
 
     final ExecutorService acceptorThread
@@ -46,7 +54,7 @@ class ConnectionAcceptor {
     ConnectionAcceptor(EventBus eventBus, UltrapeerConnectionManager manager,
         MuWireSettings settings, I2PAcceptor acceptor, HostCache hostCache,
         TrustService trustService, SearchManager searchManager, UploadManager uploadManager,
-        ConnectionEstablisher establisher) {
+        FileManager fileManager, ConnectionEstablisher establisher) {
         this.eventBus = eventBus
         this.manager = manager
         this.settings = settings
@@ -54,6 +62,7 @@ class ConnectionAcceptor {
         this.hostCache = hostCache
         this.trustService = trustService
         this.searchManager = searchManager
+        this.fileManager = fileManager
         this.uploadManager = uploadManager
         this.establisher = establisher
 
@@ -125,6 +134,15 @@ 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
                 default:
                     throw new Exception("Invalid read $read")
             }
@@ -225,7 +243,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++) {
@@ -243,4 +261,146 @@ class ConnectionAcceptor {
         }
     }
     
+    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 = 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("Sender"))
+                throw new IOException("No Sender header")
+            if (!headers.containsKey("Count"))
+                throw new IOException("No Count header")
+                
+            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)
+            }
+            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")
+            String header
+            while ((header = DataUtil.readTillRN(dis)) != ""); // ignore headers for now
+
+            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
+            }
+
+
+            os.write("200 OK\r\n".getBytes(StandardCharsets.US_ASCII))
+
+            def sharedFiles = fileManager.getSharedFiles().values()
+
+            os.write("Count: ${sharedFiles.size()}\r\n\r\n".getBytes(StandardCharsets.US_ASCII))
+
+            DataOutputStream dos = new DataOutputStream(new GZIPOutputStream(os))
+            JsonOutput jsonOutput = new JsonOutput()
+            sharedFiles.each {
+                def obj = ResultsSender.sharedFileToObj(it, false)
+                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) {
+        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")
+            String header
+            while ((header = DataUtil.readTillRN(dis)) != ""); // ignore headers for now
+
+                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
+            }
+
+            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)
+            }
+
+            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)
+            }
+
+            dos.flush()
+        } finally {
+            e.close()
+        }
+    }
+
 }

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

@@ -31,7 +31,7 @@ class ConnectionEstablisher {
     final HostCache hostCache
 
     final Timer timer
-	final ExecutorService executor
+    final ExecutorService executor, closer
 
     final Set inProgress = new ConcurrentHashSet()
 
@@ -51,6 +51,8 @@ class ConnectionEstablisher {
             rv.setName("connector-${System.currentTimeMillis()}")
             rv
         } as ThreadFactory)
+        
+        closer = Executors.newSingleThreadExecutor()
     }
 
     void start() {
@@ -60,6 +62,7 @@ class ConnectionEstablisher {
     void stop() {
         timer.cancel()
         executor.shutdownNow()
+        closer.shutdown()
     }
 
     private void connectIfNeeded() {
@@ -120,8 +123,10 @@ class ConnectionEstablisher {
     }
 
     private void fail(Endpoint endpoint) {
+        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 +180,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/content/ContentControlEvent.groovy

@@ -0,0 +1,9 @@
+package com.muwire.core.content
+
+import com.muwire.core.Event
+
+class ContentControlEvent extends Event {
+    String term
+    boolean regex
+    boolean add
+}

core/src/main/groovy/com/muwire/core/content/ContentManager.groovy

@@ -0,0 +1,30 @@
+package com.muwire.core.content
+
+import java.util.concurrent.ConcurrentHashMap
+
+import com.muwire.core.search.QueryEvent
+
+import net.i2p.util.ConcurrentHashSet
+
+class ContentManager {
+
+    Set<Matcher> matchers = new ConcurrentHashSet()    
+    
+    void onContentControlEvent(ContentControlEvent e) {
+        Matcher m
+        if (e.regex)
+            m = new RegexMatcher(e.term)
+        else
+            m = new KeywordMatcher(e.term)
+        if (e.add)
+            matchers.add(m)
+        else
+            matchers.remove(m)
+    }
+    
+    void onQueryEvent(QueryEvent e) {
+        if (e.searchEvent.searchTerms == null)
+            return
+        matchers.each { it.process(e) }
+    }
+}

core/src/main/groovy/com/muwire/core/content/KeywordMatcher.groovy

@@ -0,0 +1,36 @@
+package com.muwire.core.content
+
+class KeywordMatcher extends Matcher {
+    private final String keyword
+    KeywordMatcher(String keyword) {
+        this.keyword = keyword
+    }
+    
+    @Override
+    protected boolean match(List<String> searchTerms) {
+        boolean found = false
+        searchTerms.each { 
+            if (keyword == it)
+                found = true
+        }
+        found
+    }
+    
+    @Override
+    public String getTerm() {
+        keyword
+    }
+    
+    @Override
+    public int hashCode() {
+        keyword.hashCode()
+    }
+    
+    @Override
+    public boolean equals(Object o) {
+        if (!(o instanceof KeywordMatcher))
+            return false
+        KeywordMatcher other = (KeywordMatcher) o
+        keyword.equals(other.keyword)
+    }
+}

core/src/main/groovy/com/muwire/core/content/Match.groovy

@@ -0,0 +1,9 @@
+package com.muwire.core.content
+
+import com.muwire.core.Persona
+
+class Match {
+    Persona persona
+    String [] keywords
+    long timestamp
+}

core/src/main/groovy/com/muwire/core/content/Matcher.groovy

@@ -0,0 +1,20 @@
+package com.muwire.core.content
+
+import com.muwire.core.search.QueryEvent
+
+abstract class Matcher {
+    final List<Match> matches = Collections.synchronizedList(new ArrayList<>())
+    final Set<UUID> uuids = new HashSet<>()
+    
+    protected abstract boolean match(List<String> searchTerms);
+    
+    public abstract String getTerm();
+    
+    public void process(QueryEvent qe) {
+        def terms = qe.searchEvent.searchTerms
+        if (match(terms) && uuids.add(qe.searchEvent.uuid)) {
+            long now = System.currentTimeMillis()
+            matches << new Match(persona : qe.originator, keywords : terms, timestamp : now)
+        }
+    }
+}

core/src/main/groovy/com/muwire/core/content/RegexMatcher.groovy

@@ -0,0 +1,35 @@
+package com.muwire.core.content
+
+import java.util.regex.Pattern
+import java.util.stream.Collectors
+
+class RegexMatcher extends Matcher {
+    private final Pattern pattern
+    RegexMatcher(String pattern) {
+        this.pattern = Pattern.compile(pattern)
+    }
+    
+    @Override
+    protected boolean match(List<String> keywords) {
+        String combined = keywords.join(" ")
+        return pattern.matcher(combined).find()
+    }
+    
+    @Override
+    public String getTerm() {
+        pattern.pattern()
+    }
+    
+    @Override
+    public int hashCode() {
+        pattern.pattern().hashCode()
+    }
+    
+    @Override
+    public boolean equals(Object o) {
+        if (!(o instanceof RegexMatcher))
+            return false
+        RegexMatcher other = (RegexMatcher) o
+        pattern.pattern() == other.pattern.pattern()
+    }
+}

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

@@ -34,7 +34,7 @@ public class DownloadManager {
     private 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 Map<InfoHash, Downloader> downloaders = new ConcurrentHashMap<>()
@@ -46,12 +46,9 @@ public class DownloadManager {
         this.meshManager = meshManager
         this.muSettings = muSettings
         this.connector = connector
-        this.incompletes = new File(home,"incompletes")
         this.home = home
         this.me = me
 
-        incompletes.mkdir()
-        
         this.executor = Executors.newCachedThreadPool({ r ->
             Thread rv = new Thread(r)
             rv.setName("download-worker")
@@ -63,6 +60,11 @@ public class DownloadManager {
 
     public void onUIDownloadEvent(UIDownloadEvent e) {
 
+        File incompletes = muSettings.incompleteLocation
+        if (incompletes == null)
+            incompletes = new File(home, "incompletes")
+        incompletes.mkdirs()
+        
         def size = e.result[0].size
         def infohash = e.result[0].infohash
         def pieceSize = e.result[0].pieceSize
@@ -74,7 +76,7 @@ public class DownloadManager {
         destinations.addAll(e.sources)
         destinations.remove(me.destination)
 
-        Pieces pieces = getPieces(infohash, size, pieceSize)
+        Pieces pieces = getPieces(infohash, size, pieceSize, e.sequential)
 
         def downloader = new Downloader(eventBus, this, me, e.target, size,
             infohash, pieceSize, connector, destinations,
@@ -123,7 +125,17 @@ public class DownloadManager {
                 infoHash = new InfoHash(root)
             }
             
-            Pieces pieces = getPieces(infoHash, (long)json.length, json.pieceSizePow2)
+            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, sequential)
 
             def downloader = new Downloader(eventBus, this, me, file, (long)json.length,
                 infoHash, json.pieceSizePow2, connector, destinations, incompletes, pieces)
@@ -137,12 +149,12 @@ public class DownloadManager {
         }
     }
 
-    private Pieces getPieces(InfoHash infoHash, long length, int pieceSizePow2) {
+    private Pieces getPieces(InfoHash infoHash, long length, int pieceSizePow2, boolean sequential) {
         int pieceSize = 0x1 << 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 +200,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))
                 }
             }

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

@@ -14,6 +14,7 @@ import static com.muwire.core.util.DataUtil.readTillRN
 import groovy.util.logging.Log
 
 import java.nio.ByteBuffer
+import java.nio.MappedByteBuffer
 import java.nio.channels.FileChannel
 import java.nio.charset.StandardCharsets
 import java.nio.file.Files
@@ -25,8 +26,6 @@ import java.util.logging.Level
 @Log
 class DownloadSession {
 
-    private static int SAMPLES = 10
-    
     private final EventBus eventBus
     private final String meB64
     private final Pieces pieces
@@ -38,10 +37,10 @@ class DownloadSession {
     private final Set<Integer> available
     private final MessageDigest digest
 
-    private final LinkedList<Long> timestamps = new LinkedList<>()
-    private final LinkedList<Integer> reads = new LinkedList<>()
+    private long lastSpeedRead = System.currentTimeMillis()
+    private long dataSinceLastRead
 
-    private ByteBuffer mapped
+    private MappedByteBuffer mapped
 
     DownloadSession(EventBus eventBus, String meB64, Pieces pieces, InfoHash infoHash, Endpoint endpoint, File file,
         int pieceSize, long fileLength, Set<Integer> available) {
@@ -71,21 +70,23 @@ class DownloadSession {
         OutputStream os = endpoint.getOutputStream()
         InputStream is = endpoint.getInputStream()
 
-        int piece
+        int[] pieceAndPosition
         if (available.isEmpty())
-            piece = pieces.claim()
+            pieceAndPosition = pieces.claim()
         else
-            piece = pieces.claim(available)
-        if (piece == -1)
+            pieceAndPosition = pieces.claim(new HashSet<>(available))
+        if (pieceAndPosition == null)
             return false
+        int piece = pieceAndPosition[0]
+        int position = pieceAndPosition[1]
+        boolean steal = pieceAndPosition[2] == 1
         boolean unclaim = true
 
-        log.info("will download piece $piece")
-        
-        long start = piece * pieceSize
-        long end = Math.min(fileLength, start + pieceSize) - 1
-        long length = end - start + 1
+        log.info("will download piece $piece from position $position steal $steal")
 
+        long pieceStart = piece * ((long)pieceSize)
+        long end = Math.min(fileLength, pieceStart + pieceSize) - 1
+        long start = pieceStart + position
         String root = Base64.encode(infoHash.getRoot())
 
         try {
@@ -174,8 +175,9 @@ class DownloadSession {
             FileChannel channel
             try {
                 channel = Files.newByteChannel(file.toPath(), EnumSet.of(StandardOpenOption.READ, StandardOpenOption.WRITE,
-                        StandardOpenOption.SPARSE, StandardOpenOption.CREATE)) // TODO: double-check, maybe CREATE_NEW
-                mapped = channel.map(FileChannel.MapMode.READ_WRITE, start, end - start + 1)
+                        StandardOpenOption.SPARSE, StandardOpenOption.CREATE)) 
+                mapped = channel.map(FileChannel.MapMode.READ_WRITE, pieceStart, end - pieceStart + 1)
+                mapped.position(position)
 
                 byte[] tmp = new byte[0x1 << 13]
                 while(mapped.hasRemaining()) {
@@ -186,13 +188,8 @@ class DownloadSession {
                         throw new IOException()
                     synchronized(this) {
                         mapped.put(tmp, 0, read)
-
-                        if (timestamps.size() == SAMPLES) {
-                            timestamps.removeFirst()
-                            reads.removeFirst()
-                        }
-                        timestamps.addLast(System.currentTimeMillis())
-                        reads.addLast(read)
+                        dataSinceLastRead += read
+                        pieces.markPartial(piece, mapped.position())
                     }
                 }
 
@@ -201,15 +198,18 @@ class DownloadSession {
                 byte [] hash = digest.digest()
                 byte [] expected = new byte[32]
                 System.arraycopy(infoHash.getHashList(), piece * 32, expected, 0, 32)
-                if (hash != expected)
-                    throw new BadHashException()
+                if (hash != expected) {
+                    pieces.markPartial(piece, 0)
+                    throw new BadHashException("bad hash on piece $piece")
+                }
             } finally {
                 try { channel?.close() } catch (IOException ignore) {}
+                DataUtil.tryUnmap(mapped)
             }
             pieces.markDownloaded(piece)
             unclaim = false
         } finally {
-            if (unclaim)
+            if (unclaim && !steal) 
                 pieces.unclaim(piece)
         }
         return true
@@ -222,24 +222,11 @@ class DownloadSession {
     }
 
     synchronized int speed() {
-        if (timestamps.size() < SAMPLES)
-            return 0
-        int totalRead = 0
-        int idx = 0
         final long now = System.currentTimeMillis()
-        
-        while(idx < SAMPLES && timestamps.get(idx) < now - 1000)
-            idx++
-        if (idx == SAMPLES)
-            return 0
-        if (idx == SAMPLES - 1)
-            return reads[idx]
-            
-        long interval = timestamps.last - timestamps[idx]
-        if (interval == 0) 
-            interval = 1
-        for (int i = idx; i < SAMPLES; i++)
-            totalRead += reads[idx]
-        (int)(totalRead * 1000.0 / interval)
+        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

@@ -7,6 +7,7 @@ import com.muwire.core.connection.Endpoint
 import java.nio.file.AtomicMoveNotSupportedException
 import java.nio.file.Files
 import java.nio.file.StandardCopyOption
+import java.time.Instant
 import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.ExecutorService
 import java.util.concurrent.Executors
@@ -18,6 +19,7 @@ import com.muwire.core.DownloadedFile
 import com.muwire.core.EventBus
 import com.muwire.core.connection.I2PConnector
 import com.muwire.core.files.FileDownloadedEvent
+import com.muwire.core.util.DataUtil
 
 import groovy.util.logging.Log
 import net.i2p.data.Destination
@@ -25,6 +27,7 @@ import net.i2p.util.ConcurrentHashSet
 
 @Log
 public class Downloader {
+    
     public enum DownloadState { CONNECTING, HASHLIST, DOWNLOADING, FAILED, CANCELLED, PAUSED, FINISHED }
     private enum WorkerState { CONNECTING, HASHLIST, DOWNLOADING, FINISHED}
 
@@ -46,6 +49,7 @@ 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
@@ -57,6 +61,11 @@ public class Downloader {
     private final AtomicBoolean eventFired = new AtomicBoolean()
     private boolean piecesFileClosed
 
+    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,
         Persona me, File file, long length, InfoHash infoHash,
         int pieceSizePow2, I2PConnector connector, Set<Destination> destinations,
@@ -69,6 +78,7 @@ public class Downloader {
         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
@@ -100,8 +110,14 @@ public class Downloader {
         if (!piecesFile.exists())
             return
         piecesFile.eachLine {
-            int piece = Integer.parseInt(it)
+            String [] split = it.split(",")
+            int piece = Integer.parseInt(split[0])
+            if (split.length == 1)
                 pieces.markDownloaded(piece)
+            else {
+                int position = Integer.parseInt(split[1])
+                pieces.markPartial(piece, position)
+            }
         }
     }
 
@@ -110,9 +126,7 @@ public class Downloader {
             if (piecesFileClosed)
                 return
             piecesFile.withPrintWriter { writer ->
-                pieces.getDownloaded().each { piece ->
-                    writer.println(piece)
-                }
+                pieces.write(writer)
             }
         }
     }
@@ -123,14 +137,41 @@ public class Downloader {
 
 
     public int speed() {
-        int total = 0
+        int currSpeed = 0
         if (getCurrentState() == DownloadState.DOWNLOADING) {
             activeWorkers.values().each {
                 if (it.currentState == WorkerState.DOWNLOADING)
-                    total += it.speed()
+                    currSpeed += it.speed()
             }
         }
-        total
+        
+        if (speedArr.size() != downloadManager.muSettings.speedSmoothSeconds) {
+            speedArr.clear()
+            downloadManager.muSettings.speedSmoothSeconds.times { speedArr.add(0) }
+            speedPos = 0
+        }
+
+        // normalize to speedArr.size
+        currSpeed /= speedArr.size()
+
+        // compute new speedAvg and update speedArr
+        if ( speedArr[speedPos] > speedAvg ) {
+            speedAvg = 0
+        } else {
+            speedAvg -= speedArr[speedPos]
+        }
+        speedAvg += currSpeed
+        speedArr[speedPos] = currSpeed
+        // this might be necessary due to rounding errors
+        if (speedAvg < 0)
+            speedAvg = 0
+
+        // rolling index over the speedArr
+        speedPos++
+        if (speedPos >= speedArr.size())
+            speedPos=0
+
+        speedAvg
     }
 
     public DownloadState getCurrentState() {
@@ -269,14 +310,19 @@ public class Downloader {
                     writePieces()
                 }
             } catch (Exception bad) {
-                log.log(Level.WARNING,"Exception while downloading",bad)
+                log.log(Level.WARNING,"Exception while downloading",DataUtil.findRoot(bad))
             } finally {
+                writePieces()
                 currentState = WorkerState.FINISHED
                 if (pieces.isComplete() && eventFired.compareAndSet(false, true)) {
                     synchronized(piecesFile) {
                         piecesFileClosed = true
                         piecesFile.delete()
                     }
+                    activeWorkers.values().each { 
+                        if (it.destination != destination)
+                            it.cancel()
+                    }
                     try {
                         Files.move(incompleteFile.toPath(), file.toPath(), StandardCopyOption.ATOMIC_MOVE)
                     } catch (AtomicMoveNotSupportedException e) {
@@ -285,7 +331,7 @@ public class Downloader {
                     }
                     eventBus.publish(
                         new FileDownloadedEvent(
-                            downloadedFile : new DownloadedFile(file, getInfoHash(), pieceSizePow2, successfulDestinations),
+                            downloadedFile : new DownloadedFile(file.getCanonicalFile(), getInfoHash(), pieceSizePow2, successfulDestinations),
                         downloader : Downloader.this))
 
                 }

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

@@ -5,6 +5,7 @@ class Pieces {
     private final int nPieces
     private final float ratio
     private final Random random = new Random()
+    private final Map<Integer,Integer> partials = new HashMap<>()
 
     Pieces(int nPieces) {
         this(nPieces, 1.0f)
@@ -17,16 +18,22 @@ class Pieces {
         claimed = new BitSet(nPieces)
     }
     
-    synchronized int claim() {
+    synchronized int[] claim() {
         int claimedCardinality = claimed.cardinality()
-        if (claimedCardinality == nPieces)
-            return -1
+        if (claimedCardinality == nPieces) {
+            // steal
+            int downloadedCardinality = done.cardinality()
+            if (downloadedCardinality == nPieces)
+                return null
+            int rv = done.nextClearBit(0)
+            return [rv, partials.getOrDefault(rv, 0), 1]
+        }
 
         // 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
+            return [rv, partials.getOrDefault(rv, 0), 0]
         }
 
         while(true) {
@@ -34,20 +41,29 @@ class Pieces {
             if (claimed.get(start))
                 continue
             claimed.set(start)
-            return start
+            return [start, partials.getOrDefault(start,0), 0]
         }
     }
 
-    synchronized int claim(Set<Integer> available) {
-        for (int i = claimed.nextSetBit(0); i >= 0; i = claimed.nextSetBit(i+1))
+    synchronized int[] claim(Set<Integer> available) {
+        for (int i = done.nextSetBit(0); i >= 0; i = done.nextSetBit(i+1))
             available.remove(i)
         if (available.isEmpty())
-            return -1
-        List<Integer> toList = available.toList()
+            return null
+        Set<Integer> availableCopy = new HashSet<>(available)
+        for (int i = claimed.nextSetBit(0); i >= 0; i = claimed.nextSetBit(i+1))
+            availableCopy.remove(i)
+        if (availableCopy.isEmpty()) {
+            // steal
+            int rv = available.first()
+            return [rv, partials.getOrDefault(rv, 0), 1]
+        }
+        List<Integer> toList = availableCopy.toList()
+        if (ratio > 0f)
             Collections.shuffle(toList)
         int rv = toList[0]
         claimed.set(rv)
-        rv
+        [rv, partials.getOrDefault(rv, 0), 0]
     }
 
     synchronized def getDownloaded() {
@@ -61,6 +77,11 @@ class Pieces {
     synchronized void markDownloaded(int piece) {
         done.set(piece)
         claimed.set(piece)
+        partials.remove(piece)
+    }
+    
+    synchronized void markPartial(int piece, int position) {
+        partials.put(piece, position)
     }
 
     synchronized void unclaim(int piece) {
@@ -82,5 +103,15 @@ class Pieces {
     synchronized void clearAll() {
         done.clear()
         claimed.clear()
+        partials.clear()
+    }
+    
+    synchronized void write(PrintWriter writer) {
+        for (int i = done.nextSetBit(0); i >= 0; i = done.nextSetBit(i+1)) {
+            writer.println(i)
+        }
+        partials.each { piece, position ->
+            writer.println("$piece,$position")
+        }
     }
 }

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/files/DirectoryUnsharedEvent.groovy

@@ -0,0 +1,7 @@
+package com.muwire.core.files
+
+import com.muwire.core.Event
+
+class DirectoryUnsharedEvent extends Event {
+    File directory
+}

core/src/main/groovy/com/muwire/core/files/DirectoryWatcher.groovy

@@ -13,6 +13,7 @@ import java.nio.file.WatchService
 import java.util.concurrent.ConcurrentHashMap
 
 import com.muwire.core.EventBus
+import com.muwire.core.MuWireSettings
 import com.muwire.core.SharedFile
 
 import groovy.util.logging.Log
@@ -31,14 +32,19 @@ class DirectoryWatcher {
             kinds = [ENTRY_CREATE, ENTRY_MODIFY, ENTRY_DELETE]
     }
 
+    private final File home
+    private final MuWireSettings muOptions
     private final EventBus eventBus
     private final FileManager fileManager
     private final Thread watcherThread, publisherThread
     private final Map<File, Long> waitingFiles = new ConcurrentHashMap<>()
+    private final Map<File, WatchKey> watchedDirectories = new ConcurrentHashMap<>()
     private WatchService watchService
     private volatile boolean shutdown
 
-    DirectoryWatcher(EventBus eventBus, FileManager fileManager) {
+    DirectoryWatcher(EventBus eventBus, FileManager fileManager, File home, MuWireSettings muOptions) {
+        this.home = home
+        this.muOptions = muOptions
         this.eventBus = eventBus
         this.fileManager = fileManager
         this.watcherThread = new Thread({watch() } as Runnable, "directory-watcher")
@@ -47,7 +53,7 @@ class DirectoryWatcher {
         publisherThread.setDaemon(true)
     }
 
-    void start() {
+    void onAllFilesLoadedEvent(AllFilesLoadedEvent e) {
         watchService = FileSystems.getDefault().newWatchService()
         watcherThread.start()
         publisherThread.start()
@@ -55,17 +61,36 @@ class DirectoryWatcher {
 
     void stop() {
         shutdown = true
-        watcherThread.interrupt()
-        publisherThread.interrupt()
-        watchService.close()
+        watcherThread?.interrupt()
+        publisherThread?.interrupt()
+        watchService?.close()
     }
 
     void onFileSharedEvent(FileSharedEvent e) {
         if (!e.file.isDirectory())
             return
-        Path path = e.file.getCanonicalFile().toPath()
-        path.register(watchService, kinds)
+        File canonical = e.file.getCanonicalFile()
+        Path path = canonical.toPath()
+        WatchKey wk = path.register(watchService, kinds)
+        watchedDirectories.put(canonical, wk)
         
+        if (muOptions.watchedDirectories.add(canonical.toString()))
+            saveMuSettings()
+    }
+
+    void onDirectoryUnsharedEvent(DirectoryUnsharedEvent e) {
+        WatchKey wk = watchedDirectories.remove(e.directory)
+        wk?.cancel()
+        
+        if (muOptions.watchedDirectories.remove(e.directory.toString()))
+            saveMuSettings()
+    }
+    
+    private void saveMuSettings() {
+        File muSettingsFile = new File(home, "MuWire.properties")
+        muSettingsFile.withOutputStream {
+            muOptions.write(it)
+        }
     }
 
     private void watch() {
@@ -113,7 +138,7 @@ class DirectoryWatcher {
 
     private static File join(Path parent, Path path) {
         File parentFile = parent.toFile().getCanonicalFile()
-        new File(parentFile, path.toFile().getName())
+        new File(parentFile, path.toFile().getName()).getCanonicalFile()
     }
 
     private void publish() {

core/src/main/groovy/com/muwire/core/files/FileHashedEvent.groovy

@@ -7,4 +7,10 @@ class FileHashedEvent extends Event {
 
     SharedFile sharedFile
     String error
+
+    @Override
+    public String toString() {
+        super.toString() + " sharedFile " + sharedFile?.file.getAbsolutePath() + " error: $error"
+    }
+
 }

core/src/main/groovy/com/muwire/core/files/FileHasher.groovy

@@ -1,6 +1,7 @@
 package com.muwire.core.files
 
 import com.muwire.core.InfoHash
+import com.muwire.core.util.DataUtil
 
 import net.i2p.data.Base64
 
@@ -18,6 +19,8 @@ class FileHasher {
     /**
      * @param size of the file to be shared
      * @return the size of each piece in power of 2
+     * piece size is minimum 128 KBytees and maximum 16 MBytes in power of 2 steps (2^17 - 2^24)
+     * there can be up to 8192 pieces maximum per file
      */
     static int getPieceSize(long size) {
         if (size <= 0x1 << 30)
@@ -57,6 +60,7 @@ class FileHasher {
             for (int i = 0; i < numPieces - 1; i++) {
                 buf = raf.getChannel().map(MapMode.READ_ONLY, ((long)size) * i, size)
                 digest.update buf
+                DataUtil.tryUnmap(buf)
                 output.write(digest.digest(), 0, 32)
             }
             def lastPieceLength = length - (numPieces - 1) * ((long)size)

core/src/main/groovy/com/muwire/core/files/FileHashingEvent.groovy

@@ -0,0 +1,15 @@
+package com.muwire.core.files
+
+import com.muwire.core.Event
+import com.muwire.core.SharedFile
+
+class FileHashingEvent extends Event {
+
+    File hashingFile
+
+    @Override
+    public String toString() {
+        super.toString() + " hashingFile " + hashingFile.getAbsolutePath()
+    }
+
+}

core/src/main/groovy/com/muwire/core/files/FileManager.groovy

@@ -8,8 +8,10 @@ import com.muwire.core.UILoadedEvent
 import com.muwire.core.search.ResultsEvent
 import com.muwire.core.search.SearchEvent
 import com.muwire.core.search.SearchIndex
+import com.muwire.core.util.DataUtil
 
 import groovy.util.logging.Log
+import net.i2p.data.Base64
 
 @Log
 class FileManager {
@@ -20,6 +22,7 @@ class FileManager {
     final Map<InfoHash, Set<SharedFile>> rootToFiles = Collections.synchronizedMap(new HashMap<>())
     final Map<File, SharedFile> fileToSharedFile = Collections.synchronizedMap(new HashMap<>())
     final Map<String, Set<File>> nameToFiles = new HashMap<>()
+    final Map<String, Set<File>> commentToFile = new HashMap<>()
     final SearchIndex index = new SearchIndex()
 
     FileManager(EventBus eventBus, MuWireSettings settings) {
@@ -62,6 +65,18 @@ class FileManager {
         }
         existingFiles.add(sf.getFile())
 
+        String comment = sf.getComment()
+        if (comment != null) {
+            comment = DataUtil.readi18nString(Base64.decode(comment))
+            index.add(comment)
+            Set<File> existingComment = commentToFile.get(comment)
+            if(existingComment == null) {
+                existingComment = new HashSet<>()
+                commentToFile.put(comment, existingComment)
+            }
+            existingComment.add(sf.getFile())
+        }
+        
         index.add(name)
     }
 
@@ -87,9 +102,45 @@ class FileManager {
             }
         }
         
+        String comment = sf.getComment()
+        if (comment != null) {
+            Set<File> existingComment = commentToFile.get(comment)
+            if (existingComment != null) {
+                existingComment.remove(sf.getFile())
+                if (existingComment.isEmpty()) {
+                    commentToFile.remove(comment)
+                    index.remove(comment)
+                }
+            }
+        }
+
         index.remove(name)
     }
     
+    void onUICommentEvent(UICommentEvent e) {
+        if (e.oldComment != null) {
+            def comment = DataUtil.readi18nString(Base64.decode(e.oldComment))
+            Set<File> existingFiles = commentToFile.get(comment) 
+            existingFiles.remove(e.sharedFile.getFile())
+            if (existingFiles.isEmpty()) {
+                commentToFile.remove(comment)
+                index.remove(comment)
+            }
+        }
+        
+        String comment = e.sharedFile.getComment()
+        comment = DataUtil.readi18nString(Base64.decode(comment))
+        if (comment != null) {
+            index.add(comment)
+            Set<File> existingComment = commentToFile.get(comment)
+            if(existingComment == null) {
+                existingComment = new HashSet<>()
+                commentToFile.put(comment, existingComment)
+            }
+            existingComment.add(e.sharedFile.getFile())
+        }        
+    }
+
     Map<File, SharedFile> getSharedFiles() {
         synchronized(fileToSharedFile) {
             return new HashMap<>(fileToSharedFile)
@@ -112,10 +163,15 @@ class FileManager {
         } else {
             def names = index.search e.searchTerms
             Set<File> files = new HashSet<>()
-			names.each { files.addAll nameToFiles.getOrDefault(it, []) }
+            names.each { 
+                files.addAll nameToFiles.getOrDefault(it, [])
+                if (e.searchComments)
+                    files.addAll commentToFile.getOrDefault(it, [])
+            }
             Set<SharedFile> sharedFiles = new HashSet<>()
             files.each { sharedFiles.add fileToSharedFile[it] }
             files = filter(sharedFiles, e.oobInfohash)
+            
             if (!sharedFiles.isEmpty())
                 re = new ResultsEvent(results: sharedFiles.asList(), uuid: e.uuid, searchEvent: e)
 
@@ -135,4 +191,16 @@ class FileManager {
         }
         rv
     }
+
+    void onDirectoryUnsharedEvent(DirectoryUnsharedEvent e) {
+        e.directory.listFiles().each {
+            if (it.isDirectory())
+                eventBus.publish(new DirectoryUnsharedEvent(directory : it))
+            else {
+                SharedFile sf = fileToSharedFile.get(it)
+                if (sf != null)
+                    eventBus.publish(new FileUnsharedEvent(unsharedFile : sf))
+            }
+        }
+    }
 }

core/src/main/groovy/com/muwire/core/files/FileSharedEvent.groovy

@@ -5,4 +5,9 @@ import com.muwire.core.Event
 class FileSharedEvent extends Event {
 
     File file
+
+    @Override
+    public String toString() {
+        return super.toString() + " file: "+file.getAbsolutePath()
+    }
 }

core/src/main/groovy/com/muwire/core/files/HasherService.groovy

@@ -4,6 +4,7 @@ import java.util.concurrent.Executor
 import java.util.concurrent.Executors
 
 import com.muwire.core.EventBus
+import com.muwire.core.MuWireSettings
 import com.muwire.core.SharedFile
 
 class HasherService {
@@ -11,12 +12,15 @@ class HasherService {
     final FileHasher hasher
     final EventBus eventBus
     final FileManager fileManager
+    final Set<File> hashed = new HashSet<>()
+    final MuWireSettings settings
     Executor executor
 
-	HasherService(FileHasher hasher, EventBus eventBus, FileManager fileManager) {
+    HasherService(FileHasher hasher, EventBus eventBus, FileManager fileManager, MuWireSettings settings) {
         this.hasher = hasher
         this.eventBus = eventBus
         this.fileManager = fileManager
+        this.settings = settings
     }
 
     void start() {
@@ -24,13 +28,24 @@ class HasherService {
     }
 
     void onFileSharedEvent(FileSharedEvent evt) {
-        if (fileManager.fileToSharedFile.containsKey(evt.file))
+        File canonical = evt.file.getCanonicalFile()
+        if (!settings.shareHiddenFiles && canonical.isHidden())
             return
-		executor.execute( { -> process(evt.file) } as Runnable)
+        if (fileManager.fileToSharedFile.containsKey(canonical)) 
+            return
+        if (hashed.add(canonical))
+            executor.execute( { -> process(canonical) } as Runnable)
+    }
+    
+    void onFileUnsharedEvent(FileUnsharedEvent evt) {
+        hashed.remove(evt.unsharedFile.file)
+    }
+    
+    void onDirectoryUnsharedEvent(DirectoryUnsharedEvent evt) {
+        hashed.remove(evt.directory)
     }
 
     private void process(File f) {
-		f = f.getCanonicalFile()
         if (f.isDirectory()) {
             f.listFiles().each {eventBus.publish new FileSharedEvent(file: it) }
         } else {
@@ -39,6 +54,7 @@ class HasherService {
             } else if (f.length() > FileHasher.MAX_SIZE) {
                 eventBus.publish new FileHashedEvent(error: "$f is too large to be shared ${f.length()}")
             } else {
+                eventBus.publish new FileHashingEvent(hashingFile: f)
                 def hash = hasher.hashFile f
                 eventBus.publish new FileHashedEvent(sharedFile: new SharedFile(f, hash, FileHasher.getPieceSize(f.length())))
             }

core/src/main/groovy/com/muwire/core/files/PersisterService.groovy

@@ -3,6 +3,9 @@ package com.muwire.core.files
 import java.nio.file.CopyOption
 import java.nio.file.Files
 import java.nio.file.StandardCopyOption
+import java.util.concurrent.ExecutorService
+import java.util.concurrent.Executors
+import java.util.concurrent.ThreadFactory
 import java.util.logging.Level
 import java.util.stream.Collectors
 
@@ -28,13 +31,16 @@ class PersisterService extends Service {
     final int interval
     final Timer timer
     final FileManager fileManager
+    final ExecutorService persisterExecutor = Executors.newSingleThreadExecutor({ r -> 
+        new Thread(r, "file persister")
+    } as ThreadFactory)
 
     PersisterService(File location, EventBus listener, int interval, FileManager fileManager) {
         this.location = location
         this.listener = listener
         this.interval = interval
         this.fileManager = fileManager
-		timer = new Timer("file persister", true)
+        timer = new Timer("file persister timer", true)
     }
 
     void stop() {
@@ -45,8 +51,15 @@ class PersisterService extends Service {
         timer.schedule({load()} as TimerTask, 1)
     }
     
+    void onUIPersistFilesEvent(UIPersistFilesEvent e) {
+        persistFiles()
+    }
+
     void load() {
+        Thread.currentThread().setPriority(Thread.MIN_PRIORITY)
+
         if (location.exists() && location.isFile()) {
+            int loaded = 0
             def slurper = new JsonSlurper()
             try {
                 location.eachLine {
@@ -56,6 +69,9 @@ class PersisterService extends Service {
                         if (event != null) {
                             log.fine("loaded file $event.loadedFile.file")
                             listener.publish event
+                            loaded++
+                            if (loaded % 10 == 0)
+                                Thread.sleep(20)
                         }
                     }
                 }
@@ -109,16 +125,19 @@ class PersisterService extends Service {
             List sources = (List)json.sources
             Set<Destination> sourceSet = sources.stream().map({d -> new Destination(d.toString())}).collect Collectors.toSet()
             DownloadedFile df = new DownloadedFile(file, ih, pieceSize, sourceSet)
+            df.setComment(json.comment)
             return new FileLoadedEvent(loadedFile : df)
         }
 
 
         SharedFile sf = new SharedFile(file, ih, pieceSize)
+        sf.setComment(json.comment)
         return new FileLoadedEvent(loadedFile: sf)
 
     }
 
     private void persistFiles() {
+        persisterExecutor.submit( {
             def sharedFiles = fileManager.getSharedFiles()
 
             File tmp = File.createTempFile("muwire-files", "tmp")
@@ -132,21 +151,18 @@ class PersisterService extends Service {
             }
             Files.copy(tmp.toPath(), location.toPath(), StandardCopyOption.REPLACE_EXISTING)
             tmp.delete()
+        } as Runnable)
     }
 
     private def toJson(File f, SharedFile sf) {
         def json = [:]
-		json.file = Base64.encode DataUtil.encodei18nString(f.getCanonicalFile().toString())
-		json.length = f.length()
+        json.file = sf.getB64EncodedFileName()
+        json.length = sf.getCachedLength()
         InfoHash ih = sf.getInfoHash()
-		json.infoHash = Base64.encode ih.getRoot()
+        json.infoHash = sf.getB64EncodedHashRoot()
         json.pieceSize = sf.getPieceSize()
-		byte [] tmp = new byte [32]
-		json.hashList = []
-		for (int i = 0;i < ih.getHashList().length / 32; i++) {
-			System.arraycopy(ih.getHashList(), i * 32, tmp, 0, 32)
-			json.hashList.add Base64.encode(tmp)
-		}
+        json.hashList = sf.getB64EncodedHashList()
+        json.comment = sf.getComment()
 
         if (sf instanceof DownloadedFile) {
             json.sources = sf.sources.stream().map( {d -> d.toBase64()}).collect(Collectors.toList())

core/src/main/groovy/com/muwire/core/files/UICommentEvent.groovy

@@ -0,0 +1,9 @@
+package com.muwire.core.files
+
+import com.muwire.core.Event
+import com.muwire.core.SharedFile
+
+class UICommentEvent extends Event {
+    SharedFile sharedFile
+    String oldComment
+}

core/src/main/groovy/com/muwire/core/files/UIPersistFilesEvent.groovy

@@ -0,0 +1,6 @@
+package com.muwire.core.files
+
+import com.muwire.core.Event
+
+class UIPersistFilesEvent extends Event {
+}

core/src/main/groovy/com/muwire/core/hostcache/CacheServers.groovy

@@ -6,7 +6,12 @@ class CacheServers {
 
     private static final int TO_GIVE = 3
     private static Set<Destination> CACHES = [
-			new Destination("Wddh2E6FyyXBF7SvUYHKdN-vjf3~N6uqQWNeBDTM0P33YjiQCOsyedrjmDZmWFrXUJfJLWnCb5bnKezfk4uDaMyj~uvDG~yvLVcFgcPWSUd7BfGgym-zqcG1q1DcM8vfun-US7YamBlmtC6MZ2j-~Igqzmgshita8aLPCfNAA6S6e2UMjjtG7QIXlxpMec75dkHdJlVWbzrk9z8Qgru3YIk0UztYgEwDNBbm9wInsbHhr3HtAfa02QcgRVqRN2PnQXuqUJs7R7~09FZPEviiIcUpkY3FeyLlX1sgQFBeGeA96blaPvZNGd6KnNdgfLgMebx5SSxC-N4KZMSMBz5cgonQF3~m2HHFRSI85zqZNG5X9bJN85t80ltiv1W1es8ZnQW4es11r7MrvJNXz5bmSH641yJIvS6qI8OJJNpFVBIQSXLD-96TayrLQPaYw~uNZ-eXaE6G5dYhiuN8xHsFI1QkdaUaVZnvDGfsRbpS5GtpUbBDbyLkdPurG0i7dN1wAAAA")
+            // zlatinb
+            new Destination("Wddh2E6FyyXBF7SvUYHKdN-vjf3~N6uqQWNeBDTM0P33YjiQCOsyedrjmDZmWFrXUJfJLWnCb5bnKezfk4uDaMyj~uvDG~yvLVcFgcPWSUd7BfGgym-zqcG1q1DcM8vfun-US7YamBlmtC6MZ2j-~Igqzmgshita8aLPCfNAA6S6e2UMjjtG7QIXlxpMec75dkHdJlVWbzrk9z8Qgru3YIk0UztYgEwDNBbm9wInsbHhr3HtAfa02QcgRVqRN2PnQXuqUJs7R7~09FZPEviiIcUpkY3FeyLlX1sgQFBeGeA96blaPvZNGd6KnNdgfLgMebx5SSxC-N4KZMSMBz5cgonQF3~m2HHFRSI85zqZNG5X9bJN85t80ltiv1W1es8ZnQW4es11r7MrvJNXz5bmSH641yJIvS6qI8OJJNpFVBIQSXLD-96TayrLQPaYw~uNZ-eXaE6G5dYhiuN8xHsFI1QkdaUaVZnvDGfsRbpS5GtpUbBDbyLkdPurG0i7dN1wAAAA"),
+            // sNL
+            new Destination("JC63wJNOqSJmymkj4~UJWywBTvDGikKMoYP0HX2Wz9c5l3otXSkwnxWAFL4cKr~Ygh3BNNi2t93vuLIiI1W8AsE42kR~PwRx~Y-WvIHXR6KUejRmOp-n8WidtjKg9k4aDy428uSOedqXDxys5mpoeQXwDsv1CoPTTwnmb1GWFy~oTGIsCguCl~aJWGnqiKarPO3GJQ~ev-NbvAQzUfC3HeP1e6pdI5CGGjExahTCID5UjpJw8GaDXWlGmYWWH303Xu4x-vAHQy1dJLsOBCn8dZravsn5BKJk~j0POUon45CCx-~NYtaPe0Itt9cMdD2ciC76Rep1D0X0sm1SjlSs8sZ52KmF3oaLZ6OzgI9QLMIyBUrfi41sK5I0qTuUVBAkvW1xr~L-20dYJ9TrbOaOb2-vDIfKaxVi6xQOuhgQDiSBhd3qv2m0xGu-BM9DQYfNA0FdMjnZmqjmji9RMavzQSsVFIbQGLbrLepiEFlb7TseCK5UtRp8TxnG7L4gbYevBQAEAAcAAA=="),
+            // dark_trion
+            new Destination("Gec9L29FVcQvYDgpcYuEYdltJn06PPoOWAcAM8Af-gDm~ehlrJcwlLXXs0hidq~yP2A0X7QcDi6i6shAfuEofTchxGJl8LRNqj9lio7WnB7cIixXWL~uCkD7Np5LMX0~akNX34oOb9RcBYVT2U5rFGJmJ7OtBv~IBkGeLhsMrqaCjahd0jdBO~QJ-t82ZKZhh044d24~JEfF9zSJxdBoCdAcXzryGNy7sYtFVDFsPKJudAxSW-UsSQiGw2~k-TxyF0r-iAt1IdzfNu8Lu0WPqLdhDYJWcPldx2PR5uJorI~zo~z3I5RX3NwzarlbD4nEP5s65ahPSfVCEkzmaJUBgP8DvBqlFaX89K4nGRYc7jkEjJ8cX4L6YPXUpTPWcfKkW259WdQY3YFh6x7rzijrGZewpczOLCrt-bZRYgDrUibmZxKZmNhy~lQu4gYVVjkz1i4tL~DWlhIc4y0x2vItwkYLArPPi~ejTnt-~Lhb7oPMXRcWa3UrwGKpFvGZY4NXBQAEAAcAAA==")
         ]
 
     static List<Destination> getCacheServers() {

core/src/main/groovy/com/muwire/core/hostcache/Host.groovy

@@ -5,22 +5,37 @@ import net.i2p.data.Destination
 class Host {
 
     private static final int MAX_FAILURES = 3
-    private static final int CLEAR_INTERVAL = 60 * 60 * 1000
 
     final Destination destination
+    private final int clearInterval, hopelessInterval, rejectionInterval
     int failures,successes
     long lastAttempt
+    long lastSuccessfulAttempt
+    long lastRejection
 
-	public Host(Destination destination) {
+    public Host(Destination destination, int clearInterval, int hopelessInterval, int rejectionInterval) {
         this.destination = destination
+        this.clearInterval = clearInterval
+        this.hopelessInterval = hopelessInterval
+        this.rejectionInterval = rejectionInterval
     }
     
-	synchronized void onConnect() {
+    private void connectSuccessful() {
         failures = 0
         successes++
         lastAttempt = System.currentTimeMillis()
     }
 
+    synchronized void onConnect() {
+        connectSuccessful()
+        lastSuccessfulAttempt = lastAttempt
+    }
+    
+    synchronized void onReject() {
+        connectSuccessful()
+        lastRejection = lastAttempt;
+    }
+
     synchronized void onFailure() {
         failures++
         successes = 0
@@ -39,7 +54,17 @@ class Host {
         failures = 0
     }
 
-    synchronized void canTryAgain() {
-        System.currentTimeMillis() - lastAttempt > CLEAR_INTERVAL
+    synchronized boolean canTryAgain() {
+        lastSuccessfulAttempt > 0 && 
+            System.currentTimeMillis() - lastAttempt > (clearInterval * 60 * 1000)
+    }
+    
+    synchronized boolean isHopeless() {
+        isFailed() && 
+            System.currentTimeMillis() - lastSuccessfulAttempt > (hopelessInterval * 60 * 1000)
+    }
+    
+    synchronized boolean isRecentlyRejected() {
+        System.currentTimeMillis() - lastRejection < (rejectionInterval * 60 * 1000)
     }
 }

core/src/main/groovy/com/muwire/core/hostcache/HostCache.groovy

@@ -52,7 +52,7 @@ class HostCache extends Service {
             hosts.get(e.destination).clearFailures()
             return
         }
-		Host host = new Host(e.destination)
+        Host host = new Host(e.destination, settings.hostClearInterval, settings.hostHopelessInterval, settings.hostRejectInterval)
         if (allowHost(host)) {
             hosts.put(e.destination, host)
         }
@@ -64,15 +64,17 @@ class HostCache extends Service {
         Destination dest = e.endpoint.destination
         Host host = hosts.get(dest)
         if (host == null) {
-			host = new Host(dest)
+            host = new Host(dest, settings.hostClearInterval, settings.hostHopelessInterval, settings.hostRejectInterval)
             hosts.put(dest, host)
         }
 
         switch(e.status) {
             case ConnectionAttemptStatus.SUCCESSFUL:
-			case ConnectionAttemptStatus.REJECTED:
                 host.onConnect()
                 break
+            case ConnectionAttemptStatus.REJECTED:
+                host.onReject()
+                break
             case ConnectionAttemptStatus.FAILED:
                 host.onFailure()
                 break
@@ -82,6 +84,10 @@ class HostCache extends Service {
     List<Destination> getHosts(int n) {
         List<Destination> rv = new ArrayList<>(hosts.keySet())
         rv.retainAll {allowHost(hosts[it])}
+        rv.removeAll {
+            def h = hosts[it]; 
+            (h.isFailed() && !h.canTryAgain()) || h.isRecentlyRejected()
+        }
         if (rv.size() <= n)
             return rv
         Collections.shuffle(rv)
@@ -100,17 +106,37 @@ class HostCache extends Service {
         rv[0..n-1]
     }
     
+    int countFailingHosts() {
+        List<Destination> rv = new ArrayList<>(hosts.keySet())
+        rv.retainAll { 
+            hosts[it].isFailed()
+        }
+        rv.size()
+    }
+    
+    int countHopelessHosts() {
+        List<Destination> rv = new ArrayList<>(hosts.keySet())
+        rv.retainAll {
+            hosts[it].isHopeless()
+        }
+        rv.size()
+    }
+
     void load() {
         if (storage.exists()) {
             JsonSlurper slurper = new JsonSlurper()
             storage.eachLine {
                 def entry = slurper.parseText(it)
                 Destination dest = new Destination(entry.destination)
-				Host host = new Host(dest)
+                Host host = new Host(dest, settings.hostClearInterval, settings.hostHopelessInterval, settings.hostRejectInterval)
                 host.failures = Integer.valueOf(String.valueOf(entry.failures))
                 host.successes = Integer.valueOf(String.valueOf(entry.successes))
                 if (entry.lastAttempt != null)
                     host.lastAttempt = entry.lastAttempt
+                if (entry.lastSuccessfulAttempt != null)
+                    host.lastSuccessfulAttempt = entry.lastSuccessfulAttempt
+                if (entry.lastRejection != null)
+                    host.lastRejection = entry.lastRejection
                 if (allowHost(host)) 
                     hosts.put(dest, host)
             }
@@ -120,8 +146,6 @@ class HostCache extends Service {
     }
 
     private boolean allowHost(Host host) {
-		if (host.isFailed() && !host.canTryAgain())
-			return false
         if (host.destination == myself)
             return false
         TrustLevel trust = trustService.getLevel(host.destination)
@@ -140,12 +164,14 @@ class HostCache extends Service {
         storage.delete()
         storage.withPrintWriter { writer ->
             hosts.each { dest, host ->
-				if (allowHost(host)) {
+                if (allowHost(host) && !host.isHopeless()) {
                     def map = [:]
                     map.destination = dest.toBase64()
                     map.failures = host.failures
                     map.successes = host.successes
                     map.lastAttempt = host.lastAttempt
+                    map.lastSuccessfulAttempt = host.lastSuccessfulAttempt
+                    map.lastRejection = host.lastRejection
                     def json = JsonOutput.toJson(map)
                     writer.println json
                 }

core/src/main/groovy/com/muwire/core/mesh/MeshManager.groovy

@@ -1,29 +1,44 @@
 package com.muwire.core.mesh
 
+import java.util.stream.Collectors
+
 import com.muwire.core.Constants
 import com.muwire.core.InfoHash
+import com.muwire.core.MuWireSettings
+import com.muwire.core.Persona
 import com.muwire.core.download.Pieces
 import com.muwire.core.download.SourceDiscoveredEvent
 import com.muwire.core.files.FileManager
+import com.muwire.core.util.DataUtil
+
+import groovy.json.JsonOutput
+import groovy.json.JsonSlurper
+import net.i2p.data.Base64
 
 class MeshManager {
 
     private final Map<InfoHash, Mesh> meshes = Collections.synchronizedMap(new HashMap<>())
     private final FileManager fileManager
+    private final File home
+    private final MuWireSettings settings
 
-    MeshManager(FileManager fileManager) {
+    MeshManager(FileManager fileManager, File home, MuWireSettings settings) {
         this.fileManager = fileManager
+        this.home = home
+        this.settings = settings
+        load()
     }
 
     Mesh get(InfoHash infoHash) {
         meshes.get(infoHash)
     }
 
-    Mesh getOrCreate(InfoHash infoHash, int nPieces) {
+    Mesh getOrCreate(InfoHash infoHash, int nPieces, boolean sequential) {
         synchronized(meshes) {
             if (meshes.containsKey(infoHash))
                 return meshes.get(infoHash)
-            Pieces pieces = new Pieces(nPieces, Constants.DOWNLOAD_SEQUENTIAL_RATIO)
+            float ratio = sequential ? 0f : settings.downloadSequentialRatio
+            Pieces pieces = new Pieces(nPieces, ratio)
             if (fileManager.rootToFiles.containsKey(infoHash)) {
                 for (int i = 0; i < nPieces; i++)
                     pieces.markDownloaded(i)
@@ -39,5 +54,50 @@ class MeshManager {
         if (mesh == null)
             return
        mesh.sources.add(e.source)
+       save()
+    }
+
+    private void save() {
+        File meshFile = new File(home, "mesh.json")
+        synchronized(meshes) {
+            meshFile.withPrintWriter { writer ->
+                meshes.values().each { mesh ->
+                    def json = [:]
+                    json.timestamp = System.currentTimeMillis()
+                    json.infoHash = Base64.encode(mesh.infoHash.getRoot())
+                    json.sources = mesh.sources.stream().map({it.toBase64()}).collect(Collectors.toList())
+                    json.nPieces = mesh.pieces.nPieces
+                    json.xHave = DataUtil.encodeXHave(mesh.pieces.downloaded, mesh.pieces.nPieces)
+                    writer.println(JsonOutput.toJson(json))
+                }
+            }
+        }
+    }
+
+    private void load() {
+        File meshFile = new File(home, "mesh.json")
+        if (!meshFile.exists())
+            return
+        long now = System.currentTimeMillis()
+        JsonSlurper slurper = new JsonSlurper()
+        meshFile.eachLine {
+            def json = slurper.parseText(it)
+            if (now - json.timestamp > settings.meshExpiration * 60 * 1000)
+                return
+            InfoHash infoHash = new InfoHash(Base64.decode(json.infoHash))
+            Pieces pieces = new Pieces(json.nPieces, settings.downloadSequentialRatio)
+
+            Mesh mesh = new Mesh(infoHash, pieces)
+            json.sources.each { source ->
+                Persona persona = new Persona(new ByteArrayInputStream(Base64.decode(source)))
+                mesh.sources.add(persona)
+            }
+
+            if (json.xHave != null)
+                DataUtil.decodeXHave(json.xHave).each { pieces.markDownloaded(it) }
+
+            if (!mesh.sources.isEmpty())
+                meshes.put(infoHash, mesh)
+        }
     }
 }

core/src/main/groovy/com/muwire/core/search/BrowseManager.groovy

@@ -0,0 +1,87 @@
+package com.muwire.core.search
+
+import com.muwire.core.Constants
+import com.muwire.core.EventBus
+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
+
+import java.nio.charset.StandardCharsets
+import java.util.concurrent.Executor
+import java.util.concurrent.Executors
+import java.util.logging.Level
+import java.util.zip.GZIPInputStream
+
+@Log
+class BrowseManager {
+    
+    private final I2PConnector connector
+    private final EventBus eventBus
+    
+    private final Executor browserThread = Executors.newSingleThreadExecutor()
+    
+    BrowseManager(I2PConnector connector, EventBus eventBus) {
+        this.connector = connector
+        this.eventBus = eventBus
+    }
+    
+    void onUIBrowseEvent(UIBrowseEvent e) {
+        browserThread.execute({
+            Endpoint endpoint = null
+            try {
+                eventBus.publish(new BrowseStatusEvent(status : BrowseStatus.CONNECTING))
+                endpoint = connector.connect(e.host.destination)
+                OutputStream os = endpoint.getOutputStream()
+                os.write("BROWSE\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 results = Integer.parseInt(headers['Count'])
+                
+                // at this stage, start pulling the results
+                eventBus.publish(new BrowseStatusEvent(status : BrowseStatus.FETCHING, totalResults : results))
+                
+                JsonSlurper slurper = new JsonSlurper()
+                DataInputStream dis = new DataInputStream(new GZIPInputStream(is))
+                UUID uuid = UUID.randomUUID()
+                for (int i = 0; i < results; i++) {
+                    int size = dis.readUnsignedShort()
+                    byte [] tmp = new byte[size]
+                    dis.readFully(tmp)
+                    def json = slurper.parse(tmp)
+                    UIResultEvent result = ResultsParser.parse(e.host, uuid, json)
+                    eventBus.publish(result)
+                }
+                
+                eventBus.publish(new BrowseStatusEvent(status : BrowseStatus.FINISHED))
+                
+            } catch (Exception bad) {
+                log.log(Level.WARNING, "browse failed", bad)
+                eventBus.publish(new BrowseStatusEvent(status : BrowseStatus.FAILED))
+            } finally {
+                endpoint?.close()
+            }
+        } as Runnable)
+    }
+}

core/src/main/groovy/com/muwire/core/search/BrowseStatus.java

@@ -0,0 +1,5 @@
+package com.muwire.core.search;
+
+public enum BrowseStatus {
+    CONNECTING, FETCHING, FINISHED, FAILED
+}

core/src/main/groovy/com/muwire/core/search/BrowseStatusEvent.groovy

@@ -0,0 +1,8 @@
+package com.muwire.core.search
+
+import com.muwire.core.Event
+
+class BrowseStatusEvent extends Event {
+    BrowseStatus status
+    int totalResults
+}

core/src/main/groovy/com/muwire/core/search/ResultsParser.groovy

@@ -91,12 +91,22 @@ class ResultsParser {
             if (json.sources != null)
                 sources = json.sources.stream().map({new Destination(it)}).collect(Collectors.toSet())
                 
+            String comment = null
+            if (json.comment != null)
+                comment = DataUtil.readi18nString(Base64.decode(json.comment))
+                
+            boolean browse = false
+            if (json.browse != null)
+                browse = json.browse
+
             return new UIResultEvent( sender : p,
                 name : name,
                 size : size,
                 infohash : new InfoHash(infoHash),
                 pieceSize : pieceSize,
                 sources : sources,
+                comment : comment,
+                browse : browse,
                 uuid: uuid)
         } catch (Exception e) {
             throw new InvalidSearchResultException("parsing search result failed",e)

core/src/main/groovy/com/muwire/core/search/ResultsSender.groovy

@@ -4,6 +4,7 @@ import com.muwire.core.SharedFile
 import com.muwire.core.connection.Endpoint
 import com.muwire.core.connection.I2PConnector
 import com.muwire.core.files.FileHasher
+import com.muwire.core.util.DataUtil
 import com.muwire.core.Persona
 
 import java.nio.charset.StandardCharsets
@@ -13,10 +14,12 @@ import java.util.concurrent.ThreadFactory
 import java.util.concurrent.atomic.AtomicInteger
 import java.util.logging.Level
 import java.util.stream.Collectors
+import java.util.zip.GZIPOutputStream
 
 import com.muwire.core.DownloadedFile
 import com.muwire.core.EventBus
 import com.muwire.core.InfoHash
+import com.muwire.core.MuWireSettings
 
 import groovy.json.JsonOutput
 import groovy.util.logging.Log
@@ -42,16 +45,19 @@ class ResultsSender {
     private final I2PConnector connector
     private final Persona me
     private final EventBus eventBus
+    private final MuWireSettings settings
 
-    ResultsSender(EventBus eventBus, I2PConnector connector, Persona me) {
+    ResultsSender(EventBus eventBus, I2PConnector connector, Persona me, MuWireSettings settings) {
         this.connector = connector;
         this.eventBus = eventBus
         this.me = me
+        this.settings = settings
     }
 
-    void sendResults(UUID uuid, SharedFile[] results, Destination target, boolean oobInfohash) {
+    void sendResults(UUID uuid, SharedFile[] results, Destination target, boolean oobInfohash, boolean compressedResults) {
         log.info("Sending $results.length results for uuid $uuid to ${target.toBase32()} oobInfohash : $oobInfohash")
         if (target.equals(me.destination)) {
+            def uiResultEvents = []
             results.each {
                 long length = it.getFile().length()
                 int pieceSize = it.getPieceSize()
@@ -60,19 +66,25 @@ class ResultsSender {
                 Set<Destination> suggested = Collections.emptySet()
                 if (it instanceof DownloadedFile)
                     suggested = it.sources
+                def comment = null
+                if (it.getComment() != null) {
+                    comment = DataUtil.readi18nString(Base64.decode(it.getComment()))
+                }
                 def uiResultEvent = new UIResultEvent( sender : me,
                     name : it.getFile().getName(),
                     size : length,
                     infohash : it.getInfoHash(),
                     pieceSize : pieceSize,
                     uuid : uuid,
-                    sources : suggested
+                    sources : suggested,
+                    comment : comment
                     )
-                    eventBus.publish(uiResultEvent)
+                uiResultEvents << uiResultEvent
             }
+            eventBus.publish(new UIResultBatchEvent(uuid : uuid, results : uiResultEvents))
         } else {
             executor.execute(new ResultSendJob(uuid : uuid, results : results,
-                target: target, oobInfohash : oobInfohash))
+                target: target, oobInfohash : oobInfohash, compressedResults : compressedResults))
         }
     }
 
@@ -81,13 +93,14 @@ class ResultsSender {
         SharedFile [] results
         Destination target
         boolean oobInfohash
+        boolean compressedResults
 
         @Override
         public void run() {
             try {
-                byte [] tmp = new byte[InfoHash.SIZE]
                 JsonOutput jsonOutput = new JsonOutput()
                 Endpoint endpoint = null;
+                if (!compressedResults) {
                     try {
                         endpoint = connector.connect(target)
                         DataOutputStream os = new DataOutputStream(endpoint.getOutputStream())
@@ -95,33 +108,7 @@ class ResultsSender {
                         me.write(os)
                         os.writeShort((short)results.length)
                         results.each {
-                        byte [] name = it.getFile().getName().getBytes(StandardCharsets.UTF_8)
-                        def baos = new ByteArrayOutputStream()
-                        def daos = new DataOutputStream(baos)
-                        daos.writeShort((short) name.length)
-                        daos.write(name)
-                        daos.flush()
-                        String encodedName = Base64.encode(baos.toByteArray())
-                        def obj = [:]
-                        obj.type = "Result"
-                        obj.version = oobInfohash ? 2 : 1
-                        obj.name = encodedName
-                        obj.infohash = Base64.encode(it.getInfoHash().getRoot())
-                        obj.size = it.getFile().length()
-                        obj.pieceSize = it.getPieceSize()
-                        if (!oobInfohash) {
-                            byte [] hashList = it.getInfoHash().getHashList()
-                            def hashListB64 = []
-                            for (int i = 0; i < hashList.length / InfoHash.SIZE; i++) {
-                                System.arraycopy(hashList, InfoHash.SIZE * i, tmp, 0, InfoHash.SIZE)
-                                hashListB64 << Base64.encode(tmp)
-                            }
-                            obj.hashList = hashListB64
-                        }
-
-                        if (it instanceof DownloadedFile)
-                            obj.sources = it.sources.stream().map({dest -> dest.toBase64()}).collect(Collectors.toSet())
-
+                            def obj = sharedFileToObj(it, settings.browseFiles)
                             def json = jsonOutput.toJson(obj)
                             os.writeShort((short)json.length())
                             os.write(json.getBytes(StandardCharsets.US_ASCII))
@@ -130,9 +117,55 @@ class ResultsSender {
                     } finally {
                         endpoint?.close()
                     }
+                } else {
+                    try {
+                        endpoint = connector.connect(target)
+                        OutputStream os = endpoint.getOutputStream()
+                        os.write("RESULTS $uuid\r\n".getBytes(StandardCharsets.US_ASCII))
+                        os.write("Sender: ${me.toBase64()}\r\n".getBytes(StandardCharsets.US_ASCII))
+                        os.write("Count: $results.length\r\n".getBytes(StandardCharsets.US_ASCII))
+                        os.write("\r\n".getBytes(StandardCharsets.US_ASCII))
+                        DataOutputStream dos = new DataOutputStream(new GZIPOutputStream(os))
+                        results.each { 
+                            def obj = sharedFileToObj(it, settings.browseFiles)
+                            def json = jsonOutput.toJson(obj)
+                            dos.writeShort((short)json.length())
+                            dos.write(json.getBytes(StandardCharsets.US_ASCII))
+                        }
+                        dos.close()
+                    } finally {
+                        endpoint?.close()
+                    }
+                }
             } catch (Exception e) {
                 log.log(Level.WARNING, "problem sending results",e)
             }
         }
     }
+    
+    public static def sharedFileToObj(SharedFile sf, boolean browseFiles) {
+        byte [] name = sf.getFile().getName().getBytes(StandardCharsets.UTF_8)
+        def baos = new ByteArrayOutputStream()
+        def daos = new DataOutputStream(baos)
+        daos.writeShort((short) name.length)
+        daos.write(name)
+        daos.flush()
+        String encodedName = Base64.encode(baos.toByteArray())
+        def obj = [:]
+        obj.type = "Result"
+        obj.version = 2
+        obj.name = encodedName
+        obj.infohash = Base64.encode(sf.getInfoHash().getRoot())
+        obj.size = sf.getCachedLength()
+        obj.pieceSize = sf.getPieceSize()
+
+        if (sf instanceof DownloadedFile)
+            obj.sources = sf.sources.stream().map({dest -> dest.toBase64()}).collect(Collectors.toSet())
+
+        if (sf.getComment() != null)
+            obj.comment = sf.getComment()
+
+        obj.browse = browseFiles 
+        obj
+    }
 }

core/src/main/groovy/com/muwire/core/search/SearchEvent.groovy

@@ -9,11 +9,13 @@ class SearchEvent extends Event {
     byte [] searchHash
     UUID uuid
     boolean oobInfohash
+    boolean searchComments
+    boolean compressedResults
 
     String toString() {
         def infoHash = null
         if (searchHash != null)
             infoHash = new InfoHash(searchHash)
-        "searchTerms: $searchTerms searchHash:$infoHash, uuid:$uuid oobInfohash:$oobInfohash"
+        "searchTerms: $searchTerms searchHash:$infoHash, uuid:$uuid oobInfohash:$oobInfohash searchComments:$searchComments compressedResults:$compressedResults"
     }
 }

core/src/main/groovy/com/muwire/core/search/SearchIndex.groovy

@@ -1,6 +1,6 @@
 package com.muwire.core.search
 
-import com.muwire.core.Constants
+import com.muwire.core.SplitPattern
 
 class SearchIndex {
 
@@ -32,7 +32,7 @@ class SearchIndex {
     }
 
     private static String[] split(String source) {
-		source = source.replaceAll(Constants.SPLIT_PATTERN, " ").toLowerCase()
+        source = source.replaceAll(SplitPattern.SPLIT_PATTERN, " ").toLowerCase()
         String [] split = source.split(" ")
         def rv = []
         split.each { if (it.length() > 0) rv << it }

core/src/main/groovy/com/muwire/core/search/SearchManager.groovy

@@ -44,7 +44,7 @@ public class SearchManager {
             log.info("No results for search uuid $event.uuid")
             return
         }
-        resultsSender.sendResults(event.uuid, event.results, target, event.searchEvent.oobInfohash)
+        resultsSender.sendResults(event.uuid, event.results, target, event.searchEvent.oobInfohash, event.searchEvent.compressedResults)
     }
 
     boolean hasLocalSearch(UUID uuid) {

core/src/main/groovy/com/muwire/core/search/UIBrowseEvent.groovy

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

core/src/main/groovy/com/muwire/core/search/UIResultEvent.groovy

@@ -14,6 +14,8 @@ class UIResultEvent extends Event {
     long size
     InfoHash infohash
     int pieceSize
+    String comment
+    boolean browse
 
     @Override
     public String toString() {

core/src/main/groovy/com/muwire/core/trust/RemoteTrustList.groovy

@@ -0,0 +1,31 @@
+package com.muwire.core.trust
+
+import java.util.concurrent.ConcurrentHashMap
+
+import com.muwire.core.Persona
+
+import net.i2p.util.ConcurrentHashSet
+
+class RemoteTrustList {
+    public enum Status { NEW, UPDATING, UPDATED, UPDATE_FAILED }
+
+    private final Persona persona
+    private final Set<Persona> good, bad
+    volatile long timestamp
+    volatile boolean forceUpdate
+    Status status = Status.NEW
+
+    RemoteTrustList(Persona persona) {
+        this.persona = persona
+        good = new ConcurrentHashSet<>()
+        bad = new ConcurrentHashSet<>()
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (!(o instanceof RemoteTrustList))
+            return false
+        RemoteTrustList other = (RemoteTrustList)o
+        persona == other.persona
+    }
+}

core/src/main/groovy/com/muwire/core/trust/TrustSubscriber.groovy

@@ -0,0 +1,161 @@
+package com.muwire.core.trust
+
+import java.nio.charset.StandardCharsets
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.ExecutorService
+import java.util.concurrent.Executors
+import java.util.logging.Level
+
+import com.muwire.core.EventBus
+import com.muwire.core.MuWireSettings
+import com.muwire.core.Persona
+import com.muwire.core.UILoadedEvent
+import com.muwire.core.connection.Endpoint
+import com.muwire.core.connection.I2PConnector
+import com.muwire.core.util.DataUtil
+
+import groovy.util.logging.Log
+import net.i2p.data.Destination
+
+@Log
+class TrustSubscriber {
+    private final EventBus eventBus
+    private final I2PConnector i2pConnector
+    private final MuWireSettings settings
+
+    private final Map<Destination, RemoteTrustList> remoteTrustLists = new ConcurrentHashMap<>()
+
+    private final Object waitLock = new Object()
+    private volatile boolean shutdown
+    private volatile Thread thread
+    private final ExecutorService updateThreads = Executors.newCachedThreadPool()
+
+    TrustSubscriber(EventBus eventBus, I2PConnector i2pConnector, MuWireSettings settings) {
+        this.eventBus = eventBus
+        this.i2pConnector = i2pConnector
+        this.settings = settings
+    }
+
+    void onUILoadedEvent(UILoadedEvent e) {
+        thread = new Thread({checkLoop()} as Runnable, "trust-subscriber")
+        thread.setDaemon(true)
+        thread.start()
+    }
+
+    void stop() {
+        shutdown = true
+        thread?.interrupt()
+        updateThreads.shutdownNow()
+    }
+
+    void onTrustSubscriptionEvent(TrustSubscriptionEvent e) {
+        if (!e.subscribe) {
+            remoteTrustLists.remove(e.persona.destination)
+        } else {
+            RemoteTrustList trustList = remoteTrustLists.putIfAbsent(e.persona.destination, new RemoteTrustList(e.persona))
+            trustList?.forceUpdate = true
+            synchronized(waitLock) {
+                waitLock.notify()
+            }
+        }
+    }
+
+    private void checkLoop() {
+        try {
+            while(!shutdown) {
+                synchronized(waitLock) {
+                    waitLock.wait(60 * 1000)
+                }
+                final long now = System.currentTimeMillis()
+                remoteTrustLists.values().each { trustList ->
+                    if (trustList.status == RemoteTrustList.Status.UPDATING)
+                        return
+                    if (!trustList.forceUpdate &&
+                        now - trustList.timestamp < settings.trustListInterval * 60 * 60 * 1000)
+                        return
+                    trustList.forceUpdate = false
+                    updateThreads.submit(new UpdateJob(trustList))
+                }
+            }
+        } catch (InterruptedException e) {
+            if (!shutdown)
+                throw e
+        }
+    }
+
+    private class UpdateJob implements Runnable {
+
+        private final RemoteTrustList trustList
+
+        UpdateJob(RemoteTrustList trustList) {
+            this.trustList = trustList
+        }
+
+        public void run() {
+            trustList.status = RemoteTrustList.Status.UPDATING
+            eventBus.publish(new TrustSubscriptionUpdatedEvent(trustList : trustList))
+            if (check(trustList, System.currentTimeMillis()))
+                trustList.status = RemoteTrustList.Status.UPDATED
+            else
+                trustList.status = RemoteTrustList.Status.UPDATE_FAILED
+            eventBus.publish(new TrustSubscriptionUpdatedEvent(trustList : trustList))
+        }
+    }
+
+    private boolean check(RemoteTrustList trustList, long now) {
+        log.info("fetching trust list from ${trustList.persona.getHumanReadableName()}")
+        Endpoint endpoint = null
+        try {
+            endpoint = i2pConnector.connect(trustList.persona.destination)
+            OutputStream os = endpoint.getOutputStream()
+            InputStream is = endpoint.getInputStream()
+            os.write("TRUST\r\n\r\n".getBytes(StandardCharsets.US_ASCII))
+            os.flush()
+
+            String codeString = DataUtil.readTillRN(is)
+            int space = codeString.indexOf(' ')
+            if (space > 0)
+                codeString = codeString.substring(0,space)
+            int code = Integer.parseInt(codeString.trim())
+
+            if (code != 200) {
+                log.info("couldn't fetch trust list, code $code")
+                return false
+            }
+
+            // swallow any headers
+            String header
+            while (( header = DataUtil.readTillRN(is)) != "");
+
+            DataInputStream dis = new DataInputStream(is)
+
+            Set<Persona> good = new HashSet<>()
+            int nGood = dis.readUnsignedShort()
+            for (int i = 0; i < nGood; i++) {
+                Persona p = new Persona(dis)
+                good.add(p)
+            }
+
+            Set<Persona> bad = new HashSet<>()
+            int nBad = dis.readUnsignedShort()
+            for (int i = 0; i < nBad; i++) {
+                Persona p = new Persona(dis)
+                bad.add(p)
+            }
+
+            trustList.timestamp = now
+            trustList.good.clear()
+            trustList.good.addAll(good)
+            trustList.bad.clear()
+            trustList.bad.addAll(bad)
+
+            return true
+        } catch (Exception e) {
+            log.log(Level.WARNING,"exception fetching trust list from ${trustList.persona.getHumanReadableName()}",e)
+            return false
+        } finally {
+            endpoint?.close()
+        }
+
+    }
+}

core/src/main/groovy/com/muwire/core/trust/TrustSubscriptionEvent.groovy

@@ -0,0 +1,9 @@
+package com.muwire.core.trust
+
+import com.muwire.core.Event
+import com.muwire.core.Persona
+
+class TrustSubscriptionEvent extends Event {
+    Persona persona
+    boolean subscribe
+}

core/src/main/groovy/com/muwire/core/trust/TrustSubscriptionUpdatedEvent.groovy

@@ -0,0 +1,7 @@
+package com.muwire.core.trust
+
+import com.muwire.core.Event
+
+class TrustSubscriptionUpdatedEvent extends Event {
+    RemoteTrustList trustList
+}

core/src/main/groovy/com/muwire/core/update/UpdateClient.groovy

@@ -3,7 +3,15 @@ package com.muwire.core.update
 import java.util.logging.Level
 
 import com.muwire.core.EventBus
+import com.muwire.core.InfoHash
 import com.muwire.core.MuWireSettings
+import com.muwire.core.Persona
+import com.muwire.core.download.UIDownloadEvent
+import com.muwire.core.files.FileDownloadedEvent
+import com.muwire.core.files.FileManager
+import com.muwire.core.search.QueryEvent
+import com.muwire.core.search.SearchEvent
+import com.muwire.core.search.UIResultBatchEvent
 
 import groovy.json.JsonOutput
 import groovy.json.JsonSlurper
@@ -13,6 +21,7 @@ import net.i2p.client.I2PSessionMuxedListener
 import net.i2p.client.SendMessageOptions
 import net.i2p.client.datagram.I2PDatagramDissector
 import net.i2p.client.datagram.I2PDatagramMaker
+import net.i2p.data.Base64
 import net.i2p.util.VersionComparator
 
 @Log
@@ -21,16 +30,24 @@ class UpdateClient {
     final I2PSession session
     final String myVersion
     final MuWireSettings settings
+    final FileManager fileManager
+    final Persona me
 
     private final Timer timer
 
     private long lastUpdateCheckTime
 
-    UpdateClient(EventBus eventBus, I2PSession session, String myVersion, MuWireSettings settings) {
+    private volatile InfoHash updateInfoHash
+    private volatile String version, signer
+    private volatile boolean updateDownloading
+
+    UpdateClient(EventBus eventBus, I2PSession session, String myVersion, MuWireSettings settings, FileManager fileManager, Persona me) {
         this.eventBus = eventBus
         this.session = session
         this.myVersion = myVersion
         this.settings = settings
+        this.fileManager = fileManager
+        this.me = me
         timer = new Timer("update-client",true)
     }
 
@@ -43,6 +60,24 @@ class UpdateClient {
         timer.cancel()
     }
 
+    void onUIResultBatchEvent(UIResultBatchEvent results) {
+        if (results.results[0].infohash != updateInfoHash)
+            return
+        if (updateDownloading)
+            return
+        updateDownloading = true
+        def file = new File(settings.downloadLocation, results.results[0].name)
+        def downloadEvent = new UIDownloadEvent(result: results.results[0], sources : results.results[0].sources, target : file)
+        eventBus.publish(downloadEvent)
+    }
+
+    void onFileDownloadedEvent(FileDownloadedEvent e) {
+        if (e.downloadedFile.infoHash != updateInfoHash)
+            return
+        updateDownloading = false
+        eventBus.publish(new UpdateDownloadedEvent(version : version, signer : signer))
+    }
+
     private void checkUpdate() {
         final long now = System.currentTimeMillis()
         if (lastUpdateCheckTime > 0) {
@@ -106,8 +141,32 @@ class UpdateClient {
                     return
                 }
 
+                String infoHash
+                if (settings.updateType == "jar") {
+                    infoHash = payload.infoHash
+                } else
+                    infoHash = payload[settings.updateType]
+
+
+                if (!settings.autoDownloadUpdate) {
                     log.info("new version $payload.version available, publishing event")
-                eventBus.publish(new UpdateAvailableEvent(version : payload.version, signer : payload.signer, infoHash : payload.infoHash))
+                    eventBus.publish(new UpdateAvailableEvent(version : payload.version, signer : payload.signer, infoHash : infoHash))
+                } else {
+                    log.info("new version $payload.version available")
+                    updateInfoHash = new InfoHash(Base64.decode(infoHash))
+                    if (fileManager.rootToFiles.containsKey(updateInfoHash))
+                        eventBus.publish(new UpdateDownloadedEvent(version : payload.version, signer : payload.signer))
+                    else {
+                        updateDownloading = false
+                        version = payload.version
+                        signer = payload.signer
+                        log.info("starting search for new version hash $payload.infoHash")
+                        def searchEvent = new SearchEvent(searchHash : updateInfoHash.getRoot(), uuid : UUID.randomUUID(), oobInfohash : true)
+                        def queryEvent = new QueryEvent(searchEvent : searchEvent, firstHop : true, replyTo : me.destination,
+                            receivedOn : me.destination, originator : me)
+                        eventBus.publish(queryEvent)
+                    }
+                }
 
             } catch (Exception e) {
                 log.log(Level.WARNING,"Invalid datagram",e)

core/src/main/groovy/com/muwire/core/update/UpdateDownloadedEvent.groovy

@@ -0,0 +1,8 @@
+package com.muwire.core.update
+
+import com.muwire.core.Event
+
+class UpdateDownloadedEvent extends Event {
+    String version
+    String signer
+}

core/src/main/groovy/com/muwire/core/update/UpdateServers.groovy

@@ -3,5 +3,5 @@ package com.muwire.core.update
 import net.i2p.data.Destination
 
 class UpdateServers {
-    static final Destination UPDATE_SERVER = new Destination("pSWieSRB3czCl3Zz4WpKp4Z8tjv-05zbogRDS7SEnKcSdWOupVwjzQ92GsgQh1VqgoSRk1F8dpZOnHxxz5HFy9D7ri0uFdkMyXdSKoB7IgkkvCfTAyEmeaPwSYnurF3Zk7u286E7YG2rZkQZgJ77tow7ZS0mxFB7Z0Ti-VkZ9~GeGePW~howwNm4iSQACZA0DyTpI8iv5j4I0itPCQRgaGziob~Vfvjk49nd8N4jtaDGo9cEcafikVzQ2OgBgYWL6LRbrrItwuGqsDvITUHWaElUYIDhRQYUq8gYiUA6rwAJputfhFU0J7lIxFR9vVY7YzRvcFckfr0DNI4VQVVlPnRPkUxQa--BlldMaCIppWugjgKLwqiSiHywKpSMlBWgY2z1ry4ueEBo1WEP-mEf88wRk4cFQBCKtctCQnIG2GsnATqTl-VGUAsuzeNWZiFSwXiTy~gQ094yWx-K06fFZUDt4CMiLZVhGlixiInD~34FCRC9LVMtFcqiFB2M-Ql2AAAA")
+    static final Destination UPDATE_SERVER = new Destination("VJYAiCPZHNLraWvLkeRLxRiT4PHAqNqRO1nH240r7u1noBw8Pa~-lJOhKR7CccPkEN8ejSi4H6XjqKYLC8BKLVLeOgnAbedUVx81MV7DETPDdPEGV4RVu6YDFri7-tJOeqauGHxtlXT44YWuR69xKrTG3u4~iTWgxKnlBDht9Q3aVpSPFD2KqEizfVxolqXI0zmAZ2xMi8jfl0oe4GbgHrD9hR2FYj6yKfdqcUgHVobY4kDdJt-u31QqwWdsQMEj8Y3tR2XcNaITEVPiAjoKgBrYwB4jddWPNaT4XdHz76d9p9Iqes7dhOKq3OKpk6kg-bfIKiEOiA1mY49fn5h8pNShTqV7QBhh4CE4EDT3Szl~WsLdrlHUKJufSi7erEMh3coF7HORpF1wah2Xw7q470t~b8dKGKi7N7xQsqhGruDm66PH9oE9Kt9WBVBq2zORdPRtRM61I7EnrwDlbOkL0y~XpvQ3JKUQKdBQ3QsOJt8CHlhHHXMMbvqhntR61RSDBQAEAAcAAA==")
 }

core/src/main/groovy/com/muwire/core/upload/ContentRequest.groovy

@@ -2,5 +2,5 @@ package com.muwire.core.upload
 
 class ContentRequest extends Request {
     Range range
-    boolean have
+    int have
 }

core/src/main/groovy/com/muwire/core/upload/ContentUploader.groovy

@@ -56,7 +56,7 @@ class ContentUploader extends Uploader {
         writeMesh(request.downloader)
         os.write("\r\n".getBytes(StandardCharsets.US_ASCII))
 
-        FileChannel channel
+        FileChannel channel = null
         try {
             channel = Files.newByteChannel(file.toPath(), EnumSet.of(StandardOpenOption.READ))
             mapped = channel.map(FileChannel.MapMode.READ_ONLY, range.start, range.end - range.start + 1)
@@ -72,6 +72,10 @@ class ContentUploader extends Uploader {
         } finally {
             try {channel?.close() } catch (IOException ignored) {}
             endpoint.getOutputStream().flush()
+            synchronized(this) {
+                DataUtil.tryUnmap(mapped)
+                mapped = null
+            }
         }
     }
 
@@ -79,7 +83,7 @@ class ContentUploader extends Uploader {
         String xHave = DataUtil.encodeXHave(mesh.pieces.getDownloaded(), mesh.pieces.nPieces)
         endpoint.getOutputStream().write("X-Have: $xHave\r\n".getBytes(StandardCharsets.US_ASCII))
 
-        Set<Persona> sources = mesh.getRandom(3, toExclude)
+        Set<Persona> sources = mesh.getRandom(9, toExclude)
         if (!sources.isEmpty()) {
             String xAlts = sources.stream().map({ it.toBase64() }).collect(Collectors.joining(","))
             endpoint.getOutputStream().write("X-Alt: $xAlts\r\n".getBytes(StandardCharsets.US_ASCII))
@@ -105,4 +109,18 @@ class ContentUploader extends Uploader {
         request.downloader.getHumanReadableName()
     }
 
+    @Override
+    public int getDonePieces() {
+        return request.have;
+    }
+
+    @Override
+    public int getTotalPieces() {
+        return mesh.pieces.nPieces;
+    }
+
+    @Override
+    public long getTotalSize() {
+        return file.length();
+    }
 }

core/src/main/groovy/com/muwire/core/upload/HashListUploader.groovy

@@ -51,5 +51,18 @@ class HashListUploader extends Uploader {
         request.downloader.getHumanReadableName()
     }
 
-    
+    @Override
+    public int getDonePieces() {
+        return 0;
+    }
+
+    @Override
+    public int getTotalPieces() {
+        return 1;
+    }
+
+    @Override
+    public long getTotalSize() {
+        return -1;
+    }
 }

core/src/main/groovy/com/muwire/core/upload/Request.groovy

@@ -50,10 +50,10 @@ class Request {
             downloader = new Persona(new ByteArrayInputStream(decoded))
         }
 
-        boolean have = false
+        int have = 0
         if (headers.containsKey("X-Have")) {
             def encoded = headers["X-Have"].trim()
-            have = DataUtil.decodeXHave(encoded).size() > 0
+            have = DataUtil.decodeXHave(encoded).size()
         }
         new ContentRequest( infoHash : infoHash, range : new Range(start, end),
             headers : headers, downloader : downloader, have : have)

core/src/main/groovy/com/muwire/core/upload/UploadManager.groovy

@@ -80,7 +80,7 @@ public class UploadManager {
                 return
             }
 
-            if (request.have) 
+            if (request.have > 0)
                 eventBus.publish(new SourceDiscoveredEvent(infoHash : request.infoHash, source : request.downloader))
 
             Mesh mesh
@@ -92,7 +92,7 @@ public class UploadManager {
                 pieceSize = downloader.pieceSizePow2
             } else {
                 SharedFile sharedFile = sharedFiles.iterator().next();
-                mesh = meshManager.getOrCreate(request.infoHash, sharedFile.NPieces)
+                mesh = meshManager.getOrCreate(request.infoHash, sharedFile.NPieces, false)
                 file = sharedFile.file
                 pieceSize = sharedFile.pieceSize
             }
@@ -205,7 +205,7 @@ public class UploadManager {
                 return
             }
 
-            if (request.have)
+            if (request.have > 0)
                 eventBus.publish(new SourceDiscoveredEvent(infoHash : request.infoHash, source : request.downloader))
 
             Mesh mesh
@@ -217,7 +217,7 @@ public class UploadManager {
                 pieceSize = downloader.pieceSizePow2
             } else {
                 SharedFile sharedFile = sharedFiles.iterator().next();
-                mesh = meshManager.getOrCreate(request.infoHash, sharedFile.NPieces)
+                mesh = meshManager.getOrCreate(request.infoHash, sharedFile.NPieces, false)
                 file = sharedFile.file
                 pieceSize = sharedFile.pieceSize
             }

core/src/main/groovy/com/muwire/core/upload/Uploader.groovy

@@ -32,4 +32,10 @@ abstract class Uploader {
     abstract int getProgress();
 
     abstract String getDownloader();
+
+    abstract int getDonePieces();
+
+    abstract int getTotalPieces();
+
+    abstract long getTotalSize();
 }

core/src/main/groovy/com/muwire/core/util/DataUtil.groovy

@@ -1,112 +0,0 @@
-package com.muwire.core.util
-
-import java.nio.charset.StandardCharsets
-
-import com.muwire.core.Constants
-
-import net.i2p.data.Base64
-
-class DataUtil {
-	
-	private final static int MAX_SHORT = (0x1 << 16) - 1
-
-	static void writeUnsignedShort(int value, OutputStream os) {
-		if (value > MAX_SHORT || value < 0)
-			throw new IllegalArgumentException("$value invalid")
-		
-		byte lsb = (byte) (value & 0xFF)
-		byte msb = (byte) (value >> 8)
-		
-		os.write(msb)
-		os.write(lsb)	
-	}
-	
-	private final static int MAX_HEADER = 0x7FFFFF
-	
-	static void packHeader(int length, byte [] header) {
-		if (header.length != 3)
-			throw new IllegalArgumentException("header length $header.length")
-		if (length < 0 || length > MAX_HEADER)
-			throw new IllegalArgumentException("length $length")
-		
-		header[2] = (byte) (length & 0xFF)
-		header[1] = (byte) ((length >> 8) & 0xFF)
-		header[0] = (byte) ((length >> 16) & 0x7F)
-	}
-	
-	static int readLength(byte [] header) {
-		if (header.length != 3)
-			throw new IllegalArgumentException("header length $header.length")
-			
-		return (((int)(header[0] & 0x7F)) << 16) |
-				(((int)(header[1] & 0xFF) << 8)) |
-				((int)header[2] & 0xFF)
-	}
-    
-    static String readi18nString(byte [] encoded) {
-        if (encoded.length < 2)
-            throw new IllegalArgumentException("encoding too short $encoded.length")
-        int length = ((encoded[0] & 0xFF) << 8) | (encoded[1] & 0xFF)
-        if (encoded.length != length + 2)
-            throw new IllegalArgumentException("encoding doesn't match length, expected $length found $encoded.length")
-        byte [] string = new byte[length]
-        System.arraycopy(encoded, 2, string, 0, length)
-        new String(string, StandardCharsets.UTF_8) 
-    }
-    
-    static byte[] encodei18nString(String string) {
-        byte [] utf8 = string.getBytes(StandardCharsets.UTF_8)
-        if (utf8.length > Short.MAX_VALUE)
-            throw new IllegalArgumentException("String in utf8 too long $utf8.length")
-        def baos = new ByteArrayOutputStream()
-        def daos = new DataOutputStream(baos)
-        daos.writeShort((short) utf8.length)
-        daos.write(utf8) 
-        daos.close()
-        baos.toByteArray()
-    }
-    
-    public static String readTillRN(InputStream is) {
-        def baos = new ByteArrayOutputStream()
-        while(baos.size() < (Constants.MAX_HEADER_SIZE)) {
-            byte read = is.read()
-            if (read == -1)
-                throw new IOException()
-            if (read == '\r') {
-                if (is.read() != '\n')
-                    throw new IOException("invalid header")
-                break
-            }
-            baos.write(read)
-        }
-        new String(baos.toByteArray(), StandardCharsets.US_ASCII)
-    }
-    
-    public static String encodeXHave(List<Integer> pieces, int totalPieces) {
-        int bytes = totalPieces / 8
-        if (totalPieces % 8 != 0)
-            bytes++
-        byte[] raw = new byte[bytes]
-        pieces.each {
-            int byteIdx = it / 8
-            int offset = it % 8
-            int mask = 0x80 >>> offset
-            raw[byteIdx] |= mask
-        }
-        Base64.encode(raw)
-    }
-    
-    public static List<Integer> decodeXHave(String xHave) {
-        byte [] availablePieces = Base64.decode(xHave)
-        List<Integer> available = new ArrayList<>()
-        availablePieces.eachWithIndex {b, i ->
-            for (int j = 0; j < 8 ; j++) {
-                byte mask = 0x80 >>> j
-                if ((b & mask) == mask) {
-                    available.add(i * 8 + j)
-                }
-            }
-        }
-        available
-    }
-}

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

@@ -0,0 +1,13 @@
+package com.muwire.core;
+
+import net.i2p.crypto.SigType;
+
+public 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 int MAX_RESULTS = 0x1 << 16;
+}

core/src/main/java/com/muwire/core/DownloadedFile.java

@@ -1,6 +1,7 @@
 package com.muwire.core;
 
 import java.io.File;
+import java.io.IOException;
 import java.util.Set;
 
 import net.i2p.data.Destination;
@@ -9,7 +10,8 @@ public class DownloadedFile extends SharedFile {
 
     private final Set<Destination> sources;
 
-	public DownloadedFile(File file, InfoHash infoHash, int pieceSize, Set<Destination> sources) {
+    public DownloadedFile(File file, InfoHash infoHash, int pieceSize, Set<Destination> sources)
+    throws IOException {
         super(file, infoHash, pieceSize);
         this.sources = sources;
     }

core/src/main/java/com/muwire/core/SharedFile.java

@@ -1,6 +1,13 @@
 package com.muwire.core;
 
 import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+import com.muwire.core.util.DataUtil;
+
+import net.i2p.data.Base64;
 
 public class SharedFile {
 
@@ -8,10 +15,31 @@ public class SharedFile {
     private final InfoHash infoHash;
     private final int pieceSize;
 
-	public SharedFile(File file, InfoHash infoHash, int pieceSize) {
+    private final String cachedPath;
+    private final long cachedLength;
+    
+    private final String b64EncodedFileName;
+    private final String b64EncodedHashRoot;
+    private final List<String> b64EncodedHashList;
+    
+    private volatile String comment;
+
+    public SharedFile(File file, InfoHash infoHash, int pieceSize) throws IOException {
         this.file = file;
         this.infoHash = infoHash;
         this.pieceSize = pieceSize;
+        this.cachedPath = file.getAbsolutePath();
+        this.cachedLength = file.length();
+        this.b64EncodedFileName = Base64.encode(DataUtil.encodei18nString(file.toString()));
+        this.b64EncodedHashRoot = Base64.encode(infoHash.getRoot());
+        
+        List<String> b64List = new ArrayList<String>();
+        byte[] tmp = new byte[32];
+        for (int i = 0; i < infoHash.getHashList().length / 32; i++) {
+            System.arraycopy(infoHash.getHashList(), i * 32, tmp, 0, 32);
+            b64List.add(Base64.encode(tmp));
+        }
+        this.b64EncodedHashList = b64List;
     }
 
     public File getFile() {
@@ -30,11 +58,39 @@ public class SharedFile {
         long length = file.length();
         int rawPieceSize = 0x1 << pieceSize;
         int rv = (int) (length / rawPieceSize);
-	    if (length % pieceSize != 0)
+        if (length % rawPieceSize != 0)
             rv++;
         return rv;
     }
     
+    public String getB64EncodedFileName() {
+        return b64EncodedFileName;
+    }
+    
+    public String getB64EncodedHashRoot() {
+        return b64EncodedHashRoot;
+    }
+    
+    public List<String> getB64EncodedHashList() {
+        return b64EncodedHashList;
+    }
+
+    public String getCachedPath() {
+        return cachedPath;
+    }
+
+    public long getCachedLength() {
+        return cachedLength;
+    }
+    
+    public void setComment(String comment) {
+        this.comment = comment;
+    }
+    
+    public String getComment() {
+        return comment;
+    }
+
     @Override
     public int hashCode() {
         return file.hashCode() ^ infoHash.hashCode();

core/src/main/java/com/muwire/core/util/DataUtil.java

@@ -0,0 +1,168 @@
+package com.muwire.core.util;
+
+import java.io.ByteArrayOutputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.List;
+
+import com.muwire.core.Constants;
+
+import net.i2p.data.Base64;
+
+public class DataUtil {
+
+    private final static int MAX_SHORT = (0x1 << 16) - 1;
+
+    static void writeUnsignedShort(int value, OutputStream os) throws IOException {
+        if (value > MAX_SHORT || value < 0)
+            throw new IllegalArgumentException("$value invalid");
+
+        byte lsb = (byte) (value & 0xFF);
+        byte msb = (byte) (value >> 8);
+
+        os.write(msb);
+        os.write(lsb);
+    }
+
+    private final static int MAX_HEADER = 0x7FFFFF;
+
+    static void packHeader(int length, byte [] header) {
+        if (header.length != 3)
+            throw new IllegalArgumentException("header length $header.length");
+        if (length < 0 || length > MAX_HEADER)
+            throw new IllegalArgumentException("length $length");
+
+        header[2] = (byte) (length & 0xFF);
+        header[1] = (byte) ((length >> 8) & 0xFF);
+        header[0] = (byte) ((length >> 16) & 0x7F);
+    }
+
+    static int readLength(byte [] header) {
+        if (header.length != 3)
+            throw new IllegalArgumentException("header length $header.length");
+
+        return (((int)(header[0] & 0x7F)) << 16) |
+                (((int)(header[1] & 0xFF) << 8)) |
+                ((int)header[2] & 0xFF);
+    }
+
+    static String readi18nString(byte [] encoded) {
+        if (encoded.length < 2)
+            throw new IllegalArgumentException("encoding too short $encoded.length");
+        int length = ((encoded[0] & 0xFF) << 8) | (encoded[1] & 0xFF);
+        if (encoded.length != length + 2)
+            throw new IllegalArgumentException("encoding doesn't match length, expected $length found $encoded.length");
+        byte [] string = new byte[length];
+        System.arraycopy(encoded, 2, string, 0, length);
+        return new String(string, StandardCharsets.UTF_8);
+    }
+
+    public static byte[] encodei18nString(String string) {
+        byte [] utf8 = string.getBytes(StandardCharsets.UTF_8);
+        if (utf8.length > Short.MAX_VALUE)
+            throw new IllegalArgumentException("String in utf8 too long $utf8.length");
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        DataOutputStream daos = new DataOutputStream(baos);
+        try {
+            daos.writeShort((short) utf8.length);
+            daos.write(utf8);
+            daos.close();
+        } catch (IOException impossible) {
+            throw new IllegalStateException(impossible);
+        }
+        return baos.toByteArray();
+    }
+
+    public static String readTillRN(InputStream is) throws IOException {
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        while(baos.size() < (Constants.MAX_HEADER_SIZE)) {
+            int read = is.read();
+            if (read == -1)
+                throw new IOException();
+            if (read == '\r') {
+                if (is.read() != '\n')
+                    throw new IOException("invalid header");
+                break;
+            }
+            baos.write(read);
+        }
+        return new String(baos.toByteArray(), StandardCharsets.US_ASCII);
+    }
+
+    public static String encodeXHave(List<Integer> pieces, int totalPieces) {
+        int bytes = totalPieces / 8;
+        if (totalPieces % 8 != 0)
+            bytes++;
+        byte[] raw = new byte[bytes];
+        for (int it : pieces) {
+            int byteIdx = it / 8;
+            int offset = it % 8;
+            int mask = 0x80 >>> offset;
+            raw[byteIdx] |= mask;
+        }
+        return Base64.encode(raw);
+    }
+
+    public static List<Integer> decodeXHave(String xHave) {
+        byte [] availablePieces = Base64.decode(xHave);
+        List<Integer> available = new ArrayList<>();
+        for (int i = 0; i < availablePieces.length; i ++) {
+            byte b = availablePieces[i];
+            for (int j = 0; j < 8 ; j++) {
+                byte mask = (byte) (0x80 >>> j);
+                if ((b & mask) == mask) {
+                    available.add(i * 8 + j);
+                }
+            }
+        }
+        return available;
+    }
+
+    public static Throwable findRoot(Throwable e) {
+        while(e.getCause() != null)
+            e = e.getCause();
+        return e;
+    }
+
+    public static void tryUnmap(ByteBuffer cb) {
+        if (cb==null || !cb.isDirect()) return;
+        // we could use this type cast and call functions without reflection code,
+        // but static import from sun.* package is risky for non-SUN virtual machine.
+        //try { ((sun.nio.ch.DirectBuffer)cb).cleaner().clean(); } catch (Exception ex) { }
+
+        // JavaSpecVer: 1.6, 1.7, 1.8, 9, 10
+        boolean isOldJDK = System.getProperty("java.specification.version","99").startsWith("1.");
+        try {
+            if (isOldJDK) {
+                Method cleaner = cb.getClass().getMethod("cleaner");
+                cleaner.setAccessible(true);
+                Method clean = Class.forName("sun.misc.Cleaner").getMethod("clean");
+                clean.setAccessible(true);
+                clean.invoke(cleaner.invoke(cb));
+            } else {
+                Class unsafeClass;
+                try {
+                    unsafeClass = Class.forName("sun.misc.Unsafe");
+                } catch(Exception ex) {
+                    // jdk.internal.misc.Unsafe doesn't yet have an invokeCleaner() method,
+                    // but that method should be added if sun.misc.Unsafe is removed.
+                    unsafeClass = Class.forName("jdk.internal.misc.Unsafe");
+                }
+                Method clean = unsafeClass.getMethod("invokeCleaner", ByteBuffer.class);
+                clean.setAccessible(true);
+                Field theUnsafeField = unsafeClass.getDeclaredField("theUnsafe");
+                theUnsafeField.setAccessible(true);
+                Object theUnsafe = theUnsafeField.get(null);
+                clean.invoke(theUnsafe, cb);
+            }
+        } catch(Exception ex) { }
+        cb = null;
+    }
+}

core/src/test/groovy/com/muwire/core/download/DownloadSessionTest.groovy

@@ -4,6 +4,7 @@ import static org.junit.Assert.fail
 
 import org.junit.After
 import org.junit.Before
+import org.junit.Ignore
 import org.junit.Test
 
 import com.muwire.core.EventBus
@@ -180,10 +181,11 @@ class DownloadSessionTest {
     }
 
     @Test
+    @Ignore // this needs to be rewritten with stealing in mind
     public void testSmallFileClaimed() {
         initSession(20, [0])
         long now = System.currentTimeMillis()
-        downloadThread.join(100)
+        downloadThread.join(150)
         assert 100 >= (System.currentTimeMillis() - now)
         assert !performed
         assert available.isEmpty()

core/src/test/groovy/com/muwire/core/download/PiecesTest.groovy

@@ -16,7 +16,7 @@ class PiecesTest {
     public void testSinglePiece() {
         pieces = new Pieces(1)
         assert !pieces.isComplete()
-        assert pieces.claim() == 0
+        assert pieces.claim() == [0,0,0]
         pieces.markDownloaded(0)
         assert pieces.isComplete()
     }
@@ -25,28 +25,28 @@ class PiecesTest {
     public void testTwoPieces() {
         pieces = new Pieces(2)
         assert !pieces.isComplete()
-        int piece = pieces.claim()
-        assert piece == 0 || piece == 1
-        pieces.markDownloaded(piece)
+        int[] piece = pieces.claim()
+        assert piece[0] == 0 || piece[0] == 1
+        pieces.markDownloaded(piece[0])
         assert !pieces.isComplete()
-        int piece2 = pieces.claim()
-        assert piece != piece2
-        pieces.markDownloaded(piece2)
+        int[] piece2 = pieces.claim()
+        assert piece[0] != piece2[0]
+        pieces.markDownloaded(piece2[0])
         assert pieces.isComplete()
     }
 
     @Test
     public void testClaimAvailable() {
         pieces = new Pieces(2)
-        int claimed = pieces.claim([0].toSet())
-        assert claimed == 0
-        assert -1 == pieces.claim([0].toSet())
+        int[] claimed = pieces.claim([0].toSet())
+        assert claimed == [0,0,0]
+        assert [0,0,1] == pieces.claim([0].toSet())
     }
 
     @Test
     public void testClaimNoneAvailable() {
         pieces = new Pieces(20)
-        int claimed = pieces.claim()
-        assert -1 == pieces.claim([claimed].toSet())
+        int[] claimed = pieces.claim()
+        assert [0,0,0] == pieces.claim(claimed.toSet())
     }
 }

core/src/test/groovy/com/muwire/core/files/HasherServiceTest.groovy

@@ -25,7 +25,8 @@ class HasherServiceTest {
     void before() {
         eventBus = new EventBus()
         hasher = new FileHasher()
-		service = new HasherService(hasher, eventBus, new FileManager(eventBus, new MuWireSettings()))
+        def props = new MuWireSettings()
+        service = new HasherService(hasher, eventBus, new FileManager(eventBus, props), props)
         eventBus.register(FileHashedEvent.class, listener)
         eventBus.register(FileSharedEvent.class, service)
         service.start()

core/src/test/groovy/com/muwire/core/hostcache/HostCacheTest.groovy

@@ -72,6 +72,9 @@ class HostCacheTest {
             TrustLevel.NEUTRAL
         }
         settingsMock.ignore.allowUntrusted { true }
+        settingsMock.ignore.getHostClearInterval { 0 }
+        settingsMock.ignore.getHostHopelessInterval { 0 }
+        settingsMock.ignore.getHostRejectInterval { 0 }
 
         initMocks()
 
@@ -91,6 +94,10 @@ class HostCacheTest {
             TrustLevel.DISTRUSTED
         }
 
+        settingsMock.ignore.getHostClearInterval { 0 }
+        settingsMock.ignore.getHostHopelessInterval { 0 }
+        settingsMock.ignore.getHostRejectInterval { 0 }
+        
         initMocks()
 
         cache.onHostDiscoveredEvent(new HostDiscoveredEvent(destination: destinations.dest1))
@@ -104,6 +111,9 @@ class HostCacheTest {
             TrustLevel.NEUTRAL
         }
         settingsMock.ignore.allowUntrusted { false }
+        settingsMock.ignore.getHostClearInterval { 0 }
+        settingsMock.ignore.getHostHopelessInterval { 0 }
+        settingsMock.ignore.getHostRejectInterval { 0 }
 
         initMocks()
 
@@ -123,6 +133,9 @@ class HostCacheTest {
         }
         trustMock.demand.getLevel{ d -> TrustLevel.TRUSTED }
         trustMock.demand.getLevel{ d -> TrustLevel.TRUSTED }
+        settingsMock.ignore.getHostClearInterval { 0 }
+        settingsMock.ignore.getHostHopelessInterval { 0 }
+        settingsMock.ignore.getHostRejectInterval { 0 }
 
         initMocks()
         cache.onHostDiscoveredEvent(new HostDiscoveredEvent(destination: destinations.dest1))
@@ -139,6 +152,14 @@ class HostCacheTest {
             assert d == destinations.dest1
             TrustLevel.TRUSTED
         }
+        trustMock.demand.getLevel { d ->
+            assert d == destinations.dest1
+            TrustLevel.TRUSTED
+        }
+
+        settingsMock.ignore.getHostClearInterval { 100 }
+        settingsMock.ignore.getHostHopelessInterval { 0 }
+        settingsMock.ignore.getHostRejectInterval { 0 }
         
         initMocks()
         cache.onHostDiscoveredEvent(new HostDiscoveredEvent(destination: destinations.dest1))
@@ -158,6 +179,10 @@ class HostCacheTest {
             TrustLevel.TRUSTED
         }
 
+        settingsMock.ignore.getHostClearInterval { 0 }
+        settingsMock.ignore.getHostHopelessInterval { 0 }
+        settingsMock.ignore.getHostRejectInterval { 0 }
+        
         initMocks()
         cache.onHostDiscoveredEvent(new HostDiscoveredEvent(destination: destinations.dest1))
 
@@ -183,6 +208,10 @@ class HostCacheTest {
             TrustLevel.TRUSTED
         }
 
+        settingsMock.ignore.getHostClearInterval { 0 }
+        settingsMock.ignore.getHostHopelessInterval { 0 }
+        settingsMock.ignore.getHostRejectInterval { 0 }
+        
         initMocks()
         cache.onHostDiscoveredEvent(new HostDiscoveredEvent(destination: destinations.dest1))
 
@@ -214,6 +243,10 @@ class HostCacheTest {
             TrustLevel.TRUSTED
         }
 
+        settingsMock.ignore.getHostClearInterval { 0 }
+        settingsMock.ignore.getHostHopelessInterval { 0 }
+        settingsMock.ignore.getHostRejectInterval { 0 }
+        
         initMocks()
         cache.onHostDiscoveredEvent(new HostDiscoveredEvent(destination: destinations.dest1))
         cache.onHostDiscoveredEvent(new HostDiscoveredEvent(destination: destinations.dest1))
@@ -229,6 +262,11 @@ class HostCacheTest {
             assert d == destinations.dest1
             TrustLevel.TRUSTED
         }
+        
+        settingsMock.ignore.getHostClearInterval { 0 }
+        settingsMock.ignore.getHostHopelessInterval { 0 }
+        settingsMock.ignore.getHostRejectInterval { 0 }
+        
         initMocks()
         cache.onHostDiscoveredEvent(new HostDiscoveredEvent(destination: destinations.dest1))
         Thread.sleep(150)
@@ -260,6 +298,10 @@ class HostCacheTest {
             TrustLevel.TRUSTED
         }
 
+        settingsMock.ignore.getHostClearInterval { 0 }
+        settingsMock.ignore.getHostHopelessInterval { 0 }
+        settingsMock.ignore.getHostRejectInterval { 0 }
+        
         initMocks()
         def rv = cache.getHosts(5)
         assert rv.size() == 1

core/src/test/groovy/com/muwire/core/upload/UploaderTest.groovy

@@ -9,6 +9,9 @@ import org.junit.Test
 
 import com.muwire.core.InfoHash
 import com.muwire.core.connection.Endpoint
+import com.muwire.core.download.Pieces
+import com.muwire.core.files.FileHasher
+import com.muwire.core.mesh.Mesh
 
 class UploaderTest {
 
@@ -52,7 +55,13 @@ class UploaderTest {
     }
 
     private void startUpload() {
-        uploader = new ContentUploader(file, request, endpoint)
+        def hasher = new FileHasher()
+        InfoHash infoHash = hasher.hashFile(file)
+        Pieces pieces = new Pieces(FileHasher.getPieceSize(file.length()))
+        for (int i = 0; i < pieces.nPieces; i++)
+            pieces.markDownloaded(i)
+        Mesh mesh = new Mesh(infoHash, pieces)
+        uploader = new ContentUploader(file, request, endpoint, mesh, FileHasher.getPieceSize(file.length()))
         uploadThread = new Thread(uploader.respond() as Runnable)
         uploadThread.setDaemon(true)
         uploadThread.start()
@@ -81,6 +90,7 @@ class UploaderTest {
         startUpload()
         assert "200 OK" == readUntilRN()
         assert "Content-Range: 0-19" == readUntilRN()
+        assert readUntilRN().startsWith("X-Have")
         assert "" == readUntilRN()
 
         byte [] data = new byte[20]
@@ -96,6 +106,7 @@ class UploaderTest {
         startUpload()
         assert "200 OK" == readUntilRN()
         assert "Content-Range: 5-15" == readUntilRN()
+        assert readUntilRN().startsWith("X-Have")
         assert "" == readUntilRN()
 
         byte [] data = new byte[11]
@@ -111,6 +122,7 @@ class UploaderTest {
         request = new ContentRequest(range : new Range(0,20))
         startUpload()
         assert "416 Range Not Satisfiable" == readUntilRN()
+        assert readUntilRN().startsWith("X-Have")
         assert "" == readUntilRN()
     }
 
@@ -123,6 +135,7 @@ class UploaderTest {
         readUntilRN()
         readUntilRN()
         readUntilRN()
+        readUntilRN()
 
         byte [] data = new byte[length]
         DataInputStream dis = new DataInputStream(is)

gradle.properties

@@ -1,8 +1,20 @@
 group         = com.muwire
-version       = 0.3.6
+version       = 0.5.2
+i2pVersion    = 0.9.42
 groovyVersion = 2.4.15
 slf4jVersion  = 1.7.25
 spockVersion  = 1.1-groovy-2.4
+grailsVersion=4.0.0
+gorm.version=7.0.2.RELEASE
 
 sourceCompatibility=1.8
 targetCompatibility=1.8
+
+# plugin properties
+author = zab@mail.i2p
+signer = zab@mail.i2p
+keystorePassword=changeit
+websiteURL=http://muwire.i2p
+updateURLsu3=http://muwire.i2p/MuWire.su3
+
+pack200=true

gradlew

@@ -11,21 +11,21 @@
 PRG="$0"
 # Need this for relative symlinks.
 while [ -h "$PRG" ] ; do
-    ls=`ls -ld "$PRG"`
-    link=`expr "$ls" : '.*-> \(.*\)$'`
+    ls=$(ls -ld "$PRG")
+    link=$(expr "$ls" : '.*-> \(.*\)$')
     if expr "$link" : '/.*' > /dev/null; then
         PRG="$link"
     else
-        PRG=`dirname "$PRG"`"/$link"
+        PRG=$(dirname "$PRG")"/$link"
     fi
 done
-SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >/dev/null
-APP_HOME="`pwd -P`"
+SAVED="$(pwd)"
+cd "$(dirname "$PRG")/" >/dev/null
+APP_HOME="$(pwd -P)"
 cd "$SAVED" >/dev/null
 
 APP_NAME="Gradle"
-APP_BASE_NAME=`basename "$0"`
+APP_BASE_NAME=$(basename "$0")
 
 # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
 DEFAULT_JVM_OPTS=""
@@ -49,7 +49,7 @@ cygwin=false
 msys=false
 darwin=false
 nonstop=false
-case "`uname`" in
+case "$(uname)" in
   CYGWIN* )
     cygwin=true
     ;;
@@ -90,7 +90,7 @@ fi
 
 # Increase the maximum file descriptors if we can.
 if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
-    MAX_FD_LIMIT=`ulimit -H -n`
+    MAX_FD_LIMIT=$(ulimit -H -n)
     if [ $? -eq 0 ] ; then
         if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
             MAX_FD="$MAX_FD_LIMIT"
@@ -111,12 +111,12 @@ fi
 
 # For Cygwin, switch paths to Windows format before running java
 if $cygwin ; then
-    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
-    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
-    JAVACMD=`cygpath --unix "$JAVACMD"`
+    APP_HOME=$(cygpath --path --mixed "$APP_HOME")
+    CLASSPATH=$(cygpath --path --mixed "$CLASSPATH")
+    JAVACMD=$(cygpath --unix "$JAVACMD")
 
     # We build the pattern for arguments to be converted via cygpath
-    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+    ROOTDIRSRAW=$(find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null)
     SEP=""
     for dir in $ROOTDIRSRAW ; do
         ROOTDIRS="$ROOTDIRS$SEP$dir"
@@ -130,13 +130,13 @@ if $cygwin ; then
     # Now convert the arguments - kludge to limit ourselves to /bin/sh
     i=0
     for arg in "$@" ; do
-        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
-        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
+        CHECK=$(echo "$arg"|egrep -c "$OURCYGPATTERN" -)
+        CHECK2=$(echo "$arg"|egrep -c "^-")                                ### Determine if an option
 
         if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
-            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+            eval $(echo args$i)=$(cygpath --path --ignore --mixed "$arg")
         else
-            eval `echo args$i`="\"$arg\""
+            eval $(echo args$i)="\"$arg\""
         fi
         i=$((i+1))
     done

gui/build.gradle

@@ -44,9 +44,9 @@ mainClassName = 'com.muwire.gui.Launcher'
 applicationDefaultJvmArgs = ['-Djava.util.logging.config.file=logging.properties']
 
 apply from: 'gradle/publishing.gradle'
-apply from: 'gradle/code-coverage.gradle'
-apply from: 'gradle/code-quality.gradle'
-apply from: 'gradle/integration-test.gradle'
+// apply from: 'gradle/code-coverage.gradle'
+// apply from: 'gradle/code-quality.gradle'
+// apply from: 'gradle/integration-test.gradle'
 // apply from: 'gradle/package.gradle'
 apply from: 'gradle/docs.gradle'
 apply plugin: 'com.github.johnrengelman.shadow'
@@ -58,7 +58,11 @@ dependencies {
     compile project(":core")
     compile "org.codehaus.griffon:griffon-guice:${griffon.version}"
 
-    runtime "org.slf4j:slf4j-simple:${slf4jVersion}"
+    // runtime "org.slf4j:slf4j-simple:${slf4jVersion}"
+
+    runtime group: 'org.slf4j', name: 'slf4j-jdk14', version: "${slf4jVersion}"
+    runtime group: 'org.slf4j', name: 'slf4j-api', version: "${slf4jVersion}"    
+    runtime group: 'org.slf4j', name: 'jul-to-slf4j', version: "${slf4jVersion}"
     runtime "javax.annotation:javax.annotation-api:1.3.2"
 
     testCompile "org.codehaus.griffon:griffon-fest-test:${griffon.version}"
@@ -119,6 +123,7 @@ if (hasProperty('debugRun') && ((project.debugRun as boolean))) {
     }
 }
 
+/*
 task jacocoRootMerge(type: org.gradle.testing.jacoco.tasks.JacocoMerge, dependsOn: [test, jacocoTestReport, jacocoIntegrationTestReport]) {
     executionData = files(jacocoTestReport.executionData, jacocoIntegrationTestReport.executionData)
     destinationFile = file("${buildDir}/jacoco/root.exec")
@@ -138,4 +143,5 @@ task jacocoRootReport(dependsOn: jacocoRootMerge, type: JacocoReport) {
         xml.destination = file("${buildDir}/reports/jacoco/root/root.xml")
     }
 }
+*/
 

gui/griffon-app/conf/Config.groovy

@@ -26,4 +26,39 @@ mvcGroups {
         view = 'com.muwire.gui.OptionsView'
         controller = 'com.muwire.gui.OptionsController'
     }
+    "mu-wire-status" {
+        model = 'com.muwire.gui.MuWireStatusModel'
+        view = 'com.muwire.gui.MuWireStatusView'
+        controller = 'com.muwire.gui.MuWireStatusController'
+    }
+    'i-2-p-status' {
+        model = 'com.muwire.gui.I2PStatusModel'
+        view = 'com.muwire.gui.I2PStatusView'
+        controller = 'com.muwire.gui.I2PStatusController'
+    }
+    'trust-list' {
+        model = 'com.muwire.gui.TrustListModel'
+        view = 'com.muwire.gui.TrustListView'
+        controller = 'com.muwire.gui.TrustListController'
+    }
+    'content-panel' {
+        model = 'com.muwire.gui.ContentPanelModel'
+        view = 'com.muwire.gui.ContentPanelView'
+        controller = 'com.muwire.gui.ContentPanelController'
+    }
+    'show-comment' {
+        model = 'com.muwire.gui.ShowCommentModel'
+        view = 'com.muwire.gui.ShowCommentView'
+        controller = 'com.muwire.gui.ShowCommentController'
+    }
+    'add-comment' {
+        model = 'com.muwire.gui.AddCommentModel'
+        view = 'com.muwire.gui.AddCommentView'
+        controller = 'com.muwire.gui.AddCommentController'
+    }
+    'browse' {
+        model = 'com.muwire.gui.BrowseModel'
+        view = 'com.muwire.gui.BrowseView'
+        controller = 'com.muwire.gui.BrowseController'
+    }
 }

gui/griffon-app/controllers/com/muwire/gui/AddCommentController.groovy

@@ -0,0 +1,45 @@
+package com.muwire.gui
+
+import griffon.core.artifact.GriffonController
+import griffon.core.controller.ControllerAction
+import griffon.inject.MVCMember
+import griffon.metadata.ArtifactProviderFor
+import net.i2p.data.Base64
+
+import javax.annotation.Nonnull
+
+import com.muwire.core.Core
+import com.muwire.core.files.UICommentEvent
+import com.muwire.core.util.DataUtil
+
+@ArtifactProviderFor(GriffonController)
+class AddCommentController {
+    @MVCMember @Nonnull
+    AddCommentModel model
+    @MVCMember @Nonnull
+    AddCommentView view
+
+    Core core
+    
+    @ControllerAction
+    void save() {
+        String comment = view.textarea.getText()
+        if (comment.trim().length() == 0)
+            comment = null
+        else
+            comment = Base64.encode(DataUtil.encodei18nString(comment))
+        model.selectedFiles.each {
+            def event = new UICommentEvent(sharedFile : it, oldComment : it.getComment())
+            it.setComment(comment)
+            core.eventBus.publish(event)    
+        }
+        mvcGroup.parentGroup.view.refreshSharedFiles()
+        cancel()
+    }
+    
+    @ControllerAction
+    void cancel() {
+        view.dialog.setVisible(false)
+        mvcGroup.destroy()
+    }
+}

gui/griffon-app/controllers/com/muwire/gui/BrowseController.groovy

@@ -0,0 +1,99 @@
+package com.muwire.gui
+
+import griffon.core.artifact.GriffonController
+import griffon.core.controller.ControllerAction
+import griffon.inject.MVCMember
+import griffon.metadata.ArtifactProviderFor
+import net.i2p.data.Base64
+
+import javax.annotation.Nonnull
+
+import com.muwire.core.EventBus
+import com.muwire.core.download.UIDownloadEvent
+import com.muwire.core.search.BrowseStatus
+import com.muwire.core.search.BrowseStatusEvent
+import com.muwire.core.search.UIBrowseEvent
+import com.muwire.core.search.UIResultEvent
+
+@ArtifactProviderFor(GriffonController)
+class BrowseController {
+    @MVCMember @Nonnull
+    BrowseModel model
+    @MVCMember @Nonnull
+    BrowseView view
+
+    EventBus eventBus
+    
+    
+    void register() {
+        eventBus.register(BrowseStatusEvent.class, this)
+        eventBus.register(UIResultEvent.class, this)
+        eventBus.publish(new UIBrowseEvent(host : model.host))
+    }
+    
+    void mvcGroupDestroy() {
+        eventBus.unregister(BrowseStatusEvent.class, this)
+        eventBus.unregister(UIResultEvent.class, this)
+    }
+    
+    void onBrowseStatusEvent(BrowseStatusEvent e) {
+        runInsideUIAsync {
+            model.status = e.status
+            if (e.status == BrowseStatus.FETCHING)
+                model.totalResults = e.totalResults
+        }
+    }
+    
+    void onUIResultEvent(UIResultEvent e) {
+        runInsideUIAsync {
+            model.results << e
+            model.resultCount = model.results.size()
+            view.resultsTable.model.fireTableDataChanged()
+        }
+    }
+    
+    @ControllerAction
+    void dismiss() {
+        view.dialog.setVisible(false)
+        mvcGroup.destroy()
+    }
+    
+    @ControllerAction
+    void download() {
+        def selectedResults = view.selectedResults()
+        if (selectedResults == null || selectedResults.isEmpty())
+            return
+        selectedResults.removeAll {
+            !mvcGroup.parentGroup.parentGroup.model.canDownload(it.infohash)
+        }
+        
+        selectedResults.each { result ->
+            def file = new File(application.context.get("muwire-settings").downloadLocation, result.name)
+            eventBus.publish(new UIDownloadEvent(
+                result : [result],
+                sources : [model.host.destination],
+                target : file,
+                sequential : mvcGroup.parentGroup.view.sequentialDownloadCheckbox.model.isSelected()
+                ))
+        }
+        
+        mvcGroup.parentGroup.parentGroup.view.showDownloadsWindow.call()
+        dismiss()
+    }
+    
+    @ControllerAction
+    void viewComment() {
+        def selectedResults = view.selectedResults()
+        if (selectedResults == null || selectedResults.size() != 1)
+            return
+        def result = selectedResults[0]
+        if (result.comment == null)
+            return
+        
+        String groupId = Base64.encode(result.infohash.getRoot())
+        Map<String,Object> params = new HashMap<>()
+        params['result'] = result
+        
+        mvcGroup.createMVCGroup("show-comment", groupId, params)
+    }
+}

gui/griffon-app/controllers/com/muwire/gui/ContentPanelController.groovy

@@ -0,0 +1,105 @@
+package com.muwire.gui
+
+import griffon.core.artifact.GriffonController
+import griffon.core.controller.ControllerAction
+import griffon.inject.MVCMember
+import griffon.metadata.ArtifactProviderFor
+import javax.annotation.Nonnull
+
+import com.muwire.core.Core
+import com.muwire.core.EventBus
+import com.muwire.core.content.ContentControlEvent
+import com.muwire.core.content.Match
+import com.muwire.core.content.Matcher
+import com.muwire.core.content.RegexMatcher
+import com.muwire.core.trust.TrustEvent
+import com.muwire.core.trust.TrustLevel
+
+@ArtifactProviderFor(GriffonController)
+class ContentPanelController {
+    @MVCMember @Nonnull
+    ContentPanelModel model
+    @MVCMember @Nonnull
+    ContentPanelView view
+    
+    Core core
+
+    @ControllerAction
+    void addRule() {
+        def term = view.ruleTextField.text
+        
+        if (model.regex)
+            core.muOptions.watchedRegexes.add(term)
+        else
+            core.muOptions.watchedKeywords.add(term)
+        saveMuWireSettings()
+           
+        core.eventBus.publish(new ContentControlEvent(term : term, regex : model.regex, add:true))
+    }
+    
+    @ControllerAction
+    void deleteRule() {
+        int rule = view.getSelectedRule()
+        if (rule < 0)
+            return
+        Matcher matcher = model.rules[rule]
+        String term = matcher.getTerm()
+        if (matcher instanceof RegexMatcher) 
+            core.muOptions.watchedRegexes.remove(term)
+        else
+            core.muOptions.watchedKeywords.remove(term)
+        saveMuWireSettings()
+        
+        core.eventBus.publish(new ContentControlEvent(term : term, regex : (matcher instanceof RegexMatcher), add: false))
+    }
+    
+    @ControllerAction
+    void keyword() {
+        model.regex = false
+    }
+    
+    @ControllerAction
+    void regex() {
+        model.regex = true
+    }
+    
+    @ControllerAction
+    void refresh() {
+        model.refresh()
+    }
+    
+    @ControllerAction
+    void clearHits() {
+        int selectedRule = view.getSelectedRule()
+        if (selectedRule < 0)
+            return
+        Matcher matcher = model.rules[selectedRule]
+        matcher.matches.clear()
+        model.refresh()
+    }
+    
+    @ControllerAction
+    void trust() {
+        int selectedHit = view.getSelectedHit()
+        if (selectedHit < 0)
+            return
+        Match m = model.hits[selectedHit]
+        core.eventBus.publish(new TrustEvent(persona : m.persona, level : TrustLevel.TRUSTED))
+    }
+    
+    @ControllerAction
+    void distrust() {
+        int selectedHit = view.getSelectedHit()
+        if (selectedHit < 0)
+            return
+        Match m = model.hits[selectedHit]
+        core.eventBus.publish(new TrustEvent(persona : m.persona, level : TrustLevel.DISTRUSTED))
+    }
+    
+    void saveMuWireSettings() {
+        File f = new File(core.home, "MuWire.properties")
+        f.withOutputStream {
+            core.muOptions.write(it)
+        }
+    }
+}

gui/griffon-app/controllers/com/muwire/gui/I2PStatusController.groovy

@@ -0,0 +1,41 @@
+package com.muwire.gui
+
+import griffon.core.artifact.GriffonController
+import griffon.core.controller.ControllerAction
+import griffon.inject.MVCMember
+import griffon.metadata.ArtifactProviderFor
+import net.i2p.router.Router
+
+import javax.annotation.Nonnull
+
+import com.muwire.core.Core
+
+@ArtifactProviderFor(GriffonController)
+class I2PStatusController {
+    @MVCMember @Nonnull
+    I2PStatusModel model
+    @MVCMember @Nonnull
+    I2PStatusView view
+
+    @ControllerAction
+    void refresh() {
+        Core core = application.context.get("core")
+        Router router = core.router
+        model.networkStatus = router._context.commSystem().status.toStatusString()
+        model.floodfill = router._context.netDb().floodfillEnabled()
+        model.ntcpConnections = router._context.commSystem().getTransports()["NTCP"].countPeers()
+        model.ssuConnections = router._context.commSystem().getTransports()["SSU"].countPeers()
+        model.participatingTunnels = router._context.tunnelManager().getParticipatingCount()
+        model.activePeers = router._context.profileOrganizer().countActivePeers()
+        model.receiveBps = router._context.bandwidthLimiter().getReceiveBps15s()
+        model.sendBps = router._context.bandwidthLimiter().getSendBps15s()
+        model.participatingBW = router._context.bandwidthLimiter().getCurrentParticipatingBandwidth()
+
+    }
+
+    @ControllerAction
+    void close() {
+        view.dialog.setVisible(false)
+        mvcGroup.destroy()
+    }
+}

gui/griffon-app/controllers/com/muwire/gui/MainFrameController.groovy

@@ -11,18 +11,27 @@ import net.i2p.data.Base64
 
 import javax.annotation.Nonnull
 import javax.inject.Inject
+import javax.swing.JTable
 
-import com.muwire.core.Constants
 import com.muwire.core.Core
+import com.muwire.core.Persona
+import com.muwire.core.SharedFile
+import com.muwire.core.SplitPattern
+import com.muwire.core.download.Downloader
 import com.muwire.core.download.DownloadStartedEvent
 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.files.DirectoryUnsharedEvent
+import com.muwire.core.files.FileUnsharedEvent
+import com.muwire.core.files.UIPersistFilesEvent
 import com.muwire.core.search.QueryEvent
 import com.muwire.core.search.SearchEvent
+import com.muwire.core.trust.RemoteTrustList
 import com.muwire.core.trust.TrustEvent
 import com.muwire.core.trust.TrustLevel
+import com.muwire.core.trust.TrustSubscriptionEvent
 
 @ArtifactProviderFor(GriffonController)
 class MainFrameController {
@@ -32,6 +41,8 @@ class MainFrameController {
 
     @MVCMember @Nonnull
     MainFrameModel model
+    @MVCMember @Nonnull
+    MainFrameView view
 
     private volatile Core core
 
@@ -44,10 +55,13 @@ class MainFrameController {
         search = search.trim()
         if (search.length() == 0)
             return
+        if (search.length() > 128)
+            search = search.substring(0,128)
         def uuid = UUID.randomUUID()
         Map<String, Object> params = new HashMap<>()
         params["search-terms"] = search
         params["uuid"] = uuid.toString()
+        params["core"] = core
         def group = mvcGroup.createMVCGroup("SearchTab", uuid.toString(), params)
         model.results[uuid.toString()] = group
 
@@ -64,16 +78,18 @@ class MainFrameController {
 
         def searchEvent
         if (hashSearch) {
-            searchEvent = new SearchEvent(searchHash : root, uuid : uuid, oobInfohash: true)
+            searchEvent = new SearchEvent(searchHash : root, uuid : uuid, oobInfohash: true, compressedResults : true)
         } else {
             // this can be improved a lot
-            def replaced = search.toLowerCase().trim().replaceAll(Constants.SPLIT_PATTERN, " ")
+            def replaced = search.toLowerCase().trim().replaceAll(SplitPattern.SPLIT_PATTERN, " ")
             def terms = replaced.split(" ")
             def nonEmpty = []
             terms.each { if (it.length() > 0) nonEmpty << it }
-            searchEvent = new SearchEvent(searchTerms : nonEmpty, uuid : uuid, oobInfohash: true)
+            searchEvent = new SearchEvent(searchTerms : nonEmpty, uuid : uuid, oobInfohash: true, 
+                searchComments : core.muOptions.searchComments, compressedResults : true)
         }
-        core.eventBus.publish(new QueryEvent(searchEvent : searchEvent, firstHop : true, 
+        boolean firstHop = core.muOptions.allowUntrusted || core.muOptions.searchExtraHop
+        core.eventBus.publish(new QueryEvent(searchEvent : searchEvent, firstHop : firstHop,
             replyTo: core.me.destination, receivedOn: core.me.destination,
             originator : core.me))
     }
@@ -85,6 +101,7 @@ class MainFrameController {
         Map<String, Object> params = new HashMap<>()
         params["search-terms"] = tabTitle
         params["uuid"] = uuid.toString()
+        params["core"] = core
         def group = mvcGroup.createMVCGroup("SearchTab", uuid.toString(), params)
         model.results[uuid.toString()] = group
 
@@ -95,20 +112,6 @@ class MainFrameController {
             originator : core.me))
     }
 
-    private def selectedResult() {
-        def selected = builder.getVariable("result-tabs").getSelectedComponent()
-        def group = selected.getClientProperty("mvc-group")
-        def table = selected.getClientProperty("results-table")
-        int row = table.getSelectedRow()
-        if (row == -1)
-            return
-        def sortEvt = group.view.lastSortEvent
-        if (sortEvt != null) {
-            row = group.view.resultsTable.rowSorter.convertRowIndexToModel(row)
-        } 
-        group.model.results[row]        
-    }
-    
     private int selectedDownload() {
         def downloadsTable = builder.getVariable("downloads-table")
         def selected = downloadsTable.getSelectedRow()
@@ -119,39 +122,21 @@ class MainFrameController {
     }
 
     @ControllerAction
-    void download() {
-        def result = selectedResult()
-        if (result == null)
+    void trustPersonaFromSearch() {
+        int selected = builder.getVariable("searches-table").getSelectedRow()
+        if (selected < 0)
             return
-        
-        if (!model.canDownload(result.infohash))
-            return   
-             
-        def file = new File(application.context.get("muwire-settings").downloadLocation, result.name)
-        
-        def selected = builder.getVariable("result-tabs").getSelectedComponent()
-        def group = selected.getClientProperty("mvc-group")
-        
-        def resultsBucket = group.model.hashBucket[result.infohash]
-        def sources = group.model.sourcesBucket[result.infohash]
-         
-        core.eventBus.publish(new UIDownloadEvent(result : resultsBucket, sources: sources, target : file))
+        Persona p = model.searches[selected].originator
+        core.eventBus.publish( new TrustEvent(persona : p, level : TrustLevel.TRUSTED) )
     }
 
     @ControllerAction
-    void trust() {
-        def result = selectedResult()
-        if (result == null)
-            return // TODO disable button
-        core.eventBus.publish( new TrustEvent(persona : result.sender, level : TrustLevel.TRUSTED))
-    }
-    
-    @ControllerAction
-    void distrust() {
-        def result = selectedResult()
-        if (result == null)
-            return // TODO disable button
-        core.eventBus.publish( new TrustEvent(persona : result.sender, level : TrustLevel.DISTRUSTED))
+    void distrustPersonaFromSearch() {
+        int selected = builder.getVariable("searches-table").getSelectedRow()
+        if (selected < 0)
+            return
+        Persona p = model.searches[selected].originator
+        core.eventBus.publish( new TrustEvent(persona : p, level : TrustLevel.DISTRUSTED) )
     }
 
     @ControllerAction
@@ -176,35 +161,136 @@ class MainFrameController {
         core.eventBus.publish(new UIDownloadPausedEvent())
     }
 
+    @ControllerAction
+    void clear() {
+        def toRemove = []
+        model.downloads.each {
+             if (it.downloader.getCurrentState() == Downloader.DownloadState.CANCELLED) {
+                 toRemove << it
+             } else if (it.downloader.getCurrentState() == Downloader.DownloadState.FINISHED) {
+                 toRemove << it
+             }
+         }
+         toRemove.each {
+             model.downloads.remove(it)
+         }
+         model.clearButtonEnabled = false
+
+    }
+
     private void markTrust(String tableName, TrustLevel level, def list) {
-        int row = builder.getVariable(tableName).getSelectedRow()
+        int row = view.getSelectedTrustTablesRow(tableName)
         if (row < 0)
             return
+        builder.getVariable(tableName).model.fireTableDataChanged()
         core.eventBus.publish(new TrustEvent(persona : list[row], level : level))
     }
 
     @ControllerAction
     void markTrusted() {
         markTrust("distrusted-table", TrustLevel.TRUSTED, model.distrusted)
+        model.markTrustedButtonEnabled = false
+        model.markNeutralFromDistrustedButtonEnabled = false
     }
 
     @ControllerAction
     void markNeutralFromDistrusted() {
         markTrust("distrusted-table", TrustLevel.NEUTRAL, model.distrusted)
+        model.markTrustedButtonEnabled = false
+        model.markNeutralFromDistrustedButtonEnabled = false
     }
 
     @ControllerAction
     void markDistrusted() {
         markTrust("trusted-table", TrustLevel.DISTRUSTED, model.trusted)
+        model.subscribeButtonEnabled = false
+        model.markDistrustedButtonEnabled = false
+        model.markNeutralFromTrustedButtonEnabled = false
     }
 
     @ControllerAction
     void markNeutralFromTrusted() {
         markTrust("trusted-table", TrustLevel.NEUTRAL, model.trusted)
+        model.subscribeButtonEnabled = false
+        model.markDistrustedButtonEnabled = false
+        model.markNeutralFromTrustedButtonEnabled = false
     }
 
-    void unshareSelectedFiles() {
-        println "unsharing selected files"
+    @ControllerAction
+    void subscribe() {
+        int row = view.getSelectedTrustTablesRow("trusted-table")
+        if (row < 0)
+            return
+        Persona p = model.trusted[row]
+        core.muOptions.trustSubscriptions.add(p)
+        saveMuWireSettings()
+        core.eventBus.publish(new TrustSubscriptionEvent(persona : p, subscribe : true))
+        model.subscribeButtonEnabled = false
+        model.markDistrustedButtonEnabled = false
+        model.markNeutralFromTrustedButtonEnabled = false
+    }
+
+    @ControllerAction
+    void review() {
+        RemoteTrustList list = getSelectedTrustList()
+        if (list == null)
+            return
+        Map<String,Object> env = new HashMap<>()
+        env["trustList"] = list
+        env["trustService"] = core.trustService
+        env["eventBus"] = core.eventBus
+        mvcGroup.createMVCGroup("trust-list", env)
+
+    }
+
+    @ControllerAction
+    void update() {
+        RemoteTrustList list = getSelectedTrustList()
+        if (list == null)
+            return
+        core.eventBus.publish(new TrustSubscriptionEvent(persona : list.persona, subscribe : true))
+    }
+
+    @ControllerAction
+    void unsubscribe() {
+        RemoteTrustList list = getSelectedTrustList()
+        if (list == null)
+            return
+        core.muOptions.trustSubscriptions.remove(list.persona)
+        saveMuWireSettings()
+        model.subscriptions.remove(list)
+        JTable table = builder.getVariable("subscription-table")
+        table.model.fireTableDataChanged()
+        core.eventBus.publish(new TrustSubscriptionEvent(persona : list.persona, subscribe : false))
+    }
+
+    private RemoteTrustList getSelectedTrustList() {
+        int row = view.getSelectedTrustTablesRow("subscription-table")
+        if (row < 0)
+            return null
+        model.subscriptions[row]
+    }
+
+    void unshareSelectedFile() {
+        def sf = view.selectedSharedFiles()
+        if (sf == null)
+            return
+        sf.each {  
+            core.eventBus.publish(new FileUnsharedEvent(unsharedFile : it))
+        }
+        core.eventBus.publish(new UIPersistFilesEvent())
+    }
+    
+    @ControllerAction
+    void addComment() {
+        def selectedFiles = view.selectedSharedFiles()
+        if (selectedFiles == null || selectedFiles.isEmpty())
+            return
+        
+        Map<String, Object> params = new HashMap<>()
+        params['selectedFiles'] = selectedFiles
+        params['core'] = core
+        mvcGroup.createMVCGroup("add-comment", "Add Comment", params)
     }
 
     void saveMuWireSettings() {

gui/griffon-app/controllers/com/muwire/gui/MuWireStatusController.groovy

@@ -0,0 +1,48 @@
+package com.muwire.gui
+
+import griffon.core.artifact.GriffonController
+import griffon.core.controller.ControllerAction
+import griffon.inject.MVCMember
+import griffon.metadata.ArtifactProviderFor
+import javax.annotation.Nonnull
+
+import com.muwire.core.Core
+
+@ArtifactProviderFor(GriffonController)
+class MuWireStatusController {
+    @MVCMember @Nonnull
+    MuWireStatusModel model
+    @MVCMember @Nonnull
+    MuWireStatusView view
+
+    @ControllerAction
+    void refresh() {
+        Core core = application.context.get("core")
+
+        int incoming = 0
+        int outgoing = 0
+        core.connectionManager.getConnections().each {
+            if (it.incoming)
+                incoming++
+            else
+                outgoing++
+        }
+        model.incomingConnections = incoming
+        model.outgoingConnections = outgoing
+
+        model.knownHosts = core.hostCache.hosts.size()
+        model.failingHosts = core.hostCache.countFailingHosts()
+        model.hopelessHosts = core.hostCache.countHopelessHosts()
+        
+
+        model.sharedFiles = core.fileManager.fileToSharedFile.size()
+
+        model.downloads = core.downloadManager.downloaders.size()
+    }
+
+    @ControllerAction
+    void close() {
+        view.dialog.setVisible(false)
+        mvcGroup.destroy()
+    }
+}

gui/griffon-app/controllers/com/muwire/gui/OptionsController.groovy

@@ -4,9 +4,15 @@ import griffon.core.artifact.GriffonController
 import griffon.core.controller.ControllerAction
 import griffon.inject.MVCMember
 import griffon.metadata.ArtifactProviderFor
+import groovy.util.logging.Log
+
+import java.util.logging.Level
+
 import javax.annotation.Nonnull
+import javax.swing.JFileChooser
 
 import com.muwire.core.Core
+import com.muwire.core.MuWireSettings
 
 @ArtifactProviderFor(GriffonController)
 class OptionsController {
@@ -19,6 +25,7 @@ class OptionsController {
     void save() {
         String text
         Core core = application.context.get("core")
+        MuWireSettings settings = application.context.get("muwire-settings")
 
         def i2pProps = core.i2pOptions
 
@@ -38,6 +45,17 @@ class OptionsController {
         model.outboundLength = text
         i2pProps["outbound.length"] = text
 
+        if (settings.embeddedRouter) {
+            text = view.i2pNTCPPortField.text
+            model.i2pNTCPPort = text
+            i2pProps["i2np.ntcp.port"] = text
+
+            text = view.i2pUDPPortField.text
+            model.i2pUDPPort = text
+            i2pProps["i2np.udp.port"] = text
+        }
+
+
         File i2pSettingsFile = new File(core.home, "i2p.properties")
         i2pSettingsFile.withOutputStream {
             i2pProps.store(it,"")
@@ -46,21 +64,69 @@ class OptionsController {
         text = view.retryField.text
         model.downloadRetryInterval = text
 
-        def settings = application.context.get("muwire-settings")
         settings.downloadRetryInterval = Integer.valueOf(text)
 
         text = view.updateField.text
         model.updateCheckInterval = text
         settings.updateCheckInterval = Integer.valueOf(text)
 
-        boolean onlyTrusted = view.allowUntrustedCheckbox.model.isSelected()
-        model.onlyTrusted = onlyTrusted
-        settings.setAllowUntrusted(!onlyTrusted)
+        boolean searchComments = view.searchCommentsCheckbox.model.isSelected()
+        model.searchComments = searchComments
+        settings.searchComments = searchComments
+        
+        boolean autoDownloadUpdate = view.autoDownloadUpdateCheckbox.model.isSelected()
+        model.autoDownloadUpdate = autoDownloadUpdate
+        settings.autoDownloadUpdate = autoDownloadUpdate
+
 
         boolean shareDownloaded = view.shareDownloadedCheckbox.model.isSelected()
         model.shareDownloadedFiles = shareDownloaded
         settings.shareDownloadedFiles = shareDownloaded
         
+        boolean shareHidden = view.shareHiddenCheckbox.model.isSelected()
+        model.shareHiddenFiles = shareHidden
+        settings.shareHiddenFiles = shareHidden
+
+        boolean browseFiles = view.browseFilesCheckbox.model.isSelected()
+        model.browseFiles = browseFiles
+        settings.browseFiles = browseFiles
+        
+        text = view.speedSmoothSecondsField.text
+        model.speedSmoothSeconds = Integer.valueOf(text)
+        settings.speedSmoothSeconds = Integer.valueOf(text)
+        
+        String downloadLocation = model.downloadLocation
+        settings.downloadLocation = new File(downloadLocation)
+        
+        String incompleteLocation = model.incompleteLocation
+        settings.incompleteLocation = new File(incompleteLocation)
+
+        if (settings.embeddedRouter) {
+            text = view.inBwField.text
+            model.inBw = text
+            settings.inBw = Integer.valueOf(text)
+            text = view.outBwField.text
+            model.outBw = text
+            settings.outBw = Integer.valueOf(text)
+        }
+
+
+        boolean onlyTrusted = view.allowUntrustedCheckbox.model.isSelected()
+        model.onlyTrusted = onlyTrusted
+        settings.setAllowUntrusted(!onlyTrusted)
+
+        boolean searchExtraHop = view.searchExtraHopCheckbox.model.isSelected()
+        model.searchExtraHop = searchExtraHop
+        settings.searchExtraHop = searchExtraHop
+        
+        boolean trustLists = view.allowTrustListsCheckbox.model.isSelected()
+        model.trustLists = trustLists
+        settings.allowTrustLists = trustLists
+
+        String trustListInterval = view.trustListIntervalField.text
+        model.trustListInterval = trustListInterval
+        settings.trustListInterval = Integer.parseInt(trustListInterval)
+
         File settingsFile = new File(core.home, "MuWire.properties")
         settingsFile.withOutputStream {
             settings.write(it)
@@ -77,9 +143,8 @@ class OptionsController {
         model.font = text
         uiSettings.font = text
         
-//        boolean showMonitor = view.monitorCheckbox.model.isSelected()
-//        model.showMonitor = showMonitor
-//        uiSettings.showMonitor = showMonitor
+        uiSettings.autoFontSize = model.automaticFontSize
+        uiSettings.fontSize = Integer.parseInt(view.fontSizeField.text)
 
         boolean clearCancelledDownloads = view.clearCancelledDownloadsCheckbox.model.isSelected()
         model.clearCancelledDownloads = clearCancelledDownloads
@@ -93,10 +158,6 @@ class OptionsController {
         model.excludeLocalResult = excludeLocalResult
         uiSettings.excludeLocalResult = excludeLocalResult
 
-//        boolean showSearchHashes = view.showSearchHashesCheckbox.model.isSelected()
-//        model.showSearchHashes = showSearchHashes
-//        uiSettings.showSearchHashes = showSearchHashes
-        
         File uiSettingsFile = new File(core.home, "gui.properties")
         uiSettingsFile.withOutputStream {
             uiSettings.write(it)
@@ -110,4 +171,37 @@ class OptionsController {
         view.d.setVisible(false)
         mvcGroup.destroy()
     }
+
+    @ControllerAction
+    void downloadLocation() {
+        def chooser = new JFileChooser()
+        chooser.setFileHidingEnabled(false)
+        chooser.setDialogTitle("Select location for downloaded files")
+        chooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY)
+        int rv = chooser.showOpenDialog(null)
+        if (rv == JFileChooser.APPROVE_OPTION)
+            model.downloadLocation = chooser.getSelectedFile().getAbsolutePath()
+    }
+    
+    @ControllerAction
+    void incompleteLocation() {
+        def chooser = new JFileChooser()
+        chooser.setFileHidingEnabled(false)
+        chooser.setDialogTitle("Select location for downloaded files")
+        chooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY)
+        int rv = chooser.showOpenDialog(null)
+        if (rv == JFileChooser.APPROVE_OPTION)
+            model.incompleteLocation = chooser.getSelectedFile().getAbsolutePath()
+    }
+    
+    @ControllerAction
+    void automaticFontAction() {
+        model.automaticFontSize = true
+        model.customFontSize = 12
+    }
+    
+    @ControllerAction
+    void customFontAction() {
+        model.automaticFontSize = false
+    }
 }

gui/griffon-app/controllers/com/muwire/gui/SearchTabController.groovy

@@ -4,8 +4,121 @@ import griffon.core.artifact.GriffonController
 import griffon.core.controller.ControllerAction
 import griffon.inject.MVCMember
 import griffon.metadata.ArtifactProviderFor
+import net.i2p.data.Base64
+
 import javax.annotation.Nonnull
 
+import com.muwire.core.Core
+import com.muwire.core.Persona
+import com.muwire.core.download.UIDownloadEvent
+import com.muwire.core.search.UIResultEvent
+import com.muwire.core.trust.TrustEvent
+import com.muwire.core.trust.TrustLevel
+
 @ArtifactProviderFor(GriffonController)
 class SearchTabController {
+
+    @MVCMember @Nonnull
+    SearchTabModel model
+    @MVCMember @Nonnull
+    SearchTabView view
+
+    Core core
+
+    private def selectedResults() {
+        int[] rows = view.resultsTable.getSelectedRows()
+        if (rows.length == 0)
+            return null
+        def sortEvt = view.lastSortEvent
+        if (sortEvt != null) {
+            for (int i = 0; i < rows.length; i++) {
+                rows[i] = view.resultsTable.rowSorter.convertRowIndexToModel(rows[i])
+            }
+        }
+        List<UIResultEvent> results = new ArrayList<>()
+        rows.each { results.add(model.results[it]) }
+            results
+        }
+
+        @ControllerAction
+        void download() {
+            def results = selectedResults()
+            if (results == null)
+                return
+
+            results.removeAll {
+                !mvcGroup.parentGroup.model.canDownload(it.infohash)
+            }
+
+            results.each { result ->
+                def file = new File(application.context.get("muwire-settings").downloadLocation, result.name)
+
+                def resultsBucket = model.hashBucket[result.infohash]
+                def sources = model.sourcesBucket[result.infohash]
+
+                core.eventBus.publish(new UIDownloadEvent(result : resultsBucket, sources: sources,
+                target : file, sequential : view.sequentialDownloadCheckbox.model.isSelected()))
+            }
+            mvcGroup.parentGroup.view.showDownloadsWindow.call()
+        }
+
+        @ControllerAction
+        void trust() {
+            int row = view.selectedSenderRow()
+            if (row < 0)
+                return
+            def sender = model.senders[row]
+            core.eventBus.publish( new TrustEvent(persona : sender, level : TrustLevel.TRUSTED))
+        }
+
+        @ControllerAction
+        void distrust() {
+            int row = view.selectedSenderRow()
+            if (row < 0)
+                return
+            def sender = model.senders[row]
+            core.eventBus.publish( new TrustEvent(persona : sender, level : TrustLevel.DISTRUSTED))
+        }
+
+        @ControllerAction
+        void neutral() {
+            int row = view.selectedSenderRow()
+            if (row < 0)
+                return
+            def sender = model.senders[row]
+            core.eventBus.publish( new TrustEvent(persona : sender, level : TrustLevel.NEUTRAL))
+        }
+        
+        @ControllerAction
+        void browse() {
+            int selectedSender = view.selectedSenderRow()
+            if (selectedSender < 0)
+                return
+            Persona sender = model.senders[selectedSender]
+            
+            String groupId = sender.getHumanReadableName()
+            Map<String,Object> params = new HashMap<>()
+            params['host'] = sender
+            params['eventBus'] = core.eventBus
+            
+            mvcGroup.createMVCGroup("browse", groupId, params)
+        }
+        
+        @ControllerAction
+        void showComment() {
+            int[] selectedRows = view.resultsTable.getSelectedRows()
+            if (selectedRows.length != 1)
+                return
+            if (view.lastSortEvent != null)
+                selectedRows[0] = view.resultsTable.rowSorter.convertRowIndexToModel(selectedRows[0])
+            UIResultEvent event = model.results[selectedRows[0]]
+            if (event.comment == null)
+                return
+                
+            String groupId = Base64.encode(event.infohash.getRoot())
+            Map<String,Object> params = new HashMap<>()
+            params['result'] = event
+            
+            mvcGroup.createMVCGroup("show-comment", groupId, params)
+        }
     }

gui/griffon-app/controllers/com/muwire/gui/ShowCommentController.groovy

@@ -0,0 +1,19 @@
+package com.muwire.gui
+
+import griffon.core.artifact.GriffonController
+import griffon.core.controller.ControllerAction
+import griffon.inject.MVCMember
+import griffon.metadata.ArtifactProviderFor
+import javax.annotation.Nonnull
+
+@ArtifactProviderFor(GriffonController)
+class ShowCommentController {
+    @MVCMember @Nonnull
+    ShowCommentView view
+
+    @ControllerAction
+    void dismiss() {
+        view.dialog.setVisible(false)
+        mvcGroup.destroy()
+    }
+}

gui/griffon-app/controllers/com/muwire/gui/TrustListController.groovy

@@ -0,0 +1,62 @@
+package com.muwire.gui
+
+import griffon.core.artifact.GriffonController
+import griffon.core.controller.ControllerAction
+import griffon.inject.MVCMember
+import griffon.metadata.ArtifactProviderFor
+import javax.annotation.Nonnull
+
+import com.muwire.core.EventBus
+import com.muwire.core.Persona
+import com.muwire.core.trust.TrustEvent
+import com.muwire.core.trust.TrustLevel
+
+@ArtifactProviderFor(GriffonController)
+class TrustListController {
+    @MVCMember @Nonnull
+    TrustListModel model
+    @MVCMember @Nonnull
+    TrustListView view
+
+    EventBus eventBus
+
+    @ControllerAction
+    void trustFromTrusted() {
+        int selectedRow = view.getSelectedRow("trusted-table")
+        if (selectedRow < 0)
+            return
+        Persona p = model.trusted[selectedRow]
+        eventBus.publish(new TrustEvent(persona : p, level : TrustLevel.TRUSTED))
+        view.fireUpdate("trusted-table")
+    }
+
+    @ControllerAction
+    void trustFromDistrusted() {
+        int selectedRow = view.getSelectedRow("distrusted-table")
+        if (selectedRow < 0)
+            return
+        Persona p = model.distrusted[selectedRow]
+        eventBus.publish(new TrustEvent(persona : p, level : TrustLevel.TRUSTED))
+        view.fireUpdate("distrusted-table")
+    }
+
+    @ControllerAction
+    void distrustFromTrusted() {
+        int selectedRow = view.getSelectedRow("trusted-table")
+        if (selectedRow < 0)
+            return
+        Persona p = model.trusted[selectedRow]
+        eventBus.publish(new TrustEvent(persona : p, level : TrustLevel.DISTRUSTED))
+        view.fireUpdate("trusted-table")
+    }
+
+    @ControllerAction
+    void distrustFromDistrusted() {
+        int selectedRow = view.getSelectedRow("distrusted-table")
+        if (selectedRow < 0)
+            return
+        Persona p = model.distrusted[selectedRow]
+        eventBus.publish(new TrustEvent(persona : p, level : TrustLevel.DISTRUSTED))
+        view.fireUpdate("distrusted-table")
+    }
+}

gui/griffon-app/lifecycle/Initialize.groovy

@@ -10,15 +10,19 @@ import com.muwire.gui.UISettings
 
 import javax.annotation.Nonnull
 import javax.inject.Inject
+import javax.swing.JLabel
 import javax.swing.JTable
 import javax.swing.LookAndFeel
 import javax.swing.UIManager
+import javax.swing.plaf.FontUIResource
 
 import static griffon.util.GriffonApplicationUtils.isMacOSX
 import static groovy.swing.SwingBuilder.lookAndFeel
 
 import java.awt.Font
+import java.awt.Toolkit
 import java.util.logging.Level
+import java.util.logging.LogManager
 
 @Log
 class Initialize extends AbstractLifecycleHandler {
@@ -29,6 +33,16 @@ class Initialize extends AbstractLifecycleHandler {
 
     @Override
     void execute() {
+        
+        if (System.getProperty("java.util.logging.config.file") == null) {
+            log.info("No config file specified, so turning off most logging")
+            def names = LogManager.getLogManager().getLoggerNames()
+            while(names.hasMoreElements()) {
+                def name = names.nextElement()
+                LogManager.getLogManager().getLogger(name).setLevel(Level.SEVERE)
+            }
+        }
+        
         log.info "Loading home dir"
         def portableHome = System.getProperty("portable.home")
         def home = portableHome == null ?
@@ -43,6 +57,8 @@ class Initialize extends AbstractLifecycleHandler {
 
         application.context.put("muwire-home", home.getAbsolutePath())
 
+        System.getProperties().setProperty("awt.useSystemAAFontSettings", "gasp")
+
         def guiPropsFile = new File(home, "gui.properties")
         UISettings uiSettings
         if (guiPropsFile.exists()) {
@@ -50,25 +66,43 @@ class Initialize extends AbstractLifecycleHandler {
             guiPropsFile.withInputStream { props.load(it) }
             uiSettings = new UISettings(props)
 
+            def lnf
             log.info("settting user-specified lnf $uiSettings.lnf")
             try {
-                lookAndFeel(uiSettings.lnf)
+                lnf = lookAndFeel(uiSettings.lnf)
             } catch (Throwable bad) {
-                log.log(Level.WARNING,"couldn't set desired look and feeel, switching to defaults", bad)
-                uiSettings.lnf = lookAndFeel("system","gtk","metal").getID()
+                log.log(Level.WARNING,"couldn't set desired look and feel, switching to defaults", bad)
+                lnf = lookAndFeel("system","gtk","metal")
+                uiSettings.lnf = lnf.getID()
             }
 
-            if (uiSettings.font != null) {
-                log.info("setting user-specified font $uiSettings.font")
-                Font font = new Font(uiSettings.font, Font.PLAIN, 12)
-                def defaults = UIManager.getDefaults()
-                defaults.put("Button.font", font)
-                defaults.put("RadioButton.font", font)
-                defaults.put("Label.font", font)
-                defaults.put("CheckBox.font", font)
-                defaults.put("Table.font", font)
-                defaults.put("TableHeader.font", font)
-                // TODO: add others
+            if (uiSettings.font != null || uiSettings.autoFontSize || uiSettings.fontSize > 0) {
+
+                FontUIResource defaultFont = lnf.getDefaults().getFont("Label.font")
+                
+                String fontName
+                if (uiSettings.font != null)
+                    fontName = uiSettings.font
+                else
+                    fontName = defaultFont.getName()
+                
+                int fontSize = defaultFont.getSize()
+                if (uiSettings.autoFontSize) {
+                    int resolution = Toolkit.getDefaultToolkit().getScreenResolution()
+                    fontSize = resolution / 9;
+                } else {
+                    fontSize = uiSettings.fontSize
+                }
+                
+                FontUIResource font = new FontUIResource(fontName, Font.PLAIN, fontSize)
+                
+                def keys = lnf.getDefaults().keys()
+                while(keys.hasMoreElements()) {
+                    def key = keys.nextElement()
+                    def value = lnf.getDefaults().get(key)
+                    if (value instanceof FontUIResource)
+                        lnf.getDefaults().put(key, font)
+                }
             }
         } else {
             Properties props = new Properties()
@@ -84,6 +118,8 @@ class Initialize extends AbstractLifecycleHandler {
                 }
             } else {
                 LookAndFeel chosen = lookAndFeel('system', 'gtk')
+                if (chosen == null)
+                    chosen = lookAndFeel('metal')
                 uiSettings.lnf = chosen.getID()
                 log.info("ended up applying $chosen.name")
             }

gui/griffon-app/lifecycle/Ready.groovy

@@ -45,9 +45,14 @@ class Ready extends AbstractLifecycleHandler {
                 props.load(it)
             }
             props = new MuWireSettings(props)
+            if (props.incompleteLocation == null)
+                props.incompleteLocation = new File(home, "incompletes")
         } else {
             log.info("creating new properties")
             props = new MuWireSettings()
+            props.incompleteLocation = new File(home, "incompletes")
+            props.embeddedRouter = Boolean.parseBoolean(System.getProperties().getProperty("embeddedRouter"))
+            props.updateType = System.getProperty("updateType","jar")
             def nickname
             while (true) {
                 nickname = JOptionPane.showInputDialog(null,
@@ -74,6 +79,7 @@ class Ready extends AbstractLifecycleHandler {
                 props.downloadLocation = new File(portableDownloads)
             } else {
                 def chooser = new JFileChooser()
+                chooser.setFileHidingEnabled(false)
                 chooser.setDialogTitle("Select a directory where downloads will be saved")
                 chooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY)
                 int rv = chooser.showOpenDialog(null)

gui/griffon-app/models/com/muwire/gui/AddCommentModel.groovy

@@ -0,0 +1,12 @@
+package com.muwire.gui
+
+import com.muwire.core.SharedFile
+
+import griffon.core.artifact.GriffonModel
+import griffon.transform.Observable
+import griffon.metadata.ArtifactProviderFor
+
+@ArtifactProviderFor(GriffonModel)
+class AddCommentModel {
+    List<SharedFile> selectedFiles
+}

gui/griffon-app/models/com/muwire/gui/BrowseModel.groovy

@@ -0,0 +1,21 @@
+package com.muwire.gui
+
+import com.muwire.core.Persona
+
+import griffon.core.artifact.GriffonModel
+import griffon.transform.Observable
+import griffon.metadata.ArtifactProviderFor
+
+import com.muwire.core.search.BrowseStatus
+
+@ArtifactProviderFor(GriffonModel)
+class BrowseModel {
+    Persona host
+    @Observable BrowseStatus status
+    @Observable boolean downloadActionEnabled
+    @Observable boolean viewCommentActionEnabled
+    @Observable int totalResults
+    @Observable int resultCount
+    
+    def results = []
+}

gui/griffon-app/models/com/muwire/gui/ContentPanelModel.groovy

@@ -0,0 +1,59 @@
+package com.muwire.gui
+
+import javax.annotation.Nonnull
+
+import com.muwire.core.Core
+import com.muwire.core.EventBus
+import com.muwire.core.content.ContentControlEvent
+import com.muwire.core.content.ContentManager
+
+import griffon.core.artifact.GriffonModel
+import griffon.inject.MVCMember
+import griffon.transform.Observable
+import griffon.metadata.ArtifactProviderFor
+
+@ArtifactProviderFor(GriffonModel)
+class ContentPanelModel {
+    
+    @MVCMember @Nonnull
+    ContentPanelView view
+    
+    Core core
+    
+    private ContentManager contentManager
+    
+    def rules = []
+    def hits = []
+    
+    @Observable boolean regex
+    @Observable boolean deleteButtonEnabled
+    @Observable boolean trustButtonsEnabled
+    
+    void mvcGroupInit(Map<String,String> args) {
+        contentManager = application.context.get("core").contentManager
+        rules.addAll(contentManager.matchers)
+        core.eventBus.register(ContentControlEvent.class, this)
+    }
+    
+    void mvcGroupDestroy() {
+        core.eventBus.unregister(ContentControlEvent.class, this)
+    }
+    
+    void refresh() {
+        int selectedRule = view.getSelectedRule()
+        rules.clear()
+        rules.addAll(contentManager.matchers)
+        hits.clear()
+        view.rulesTable.model.fireTableDataChanged()
+        view.hitsTable.model.fireTableDataChanged()
+        if (selectedRule >= 0) {
+            view.rulesTable.selectionModel.setSelectionInterval(selectedRule,selectedRule)
+        }
+    }
+    
+    void onContentControlEvent(ContentControlEvent e) {
+        runInsideUIAsync {
+            refresh()
+        }
+    }
+}

gui/griffon-app/models/com/muwire/gui/I2PStatusModel.groovy

@@ -0,0 +1,28 @@
+package com.muwire.gui
+
+import javax.annotation.Nonnull
+
+import griffon.core.artifact.GriffonModel
+import griffon.inject.MVCMember
+import griffon.transform.Observable
+import griffon.metadata.ArtifactProviderFor
+
+@ArtifactProviderFor(GriffonModel)
+class I2PStatusModel {
+    @MVCMember @Nonnull
+    I2PStatusController controller
+
+    @Observable int ntcpConnections
+    @Observable int ssuConnections
+    @Observable String networkStatus
+    @Observable boolean floodfill
+    @Observable int participatingTunnels
+    @Observable int activePeers
+    @Observable int receiveBps
+    @Observable int sendBps
+    @Observable int participatingBW
+
+    void mvcGroupInit(Map<String,String> args) {
+        controller.refresh()
+    }
+}

gui/griffon-app/models/com/muwire/gui/MainFrameModel.groovy

@@ -1,24 +1,36 @@
 package com.muwire.gui
 
 import java.util.concurrent.ConcurrentHashMap
+import java.nio.file.Path
+import java.nio.file.Paths
+import java.util.Calendar
+import java.util.UUID
 
 import javax.annotation.Nonnull
 import javax.inject.Inject
 import javax.swing.JOptionPane
 import javax.swing.JTable
+import javax.swing.tree.DefaultMutableTreeNode
+import javax.swing.tree.DefaultTreeModel
+import javax.swing.tree.TreeNode
 
 import com.muwire.core.Core
 import com.muwire.core.InfoHash
 import com.muwire.core.MuWireSettings
 import com.muwire.core.Persona
 import com.muwire.core.RouterDisconnectedEvent
+import com.muwire.core.SharedFile
 import com.muwire.core.connection.ConnectionAttemptStatus
 import com.muwire.core.connection.ConnectionEvent
 import com.muwire.core.connection.DisconnectionEvent
+import com.muwire.core.content.ContentControlEvent
 import com.muwire.core.download.DownloadStartedEvent
 import com.muwire.core.download.Downloader
+import com.muwire.core.files.AllFilesLoadedEvent
+import com.muwire.core.files.DirectoryUnsharedEvent
 import com.muwire.core.files.FileDownloadedEvent
 import com.muwire.core.files.FileHashedEvent
+import com.muwire.core.files.FileHashingEvent
 import com.muwire.core.files.FileLoadedEvent
 import com.muwire.core.files.FileSharedEvent
 import com.muwire.core.files.FileUnsharedEvent
@@ -27,7 +39,10 @@ import com.muwire.core.search.UIResultBatchEvent
 import com.muwire.core.search.UIResultEvent
 import com.muwire.core.trust.TrustEvent
 import com.muwire.core.trust.TrustService
+import com.muwire.core.trust.TrustSubscriptionEvent
+import com.muwire.core.trust.TrustSubscriptionUpdatedEvent
 import com.muwire.core.update.UpdateAvailableEvent
+import com.muwire.core.update.UpdateDownloadedEvent
 import com.muwire.core.upload.UploadEvent
 import com.muwire.core.upload.UploadFinishedEvent
 
@@ -49,33 +64,56 @@ class MainFrameModel {
     FactoryBuilderSupport builder
     @MVCMember @Nonnull
     MainFrameController controller
+    @MVCMember @Nonnull
+    MainFrameView view
     @Inject @Nonnull GriffonApplication application
     @Observable boolean coreInitialized = false
+    @Observable boolean routerPresent
 
     def results = new ConcurrentHashMap<>()
     def downloads = []
     def uploads = []
-    def shared = []
-    def watched = []
+    boolean treeVisible = true
+    def shared 
+    def sharedTree 
+    def treeRoot
+    final Map<SharedFile, TreeNode> fileToNode = new HashMap<>()
     def connectionList = []
     def searches = new LinkedList()
     def trusted = []
     def distrusted = []
+    def subscriptions = []
 
     @Observable int connections
     @Observable String me
-    @Observable boolean downloadActionEnabled
-    @Observable boolean trustButtonsEnabled
+    @Observable int loadedFiles
+    @Observable File hashingFile
     @Observable boolean cancelButtonEnabled
     @Observable boolean retryButtonEnabled
     @Observable boolean pauseButtonEnabled
+    @Observable boolean clearButtonEnabled
     @Observable String resumeButtonText
+    @Observable boolean addCommentButtonEnabled
+    @Observable boolean subscribeButtonEnabled
+    @Observable boolean markNeutralFromTrustedButtonEnabled
+    @Observable boolean markDistrustedButtonEnabled
+    @Observable boolean markNeutralFromDistrustedButtonEnabled
+    @Observable boolean markTrustedButtonEnabled
+    @Observable boolean reviewButtonEnabled
+    @Observable boolean updateButtonEnabled
+    @Observable boolean unsubscribeButtonEnabled
     
-    private final Set<InfoHash> infoHashes = new HashSet<>()
+    @Observable boolean searchesPaneButtonEnabled
+    @Observable boolean downloadsPaneButtonEnabled
+    @Observable boolean uploadsPaneButtonEnabled
+    @Observable boolean monitorPaneButtonEnabled
+    @Observable boolean trustPaneButtonEnabled
+    
+    @Observable Downloader downloader
 
     private final Set<InfoHash> downloadInfoHashes = new HashSet<>()
 
-    volatile Core core    
+    @Observable volatile Core core
 
     private long lastRetryTime = System.currentTimeMillis()
 
@@ -84,7 +122,12 @@ class MainFrameModel {
     void updateTablePreservingSelection(String tableName) {
         def downloadTable = builder.getVariable(tableName)
         int selectedRow = downloadTable.getSelectedRow()
+        while(true) {
+            try {
                 downloadTable.model.fireTableDataChanged()
+                break
+            } catch (IllegalArgumentException iae) {} // caused by underlying model changing while table is sorted
+        }
         downloadTable.selectionModel.setSelectionInterval(selectedRow,selectedRow)
     }
 
@@ -92,6 +135,10 @@ class MainFrameModel {
 
         uiSettings = application.context.get("ui-settings")
         
+        shared = []
+        treeRoot = new DefaultMutableTreeNode()
+        sharedTree = new DefaultTreeModel(treeRoot)
+
         Timer timer = new Timer("download-pumper", true)
         timer.schedule({
             runInsideUIAsync {
@@ -99,18 +146,27 @@ class MainFrameModel {
                     return
 
                 // remove cancelled or finished downloads
+                if (!clearButtonEnabled || uiSettings.clearCancelledDownloads || uiSettings.clearFinishedDownloads) {
                     def toRemove = []
                     downloads.each {
-                    if (uiSettings.clearCancelledDownloads &&
-                        it.downloader.getCurrentState() == Downloader.DownloadState.CANCELLED)
+                        if (it.downloader.getCurrentState() == Downloader.DownloadState.CANCELLED) {
+                            if (uiSettings.clearCancelledDownloads) {
                                 toRemove << it
-                    if (uiSettings.clearFinishedDownloads &&
-                        it.downloader.getCurrentState() == Downloader.DownloadState.FINISHED)
+                            } else {
+                                clearButtonEnabled = true
+                            }
+                        } else if (it.downloader.getCurrentState() == Downloader.DownloadState.FINISHED) {
+                            if (uiSettings.clearFinishedDownloads) {
                                 toRemove << it
+                            } else {
+                                clearButtonEnabled = true
+                            }
+                        }
                     }
                     toRemove.each {
                         downloads.remove(it)
                     }
+                }
 
                 builder.getVariable("uploads-table")?.model.fireTableDataChanged()
 
@@ -123,13 +179,14 @@ class MainFrameModel {
         application.addPropertyChangeListener("core", {e ->
             coreInitialized = (e.getNewValue() != null)
             core = e.getNewValue()
+            routerPresent = core.router != null
             me = core.me.getHumanReadableName()
-            core.eventBus.register(UIResultEvent.class, this)
             core.eventBus.register(UIResultBatchEvent.class, this)
             core.eventBus.register(DownloadStartedEvent.class, this)
             core.eventBus.register(ConnectionEvent.class, this)
             core.eventBus.register(DisconnectionEvent.class, this)
             core.eventBus.register(FileHashedEvent.class, this)
+            core.eventBus.register(FileHashingEvent.class, this)
             core.eventBus.register(FileLoadedEvent.class, this)
             core.eventBus.register(UploadEvent.class, this)
             core.eventBus.register(UploadFinishedEvent.class, this)
@@ -139,13 +196,23 @@ class MainFrameModel {
             core.eventBus.register(FileDownloadedEvent.class, this)
             core.eventBus.register(FileUnsharedEvent.class, this)
             core.eventBus.register(RouterDisconnectedEvent.class, this)
+            core.eventBus.register(AllFilesLoadedEvent.class, this)
+            core.eventBus.register(UpdateDownloadedEvent.class, this)
+            core.eventBus.register(TrustSubscriptionUpdatedEvent.class, this)
+
+            core.muOptions.watchedKeywords.each {
+                core.eventBus.publish(new ContentControlEvent(term : it, regex: false, add: true))
+            }
+            core.muOptions.watchedRegexes.each {
+                core.eventBus.publish(new ContentControlEvent(term : it, regex: true, add: true))
+            }
             
             timer.schedule({
                 if (core.shutdown.get())
                     return
                 int retryInterval = core.muOptions.downloadRetryInterval
                 if (retryInterval > 0) {
-                    retryInterval *= 60000
+                    retryInterval *= 1000
                     long now = System.currentTimeMillis()
                     if (now - lastRetryTime > retryInterval) {
                         lastRetryTime = now
@@ -161,22 +228,41 @@ class MainFrameModel {
 
                     }
                 }
-            }, 60000, 60000)
+            }, 1000, 1000)
 
             runInsideUIAsync {
                 trusted.addAll(core.trustService.good.values())
                 distrusted.addAll(core.trustService.bad.values())
 
-                watched.addAll(core.muOptions.watchedDirectories)
-                builder.getVariable("watched-directories-table").model.fireTableDataChanged()
-                watched.each { core.eventBus.publish(new FileSharedEvent(file : new File(it))) }
-                
                 resumeButtonText = "Retry"
+                
+                searchesPaneButtonEnabled = false
+                downloadsPaneButtonEnabled = true
+                uploadsPaneButtonEnabled = true
+                monitorPaneButtonEnabled = true
+                trustPaneButtonEnabled = true
             }
         })
 
     }
 
+    void onAllFilesLoadedEvent(AllFilesLoadedEvent e) {
+        runInsideUIAsync {
+            core.muOptions.watchedDirectories.each { core.eventBus.publish(new FileSharedEvent(file : new File(it))) }
+
+            core.muOptions.trustSubscriptions.each {
+                core.eventBus.publish(new TrustSubscriptionEvent(persona : it, subscribe : true))
+            }
+        }
+    }
+
+    void onUpdateDownloadedEvent(UpdateDownloadedEvent e) {
+        runInsideUIAsync {
+            JOptionPane.showMessageDialog(null, "MuWire $e.version has been downloaded.  You can update now",
+                "Update Downloaded", JOptionPane.INFORMATION_MESSAGE)
+        }
+    }
+
     void onUIResultEvent(UIResultEvent e) {
         MVCGroup resultsGroup = results.get(e.uuid)
         resultsGroup?.model.handleResult(e)
@@ -184,7 +270,7 @@ class MainFrameModel {
 
     void onUIResultBatchEvent(UIResultBatchEvent e) {
         MVCGroup resultsGroup = results.get(e.uuid)
-        resultsGroup?.model.handleResultBatch(e.results)
+        resultsGroup?.model?.handleResultBatch(e.results)
     }
 
     void onDownloadStartedEvent(DownloadStartedEvent e) {
@@ -228,38 +314,63 @@ class MainFrameModel {
         }
     }
 
+    void onFileHashingEvent(FileHashingEvent e) {
+        runInsideUIAsync {
+            hashingFile = e.hashingFile
+        }
+    }
+
     void onFileHashedEvent(FileHashedEvent e) {
+        runInsideUIAsync {
+            hashingFile = null
+        }
         if (e.error != null)
             return // TODO do something
-        if (infoHashes.contains(e.sharedFile.infoHash))
-            return    
-        infoHashes.add(e.sharedFile.infoHash)
         runInsideUIAsync {
             shared << e.sharedFile
+            loadedFiles = shared.size()
             JTable table = builder.getVariable("shared-files-table")
             table.model.fireTableDataChanged()
+            insertIntoTree(e.sharedFile)
+            loadedFiles = fileToNode.size()
         }
     }
 
     void onFileLoadedEvent(FileLoadedEvent e) {
-        if (infoHashes.contains(e.loadedFile.infoHash))
-            return
-        infoHashes.add(e.loadedFile.infoHash)
         runInsideUIAsync {
             shared << e.loadedFile
+            loadedFiles = shared.size()
             JTable table = builder.getVariable("shared-files-table")
             table.model.fireTableDataChanged()
+            insertIntoTree(e.loadedFile)
+            loadedFiles = fileToNode.size()
         }
     }
 
     void onFileUnsharedEvent(FileUnsharedEvent e) {
-        InfoHash infohash = e.unsharedFile.infoHash
-        if (!infoHashes.remove(infohash))
-            return
         runInsideUIAsync {
             shared.remove(e.unsharedFile)
-            JTable table = builder.getVariable("shared-files-table")
-            table.model.fireTableDataChanged()
+            loadedFiles = shared.size()
+            
+            def dmtn = fileToNode.remove(e.unsharedFile)
+            if (dmtn != null) {
+                loadedFiles = fileToNode.size()
+                while (true) {
+                    def parent = dmtn.getParent()
+                    parent.remove(dmtn)
+                    if (parent == treeRoot)
+                        break
+                    if (parent.getChildCount() == 0) {
+                        File file = parent.getUserObject().file
+                        if (core.muOptions.watchedDirectories.contains(file.toString()))
+                            core.eventBus.publish(new DirectoryUnsharedEvent(directory : parent.getUserObject().file))
+                        dmtn = parent
+                        continue
+                    }
+                    break
+                }
+            } 
+            view.refreshSharedFiles()
         }
     }
 
@@ -298,6 +409,14 @@ class MainFrameModel {
         }
     }
 
+    void onTrustSubscriptionUpdatedEvent(TrustSubscriptionUpdatedEvent e) {
+        runInsideUIAsync {
+            if (!subscriptions.contains(e.trustList))
+                subscriptions << e.trustList
+            updateTablePreservingSelection("subscription-table")
+        }
+    }
+
     void onQueryEvent(QueryEvent e) {
         if (e.replyTo == core.me.destination)
             return
@@ -319,10 +438,32 @@ class MainFrameModel {
                 return
         }
         runInsideUIAsync {
-            searches.addFirst(new IncomingSearch(search : search, replyTo : e.replyTo, originator : e.originator))
+            JTable table = builder.getVariable("searches-table")
+
+            Boolean searchFound = false
+            Iterator searchIter = searches.iterator()
+            while ( searchIter.hasNext() ) {
+                IncomingSearch searchEle = searchIter.next()
+                if ( searchEle.search == search
+                        && searchEle.originator == e.originator
+                        && searchEle.uuid == e.searchEvent.getUuid() ) {
+                    searchIter.remove()
+                    table.model.fireTableDataChanged()
+                    searchFound = true
+                    searchEle.count++
+                    searchEle.timestamp = Calendar.getInstance()
+                    searches.addFirst(searchEle)
+                    break
+                }
+            }
+
+            if (!searchFound) {
+                searches.addFirst(new IncomingSearch(search, e.replyTo, e.originator, e.searchEvent.getUuid()))
+            }
+
             while(searches.size() > 200)
                 searches.removeLast()
-            JTable table = builder.getVariable("searches-table")
+
             table.model.fireTableDataChanged()
         }
     }
@@ -331,6 +472,18 @@ class MainFrameModel {
         String search
         Destination replyTo
         Persona originator
+        long count
+        UUID uuid
+        Calendar timestamp
+
+        IncomingSearch( String search, Destination replyTo, Persona originator, UUID uuid ) {
+            this.search = search
+            this.replyTo = replyTo
+            this.originator = originator
+            this.uuid = uuid
+            this.count = 1
+            this.timestamp = Calendar.getInstance()
+        }
     }
 
     void onUpdateAvailableEvent(UpdateAvailableEvent e) {
@@ -356,14 +509,49 @@ class MainFrameModel {
     void onFileDownloadedEvent(FileDownloadedEvent e) {
         if (!core.muOptions.shareDownloadedFiles)
             return
-        infoHashes.add(e.downloadedFile.infoHash)
         runInsideUIAsync {
             shared << e.downloadedFile
             JTable table = builder.getVariable("shared-files-table")
             table.model.fireTableDataChanged()
+            insertIntoTree(e.downloadedFile)
+            loadedFiles = fileToNode.size()
         }
     }
     
+    private void insertIntoTree(SharedFile file) {
+        List<File> parents = new ArrayList<>()
+        File tmp = file.file.getParentFile()
+        while(tmp.getParent() != null) {
+            parents << tmp
+            tmp = tmp.getParentFile()
+        }
+        Collections.reverse(parents)
+        TreeNode node = treeRoot
+        for(File path : parents) {
+            boolean exists = false
+            def children = node.children()
+            def child = null
+            while(children.hasMoreElements()) {
+                child = children.nextElement()
+                def userObject = child.getUserObject()
+                if (userObject != null && userObject.file == path) {
+                    exists = true
+                    break
+                }
+            }
+            if (!exists) {
+                child = new DefaultMutableTreeNode(new InterimTreeNode(path))
+                node.add(child)
+            }
+            node = child
+        }
+        
+        def dmtn = new DefaultMutableTreeNode(file)
+        fileToNode.put(file, dmtn)
+        node.add(dmtn)
+        view.refreshSharedFiles()
+    }
+
     private static class UIConnection {
         Destination destination
         boolean incoming

gui/griffon-app/models/com/muwire/gui/MuWireStatusModel.groovy

@@ -0,0 +1,27 @@
+package com.muwire.gui
+
+import javax.annotation.Nonnull
+
+import griffon.core.artifact.GriffonModel
+import griffon.inject.MVCMember
+import griffon.transform.Observable
+import griffon.metadata.ArtifactProviderFor
+
+@ArtifactProviderFor(GriffonModel)
+class MuWireStatusModel {
+
+    @MVCMember @Nonnull
+    MuWireStatusController controller
+
+    @Observable int incomingConnections
+    @Observable int outgoingConnections
+    @Observable int knownHosts
+    @Observable int failingHosts
+    @Observable int hopelessHosts
+    @Observable int sharedFiles
+    @Observable int downloads
+
+    void mvcGroupInit(Map<String,String> args) {
+        controller.refresh()
+    }
+}

gui/griffon-app/models/com/muwire/gui/OptionsModel.groovy

@@ -11,44 +11,85 @@ import griffon.metadata.ArtifactProviderFor
 class OptionsModel {
     @Observable String downloadRetryInterval
     @Observable String updateCheckInterval
-    @Observable boolean onlyTrusted
+    @Observable boolean autoDownloadUpdate
     @Observable boolean shareDownloadedFiles
+    @Observable boolean shareHiddenFiles
+    @Observable String downloadLocation
+    @Observable String incompleteLocation
+    @Observable boolean searchComments
+    @Observable boolean browseFiles
+    @Observable int speedSmoothSeconds
 
     // i2p options
     @Observable String inboundLength
     @Observable String inboundQuantity
     @Observable String outboundLength
     @Observable String outboundQuantity
+    @Observable String i2pUDPPort
+    @Observable String i2pNTCPPort
 
     // gui options
     @Observable boolean showMonitor
     @Observable String lnf
     @Observable String font
+    @Observable boolean automaticFontSize
+    @Observable int customFontSize
     @Observable boolean clearCancelledDownloads
     @Observable boolean clearFinishedDownloads
     @Observable boolean excludeLocalResult
     @Observable boolean showSearchHashes
 
+    // bw options
+    @Observable String inBw
+    @Observable String outBw
+
+    // trust options
+    @Observable boolean onlyTrusted
+    @Observable boolean searchExtraHop
+    @Observable boolean trustLists
+    @Observable String trustListInterval
+
+
     void mvcGroupInit(Map<String, String> args) {
         MuWireSettings settings = application.context.get("muwire-settings")
         downloadRetryInterval = settings.downloadRetryInterval
         updateCheckInterval = settings.updateCheckInterval
-        onlyTrusted = !settings.allowUntrusted()
+        autoDownloadUpdate = settings.autoDownloadUpdate
         shareDownloadedFiles = settings.shareDownloadedFiles
+        shareHiddenFiles = settings.shareHiddenFiles
+        downloadLocation = settings.downloadLocation.getAbsolutePath()
+        incompleteLocation = settings.incompleteLocation.getAbsolutePath()
+        searchComments = settings.searchComments
+        browseFiles = settings.browseFiles
+        speedSmoothSeconds = settings.speedSmoothSeconds
 
         Core core = application.context.get("core")
         inboundLength = core.i2pOptions["inbound.length"]
         inboundQuantity = core.i2pOptions["inbound.quantity"]
         outboundLength = core.i2pOptions["outbound.length"]
         outboundQuantity = core.i2pOptions["outbound.quantity"]
+        i2pUDPPort = core.i2pOptions["i2np.udp.port"]
+        i2pNTCPPort = core.i2pOptions["i2np.ntcp.port"]
 
         UISettings uiSettings = application.context.get("ui-settings")
         showMonitor = uiSettings.showMonitor
         lnf = uiSettings.lnf
         font = uiSettings.font
+        automaticFontSize = uiSettings.autoFontSize
+        customFontSize = uiSettings.fontSize
         clearCancelledDownloads = uiSettings.clearCancelledDownloads
         clearFinishedDownloads = uiSettings.clearFinishedDownloads
         excludeLocalResult = uiSettings.excludeLocalResult
         showSearchHashes = uiSettings.showSearchHashes
+
+        if (core.router != null) {
+            inBw = String.valueOf(settings.inBw)
+            outBw = String.valueOf(settings.outBw)
+        }
+
+        onlyTrusted = !settings.allowUntrusted()
+        searchExtraHop = settings.searchExtraHop
+        trustLists = settings.allowTrustLists
+        trustListInterval = String.valueOf(settings.trustListInterval)
     }
 }

gui/griffon-app/models/com/muwire/gui/SearchTabModel.groovy

@@ -5,6 +5,7 @@ import javax.inject.Inject
 import javax.swing.JTable
 
 import com.muwire.core.Core
+import com.muwire.core.Persona
 import com.muwire.core.search.UIResultEvent
 
 import griffon.core.artifact.GriffonModel
@@ -18,12 +19,19 @@ class SearchTabModel {
     @MVCMember @Nonnull
     FactoryBuilderSupport builder
     
+    @Observable boolean downloadActionEnabled
+    @Observable boolean trustButtonsEnabled
+    @Observable boolean browseActionEnabled
+    @Observable boolean viewCommentActionEnabled
+
     Core core
     UISettings uiSettings
     String uuid
+    def senders = []
     def results = []
     def hashBucket = [:]
     def sourcesBucket = [:]
+    def sendersBucket = new LinkedHashMap<>()
     
 
     void mvcGroupInit(Map<String, String> args) {
@@ -48,6 +56,15 @@ class SearchTabModel {
             }
             bucket << e
 
+            def senderBucket = sendersBucket.get(e.sender)
+            if (senderBucket == null) {
+                senderBucket = []
+                sendersBucket[e.sender] = senderBucket
+                senders.clear()
+                senders.addAll(sendersBucket.keySet())
+            }
+            senderBucket << e
+            
             Set sourceBucket = sourcesBucket.get(e.infohash)
             if (sourceBucket == null) {
                 sourceBucket = new HashSet()
@@ -55,8 +72,7 @@ class SearchTabModel {
             }
             sourceBucket.addAll(e.sources)
 
-            results << e
-            JTable table = builder.getVariable("results-table")
+            JTable table = builder.getVariable("senders-table")
             table.model.fireTableDataChanged()
         }
     }
@@ -73,6 +89,14 @@ class SearchTabModel {
                     hashBucket[it.infohash] = bucket
                 }
                 
+                def senderBucket = sendersBucket.get(it.sender)
+                if (senderBucket == null) {
+                    senderBucket = []
+                    sendersBucket[it.sender] = senderBucket
+                    senders.clear()
+                    senders.addAll(sendersBucket.keySet())
+                }
+
                 Set sourceBucket = sourcesBucket.get(it.infohash)
                 if (sourceBucket == null) {
                     sourceBucket = new HashSet()
@@ -81,9 +105,9 @@ class SearchTabModel {
                 sourceBucket.addAll(it.sources)
 
                 bucket << it
-                results << it
+                senderBucket << it
             }
-            JTable table = builder.getVariable("results-table")
+            JTable table = builder.getVariable("senders-table")
             table.model.fireTableDataChanged()
         }
     }

gui/griffon-app/models/com/muwire/gui/ShowCommentModel.groovy

@@ -0,0 +1,12 @@
+package com.muwire.gui
+
+import com.muwire.core.search.UIResultEvent
+
+import griffon.core.artifact.GriffonModel
+import griffon.transform.Observable
+import griffon.metadata.ArtifactProviderFor
+
+@ArtifactProviderFor(GriffonModel)
+class ShowCommentModel {
+    UIResultEvent result
+}

gui/griffon-app/models/com/muwire/gui/TrustListModel.groovy

@@ -0,0 +1,22 @@
+package com.muwire.gui
+
+import com.muwire.core.trust.RemoteTrustList
+import com.muwire.core.trust.TrustService
+
+import griffon.core.artifact.GriffonModel
+import griffon.transform.Observable
+import griffon.metadata.ArtifactProviderFor
+
+@ArtifactProviderFor(GriffonModel)
+class TrustListModel {
+    RemoteTrustList trustList
+    TrustService trustService
+
+    def trusted
+    def distrusted
+
+    void mvcGroupInit(Map<String,String> args) {
+        trusted = new ArrayList<>(trustList.good)
+        distrusted = new ArrayList<>(trustList.bad)
+    }
+}