correct element

README.md

@@ -1,10 +1,10 @@
 # MuWire - Easy Anonymous File-Sharing
 
-MuWire is an easy to use file-sharing program which offers anonymity using [I2P technology](http://geti2p.net).
+MuWire is an easy to use file-sharing program which offers anonymity using [I2P technology](http://geti2p.net).  It works on any platform Java works on, including Windows,MacOS,Linux.
 
 It is inspired by the LimeWire Gnutella client and developped by a former LimeWire developer.
 
-The project is in development.  You can find technical documentation in the "doc" folder.
+The first stable release - 0.1.0 is avaiable for download at http://muwire.com.  You can find technical documentation in the "doc" folder.
 
 ### Building
 
@@ -23,17 +23,14 @@ Some of the UI tests will fail because they haven't been written yet :-/
 
 ### 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.  
+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.post=<port>" in there.
 
-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.
+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.
-
-At the moment there are very few nodes on the network, so you will see very few connections and search results.  It is best to leave MuWire running all the time, just like I2P.
 
 
 ### Known bugs and limitations
 
-* Any shared files get re-hashed on startup
-* Sometimes the list of shared files gets lost 
 * Many UI features you would expect are not there yet
-
+* On windows the preferences are stored in %HOME%\.MuWire instead of the user profile directory
+* Downloads in progress do not get remembered between restarts
 

cli/build.gradle

@@ -0,0 +1,22 @@
+buildscript {
+
+    repositories {
+        jcenter()
+        mavenLocal()
+    }
+
+    dependencies {
+        classpath 'com.github.jengelman.gradle.plugins:shadow:2.0.4'
+    }
+}
+
+apply plugin : 'application'
+mainClassName = 'com.muwire.cli.Cli'
+apply plugin : 'com.github.johnrengelman.shadow'
+
+applicationDefaultJvmArgs = ['-Djava.util.logging.config.file=logging.properties']
+
+dependencies {
+    compile project(":core")
+}
+

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

@@ -0,0 +1,142 @@
+package com.muwire.cli
+
+import java.util.concurrent.CountDownLatch
+
+import com.muwire.core.Core
+import com.muwire.core.MuWireSettings
+import com.muwire.core.connection.ConnectionAttemptStatus
+import com.muwire.core.connection.ConnectionEvent
+import com.muwire.core.connection.DisconnectionEvent
+import com.muwire.core.files.AllFilesLoadedEvent
+import com.muwire.core.files.FileHashedEvent
+import com.muwire.core.files.FileLoadedEvent
+import com.muwire.core.files.FileSharedEvent
+import com.muwire.core.upload.UploadEvent
+import com.muwire.core.upload.UploadFinishedEvent
+
+class Cli {
+    
+    public static void main(String[] args) {
+        def home = System.getProperty("user.home") + File.separator + ".MuWire"
+        home = new File(home)
+        if (!home.exists())
+            home.mkdirs()
+        
+        def propsFile = new File(home,"MuWire.properties")
+        if (!propsFile.exists()) {
+            println "create props file ${propsFile.getAbsoluteFile()} before launching MuWire"
+            System.exit(1)
+        }
+        
+        def props = new Properties()
+        propsFile.withInputStream { props.load(it) }
+        props = new MuWireSettings(props)
+        
+        Core core 
+        try {
+            core = new Core(props, home, "0.1.1")
+        } catch (Exception bad) {
+            bad.printStackTrace(System.out)
+            println "Failed to initialize core, exiting"
+            System.exit(1)
+        }
+
+                
+        
+        
+        def filesList
+        if (args.length == 0) {
+            println "Enter a file containing list of files to share"
+            def reader = new BufferedReader(new InputStreamReader(System.in))
+            filesList = reader.readLine()
+        } else 
+            filesList = args[0]
+        
+        Thread.sleep(1000)
+        println "loading shared files from $filesList"
+        
+        // listener for shared files
+        def sharedListener = new SharedListener()
+        core.eventBus.register(FileHashedEvent.class, sharedListener)
+        core.eventBus.register(FileLoadedEvent.class, sharedListener)
+        
+        // for connections
+        def connectionsListener = new ConnectionListener()
+        core.eventBus.register(ConnectionEvent.class, connectionsListener)
+        core.eventBus.register(DisconnectionEvent.class, connectionsListener)
+        
+        // for uploads
+        def uploadsListener = new UploadsListener()
+        core.eventBus.register(UploadEvent.class, uploadsListener)
+        core.eventBus.register(UploadFinishedEvent.class, uploadsListener)
+        
+        Timer timer = new Timer("status-printer", true)
+        timer.schedule({
+            println "Connections $connectionsListener.connections Uploads $uploadsListener.uploads Shared $sharedListener.shared"
+        } as TimerTask, 60000, 60000)
+        
+        def latch = new CountDownLatch(1)
+        def fileLoader = new Object() {
+            public void onAllFilesLoadedEvent(AllFilesLoadedEvent e) {
+                latch.countDown()
+            }
+        }
+        core.eventBus.register(AllFilesLoadedEvent.class, fileLoader)
+        core.startServices()
+        
+        println "waiting for files to load"
+        latch.await()
+        // now we begin
+        println "MuWire is ready"
+        
+        filesList = new File(filesList)
+        filesList.withReader { 
+            def toShare = it.readLine()
+            core.eventBus.publish(new FileSharedEvent(file : new File(toShare)))
+        }
+        Runtime.getRuntime().addShutdownHook({
+            println "shutting down.."
+            core.shutdown()
+            println "shutdown."
+        })
+        Thread.sleep(Integer.MAX_VALUE)
+    }
+    
+    static class ConnectionListener {
+        volatile int connections
+        public void onConnectionEvent(ConnectionEvent e) {
+            if (e.status == ConnectionAttemptStatus.SUCCESSFUL)
+                connections++
+        }
+        public void onDisconnectionEvent(DisconnectionEvent e) {
+            connections--
+        }
+    }
+    
+    static class UploadsListener {
+        volatile int uploads
+        public void onUploadEvent(UploadEvent e) {
+            uploads++
+            println "Starting upload of ${e.uploader.file.getName()} to ${e.uploader.request.downloader.getHumanReadableName()}"
+        }
+        public void onUploadFinishedEvent(UploadFinishedEvent e) {
+            uploads--
+            println "Finished upload of ${e.uploader.file.getName()} to ${e.uploader.request.downloader.getHumanReadableName()}"
+        }
+    }
+    
+    static class SharedListener {
+        volatile int shared
+        void onFileHashedEvent(FileHashedEvent e) {
+            if (e.error != null)
+                println "ERROR $e.error"
+            else {
+                println "Shared file : $e.sharedFile.file"
+                shared++
+            }
+        }
+        void onFileLoadedEvent(FileLoadedEvent e) {
+            shared++
+        }
+    }
+}

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

@@ -0,0 +1,166 @@
+package com.muwire.cli
+
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.CountDownLatch
+
+import com.muwire.core.Core
+import com.muwire.core.MuWireSettings
+import com.muwire.core.connection.ConnectionAttemptStatus
+import com.muwire.core.connection.ConnectionEvent
+import com.muwire.core.download.DownloadStartedEvent
+import com.muwire.core.download.Downloader
+import com.muwire.core.download.UIDownloadEvent
+import com.muwire.core.search.QueryEvent
+import com.muwire.core.search.SearchEvent
+import com.muwire.core.search.UIResultEvent
+
+import net.i2p.data.Base64
+
+class CliDownloader {
+    
+    private static final List<Downloader> downloaders = Collections.synchronizedList(new ArrayList<>())
+    private static final Map<UUID,ResultsHolder> resultsListeners = new ConcurrentHashMap<>()
+    
+    public static void main(String []args) {
+        def home = System.getProperty("user.home") + File.separator + ".MuWire"
+        home = new File(home)
+        if (!home.exists())
+            home.mkdirs()
+        
+        def propsFile = new File(home,"MuWire.properties")
+        if (!propsFile.exists()) {
+            println "create props file ${propsFile.getAbsoluteFile()} before launching MuWire"
+            System.exit(1)
+        }
+        
+        def props = new Properties()
+        propsFile.withInputStream { props.load(it) }
+        props = new MuWireSettings(props)
+        
+        def filesList
+        int connections
+        int resultWait
+        if (args.length != 3) {
+            println "Enter a file containing list of hashes of files to download, " + 
+                "how many connections you want before searching" +
+                "and how long to wait for results to arrive"
+                System.exit(1)
+        } else {
+            filesList = args[0]
+            connections = Integer.parseInt(args[1])
+            resultWait = Integer.parseInt(args[2])
+        }
+
+        Core core
+        try {
+            core = new Core(props, home, "0.1.1")
+        } catch (Exception bad) {
+            bad.printStackTrace(System.out)
+            println "Failed to initialize core, exiting"
+            System.exit(1)
+        }
+        
+        
+        def latch = new CountDownLatch(connections)
+        def connectionListener = new ConnectionWaiter(latch : latch)
+        core.eventBus.register(ConnectionEvent.class, connectionListener)
+        
+        core.startServices()
+        println "starting to wait until there are $connections connections"
+        latch.await()
+        
+        println "connected, searching for files"
+        
+        def file = new File(filesList)
+        file.eachLine {
+            String[] split = it.split(",")
+            UUID uuid = UUID.randomUUID()
+            core.eventBus.register(UIResultEvent.class, new ResultsListener(fileName : split[1]))
+            def hash = Base64.decode(split[0])
+            def searchEvent = new SearchEvent(searchHash : hash, uuid : uuid)
+            core.eventBus.publish(new QueryEvent(searchEvent : searchEvent, firstHop:true,
+                replyTo: core.me.destination, receivedOn : core.me.destination, originator: core.me)) 
+        }
+        
+        println "waiting for results to arrive"
+        Thread.sleep(resultWait * 1000)
+        
+        core.eventBus.register(DownloadStartedEvent.class, new DownloadListener())
+        resultsListeners.each { uuid, resultsListener ->
+            println "starting download of $resultsListener.fileName from ${resultsListener.getResults().size()} hosts"
+            File target = new File(resultsListener.fileName)
+            
+            core.eventBus.publish(new UIDownloadEvent(target : target, result : resultsListener.getResults()))
+        }
+        
+        Thread.sleep(1000)
+        
+        Timer timer = new Timer("stats-printer")
+        timer.schedule({
+            println "==== STATUS UPDATE ==="
+            downloaders.each {
+                int donePieces = it.donePieces()
+                int totalPieces = it.nPieces
+                int sources = it.activeWorkers.size()
+                def root = Base64.encode(it.infoHash.getRoot())
+                def state = it.getCurrentState()
+                println "file $it.file hash: $root progress: $donePieces/$totalPieces sources: $sources status: $state}"
+                it.resume()
+            }
+            println "==== END ==="
+        } as TimerTask, 60000, 60000)
+        
+        println "waiting for downloads to finish"
+        while(true) {
+            boolean allFinished = true
+            for (Downloader d : downloaders) {
+                allFinished &= d.getCurrentState() == Downloader.DownloadState.FINISHED
+            }
+            if (allFinished)
+                break
+            Thread.sleep(1000)
+        }
+        
+        println "all downloads finished"
+    }
+    
+    static class ResultsHolder {
+        final List<UIResultEvent> results = Collections.synchronizedList(new ArrayList<>())
+        String fileName
+        void add(UIResultEvent e) {
+            results.add(e)
+        }
+        List getResults() {
+            results
+        }
+    }
+    
+    static class ResultsListener {
+        UUID uuid
+        String fileName
+        public onUIResultEvent(UIResultEvent e) {
+            println "got a result for $fileName from ${e.sender.getHumanReadableName()}"
+            ResultsHolder listener = resultsListeners.get(e.uuid)
+            if (listener == null) {
+                listener = new ResultsHolder(fileName : fileName)
+                resultsListeners.put(e.uuid, listener)
+            }
+            listener.add(e)
+        }
+    }
+    
+    static class ConnectionWaiter {
+        CountDownLatch latch
+        public void onConnectionEvent(ConnectionEvent e) {
+            if (e.status == ConnectionAttemptStatus.SUCCESSFUL)
+                latch.countDown()
+        }
+    }
+    
+
+    static class DownloadListener {
+        public void onDownloadStartedEvent(DownloadStartedEvent e) {
+            downloaders.add(e.downloader)
+        }
+    }
+}

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

@@ -32,6 +32,7 @@ import com.muwire.core.search.SearchEvent
 import com.muwire.core.search.SearchManager
 import com.muwire.core.trust.TrustEvent
 import com.muwire.core.trust.TrustService
+import com.muwire.core.update.UpdateClient
 import com.muwire.core.upload.UploadManager
 import com.muwire.core.util.MuWireLogManager
 
@@ -55,18 +56,22 @@ public class Core {
     final EventBus eventBus
     final Persona me
     final File home
+    final Properties i2pOptions
+    final MuWireSettings muOptions
     
     private final TrustService trustService
     private final PersisterService persisterService
     private final HostCache hostCache
     private final ConnectionManager connectionManager
     private final CacheClient cacheClient
+    private final UpdateClient updateClient
     private final ConnectionAcceptor connectionAcceptor
     private final ConnectionEstablisher connectionEstablisher
     private final HasherService hasherService
         
-    public Core(MuWireSettings props, File home) {
+    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()
@@ -81,12 +86,28 @@ public class Core {
 			}
 		}
 		
-		def sysProps = System.getProperties().clone()
+        i2pOptions = new Properties()
-		sysProps["inbound.nickname"] = "MuWire"
+        def i2pOptionsFile = new File(home,"i2p.properties")
+        if (i2pOptionsFile.exists()) {
+            i2pOptionsFile.withInputStream { i2pOptions.load(it) }
+            if (!i2pOptions.hasProperty("inbound.nickname"))
+                i2pOptions["inbound.nickname"] = "MuWire"
+            if (!i2pOptions.hasProperty("outbound.nickname"))
+                i2pOptions["outbound.nickname"] = "MuWire"
+        } else {
+            i2pOptions["inbound.nickname"] = "MuWire"
+            i2pOptions["outbound.nickname"] = "MuWire"
+            i2pOptions["inbound.length"] = "3"
+            i2pOptions["inbound.quantity"] = "2"
+            i2pOptions["outbound.length"] = "3"
+            i2pOptions["outbound.quantity"] = "2"
+        }
+        
+        // options like tunnel length and quantity
 		I2PSession i2pSession
 		I2PSocketManager socketManager
 		keyDat.withInputStream {
-			socketManager = new I2PSocketManagerFactory().createManager(it, sysProps)
+			socketManager = new I2PSocketManagerFactory().createManager(it, i2pOptions)
 		}
 		socketManager.getDefaultOptions().setReadTimeout(60000)
 		socketManager.getDefaultOptions().setConnectTimeout(30000)
@@ -127,7 +148,7 @@ public class Core {
 		
 		
 		log.info "initializing file manager"
-		FileManager fileManager = new FileManager(eventBus)
+		FileManager fileManager = new FileManager(eventBus, props)
 		eventBus.register(FileHashedEvent.class, fileManager)
 		eventBus.register(FileLoadedEvent.class, fileManager)
 		eventBus.register(FileDownloadedEvent.class, fileManager)
@@ -145,7 +166,8 @@ public class Core {
 		
 		log.info("initializing connection manager")
 		connectionManager = props.isLeaf() ? 
-			new LeafConnectionManager(eventBus, me, 3, hostCache) : new UltrapeerConnectionManager(eventBus, me, 512, 512, hostCache, trustService)
+			new LeafConnectionManager(eventBus, me, 3, hostCache, props) : 
+            new UltrapeerConnectionManager(eventBus, me, 512, 512, hostCache, trustService, props)
 		eventBus.register(TrustEvent.class, connectionManager)
 		eventBus.register(ConnectionEvent.class, connectionManager)
 		eventBus.register(DisconnectionEvent.class, connectionManager)
@@ -154,6 +176,9 @@ public class Core {
 		log.info("initializing cache client")
 		cacheClient = new CacheClient(eventBus,hostCache, connectionManager, i2pSession, props, 10000)
         
+        log.info("initializing update client")
+        updateClient = new UpdateClient(eventBus, i2pSession, myVersion, props)
+        
 		log.info("initializing connector")
 		I2PConnector i2pConnector = new I2PConnector(socketManager)
         
@@ -172,17 +197,17 @@ public class Core {
         log.info("initializing upload manager")
         UploadManager uploadManager = new UploadManager(eventBus, fileManager)
         
+        log.info("initializing connection establisher")
+        connectionEstablisher = new ConnectionEstablisher(eventBus, i2pConnector, props, connectionManager, hostCache)
         
 		log.info("initializing acceptor")
 		I2PAcceptor i2pAcceptor = new I2PAcceptor(socketManager)
 		connectionAcceptor = new ConnectionAcceptor(eventBus, connectionManager, props, 
-            i2pAcceptor, hostCache, trustService, searchManager, uploadManager)
+            i2pAcceptor, hostCache, trustService, searchManager, uploadManager, connectionEstablisher)
 		
         
-        connectionEstablisher = new ConnectionEstablisher(eventBus, i2pConnector, props, connectionManager, hostCache)
-        
         log.info("initializing hasher service")
-        hasherService = new HasherService(new FileHasher(), eventBus)
+        hasherService = new HasherService(new FileHasher(), eventBus, fileManager)
         eventBus.register(FileSharedEvent.class, hasherService)
 	}
     
@@ -197,6 +222,7 @@ public class Core {
         connectionAcceptor.start()
         connectionEstablisher.start()
         hostCache.waitForLoad()
+        updateClient.start()
     }
     
     public void shutdown() {
@@ -227,7 +253,7 @@ public class Core {
             }
         }
         
-        Core core = new Core(props, home)
+        Core core = new Core(props, home, "0.1.1")
         core.startServices()
         
         // ... at the end, sleep or execute script

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

@@ -3,6 +3,7 @@ package com.muwire.core
 import java.util.concurrent.CopyOnWriteArrayList
 import java.util.concurrent.Executor
 import java.util.concurrent.Executors
+import java.util.logging.Level
 
 import com.muwire.core.files.FileSharedEvent
 
@@ -23,14 +24,18 @@ class EventBus {
 	}
 	
 	private void publishInternal(Event e) {
-		log.fine "publishing event $e of type ${e.getClass().getSimpleName()}"
+		log.fine "publishing event $e of type ${e.getClass().getSimpleName()} event $e"
 		def currentHandlers
 		final def clazz = e.getClass()
 		synchronized(this) {
 			currentHandlers = handlers.getOrDefault(clazz, [])
 		}
 		currentHandlers.each {
-			it."on${clazz.getSimpleName()}"(e)
+            try {
+                it."on${clazz.getSimpleName()}"(e)
+            } catch (Exception bad) {
+                log.log(Level.SEVERE, "exception dispatching event",bad)
+            }
 		}
 	}
 	

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

@@ -7,10 +7,12 @@ class MuWireSettings {
     final boolean isLeaf
     boolean allowUntrusted
     int downloadRetryInterval
+    int updateCheckInterval
     String nickname
     File downloadLocation
     String sharedFiles
     CrawlerResponse crawlerResponse
+    boolean shareDownloadedFiles
     
 	MuWireSettings() {
         this(new Properties())
@@ -25,6 +27,8 @@ class MuWireSettings {
             System.getProperty("user.home")))
         sharedFiles = props.getProperty("sharedFiles")
         downloadRetryInterval = Integer.parseInt(props.getProperty("downloadRetryInterval","15"))
+        updateCheckInterval = Integer.parseInt(props.getProperty("updateCheckInterval","36"))
+        shareDownloadedFiles = Boolean.parseBoolean(props.getProperty("shareDownloadedFiles","true"))
 	}
     
     void write(OutputStream out) throws IOException {
@@ -34,7 +38,9 @@ class MuWireSettings {
         props.setProperty("crawlerResponse", crawlerResponse.toString())
         props.setProperty("nickname", nickname)
         props.setProperty("downloadLocation", downloadLocation.getAbsolutePath())
-        props.setProperty("downloadRetryInterval", "15")
+        props.setProperty("downloadRetryInterval", String.valueOf(downloadRetryInterval))
+        props.setProperty("updateCheckInterval", String.valueOf(updateCheckInterval))
+        props.setProperty("shareDownloadedFiles", String.valueOf(shareDownloadedFiles))
         if (sharedFiles != null)
             props.setProperty("sharedFiles", sharedFiles)
         props.store(out, "")

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

@@ -6,6 +6,8 @@ import java.util.concurrent.atomic.AtomicBoolean
 import java.util.logging.Level
 
 import com.muwire.core.EventBus
+import com.muwire.core.MuWireSettings
+import com.muwire.core.Persona
 import com.muwire.core.hostcache.HostCache
 import com.muwire.core.hostcache.HostDiscoveredEvent
 import com.muwire.core.search.QueryEvent
@@ -14,6 +16,7 @@ import com.muwire.core.trust.TrustLevel
 import com.muwire.core.trust.TrustService
 
 import groovy.util.logging.Log
+import net.i2p.data.Base64
 import net.i2p.data.Destination
 
 @Log
@@ -24,6 +27,7 @@ abstract class Connection implements Closeable {
 	final boolean incoming
 	final HostCache hostCache
     final TrustService trustService
+    final MuWireSettings settings
     	
 	private final AtomicBoolean running = new AtomicBoolean()
 	private final BlockingQueue messages = new LinkedBlockingQueue()
@@ -33,12 +37,14 @@ abstract class Connection implements Closeable {
 	
 	long lastPingSentTime, lastPongReceivedTime
 	
-	Connection(EventBus eventBus, Endpoint endpoint, boolean incoming, HostCache hostCache, TrustService trustService) {
+	Connection(EventBus eventBus, Endpoint endpoint, boolean incoming, 
+        HostCache hostCache, TrustService trustService, MuWireSettings settings) {
 		this.eventBus = eventBus
 		this.incoming = incoming
 		this.endpoint = endpoint
 		this.hostCache = hostCache
         this.trustService = trustService
+        this.settings = settings
 		
 		this.name = endpoint.destination.toBase32().substring(0,8)
 		
@@ -120,9 +126,13 @@ abstract class Connection implements Closeable {
         query.version = 1
         query.uuid = e.searchEvent.getUuid()
         query.firstHop = e.firstHop
-        // TODO: first hop figure out
         query.keywords = e.searchEvent.getSearchTerms()
-        query.replyTo = e.getReceivedOn().toBase64()
+        query.oobInfohash = e.searchEvent.oobInfohash
+        if (e.searchEvent.searchHash != null)
+            query.infohash = Base64.encode(e.searchEvent.searchHash)
+        query.replyTo = e.replyTo.toBase64()
+        if (e.originator != null)
+            query.originator = e.originator.toBase64()
         messages.put(query)
     }
 	
@@ -148,21 +158,43 @@ abstract class Connection implements Closeable {
     
     protected void handleSearch(def search) {
         UUID uuid = UUID.fromString(search.uuid)
-        if (search.infohash != null)
+        byte [] infohash = null
+        if (search.infohash != null) {
             search.keywords = null
+            infohash = Base64.decode(search.infohash)
+        }
             
         Destination replyTo = new Destination(search.replyTo)
-        if (trustService.getLevel(replyTo) == TrustLevel.DISTRUSTED) {
+        TrustLevel trustLevel = trustService.getLevel(replyTo)
+        if (trustLevel == TrustLevel.DISTRUSTED) {
             log.info "dropping search from distrusted peer"
             return
         }
-        // TODO: add option to respond only to trusted peers
+        if (trustLevel == TrustLevel.NEUTRAL && !settings.allowUntrusted()) {
+            log.info("dropping search from neutral peer")
+            return
+        }
+        
+        Persona originator = null
+        if (search.originator != null) {
+            originator = new Persona(new ByteArrayInputStream(Base64.decode(search.originator)))
+            if (originator.destination != replyTo) {
+                log.info("originator doesn't match destination")
+                return
+            }
+        }
+        
+        boolean oob = false
+        if (search.oobInfohash != null)
+            oob = search.oobInfohash
         
         SearchEvent searchEvent = new SearchEvent(searchTerms : search.keywords,
-                                            searchHash : search.infohash,
+                                            searchHash : infohash,
-                                            uuid : uuid)
+                                            uuid : uuid,
+                                            oobInfohash : oob)
         QueryEvent event = new QueryEvent ( searchEvent : searchEvent,
                                             replyTo : replyTo,
+                                            originator : originator,
                                             receivedOn : endpoint.destination,
                                             firstHop : search.firstHop )
         eventBus.publish(event)

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

@@ -34,13 +34,15 @@ class ConnectionAcceptor {
 	final TrustService trustService
     final SearchManager searchManager 
     final UploadManager uploadManager
+    final ConnectionEstablisher establisher
 	
 	final ExecutorService acceptorThread
 	final ExecutorService handshakerThreads
 	
 	ConnectionAcceptor(EventBus eventBus, UltrapeerConnectionManager manager,
 		MuWireSettings settings, I2PAcceptor acceptor, HostCache hostCache,
-		TrustService trustService, SearchManager searchManager, UploadManager uploadManager) {
+		TrustService trustService, SearchManager searchManager, UploadManager uploadManager,
+        ConnectionEstablisher establisher) {
 		this.eventBus = eventBus
 		this.manager = manager
 		this.settings = settings
@@ -49,6 +51,7 @@ class ConnectionAcceptor {
 		this.trustService = trustService
         this.searchManager = searchManager
         this.uploadManager = uploadManager
+		this.establisher = establisher
         
 		acceptorThread = Executors.newSingleThreadExecutor { r -> 
 			def rv = new Thread(r)
@@ -140,7 +143,9 @@ class ConnectionAcceptor {
     }
 
 	private void handleIncoming(Endpoint e, boolean leaf) {
-		boolean accept = !manager.isConnected(e.destination) && (leaf ? manager.hasLeafSlots() : manager.hasPeerSlots())
+		boolean accept = !manager.isConnected(e.destination) && 
+            !establisher.isInProgress(e.destination) &&
+            (leaf ? manager.hasLeafSlots() : manager.hasPeerSlots())
 		if (accept) {
 			log.info("accepting connection, leaf:$leaf")
 			e.outputStream.write("OK".bytes)

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

@@ -35,6 +35,8 @@ class ConnectionEstablisher {
 	
 	final Set inProgress = new ConcurrentHashSet()
 	
+    ConnectionEstablisher(){}
+    
 	ConnectionEstablisher(EventBus eventBus, I2PConnector i2pConnector, MuWireSettings settings,
 		ConnectionManager connectionManager, HostCache hostCache) {
 		this.eventBus = eventBus
@@ -176,4 +178,8 @@ class ConnectionEstablisher {
 			e.close()
 		}
 	}
+    
+    public boolean isInProgress(Destination d) {
+        inProgress.contains(d)
+    }
 }

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

@@ -1,6 +1,7 @@
 package com.muwire.core.connection
 
 import com.muwire.core.EventBus
+import com.muwire.core.MuWireSettings
 import com.muwire.core.Persona
 import com.muwire.core.hostcache.HostCache
 import com.muwire.core.search.QueryEvent
@@ -19,13 +20,15 @@ abstract class ConnectionManager {
 	
 	protected final HostCache hostCache
     protected final Persona me
+    protected final MuWireSettings settings
 	
 	ConnectionManager() {}
 	
-	ConnectionManager(EventBus eventBus, Persona me, HostCache hostCache) {
+	ConnectionManager(EventBus eventBus, Persona me, HostCache hostCache, MuWireSettings settings) {
 		this.eventBus = eventBus
         this.me = me
 		this.hostCache = hostCache
+        this.settings = settings
 		this.timer = new Timer("connections-pinger",true)
 	}
 	

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

@@ -4,6 +4,7 @@ import java.io.InputStream
 import java.io.OutputStream
 
 import com.muwire.core.EventBus
+import com.muwire.core.MuWireSettings
 import com.muwire.core.hostcache.HostCache
 import com.muwire.core.trust.TrustService
 
@@ -16,8 +17,9 @@ import net.i2p.data.Destination
  */
 class LeafConnection extends Connection {
 
-	public LeafConnection(EventBus eventBus, Endpoint endpoint, HostCache hostCache, TrustService trustService) {
+	public LeafConnection(EventBus eventBus, Endpoint endpoint, HostCache hostCache, 
-		super(eventBus, endpoint, true, hostCache, trustService);
+        TrustService trustService, MuWireSettings settings) {
+		super(eventBus, endpoint, true, hostCache, trustService, settings);
 	}
 
 	@Override

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

@@ -3,6 +3,7 @@ package com.muwire.core.connection
 import java.util.concurrent.ConcurrentHashMap
 
 import com.muwire.core.EventBus
+import com.muwire.core.MuWireSettings
 import com.muwire.core.Persona
 import com.muwire.core.hostcache.HostCache
 import com.muwire.core.search.QueryEvent
@@ -17,8 +18,9 @@ class LeafConnectionManager extends ConnectionManager {
 	
 	final Map<Destination, UltrapeerConnection> connections = new ConcurrentHashMap()
 	
-	public LeafConnectionManager(EventBus eventBus, Persona me, int maxConnections, HostCache hostCache) {
+	public LeafConnectionManager(EventBus eventBus, Persona me, int maxConnections, 
-		super(eventBus, me, hostCache)
+        HostCache hostCache, MuWireSettings settings) {
+		super(eventBus, me, hostCache, settings)
 		this.maxConnections = maxConnections
 	}
 	

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

@@ -4,6 +4,7 @@ import java.io.InputStream
 import java.io.OutputStream
 
 import com.muwire.core.EventBus
+import com.muwire.core.MuWireSettings
 import com.muwire.core.hostcache.HostCache
 import com.muwire.core.trust.TrustService
 import com.muwire.core.util.DataUtil
@@ -29,8 +30,9 @@ class PeerConnection extends Connection {
 	private final JsonSlurper slurper = new JsonSlurper()
 
 	public PeerConnection(EventBus eventBus, Endpoint endpoint,
-			boolean incoming, HostCache hostCache, TrustService trustService) {
+			boolean incoming, HostCache hostCache, TrustService trustService,
-		super(eventBus, endpoint, incoming, hostCache, trustService)
+            MuWireSettings settings) {
+		super(eventBus, endpoint, incoming, hostCache, trustService, settings)
 		this.dis = new DataInputStream(endpoint.inputStream)
 		this.dos = new DataOutputStream(endpoint.outputStream)
 	}

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

@@ -4,6 +4,7 @@ import java.util.Collection
 import java.util.concurrent.ConcurrentHashMap
 
 import com.muwire.core.EventBus
+import com.muwire.core.MuWireSettings
 import com.muwire.core.Persona
 import com.muwire.core.hostcache.HostCache
 import com.muwire.core.search.QueryEvent
@@ -24,8 +25,8 @@ class UltrapeerConnectionManager extends ConnectionManager {
 	UltrapeerConnectionManager() {}
 
 	public UltrapeerConnectionManager(EventBus eventBus, Persona me, int maxPeers, int maxLeafs, 
-        HostCache hostCache, TrustService trustService) {
+        HostCache hostCache, TrustService trustService, MuWireSettings settings) {
-		super(eventBus, me, hostCache)
+		super(eventBus, me, hostCache, settings)
 		this.maxPeers = maxPeers
 		this.maxLeafs = maxLeafs
         this.trustService = trustService
@@ -85,8 +86,8 @@ class UltrapeerConnectionManager extends ConnectionManager {
 			return
 		
 		Connection c = e.leaf ? 
-			new LeafConnection(eventBus, e.endpoint, hostCache, trustService) : 
+			new LeafConnection(eventBus, e.endpoint, hostCache, trustService, settings) : 
-			new PeerConnection(eventBus, e.endpoint, e.incoming, hostCache, trustService)
+			new PeerConnection(eventBus, e.endpoint, e.incoming, hostCache, trustService, settings)
 		def map = e.leaf ? leafConnections : peerConnections
 		map.put(e.endpoint.destination, c)
 		c.start()

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

@@ -3,6 +3,7 @@ package com.muwire.core.download
 import com.muwire.core.connection.I2PConnector
 
 import net.i2p.data.Base64
+import net.i2p.data.Destination
 
 import com.muwire.core.EventBus
 import com.muwire.core.Persona
@@ -16,16 +17,13 @@ public class DownloadManager {
     private final I2PConnector connector
     private final Executor executor
     private final File incompletes
-    private final String meB64
+    private final Persona me
     
     public DownloadManager(EventBus eventBus, I2PConnector connector, File incompletes, Persona me) {
         this.eventBus = eventBus
         this.connector = connector
         this.incompletes = incompletes
-        
+        this.me = me
-        def baos = new ByteArrayOutputStream()
-        me.write(baos)
-        this.meB64 = Base64.encode(baos.toByteArray())
         
         incompletes.mkdir()
         
@@ -39,8 +37,18 @@ public class DownloadManager {
     
     
     public void onUIDownloadEvent(UIDownloadEvent e) {
-        def downloader = new Downloader(this, meB64, e.target, e.result.size,
+        
-            e.result.infohash, e.result.pieceSize, connector, e.result.sender.destination,
+        def size = e.result[0].size
+        def infohash = e.result[0].infohash
+        def pieceSize = e.result[0].pieceSize
+        
+        Set<Destination> destinations = new HashSet<>()
+        e.result.each { 
+            destinations.add(it.sender.destination)
+        }
+        
+        def downloader = new Downloader(eventBus, this, me, e.target, size,
+            infohash, pieceSize, connector, destinations,
             incompletes)
         executor.execute({downloader.download()} as Runnable)
         eventBus.publish(new DownloadStartedEvent(downloader : downloader))

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

@@ -20,8 +20,10 @@ import java.security.NoSuchAlgorithmException
 @Log
 class DownloadSession {
     
+    private static int SAMPLES = 10
+    
     private final String meB64
-    private final Pieces pieces
+    private final Pieces downloaded, claimed
     private final InfoHash infoHash
     private final Endpoint endpoint
     private final File file
@@ -29,12 +31,16 @@ class DownloadSession {
     private final long fileLength
     private final MessageDigest digest
     
+    private final LinkedList<Long> timestamps = new LinkedList<>()
+    private final LinkedList<Integer> reads = new LinkedList<>()
+    
     private ByteBuffer mapped
     
-    DownloadSession(String meB64, Pieces pieces, InfoHash infoHash, Endpoint endpoint, File file, 
+    DownloadSession(String meB64, Pieces downloaded, Pieces claimed, InfoHash infoHash, Endpoint endpoint, File file, 
         int pieceSize, long fileLength) {
         this.meB64 = meB64
-        this.pieces = pieces
+        this.downloaded = downloaded
+        this.claimed = claimed
         this.endpoint = endpoint
         this.infoHash = infoHash
         this.file = file
@@ -48,11 +54,31 @@ class DownloadSession {
         }
     }
     
-    public void request() throws IOException {
+    /**
+     * @return if the request will proceed.  The only time it may not
+     * is if all the pieces have been claimed by other sessions.
+     * @throws IOException
+     */
+    public boolean request() throws IOException {
         OutputStream os = endpoint.getOutputStream()
         InputStream is = endpoint.getInputStream()
         
-        int piece = pieces.getRandomPiece()
+        int piece
+        while(true) {
+            piece = downloaded.getRandomPiece()
+            if (claimed.isMarked(piece)) {
+                if (downloaded.donePieces() + claimed.donePieces() == downloaded.nPieces) {
+                    log.info("all pieces claimed")
+                    return false
+                }
+                continue
+            }
+            break
+        }
+        claimed.markDownloaded(piece)
+        
+        log.info("will download piece $piece")
+        
         long start = piece * pieceSize
         long end = Math.min(fileLength, start + pieceSize) - 1
         long length = end - start + 1
@@ -122,6 +148,13 @@ 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)
                 }
             }
             
@@ -133,10 +166,12 @@ class DownloadSession {
             if (hash != expected) 
                 throw new BadHashException()
             
-            pieces.markDownloaded(piece)        
+            downloaded.markDownloaded(piece)        
         } finally {
+            claimed.clear(piece)
             try { channel?.close() } catch (IOException ignore) {}
         }
+        return true
     }
     
     synchronized int positionInPiece() {
@@ -144,4 +179,26 @@ class DownloadSession {
             return 0
         mapped.position()
     }
+    
+    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)
+    }
 }

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

@@ -1,12 +1,19 @@
 package com.muwire.core.download
 
 import com.muwire.core.InfoHash
+import com.muwire.core.Persona
 import com.muwire.core.connection.Endpoint
 
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.ExecutorService
+import java.util.concurrent.Executors
 import java.util.logging.Level
 
 import com.muwire.core.Constants
+import com.muwire.core.DownloadedFile
+import com.muwire.core.EventBus
 import com.muwire.core.connection.I2PConnector
+import com.muwire.core.files.FileDownloadedEvent
 
 import groovy.util.logging.Log
 import net.i2p.data.Destination
@@ -14,35 +21,45 @@ import net.i2p.data.Destination
 @Log
 public class Downloader {
     public enum DownloadState { CONNECTING, DOWNLOADING, FAILED, CANCELLED, FINISHED }
+    private enum WorkerState { CONNECTING, DOWNLOADING, FINISHED}
     
+    private static final ExecutorService executorService = Executors.newCachedThreadPool({r ->
+        Thread rv = new Thread(r)
+        rv.setName("download worker")
+        rv.setDaemon(true)
+        rv
+    })
+
+    private final EventBus eventBus
     private final DownloadManager downloadManager 
-    private final String meB64   
+    private final Persona me   
     private final File file
-    private final Pieces pieces
+    private final Pieces downloaded, claimed
     private final long length
     private final InfoHash infoHash
     private final int pieceSize
     private final I2PConnector connector
-    private final Destination destination
+    private final Set<Destination> destinations
     private final int nPieces
     private final File piecesFile
+    private final Map<Destination, DownloadWorker> activeWorkers = new ConcurrentHashMap<>()
+    
     
-    private Endpoint endpoint
-    private volatile DownloadSession currentSession
-    private volatile DownloadState currentState
     private volatile boolean cancelled
-    private volatile Thread downloadThread
+    private volatile boolean eventFired
 
-    public Downloader(DownloadManager downloadManager, String meB64, File file, long length, InfoHash infoHash, 
+    public Downloader(EventBus eventBus, DownloadManager downloadManager, 
-        int pieceSizePow2, I2PConnector connector, Destination destination,
+        Persona me, File file, long length, InfoHash infoHash, 
+        int pieceSizePow2, I2PConnector connector, Set<Destination> destinations,
         File incompletes) {
-        this.meB64 = meB64
+        this.eventBus = eventBus
+        this.me = me
         this.downloadManager = downloadManager
         this.file = file
         this.infoHash = infoHash
         this.length = length
         this.connector = connector
-        this.destination = destination
+        this.destinations = destinations
         this.piecesFile = new File(incompletes, file.getName()+".pieces")
         this.pieceSize = 1 << pieceSizePow2
         
@@ -53,32 +70,18 @@ public class Downloader {
             nPieces = length / pieceSize + 1
         this.nPieces = nPieces
         
-        pieces = new Pieces(nPieces, Constants.DOWNLOAD_SEQUENTIAL_RATIO)
+        downloaded = new Pieces(nPieces, Constants.DOWNLOAD_SEQUENTIAL_RATIO)
-        currentState = DownloadState.CONNECTING
+        claimed = new Pieces(nPieces)
     }
     
     void download() {
         readPieces()
-        downloadThread = Thread.currentThread()
+        destinations.each {
-        Endpoint endpoint = null
+            if (it != me.destination) {
-        try {
+                def worker = new DownloadWorker(it)
-            endpoint = connector.connect(destination)
+                activeWorkers.put(it, worker)
-            currentState = DownloadState.DOWNLOADING
+                executorService.submit(worker)
-            while(!pieces.isComplete()) {
-                currentSession = new DownloadSession(meB64, pieces, infoHash, endpoint, file, pieceSize, length)
-                currentSession.request()
-                writePieces()
             }
-            currentState = DownloadState.FINISHED
-            piecesFile.delete()
-        } catch (Exception bad) {
-            log.log(Level.WARNING,"Exception while downloading",bad)
-            if (cancelled)
-                currentState = DownloadState.CANCELLED
-            else if (currentState != DownloadState.FINISHED)
-                currentState = DownloadState.FAILED
-        } finally {
-            endpoint?.close()
         }
     }
     
@@ -87,38 +90,135 @@ public class Downloader {
             return
         piecesFile.withReader { 
             int piece = Integer.parseInt(it.readLine())
-            pieces.markDownloaded(piece)
+            downloaded.markDownloaded(piece)
         }
     }
     
     void writePieces() {
         piecesFile.withPrintWriter { writer ->
-            pieces.getDownloaded().each { piece -> 
+            downloaded.getDownloaded().each { piece -> 
                 writer.println(piece)
             }
         }
     }
     
     public long donePieces() {
-        pieces.donePieces()
+        downloaded.donePieces()
     }
     
-    public int positionInPiece() {
+    
-        if (currentSession == null)
+    public int speed() {
-            return 0
+        int total = 0
-        currentSession.positionInPiece()
+        if (getCurrentState() == DownloadState.DOWNLOADING) {
+            activeWorkers.values().each {
+                if (it.currentState == WorkerState.DOWNLOADING)
+                    total += it.speed()
+            }
+        }
+        total
     }
     
     public DownloadState getCurrentState() {
-        currentState
+        if (cancelled)
+            return DownloadState.CANCELLED
+        boolean allFinished = true
+        activeWorkers.values().each { 
+            allFinished &= it.currentState == WorkerState.FINISHED
+        }
+        if (allFinished) {
+            if (downloaded.isComplete())
+                return DownloadState.FINISHED
+            return DownloadState.FAILED
+        }
+        
+        // if at least one is downloading...
+        boolean oneDownloading = false
+        activeWorkers.values().each { 
+            if (it.currentState == WorkerState.DOWNLOADING) {
+                oneDownloading = true
+                return 
+            }
+        }
+        
+        if (oneDownloading)
+            return DownloadState.DOWNLOADING
+        
+        return DownloadState.CONNECTING
     }
     
     public void cancel() {
         cancelled = true
-        downloadThread?.interrupt()
+        activeWorkers.values().each { 
+            it.cancel()
+        }
+    }
+    
+    public int activeWorkers() {
+        int active = 0
+        activeWorkers.values().each { 
+            if (it.currentState != WorkerState.FINISHED)
+                active++
+        }
+        active
     }
     
     public void resume() {
-        downloadManager.resume(this)
+        activeWorkers.each { destination, worker ->
+            if (worker.currentState == WorkerState.FINISHED) {
+                def newWorker = new DownloadWorker(destination)
+                activeWorkers.put(destination, newWorker)
+                executorService.submit(newWorker)
+            }
+        }
+    }
+    
+    class DownloadWorker implements Runnable {
+        private final Destination destination
+        private volatile WorkerState currentState
+        private volatile Thread downloadThread
+        private Endpoint endpoint
+        private volatile DownloadSession currentSession
+                
+        DownloadWorker(Destination destination) {
+            this.destination = destination
+        }
+        
+        public void run() {
+            downloadThread = Thread.currentThread()
+            currentState = WorkerState.CONNECTING
+            Endpoint endpoint = null
+            try {
+                endpoint = connector.connect(destination)
+                currentState = WorkerState.DOWNLOADING
+                boolean requestPerformed
+                while(!downloaded.isComplete()) {
+                    currentSession = new DownloadSession(me.toBase64(), downloaded, claimed, infoHash, endpoint, file, pieceSize, length)
+                    requestPerformed = currentSession.request()
+                    if (!requestPerformed)
+                        break
+                    writePieces()
+                }
+            } catch (Exception bad) {
+                log.log(Level.WARNING,"Exception while downloading",bad)
+            } finally {
+                currentState = WorkerState.FINISHED
+                if (downloaded.isComplete() && !eventFired) {
+                    piecesFile.delete()
+                    eventFired = true
+                    eventBus.publish(new FileDownloadedEvent(downloadedFile : new DownloadedFile(file, infoHash, pieceSize, Collections.emptySet())))
+                }
+                endpoint?.close()
+            }
+        }
+        
+        int speed() {
+            if (currentSession == null)
+                return 0
+            currentSession.speed()
+        }
+        
+        void cancel() {
+            downloadThread?.interrupt()
+        }
     }
 }

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

@@ -28,7 +28,8 @@ class Pieces {
         
         while(true) {
             int start = random.nextInt(nPieces)
-            while(bitSet.get(start) && ++start < nPieces);
+            if (bitSet.get(start))
+                continue
             return start
         }
     }
@@ -45,10 +46,18 @@ class Pieces {
         bitSet.set(piece)
     }
     
+    synchronized void clear(int piece) {
+        bitSet.clear(piece)
+    }
+    
     synchronized boolean isComplete() {
         bitSet.cardinality() == nPieces
     }
     
+    synchronized boolean isMarked(int piece) {
+        bitSet.get(piece)
+    }
+    
     synchronized int donePieces() {
         bitSet.cardinality()
     }

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

@@ -5,6 +5,6 @@ import com.muwire.core.search.UIResultEvent
 
 class UIDownloadEvent extends Event {
     
-    UIResultEvent result
+    UIResultEvent[] result
     File target
 }

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

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

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

@@ -17,12 +17,12 @@ class FileHasher {
 	 * @return the size of each piece in power of 2
 	 */
 	static int getPieceSize(long size) {
-		if (size <= 0x1 << 25)
+		if (size <= 0x1 << 27)
-			return 18
+			return 17
 		
-		for (int i = 26; i <= 37; i++) {
+		for (int i = 28; i <= 37; i++) {
 			if (size <= 0x1L << i) {
-				return i-7
+				return i-10
 			}
 		}
 		
@@ -52,11 +52,11 @@ class FileHasher {
 		try {
 			MappedByteBuffer buf
 			for (int i = 0; i < numPieces - 1; i++) {
-				buf = raf.getChannel().map(MapMode.READ_ONLY, size * i, size)
+				buf = raf.getChannel().map(MapMode.READ_ONLY, ((long)size) * i, size)
 				digest.update buf
 				output.write(digest.digest(), 0, 32)
 			}
-			def lastPieceLength = length - (numPieces - 1) * size
+			def lastPieceLength = length - (numPieces - 1) * ((long)size)
 			buf = raf.getChannel().map(MapMode.READ_ONLY, length - lastPieceLength, lastPieceLength)
 			digest.update buf
 			output.write(digest.digest(), 0, 32)
@@ -67,4 +67,18 @@ class FileHasher {
 		byte [] hashList = output.toByteArray()
 		InfoHash.fromHashList(hashList)
 	}
+    
+    public static void main(String[] args) {
+        if (args.length != 1) {
+            println "This utility computes an infohash of a file"
+            println "Pass absolute path to a file as an argument"
+            System.exit(1)
+        }
+        
+        def file = new File(args[0])
+        file = file.getAbsoluteFile()
+        def hasher = new FileHasher()
+        def infohash = hasher.hashFile(file)
+        println infohash
+    }
 }

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

@@ -2,6 +2,7 @@ package com.muwire.core.files
 
 import com.muwire.core.EventBus
 import com.muwire.core.InfoHash
+import com.muwire.core.MuWireSettings
 import com.muwire.core.SharedFile
 import com.muwire.core.search.ResultsEvent
 import com.muwire.core.search.SearchEvent
@@ -14,27 +15,31 @@ class FileManager {
 
 
 	final EventBus eventBus
+    final MuWireSettings settings
 	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 SearchIndex index = new SearchIndex()
 	
-	FileManager(EventBus eventBus) {
+	FileManager(EventBus eventBus, MuWireSettings settings) {
+        this.settings = settings
 		this.eventBus = eventBus
 	}
 	
-	void onFileHashedEvent(FileHashedEvent e) {
+    void onFileHashedEvent(FileHashedEvent e) {
-		if (e.sharedFile != null)
+        if (e.sharedFile != null)
-			addToIndex(e.sharedFile)
+            addToIndex(e.sharedFile)
-	}
+    }
 	
 	void onFileLoadedEvent(FileLoadedEvent e) {
 		addToIndex(e.loadedFile)
 	}
 	
-	void onFileDownloadedEvent(FileDownloadedEvent e) {
+    void onFileDownloadedEvent(FileDownloadedEvent e) {
-		addToIndex(e.downloadedFile)
+        if (settings.shareDownloadedFiles) {
-	}
+            addToIndex(e.downloadedFile)
+        }
+    }
 	
 	private void addToIndex(SharedFile sf) {
         log.info("Adding shared file " + sf.getFile())
@@ -100,6 +105,7 @@ class FileManager {
 		if (e.searchHash != null) {
             Set<SharedFile> found
             found = rootToFiles.get new InfoHash(e.searchHash)
+            found = filter(found, e.oobInfohash)
 			if (found != null && !found.isEmpty())
 				re = new ResultsEvent(results: found.asList(), uuid: e.uuid)
 		} else {
@@ -108,6 +114,7 @@ class FileManager {
 			names.each { files.addAll nameToFiles.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)
 			
@@ -116,4 +123,15 @@ class FileManager {
 		if (re != null)
 			eventBus.publish(re)
 	}
+    
+    private static Set<SharedFile> filter(Set<SharedFile> files, boolean oob) {
+        if (!oob)
+            return files
+        Set<SharedFile> rv = new HashSet<>()
+        files.each { 
+            if (it.getPieceSize() != 0)
+                rv.add(it)
+        }
+        rv
+    }
 }

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

@@ -10,11 +10,13 @@ class HasherService {
 
 	final FileHasher hasher
 	final EventBus eventBus
+    final FileManager fileManager
 	Executor executor
 	
-	HasherService(FileHasher hasher, EventBus eventBus) {
+	HasherService(FileHasher hasher, EventBus eventBus, FileManager fileManager) {
 		this.hasher = hasher
 		this.eventBus = eventBus
+        this.fileManager = fileManager
 	}
 	
 	void start() {
@@ -22,6 +24,8 @@ class HasherService {
 	}
 	
 	void onFileSharedEvent(FileSharedEvent evt) {
+        if (fileManager.fileToSharedFile.containsKey(evt.file))
+            return
 		executor.execute( { -> process(evt.file) } as Runnable)
 	}
 	
@@ -36,7 +40,7 @@ class HasherService {
 				eventBus.publish new FileHashedEvent(error: "$f is too large to be shared ${f.length()}")
 			} else {
 				def hash = hasher.hashFile f
-				eventBus.publish new FileHashedEvent(sharedFile: new SharedFile(f, hash))
+				eventBus.publish new FileHashedEvent(sharedFile: new SharedFile(f, hash, FileHasher.getPieceSize(f.length())))
 			}
 		}
 	}

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

@@ -1,5 +1,8 @@
 package com.muwire.core.files
 
+import java.nio.file.CopyOption
+import java.nio.file.Files
+import java.nio.file.StandardCopyOption
 import java.util.logging.Level
 import java.util.stream.Collectors
 
@@ -34,7 +37,7 @@ class PersisterService extends Service {
 	}
 	
 	void start() {
-		timer.schedule({load()} as TimerTask, 1000)
+		timer.schedule({load()} as TimerTask, 1)
 	}
 	
 	void stop() {
@@ -55,6 +58,7 @@ class PersisterService extends Service {
 						}
 					}
 				}
+                listener.publish(new AllFilesLoadedEvent())
 			} catch (IllegalArgumentException|NumberFormatException e) {
                 log.log(Level.WARNING, "couldn't load files",e)
 			}
@@ -94,28 +98,37 @@ class PersisterService extends Service {
 		if (!Arrays.equals(root, ih.getRoot()))
 			return null
 			
-		if (json.sources != null) {
+        int pieceSize = 0
+        if (json.pieceSize != null)
+            pieceSize = json.pieceSize
+            
+        if (json.sources != null) {
 			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, sourceSet)
+			DownloadedFile df = new DownloadedFile(file, ih, pieceSize, sourceSet)
 			return new FileLoadedEvent(loadedFile : df)
 		}
         
-		SharedFile sf = new SharedFile(file, ih)
+		 
+		SharedFile sf = new SharedFile(file, ih, pieceSize)
 		return new FileLoadedEvent(loadedFile: sf)
 		
 	}
 	
 	private void persistFiles() {
-		location.delete()
 		def sharedFiles = fileManager.getSharedFiles()
-		location.withPrintWriter { writer ->
+        
+        File tmp = File.createTempFile("muwire-files", "tmp")
+        tmp.deleteOnExit()
+		tmp.withPrintWriter { writer ->
 			sharedFiles.each { k, v ->
 				def json = toJson(k,v)
 				json = JsonOutput.toJson(json)
 				writer.println json
 			}
 		}
+        Files.copy(tmp.toPath(), location.toPath(), StandardCopyOption.REPLACE_EXISTING)
+        tmp.delete()
 	}
 	
 	private def toJson(File f, SharedFile sf) {
@@ -124,6 +137,7 @@ class PersisterService extends Service {
 		json.length = f.length()
 		InfoHash ih = sf.getInfoHash()
 		json.infoHash = Base64.encode ih.getRoot()
+        json.pieceSize = sf.getPieceSize()
 		byte [] tmp = new byte [32]
 		json.hashList = []
 		for (int i = 0;i < ih.getHashList().length / 32; i++) {

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

@@ -65,7 +65,7 @@ class CacheClient {
 		options.setSendLeaseSet(true)
 		CacheServers.getCacheServers().each {
 			log.info "Querying hostcache ${it.toBase32()}"
-			session.sendMessage(it, ping, 0, ping.length, I2PSession.PROTO_DATAGRAM, 0, 0, options)
+			session.sendMessage(it, ping, 0, ping.length, I2PSession.PROTO_DATAGRAM, 1, 0, options)
 		}
 	}
 	
@@ -140,7 +140,7 @@ class CacheClient {
 		pong.pongs.asList().each { 
 			Destination dest = new Destination(it)
 			if (!session.getMyDestination().equals(dest))
-				eventBus.publish(new HostDiscoveredEvent(destination: dest)) 
+				eventBus.publish(new HostDiscoveredEvent(destination: dest, fromHostcache : true)) 
 		}
 		
 	}

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

@@ -30,4 +30,8 @@ class Host {
 	synchronized boolean hasSucceeded() {
 		successes > 0
 	}
+    
+    synchronized void clearFailures() {
+        failures = 0
+    }
 }

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

@@ -46,8 +46,12 @@ class HostCache extends Service {
 	void onHostDiscoveredEvent(HostDiscoveredEvent e) {
 		if (myself == e.destination)
 			return
-		if (hosts.containsKey(e.destination))
+		if (hosts.containsKey(e.destination)) {
-			return
+            if (!e.fromHostcache)
+                return
+            hosts.get(e.destination).clearFailures()
+            return
+		}
 		Host host = new Host(e.destination)
 		if (allowHost(host)) {
 			hosts.put(e.destination, host)
@@ -55,7 +59,7 @@ class HostCache extends Service {
 	}
 	
 	void onConnectionEvent(ConnectionEvent e) {
-		if (e.incoming || e.leaf)
+		if (e.leaf)
 			return
 		Destination dest = e.endpoint.destination
 		Host host = hosts.get(dest)

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

@@ -7,9 +7,10 @@ import net.i2p.data.Destination
 class HostDiscoveredEvent extends Event {
 
 	Destination destination
+    boolean fromHostcache
     
 	@Override
 	public String toString() {
-		"HostDiscoveredEvent ${super.toString()} destination:${destination.toBase32()}"
+		"HostDiscoveredEvent ${super.toString()} destination:${destination.toBase32()} from hostcache $fromHostcache"
 	}
 }

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

@@ -1,6 +1,7 @@
 package com.muwire.core.search
 
 import com.muwire.core.Event
+import com.muwire.core.Persona
 
 import net.i2p.data.Destination
 
@@ -9,6 +10,11 @@ class QueryEvent extends Event {
     SearchEvent searchEvent
 	boolean firstHop
 	Destination replyTo
+    Persona originator
 	Destination receivedOn
 
+    String toString() {
+        "searchEvent: $searchEvent firstHop:$firstHop, replyTo:${replyTo.toBase32()}" +
+        "originator: ${originator.getHumanReadableName()} receivedOn: ${receivedOn.toBase32()}"
+    }
 }

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

@@ -51,11 +51,14 @@ class ResultsSender {
         if (target.equals(me.destination)) {
             results.each { 
                 long length = it.getFile().length()
+                int pieceSize = it.getPieceSize()
+                if (pieceSize == 0)
+                    pieceSize = FileHasher.getPieceSize(length)
                 def uiResultEvent = new UIResultEvent( sender : me,
                     name : it.getFile().getName(),
                     size : length,
                     infohash : it.getInfoHash(),
-                    pieceSize : FileHasher.getPieceSize(length),
+                    pieceSize : pieceSize,
                     uuid : uuid
                     )
                     eventBus.publish(uiResultEvent)
@@ -95,7 +98,7 @@ class ResultsSender {
                     obj.name = encodedName
                     obj.infohash = Base64.encode(it.getInfoHash().getRoot())
                     obj.size = it.getFile().length()
-                    obj.pieceSize = FileHasher.getPieceSize(it.getFile().length())
+                    obj.pieceSize = it.getPieceSize()
                     byte [] hashList = it.getInfoHash().getHashList()
                     def hashListB64 = []
                     for (int i = 0; i < hashList.length / InfoHash.SIZE; i++) {

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

@@ -1,10 +1,19 @@
 package com.muwire.core.search
 
 import com.muwire.core.Event
+import com.muwire.core.InfoHash
 
 class SearchEvent extends Event {
 
 	List<String> searchTerms
 	byte [] searchHash
 	UUID uuid
+    boolean oobInfohash
+    
+    String toString() {
+        def infoHash = null
+        if (searchHash != null)
+            infoHash = new InfoHash(searchHash)
+        "searchTerms: $searchTerms searchHash:$infoHash, uuid:$uuid oobInfohash:$oobInfohash"
+    }
 }

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

@@ -0,0 +1,10 @@
+package com.muwire.core.update
+
+import com.muwire.core.Event
+import com.muwire.core.InfoHash
+
+class UpdateAvailableEvent extends Event {
+    String version
+    String signer
+    String infoHash
+}

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

@@ -0,0 +1,132 @@
+package com.muwire.core.update
+
+import java.util.logging.Level
+
+import com.muwire.core.EventBus
+import com.muwire.core.MuWireSettings
+
+import groovy.json.JsonOutput
+import groovy.json.JsonSlurper
+import groovy.util.logging.Log
+import net.i2p.client.I2PSession
+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.util.VersionComparator
+
+@Log
+class UpdateClient {
+    final EventBus eventBus
+    final I2PSession session
+    final String myVersion
+    final MuWireSettings settings
+    
+    private final Timer timer
+    
+    private long lastUpdateCheckTime
+    
+    UpdateClient(EventBus eventBus, I2PSession session, String myVersion, MuWireSettings settings) {
+        this.eventBus = eventBus
+        this.session = session
+        this.myVersion = myVersion
+        this.settings = settings
+        timer = new Timer("update-client",true)
+    }
+    
+    void start() {
+        session.addMuxedSessionListener(new Listener(), I2PSession.PROTO_DATAGRAM, 2)
+        timer.schedule({checkUpdate()} as TimerTask, 60000, 60 * 60 * 1000)
+    }
+    
+    void stop() {
+        timer.cancel()
+    }
+    
+    private void checkUpdate() {
+        final long now = System.currentTimeMillis()
+        if (lastUpdateCheckTime > 0) {
+            if (now - lastUpdateCheckTime < settings.updateCheckInterval * 60 * 60 * 1000)
+                return
+        }
+        lastUpdateCheckTime = now
+    
+        log.info("checking for update")
+        
+        def ping = [version : 1, myVersion : myVersion]
+        ping = JsonOutput.toJson(ping)
+        def maker = new I2PDatagramMaker(session)
+        ping = maker.makeI2PDatagram(ping.bytes)
+        def options = new SendMessageOptions() 
+        options.setSendLeaseSet(true)
+        session.sendMessage(UpdateServers.UPDATE_SERVER, ping, 0, ping.length, I2PSession.PROTO_DATAGRAM, 2, 0, options)   
+    }
+    
+    class Listener implements I2PSessionMuxedListener {
+        
+        final JsonSlurper slurper = new JsonSlurper()
+
+        @Override
+        public void messageAvailable(I2PSession session, int msgId, long size) {
+        }
+
+        @Override
+        public void messageAvailable(I2PSession session, int msgId, long size, int proto, int fromport, int toport) {
+            if (proto != I2PSession.PROTO_DATAGRAM) {
+                log.warning "Received unexpected protocol $proto"
+                return
+            }
+            
+            def payload = session.receiveMessage(msgId)
+            def dissector = new I2PDatagramDissector()
+            try {
+                dissector.loadI2PDatagram(payload)
+                def sender = dissector.getSender()
+                if (sender != UpdateServers.UPDATE_SERVER) {
+                    log.warning("received something not from update server " + sender.toBase32())
+                    return
+                }
+                
+                log.info("Received something from update server")
+                
+                payload = dissector.getPayload()
+                payload = slurper.parse(payload)
+                
+                if (payload.version == null) {
+                    log.warning("version missing")
+                    return
+                }
+                
+                if (payload.signer == null) {
+                    log.warning("signer missing")
+                }
+                
+                if (VersionComparator.comp(myVersion, payload.version) >= 0) {
+                    log.info("no new version available")
+                    return
+                }
+                
+                log.info("new version $payload.version available, publishing event")
+                eventBus.publish(new UpdateAvailableEvent(version : payload.version, signer : payload.signer, infoHash : payload.infoHash))
+                
+            } catch (Exception e) {
+                log.log(Level.WARNING,"Invalid datagram",e)
+            }
+        }
+
+        @Override
+        public void reportAbuse(I2PSession session, int severity) {
+        }
+
+        @Override
+        public void disconnected(I2PSession session) {
+            log.severe("I2P session disconnected")
+        }
+
+        @Override
+        public void errorOccurred(I2PSession session, String message, Throwable error) {
+            log.log(Level.SEVERE, message, error)
+        }
+        
+    }
+}

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

@@ -0,0 +1,7 @@
+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")
+}

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

@@ -62,6 +62,11 @@ public class UploadManager {
             }
 
             Request request = Request.parse(new InfoHash(infoHashRoot), e.getInputStream())
+            if (request.downloader != null && request.downloader.destination != e.destination) {
+                log.info("Downloader persona doesn't match their destination")
+                e.close()
+                return
+            }
             Uploader uploader = new Uploader(sharedFiles.iterator().next().file, request, e)
             eventBus.publish(new UploadEvent(uploader : uploader))
             try {

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

@@ -55,21 +55,21 @@ class JULLog extends Log {
 
     @Override
     public boolean shouldDebug() {
-        level.intValue().intValue() >= Level.FINE.intValue()
+        level.intValue().intValue() <= Level.FINE.intValue()
     }
 
     @Override
     public boolean shouldInfo() {
-        level.intValue().intValue() >= Level.INFO.intValue()
+        level.intValue().intValue() <= Level.INFO.intValue()
     }
 
     @Override
     public boolean shouldWarn() {
-        level.intValue().intValue() >= Level.WARNING.intValue()
+        level.intValue().intValue() <= Level.WARNING.intValue()
     }
 
     @Override
     public boolean shouldError() {
-        level.intValue().intValue() >= Level.SEVERE.intValue()
+        level.intValue().intValue() <= Level.SEVERE.intValue()
     }
 }

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

@@ -9,8 +9,8 @@ public class DownloadedFile extends SharedFile {
 	
 	private final Set<Destination> sources;
 
-	public DownloadedFile(File file, InfoHash infoHash, Set<Destination> sources) {
+	public DownloadedFile(File file, InfoHash infoHash, int pieceSize, Set<Destination> sources) {
-		super(file, infoHash);
+		super(file, infoHash, pieceSize);
 		this.sources = sources;
 	}
 	

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

@@ -7,6 +7,7 @@ import java.util.Arrays;
 import java.util.List;
 
 import net.i2p.data.Base32;
+import net.i2p.data.Base64;
 
 public class InfoHash {
 
@@ -76,14 +77,16 @@ public class InfoHash {
 	}
 	
 	public String toString() {
-		String rv = "InfoHash[root:"+Base32.encode(root) + " hashList:";
+		String rv = "InfoHash[root:"+Base64.encode(root) + " hashList:";
-		List<String> b32HashList = new ArrayList<>(hashList.length / SIZE);
+		List<String> b64HashList = new ArrayList<>();
-		byte [] tmp = new byte[SIZE];
+		if (hashList != null) {       
-		for (int i = 0; i < hashList.length / SIZE; i++) {
+		    byte [] tmp = new byte[SIZE];
-			System.arraycopy(hashList, SIZE * i, tmp, 0, SIZE);
+		    for (int i = 0; i < hashList.length / SIZE; i++) {
-			b32HashList.add(Base32.encode(tmp));
+		        System.arraycopy(hashList, SIZE * i, tmp, 0, SIZE);
+		        b64HashList.add(Base64.encode(tmp));
+		    }
 		}
-		rv += b32HashList.toString();
+		rv += b64HashList.toString();
 		rv += "]";
 		return rv;
 	}

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

@@ -6,10 +6,12 @@ public class SharedFile {
 
 	private final File file;
 	private final InfoHash infoHash;
+	private final int pieceSize;
 	
-	public SharedFile(File file, InfoHash infoHash) {
+	public SharedFile(File file, InfoHash infoHash, int pieceSize) {
 		this.file = file;
 		this.infoHash = infoHash;
+		this.pieceSize = pieceSize;
 	}
 
 	public File getFile() {
@@ -20,4 +22,7 @@ public class SharedFile {
 		return infoHash;
 	}
 	
+	public int getPieceSize() {
+	    return pieceSize;
+	}
 }

core/src/test/groovy/com/muwire/core/Personas.groovy

@@ -0,0 +1,11 @@
+package com.muwire.core
+
+import net.i2p.data.Base64
+
+class Personas {
+    private final String encoded1 = "AQADemFiO~pgSoEo8wQfwncYMvBQWkvPY9I7DYUllHp289UE~zBaLdbl~wbliktAUsW-S70f3UeYgHq34~c7zVuUQjgHZ506iG9hX8B9S3a9gQ3CSG0GuDpeNyiXmZkpHp5m8vT9PZ1zMWzxvzZY~fP9yKFKgO4yrso5I9~DGOPeyJZJ4BFsTJDERv41aZqjFLYUBDmeHGgg9RjYy~93h-nQMVYj9JSO3AgowW-ix49rtiKYIXHMa2PxWHUXkUHWJZtIZntNIDEFeMnPdzLxjAl8so2G6pDcTMZPLLwyb73Ee5ZVfxUynPqyp~fIGVP8Rl4rlaGFli2~ATGBz3XY54aObC~0p7us2JnWaTC~oQT5DVDM7gaOO885o-m8BB8b0duzMBelbdnMZFQJ5jIHVKxkC6Niw4fxTOoXTyOqQmVhtK-9xcwxMuN5DF9IewkR5bhpq5rgnfBP5zvyBaAHMq-d3TCOjTsZ-d3liB98xX5p8G5zmS7gfKArQtM5~CcK~AlX-lGLBQAEAAcAAN5MW1Tq983szfZgY1l8tQFqy8I9tdMf7vc1Ktj~TCIvXYw6AYMbMGy3S67FSPLZVmfHEMQKj2KLAdaRKQkHPAY"
+    private final String encoded2 = "AQAHemxhdGluYiN~3G-hPoBfJ04mhcC52lC6TYSwWxH-WNWno9Y35JS-WrXlnPsodZtwy96ttEaiKTg-hkRqMsaYKpWar1FwayR6qlo0pZCo5pQOLfR7GIM3~wde0JIBEp8BUpgzF1-QXLhuRG1t7tBbenW2tSgp5jQH61RI-c9flyUlOvf6nrhQMZ3aoviZ4aZW23Fx-ajYQBDk7PIxuyn8qYNwWy3kWOhGan05c54NnumS3XCzQWFDDPlADmco1WROeY9qrwwtmLM8lzDCEtJQXJlk~K5yLbyB63hmAeTK7J4iS6f9nnWv7TbB5r-Z3kC6D9TLYrQbu3h4AAxrqso45P8yHQtKUA4QJicS-6NJoBOnlCCU887wx2k9YSxxwNydlIxb1mZsX65Ke4uY0HDFokZHTzUcxvfLB6G~5JkSPDCyZz~2fREgW2-VXu7gokEdEugkuZRrsiQzyfAOOkv53ti5MzTbMOXinBskSb1vZyN2-XcZNaDJvEqUNj~qpfhe-ov2F7FuwQUABAAHAAAfqq-MneIqWBQY92-sy9Z0s~iQsq6lUFa~sYMdY-5o-94fF8a140dm-emF3rO8vuidUIPNaS-37Rl05mAKUCcB"
+    
+    Persona persona1 = new Persona(new ByteArrayInputStream(Base64.decode(encoded1)))
+    Persona persona2 = new Persona(new ByteArrayInputStream(Base64.decode(encoded2)))
+}

core/src/test/groovy/com/muwire/core/connection/ConnectionAcceptorTest.groovy

@@ -44,6 +44,9 @@ class ConnectionAcceptorTest {
     def uploadManagerMock
     UploadManager uploadManager
     
+    def connectionEstablisherMock
+    ConnectionEstablisher connectionEstablisher
+	
 	ConnectionAcceptor acceptor
 	List<ConnectionEvent> connectionEvents
 	InputStream inputStream
@@ -57,6 +60,7 @@ class ConnectionAcceptorTest {
 		trustServiceMock = new MockFor(TrustService.class)
         searchManagerMock = new MockFor(SearchManager.class)
         uploadManagerMock = new MockFor(UploadManager.class)
+        connectionEstablisherMock = new MockFor(ConnectionEstablisher.class)
 	}
 	
 	@After
@@ -68,6 +72,7 @@ class ConnectionAcceptorTest {
 		trustServiceMock.verify trustService
         searchManagerMock.verify searchManager
         uploadManagerMock.verify uploadManager
+        connectionEstablisherMock.verify connectionEstablisher
 		Thread.sleep(100)
 	}
 	
@@ -87,8 +92,10 @@ class ConnectionAcceptorTest {
 		trustService = trustServiceMock.proxyInstance()
         searchManager = searchManagerMock.proxyInstance()
         uploadManager = uploadManagerMock.proxyInstance()
+        connectionEstablisher = connectionEstablisherMock.proxyInstance()
 		
-		acceptor = new ConnectionAcceptor(eventBus, connectionManager, settings, i2pAcceptor, hostCache, trustService, searchManager, uploadManager)
+		acceptor = new ConnectionAcceptor(eventBus, connectionManager, settings, i2pAcceptor, 
+            hostCache, trustService, searchManager, uploadManager, connectionEstablisher)
 		acceptor.start()
 		Thread.sleep(100)
 	}
@@ -108,6 +115,7 @@ class ConnectionAcceptorTest {
 			new Endpoint(destinations.dest1, is, os, null)
 		}
 		i2pAcceptorMock.demand.accept { Thread.sleep(Integer.MAX_VALUE) }
+        connectionEstablisherMock.demand.isInProgress(destinations.dest1) { false }
         connectionManagerMock.demand.isConnected { dest ->
             assert dest == destinations.dest1
             false
@@ -150,6 +158,7 @@ class ConnectionAcceptorTest {
 			new Endpoint(destinations.dest1, is, os, null)
 		}
 		i2pAcceptorMock.demand.accept { Thread.sleep(Integer.MAX_VALUE) }
+        connectionEstablisherMock.demand.isInProgress(destinations.dest1) { false }
         connectionManagerMock.demand.isConnected { dest ->
             assert dest == destinations.dest1
             false
@@ -264,6 +273,7 @@ class ConnectionAcceptorTest {
 			new Endpoint(destinations.dest1, is, os, null)
 		}
 		i2pAcceptorMock.demand.accept { Thread.sleep(Integer.MAX_VALUE) }
+        connectionEstablisherMock.demand.isInProgress(destinations.dest1) { false }
         connectionManagerMock.demand.isConnected { dest ->
             assert dest == destinations.dest1
             false
@@ -310,6 +320,7 @@ class ConnectionAcceptorTest {
 			new Endpoint(destinations.dest1, is, os, null)
 		}
 		i2pAcceptorMock.demand.accept { Thread.sleep(Integer.MAX_VALUE) }
+        connectionEstablisherMock.demand.isInProgress(destinations.dest1) { false }
         connectionManagerMock.demand.isConnected { dest ->
             assert dest == destinations.dest1
             false
@@ -356,6 +367,7 @@ class ConnectionAcceptorTest {
 			new Endpoint(destinations.dest1, is, os, null)
 		}
 		i2pAcceptorMock.demand.accept { Thread.sleep(Integer.MAX_VALUE) }
+        connectionEstablisherMock.demand.isInProgress(destinations.dest1) { false }
         connectionManagerMock.demand.isConnected { dest ->
             assert dest == destinations.dest1
             false

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

@@ -15,7 +15,7 @@ class DownloadSessionTest {
     private File source, target
     private InfoHash infoHash
     private Endpoint endpoint
-    private Pieces pieces
+    private Pieces pieces, claimed
     private String rootBase64
     
     private DownloadSession session
@@ -24,7 +24,7 @@ class DownloadSessionTest {
     private InputStream fromDownloader, fromUploader
     private OutputStream toDownloader, toUploader
     
-    private void initSession(int size) {
+    private void initSession(int size, def claimedPieces = []) {
         Random r = new Random()
         byte [] content = new byte[size]
         r.nextBytes(content)
@@ -48,6 +48,8 @@ class DownloadSessionTest {
         else
             nPieces = size / pieceSize + 1
         pieces = new Pieces(nPieces)
+        claimed = new Pieces(nPieces)
+        claimedPieces.each {claimed.markDownloaded(it)}
         
         fromDownloader = new PipedInputStream()
         fromUploader = new PipedInputStream()
@@ -55,7 +57,7 @@ class DownloadSessionTest {
         toUploader = new PipedOutputStream(fromDownloader)
         endpoint = new Endpoint(null, fromUploader, toUploader, null)
         
-        session = new DownloadSession("",pieces, infoHash, endpoint, target, pieceSize, size)
+        session = new DownloadSession("",pieces, claimed, infoHash, endpoint, target, pieceSize, size)
         downloadThread = new Thread( { session.request() } as Runnable)
         downloadThread.setDaemon(true)
         downloadThread.start()
@@ -138,4 +140,29 @@ class DownloadSessionTest {
         assert !pieces.isComplete()
         assert 1 == pieces.donePieces()
     }
+    
+    @Test
+    public void testSmallFileClaimed() {
+        initSession(20, [0])
+        long now = System.currentTimeMillis()
+        downloadThread.join(100)
+        assert 100 > (System.currentTimeMillis() - now)
+    }
+    
+    @Test
+    public void testClaimedPiecesAvoided() {
+        int pieceSize = FileHasher.getPieceSize(1)
+        int size = (1 << pieceSize) * 10
+        initSession(size, [1,2,3,4,5,6,7,8,9])
+        assert !claimed.isMarked(0)
+        
+        assert "GET $rootBase64" == readTillRN(fromDownloader)
+        String range = readTillRN(fromDownloader)
+        def matcher = (range =~ /^Range: (\d+)-(\d+)$/)
+        int start = Integer.parseInt(matcher[0][1])
+        int end = Integer.parseInt(matcher[0][2])
+        
+        assert claimed.isMarked(0)
+        assert start == 0 && end == (1 << pieceSize) - 1
+    }
 }

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

@@ -5,6 +5,7 @@ import org.junit.Test
 
 import com.muwire.core.EventBus
 import com.muwire.core.InfoHash
+import com.muwire.core.MuWireSettings
 import com.muwire.core.SharedFile
 import com.muwire.core.search.ResultsEvent
 import com.muwire.core.search.SearchEvent
@@ -26,7 +27,7 @@ class FileManagerTest {
 	void before() {
 		eventBus = new EventBus()
 		eventBus.register(ResultsEvent.class, listener)
-		manager = new FileManager(eventBus)
+		manager = new FileManager(eventBus, new MuWireSettings())
 		results = null
 	}
 	
@@ -34,7 +35,7 @@ class FileManagerTest {
 	void testHash1Result() {
 		File f = new File("a b.c")
 		InfoHash ih = InfoHash.fromHashList(new byte[32])
-		SharedFile sf = new SharedFile(f,ih)
+		SharedFile sf = new SharedFile(f,ih, 0)
 		FileHashedEvent fhe = new FileHashedEvent(sharedFile: sf)
 		manager.onFileHashedEvent(fhe)
 		
@@ -53,8 +54,8 @@ class FileManagerTest {
 	@Test
 	void testHash2Results() {
 		InfoHash ih = InfoHash.fromHashList(new byte[32])
-		SharedFile sf1 = new SharedFile(new File("a b.c"), ih)
+		SharedFile sf1 = new SharedFile(new File("a b.c"), ih, 0)
-		SharedFile sf2 = new SharedFile(new File("d e.f"), ih)
+		SharedFile sf2 = new SharedFile(new File("d e.f"), ih, 0)
 		manager.onFileLoadedEvent new FileLoadedEvent(loadedFile : sf1)
 		manager.onFileLoadedEvent new FileLoadedEvent(loadedFile : sf2)
 
@@ -75,7 +76,7 @@ class FileManagerTest {
 	void testHash0Results() {
 		File f = new File("a b.c")
 		InfoHash ih = InfoHash.fromHashList(new byte[32])
-		SharedFile sf = new SharedFile(f,ih)
+		SharedFile sf = new SharedFile(f,ih, 0)
 		FileHashedEvent fhe = new FileHashedEvent(sharedFile: sf)
 		manager.onFileHashedEvent(fhe)
 		
@@ -89,7 +90,7 @@ class FileManagerTest {
 	void testKeyword1Result() {
 		File f = new File("a b.c")
 		InfoHash ih = InfoHash.fromHashList(new byte[32])
-		SharedFile sf = new SharedFile(f,ih)
+		SharedFile sf = new SharedFile(f,ih,0)
 		FileHashedEvent fhe = new FileHashedEvent(sharedFile: sf)
 		manager.onFileHashedEvent(fhe)
 		
@@ -107,12 +108,12 @@ class FileManagerTest {
 	void testKeyword2Results() {
 		File f1 = new File("a b.c")
 		InfoHash ih1 = InfoHash.fromHashList(new byte[32])
-		SharedFile sf1 = new SharedFile(f1, ih1)
+		SharedFile sf1 = new SharedFile(f1, ih1, 0)
 		manager.onFileLoadedEvent new FileLoadedEvent(loadedFile: sf1)
 		
 		File f2 = new File("c d.e")
 		InfoHash ih2 = InfoHash.fromHashList(new byte[64])
-		SharedFile sf2 = new SharedFile(f2, ih2)
+		SharedFile sf2 = new SharedFile(f2, ih2, 0)
 		manager.onFileLoadedEvent new FileLoadedEvent(loadedFile: sf2)
 		
 		UUID uuid = UUID.randomUUID()
@@ -130,7 +131,7 @@ class FileManagerTest {
 	void testKeyword0Results() {
 		File f = new File("a b.c")
 		InfoHash ih = InfoHash.fromHashList(new byte[32])
-		SharedFile sf = new SharedFile(f,ih)
+		SharedFile sf = new SharedFile(f,ih,0)
 		FileHashedEvent fhe = new FileHashedEvent(sharedFile: sf)
 		manager.onFileHashedEvent(fhe)
 		
@@ -143,8 +144,8 @@ class FileManagerTest {
 	@Test
 	void testRemoveFileExistingHash() {
 		InfoHash ih = InfoHash.fromHashList(new byte[32])
-		SharedFile sf1 = new SharedFile(new File("a b.c"), ih)
+		SharedFile sf1 = new SharedFile(new File("a b.c"), ih, 0)
-		SharedFile sf2 = new SharedFile(new File("d e.f"), ih)
+		SharedFile sf2 = new SharedFile(new File("d e.f"), ih, 0)
 		manager.onFileLoadedEvent new FileLoadedEvent(loadedFile : sf1)
 		manager.onFileLoadedEvent new FileLoadedEvent(loadedFile : sf2)
 		
@@ -161,12 +162,12 @@ class FileManagerTest {
 	void testRemoveFile() {
 		File f1 = new File("a b.c")
 		InfoHash ih1 = InfoHash.fromHashList(new byte[32])
-		SharedFile sf1 = new SharedFile(f1, ih1)
+		SharedFile sf1 = new SharedFile(f1, ih1, 0)
 		manager.onFileLoadedEvent new FileLoadedEvent(loadedFile: sf1)
 		
 		File f2 = new File("c d.e")
 		InfoHash ih2 = InfoHash.fromHashList(new byte[64])
-		SharedFile sf2 = new SharedFile(f2, ih2)
+		SharedFile sf2 = new SharedFile(f2, ih2, 0)
 		manager.onFileLoadedEvent new FileLoadedEvent(loadedFile: sf2)
 		
 		manager.onFileUnsharedEvent new FileUnsharedEvent(unsharedFile: sf2)

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

@@ -8,6 +8,7 @@ import org.junit.Before
 import org.junit.Test
 
 import com.muwire.core.EventBus
+import com.muwire.core.MuWireSettings
 
 class HasherServiceTest {
 
@@ -24,7 +25,7 @@ class HasherServiceTest {
 	void before() {
         eventBus = new EventBus()
 		hasher = new FileHasher()
-		service = new HasherService(hasher, eventBus)
+		service = new HasherService(hasher, eventBus, new FileManager(eventBus, new MuWireSettings()))
         eventBus.register(FileHashedEvent.class, listener)
 		service.start()
 	}

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

@@ -8,6 +8,7 @@ import com.muwire.core.Destinations
 import com.muwire.core.DownloadedFile
 import com.muwire.core.EventBus
 import com.muwire.core.InfoHash
+import com.muwire.core.MuWireSettings
 import com.muwire.core.SharedFile
 import com.muwire.core.util.DataUtil
 
@@ -31,7 +32,7 @@ class PersisterServiceSavingTest {
 		f = new File("build.gradle")
 		f = f.getCanonicalFile()
 		ih = fh.hashFile(f)
-		fileSource = new FileManager(eventBus) {
+		fileSource = new FileManager(eventBus, new MuWireSettings()) {
 					Map<File, SharedFile> getSharedFiles() {
 						Map<File, SharedFile> rv = new HashMap<>()
 						rv.put(f, sf)
@@ -54,7 +55,7 @@ class PersisterServiceSavingTest {
 	
 	@Test
 	void testSavingSharedFile() {
-		sf = new SharedFile(f, ih)
+		sf = new SharedFile(f, ih, 0)
 		
 		ps = new PersisterService(persisted, eventBus, 100, fileSource)
 		ps.start()
@@ -73,7 +74,7 @@ class PersisterServiceSavingTest {
 	@Test
 	void testSavingDownloadedFile() {
 		Destinations dests = new Destinations()
-		sf = new DownloadedFile(f, ih, new HashSet([dests.dest1, dests.dest2]))
+		sf = new DownloadedFile(f, ih, 0, new HashSet([dests.dest1, dests.dest2]))
 		
 		ps = new PersisterService(persisted, eventBus, 100, fileSource)
 		ps.start()

core/src/test/groovy/com/muwire/core/trust/TrustServiceTest.groovy

@@ -5,14 +5,17 @@ import org.junit.Before
 import org.junit.Test
 
 import com.muwire.core.Destinations
+import com.muwire.core.Persona
+import com.muwire.core.Personas
 
+import net.i2p.data.Base64
 import net.i2p.data.Destination
 
 class TrustServiceTest {
 
 	TrustService service
 	File persistGood, persistBad
-	Destinations dests = new Destinations()
+	Personas personas = new Personas()
 	
 	@Before
 	void before() {
@@ -33,51 +36,50 @@ class TrustServiceTest {
 	
 	@Test
 	void testEmpty() {
-		assert TrustLevel.NEUTRAL == service.getLevel(dests.dest1)
+		assert TrustLevel.NEUTRAL == service.getLevel(personas.persona1.destination)
-		assert TrustLevel.NEUTRAL == service.getLevel(dests.dest2)
+		assert TrustLevel.NEUTRAL == service.getLevel(personas.persona2.destination)
 	}
 	
 	@Test
 	void testOnEvent() {
-		service.onTrustEvent new TrustEvent(level: TrustLevel.TRUSTED, destination: dests.dest1)
+		service.onTrustEvent new TrustEvent(level: TrustLevel.TRUSTED, persona: personas.persona1)
-		service.onTrustEvent new TrustEvent(level: TrustLevel.DISTRUSTED, destination: dests.dest2)
+		service.onTrustEvent new TrustEvent(level: TrustLevel.DISTRUSTED, persona: personas.persona2)
 		
-		assert TrustLevel.TRUSTED == service.getLevel(dests.dest1)
+		assert TrustLevel.TRUSTED == service.getLevel(personas.persona1.destination)
-		assert TrustLevel.DISTRUSTED == service.getLevel(dests.dest2)
+		assert TrustLevel.DISTRUSTED == service.getLevel(personas.persona2.destination)
 	}
 	
 	@Test 
 	void testPersist() {
-		service.onTrustEvent new TrustEvent(level: TrustLevel.TRUSTED, destination: dests.dest1)
+		service.onTrustEvent new TrustEvent(level: TrustLevel.TRUSTED, persona: personas.persona1)
-		service.onTrustEvent new TrustEvent(level: TrustLevel.DISTRUSTED, destination: dests.dest2)
+		service.onTrustEvent new TrustEvent(level: TrustLevel.DISTRUSTED, persona: personas.persona2)
 		
 		Thread.sleep(250)
 		def trusted = new HashSet<>()
 		persistGood.eachLine {
-			trusted.add(new Destination(it))
+			trusted.add(new Persona(new ByteArrayInputStream(Base64.decode(it))))
 		}
 		def distrusted = new HashSet<>()
 		persistBad.eachLine {
-			distrusted.add(new Destination(it))
+			distrusted.add(new Persona(new ByteArrayInputStream(Base64.decode(it))))
 		}
 		
 		assert trusted.size() == 1
-		assert trusted.contains(dests.dest1)
+		assert trusted.contains(personas.persona1)
 		assert distrusted.size() == 1
-		assert distrusted.contains(dests.dest2)
+		assert distrusted.contains(personas.persona2)
 	}
 	
 	@Test
 	void testLoad() {
 		service.stop()
-		persistGood.append("${dests.dest1.toBase64()}\n")
+		persistGood.append("${personas.persona1.toBase64()}\n")
-		persistBad.append("${dests.dest2.toBase64()}\n")
+		persistBad.append("${personas.persona2.toBase64()}\n")
 		service = new TrustService(persistGood, persistBad, 100)
 		service.start()
-		Thread.sleep(10)
+		Thread.sleep(50)
-		
-		assert TrustLevel.TRUSTED == service.getLevel(dests.dest1)
-		assert TrustLevel.DISTRUSTED == service.getLevel(dests.dest2)
 		
+		assert TrustLevel.TRUSTED == service.getLevel(personas.persona1.destination)
+		assert TrustLevel.DISTRUSTED == service.getLevel(personas.persona2.destination)
 	}
 }

doc/infohash-upgrade.md

@@ -0,0 +1,37 @@
+# InfoHash Upgrade
+
+An infohash is a list of hashes of the pieces of the file.  In MuWire 0.1.0 the piece size is determined by policy based on the file size, with the intention being to keep the list of hashes to maximum 128 in number.  The reason for this is that infohashes get returned with search results, and smaller piece size will result in larger infohash which will slow down the transmission of search results.
+
+### The problem
+
+This presents the following problem - larger files have larger piece sizes: a 2GB file will have a 16MB piece size, a 4GB file 32MB and so on.  Pieces are atomic, i.e. if a download fails halfway through a piece it will resume since the beginning of the piece.  Unfortunately in the current state of I2P the failure rate of streaming connections is too high and transmitting an entire piece over a single connection is not likely to succeed as the size of the piece increases.  This makes downloading multi-gigabyte files nearly impossible.
+
+### Out-of-band request proposal
+
+Barring any improvement to the reliability of I2P connections, the following approach can be used to enable smaller piece sizes and the corresponding increase in download success rate of large files:
+
+* Search results do carry the full infohash of the file, instead they carry just the root and the number of 32-byte hashes in the infohash
+* When a downloader begins a download, it issues a request for the full infohash first.  Only after that is fetched and verified, the download proceeds as usual.
+
+Such approach is more complicated in nature than the current simplistic one, but it has the additional benefit of reducing the size of search results.
+
+### Wire protocol changes
+
+A new request method - "HASHLIST" is introduced.  It is immediately followed by the Base64 encoded root of the infohash and '\r\n'.  The request may contain HTTP headers in the same format as in HTTP 1.1.  One such header may be the X-Persona header, but that is optional.  After all the headers a blank line with just '\r\n' is sent.
+
+The response is identical to that of regular GET request, with the same response codes.  The response may also carry headers, and is also followed by a blank line with '\r\n'.  What follows immediately after that is a binary representation of the hashlist.  After sending the full hashlist, the uploader keeps the connection open in anticipation of the first content GET request.
+
+The downloader verifies the hashlist by hashing it with SHA256 and comparing it to the advertised infohash root.  If there is a match, it proceeds with the rest of the download as in MuWire 0.1.0.
+
+### Necessary changes to MuWire 0.1.0
+
+To accommodate this proposal in a backwards compatible manner, it is necessary to first de-hardcode the piece count computation logic which is currently hardcoded in a few places.  Then it is necessary to:
+
+* persist the piece size to disk when a file is being shared so that it can be returned in search results
+* search queries need to carry a flag of some kind that indicates support for out-of-band infohash support
+  * that in turn requires nodes to support passing of that flag as the queries are being routed through the network
+* the returned results need to indicate whether they are returning a full infohash or just a root; the "version" field in the json can be used for that
+
+### Roadmap
+
+Support for this proposal is currently intended for MuWire 0.2.0.  However, in order to make rollout smooth, in MuWire 0.1.1 support for the first two items will be introduced.  Since there already are users on the network who have shared files without persisting the size of their pieces on disk, those files will not be eligible to participate in this scheme unless re-shared (which implies re-hashing).

gradle.properties

@@ -1,5 +1,5 @@
 group         = com.muwire
-version       = 0.0.5
+version       = 0.1.0
 groovyVersion = 2.4.15
 slf4jVersion  = 1.7.25
 spockVersion  = 1.1-groovy-2.4

gui/build.gradle

@@ -41,6 +41,7 @@ griffon {
 }
 
 mainClassName = 'com.muwire.gui.Launcher'
+applicationDefaultJvmArgs = ['-Djava.util.logging.config.file=logging.properties']
 
 apply from: 'gradle/publishing.gradle'
 apply from: 'gradle/code-coverage.gradle'

gui/griffon-app/conf/Config.groovy

@@ -21,4 +21,9 @@ mvcGroups {
         view = 'com.muwire.gui.SearchTabView'
         controller = 'com.muwire.gui.SearchTabController'
     }
+    'Options' {
+        model = 'com.muwire.gui.OptionsModel'
+        view = 'com.muwire.gui.OptionsView'
+        controller = 'com.muwire.gui.OptionsController'
+    }
 }

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

@@ -7,6 +7,8 @@ import griffon.core.mvc.MVCGroup
 import griffon.core.mvc.MVCGroupConfiguration
 import griffon.inject.MVCMember
 import griffon.metadata.ArtifactProviderFor
+import net.i2p.data.Base64
+
 import javax.annotation.Nonnull
 import javax.inject.Inject
 
@@ -43,11 +45,34 @@ class MainFrameController {
         def group = mvcGroup.createMVCGroup("SearchTab", uuid.toString(), params)
         model.results[uuid.toString()] = group
 
-        // this can be improved a lot
+        def searchEvent
-        def terms = search.toLowerCase().trim().split(Constants.SPLIT_PATTERN)
+        if (model.hashSearch) {
-        def searchEvent = new SearchEvent(searchTerms : terms, uuid : uuid)
+            searchEvent = new SearchEvent(searchHash : Base64.decode(search), uuid : uuid)
+        } else {
+            // this can be improved a lot
+            def replaced = search.toLowerCase().trim().replaceAll(Constants.SPLIT_PATTERN, " ")
+            def terms = replaced.split(" ")
+            searchEvent = new SearchEvent(searchTerms : terms, uuid : uuid, oobInfohash: false)
+        }
         core.eventBus.publish(new QueryEvent(searchEvent : searchEvent, firstHop : true, 
-            replyTo: core.me.destination, receivedOn: core.me.destination))
+            replyTo: core.me.destination, receivedOn: core.me.destination,
+            originator : core.me))
+    }
+    
+    void search(String infoHash, String tabTitle) {
+        def cardsPanel = builder.getVariable("cards-panel")
+        cardsPanel.getLayout().show(cardsPanel, "search window")
+        def uuid = UUID.randomUUID()
+        Map<String, Object> params = new HashMap<>()
+        params["search-terms"] = tabTitle
+        params["uuid"] = uuid.toString()
+        def group = mvcGroup.createMVCGroup("SearchTab", uuid.toString(), params)
+        model.results[uuid.toString()] = group
+        
+        def searchEvent = new SearchEvent(searchHash : Base64.decode(infoHash), uuid:uuid)
+        core.eventBus.publish(new QueryEvent(searchEvent : searchEvent, firstHop : true,
+            replyTo: core.me.destination, receivedOn: core.me.destination,
+            originator : core.me))
     }
     
     private def selectedResult() {
@@ -70,8 +95,15 @@ class MainFrameController {
         def result = selectedResult()
         if (result == null)
             return // TODO disable button
+            
         def file = new File(application.context.get("muwire-settings").downloadLocation, result.name)
-        core.eventBus.publish(new UIDownloadEvent(result : result, target : file))
+        
+        def selected = builder.getVariable("result-tabs").getSelectedComponent()
+        def group = selected.getClientProperty("mvc-group")
+        
+        def resultsBucket = group.model.hashBucket[result.infohash]
+         
+        core.eventBus.publish(new UIDownloadEvent(result : resultsBucket, target : file))
     }
     
     @ControllerAction
@@ -129,6 +161,16 @@ class MainFrameController {
         markTrust("trusted-table", TrustLevel.NEUTRAL, model.trusted)
     }
     
+    @ControllerAction
+    void keywordSearch() {
+        model.hashSearch = false
+    }
+    
+    @ControllerAction
+    void hashSearch() {
+        model.hashSearch = true
+    }
+    
     void mvcGroupInit(Map<String, String> args) {
         application.addPropertyChangeListener("core", {e-> 
             core = e.getNewValue()

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

@@ -0,0 +1,77 @@
+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 OptionsController {
+    @MVCMember @Nonnull
+    OptionsModel model
+    @MVCMember @Nonnull
+    OptionsView view
+
+    @ControllerAction
+    void save() {
+        String text
+        Core core = application.context.get("core")
+        
+        def i2pProps = core.i2pOptions
+        
+        text = view.inboundLengthField.text
+        model.inboundLength = text
+        i2pProps["inbound.length"] = text
+        
+        text = view.inboundQuantityField.text
+        model.inboundQuantity = text
+        i2pProps["inbound.quantity"] = text
+        
+        text = view.outboundQuantityField.text
+        model.outboundQuantity = text
+        i2pProps["outbound.quantity"] = text
+        
+        text = view.outboundLengthField.text
+        model.outboundLength = text
+        i2pProps["outbound.length"] = text
+        
+        File i2pSettingsFile = new File(core.home, "i2p.properties")
+        i2pSettingsFile.withOutputStream { 
+            i2pProps.store(it,"")
+        }
+                
+        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 shareDownloaded = view.shareDownloadedCheckbox.model.isSelected()
+        model.shareDownloadedFiles = shareDownloaded
+        settings.shareDownloadedFiles = shareDownloaded
+                        
+        File settingsFile = new File(core.home, "MuWire.properties")
+        settingsFile.withOutputStream { 
+            settings.write(it)
+        }
+        
+        cancel()
+    }
+    
+    @ControllerAction
+    void cancel() {
+        view.d.setVisible(false)
+        mvcGroup.destroy()
+    }
+}

gui/griffon-app/lifecycle/Initialize.groovy

@@ -8,6 +8,7 @@ import com.muwire.core.MuWireSettings
 
 import javax.annotation.Nonnull
 import javax.inject.Inject
+import javax.swing.JTable
 
 import static griffon.util.GriffonApplicationUtils.isMacOSX
 import static groovy.swing.SwingBuilder.lookAndFeel

gui/griffon-app/lifecycle/Ready.groovy

@@ -1,5 +1,7 @@
 import griffon.core.GriffonApplication
+import griffon.core.env.Metadata
 import groovy.util.logging.Log
+import net.i2p.util.SystemVersion
 
 import org.codehaus.griffon.runtime.core.AbstractLifecycleHandler
 
@@ -20,6 +22,9 @@ import java.util.logging.Level
 
 @Log
 class Ready extends AbstractLifecycleHandler {
+    
+    @Inject Metadata metadata
+    
     @Inject
     Ready(@Nonnull GriffonApplication application) {
         super(application)
@@ -30,13 +35,13 @@ class Ready extends AbstractLifecycleHandler {
         log.info "starting core services"
         def portableHome = System.getProperty("portable.home")
         def home = portableHome == null ? 
-            System.getProperty("user.home") + File.separator + ".MuWire" :
+            selectHome() :
             portableHome
             
         home = new File(home)
         if (!home.exists()) {
-            log.info("creating home dir")
+            log.info("creating home dir $home")
-            home.mkdir()
+            home.mkdirs()
         }
         
         def props = new Properties()
@@ -90,9 +95,10 @@ class Ready extends AbstractLifecycleHandler {
                 props.write(it)
             }
         }
+        
         Core core
         try {
-            core = new Core(props, home)
+            core = new Core(props, home, metadata["application.version"])
         } catch (Exception bad) {
             log.log(Level.SEVERE,"couldn't initialize core",bad)
             JOptionPane.showMessageDialog(null, "Couldn't connect to I2P router.  Make sure I2P is running and restart MuWire",
@@ -112,5 +118,25 @@ class Ready extends AbstractLifecycleHandler {
             }
         }
     }
+    
+    private static String selectHome() {
+        def home = new File(System.properties["user.home"])
+        def defaultHome = new File(home, ".MuWire")
+        if (defaultHome.exists())
+            return defaultHome.getAbsolutePath()
+        if (SystemVersion.isMac()) { 
+            def library = new File(home, "Library")
+            def appSupport = new File(library, "Application Support")
+            def muwire = new File(appSupport,"MuWire")
+            return muwire.getAbsolutePath()
+        }
+        if (SystemVersion.isWindows()) {
+            def appData = new File(home,"AppData")
+            def roaming = new File(appData, "Roaming")
+            def muwire = new File(roaming, "MuWire")
+            return muwire.getAbsolutePath()
+        }
+        defaultHome.getAbsolutePath()
+    }
 }
 

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

@@ -4,15 +4,18 @@ import java.util.concurrent.ConcurrentHashMap
 
 import javax.annotation.Nonnull
 import javax.inject.Inject
+import javax.swing.JOptionPane
 import javax.swing.JTable
 
 import com.muwire.core.Core
 import com.muwire.core.InfoHash
+import com.muwire.core.Persona
 import com.muwire.core.connection.ConnectionAttemptStatus
 import com.muwire.core.connection.ConnectionEvent
 import com.muwire.core.connection.DisconnectionEvent
 import com.muwire.core.download.DownloadStartedEvent
 import com.muwire.core.download.Downloader
+import com.muwire.core.files.FileDownloadedEvent
 import com.muwire.core.files.FileHashedEvent
 import com.muwire.core.files.FileLoadedEvent
 import com.muwire.core.files.FileSharedEvent
@@ -20,11 +23,13 @@ import com.muwire.core.search.QueryEvent
 import com.muwire.core.search.UIResultEvent
 import com.muwire.core.trust.TrustEvent
 import com.muwire.core.trust.TrustService
+import com.muwire.core.update.UpdateAvailableEvent
 import com.muwire.core.upload.UploadEvent
 import com.muwire.core.upload.UploadFinishedEvent
 
 import griffon.core.GriffonApplication
 import griffon.core.artifact.GriffonModel
+import griffon.core.env.Metadata
 import griffon.core.mvc.MVCGroup
 import griffon.inject.MVCMember
 import griffon.transform.FXObservable
@@ -34,8 +39,11 @@ import griffon.metadata.ArtifactProviderFor
 
 @ArtifactProviderFor(GriffonModel)
 class MainFrameModel {
+    @Inject Metadata metadata
     @MVCMember @Nonnull
     FactoryBuilderSupport builder
+    @MVCMember @Nonnull
+    MainFrameController controller
     @Inject @Nonnull GriffonApplication application
     @Observable boolean coreInitialized = false
     
@@ -48,6 +56,8 @@ class MainFrameModel {
     def trusted = []
     def distrusted = []
     
+    boolean hashSearch
+    
     @Observable int connections
     @Observable String me
     @Observable boolean searchButtonsEnabled
@@ -58,6 +68,8 @@ class MainFrameModel {
 
     volatile Core core    
 
+    private long lastRetryTime = System.currentTimeMillis()
+        
     void updateTablePreservingSelection(String tableName) {
         def downloadTable = builder.getVariable(tableName)
         int selectedRow = downloadTable.getSelectedRow()
@@ -94,19 +106,29 @@ class MainFrameModel {
             core.eventBus.register(UploadFinishedEvent.class, this)
             core.eventBus.register(TrustEvent.class, this)
             core.eventBus.register(QueryEvent.class, this)
+            core.eventBus.register(UpdateAvailableEvent.class, this)
+            core.eventBus.register(FileDownloadedEvent.class, this)
             
-            int retryInterval = application.context.get("muwire-settings").downloadRetryInterval
+            timer.schedule({
-            if (retryInterval > 0) {
+                int retryInterval = application.context.get("muwire-settings").downloadRetryInterval
-                retryInterval *= 60000
+                if (retryInterval > 0) {
-                timer.schedule({
+                    retryInterval *= 60000
-                    runInsideUIAsync {
+                    long now = System.currentTimeMillis()
-                        downloads.each {
+                    if (now - lastRetryTime > retryInterval) {
-                            if (it.downloader.currentState == Downloader.DownloadState.FAILED)
+                        lastRetryTime = now
-                                it.downloader.resume()
+                        runInsideUIAsync {
+                            downloads.each {
+                                def state = it.downloader.currentState
+                                if (state == Downloader.DownloadState.FAILED || 
+                                    state == Downloader.DownloadState.DOWNLOADING)
+                                    it.downloader.resume()
+                                updateTablePreservingSelection("downloads-table")
+                            }
                         }
+
                     }
-                }, retryInterval, retryInterval)
+                }
-            }
+            }, 60000, 60000)
             
             runInsideUIAsync {
                 trusted.addAll(core.trustService.good.values())
@@ -228,11 +250,40 @@ class MainFrameModel {
         if (search.trim().size() == 0)
             return
         runInsideUIAsync {
-            searches.addFirst(search)
+            searches.addFirst(new IncomingSearch(search : search, replyTo : e.replyTo, originator : e.originator))
             while(searches.size() > 200)
                 searches.removeLast()
             JTable table = builder.getVariable("searches-table")
             table.model.fireTableDataChanged()
         }
     }
+    
+    class IncomingSearch {
+        String search
+        Destination replyTo
+        Persona originator
+    }
+    
+    void onUpdateAvailableEvent(UpdateAvailableEvent e) {
+        runInsideUIAsync {
+            
+            int option = JOptionPane.showConfirmDialog(null, 
+                "MuWire $e.version is available from $e.signer.  You have "+ metadata["application.version"]+" Update?",
+                "New MuWire version availble", JOptionPane.OK_CANCEL_OPTION)
+            if (option == JOptionPane.CANCEL_OPTION)
+                return
+            controller.search(e.infoHash,"MuWire update")
+        }
+    }
+    
+    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()
+        }
+    }
 }

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

@@ -0,0 +1,36 @@
+package com.muwire.gui
+
+import com.muwire.core.Core
+import com.muwire.core.MuWireSettings
+
+import griffon.core.artifact.GriffonModel
+import griffon.transform.Observable
+import griffon.metadata.ArtifactProviderFor
+
+@ArtifactProviderFor(GriffonModel)
+class OptionsModel {
+    @Observable String downloadRetryInterval 
+    @Observable String updateCheckInterval
+    @Observable boolean onlyTrusted
+    @Observable boolean shareDownloadedFiles
+    
+    // i2p options
+    @Observable String inboundLength
+    @Observable String inboundQuantity
+    @Observable String outboundLength
+    @Observable String outboundQuantity
+    
+    void mvcGroupInit(Map<String, String> args) {
+        MuWireSettings settings = application.context.get("muwire-settings")
+        downloadRetryInterval = settings.downloadRetryInterval
+        updateCheckInterval = settings.updateCheckInterval
+        onlyTrusted = !settings.allowUntrusted()
+        shareDownloadedFiles = settings.shareDownloadedFiles
+        
+        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"]
+    }
+}

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

@@ -21,6 +21,7 @@ class SearchTabModel {
     Core core
     String uuid
     def results = []
+    def hashBucket = [:]
     
     
     void mvcGroupInit(Map<String, String> args) {
@@ -34,6 +35,13 @@ class SearchTabModel {
     
     void handleResult(UIResultEvent e) {
         runInsideUIAsync {
+            def bucket = hashBucket.get(e.infohash)
+            if (bucket == null) {
+                bucket = []
+                hashBucket[e.infohash] = bucket
+            }
+            bucket << e
+                            
             results << e
             JTable table = builder.getVariable("results-table")
             table.model.fireTableDataChanged()

gui/griffon-app/views/com/muwire/gui/MainFrameView.groovy

@@ -3,16 +3,20 @@ package com.muwire.gui
 import griffon.core.artifact.GriffonView
 import griffon.inject.MVCMember
 import griffon.metadata.ArtifactProviderFor
+import net.i2p.data.DataHelper
 
 import javax.swing.BorderFactory
 import javax.swing.Box
 import javax.swing.BoxLayout
 import javax.swing.JFileChooser
+import javax.swing.JLabel
 import javax.swing.JSplitPane
 import javax.swing.ListSelectionModel
 import javax.swing.SwingConstants
 import javax.swing.border.Border
+import javax.swing.table.DefaultTableCellRenderer
 
+import com.muwire.core.Constants
 import com.muwire.core.download.Downloader
 import com.muwire.core.files.FileSharedEvent
 
@@ -44,6 +48,11 @@ class MainFrameView {
                 imageIcon('/griffon-icon-16x16.png').image],
             pack : false,
             visible : bind { model.coreInitialized }) {
+                menuBar {
+                    menu (text : "Options") {
+                        menuItem("Configuration", actionPerformed : {mvcGroup.createMVCGroup("Options")})
+                    }
+                }
                 borderLayout()
                 panel (border: etchedBorder(), constraints : BorderLayout.NORTH) {
                     borderLayout()
@@ -67,6 +76,12 @@ class MainFrameView {
 
                             }
                             panel( constraints: BorderLayout.EAST) {
+                                panel {
+                                    buttonGroup(id : "searchButtonGroup") 
+                                    radioButton(text : "Keywords", selected : true, buttonGroup : searchButtonGroup, keywordSearchAction)
+                                    radioButton(text : "Hash", selected : false, buttonGroup : searchButtonGroup, hashSearchAction)
+                                    
+                                }
                                 button(text: "Search", searchAction)
                             }
                         }
@@ -90,19 +105,18 @@ class MainFrameView {
                             panel (constraints : JSplitPane.BOTTOM) {
                                 borderLayout()
                                 scrollPane (constraints : BorderLayout.CENTER) {
-                                    table(id : "downloads-table") {
+                                    table(id : "downloads-table", autoCreateRowSorter : true) {
                                         tableModel(list: model.downloads) {
-                                            closureColumn(header: "Name", type: String, read : {row -> row.downloader.file.getName()})
+                                            closureColumn(header: "Name", preferredWidth: 350, type: String, read : {row -> row.downloader.file.getName()})
-                                            closureColumn(header: "Status", type: String, read : {row -> row.downloader.getCurrentState()})
+                                            closureColumn(header: "Status", preferredWidth: 50, type: String, read : {row -> row.downloader.getCurrentState()})
-                                            closureColumn(header: "Progress", type: String, read: { row ->
+                                            closureColumn(header: "Progress", preferredWidth: 20, type: String, read: { row ->
                                                 int pieces = row.downloader.nPieces
                                                 int done = row.downloader.donePieces()
                                                 "$done/$pieces pieces"
                                             })
-                                            closureColumn(header: "Piece", type: String, read: { row ->
+                                            closureColumn(header: "Sources", preferredWidth : 10, type: Integer, read : {row -> row.downloader.activeWorkers()})
-                                                int position = row.downloader.positionInPiece()
+                                            closureColumn(header: "Speed", preferredWidth: 50, type:String, read :{row -> 
-                                                int pieceSize = row.downloader.pieceSize // TODO: fix for last piece
+                                                DataHelper.formatSize2Decimal(row.downloader.speed(), false) + "B/sec"
-                                                "$position/$pieceSize bytes"
                                             })
                                         }
                                     }
@@ -122,10 +136,11 @@ class MainFrameView {
                                 button(text : "Click here to share files", actionPerformed : shareFiles)
                             }
                             scrollPane ( constraints : BorderLayout.CENTER) {
-                                table(id : "shared-files-table") {
+                                table(id : "shared-files-table", autoCreateRowSorter: true) {
                                      tableModel(list : model.shared) {
-                                         closureColumn(header : "Name", type : String, read : {row -> row.file.getAbsolutePath()})
+                                         closureColumn(header : "Name", preferredWidth : 550, type : String, read : {row -> row.file.getAbsolutePath()})
-                                         closureColumn(header : "Size", type : Long, read : {row -> row.file.length()})
+                                         closureColumn(header : "Size", preferredWidth : 50, type : String, 
+                                             read : {row -> DataHelper.formatSize2Decimal(row.file.length(),false) + "B"})
                                      }   
                                 }
                             }
@@ -177,7 +192,17 @@ class MainFrameView {
                             scrollPane(constraints : BorderLayout.CENTER) {
                                 table(id : "searches-table") {
                                     tableModel(list : model.searches) {
-                                        closureColumn(header : "Keywords", type : String, read : { it })
+                                        closureColumn(header : "Keywords", type : String, read : { 
+                                            sanitized = it.search.replace('<', ' ')
+                                            sanitized 
+                                        })
+                                        closureColumn(header : "From", type : String, read : {
+                                            if (it.originator != null) {
+                                                return it.originator.getHumanReadableName()
+                                            } else {
+                                                return it.replyTo.toBase32()
+                                            }
+                                        })
                                     }
                                 }
                             }
@@ -188,7 +213,7 @@ class MainFrameView {
                         panel (border : etchedBorder()){
                             borderLayout()
                             scrollPane(constraints : BorderLayout.CENTER) {
-                                table(id : "trusted-table") {
+                                table(id : "trusted-table", autoCreateRowSorter : true) {
                                     tableModel(list : model.trusted) {
                                         closureColumn(header : "Trusted Users", type : String, read : { it.getHumanReadableName() } )
                                     }
@@ -203,7 +228,7 @@ class MainFrameView {
                         panel (border : etchedBorder()){
                             borderLayout()
                             scrollPane(constraints : BorderLayout.CENTER) {
-                                table(id : "distrusted-table") {
+                                table(id : "distrusted-table", autoCreateRowSorter : true) {
                                     tableModel(list : model.distrusted) {
                                         closureColumn(header: "Distrusted Users", type : String, read : { it.getHumanReadableName() } )
                                     }
@@ -252,6 +277,10 @@ class MainFrameView {
                 model.retryButtonEnabled = false
             }
         })
+        
+        def centerRenderer = new DefaultTableCellRenderer()
+        centerRenderer.setHorizontalAlignment(JLabel.CENTER)
+        builder.getVariable("downloads-table").setDefaultRenderer(Integer.class, centerRenderer)
     }
 
     def showSearchWindow = {

gui/griffon-app/views/com/muwire/gui/OptionsView.groovy

@@ -0,0 +1,103 @@
+package com.muwire.gui
+
+import griffon.core.artifact.GriffonView
+import griffon.inject.MVCMember
+import griffon.metadata.ArtifactProviderFor
+
+import javax.swing.JDialog
+import javax.swing.JPanel
+import javax.swing.JTabbedPane
+import javax.swing.SwingConstants
+
+import java.awt.BorderLayout
+import java.awt.event.WindowAdapter
+import java.awt.event.WindowEvent
+
+import javax.annotation.Nonnull
+
+@ArtifactProviderFor(GriffonView)
+class OptionsView {
+    @MVCMember @Nonnull
+    FactoryBuilderSupport builder
+    @MVCMember @Nonnull
+    OptionsModel model
+
+    def d
+    def p
+    def i
+    def retryField
+    def updateField
+    def allowUntrustedCheckbox
+    def shareDownloadedCheckbox
+    
+    def inboundLengthField
+    def inboundQuantityField
+    def outboundLengthField
+    def outboundQuantityField
+
+    def buttonsPanel    
+    
+    def mainFrame
+    
+    void initUI() {
+        mainFrame = application.windowManager.findWindow("main-frame")
+        d = new JDialog(mainFrame, "Options", true)
+        d.setResizable(false)
+        p = builder.panel {
+            gridBagLayout()
+            label(text : "Retry failed downloads every", constraints : gbc(gridx: 0, gridy: 0))
+            retryField = textField(text : bind { model.downloadRetryInterval }, columns : 2, constraints : gbc(gridx: 1, gridy: 0))
+            label(text : "minutes", constraints : gbc(gridx : 2, gridy: 0))
+            
+            label(text : "Check for updates every", constraints : gbc(gridx : 0, gridy: 1))
+            updateField = textField(text : bind {model.updateCheckInterval }, columns : 2, constraints : gbc(gridx : 1, gridy: 1))
+            label(text : "hours", constraints : gbc(gridx: 2, gridy : 1))
+
+            label(text : "Allow only trusted connections", constraints : gbc(gridx: 0, gridy : 2))
+            allowUntrustedCheckbox = checkBox(selected : bind {model.onlyTrusted}, constraints : gbc(gridx: 1, gridy : 2))
+            
+            label(text : "Share downloaded files", constraints : gbc(gridx : 0, gridy:3))
+            shareDownloadedCheckbox = checkBox(selected : bind {model.shareDownloadedFiles}, constraints : gbc(gridx :1, gridy:3))
+                        
+        }
+        i = builder.panel {
+            gridBagLayout()
+            label(text : "Changing these settings requires a restart", constraints : gbc(gridx : 0, gridy : 0, gridwidth: 2))
+            label(text : "Inbound Length", constraints : gbc(gridx:0, gridy:1))
+            inboundLengthField = textField(text : bind {model.inboundLength}, columns : 2, constraints : gbc(gridx:1, gridy:1))
+            label(text : "Inbound Quantity", constraints : gbc(gridx:0, gridy:2))
+            inboundQuantityField = textField(text : bind {model.inboundQuantity}, columns : 2, constraints : gbc(gridx:1, gridy:2))
+            label(text : "Outbound Length", constraints : gbc(gridx:0, gridy:3))
+            outboundLengthField = textField(text : bind {model.outboundLength}, columns : 2, constraints : gbc(gridx:1, gridy:3))
+            label(text : "Outbound Quantity", constraints : gbc(gridx:0, gridy:4))
+            outboundQuantityField = textField(text : bind {model.outboundQuantity}, columns : 2, constraints : gbc(gridx:1, gridy:4))
+        }
+        buttonsPanel = builder.panel {
+            gridBagLayout()
+            button(text : "Save", constraints : gbc(gridx : 1, gridy: 2), saveAction)
+            button(text : "Cancel", constraints : gbc(gridx : 2, gridy: 2), cancelAction)
+        }
+    }
+    
+    void mvcGroupInit(Map<String,String> args) {
+        def tabbedPane = new JTabbedPane()
+        tabbedPane.addTab("MuWire Options", p)
+        tabbedPane.addTab("I2P Options", i)
+                
+        JPanel panel = new JPanel()
+        panel.setLayout(new BorderLayout())
+        panel.add(tabbedPane, BorderLayout.CENTER)
+        panel.add(buttonsPanel, BorderLayout.SOUTH)
+                
+        d.getContentPane().add(panel)
+        d.pack()
+        d.setLocationRelativeTo(mainFrame)
+        d.setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE)
+        d.addWindowListener(new WindowAdapter() {
+            public void windowClosed(WindowEvent e) {
+                mvcGroup.destroy()
+            }
+        })
+        d.show()
+    }
+}

gui/griffon-app/views/com/muwire/gui/SearchTabView.groovy

@@ -4,9 +4,12 @@ import griffon.core.artifact.GriffonView
 import griffon.core.mvc.MVCGroup
 import griffon.inject.MVCMember
 import griffon.metadata.ArtifactProviderFor
+import net.i2p.data.DataHelper
 
+import javax.swing.JLabel
 import javax.swing.ListSelectionModel
 import javax.swing.SwingConstants
+import javax.swing.table.DefaultTableCellRenderer
 
 import java.awt.BorderLayout
 
@@ -22,26 +25,31 @@ class SearchTabView {
     def pane 
     def parent
     def searchTerms
+    def resultsTable
     
     void initUI() {
         builder.with {
             def resultsTable
             def pane = scrollPane {
-                resultsTable = table(id : "results-table") {
+                resultsTable = table(id : "results-table", autoCreateRowSorter : true) {
                     tableModel(list: model.results) {
-                        closureColumn(header: "Name", type: String, read : {row -> row.name})
+                        closureColumn(header: "Name", preferredWidth: 350, type: String, read : {row -> row.name.replace('<','_')})
-                        closureColumn(header: "Size", preferredWidth: 150, type: Long, read : {row -> row.size})
+                        closureColumn(header: "Size", preferredWidth: 50, type: String, read : {row -> DataHelper.formatSize2Decimal(row.size, false)+"B"})
-                        closureColumn(header: "Sender", type: String, read : {row -> row.sender.getHumanReadableName()})
+                        closureColumn(header: "Sources", preferredWidth: 10, type : Integer, read : { row -> model.hashBucket[row.infohash].size()})
-                        closureColumn(header: "Trust", type: String, read : {row ->
+                        closureColumn(header: "Sender", preferredWidth: 170, type: String, read : {row -> row.sender.getHumanReadableName()})
+                        closureColumn(header: "Trust", preferredWidth: 50, type: String, read : {row ->
                           model.core.trustService.getLevel(row.sender.destination)
                         })
                     }
                 }
             }
+            
             this.pane = pane
             this.pane.putClientProperty("mvc-group", mvcGroup)
             this.pane.putClientProperty("results-table",resultsTable)
 
+            this.resultsTable = resultsTable
+                        
             def selectionModel = resultsTable.getSelectionModel()
             selectionModel.setSelectionMode(ListSelectionModel.SINGLE_SELECTION)
             selectionModel.addListSelectionListener( {
@@ -54,7 +62,7 @@ class SearchTabView {
         searchTerms = args["search-terms"]
         parent = mvcGroup.parentGroup.view.builder.getVariable("result-tabs")
         parent.addTab(searchTerms, pane)
-        int index = parent.indexOfTab(searchTerms)
+        int index = parent.indexOfComponent(pane)
         parent.setSelectedIndex(index)
         
         def tabPanel
@@ -70,6 +78,12 @@ class SearchTabView {
         }
         
         parent.setTabComponentAt(index, tabPanel)
+        
+        def centerRenderer = new DefaultTableCellRenderer()
+        centerRenderer.setHorizontalAlignment(JLabel.CENTER)
+        resultsTable.columnModel.getColumn(1).setCellRenderer(centerRenderer)
+        resultsTable.setDefaultRenderer(Integer.class,centerRenderer)
+        resultsTable.columnModel.getColumn(4).setCellRenderer(centerRenderer)
     }
     
     def closeTab = {

gui/src/integration-test/groovy/com/muwire/gui/OptionsIntegrationTest.groovy

@@ -0,0 +1,25 @@
+package com.muwire.gui
+
+import griffon.core.test.GriffonFestRule
+import org.fest.swing.fixture.FrameFixture
+import org.junit.Rule
+import org.junit.Test
+
+import static org.junit.Assert.fail
+
+class OptionsIntegrationTest {
+    static {
+        System.setProperty('griffon.swing.edt.violations.check', 'true')
+        System.setProperty('griffon.swing.edt.hang.monitor', 'true')
+    }
+
+    @Rule
+    public final GriffonFestRule fest = new GriffonFestRule()
+
+    private FrameFixture window
+
+    @Test
+    void smokeTest() {
+        fail('Not implemented yet!')
+    }
+}

gui/src/test/groovy/com/muwire/gui/OptionsControllerTest.groovy

@@ -0,0 +1,21 @@
+package com.muwire.gui
+
+import griffon.core.test.GriffonUnitRule
+import griffon.core.test.TestFor
+import org.junit.Rule
+import org.junit.Test
+
+import static org.junit.Assert.fail
+
+@TestFor(OptionsController)
+class OptionsControllerTest {
+    private OptionsController controller
+
+    @Rule
+    public final GriffonUnitRule griffon = new GriffonUnitRule()
+
+    @Test
+    void smokeTest() {
+        fail('Not yet implemented!')
+    }
+}

host-cache/build.gradle

@@ -1,2 +1,3 @@
 apply plugin : 'application'
 mainClassName = 'com.muwire.hostcache.HostCache'
+applicationDefaultJvmArgs = ['-Djava.util.logging.config.file=logging.properties']

host-cache/src/main/groovy/com/muwire/hostcache/Crawler.groovy

@@ -1,9 +1,12 @@
 package com.muwire.hostcache
 
+import java.util.logging.Level
 import java.util.stream.Collectors
 
+import groovy.util.logging.Log
 import net.i2p.data.Destination
 
+@Log
 class Crawler {
 
     final def pinger
@@ -22,12 +25,14 @@ class Crawler {
     
     synchronized def handleCrawlerPong(pong, Destination source) {
         if (!inFlight.containsKey(source)) {
+            log.info("response from host that hasn't been crawled")
             return
         }
         Host host = inFlight.remove(source)
         
         if (pong.uuid == null || pong.leafSlots == null || pong.peerSlots == null || pong.peers == null) {
             hostPool.fail(host)
+            log.info("invalid crawler pong")
             return
         }
         
@@ -40,6 +45,7 @@ class Crawler {
         }
         
         if (!uuid.equals(currentUUID)) {
+            log.info("uuid mismatch")
             hostPool.fail(host)
             return
         }
@@ -50,7 +56,9 @@ class Crawler {
         def peers
         try {
             peers = pong.peers.stream().map({b64 -> new Destination(b64)}).collect(Collectors.toSet())
+            log.info("received ${peers.size()} peers")
         } catch (Exception e) {
+            log.log(Level.WARNING,"couldn't parse peers", e)
             hostPool.fail(host)
             return
         }

host-cache/src/main/groovy/com/muwire/hostcache/HostCache.groovy

@@ -1,9 +1,11 @@
 package com.muwire.hostcache
 
+import java.util.logging.Level
 import java.util.stream.Collectors
 
 import groovy.json.JsonOutput
 import groovy.json.JsonSlurper
+import groovy.util.logging.Log
 import net.i2p.client.I2PClientFactory
 import net.i2p.client.I2PSession
 import net.i2p.client.I2PSessionMuxedListener
@@ -12,6 +14,7 @@ import net.i2p.client.datagram.I2PDatagramMaker
 import net.i2p.util.SystemVersion
 import net.i2p.data.*
 
+@Log
 public class HostCache {
 
     public static void main(String[] args) {
@@ -53,7 +56,7 @@ public class HostCache {
         myDest = session.getMyDestination()
         
 		// initialize hostpool and crawler
-		HostPool hostPool = new HostPool(3, 60 * 1000 * 1000)
+		HostPool hostPool = new HostPool(3, 60 * 60 * 1000)
 		Pinger pinger = new Pinger(session)
 		Crawler crawler = new Crawler(pinger, hostPool, 5)
 		
@@ -64,7 +67,7 @@ public class HostCache {
         session.addMuxedSessionListener(new Listener(hostPool: hostPool, toReturn: 2, crawler: crawler), 
             I2PSession.PROTO_DATAGRAM, I2PSession.PORT_ANY)
         session.connect()
-        println "INFO: connected, going to sleep"
+        log.info("connected, going to sleep")
         Thread.sleep(Integer.MAX_VALUE)
         
     }
@@ -77,16 +80,16 @@ public class HostCache {
         
         void reportAbuse(I2PSession sesison, int severity) {}
         void disconnected(I2PSession session) {
-            println "ERROR: session disconnected, exiting"
+            log.severe("session disconnected, exiting")
             System.exit(1)
         }
         void errorOccurred(I2PSession session, String message, Throwable error) {
-            println "ERROR: ${message} ${error}"
+            log.warning("${message} ${error}")
         }
         void messageAvailable(I2PSession session, int msgId, long size, int proto,
             int fromport, int toport) {
             if (proto != I2PSession.PROTO_DATAGRAM) {
-                println "WARN: received unexpected protocol ${proto}"
+                log.warning("received unexpected protocol ${proto}")
                 return
             }
 
@@ -95,19 +98,19 @@ public class HostCache {
             try {
                 dissector.loadI2PDatagram(payload)
                 def sender = dissector.getSender()
-                println "INFO: Received something from ${sender.toBase32()}"
+                def b32 = sender.toBase32()
                 
                 payload = dissector.getPayload()
                 payload = json.parse(payload)
                 if (payload.type == null) {
-                    println "WARN: type field missing"
+                    log.warning("type field missing from $b32")
                     return
                 }
                 switch(payload.type) {
                     case "Ping" :
-                    println "Ping"
+                    log.info("ping from $b32") 
 					if (payload.leaf == null) {
-						println "WARN: ping didn't specify if leaf"
+						log.warning("ping didn't specify if leaf from $b32")
 						return
 					}
 					payload.leaf = Boolean.parseBoolean(payload.leaf.toString())
@@ -116,14 +119,14 @@ public class HostCache {
 					respond(session, sender, payload)
                     break
                     case "CrawlerPong":
-                    println "CrawlerPong"
+                    log.info("CrawlerPong from $b32")
 					crawler.handleCrawlerPong(payload, sender)
                     break
                     default:
-                    println "WARN: Unexpected message type ${payload.type}, dropping"
+                    log.warning("Unexpected message type ${payload.type}, dropping from $b32")
                 }
             } catch (Exception dfe) {
-                println "WARN: invalid datagram ${dfe}"
+                log.log(Level.WARNING,"invalid datagram", dfe)
             } 
         }
         void messageAvailable(I2PSession session, int msgId, long size) {

settings.gradle

@@ -1,4 +1,6 @@
 include 'pinger'
 include 'host-cache'
+include 'update-server'
 include 'core'
 include 'gui'
+include 'cli'

update-server/build.gradle

@@ -0,0 +1,3 @@
+apply plugin : 'application'
+mainClassName = 'com.muwire.update.UpdateServer'
+applicationDefaultJvmArgs = ['-Djava.util.logging.config.file=logging.properties']

update-server/src/main/groovy/com/muwire/update/UpdateServer.groovy

@@ -0,0 +1,107 @@
+package com.muwire.update
+
+import java.util.logging.Level
+
+import groovy.json.JsonSlurper
+import groovy.util.logging.Log
+import net.i2p.client.I2PClientFactory
+import net.i2p.client.I2PSession
+import net.i2p.client.I2PSessionMuxedListener
+import net.i2p.client.datagram.I2PDatagramDissector
+import net.i2p.client.datagram.I2PDatagramMaker
+
+
+@Log
+class UpdateServer {
+    public static void main(String[] args) {
+        def home = System.getProperty("user.home") + "/.MuWireUpdateServer"
+        home = new File(home)
+        if (!home.exists())
+            home.mkdirs()
+        
+        def keyFile = new File(home, "key.dat")
+        
+        def i2pClientFactory = new I2PClientFactory()
+        def i2pClient = i2pClientFactory.createClient()
+        
+        def myDest
+        def session
+        if (!keyFile.exists()) {
+            def os = new FileOutputStream(keyFile);
+            myDest = i2pClient.createDestination(os)
+            os.close()
+            log.info "No key.dat file was found, so creating a new destination."
+            log.info "This is the destination you want to give out for your new UpdateServer"
+            log.info myDest.toBase64()
+        }
+        
+        def update = new File(home, "update.json")
+        if (!update.exists()) {
+            log.warning("update file doesn't exist, exiting")
+            System.exit(1)
+        }
+        
+        def props = System.getProperties().clone()
+        props.putAt("inbound.nickname", "MuWire UpdateServer")
+        session = i2pClient.createSession(new FileInputStream(keyFile), props)
+        myDest = session.getMyDestination()
+        
+        session.addMuxedSessionListener(new Listener(update), I2PSession.PROTO_DATAGRAM, I2PSession.PORT_ANY)
+        session.connect()
+        log.info("Connected, going to sleep")
+        Thread.sleep(Integer.MAX_VALUE)
+        
+    }
+    
+    static class Listener implements I2PSessionMuxedListener {
+        
+        private final File json
+        private final def slurper = new JsonSlurper()
+        Listener(File json) {
+            this.json = json
+        }
+
+        @Override
+        public void messageAvailable(I2PSession session, int msgId, long size) {
+        }
+
+        @Override
+        public void messageAvailable(I2PSession session, int msgId, long size, int proto, int fromport, int toport) {
+            if (proto != I2PSession.PROTO_DATAGRAM) {
+                log.warning("received uknown protocol $proto")
+                return
+            }
+            
+            def payload = session.receiveMessage(msgId)
+            def dissector = new I2PDatagramDissector()
+            try {
+                dissector.loadI2PDatagram(payload)
+                def sender = dissector.getSender()
+                payload = slurper.parse(dissector.getPayload())
+                log.info("Got an update ping from "+sender.toBase32() + " reported version "+payload?.myVersion)
+                
+                def maker = new I2PDatagramMaker(session)
+                def response = maker.makeI2PDatagram(json.bytes)
+                session.sendMessage(sender, response, I2PSession.PROTO_DATAGRAM, 0, 2)
+            } catch (Exception e) {
+                log.log(Level.WARNING, "exception responding to update request",e)
+            }
+        }
+
+        @Override
+        public void reportAbuse(I2PSession session, int severity) {
+        }
+
+        @Override
+        public void disconnected(I2PSession session) {
+            Log.severe("Disconnected from I2P router")
+            System.exit(1)
+        }
+
+        @Override
+        public void errorOccurred(I2PSession session, String message, Throwable error) {
+            log.log(Level.SEVERE, message, error)
+        }
+        
+    }
+}