0.8.1

and 'c65ae88fa8b668ccd972d6a0bafe7843ea487285'

INSTALL-headless.txt

@@ -3,9 +3,10 @@ Headless I2P installation instructions
 1) java -jar i2pinstall.exe -console       (you've already done this)
 
 This will run the installer in text mode, including running the postinstall.sh
-script, which will start the router and launch a browser.
+script. After that, you may run 'sh i2prouter start'
+which will start the router and attempt to launch a browser.
 
-If you do not have an X server running, the browser launch will fail, and
+If you do not have an X server running, the browser launch will probably fail, and
 you may use:
   lynx http://localhost:7657/index.jsp
 to configure the router.
@@ -13,9 +14,20 @@ to configure the router.
 If you're having trouble, swing by http://forum.i2p2.de/, check the
 website at http://www.i2p2.de/, or get on irc://irc.freenode.net/#i2p
 
+I2P will create and store files and configuration data in the user directory
+~/.i2p/ on Linux and %APPDATA%\I2P\ on Windows. This directory is created
+when I2P is run for the first time. It also creates files in the system
+temporary directory specified by the Java Virtual Machine.
+To change the location of these directories, or to configure I2P to
+put all files in this directory (the so-called "portable" configuration),
+edit the files i2prouter (Linux) and wrapper.config (Linux and Windows)
+where there are comments labeled "PORTABLE". Do this before you
+run I2P for the first time.
+
 To run I2P explicitly:
    (*nix): sh i2prouter start
    (win*): I2P.exe
+   (Platforms unsupported by the wrapper - PPC, ARM, etc): sh runplain.sh
 
 To stop the router (gracefully):
    lynx http://localhost:7657/configservice.jsp ("Shutdown gracefully")

INSTALL.txt

@@ -1,10 +1,18 @@
 I2P source installation instructions
 
+Prerequisites to build from source:
+	Java SDK (preferably Sun) 1.5.0 or higher (1.6 recommended)
+	The SDK must have Pack200 support (java.util.jar.Pack200)
+	Apache Ant 1.7.0 or higher
+	Optional, For multilanguage support: The xgettext, msgfmt, and msgmerge tools installed
+	from the GNU gettext package http://www.gnu.org/software/gettext/
+
 To build and install I2P from source, you must first build
 and package up the appropriate installer by running:
 
   ant pkg
 
+
 This will produce a few key files:
 * install.jar:    the GUI and console installer
 * i2pinstall.exe: the GUI and console installer wrapped for cross-platform execution
@@ -18,9 +26,6 @@ Or run the GUI installer:
 
 Or move the update file into an existing installation directory and restart.
 
-You will need to have ant installed from http://ant.apache.org/
-(1.7.0 or newer)
-
 Supported JVMs:
   Windows: Latest available from http://java.sun.com/ (1.5+ supported)
   Linux:   Latest available from http://java.sun.com/ (1.5+ supported)

LICENSE.txt

@@ -64,6 +64,9 @@ Public domain except as listed below:
    Copyright 2006 Gregory Rubin grrubin@gmail.com
    See licenses/LICENSE-HashCash.txt
 
+   GettextResource from gettext v0.18:
+   Copyright (C) 2001, 2007 Free Software Foundation, Inc.
+   See licenses/LICENSE-LGPLv2.1.txt
 
 
 Router:
@@ -76,16 +79,14 @@ Public domain except as listed below:
    Copyright (C) 2003-2006 Satoshi Konno
    See licenses/LICENSE-UPnP.txt
 
-   XMLPull library used by UPnP:
-   See licenses/LICENSE-Apache2.0.txt
-
    GeoIP data free to use, courtesy http://ip-to-country.webhosting.info/
 
 
 Installer:
-   Launch4j 2.0.RC3:
-   Copyright (C) 2005 Grzegorz Kowal
-   See licenses/LICENSE-GPLv2.txt
+   Launch4j 3.0.1:
+   Copyright (c) 2004, 2008 Grzegorz Kowal
+   See licenses/LICENSE-Launch4j.txt (in binary packages)
+   See installer/lib/launch4j/LICENSE.txt (in source packages)
    The following projects are used by Launch4j...
 	MinGW binutils (http://www.mingw.org/)
 
@@ -141,6 +142,7 @@ Applications:
    I2PSnark:
    Copyright (C) 2003 Mark J. Wielaard
    See licenses/LICENSE-GPLv2.txt
+       Silk icons: See licenses/LICENSE-SilkIcons.txt
 
    I2PTunnel:
    (c) 2003 - 2004 mihi
@@ -177,7 +179,12 @@ Applications:
 
    Router console:
    Public domain.
-   Flag icons public domain, courtesy mjames@gmail.com http://www.famfamfam.com/
+       Flag icons: public domain, courtesy mjames@gmail.com http://www.famfamfam.com/
+       Silk icons: See licenses/LICENSE-SilkIcons.txt
+
+       GeoIP Data:
+       Copyright (c) 2003 Direct Information Pvt. Ltd. All Rights Reserved.
+       See licenses/LICENSE-GeoIP.txt
 
    SAM:
    Public domain.
@@ -206,6 +213,9 @@ The following applications and libraries are not used or bundled in
 binary packages, therefore the licenses are not included in binary
 distributions. See the source package for the additional license information.
 
+   Admin Manager:
+   Public domain
+
    Atalk:
    Public domain
 
@@ -226,3 +236,7 @@ distributions. See the source package for the additional license information.
 
    SAM Python Library:
    Public domain.
+   
+   I2PSnark: 
+   "Man with hat over face" graphic licensed under a Creative Commons 2.0 license.
+   Original photo by Florian Kuhlmann. http://www.flickr.com/photos/floriankuhlmann/3117758155

Makefile.gcj

@@ -5,7 +5,7 @@
 GCJ=gcj #/usr/local/gcc-4.0.2/bin/gcj
 EXTRA_LD_PATH= #/usr/local/gcc-4.0.2/lib
 ANT=ant #/opt/apache-ant-1.6.5/bin/ant
-ANT_TARGET=buildclean
+ANT_TARGET=build2
 NATIVE_DIR=native
 
 ## 
@@ -24,20 +24,22 @@ JAR_BASE=i2p.jar mstreaming.jar streaming.jar
 JAR_CLIENTS=i2ptunnel.jar sam.jar
 JAR_ROUTER=router.jar
 JAR_JBIGI=jbigi.jar
-JAR_XML=xml-apis.jar resolver.jar xercesImpl.jar
 JAR_CONSOLE=\
-            i2psnark.jar \
             javax.servlet.jar \
             commons-el.jar \
             commons-logging.jar \
 	    jasper-runtime.jar \
-            ant-apache-bcel.jar \
-            ant.jar \
             jasper-compiler.jar \
             org.mortbay.jetty.jar \
 	    routerconsole.jar
-JAR_SUCKER=jdom.jar rome-0.7.jar sucker.jar
 LIBI2P_JARS=${JAR_BASE} ${JAR_CLIENTS} ${JAR_ROUTER} ${JAR_JBIGI}
+LIBSAM_JARS=${JAR_BASE} sam.jar
+LIBROUTER_JARS=i2p.jar ${JAR_ROUTER} ${JAR_JBIGI}
+LIBCONSOLE_JARS=${LIBROUTER_JARS} ${JAR_CONSOLE}
+LIBSNARK_JARS=${LIBROUTER_JARS} i2psnark.jar
+# update:
+# similar error with gcj 4.3.3.
+#
 # unfortunately, its not quite ready for most end users, as the
 # ${JAR_CONSOLE} fails to compile with: 
 # org/apache/commons/logging/impl/LogKitLogger.java: In class 'org.apache.commons.logging.impl.LogKitLogger':
@@ -95,7 +97,36 @@ native_shared: libi2p.so
 	@echo "  i2ptunnel will, so it will start all the proxies defined in i2ptunnel.config"
 
 libi2p.so:
-	@echo "* Building libi2p.so"
-	@(cd build ; time ${GCJ} ${OPTIMIZE} -fPIC -fjni -shared -o ../${NATIVE_DIR}/libi2p.so ${LIBI2P_JARS} ; cd .. )
-	@ls -l ${NATIVE_DIR}/libi2p.so
-	@echo "* libi2p.so built"
+	@echo "* Building $@"
+	@(cd build ; time ${GCJ} ${OPTIMIZE} -fPIC -fjni -shared -o ../${NATIVE_DIR}/$@ ${LIBI2P_JARS} ; cd .. )
+	@ls -l ${NATIVE_DIR}/$@
+	@echo "* $@ built"
+
+sam: jars libi2psam.so
+
+libi2psam.so:
+	@echo "* Building $@"
+	@rm -f ${NATIVE_DIR}/$@
+	@(cd build ; time ${GCJ} ${OPTIMIZE} -fPIC -fjni -shared -o ../${NATIVE_DIR}/$@ ${LIBSAM_JARS} ; cd .. )
+	@ls -l ${NATIVE_DIR}/$@
+	@echo "* $@ built"
+
+router: jars libi2prouter.so
+
+libi2prouter.so:
+	@echo "* Building $@"
+	@rm -f ${NATIVE_DIR}/$@
+	@(cd build ; time ${GCJ} ${OPTIMIZE} -fPIC -fjni -shared -o ../${NATIVE_DIR}/$@ ${LIBROUTER_JARS} ; cd .. )
+	@ls -l ${NATIVE_DIR}/$@
+	@echo "* $@ built"
+
+console: jars libi2pconsole.so
+
+# doesn't work, see above
+libi2pconsole.so:
+	@echo "* Building $@"
+	@rm -f ${NATIVE_DIR}/$@
+	@(cd build ; time ${GCJ} ${OPTIMIZE} -fPIC -fjni -shared -o ../${NATIVE_DIR}/$@ ${LIBCONSOLE_JARS} ; cd .. )
+	@ls -l ${NATIVE_DIR}/$@
+	@echo "* $@ built"
+

README.txt

@@ -1,11 +1,14 @@
 Prerequisites to build from source:
 	Java SDK (preferably Sun) 1.5.0 or higher (1.6 recommended)
+	The SDK must have Pack200 support (java.util.jar.Pack200)
 	Apache Ant 1.7.0 or higher
+	Optional, For multilanguage support: The xgettext, msgfmt, and msgmerge tools installed
+	from the GNU gettext package http://www.gnu.org/software/gettext/
 
 To build:
 	ant pkg
 	Run 'ant' with no arguments to see other build options.
-	See http://www.i2p2.de/download.html for installation instructions.
+	See INSTALL.txt or http://www.i2p2.de/download.html for installation instructions.
 
 Documentation:
 	http://www.i2p2.de/

Slackware/i2p-base/doinst.sh

@@ -1,43 +1,155 @@
 #!/bin/sh
+#
+#
+# Now in the future we only need to look for '#I2P' and '#/I2P' 
+# for modifications to rc.local and rc.local_shutdown. 
+# I was a moron for not doing it this way in the first place :-) -- Sponge
+#
+#
+
 touch /etc/rc.d/rc.local
 touch /etc/rc.d/rc.local_shutdown
 
-I2PRCA=`grep -c /etc/rc.d/rc.local -e i2p`
-I2PRCB=`grep -c /etc/rc.d/rc.local_shutdown -e i2p`
-
 echo
+echo -n "Check 1: /etc/rc.d/rc.local "
+I2PRCA=`grep -c /etc/rc.d/rc.local -e '/etc/rc.d/rc.i2p'`
 
 if [ $I2PRCA -eq 0 ] ; then
+	echo '#I2P' >> /etc/rc.d/rc.local
+	echo '( cd /tmp ; rm -Rf i2p-*.tmp )' >> /etc/rc.d/rc.local
 	echo "if [ -x /etc/rc.d/rc.i2p ] ; then" >> /etc/rc.d/rc.local
 	echo "        sh /etc/rc.d/rc.i2p start" >> /etc/rc.d/rc.local
 	echo "fi" >> /etc/rc.d/rc.local
-	echo "/etc/rc.d/rc.local modified."
+	echo '#/I2P' >> /etc/rc.d/rc.local
+	echo "modified."
 else
-	echo "/etc/rc.d/rc.local looks OK"
+	echo -n "looks OK so far,"
+	# Fix old installs, or where people have modified.
+
+	echo -n " Check 1A: "
+	I2PRCC=`grep -c /etc/rc.d/rc.local -e 'i2p-\*\.tmp'`
+
+	if [ $I2PRCC -eq 0 ] ; then
+		DATA=$(cat /etc/rc.d/rc.local | sed -re 's/if \[ -x \/etc\/rc\.d\/rc\.i2p \] ; then/#I2P\n\( cd \/tmp ; rm -Rf i2p-*.tmp \)\nif \[ -x \/etc\/rc.d\/rc.i2p \] ; then/')
+		echo "${DATA}" > /etc/rc.d/rc.local
+		echo -n "additional modifications applied,"
+	else
+		echo -n "looks OK so far,"
+	fi
+
+	echo -n " Check 1B: "
+	I2PRCE=`grep -c /etc/rc.d/rc.local -e 'i2p-\*\.tmp'`
+	if [ $I2PRCE -eq 0 ] ; then
+		DATATOP=$(cat /etc/rc.d/rc.local | sed -n '0,/i2p-\*\.tmp/p' | sed '$d' )
+		DATABOT=$(cat /etc/rc.d/rc.local | sed -n '/i2p-\*\.tmp/,$p' | sed -n '/^fi/,$p' | sed "1d")
+		echo "${DATATOP}" > /etc/rc.d/rc.local
+		echo '#I2P' >> /etc/rc.d/rc.local
+		echo '( cd /tmp ; rm -Rf i2p-*.tmp )' >> /etc/rc.d/rc.local
+		echo "if [ -x /etc/rc.d/rc.i2p ] ; then" >> /etc/rc.d/rc.local
+		echo "        sh /etc/rc.d/rc.i2p start" >> /etc/rc.d/rc.local
+		echo "fi" >> /etc/rc.d/rc.local
+		echo '#/I2P' >> /etc/rc.d/rc.local
+		echo "${DATABOT}" >> /etc/rc.d/rc.local
+		
+		echo -n "additional modifications applied,"
+	else
+		echo -n "looks ok so far,"
+	fi
+	echo -n " Check 1C: "
+	I2PRCF=`grep -c /etc/rc.d/rc.local -e '#/I2P'`
+	if [ $I2PRCF -eq 0 ] ; then
+		DATATOP=$(cat /etc/rc.d/rc.local | sed -n '0,/^#I2P/p' | sed '$d' )
+		DATABOT=$(cat /etc/rc.d/rc.local | sed -n '/^#I2P/,$p' | sed -n '/^fi/,$p' | sed "1d")
+		echo "${DATATOP}" > /etc/rc.d/rc.local
+		echo '#I2P' >> /etc/rc.d/rc.local
+		echo '( cd /tmp ; rm -Rf i2p-*.tmp )' >> /etc/rc.d/rc.local
+		echo "if [ -x /etc/rc.d/rc.i2p ] ; then" >> /etc/rc.d/rc.local
+		echo "        sh /etc/rc.d/rc.i2p start" >> /etc/rc.d/rc.local
+		echo "fi" >> /etc/rc.d/rc.local
+		echo '#/I2P' >> /etc/rc.d/rc.local
+		echo "${DATABOT}" >> /etc/rc.d/rc.local
+
+		echo -n "additional modifications applied,"
+	else
+		echo -n "looks ok so far,"
+	fi
+	echo " Done."
 fi
 
+echo -n "Check 2: /etc/rc.d/rc.local_shutdown "
+I2PRCB=`grep -c /etc/rc.d/rc.local_shutdown -e '/etc/rc.d/rc.i2p'`
 if [ $I2PRCB -eq 0 ] ; then
+	echo "#I2P" >> /etc/rc.d/rc.local_shutdown
 	echo "if [ -x /etc/rc.d/rc.i2p ] ; then" >> /etc/rc.d/rc.local_shutdown
 	echo "        sh /etc/rc.d/rc.i2p stop" >> /etc/rc.d/rc.local_shutdown
 	echo "fi" >> /etc/rc.d/rc.local_shutdown
-	echo "/etc/rc.d/rc.local_shutdown modified."
+	echo "#/I2P" >> /etc/rc.d/rc.local_shutdown
+	echo "modified."
 else
-	echo "/etc/rc.d/rc.local_shutdown looks OK"
+	echo -n "looks OK so far,"
+	# Fix old installs
+
+	echo -n " Check 1A: "
+	I2PRCG=`grep -c /etc/rc.d/rc.local_shutdown -e '#I2P'`
+	if [ $I2PRCG -eq 0 ] ; then
+		DATATOP=$(cat /etc/rc.d/rc.local_shutdown | sed -n '0,/^if \[ -x \/etc\/rc\.d\/rc\.i2p \] ; then/p' | sed '$d' )
+		DATABOT=$(cat /etc/rc.d/rc.local_shutdown | sed -n '/^if \[ -x \/etc\/rc\.d\/rc\.i2p \] ; then/,$p' | sed -n '/^fi/,$p' | sed "1d")
+		echo "${DATATOP}" > /etc/rc.d/rc.local_shutdown
+		echo '#I2P' >> /etc/rc.d/rc.local_shutdown
+		echo "if [ -x /etc/rc.d/rc.i2p ] ; then" >> /etc/rc.d/rc.local_shutdown
+		echo "        sh /etc/rc.d/rc.i2p stop" >> /etc/rc.d/rc.local_shutdown
+		echo "fi" >> /etc/rc.d/rc.local_shutdown
+		echo "#/I2P" >> /etc/rc.d/rc.local_shutdown
+		echo "${DATABOT}" >> /etc/rc.d/rc.local_shutdown
+		echo -n "additional modifications applied,"
+	else
+		echo -n "looks OK so far,"
+	fi
+	echo -n " Check 1B: "
+	I2PRCH=`grep -c /etc/rc.d/rc.local_shutdown -e '#/I2P'`
+	if [ $I2PRCH -eq 0 ] ; then
+		DATATOP=$(cat /etc/rc.d/rc.local_shutdown | sed -n '0,/^#I2P/p' | sed '$d' )
+		DATABOT=$(cat /etc/rc.d/rc.local_shutdown | sed -n '/^#I2P/,$p' | sed -n '/^fi/,$p' | sed "1d")
+		echo "${DATATOP}" > /etc/rc.d/rc.local_shutdown
+		echo '#I2P' >> /etc/rc.d/rc.local_shutdown
+		echo "if [ -x /etc/rc.d/rc.i2p ] ; then" >> /etc/rc.d/rc.local_shutdown
+		echo "        sh /etc/rc.d/rc.i2p stop" >> /etc/rc.d/rc.local_shutdown
+		echo "fi" >> /etc/rc.d/rc.local_shutdown
+		echo "#/I2P" >> /etc/rc.d/rc.local_shutdown
+		echo "${DATABOT}" >> /etc/rc.d/rc.local_shutdown
+		echo -n "additional modifications applied,"
+	else
+		echo -n "looks OK so far,"
+	fi
+	echo " Done."
 fi
 
 if [ -f /etc/rc.d/rc.i2p ] ; then
 	if [ -x /etc/rc.d/rc.i2p ] ; then
 		chmod +x /etc/rc.d/rc.i2p.new
 	fi
-	echo
+	# Hopefully get admin's attention.
+	echo -ne "\007" ; sleep 0.3
+	echo -ne "\007" ; sleep 0.3
+	echo -ne "\007" ; sleep 0.3
+	echo -ne "\007" ; sleep 0.3
+	echo -ne "\007" ; sleep 0.3
+	echo -ne "\007" ; sleep 0.3
+	echo -e "\007" ; sleep 0.3
 	echo "It apears that you already have /etc/rc.d/rc.i2p"
-	echo "You may wish to replace it with /etc/rc.d/rc.i2p.new"
-	echo 
+	echo "You should replace it with /etc/rc.d/rc.i2p.new as soon as possible"
+	echo -ne "\007" ; sleep 0.3
+	echo -ne "\007" ; sleep 0.3
+	echo -ne "\007" ; sleep 0.3
+	echo -ne "\007" ; sleep 0.3
+	echo -ne "\007" ; sleep 0.3
+	echo -ne "\007" ; sleep 0.3
+	echo -e "\007" ; sleep 0.3
 else
 	mv /etc/rc.d/rc.i2p.new /etc/rc.d/rc.i2p
 	echo
 	echo "Installation finished. The i2p start/stop script has been"
-	echo "installed on /etc/rc.d directory. You should chmod +x"
+	echo "installed in /etc/rc.d . You should chmod +x"
 	echo '/etc/rc.d/rc.i2p to start it on boot.'
 	echo
 fi

Slackware/i2p-base/i2p-base.SlackBuild

@@ -1,42 +1,57 @@
 #!/bin/sh
-# Heavily based on the Slackware 12.1 SlackBuild
-# Slackware build script for i2p
-
+#
+# Heavily based on the Slackware 12.2 SlackBuild
+# Slackware build script for I2P
+#
 # PLEASE READ THIS:
-# Probably you will never have to update i2p packages with upgradepkg,
-# just because i2p have an auto-update function.
-# How to start i2p:
-# After installpkg command, doinst.sh will execute a postinstallation script
-# needed by i2p. After that you have to chmod +x /etc/rc.d/rc.i2p and start
-# i2p service with /etc/rc.d/rc.i2p start.
+# How to start I2P:
+# After installpkg command, doinst.sh will execute a post-installation script
+# needed by I2P. After that you have to chmod +x /etc/rc.d/rc.i2p and start
+# I2P service with /etc/rc.d/rc.i2p start.
+#
 # Now tell your browser to user this proxy: localhost on port 4444 and open
 # this page: http://localhost:7657/index.jsp
-# Here you can configure i2p, watch network status and navigate anonimously.
+#
+# Here you can configure I2P, watch network status and navigate anonimously.
 # It's suggested to subscribe to various dns host, like i2host.i2p
 # For any additional information, visit i2host.i2p and forum.i2p
+#
 
 CWD=$(pwd)
 TMP=/tmp
 PKG=/$TMP/package-base-i2p
-rm -rf $PKG
-mkdir -p $PKG
-# put here installation dir, without first and last /
-# es: usr/local
 NAME=i2p-base
-VERSION=0.0.1
-BUILD=1sim
+VERSION=0.0.2
+BUILD=1sponge
 ARCH=noarch
 INSTALL_DIR=opt
+
+# Less than slackware 13?
+SLKPLT=$(cat /etc/slackware-version | sed -re "s/(Slackware )([0-9]*)(.*)/\2/")
+if [ $SLKPLT -lt 13 ] ; then
+	EXT=tgz
+else
+	EXT=txz
+fi
+
+rm -rf $PKG
+mkdir -p $PKG
 cd $PKG
 chown -R root:root .
 
 mkdir -p $PKG/etc/rc.d
 mkdir -p $PKG/install
-sed "s|directory|/$INSTALL_DIR/i2p/i2prouter|g" $CWD/rc.i2p_def > $PKG/etc/rc.d/rc.i2p.new
+sed "s|directory|/$INSTALL_DIR/i2p/i2prouter|g" "$CWD/rc.i2p_def" > $PKG/etc/rc.d/rc.i2p.new
 chmod 644 $PKG/etc/rc.d/rc.i2p.new
-sed "s|directory|/$INSTALL_DIR/i2p/|g" $CWD/doinst.sh > $PKG/install/doinst.sh
-cat $CWD/slack-desc > $PKG/install/slack-desc
+cat "$CWD/doinst.sh" > $PKG/install/doinst.sh
+cat "$CWD/slack-desc" > $PKG/install/slack-desc
 
 cd $PKG
-requiredbuilder -v -y -s $CWD $PKG
-makepkg -l y -c n $CWD/${NAME}-$VERSION-$ARCH-$BUILD.tgz
+#
+# Not really that important to exec this 
+# as there aren't any deps we don't know.
+#
+# requiredbuilder -v -y -s $CWD $PKG
+#
+cat "$CWD/slack-required" > $PKG/install/slack-required
+makepkg -l y -c n $CWD/${NAME}-$VERSION-$ARCH-$BUILD.$EXT

Slackware/i2p-base/rc.i2p_def

@@ -2,11 +2,44 @@
 # Start/stop i2p service.
 
 i2p_start() {
- /bin/su - -c "( export PATH=\"$PATH:/usr/lib/java/bin:/usr/lib/java/jre/bin\"; directory start )"
+ # Check if router is up first!
+ /bin/su - -c "( export PATH=\"$PATH:/usr/lib/java/bin:/usr/lib/java/jre/bin\"; directory status )" > /dev/null
+ if [ ! $? -eq 0 ] ; then {
+  # I2p is already running, so tell the user.
+  echo "I2P is already running..."
+  i2p_status
+ } 
+ else
+ {
+  # Just in-case there are leftover junk in /tmp...
+  rm -Rf `grep /tmp/hsperfdata_root/* -le i2p` /tmp/i2p-*.tmp /tmp/router.ping
+  # Now that all junk is cleaned up, start.
+  /bin/su - -c "( export PATH=\"$PATH:/usr/lib/java/bin:/usr/lib/java/jre/bin\"; directory start )"
+ }
+ fi
 }
 
 i2p_stop() {
  /bin/su - -c "( export PATH=\"$PATH:/usr/lib/java/bin:/usr/lib/java/jre/bin\"; directory stop )"
+ rm -Rf `grep /tmp/hsperfdata_root/* -le i2p` /tmp/i2p-*.tmp /tmp/router.ping
+}
+
+i2p_restart() {
+ # We want a FULL cycle here, not the wrappers idea of this!
+ i2p_stop
+ i2p_start
+}
+
+i2p_status() {
+ /bin/su - -c "( export PATH=\"$PATH:/usr/lib/java/bin:/usr/lib/java/jre/bin\"; directory status )"
+}
+
+i2p_console() {
+ /bin/su - -c "( export PATH=\"$PATH:/usr/lib/java/bin:/usr/lib/java/jre/bin\"; directory console )"
+}
+
+i2p_dump() {
+ /bin/su - -c "( export PATH=\"$PATH:/usr/lib/java/bin:/usr/lib/java/jre/bin\"; directory dump )"
 }
 
 case "$1" in
@@ -17,11 +50,19 @@ case "$1" in
   i2p_stop
   ;;
 'restart')
-  i2p_stop
-  i2p_start
+  i2p_restart
+  ;;
+'status')
+  i2p_status
+  ;;
+'console')
+  i2p_console
+  ;;
+'dump')
+  i2p_dump
   ;;
 *)
-  echo "usage $0 start|stop|restart"
+  echo "usage $0 start|stop|restart|status|console|dump"
   ;;
 esac
 

Slackware/i2p/doinst.sh

@@ -49,16 +49,21 @@ echo
 echo "FINISHING I2P INSTALLATION. PLEASE WAIT."
 
 cd $INST_DIR
-sh postinstall.sh || (
-  echo "ERROR: failed execution of postinstall.sh. Please"
-  echo "cd into i2p installation directory and run "
-  echo "postinstall.sh manually with ./postinstall.sh"
-  exit 1
-)
 
-sleep 10
 
-sh i2prouter stop || exit 1
+
+OS_ARCH=`uname -m`
+X86_64=`echo "$OS_ARCH" | grep x86_64`
+if [ "X$X86_64" = "X" ]; then
+        wrapperpath="./lib/wrapper/linux"
+else
+        wrapperpath="./lib/wrapper/linux64"
+fi
+cp $wrapperpath/libwrapper.so ./lib/
+cp $wrapperpath/wrapper.jar ./lib/
+cp $wrapperpath/i2psvc .
+rm -rf ./lib/wrapper
+chmod 744 ./i2psvc
 
 echo
 echo "Installation finished."

Slackware/i2p/i2p.SlackBuild

@@ -1,28 +1,35 @@
 #!/bin/sh
-# Heavily based on the Slackware 12.1 SlackBuild
-# Slackware build script for i2p
-
+#
+# Heavily based on the Slackware 12.2 SlackBuild
+# Slackware build script for I2P
+#
 # PLEASE READ THIS:
-# Probably you will never have to update i2p packages with upgradepkg,
-# just because i2p have an auto-update function.
-# How to start i2p:
-# After installpkg command, doinst.sh will execute a postinstallation script
-# needed by i2p. After that you have to chmod +x /etc/rc.d/rc.i2p and start
-# i2p service with /etc/rc.d/rc.i2p start.
-# Now tell your browser to user this proxy: localhost on port 4444 and open
-# this page: http://localhost:7657/index.jsp
-# Here you can configure i2p, watch network status and navigate anonimously.
-# It's suggested to subscribe to various dns host, like i2host.i2p
-# For any additional information, visit i2host.i2p and forum.i2p
+# Probably you will never have to update I2P packages with upgradepkg,
+# just because I2P has an auto-update function.
+# Really you should not ever use any "upgrade" method.
+#
+# The correct way to upgrade is to: 
+# 1: install the upgrade
+# 2: remove the old package
+#
+# It is a terrible shame that upgradepkg doesn't do this, infact, 
+# it would actually be the correct way for *any* package!
+#
+#
 
-BUILD=1sim
-
-# put here installation dir, without first and last /
-# es: usr/local
+BUILD=1sponge
 INSTALL_DIR=opt
 NAME=i2p
 ARCH=noarch
 
+# Less than slackware 13?
+SLKPLT=$(cat /etc/slackware-version | sed -re "s/(Slackware )([0-9]*)(.*)/\2/")
+if [ $SLKPLT -lt 13 ] ; then
+	EXT=tgz
+else
+	EXT=txz
+fi
+
 
 #
 # This mess is here due to the totally moronic way i2p does versioning.
@@ -64,8 +71,8 @@ mkdir -p $PKG
 cd $CWD/../../
 
 ant distclean
-ant dist
-
+#ant dist
+ant tarball
 
 tar xjvf i2p.tar.bz2 -C $TMP
 
@@ -76,6 +83,37 @@ mkdir -p $PKG/$INSTALL_DIR/
 cp -a ../i2p $PKG/$INSTALL_DIR/
 
 mkdir -p $PKG/install
+
+#############################################################################
+# Preconfigureation to make package smaller, and...
+# we keep as much as reasonable in the installation directory.
+# This makes the install map fairly well to the standard installation.
+# It also makes it easier to find the log and pid files!
+#############################################################################
+cd $PKG/$INSTALL_DIR/i2p
+
+# wrapper.config $INSTALL_PATH and $SYSTEM_java_io_tmpdir
+sed "s|\$INSTALL_PATH|/$INSTALL_DIR/i2p|g" wrapper.config > a
+sed "s|\$SYSTEM_java_io_tmpdir|/$INSTALL_DIR/i2p|g" a > wrapper.config
+# eepget %INSTALL_PATH
+sed "s|\$INSTALL_PATH|/$INSTALL_DIR/i2p|g" eepget > a
+rm eepget
+mv a eepget
+# runplain.sh %INSTALL_PATH and %SYSTEM_java_io_tmpdir
+sed "s|%INSTALL_PATH|/$INSTALL_DIR/i2p|g" runplain.sh > a
+sed "s|%SYSTEM_java_io_tmpdir|/$INSTALL_DIR/i2p|g" a > runplain.sh
+# i2prouter %INSTALL_PATH and %SYSTEM_java_io_tmpdir
+sed "s|%INSTALL_PATH|/$INSTALL_DIR/i2p|g" i2prouter > a
+sed "s|%SYSTEM_java_io_tmpdir|/$INSTALL_DIR/i2p|g" a > i2prouter
+
+chmod 744 ./i2prouter
+chmod 744 ./osid
+chmod 744 ./runplain.sh
+chmod 744 ./eepget
+chmod 744 ./scripts/i2pbench.sh
+chmod 744 ./scripts/i2ptest.sh
+rm -Rf ./lib/*.dll ./*.bat ./*.exe ./installer ./icons ./a postinstall.sh
+
 mv $PKG/$INSTALL_DIR/i2p/*.config $PKG/install
 mv $PKG/$INSTALL_DIR/i2p/blocklist.txt $PKG/$INSTALL_DIR/i2p/blocklist.txt.new
 mv $PKG/$INSTALL_DIR/i2p/eepsite/jetty.xml $PKG/$INSTALL_DIR/i2p/eepsite/jetty.xml.new
@@ -83,6 +121,13 @@ mv $PKG/$INSTALL_DIR/i2p/eepsite/docroot/index.html $PKG/$INSTALL_DIR/i2p/eepsit
 mv $PKG/$INSTALL_DIR/i2p/eepsite/docroot/favicon.ico $PKG/$INSTALL_DIR/i2p/eepsite/docroot/favicon.ico.new
 sed "s|directory|/$INSTALL_DIR/i2p/|g" $CWD/doinst.sh > $PKG/install/doinst.sh
 cat $CWD/slack-desc > $PKG/install/slack-desc
+
 cd $PKG
-requiredbuilder -v -y -s $CWD $PKG
-makepkg -l y -c n $CWD/${NAME}-$VERSION-$ARCH-$BUILD.tgz
+#
+# requiredbuilder fucks up REALLY bad, and thinks java is perl?!
+# It also did not catch the shell requirements! BOOOOOOOOOOO! HISSSSSSSS!
+#
+# requiredbuilder -v -y -s $CWD $PKG
+#
+cat $CWD/slack-required > $PKG/install/slack-required
+makepkg -l y -c n $CWD/${NAME}-$VERSION-$ARCH-$BUILD.$EXT

Slackware/i2p/slack-required

@@ -1,2 +1,4 @@
-glibc >= 2.7-i486-17 | glibc-solibs >= 2.7-i486-17
-perl >= 5.10.0-i486-1
+jre >= 5
+i2p-base >= 0.0.1
+bash >= 3.1.017
+

android/AndroidManifest.xml

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+      package="net.i2p.router"
+      android:versionCode="1"
+      android:versionName="1.0.0">
+    <uses-permission android:name="android.permission.INTERNET" />
+    <!-- 3 = 1.5, 2 = 1.1, 1 = 1.0; would probably work with 1 but don't have a 1.0 SDK to test against -->
+    <uses-sdk android:minSdkVersion="2" />
+    <application android:label="@string/app_name">
+        <activity android:name=".I2PAndroid"
+                  android:label="@string/app_name"
+                  android:launchMode="singleTask" >
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+</manifest> 

android/README.txt

@@ -0,0 +1,38 @@
+These instructions are for a recent Android SDK (1.6 or later)..
+Should also still work with a 1.5 SDK.
+The build file is not compatible with the 1.1 SDK any more.
+
+#Download the SDK from http://developer.android.com/sdk/index.html
+#Unzip the android SDK in ../../
+#So then the android tools will be in ../../android-sdk-linux_86/tools/
+#
+# now go to the available packages tab, check the box and click refresh,
+# and download an SDK Platform
+# Since I2P is configured to run on 1.1 or higher
+# (API 2) download that one. Otherwise you must change the
+# target in default.properties from android-2 to andriod-x
+# where x is the API version.
+
+# create a file local.properties with the following line:
+# sdk-location=/path/to/your/android-sdk-linux_86
+
+#then build the android apk file:
+ant debug
+
+# Create the android 1.1 (API 2) virtual device
+# (don't make a custom hardware profile)
+# A AVD created with the 1.5 SDK will not work with the newer tools
+../../android-sdk-linux_86/tools/android create avd --name i2p --target 2
+
+#then run the emulator:
+../../android-sdk-linux_86/tools/emulator -avd i2p &
+
+#then wait a couple minutes until the emulator is up
+#then install the I2P app
+ant install
+
+#then run the debugger
+../../android-sdk-linux_86/tools/ddms &
+
+#to rebuild and reinstall to emulator:
+ant reinstall

android/build.xml

@@ -0,0 +1,356 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project name=".I2PAndroid" default="help">
+
+    <!-- The local.properties file is created and updated by the 'android' tool.
+         It contain the path to the SDK. It should *NOT* be checked in in Version
+         Control Systems. -->
+    <property file="local.properties"/>
+
+    <!-- The build.properties file can be created by you and is never touched
+         by the 'android' tool. This is the place to change some of the default property values
+         used by the Ant rules.
+         Here are some properties you may want to change/update:
+
+         application-package
+             the name of your application package as defined in the manifest. Used by the
+             'uninstall' rule.
+         source-folder
+             the name of the source folder. Default is 'src'.
+         out-folder
+             the name of the output folder. Default is 'bin'.
+
+         Properties related to the SDK location or the project target should be updated
+          using the 'android' tool with the 'update' action.
+
+         This file is an integral part of the build system for your application and
+         should be checked in in Version Control Systems.
+
+         -->
+    <property file="build.properties"/>
+
+    <!-- The default.properties file is created and updated by the 'android' tool, as well
+         as ADT. 
+         This file is an integral part of the build system for your application and
+         should be checked in in Version Control Systems. -->
+    <property file="default.properties"/>
+
+    <!-- Custom Android task to deal with the project target, and import the proper rules.
+         This requires ant 1.6.0 or above. -->
+    <path id="android.antlibs">
+        <pathelement path="${sdk-location}/tools/lib/anttasks.jar" />
+        <pathelement path="${sdk-location}/tools/lib/sdklib.jar" />
+        <pathelement path="${sdk-location}/tools/lib/androidprefs.jar" />
+        <pathelement path="${sdk-location}/tools/lib/apkbuilder.jar" />
+        <pathelement path="${sdk-location}/tools/lib/jarutils.jar" />
+    </path>
+
+    <taskdef name="setup"
+        classname="com.android.ant.SetupTask"
+        classpathref="android.antlibs"/>
+
+    <!-- Execute the Android Setup task that will setup some properties specific to the target,
+         and import the rules files.
+         To customize the rules, copy/paste them below the task, and disable import by setting
+         the import attribute to false:
+            <setup import="false" />
+         
+         This will ensure that the properties are setup correctly but that your customized
+         targets are used.
+    -->
+    <setup import="false" />
+
+    <!--
+         ================================================================================
+         New I2P rules
+         ================================================================================
+    -->
+
+    <target name="buildrouter" depends="dirs" >
+        <!-- build router and core -->
+        <ant dir=".." target="buildrouter" />
+
+        <!-- router -->
+        <copy file="../build/router.jar" todir="${external-libs-folder}" />
+
+        <!-- core -->
+        <mkdir dir="tmp" />
+        <unjar src="../build/i2p.jar" dest="tmp/" />
+        <delete file="tmp/net/i2p/util/LogWriter.class" />
+        <!-- org.bouncycastle.crypto already in android
+             but we need a little trickery because our HMac is incompatible...
+             and the libs aren't in the SDK to compile against??? -->
+        <jar destfile="${external-libs-folder}/crypto.jar" >
+            <fileset dir="tmp/" >
+                <include name="org/bouncycastle/crypto/Digest.class" />
+                <include name="org/bouncycastle/crypto/Mac.class" />
+                <include name="org/bouncycastle/crypto/digests/GeneralDigest.class" />
+                <include name="org/bouncycastle/crypto/digests/MD5Digest.class" />
+            </fileset>
+        </jar>
+        <delete>
+            <fileset dir="tmp/" >
+                <include name="org/bouncycastle/crypto/Digest.class" />
+                <include name="org/bouncycastle/crypto/Mac.class" />
+                <include name="org/bouncycastle/crypto/digests/GeneralDigest.class" />
+                <include name="org/bouncycastle/crypto/digests/MD5Digest.class" />
+            </fileset>
+        </delete>
+<!--
+        <delete dir="tmp/org/bouncycastle/" />
+        <delete file="tmp/net/i2p/crypto/HMACGenerator.class" />
+-->
+        <delete file="tmp/org/bouncycastle/" />
+        <!-- lots of unneeded stuff could be deleted here -->
+        <jar destfile="${external-libs-folder}/i2p.jar" basedir="tmp/" />
+
+        <!-- some resources -->
+        <mkdir dir="res/drawable/" />
+        <copy file="../installer/resources/themes/console/images/i2plogo.png" todir="res/drawable/" />
+        <copy file="../installer/resources/blocklist.txt" tofile="res/raw/blocklist_txt" />
+    </target>
+
+    <target name="hackcleanup">
+        <delete file="${external-libs-folder}/crypto.jar" />
+    </target>
+
+    <!-- fix for property name change sometime after SDK 1.5 -->
+    <property name="android-jar" value="${android.jar}" />
+    <property name="android-aidl" value="${android.aidl}" />
+
+    <!--
+         ================================================================================
+         From here down copied from SDK platforms/android-1.1/templates/android_rules.xml
+         and then modified
+         ================================================================================
+    -->
+
+    <!--
+        This rules file is meant to be imported by the custom Ant task:
+            com.android.ant.AndroidInitTask
+
+        The following properties are put in place by the importing task:
+            android-jar, android-aidl, aapt, aidl, and dx
+
+        Additionnaly, the task sets up the following classpath reference:
+            android.target.classpath
+        This is used by the compiler task as the boot classpath.
+    -->
+
+    <!-- Custom tasks -->
+    <taskdef name="aaptexec"
+        classname="com.android.ant.AaptExecLoopTask"
+        classpathref="android.antlibs"/>
+
+    <taskdef name="apkbuilder"
+        classname="com.android.ant.ApkBuilderTask"
+        classpathref="android.antlibs"/>
+
+    <!-- Properties -->
+
+    <property name="android-tools" value="${sdk-location}/tools" />
+
+    <!-- Input directories -->
+    <property name="source-folder" value="src" />
+    <property name="gen-folder" value="gen" />
+    <property name="resource-folder" value="res" />
+    <property name="asset-folder" value="assets" />
+    <property name="source-location" value="${basedir}/${source-folder}" />
+
+    <!-- folder for the 3rd party java libraries -->
+    <property name="external-libs-folder" value="libs" />
+
+    <!-- folder for the native libraries -->
+    <property name="native-libs-folder" value="libs" />
+
+    <!-- Output directories -->
+    <property name="gen-folder" value="gen" />
+    <property name="out-folder" value="bin" />
+    <property name="out-classes" value="${out-folder}/classes" />
+    <property name="out-classes-location" value="${basedir}/${out-classes}"/>
+    <!-- out folders for a parent project if this project is an instrumentation project -->
+    <property name="main-out-folder" value="../${out-folder}" />
+    <property name="main-out-classes" value="${main-out-folder}/classes"/>
+
+    <!-- Intermediate files -->
+    <property name="dex-file" value="classes.dex" />
+    <property name="intermediate-dex" value="${out-folder}/${dex-file}" />
+    <!-- dx does not properly support incorrect / or \ based on the platform
+         and Ant cannot convert them because the parameter is not a valid path.
+         Because of this we have to compute different paths depending on the platform. -->
+    <condition property="intermediate-dex-location"
+            value="${basedir}\${intermediate-dex}"
+            else="${basedir}/${intermediate-dex}" >
+        <os family="windows"/>
+    </condition>
+
+    <!-- The final package file to generate -->
+    <property name="out-debug-package" value="${out-folder}/${ant.project.name}-debug.apk"/>
+
+    <!-- Tools -->
+    <condition property="exe" value=".exe" else=""><os family="windows"/></condition>
+    <property name="adb" value="${android-tools}/adb${exe}"/>
+
+    <!-- rules -->
+
+    <!-- Create the output directories if they don't exist yet. -->
+    <target name="dirs">
+        <echo>Creating output directories if needed...</echo>
+        <mkdir dir="${resource-folder}" />
+        <mkdir dir="${external-libs-folder}" />
+        <mkdir dir="${gen-folder}" />
+        <mkdir dir="${out-folder}" />
+        <mkdir dir="${out-classes}" />
+    </target>
+
+    <!-- Generate the R.java file for this project's resources. -->
+    <target name="resource-src" depends="dirs">
+        <echo>Generating R.java / Manifest.java from the resources...</echo>
+        <exec executable="${aapt}" failonerror="true">
+            <arg value="package" />
+            <arg value="-m" />
+            <arg value="-J" />
+            <arg path="${gen-folder}" />
+            <arg value="-M" />
+            <arg path="AndroidManifest.xml" />
+            <arg value="-S" />
+            <arg path="${resource-folder}" />
+            <arg value="-I" />
+            <arg path="${android-jar}" />
+        </exec>
+    </target>
+
+    <!-- Generate java classes from .aidl files. -->
+    <target name="aidl" depends="dirs">
+        <echo>Compiling aidl files into Java classes...</echo>
+        <apply executable="${aidl}" failonerror="true">
+            <arg value="-p${android-aidl}" />
+            <arg value="-I${source-folder}" />
+            <arg value="-o${gen-folder}" />
+            <fileset dir="${source-folder}">
+                <include name="**/*.aidl"/>
+            </fileset>
+        </apply>
+    </target>
+
+    <!-- Compile this project's .java files into .class files. -->
+    <!-- I2P add buildrouter -->
+    <target name="compile" depends="buildrouter, resource-src, aidl">
+        <javac encoding="ascii" target="1.5" debug="true" extdirs=""
+                destdir="${out-classes}"
+                bootclasspathref="android.target.classpath">
+            <src path="${source-folder}" />
+            <src path="${gen-folder}" />
+            <classpath>
+                <fileset dir="${external-libs-folder}" includes="*.jar"/>
+                <pathelement path="${main-out-classes}"/>
+            </classpath>
+         </javac>
+    </target>
+
+    <!-- Convert this project's .class files into .dex files. -->
+    <!-- I2P add hackcleanup -->
+    <target name="dex" depends="compile, hackcleanup">
+        <echo>Converting compiled files and external libraries into ${out-folder}/${dex-file}...</echo>
+        <apply executable="${dx}" failonerror="true" parallel="true">
+            <!-- I2P this is a bad sign that we need this -->
+            <arg value="-JXmx256m" />
+            <arg value="--dex" />
+            <arg value="--output=${intermediate-dex-location}" />
+            <arg path="${out-classes-location}" />
+            <fileset dir="${external-libs-folder}" includes="*.jar"/>
+        </apply>
+    </target>
+
+    <!-- Put the project's resources into the output package file
+         This actually can create multiple resource package in case
+         Some custom apk with specific configuration have been
+         declared in default.properties.
+         -->
+    <target name="package-resources">
+        <echo>Packaging resources</echo>
+        <aaptexec executable="${aapt}"
+                command="package"
+                manifest="AndroidManifest.xml"
+                resources="${resource-folder}"
+                assets="${asset-folder}"
+                androidjar="${android-jar}"
+                outfolder="${out-folder}"
+                basename="${ant.project.name}" />
+    </target>
+
+    <!-- Package the application and sign it with a debug key.
+         This is the default target when building. It is used for debug. -->
+    <target name="debug" depends="dex, package-resources">
+        <apkbuilder
+                outfolder="${out-folder}"
+                basename="${ant.project.name}"
+                signed="true"
+                verbose="false">
+            <file path="${intermediate-dex}" />
+            <sourcefolder path="${source-folder}" />
+            <jarfolder path="${external-libs-folder}" />
+            <nativefolder path="${native-libs-folder}" />
+        </apkbuilder>
+    </target>
+
+    <!-- Package the application without signing it.
+         This allows for the application to be signed later with an official publishing key. -->
+    <target name="release" depends="dex, package-resources">
+        <apkbuilder
+                outfolder="${out-folder}"
+                basename="${ant.project.name}"
+                signed="false"
+                verbose="false">
+            <file path="${intermediate-dex}" />
+            <sourcefolder path="${source-folder}" />
+            <jarfolder path="${external-libs-folder}" />
+            <nativefolder path="${native-libs-folder}" />
+        </apkbuilder>
+        <echo>All generated packages need to be signed with jarsigner before they are published.</echo>
+    </target>
+
+    <!-- Install the package on the default emulator -->
+    <target name="install" depends="debug">
+        <echo>Installing ${out-debug-package} onto default emulator...</echo>
+        <exec executable="${adb}" failonerror="true">
+            <arg value="install" />
+            <arg path="${out-debug-package}" />
+        </exec>
+    </target>
+
+    <target name="reinstall" depends="debug">
+        <echo>Installing ${out-debug-package} onto default emulator...</echo>
+        <exec executable="${adb}" failonerror="true">
+            <arg value="install" />
+            <arg value="-r" />
+            <arg path="${out-debug-package}" />
+        </exec>
+    </target>
+
+    <!-- Uinstall the package from the default emulator -->
+    <target name="uninstall">
+        <echo>Uninstalling ${application-package} from the default emulator...</echo>
+        <exec executable="${adb}" failonerror="true">
+            <arg value="uninstall" />
+            <arg path="${application-package}" />
+        </exec>
+    </target>
+    
+    <target name="help">
+        <!-- displays starts at col 13
+              |13                                                              80| -->
+        <echo>Android Ant Build. Available targets:</echo>
+        <echo>   help:      Displays this help.</echo>
+        <echo>   debug:     Builds the application and sign it with a debug key.</echo>
+        <echo>   release:   Builds the application. The generated apk file must be</echo>
+        <echo>              signed before it is published.</echo>
+        <echo>   install:   Installs the debug package onto a running emulator or</echo>
+        <echo>              device. This can only be used if the application has </echo>
+        <echo>              not yet been installed.</echo>
+        <echo>   reinstall: Installs the debug package on a running emulator or</echo>
+        <echo>              device that already has the application.</echo>
+        <echo>              The signatures must match.</echo>
+        <echo>   uninstall: uninstall the application from a running emulator or</echo>
+        <echo>              device.</echo>
+    </target>
+</project>

android/default.properties

@@ -0,0 +1,11 @@
+# This file is automatically generated by Android Tools.
+# Do not modify this file -- YOUR CHANGES WILL BE ERASED!
+# 
+# This file must be checked in Version Control Systems.
+# 
+# To customize properties used by the Ant build system use,
+# "build.properties", and override values to adapt the script to your
+# project structure.
+
+# Project target.
+target=android-2

android/res/layout/main.xml

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:orientation="vertical"
+    android:layout_width="fill_parent"
+    android:layout_height="fill_parent"
+    >
+<TextView  
+    android:layout_width="fill_parent" 
+    android:layout_height="wrap_content" 
+    android:text="Hello World, I2PAndroid"
+    />
+<ImageView  
+    android:layout_width="fill_parent" 
+    android:layout_height="wrap_content" 
+    android:src="@drawable/i2plogo"
+    />
+</LinearLayout>
+

android/res/raw/logger_config

@@ -0,0 +1,3 @@
+logger.defaultLevel=INFO
+logger.record.net.i2p.router.transport.FIFOBandwidthRefiller=ERROR
+logger.record.net.i2p.stat.Rate=ERROR

android/res/raw/router_config

@@ -0,0 +1,22 @@
+# initial router.config
+# temp directory
+i2p.dir.temp=/data/data/net.i2p.router/files/tmp
+i2p.dir.pid=/data/data/net.i2p.router/files/tmp
+# save memory
+prng.buffers=2
+router.decayingBloomFilterM=20
+stat.full=false
+i2np.udp.maxConnections=30
+# no I2CP
+i2p.dummyClientFacade=true
+# for now
+#i2np.ntcp.enable=false
+#
+# UDP crashes the JVM, don't know why
+#
+i2np.udp.enable=false
+# no COMM at all!!!
+#i2p.vmCommSystem=true
+# not on android
+i2np.upnp.enable=false
+routerconsole.geoip.enable=false

android/res/values/strings.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="app_name">I2PAndroid</string>
+</resources>

android/src/net/i2p/router/I2PAndroid.java

@@ -0,0 +1,142 @@
+package net.i2p.router;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.res.Resources;
+import android.content.res.Resources.NotFoundException;
+import android.os.Bundle;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.InputStream;
+import java.io.IOException;
+import java.util.List;
+
+import net.i2p.router.Router;
+import net.i2p.router.RouterLaunch;
+// import net.i2p.util.NativeBigInteger;
+
+public class I2PAndroid extends Activity
+{
+    static Context _context;
+    private static final String DIR = "/data/data/net.i2p.router/files";
+
+    /** Called when the activity is first created. */
+    @Override
+    public void onCreate(Bundle savedInstanceState)
+    {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.main);
+
+        _context = this;  // Activity extends Context
+        debugStuff();
+        initialize();
+        // 300ms per run
+        // 5x slower than java on my server and 50x slower than native on my server
+        // NativeBigInteger.main(null);
+    }
+
+    public void onRestart()
+    {
+        System.err.println("onRestart called");
+        super.onRestart();
+    }
+
+    public void onStart()
+    {
+        System.err.println("onStart called");
+        super.onStart();
+        RouterLaunch.main(null);
+        System.err.println("Router.main finished");
+    }
+
+    public void onResume()
+    {
+        System.err.println("onResume called");
+        super.onResume();
+    }
+
+    public void onPause()
+    {
+        System.err.println("onPause called");
+        super.onPause();
+    }
+
+    public void onStop()
+    {
+        System.err.println("onStop called");
+        super.onStop();
+
+        // from routerconsole ContextHelper
+        List contexts = RouterContext.listContexts();
+        if ( (contexts == null) || (contexts.isEmpty()) ) 
+            throw new IllegalStateException("No contexts. This is usually because the router is either starting up or shutting down.");
+        RouterContext ctx = (RouterContext)contexts.get(0);
+
+        // shutdown() doesn't return so use shutdownGracefully()
+        ctx.router().shutdownGracefully(Router.EXIT_HARD);
+        System.err.println("shutdown complete");
+    }
+
+    public void onDestroy()
+    {
+        System.err.println("onDestroy called");
+        super.onDestroy();
+    }
+
+    public static Context getContext() {
+        return _context;
+    }
+
+    private void debugStuff() {
+        System.err.println("java.io.tmpdir" + ": " + System.getProperty("java.io.tmpdir"));
+        System.err.println("java.vendor" + ": " + System.getProperty("java.vendor"));
+        System.err.println("java.version" + ": " + System.getProperty("java.version"));
+        System.err.println("os.arch" + ": " + System.getProperty("os.arch"));
+        System.err.println("os.name" + ": " + System.getProperty("os.name"));
+        System.err.println("os.version" + ": " + System.getProperty("os.version"));
+        System.err.println("user.dir" + ": " + System.getProperty("user.dir"));
+        System.err.println("user.home" + ": " + System.getProperty("user.home"));
+        System.err.println("user.name" + ": " + System.getProperty("user.name"));
+    }
+
+    private void initialize() {
+        // Until we can edit the router.config on the device,
+        // copy it from the resource every time.
+        // File f = new I2PFile("router.config");
+        // if (!f.exists()) {
+            copyResourceToFile(R.raw.router_config, "router.config");
+            copyResourceToFile(R.raw.logger_config, "logger.config");
+            copyResourceToFile(R.raw.blocklist_txt, "blocklist.txt");
+        // }
+
+        // Set up the locations so Router and WorkingDir can find them
+        System.setProperty("i2p.dir.base", DIR);
+        System.setProperty("i2p.dir.config", DIR);
+        System.setProperty("wrapper.logfile", DIR + "/wrapper.log");
+    }
+
+    private void copyResourceToFile(int resID, String f) {
+        InputStream in = null;
+        FileOutputStream out = null;
+
+        System.err.println("Creating file " + f + " from resource");
+        byte buf[] = new byte[4096];
+        try {
+            // Context methods
+            in = getResources().openRawResource(resID);
+            out = openFileOutput(f, 0);
+            
+            int read = 0;
+            while ( (read = in.read(buf)) != -1)
+                out.write(buf, 0, read);
+            
+        } catch (IOException ioe) {
+        } catch (Resources.NotFoundException nfe) {
+        } finally {
+            if (in != null) try { in.close(); } catch (IOException ioe) {}
+            if (out != null) try { out.close(); } catch (IOException ioe) {}
+        }
+    }
+    
+}

android/src/net/i2p/util/LogWriter.java

@@ -0,0 +1,163 @@
+package net.i2p.util;
+
+/*
+ * public domain
+ *
+ */
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.util.List;
+
+/**
+ * bridge to android logging
+ *
+ * @author zzz
+ */
+class LogWriter implements Runnable {
+    private final static long CONFIG_READ_ITERVAL = 10 * 1000;
+    private long _lastReadConfig = 0;
+    private long _numBytesInCurrentFile = 0;
+    private OutputStream _currentOut; // = System.out
+    private int _rotationNum = -1;
+    private String _logFilenamePattern;
+    private File _currentFile;
+    private LogManager _manager;
+
+    private boolean _write;
+    
+    private LogWriter() { // nop
+    }
+
+    public LogWriter(LogManager manager) {
+        _manager = manager;
+    }
+
+    public void stopWriting() {
+        _write = false;
+    }
+    
+    public void run() {
+        _write = true;
+        try {
+            while (_write) {
+                flushRecords();
+                rereadConfig();
+            }
+            System.err.println("Done writing");
+        } catch (Exception e) {
+            System.err.println("Error writing the logs: " + e.getMessage());
+            e.printStackTrace();
+        }
+    }
+
+    public void flushRecords() { flushRecords(true); }
+    public void flushRecords(boolean shouldWait) {
+        try {
+            List records = _manager._removeAll();
+            if (records == null) return;
+            for (int i = 0; i < records.size(); i++) {
+                LogRecord rec = (LogRecord) records.get(i);
+                writeRecord(rec);
+            }
+        } catch (Throwable t) {
+            t.printStackTrace();
+        } finally {
+            if (shouldWait) {
+                try { 
+                    synchronized (this) {
+                        this.wait(10*1000); 
+                    }
+                } catch (InterruptedException ie) { // nop
+                }
+            }
+        }
+    }
+
+    public String currentFile() {
+        return _currentFile != null ? _currentFile.getAbsolutePath() : "uninitialized";
+    }
+    
+    private void rereadConfig() {
+        long now = Clock.getInstance().now();
+        if (now - _lastReadConfig > CONFIG_READ_ITERVAL) {
+            _manager.rereadConfig();
+            _lastReadConfig = now;
+        }
+    }
+
+    private void writeRecord(LogRecord rec) {
+        if (rec.getThrowable() == null)
+            log(rec.getPriority(), rec.getSource(), rec.getSourceName(), rec.getThreadName(), rec.getMessage());
+        else
+            log(rec.getPriority(), rec.getSource(), rec.getSourceName(), rec.getThreadName(), rec.getMessage(), rec.getThrowable());
+    }
+
+    public void log(int priority, Class src, String name, String threadName, String msg) {
+            if (src != null) {
+                String tag = src.getName();
+                int dot = tag.lastIndexOf(".");
+                if (dot >= 0)
+                    tag = tag.substring(dot + 1);
+                android.util.Log.println(toAndroidLevel(priority),
+                                         tag,
+                                         '[' + threadName + "] " + msg);
+            } else if (name != null)
+                android.util.Log.println(toAndroidLevel(priority),
+                                         name,
+                                         '[' + threadName + "] " + msg);
+            else
+                android.util.Log.println(toAndroidLevel(priority),
+                                         threadName, msg);
+    }
+
+    public void log(int priority, Class src, String name, String threadName, String msg, Throwable t) {
+            if (src != null) {
+                String tag = src.getName();
+                int dot = tag.lastIndexOf(".");
+                if (dot >= 0)
+                    tag = tag.substring(dot + 1);
+                android.util.Log.println(toAndroidLevel(priority),
+                                         tag,
+                                         '[' + threadName + "] " + msg +
+                                         ' ' + t.toString() + ' ' + android.util.Log.getStackTraceString(t));
+            } else if (name != null)
+                android.util.Log.println(toAndroidLevel(priority),
+                                         name,
+                                         '[' + threadName + "] " + msg +
+                                         ' ' + t.toString() + ' ' + android.util.Log.getStackTraceString(t));
+            else
+                android.util.Log.println(toAndroidLevel(priority),
+                                         threadName,
+                                         msg + ' ' + t.toString() + ' ' + android.util.Log.getStackTraceString(t));
+    }
+
+    private static int toAndroidLevel(int level) {
+        switch (level) {
+        case Log.DEBUG:
+            return android.util.Log.DEBUG;
+        case Log.INFO:
+            return android.util.Log.INFO;
+        case Log.WARN:
+            return android.util.Log.WARN;
+        case Log.ERROR:
+        case Log.CRIT:
+        default:
+            return android.util.Log.ERROR;
+        }
+    }
+
+    private static final String replace(String pattern, int num) {
+        char c[] = pattern.toCharArray();
+        StringBuffer buf = new StringBuffer();
+        for (int i = 0; i < c.length; i++) {
+            if ( (c[i] != '#') && (c[i] != '@') )
+                buf.append(c[i]);
+            else
+                buf.append(num);
+        }
+        return buf.toString();
+    }
+}

apps/BOB/build.xml

@@ -71,4 +71,44 @@
     nbproject/build-impl.xml file. 
 
     -->
+    <target depends="jar" description="Build BOB into a SINGLE JAR." name="onejar">
+	<!-- Make needed working dirs -->
+	<mkdir dir="${dist.dir}/lib" />
+	<mkdir dir="${dist.dir}/classes" />
+
+	<!-- Copy jars -->
+	<copy todir="${dist.dir}/lib" flatten="true" >
+	    <path>
+	        <pathelement path="${javac.classpath}" />
+	    </path>
+	</copy>
+	<copy todir="${dist.dir}/lib" file="../../installer/lib/jbigi/jbigi.jar" />
+
+	<!-- Extract the classes inside the jar files -->
+	<unjar dest="${dist.dir}/classes" >
+            <fileset dir="${dist.dir}/lib" >
+                <include name="**/*.jar" />
+            </fileset>
+        </unjar>
+
+        <!-- Recombine the classes into a new jar file -->
+	<jar jarfile="${dist.dir}/lib/all-in-one.jar" >
+	    <fileset dir="${dist.dir}/classes" />
+        </jar>
+
+        <!-- Clean up work area -->        
+        <delete dir="${dist.dir}/classes" followsymlinks="false" includeemptydirs="true"/>
+
+        <!-- Make the single jar file -->
+        <jar jarfile="dist/BOB-one.jar" >
+            <zipfileset src="${dist.jar}" excludes="META-INF/*" />
+            <zipfileset src="${dist.dir}/lib/all-in-one.jar" excludes="**/META-INF/*" />
+            <manifest>
+                <attribute name="Main-Class" value="net.i2p.BOB.Main" />
+            </manifest>
+        </jar>
+
+        <!-- Clean up the fake jar file -->
+        <delete file="${dist.dir}/lib/all-in-one.jar" />
+    </target>
 </project>

apps/BOB/nbproject/private/private.properties

@@ -1,7 +0,0 @@
-compile.on.save=false
-do.depend=false
-do.jar=true
-javac.debug=true
-javadoc.preview=true
-jaxws.endorsed.dir=/usr/local/netbeans-6.5/java2/modules/ext/jaxws21/api:/usr/local/netbeans-6.5/ide10/modules/ext/jaxb/api
-user.properties.file=/root/.netbeans/6.5/build.properties

apps/BOB/nbproject/private/private.xml

@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project-private xmlns="http://www.netbeans.org/ns/project-private/1">
-    <editor-bookmarks xmlns="http://www.netbeans.org/ns/editor-bookmarks/1"/>
-</project-private>

apps/BOB/nbproject/project.properties

@@ -1,5 +1,6 @@
+application.homepage=http://bob.i2p/
 application.title=BOB
-application.vendor=root
+application.vendor=Sponge
 auxiliary.org-netbeans-modules-editor-indent.CodeStyle.project.expand-tabs=false
 auxiliary.org-netbeans-modules-editor-indent.CodeStyle.project.indent-shift-width=8
 auxiliary.org-netbeans-modules-editor-indent.CodeStyle.project.spaces-per-tab=8
@@ -11,6 +12,7 @@ build.classes.excludes=**/*.java,**/*.form
 # This directory is removed when the project is cleaned:
 build.dir=build
 build.generated.dir=${build.dir}/generated
+build.generated.sources.dir=${build.dir}/generated-sources
 # Only compile against the classpath explicitly listed here:
 build.sysclasspath=ignore
 build.test.classes.dir=${build.dir}/test/classes
@@ -23,6 +25,7 @@ debug.test.classpath=\
 dist.dir=dist
 dist.jar=${dist.dir}/BOB.jar
 dist.javadoc.dir=${dist.dir}/javadoc
+endorsed.classpath=
 excludes=
 file.reference.build-javadoc=../../i2p.i2p/build/javadoc
 file.reference.i2p.jar=../../core/java/build/i2p.jar
@@ -33,7 +36,7 @@ file.reference.router.jar=../../router/java/build/router.jar
 file.reference.streaming.jar=../streaming/java/build/streaming.jar
 file.reference.wrapper.jar=../../installer/lib/wrapper/linux/wrapper.jar
 includes=**
-jar.compress=false
+jar.compress=true
 javac.classpath=\
     ${file.reference.router.jar}:\
     ${file.reference.i2ptunnel.jar}:\
@@ -63,8 +66,9 @@ javadoc.splitindex=true
 javadoc.use=true
 javadoc.version=false
 javadoc.windowtitle=
+jaxbwiz.endorsed.dirs="${netbeans.home}/../ide12/modules/ext/jaxb/api"
 jnlp.codebase.type=local
-jnlp.codebase.url=file:/root/NetBeansProjects/i2p.i2p/apps/BOB/dist/
+jnlp.codebase.url=file:/usblv/NetBeansProjects/i2p.i2p/apps/BOB/dist
 jnlp.descriptor=application
 jnlp.enabled=false
 jnlp.offline-allowed=false

apps/BOB/src/net/i2p/BOB/BOB.java

@@ -23,6 +23,7 @@
  */
 package net.i2p.BOB;
 
+import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
@@ -34,6 +35,8 @@ import java.net.Socket;
 import java.net.SocketTimeoutException;
 import java.util.Properties;
 import java.util.concurrent.atomic.AtomicBoolean;
+
+import net.i2p.I2PAppContext;
 import net.i2p.client.I2PClient;
 import net.i2p.client.streaming.RetransmissionTimer;
 import net.i2p.util.Log;
@@ -163,6 +166,7 @@ public class BOB {
 	public static void stop() {
 		spin.set(false);
 	}
+
 	/**
 	 * Listen for incoming connections and handle them
 	 *
@@ -185,16 +189,20 @@ public class BOB {
 		i = Y2.hashCode();
 		try {
 			{
+				File cfg = new File(configLocation);
+				if (!cfg.isAbsolute()) {
+					cfg = new File(I2PAppContext.getGlobalContext().getConfigDir(), configLocation);
+				}
 				try {
-					FileInputStream fi = new FileInputStream(configLocation);
+					FileInputStream fi = new FileInputStream(cfg);
 					props.load(fi);
 					fi.close();
 				} catch (FileNotFoundException fnfe) {
-					warn("Unable to load up the BOB config file " + configLocation + ", Using defaults.");
+					warn("Unable to load up the BOB config file " + cfg.getAbsolutePath() + ", Using defaults.");
 					warn(fnfe.toString());
 					save = true;
 				} catch (IOException ioe) {
-					warn("IOException on BOB config file " + configLocation + ", using defaults.");
+					warn("IOException on BOB config file " + cfg.getAbsolutePath() + ", using defaults.");
 					warn(ioe.toString());
 				}
 			}
@@ -227,13 +235,17 @@ public class BOB {
 				props.setProperty(PROP_BOB_HOST, "localhost");
 			}
 			if (save) {
+				File cfg = new File(configLocation);
+				if (!cfg.isAbsolute()) {
+					cfg = new File(I2PAppContext.getGlobalContext().getConfigDir(), configLocation);
+				}
 				try {
-					warn("Writing new defaults file " + configLocation);
-					FileOutputStream fo = new FileOutputStream(configLocation);
-					props.store(fo, configLocation);
+					warn("Writing new defaults file " + cfg.getAbsolutePath());
+					FileOutputStream fo = new FileOutputStream(cfg);
+					props.store(fo, cfg.getAbsolutePath());
 					fo.close();
 				} catch (IOException ioe) {
-					error("IOException on BOB config file " + configLocation + ", " + ioe);
+					error("IOException on BOB config file " + cfg.getAbsolutePath() + ", " + ioe);
 				}
 			}
 
@@ -244,11 +256,13 @@ public class BOB {
 				listener = new ServerSocket(Integer.parseInt(props.getProperty(PROP_BOB_PORT)), 10, InetAddress.getByName(props.getProperty(PROP_BOB_HOST)));
 				Socket server = null;
 				listener.setSoTimeout(500); // .5 sec
+				
 				while (spin.get()) {
 					//DoCMDS connection;
 
 					try {
 						server = listener.accept();
+						server.setKeepAlive(true);
 						g = true;
 					} catch (ConnectException ce) {
 						g = false;

apps/BOB/src/net/i2p/BOB/I2Plistener.java

@@ -25,6 +25,7 @@ package net.i2p.BOB;
 
 import java.net.ConnectException;
 import java.net.SocketTimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
 import net.i2p.I2PException;
 import net.i2p.client.streaming.I2PServerSocket;
 import net.i2p.client.streaming.I2PSocket;
@@ -43,6 +44,7 @@ public class I2Plistener implements Runnable {
 //	private int tgwatch;
 	public I2PSocketManager socketManager;
 	public I2PServerSocket serverSocket;
+	private AtomicBoolean lives;
 
 	/**
 	 * Constructor
@@ -52,23 +54,13 @@ public class I2Plistener implements Runnable {
 	 * @param database
 	 * @param _log
 	 */
-	I2Plistener(I2PServerSocket SS, I2PSocketManager S, NamedDB info, NamedDB database, Log _log) {
+	I2Plistener(I2PServerSocket SS, I2PSocketManager S, NamedDB info, NamedDB database, Log _log, AtomicBoolean lives) {
 		this.database = database;
 		this.info = info;
 		this._log = _log;
 		this.socketManager = S;
-		serverSocket = SS;
-//		tgwatch = 1;
-	}
-
-	private void rlock() throws Exception {
-		database.getReadLock();
-		info.getReadLock();
-	}
-
-	private void runlock() throws Exception {
-		database.releaseReadLock();
-		info.releaseReadLock();
+		this.serverSocket = SS;
+		this.lives = lives;
 	}
 
 	/**
@@ -80,50 +72,31 @@ public class I2Plistener implements Runnable {
 		I2PSocket sessSocket = null;
 		int conn = 0;
 		try {
-			die:
-			{
-
+			try {
 				serverSocket.setSoTimeout(50);
-				boolean spin = true;
-				while (spin) {
 
+				while (lives.get()) {
 					try {
-						rlock();
-					} catch (Exception e) {
-						break die;
+						sessSocket = serverSocket.accept();
+						g = true;
+					} catch (ConnectException ce) {
+						g = false;
+					} catch (SocketTimeoutException ste) {
+						g = false;
 					}
-					try {
-						spin = info.get("RUNNING").equals(Boolean.TRUE);
-					} catch (Exception e) {
-						try {
-							runlock();
-						} catch (Exception e2) {
-							break die;
-						}
-						break die;
+					if (g) {
+						g = false;
+						conn++;
+						// toss the connection to a new thread.
+						I2PtoTCP conn_c = new I2PtoTCP(sessSocket, info, database, lives);
+						Thread t = new Thread(conn_c, Thread.currentThread().getName() + " I2PtoTCP " + conn);
+						t.start();
 					}
-					try {
-						try {
-							sessSocket = serverSocket.accept();
-							g = true;
-						} catch (ConnectException ce) {
-							g = false;
-						} catch (SocketTimeoutException ste) {
-							g = false;
-						}
-						if (g) {
-							g = false;
-							conn++;
-							// toss the connection to a new thread.
-							I2PtoTCP conn_c = new I2PtoTCP(sessSocket, info, database);
-							Thread t = new Thread(conn_c, Thread.currentThread().getName() + " I2PtoTCP " + conn);
-							t.start();
-						}
 
-					} catch (Exception e) {
-						//	System.out.println("Exception " + e);
-					}
 				}
+			} catch (I2PException e) {
+				// bad shit
+				System.out.println("Exception " + e);
 			}
 		} finally {
 			try {

apps/BOB/src/net/i2p/BOB/I2PtoTCP.java

@@ -26,6 +26,7 @@ package net.i2p.BOB;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.net.Socket;
+import java.util.concurrent.atomic.AtomicBoolean;
 import net.i2p.client.streaming.I2PSocket;
 
 /**
@@ -38,6 +39,7 @@ public class I2PtoTCP implements Runnable {
 	private I2PSocket I2P;
 	private NamedDB info,  database;
 	private Socket sock;
+	private AtomicBoolean lives;
 
 	/**
 	 * Constructor
@@ -46,10 +48,11 @@ public class I2PtoTCP implements Runnable {
 	 * @param info
 	 * @param database
 	 */
-	I2PtoTCP(I2PSocket I2Psock, NamedDB info, NamedDB database) {
+	I2PtoTCP(I2PSocket I2Psock, NamedDB info, NamedDB database, AtomicBoolean lives) {
 		this.I2P = I2Psock;
 		this.info = info;
 		this.database = database;
+		this.lives = lives;
 	}
 
 	private void rlock() {
@@ -99,6 +102,7 @@ public class I2PtoTCP implements Runnable {
 						break die;
 					}
 					sock = new Socket(host, port);
+					sock.setKeepAlive(true);
 					// make readers/writers
 					in = sock.getInputStream();
 					out = sock.getOutputStream();
@@ -113,35 +117,19 @@ public class I2PtoTCP implements Runnable {
 						out.flush(); // not really needed, but...
 					}
 					// setup to cross the streams
-					TCPio conn_c = new TCPio(in, Iout /*, info, database */); // app -> I2P
-					TCPio conn_a = new TCPio(Iin, out /* , info, database */); // I2P -> app
+					TCPio conn_c = new TCPio(in, Iout, lives); // app -> I2P
+					TCPio conn_a = new TCPio(Iin, out, lives); // I2P -> app
 					t = new Thread(conn_c, Thread.currentThread().getName() + " TCPioA");
 					q = new Thread(conn_a, Thread.currentThread().getName() + " TCPioB");
 					// Fire!
 					t.start();
 					q.start();
-					boolean spin = true;
-					while (t.isAlive() && q.isAlive() && spin) { // AND is used here to kill off the other thread
+					while (t.isAlive() && q.isAlive() && lives.get()) { // AND is used here to kill off the other thread
 						try {
 							Thread.sleep(10); //sleep for 10 ms
 						} catch (InterruptedException e) {
 							break die;
 						}
-							try {
-								rlock();
-							} catch (Exception e) {
-								break die;
-							}
-							try {
-								spin = info.get("RUNNING").equals(Boolean.TRUE);
-							} catch (Exception e) {
-								try {
-									runlock();
-								} catch (Exception e2) {
-									break die;
-								}
-								break die;
-							}
 					}
 				// System.out.println("I2PtoTCP: Going away...");
 				} catch (Exception e) {
@@ -150,14 +138,6 @@ public class I2PtoTCP implements Runnable {
 				}
 			} // die
 		} finally {
-			try {
-				t.interrupt();
-			} catch (Exception e) {
-			}
-			try {
-				q.interrupt();
-			} catch (Exception e) {
-			}
 			try {
 				in.close();
 			} catch (Exception ex) {
@@ -174,6 +154,14 @@ public class I2PtoTCP implements Runnable {
 				Iout.close();
 			} catch (Exception ex) {
 			}
+			try {
+				t.interrupt();
+			} catch (Exception e) {
+			}
+			try {
+				q.interrupt();
+			} catch (Exception e) {
+			}
 			try {
 				// System.out.println("I2PtoTCP: Close I2P");
 				I2P.close();

apps/BOB/src/net/i2p/BOB/MUXlisten.java

@@ -43,7 +43,7 @@ import net.i2p.util.Log;
  */
 public class MUXlisten implements Runnable {
 
-	private NamedDB database, info;
+	private NamedDB database,  info;
 	private Log _log;
 	private I2PSocketManager socketManager;
 	private ByteArrayInputStream prikey;
@@ -54,6 +54,7 @@ public class MUXlisten implements Runnable {
 	boolean go_out;
 	boolean come_in;
 	private AtomicBoolean lock;
+	private AtomicBoolean lives;
 
 	/**
 	 * Constructor Will fail if INPORT is occupied.
@@ -65,47 +66,84 @@ public class MUXlisten implements Runnable {
 	 * @throws java.io.IOException
 	 */
 	MUXlisten(AtomicBoolean lock, NamedDB database, NamedDB info, Log _log) throws I2PException, IOException, RuntimeException {
-		int port = 0;
-		InetAddress host = null;
-		this.lock = lock;
-		this.tg = null;
-		this.database = database;
-		this.info = info;
-		this._log = _log;
+		try {
+			int port = 0;
+			InetAddress host = null;
+			this.lock = lock;
+			this.tg = null;
+			this.database = database;
+			this.info = info;
+			this._log = _log;
+			lives = new AtomicBoolean(false);
 
-		this.database.getReadLock();
-		this.info.getReadLock();
-		N = this.info.get("NICKNAME").toString();
-		prikey = new ByteArrayInputStream((byte[]) info.get("KEYS"));
-		// Make a new copy so that anything else won't muck with our database.
-		Properties R = (Properties) info.get("PROPERTIES");
-		Properties Q = new Properties();
-		Lifted.copyProperties(R, Q);
-		this.database.releaseReadLock();
-		this.info.releaseReadLock();
+			this.database.getWriteLock();
+			this.info.getWriteLock();
+			this.info.add("STARTING", new Boolean(true));
+			this.info.releaseWriteLock();
+			this.database.releaseWriteLock();
+			this.database.getReadLock();
+			this.info.getReadLock();
 
-		this.database.getReadLock();
-		this.info.getReadLock();
-		this.go_out = info.exists("OUTPORT");
-		this.come_in = info.exists("INPORT");
-		if (this.come_in) {
-			port = Integer.parseInt(info.get("INPORT").toString());
-			host = InetAddress.getByName(info.get("INHOST").toString());
+			N = this.info.get("NICKNAME").toString();
+			prikey = new ByteArrayInputStream((byte[]) info.get("KEYS"));
+			// Make a new copy so that anything else won't muck with our database.
+			Properties R = (Properties) info.get("PROPERTIES");
+			Properties Q = new Properties();
+			Lifted.copyProperties(R, Q);
+			this.database.releaseReadLock();
+			this.info.releaseReadLock();
+
+			this.database.getReadLock();
+			this.info.getReadLock();
+			this.go_out = info.exists("OUTPORT");
+			this.come_in = info.exists("INPORT");
+			if (this.come_in) {
+				port = Integer.parseInt(info.get("INPORT").toString());
+				host = InetAddress.getByName(info.get("INHOST").toString());
+			}
+			this.database.releaseReadLock();
+			this.info.releaseReadLock();
+
+			if (this.come_in) {
+				this.listener = new ServerSocket(port, backlog, host);
+			}
+			socketManager = I2PSocketManagerFactory.createManager(prikey, Q);
+		// I2PException, IOException, RuntimeException
+		// To bad we can't just catch and enumerate....
+		// } catch (I2PException e) {
+		// Something went bad.
+		//	this.database.getWriteLock();
+		//	this.info.getWriteLock();
+		//	this.info.add("STARTING", new Boolean(false));
+		//	this.info.releaseWriteLock();
+		//	this.database.releaseWriteLock();
+		//	throw new I2PException(e);
+		} catch (IOException e) {
+			// Something went bad.
+			this.database.getWriteLock();
+			this.info.getWriteLock();
+			this.info.add("STARTING", new Boolean(false));
+			this.info.releaseWriteLock();
+			this.database.releaseWriteLock();
+			throw new IOException(e.toString());
+		} catch (RuntimeException e) {
+			// Something went bad.
+			this.database.getWriteLock();
+			this.info.getWriteLock();
+			this.info.add("STARTING", new Boolean(false));
+			this.info.releaseWriteLock();
+			this.database.releaseWriteLock();
+			throw new RuntimeException(e);
+		} catch (Exception e) {
+			// Something else went bad.
+			this.database.getWriteLock();
+			this.info.getWriteLock();
+			this.info.add("STARTING", new Boolean(false));
+			this.info.releaseWriteLock();
+			this.database.releaseWriteLock();
+			e.printStackTrace();
+			throw new RuntimeException(e);
 		}
-		this.database.releaseReadLock();
-		this.info.releaseReadLock();
-
-		socketManager = I2PSocketManagerFactory.createManager(prikey, Q);
-		if (this.come_in) {
-			this.listener = new ServerSocket(port, backlog, host);
-		}
-
-		// Everything is OK as far as we can tell.
-		this.database.getWriteLock();
-		this.info.getWriteLock();
-		this.info.add("STARTING", new Boolean(true));
-		this.info.releaseWriteLock();
-		this.database.releaseWriteLock();
 	}
 
 	private void rlock() throws Exception {
@@ -142,18 +180,22 @@ public class MUXlisten implements Runnable {
 				try {
 					info.add("RUNNING", new Boolean(true));
 				} catch (Exception e) {
+					lock.set(false);
 					wunlock();
 					return;
 				}
 			} catch (Exception e) {
+				lock.set(false);
 				return;
 			}
 			try {
 				wunlock();
 			} catch (Exception e) {
+				lock.set(false);
 				return;
 			}
 //		socketManager.addDisconnectListener(new DisconnectListener());
+			lives.set(true);
 			lock.set(false);
 			quit:
 			{
@@ -166,14 +208,14 @@ public class MUXlisten implements Runnable {
 						if (go_out) {
 							// I2P -> TCP
 							SS = socketManager.getServerSocket();
-							I2Plistener conn = new I2Plistener(SS, socketManager, info, database, _log);
+							I2Plistener conn = new I2Plistener(SS, socketManager, info, database, _log, lives);
 							t = new Thread(tg, conn, "BOBI2Plistener " + N);
 							t.start();
 						}
 
 						if (come_in) {
 							// TCP -> I2P
-							TCPlistener conn = new TCPlistener(listener, socketManager, info, database, _log);
+							TCPlistener conn = new TCPlistener(listener, socketManager, info, database, _log, lives);
 							q = new Thread(tg, conn, "BOBTCPlistener " + N);
 							q.start();
 						}
@@ -195,7 +237,7 @@ public class MUXlisten implements Runnable {
 							break quit;
 						}
 						boolean spin = true;
-						while (spin) {
+						while (spin && lives.get()) {
 							try {
 								Thread.sleep(1000); //sleep for 1 second
 							} catch (InterruptedException e) {
@@ -226,26 +268,30 @@ public class MUXlisten implements Runnable {
 				}
 			} // quit
 		} finally {
-			// Start cleanup.
-			while (!lock.compareAndSet(false, true)) {
-				// wait
+			lives.set(false);
+			// Some grace time.
+			try {
+				Thread.sleep(100);
+			} catch (InterruptedException ex) {
 			}
-
-			// zero out everything.
 			try {
 				wlock();
 				try {
 					info.add("STARTING", new Boolean(false));
-					info.add("STOPPING", new Boolean(false));
+					info.add("STOPPING", new Boolean(true));
 					info.add("RUNNING", new Boolean(false));
 				} catch (Exception e) {
+					lock.set(false);
 					wunlock();
 					return;
 				}
 				wunlock();
 			} catch (Exception e) {
 			}
-
+			// Start cleanup.
+			while (!lock.compareAndSet(false, true)) {
+				// wait
+			}
 			if (SS != null) {
 				try {
 					SS.close();
@@ -261,11 +307,41 @@ public class MUXlisten implements Runnable {
 
 			// Some grace time.
 			try {
-				Thread.sleep(250);
+				Thread.sleep(100);
 			} catch (InterruptedException ex) {
 			}
 
+			// Hopefully nuke stuff here...
+			{
+				String boner = tg.getName();
+				try {
+					_log.warn("destroySocketManager " + boner);
+					socketManager.destroySocketManager();
+					_log.warn("destroySocketManager Successful" + boner);
+				} catch (Exception e) {
+					// nop
+					_log.warn("destroySocketManager Failed" + boner);
+					_log.warn(e.toString());
+				}
+			}
+			// zero out everything.
+			try {
+				wlock();
+				try {
+					info.add("STARTING", new Boolean(false));
+					info.add("STOPPING", new Boolean(false));
+					info.add("RUNNING", new Boolean(false));
+				} catch (Exception e) {
+					lock.set(false);
+					wunlock();
+					return;
+				}
+				wunlock();
+			} catch (Exception e) {
+			}
+
 			lock.set(false); // Should we force waiting for all threads??
+
 			// Wait around till all threads are collected.
 			if (tg != null) {
 				String boner = tg.getName();
@@ -276,7 +352,7 @@ public class MUXlisten implements Runnable {
 					// visit(tg, 0, boner);
 					int foo = tg.activeCount() + tg.activeGroupCount();
 					// hopefully no longer needed!
-					// int bar = foo;
+					// int bar = lives;
 					// System.out.println("BOB: MUXlisten: Waiting on threads for " + boner);
 					// System.out.println("\nBOB: MUXlisten: ThreadGroup dump BEGIN " + boner);
 					// visit(tg, 0, boner);
@@ -284,12 +360,12 @@ public class MUXlisten implements Runnable {
 					// Happily spin forever :-(
 					while (foo != 0) {
 						foo = tg.activeCount() + tg.activeGroupCount();
-						// if (foo != bar && foo != 0) {
+						// if (lives != bar && lives != 0) {
 						// 	System.out.println("\nBOB: MUXlisten: ThreadGroup dump BEGIN " + boner);
 						// 	visit(tg, 0, boner);
 						// 	System.out.println("BOB: MUXlisten: ThreadGroup dump END " + boner + "\n");
 						// }
-						// bar = foo;
+						// bar = lives;
 						try {
 							Thread.sleep(100); //sleep for 100 ms (One tenth second)
 						} catch (InterruptedException ex) {
@@ -356,5 +432,4 @@ public class MUXlisten implements Runnable {
 			visit(groups[i], level + 1, groups[i].getName());
 		}
 	}
-
 }

apps/BOB/src/net/i2p/BOB/Main.java

@@ -26,6 +26,7 @@ package net.i2p.BOB;
 import net.i2p.client.streaming.RetransmissionTimer;
 import net.i2p.util.SimpleScheduler;
 import net.i2p.util.SimpleTimer2;
+
 /**
  * Start from command line
  *

apps/BOB/src/net/i2p/BOB/NamedDB.java

@@ -43,10 +43,10 @@ public class NamedDB {
 	}
 
 	synchronized public void getReadLock() {
-		while((writersWaiting != 0)) {
+		while ((writersWaiting != 0)) {
 			try {
 				wait();
-			} catch(InterruptedException ie) {
+			} catch (InterruptedException ie) {
 			}
 		}
 		readers++;
@@ -59,10 +59,10 @@ public class NamedDB {
 
 	synchronized public void getWriteLock() {
 		writersWaiting++;
-		while(readers != 0 && writersWaiting != 1 ) {
+		while (readers != 0 && writersWaiting != 1) {
 			try {
 				wait();
-			} catch(InterruptedException ie) {
+			} catch (InterruptedException ie) {
 			}
 		}
 	}
@@ -79,8 +79,8 @@ public class NamedDB {
 	 * @throws ArrayIndexOutOfBoundsException when key does not exist
 	 */
 	public int idx(Object key) throws ArrayIndexOutOfBoundsException {
-		for(int i = 0; i < index; i++) {
-			if(key.equals(data[i][0])) {
+		for (int i = 0; i < index; i++) {
+			if (key.equals(data[i][0])) {
 				return i;
 			}
 		}
@@ -100,17 +100,17 @@ public class NamedDB {
 
 		try {
 			k = idx(key);
-		} catch(ArrayIndexOutOfBoundsException b) {
+		} catch (ArrayIndexOutOfBoundsException b) {
 			return;
 		}
 		olddata = new Object[index + 2][2];
 		// copy to olddata, skipping 'k'
-		for(i = 0            , l = 0; l < index; i++, l++) {
-			if(i == k) {
+		for (i = 0, l = 0; l < index; i++, l++) {
+			if (i == k) {
 				l++;
 				didsomething++;
 			}
-			for(j = 0; j < 2; j++) {
+			for (j = 0; j < 2; j++) {
 				olddata[i][j] = data[l][j];
 			}
 		}
@@ -132,13 +132,13 @@ public class NamedDB {
 
 		olddata = new Object[index + 2][2];
 		// copy to olddata
-		for(i = 0; i < index; i++) {
-			for(j = 0; j < 2; j++) {
+		for (i = 0; i < index; i++) {
+			for (j = 0; j < 2; j++) {
 				olddata[i][j] = data[i][j];
 			}
 		}
 		data = olddata;
-		data[index++] = new Object[] {key, val};
+		data[index++] = new Object[]{key, val};
 	}
 
 	/**
@@ -149,8 +149,8 @@ public class NamedDB {
 	 * @throws java.lang.RuntimeException
 	 */
 	public Object get(Object key) throws RuntimeException {
-		for(int i = 0; i < index; i++) {
-			if(key.equals(data[i][0])) {
+		for (int i = 0; i < index; i++) {
+			if (key.equals(data[i][0])) {
 				return data[i][1];
 			}
 		}
@@ -164,8 +164,8 @@ public class NamedDB {
 	 * @return true if an object exists, else returns false
 	 */
 	public boolean exists(Object key) {
-		for(int i = 0; i < index; i++) {
-			if(key.equals(data[i][0])) {
+		for (int i = 0; i < index; i++) {
+			if (key.equals(data[i][0])) {
 				return true;
 			}
 		}
@@ -180,7 +180,7 @@ public class NamedDB {
 	 * @throws java.lang.RuntimeException
 	 */
 	public Object getnext(int i) throws RuntimeException {
-		if(i < index && i > -1) {
+		if (i < index && i > -1) {
 			return data[i][1];
 		}
 		throw new RuntimeException("No more data");

apps/BOB/src/net/i2p/BOB/TCPio.java

@@ -26,6 +26,7 @@ package net.i2p.BOB;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
+import java.util.concurrent.atomic.AtomicBoolean;
 
 /**
  * Shove data from one stream to the other.
@@ -36,7 +37,7 @@ public class TCPio implements Runnable {
 
 	private InputStream Ain;
 	private OutputStream Aout;
-	// private NamedDB info,  database;
+	private AtomicBoolean lives;
 
 	/**
 	 * Constructor
@@ -46,11 +47,10 @@ public class TCPio implements Runnable {
 	 *
 	 * param database
 	 */
-	TCPio(InputStream Ain, OutputStream Aout /*, NamedDB info , NamedDB database */) {
+	TCPio(InputStream Ain, OutputStream Aout, AtomicBoolean lives) {
 		this.Ain = Ain;
 		this.Aout = Aout;
-	// this.info = info;
-	// this.database = database;
+		this.lives = lives;
 	}
 
 	/**
@@ -78,24 +78,31 @@ public class TCPio implements Runnable {
 		 * --Sponge
 		 *
 		 * Tested with 128 bytes, and there was no performance gain.
+		 * 8192 bytes did lower load average across many connections.
+		 * Should I raise it higer? The correct thing to do would be to
+		 * override... perhaps use NTCP, but I2P's streaming lib lacks
+		 * anything NTCP compatable.
 		 *
 		 * --Sponge
 		 */
 
 		int b;
-		byte a[] = new byte[1];
-		boolean spin = true;
+		byte a[] = new byte[8192];
 		try {
 			try {
-				while (spin) {
-					b = Ain.read(a, 0, 1);
+				while (lives.get()) {
+					b = Ain.read(a, 0, 8192);
 					if (b > 0) {
 						Aout.write(a, 0, b);
 					} else if (b == 0) {
-						Thread.yield(); // this should act like a mini sleep.
-						if (Ain.available() == 0) {
-							Thread.sleep(10);
+// Will this die? We'll see.
+						while(Ain.available() == 0) {
+							Thread.sleep(20);
 						}
+//						Thread.yield(); // this should act like a mini sleep.
+//						if (Ain.available() == 0) {
+//							Thread.sleep(10);
+//						}
 					} else {
 						/* according to the specs:
 						 *
@@ -105,9 +112,6 @@ public class TCPio implements Runnable {
 						 *
 						 */
 						// System.out.println("TCPio: End Of Stream");
-						// Ain.close();
-						// Aout.close();
-						//return;
 						break;
 					}
 				}

apps/BOB/src/net/i2p/BOB/TCPlistener.java

@@ -29,6 +29,7 @@ import java.net.Socket;
 import java.net.SocketTimeoutException;
 // import net.i2p.client.I2PSession;
 // import net.i2p.client.I2PSessionException;
+import java.util.concurrent.atomic.AtomicBoolean;
 import net.i2p.client.streaming.I2PServerSocket;
 import net.i2p.client.streaming.I2PSocketManager;
 import net.i2p.util.Log;
@@ -45,6 +46,7 @@ public class TCPlistener implements Runnable {
 	public I2PSocketManager socketManager;
 	public I2PServerSocket serverSocket;
 	private ServerSocket listener;
+	private AtomicBoolean lives;
 
 	/**
 	 * Constructor
@@ -53,22 +55,13 @@ public class TCPlistener implements Runnable {
 	 * @param database
 	 * @param _log
 	 */
-	TCPlistener(ServerSocket listener, I2PSocketManager S, NamedDB info, NamedDB database, Log _log) {
+	TCPlistener(ServerSocket listener, I2PSocketManager S, NamedDB info, NamedDB database, Log _log, AtomicBoolean lives) {
 		this.database = database;
 		this.info = info;
 		this._log = _log;
 		this.socketManager = S;
 		this.listener = listener;
-	}
-
-	private void rlock() throws Exception {
-		database.getReadLock();
-		info.getReadLock();
-	}
-
-	private void runlock() throws Exception {
-		database.releaseReadLock();
-		info.releaseReadLock();
+		this.lives = lives;
 	}
 
 	/**
@@ -77,47 +70,29 @@ public class TCPlistener implements Runnable {
 	 */
 	public void run() {
 		boolean g = false;
-		boolean spin = true;
 		int conn = 0;
+		Socket server = null;
 		try {
-			die:
-			{
-				try {
-					Socket server = new Socket();
-					listener.setSoTimeout(50); // We don't block, we cycle and check.
-					while (spin) {
-						try {
-							rlock();
-						} catch (Exception e) {
-							break die;
-						}
-						try {
-							spin = info.get("RUNNING").equals(Boolean.TRUE);
-						} catch (Exception e) {
-							try {
-								runlock();
-							} catch (Exception e2) {
-								break die;
-							}
-							break die;
-						}
-						try {
-							server = listener.accept();
-							g = true;
-						} catch (SocketTimeoutException ste) {
-							g = false;
-						}
-						if (g) {
-							conn++;
-							// toss the connection to a new thread.
-							TCPtoI2P conn_c = new TCPtoI2P(socketManager, server, info, database);
-							Thread t = new Thread(conn_c, Thread.currentThread().getName() + " TCPtoI2P " + conn);
-							t.start();
-							g = false;
-						}
+			try {
+				listener.setSoTimeout(50); // We don't block, we cycle and check.
+				while (lives.get()) {
+					try {
+						server = listener.accept();
+						server.setKeepAlive(true);
+						g = true;
+					} catch (SocketTimeoutException ste) {
+						g = false;
+					}
+					if (g) {
+						conn++;
+						// toss the connection to a new thread.
+						TCPtoI2P conn_c = new TCPtoI2P(socketManager, server, info, database, lives);
+						Thread t = new Thread(conn_c, Thread.currentThread().getName() + " TCPtoI2P " + conn);
+						t.start();
+						g = false;
 					}
-				} catch (IOException ioe) {
 				}
+			} catch (IOException ioe) {
 			}
 		} finally {
 			try {

apps/BOB/src/net/i2p/BOB/TCPtoI2P.java

@@ -30,6 +30,7 @@ import java.io.OutputStream;
 import java.net.ConnectException;
 import java.net.NoRouteToHostException;
 import java.net.Socket;
+import java.util.concurrent.atomic.AtomicBoolean;
 import net.i2p.I2PException;
 import net.i2p.client.streaming.I2PSocket;
 import net.i2p.client.streaming.I2PSocketManager;
@@ -49,6 +50,7 @@ public class TCPtoI2P implements Runnable {
 	private NamedDB info,  database;
 	private Socket sock;
 	private I2PSocketManager socketManager;
+	private AtomicBoolean lives;
 
 	/**
 	 * Constructor
@@ -57,11 +59,12 @@ public class TCPtoI2P implements Runnable {
 	 * param info
 	 * param database
 	 */
-	TCPtoI2P(I2PSocketManager i2p, Socket socket , NamedDB info, NamedDB database) {
+	TCPtoI2P(I2PSocketManager i2p, Socket socket, NamedDB info, NamedDB database, AtomicBoolean lives) {
 		this.sock = socket;
 		this.info = info;
 		this.database = database;
 		this.socketManager = i2p;
+		this.lives = lives;
 	}
 
 	/**
@@ -143,8 +146,14 @@ public class TCPtoI2P implements Runnable {
 				input = line.toLowerCase();
 				Destination dest = null;
 				if (input.endsWith(".i2p")) {
-					dest = I2PTunnel.destFromName(input);
-					line = dest.toBase64();
+					try {
+						dest = I2PTunnel.destFromName(input);
+						line = dest.toBase64();
+					} catch (NullPointerException npe) {
+						// Could not find the destination!?
+						Emsg("Can't find destination: " + input, out);
+						return;
+					}
 				}
 				dest = new Destination();
 				dest.fromBase64(line);
@@ -157,19 +166,15 @@ public class TCPtoI2P implements Runnable {
 					Iin = I2P.getInputStream();
 					Iout = I2P.getOutputStream();
 					// setup to cross the streams
-					TCPio conn_c = new TCPio(in, Iout /*, info, database */); // app -> I2P
-					TCPio conn_a = new TCPio(Iin, out /*, info, database */); // I2P -> app
+					TCPio conn_c = new TCPio(in, Iout, lives); // app -> I2P
+					TCPio conn_a = new TCPio(Iin, out, lives); // I2P -> app
 					t = new Thread(conn_c, Thread.currentThread().getName() + " TCPioA");
 					q = new Thread(conn_a, Thread.currentThread().getName() + " TCPioB");
 					// Fire!
 					t.start();
 					q.start();
-					boolean spin = true;
-					while (t.isAlive() && q.isAlive()) { // AND is used here to kill off the other thread
+					while (t.isAlive() && q.isAlive() && lives.get()) { // AND is used here to kill off the other thread
 						Thread.sleep(10); //sleep for 10 ms
-						rlock();
-						spin = info.get("RUNNING").equals(Boolean.TRUE);
-						runlock();
 					}
 				} catch (I2PException e) {
 					Emsg(e.toString(), out);

apps/BOB/src/net/i2p/BOB/UDPIOthread.java

@@ -78,26 +78,26 @@ public class UDPIOthread implements I2PSessionListener, Runnable {
 		try {
 			in = new DataInputStream(socket.getInputStream());
 			out = new DataOutputStream(socket.getOutputStream());
-			while(up) {
+			while (up) {
 				int c = in.read(data);
 				// Note: could do a loopback test here with a wrapper.
 				boolean ok = _session.sendMessage(_peerDestination, data, 0, c);
 
-				if(!ok) {
+				if (!ok) {
 					up = false; // Is this the right thing to do??
 				}
 			}
-		} catch(IOException ioe) {
+		} catch (IOException ioe) {
 			_log.error("Error running", ioe);
-		} catch(I2PSessionException ise) {
+		} catch (I2PSessionException ise) {
 			_log.error("Error communicating", ise);
 		//		} catch(DataFormatException dfe) {
 		//			_log.error("Peer destination file is not valid", dfe);
 		} finally {
-			if(_session != null) {
+			if (_session != null) {
 				try {
 					_session.destroySession();
-				} catch(I2PSessionException ise) {
+				} catch (I2PSessionException ise) {
 					// ignored
 				}
 			}
@@ -116,9 +116,9 @@ public class UDPIOthread implements I2PSessionListener, Runnable {
 			byte msg[] = session.receiveMessage(msgId);
 			out.write(msg);
 			out.flush();
-		} catch(I2PSessionException ise) {
+		} catch (I2PSessionException ise) {
 			up = false;
-		} catch(IOException ioe) {
+		} catch (IOException ioe) {
 			up = false;
 		}
 	}

apps/addressbook/java/src/addressbook/Servlet.java

@@ -1,63 +0,0 @@
-/*
- * Copyright (c) 2004 Ragnarok
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
- * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-
-package addressbook;
-
-import javax.servlet.GenericServlet;
-import javax.servlet.ServletConfig;
-import javax.servlet.ServletException;
-import javax.servlet.ServletRequest;
-import javax.servlet.ServletResponse;
-
-/**
- * A wrapper for addressbook to allow it to be started as a web application.
- * 
- * @author Ragnarok
- *
- */
-public class Servlet extends GenericServlet {
-
-    /* (non-Javadoc)
-     * @see javax.servlet.Servlet#service(javax.servlet.ServletRequest, javax.servlet.ServletResponse)
-     */
-    public void service(ServletRequest request, ServletResponse response) {
-    }
-
-    /* (non-Javadoc)
-     * @see javax.servlet.Servlet#init(javax.servlet.ServletConfig)
-     */
-    @Override
-    public void init(ServletConfig config) {
-        try {
-            super.init(config);
-        } catch (ServletException exp) {
-        }
-        String[] args = new String[1];
-        args[0] = config.getInitParameter("home");
-        DaemonThread thread = new DaemonThread(args);
-        thread.setDaemon(true);
-        thread.setName("Addressbook");
-        thread.start();
-        System.out.println("INFO: Starting Addressbook " + Daemon.VERSION);
-        System.out.println("INFO: config root under " + args[0]);
-    }
-
-}

apps/addressbook/java/src/net/i2p/addressbook/AddressBook.java

@@ -19,7 +19,7 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-package addressbook;
+package net.i2p.addressbook;
 
 import java.io.File;
 import java.io.IOException;
@@ -94,20 +94,21 @@ public class AddressBook {
      * @param proxyPort port number of proxy
      */
     public AddressBook(Subscription subscription, String proxyHost, int proxyPort) {
+        File tmp = new File(I2PAppContext.getGlobalContext().getTempDir(), "addressbook.tmp");
         this.location = subscription.getLocation();
         EepGet get = new EepGet(I2PAppContext.getGlobalContext(), true,
-                proxyHost, proxyPort, 0, -1l, MAX_SUB_SIZE, "addressbook.tmp", null,
+                proxyHost, proxyPort, 0, -1l, MAX_SUB_SIZE, tmp.getAbsolutePath(), null,
                 subscription.getLocation(), true, subscription.getEtag(), subscription.getLastModified(), null);
         if (get.fetch()) {
             subscription.setEtag(get.getETag());
             subscription.setLastModified(get.getLastModified());
         }
         try {            
-            this.addresses = ConfigParser.parse(new File("addressbook.tmp"));
+            this.addresses = ConfigParser.parse(tmp);
         } catch (IOException exp) {
             this.addresses = new HashMap();
         }
-        new File("addressbook.tmp").delete();
+        tmp.delete();
     }
 
     /**
@@ -192,7 +193,8 @@ public class AddressBook {
                 (! host.endsWith(".router.i2p")) &&
                 (! host.endsWith(".console.i2p")) &&
 
-		((dest.length() == MIN_DEST_LENGTH && dest.endsWith("AAAA")) ||
+                // null cert ends with AAAA but other zero-length certs would be AA
+		((dest.length() == MIN_DEST_LENGTH && dest.endsWith("AA")) ||
 		 (dest.length() > MIN_DEST_LENGTH && dest.length() <= MAX_DEST_LENGTH)) &&
                 dest.replaceAll("[a-zA-Z0-9~-]", "").length() == 0
                 ;	

apps/addressbook/java/src/net/i2p/addressbook/ConfigParser.java

@@ -19,15 +19,15 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-package addressbook;
+package net.i2p.addressbook;
 
 import java.io.BufferedReader;
 import java.io.BufferedWriter;
 import java.io.File;
 import java.io.FileInputStream;
-import java.io.FileWriter;
 import java.io.IOException;
 import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
 import java.io.StringReader;
 import java.util.HashMap;
 import java.util.Iterator;
@@ -35,10 +35,15 @@ import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 
+import net.i2p.util.SecureFileOutputStream;
+
 /**
  * Utility class providing methods to parse and write files in config file
  * format, and subscription file format.
  * 
+ * TODO: Change file encoding from default to UTF-8?
+ *       Or switch to the DataHelper loadProps/storeProps methods?
+ * 
  * @author Ragnarok
  */
 public class ConfigParser {
@@ -274,7 +279,7 @@ public class ConfigParser {
      */
     public static void write(Map map, File file) throws IOException {
         ConfigParser
-                .write(map, new BufferedWriter(new FileWriter(file, false)));
+                .write(map, new BufferedWriter(new OutputStreamWriter(new SecureFileOutputStream(file), "UTF-8")));
     }
 
     /**
@@ -313,7 +318,7 @@ public class ConfigParser {
     public static void writeSubscriptions(List list, File file)
             throws IOException {
         ConfigParser.writeSubscriptions(list, new BufferedWriter(
-                new FileWriter(file, false)));
+                new OutputStreamWriter(new SecureFileOutputStream(file), "UTF-8")));
     }
 
 }

apps/addressbook/java/src/net/i2p/addressbook/Daemon.java

@@ -19,7 +19,7 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-package addressbook;
+package net.i2p.addressbook;
 
 import java.io.File;
 import java.util.HashMap;
@@ -28,6 +28,9 @@ import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 
+import net.i2p.I2PAppContext;
+import net.i2p.util.SecureDirectory;
+
 /**
  * Main class of addressbook.  Performs updates, and runs the main loop.
  * 
@@ -37,6 +40,7 @@ import java.util.Map;
 public class Daemon {
     public static final String VERSION = "2.0.3";
     private static final Daemon _instance = new Daemon();
+    private boolean _running;
     
     /**
      * Update the router and published address books using remote data from the
@@ -124,12 +128,15 @@ public class Daemon {
     }
     
     public void run(String[] args) {
+        _running = true;
         String settingsLocation = "config.txt";
-        String home;
+        File homeFile;
         if (args.length > 0) {
-            home = args[0];
+            homeFile = new SecureDirectory(args[0]);
+            if (!homeFile.isAbsolute())
+                homeFile = new SecureDirectory(I2PAppContext.getGlobalContext().getRouterDir(), args[0]);
         } else {
-            home = ".";
+            homeFile = new SecureDirectory(System.getProperty("user.dir"));
         }
         
         Map defaultSettings = new HashMap();
@@ -145,7 +152,6 @@ public class Daemon {
         defaultSettings.put("last_modified", "last_modified");
         defaultSettings.put("update_delay", "12");
         
-        File homeFile = new File(home);
         if (!homeFile.exists()) {
             boolean created = homeFile.mkdirs();
             if (created)
@@ -163,19 +169,21 @@ public class Daemon {
 	    // Static method, and redundent Thread.currentThread().sleep(5*60*1000);
         } catch (InterruptedException ie) {}
         
-        while (true) {
+        while (_running) {
             long delay = Long.parseLong((String) settings.get("update_delay"));
             if (delay < 1) {
                 delay = 1;
             }
             
-            update(settings, home);
+            update(settings, homeFile.getAbsolutePath());
             try {
                 synchronized (this) {
                     wait(delay * 60 * 60 * 1000);
                 }
             } catch (InterruptedException exp) {
             }
+            if (!_running)
+                break;
             settings = ConfigParser.parse(settingsFile, defaultSettings);
         }
     }
@@ -189,4 +197,9 @@ public class Daemon {
             _instance.notifyAll();
         }
     }
+
+    public static void stop() {
+        _instance._running = false;
+        wakeup();
+    }
 }

apps/addressbook/java/src/net/i2p/addressbook/DaemonThread.java

@@ -19,7 +19,7 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-package addressbook;
+package net.i2p.addressbook;
 
 /**
  * A thread that waits five minutes, then runs the addressbook daemon.  
@@ -51,4 +51,9 @@ public class DaemonThread extends Thread {
         //}
         Daemon.main(this.args);
     }
-}
+
+    public void halt() {
+        Daemon.stop();
+        interrupt();
+    }
+}

apps/addressbook/java/src/net/i2p/addressbook/Log.java

@@ -19,7 +19,7 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-package addressbook;
+package net.i2p.addressbook;
 
 import java.io.BufferedWriter;
 import java.io.File;

apps/addressbook/java/src/net/i2p/addressbook/Servlet.java

@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) 2004 Ragnarok
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+package net.i2p.addressbook;
+
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.util.Random;
+
+import javax.servlet.ServletConfig;
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+/**
+ * A wrapper for addressbook to allow it to be started as a web application.
+ * 
+ * This was a GenericServlet, we make it an HttpServlet solely to provide a hook
+ * for SusiDNS to wake us up when the subscription list changes.
+ * 
+ * @author Ragnarok
+ *
+ */
+public class Servlet extends HttpServlet {
+    private DaemonThread thread;
+    private String nonce;
+    private static final String PROP_NONCE = "addressbook.nonce";
+
+    /**
+     * Hack to allow susidns to kick the daemon when the subscription list changes.
+     * URL must be /addressbook/ with wakeup param set, and nonce param set from system property.
+     *
+     * (non-Javadoc)
+     * see javax.servlet.Servlet#service(javax.servlet.ServletRequest, javax.servlet.ServletResponse)
+     */
+    public void service(HttpServletRequest request, HttpServletResponse response) throws IOException {
+        //System.err.println("Got request nonce = " + request.getParameter("nonce"));
+        if (this.thread != null && request.getParameter("wakeup") != null &&
+            this.nonce != null && this.nonce.equals(request.getParameter("nonce"))) {
+            //System.err.println("Sending interrupt");
+            this.thread.interrupt();
+            // no output
+        } else {
+            PrintWriter out = response.getWriter();
+            out.write("I2P addressbook OK");
+        }
+    }
+
+    /* (non-Javadoc)
+     * @see javax.servlet.Servlet#init(javax.servlet.ServletConfig)
+     */
+    @Override
+    public void init(ServletConfig config) {
+        try {
+            super.init(config);
+        } catch (ServletException exp) {
+            System.err.println("Addressbook init exception: " + exp);
+        }
+        this.nonce = "" + Math.abs((new Random()).nextLong());
+        // put the nonce where susidns can get it
+        System.setProperty(PROP_NONCE, this.nonce);
+        String[] args = new String[1];
+        args[0] = config.getInitParameter("home");
+        this.thread = new DaemonThread(args);
+        this.thread.setDaemon(true);
+        this.thread.setName("Addressbook");
+        this.thread.start();
+        System.out.println("INFO: Starting Addressbook " + Daemon.VERSION);
+        //System.out.println("INFO: config root under " + args[0]);
+    }
+
+    @Override
+    public void destroy() {
+        this.thread.halt();
+        super.destroy();
+    }
+}

apps/addressbook/java/src/net/i2p/addressbook/Subscription.java

@@ -19,7 +19,7 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-package addressbook;
+package net.i2p.addressbook;
 
 /**
  * A subscription to a remote address book.

apps/addressbook/java/src/net/i2p/addressbook/SubscriptionIterator.java

@@ -19,7 +19,7 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-package addressbook;
+package net.i2p.addressbook;
 
 import java.util.Iterator;
 import java.util.List;

apps/addressbook/java/src/net/i2p/addressbook/SubscriptionList.java

@@ -19,7 +19,7 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-package addressbook;
+package net.i2p.addressbook;
 
 import java.io.File;
 import java.io.IOException;

apps/addressbook/web.xml

@@ -6,11 +6,17 @@
 <web-app>
 	<servlet>
 		<servlet-name>addressbook</servlet-name>
-		<servlet-class>addressbook.Servlet</servlet-class>
+		<servlet-class>net.i2p.addressbook.Servlet</servlet-class>
 		<init-param>
 		    <param-name>home</param-name>
 		    <param-value>./addressbook</param-value>
 		</init-param>
 		<load-on-startup>1</load-on-startup>
 	</servlet>
-</web-app>
+
+    <servlet-mapping> 
+      <servlet-name>addressbook</servlet-name>
+      <url-pattern>/*</url-pattern>
+    </servlet-mapping>
+
+</web-app>

apps/admin/java/src/net/i2p/router/admin/AdminRunner.java

@@ -73,7 +73,7 @@ class AdminRunner implements Runnable {
     }
     
     private void reply(OutputStream out, String content) throws IOException {
-        StringBuffer reply = new StringBuffer(10240);
+        StringBuilder reply = new StringBuilder(10240);
         reply.append("HTTP/1.1 200 OK\n");
         reply.append("Connection: close\n");
         reply.append("Cache-control: no-cache\n");
@@ -90,7 +90,7 @@ class AdminRunner implements Runnable {
     }
     
     private void replyText(OutputStream out, String content) throws IOException {
-        StringBuffer reply = new StringBuffer(10240);
+        StringBuilder reply = new StringBuilder(10240);
         reply.append("HTTP/1.1 200 OK\n");
         reply.append("Connection: close\n");
         reply.append("Cache-control: no-cache\n");

apps/i2psnark/i2psnark.config

@@ -1 +1,7 @@
+# NOTE: This I2P config file must use UTF-8 encoding
+#
+# If you have a 'split' directory installation, with configuration
+# files in ~/.i2p (Linux) or %APPDATA%\I2P (Windows), be sure to
+# edit the file in the configuration directory, NOT the install directory.
+#
 i2psnark.dir=i2psnark

apps/i2psnark/java/bmsg.sh

@@ -0,0 +1,17 @@
+#
+# Update messages_xx.po and messages_xx.class files,
+# from both java and jsp sources.
+# Requires installed programs xgettext, msgfmt, msgmerge, and find.
+# zzz - public domain
+#
+
+## launching sh.exe with -login parameter will open a shell with the current path always pointing to \bin\
+## need to cd into our orignal path - where we call sh.exe from.
+
+cd $CALLFROM
+## echo $PWD
+
+## except this everything is the same with bundle-message.sh
+## walking - public domain :-D
+
+source bundle-messages.sh $PARAS

apps/i2psnark/java/build.xml

@@ -37,50 +37,72 @@
         </javac>
     </target>
     <target name="jar" depends="builddep, compile">
-        <jar destfile="./build/i2psnark.jar" basedir="./build/obj" includes="**/*.class" excludes="**/*Servlet.class">
+        <jar destfile="./build/i2psnark.jar" basedir="./build/obj" includes="**/*.class" excludes="**/I2PSnarkServlet*.class **/messages_*.class">
             <manifest>
                 <attribute name="Main-Class" value="org.klomp.snark.Snark" />
                 <attribute name="Class-Path" value="i2p.jar mstreaming.jar streaming.jar" />
             </manifest>
         </jar>
     </target>    
-    <target name="war" depends="jar"> 
-        <war destfile="../i2psnark.war" webxml="../web.xml">
-          <classes dir="./build/obj" includes="**/*" />
+    <!-- Ideally we would include
+      -  only include the servlet, everything else is in the jar.
+      -  However, the wrapper.config classpath in existing installs
+      -  does not include i2psnark.jar.
+      -  So we must continue to duplicate everything in the war.
+          <classes dir="./build/obj" includes="**/I2PSnarkServlet*.class" />
+     -->
+    <target name="war" depends="jar, bundle"> 
+        <war destfile="../i2psnark.war" webxml="../web.xml" basedir="../" includes="_icons/*" >
+          <!-- include only the web stuff, as of 0.7.12 the router will add i2psnark.jar to the classpath for the war -->
+          <classes dir="./build/obj" includes="**/web/*.class" />
         </war>
     </target>
     
+    <target name="bundle" depends="compile">
+        <!-- Update the messages_*.po files.
+             We need to supply the bat file for windows, and then change the fail property to true -->
+        <exec executable="sh" osfamily="unix" failifexecutionfails="false" >
+            <arg value="./bundle-messages.sh" />
+        </exec>
+        <exec executable="sh" osfamily="mac" failifexecutionfails="false" >
+            <arg value="./bundle-messages.sh" />
+        </exec>
+        <exec executable="cmd" osfamily="windows" failifexecutionfails="false" >
+            <arg value="/c" />
+            <arg value="bundle-messages.bat" />
+        </exec>
+    </target>
+
+    <target name="poupdate" depends="builddep, compile">
+        <!-- Update the messages_*.po files.  -->
+        <exec executable="sh" osfamily="unix" failifexecutionfails="true" >
+            <arg value="./bundle-messages.sh" />
+            <arg value="-p" />
+        </exec>
+        <exec executable="sh" osfamily="mac" failifexecutionfails="true" >
+            <arg value="./bundle-messages.sh" />
+            <arg value="-p" />
+        </exec>
+        <exec executable="cmd" osfamily="windows" failifexecutionfails="true" >
+            <arg value="/c" />
+            <arg value="bundle-messages.bat" />
+            <arg value="-p" />
+        </exec>
+    </target>
+
     <target name="standalone" depends="standalone_prep">
         <zip destfile="i2psnark-standalone.zip">
           <zipfileset dir="./dist/" prefix="i2psnark/" />
         </zip>
     </target>
     <target name="standalone_prep" depends="war">
-        <javac debug="true" deprecation="on" source="1.5" target="1.5" 
-               destdir="./build" srcdir="src/" includes="org/klomp/snark/web/RunStandalone.java" >
-            <compilerarg line="${javac.compilerargs}" />
-            <classpath>
-                <pathelement location="../../jetty/jettylib/commons-logging.jar" />
-                <pathelement location="../../jetty/jettylib/commons-el.jar" />
-                <pathelement location="../../jetty/jettylib/org.mortbay.jetty.jar" />
-                <pathelement location="../../jetty/jettylib/javax.servlet.jar" />
-                <pathelement location="../../../core/java/build/i2p.jar" />
-            </classpath>
-        </javac>
-    
-        <jar destfile="./build/launch-i2psnark.jar" basedir="./build/" includes="org/klomp/snark/web/RunStandalone.class">
-            <manifest>
-                <attribute name="Main-Class" value="org.klomp.snark.web.RunStandalone" />
-                <attribute name="Class-Path" value="lib/i2p.jar lib/mstreaming.jar lib/streaming.jar lib/commons-el.jar lib/commons-logging.jar lib/jasper-compiler.jar lib/jasper-runtime.jar lib/javax.servlet.jar lib/org.mortbay.jetty.jar" />
-            </manifest>
-        </jar>
-
         <delete dir="./dist" />
         <mkdir dir="./dist" />
-        <copy file="./build/launch-i2psnark.jar" tofile="./dist/launch-i2psnark.jar" />
+        <copy file="../launch-i2psnark" todir="./dist/" />
         <mkdir dir="./dist/webapps" />
         <copy file="../i2psnark.war" tofile="./dist/webapps/i2psnark.war" />
         <mkdir dir="./dist/lib" />
+        <copy file="./build/i2psnark.jar" tofile="./dist/lib/i2psnark.jar" />
         <copy file="../../../core/java/build/i2p.jar" tofile="./dist/lib/i2p.jar" />
         <copy file="../../jetty/jettylib/commons-el.jar" tofile="./dist/lib/commons-el.jar" />
         <copy file="../../jetty/jettylib/commons-logging.jar" tofile="./dist/lib/commons-logging.jar" />
@@ -92,7 +114,6 @@
         <copy file="../../streaming/java/build/streaming.jar" tofile="./dist/lib/streaming.jar" />
         <copy file="../jetty-i2psnark.xml" tofile="./dist/jetty-i2psnark.xml" />
         <copy file="../readme-standalone.txt" tofile="./dist/readme.txt" />
-        <mkdir dir="./dist/work" />
         <mkdir dir="./dist/logs" />
 
         <zip destfile="i2psnark-standalone.zip">
@@ -104,11 +125,10 @@
         <delete dir="./build" />
         <delete file="../i2psnark.war" />
         <delete file="./i2psnark-standalone.zip" />
+        <delete dir="./dist" />
     </target>
     <target name="cleandep" depends="clean">
-        <ant dir="../../ministreaming/java/" target="distclean" />
     </target>
     <target name="distclean" depends="clean">
-        <ant dir="../../ministreaming/java/" target="distclean" />
     </target>
 </project>

apps/i2psnark/java/bundle-messages.bat

@@ -0,0 +1,26 @@
+@echo off
+set Callfrom=%cd%
+set Paras=%1
+
+rem before calling make sure you have msys and mingw 's "bin" path 
+rem in your current searching path
+rem type "set path" to check 
+if not exist ..\locale\*.only goto updateALL
+
+rem put a messages_xx.only(eg messages_zh.only) into locale folder
+rem this script will only touch the po file(eg zh) you specified, leaving other po files untact.
+
+for %%i in (..\locale\*.only) do set PO=%%~ni
+echo [Notice] Yu choose to Ony update the choosen file: %PO%.po 
+for %%i in (..\locale\*.po) do if not %%~ni==%PO% ren %%i %%~ni.po-
+
+call sh --login %cd%\bmsg.sh
+
+for %%i in (..\locale\*.po-) do if not %%~ni==%PO% ren %%i %%~ni.po
+goto end
+
+:updateALL
+call sh --login %cd%\bmsg.sh
+
+:end
+echo End of Message Bundling

apps/i2psnark/java/bundle-messages.sh

@@ -0,0 +1,85 @@
+#
+# Update messages_xx.po and messages_xx.class files,
+# from both java and jsp sources.
+# Requires installed programs xgettext, msgfmt, msgmerge, and find.
+#
+# usage:
+#    bundle-messages.sh (generates the resource bundle from the .po file)
+#    bundle-messages.sh -p (updates the .po file from the source tags, then generates the resource bundle)
+#
+# zzz - public domain
+#
+CLASS=org.klomp.snark.web.messages
+TMPFILE=build/javafiles.txt
+export TZ=UTC
+
+if [ "$1" = "-p" ]
+then
+	POUPDATE=1
+fi
+
+# add ../java/ so the refs will work in the po file
+JPATHS="../java/src"
+for i in ../locale/messages_*.po
+do
+	# get language
+	LG=${i#../locale/messages_}
+	LG=${LG%.po}
+
+	if [ "$POUPDATE" = "1" ]
+	then
+		# make list of java files newer than the .po file
+		find $JPATHS -name *.java -newer $i > $TMPFILE
+	fi
+
+	if [ -s build/obj/org/klomp/snark/web/messages_$LG.class -a \
+	     build/obj/org/klomp/snark/web/messages_$LG.class -nt $i -a \
+	     ! -s $TMPFILE ]
+	then
+		continue
+	fi
+
+	if [ "$POUPDATE" = "1" ]
+	then
+	 	echo "Updating the $i file from the tags..."
+		# extract strings from java and jsp files, and update messages.po files
+		# translate calls must be one of the forms:
+		# _("foo")
+		# _x("foo")
+		# To start a new translation, copy the header from an old translation to the new .po file,
+		# then ant distclean poupdate.
+		find $JPATHS -name *.java > $TMPFILE
+		xgettext -f $TMPFILE -F -L java --from-code=UTF-8 --add-comments\
+	                 --keyword=_ --keyword=_x \
+		         -o ${i}t
+		if [ $? -ne 0 ]
+		then
+			echo 'Warning - xgettext failed, not updating translations'
+			rm -f ${i}t
+			break
+		fi
+		msgmerge -U --backup=none $i ${i}t
+		if [ $? -ne 0 ]
+		then
+			echo 'Warning - msgmerge failed, not updating translations'
+			rm -f ${i}t
+			break
+		fi
+		rm -f ${i}t
+		# so we don't do this again
+		touch $i
+	fi
+
+	echo "Generating ${CLASS}_$LG ResourceBundle..."
+
+	# convert to class files in build/obj
+	msgfmt --java --statistics -r $CLASS -l $LG -d build/obj $i
+	if [ $? -ne 0 ]
+	then
+		echo 'Warning - msgfmt failed, not updating translations'
+		break
+	fi
+done
+rm -f $TMPFILE
+# todo: return failure
+exit 0

apps/i2psnark/java/src/org/klomp/snark/BWLimits.java

@@ -7,7 +7,6 @@ package org.klomp.snark;
 import java.util.Arrays;
 import java.util.Properties;
 
-import net.i2p.I2PAppContext;
 import net.i2p.client.I2PSessionException;
 import net.i2p.client.I2PClient;
 import net.i2p.client.I2PSession;

apps/i2psnark/java/src/org/klomp/snark/BitField.java

@@ -137,10 +137,11 @@ public class BitField
     return count >= size;
   }
 
+    @Override
   public String toString()
   {
     // Not very efficient
-    StringBuffer sb = new StringBuffer("BitField(");
+    StringBuilder sb = new StringBuilder("BitField(");
     sb.append(size).append(")[");
     for (int i = 0; i < size; i++)
       if (get(i))

apps/i2psnark/java/src/org/klomp/snark/ConnectionAcceptor.java

@@ -25,6 +25,7 @@ import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 
+import net.i2p.I2PAppContext;
 import net.i2p.I2PException;
 import net.i2p.client.streaming.I2PServerSocket;
 import net.i2p.client.streaming.I2PSocket;
@@ -36,7 +37,7 @@ import net.i2p.util.Log;
  */
 public class ConnectionAcceptor implements Runnable
 {
-  private Log _log = new Log(ConnectionAcceptor.class);
+  private final Log _log = I2PAppContext.getGlobalContext().logManager().getLog(ConnectionAcceptor.class);
   private I2PServerSocket serverSocket;
   private PeerAcceptor peeracceptor;
   private Thread thread;

apps/i2psnark/java/src/org/klomp/snark/I2PSnarkUtil.java

@@ -4,7 +4,6 @@ import java.io.File;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.HashMap;
-import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
@@ -17,16 +16,20 @@ import net.i2p.I2PException;
 import net.i2p.client.I2PSession;
 import net.i2p.client.streaming.I2PServerSocket;
 import net.i2p.client.streaming.I2PSocket;
+import net.i2p.client.streaming.I2PSocketEepGet;
 import net.i2p.client.streaming.I2PSocketManager;
 import net.i2p.client.streaming.I2PSocketManagerFactory;
 import net.i2p.data.DataFormatException;
 import net.i2p.data.Destination;
 import net.i2p.data.Hash;
+import net.i2p.util.ConcurrentHashSet;
 import net.i2p.util.EepGet;
 import net.i2p.util.FileUtil;
 import net.i2p.util.Log;
+import net.i2p.util.SecureDirectory;
 import net.i2p.util.SimpleScheduler;
 import net.i2p.util.SimpleTimer;
+import net.i2p.util.Translate;
 
 /**
  * I2P specific helpers for I2PSnark
@@ -43,37 +46,39 @@ public class I2PSnarkUtil {
     private int _proxyPort;
     private String _i2cpHost;
     private int _i2cpPort;
-    private Map _opts;
+    private Map<String, String> _opts;
     private I2PSocketManager _manager;
     private boolean _configured;
-    private Set _shitlist;
+    private final Set<Hash> _shitlist;
     private int _maxUploaders;
     private int _maxUpBW;
     private int _maxConnections;
     private File _tmpDir;
-    
+    private int _startupDelay;
+
+    public static final int DEFAULT_STARTUP_DELAY = 3;
     public static final String PROP_USE_OPENTRACKERS = "i2psnark.useOpentrackers";
     public static final boolean DEFAULT_USE_OPENTRACKERS = true;
     public static final String PROP_OPENTRACKERS = "i2psnark.opentrackers";
     public static final String DEFAULT_OPENTRACKERS = "http://tracker.welterde.i2p/a";
     public static final int DEFAULT_MAX_UP_BW = 8;  //KBps
     public static final int MAX_CONNECTIONS = 16; // per torrent
-
     public I2PSnarkUtil(I2PAppContext ctx) {
         _context = ctx;
         _log = _context.logManager().getLog(Snark.class);
         _opts = new HashMap();
-        setProxy("127.0.0.1", 4444);
+        //setProxy("127.0.0.1", 4444);
         setI2CPConfig("127.0.0.1", 7654, null);
-        _shitlist = new HashSet(64);
+        _shitlist = new ConcurrentHashSet();
         _configured = false;
         _maxUploaders = Snark.MAX_TOTAL_UPLOADERS;
         _maxUpBW = DEFAULT_MAX_UP_BW;
         _maxConnections = MAX_CONNECTIONS;
+        _startupDelay = DEFAULT_STARTUP_DELAY;
         // This is used for both announce replies and .torrent file downloads,
         // so it must be available even if not connected to I2CP.
         // so much for multiple instances
-        _tmpDir = new File("tmp", "i2psnark");
+        _tmpDir = new SecureDirectory(ctx.getTempDir(), "i2psnark");
         FileUtil.rmdir(_tmpDir, false);
         _tmpDir.mkdirs();
     }
@@ -83,6 +88,7 @@ public class I2PSnarkUtil {
      * host for no proxying)
      *
      */
+/*****
     public void setProxy(String host, int port) {
         if ( (host != null) && (port > 0) ) {
             _shouldProxy = true;
@@ -95,6 +101,7 @@ public class I2PSnarkUtil {
         }
         _configured = true;
     }
+******/
     
     public boolean configured() { return _configured; }
     
@@ -123,22 +130,31 @@ public class I2PSnarkUtil {
         _maxConnections = limit;
         _configured = true;
     }
+
+    public void setStartupDelay(int minutes) {
+	_startupDelay = minutes;
+	_configured = true;
+    }
     
     public String getI2CPHost() { return _i2cpHost; }
     public int getI2CPPort() { return _i2cpPort; }
-    public Map getI2CPOptions() { return _opts; }
+    public Map<String, String> getI2CPOptions() { return _opts; }
     public String getEepProxyHost() { return _proxyHost; }
     public int getEepProxyPort() { return _proxyPort; }
     public boolean getEepProxySet() { return _shouldProxy; }
     public int getMaxUploaders() { return _maxUploaders; }
     public int getMaxUpBW() { return _maxUpBW; }
     public int getMaxConnections() { return _maxConnections; }
-    
+    public int getStartupDelay() { return _startupDelay; }  
+  
     /**
      * Connect to the router, if we aren't already
      */
     synchronized public boolean connect() {
         if (_manager == null) {
+            // try to find why reconnecting after stop
+            if (_log.shouldLog(Log.DEBUG))
+                _log.debug("Connecting to I2P", new Exception("I did it"));
             Properties opts = new Properties();
             if (_opts != null) {
                 for (Iterator iter = _opts.keySet().iterator(); iter.hasNext(); ) {
@@ -150,6 +166,10 @@ public class I2PSnarkUtil {
                 opts.setProperty("inbound.nickname", "I2PSnark");
             if (opts.getProperty("outbound.nickname") == null)
                 opts.setProperty("outbound.nickname", "I2PSnark");
+            // Dont do this for now, it is set in I2PSocketEepGet for announces,
+            // we don't need fast handshake for peer connections.
+            //if (opts.getProperty("i2p.streaming.connectDelay") == null)
+            //    opts.setProperty("i2p.streaming.connectDelay", "500");
             if (opts.getProperty("i2p.streaming.inactivityTimeout") == null)
                 opts.setProperty("i2p.streaming.inactivityTimeout", "240000");
             if (opts.getProperty("i2p.streaming.inactivityAction") == null)
@@ -173,6 +193,7 @@ public class I2PSnarkUtil {
      */
     public void disconnect() {
         I2PSocketManager mgr = _manager;
+        // FIXME this can cause race NPEs elsewhere
         _manager = null;
         _shitlist.clear();
         mgr.destroySocketManager();
@@ -184,19 +205,22 @@ public class I2PSnarkUtil {
     
     /** connect to the given destination */
     I2PSocket connect(PeerID peer) throws IOException {
-        Hash dest = peer.getAddress().calculateHash();
-        synchronized (_shitlist) {
-            if (_shitlist.contains(dest))
-                throw new IOException("Not trying to contact " + dest.toBase64() + ", as they are shitlisted");
-        }
+        I2PSocketManager mgr = _manager;
+        if (mgr == null)
+            throw new IOException("No socket manager");
+        Destination addr = peer.getAddress();
+        if (addr == null)
+            throw new IOException("Null address");
+        Hash dest = addr.calculateHash();
+        if (_shitlist.contains(dest))
+            throw new IOException("Not trying to contact " + dest.toBase64() + ", as they are shitlisted");
         try {
-            I2PSocket rv = _manager.connect(peer.getAddress());
-            if (rv != null) synchronized (_shitlist) { _shitlist.remove(dest); }
+            I2PSocket rv = _manager.connect(addr);
+            if (rv != null)
+                _shitlist.remove(dest);
             return rv;
         } catch (I2PException ie) {
-            synchronized (_shitlist) {
-                _shitlist.add(dest);
-            }
+            _shitlist.add(dest);
             SimpleScheduler.getInstance().addEvent(new Unshitlist(dest), 10*60*1000);
             throw new IOException("Unable to reach the peer " + peer + ": " + ie.getMessage());
         }
@@ -205,7 +229,7 @@ public class I2PSnarkUtil {
     private class Unshitlist implements SimpleTimer.TimedEvent {
         private Hash _dest;
         public Unshitlist(Hash dest) { _dest = dest; }
-        public void timeReached() { synchronized (_shitlist) { _shitlist.remove(_dest); } }
+        public void timeReached() { _shitlist.remove(_dest); }
     }
     
     /**
@@ -215,7 +239,8 @@ public class I2PSnarkUtil {
     public File get(String url, boolean rewrite) { return get(url, rewrite, 0); }
     public File get(String url, int retries) { return get(url, true, retries); }
     public File get(String url, boolean rewrite, int retries) {
-        _log.debug("Fetching [" + url + "] proxy=" + _proxyHost + ":" + _proxyPort + ": " + _shouldProxy);
+        if (_log.shouldLog(Log.DEBUG))
+            _log.debug("Fetching [" + url + "] proxy=" + _proxyHost + ":" + _proxyPort + ": " + _shouldProxy);
         File out = null;
         try {
             // we could use the system tmp dir but deleteOnExit() doesn't seem to work on all platforms...
@@ -231,12 +256,20 @@ public class I2PSnarkUtil {
         if (rewrite)
             fetchURL = rewriteAnnounce(url);
         //_log.debug("Rewritten url [" + fetchURL + "]");
-        EepGet get = new EepGet(_context, _shouldProxy, _proxyHost, _proxyPort, retries, out.getAbsolutePath(), fetchURL);
+        //EepGet get = new EepGet(_context, _shouldProxy, _proxyHost, _proxyPort, retries, out.getAbsolutePath(), fetchURL);
+        // Use our tunnel for announces and .torrent fetches too! Make sure we're connected first...
+        if (!connected()) {
+            if (!connect())
+                return null;
+        }
+        EepGet get = new I2PSocketEepGet(_context, _manager, retries, out.getAbsolutePath(), fetchURL);
         if (get.fetch()) {
-            _log.debug("Fetch successful [" + url + "]: size=" + out.length());
+            if (_log.shouldLog(Log.DEBUG))
+                _log.debug("Fetch successful [" + url + "]: size=" + out.length());
             return out;
         } else {
-            _log.warn("Fetch failed [" + url + "]");
+            if (_log.shouldLog(Log.WARN))
+                _log.warn("Fetch failed [" + url + "]");
             out.delete();
             return null;
         }
@@ -327,6 +360,11 @@ public class I2PSnarkUtil {
         return rv;
     }
     
+    /** @param ot non-null */
+    public void setOpenTrackerString(String ot) { 
+        _opts.put(PROP_OPENTRACKERS, ot);
+    }
+
     public String getOpenTrackerString() { 
         String rv = (String) _opts.get(PROP_OPENTRACKERS);
         if (rv == null)
@@ -345,7 +383,7 @@ public class I2PSnarkUtil {
         while (tok.hasMoreTokens())
             rv.add(tok.nextToken());
         
-        if (rv.size() <= 0)
+        if (rv.isEmpty())
             return null;
         return rv;
     }
@@ -390,4 +428,37 @@ public class I2PSnarkUtil {
                 break;
         }
     }
+
+    private static final String BUNDLE_NAME = "org.klomp.snark.web.messages";
+
+    /** lang in routerconsole.lang property, else current locale */
+    public String getString(String key) {
+        return Translate.getString(key, _context, BUNDLE_NAME);
+    }
+
+    /**
+     *  translate a string with a parameter
+     *  This is a lot more expensive than getString(s, ctx), so use sparingly.
+     *
+     *  @param s string to be translated containing {0}
+     *    The {0} will be replaced by the parameter.
+     *    Single quotes must be doubled, i.e. ' -> '' in the string.
+     *  @param o parameter, not translated.
+     *    To tranlslate parameter also, use _("foo {0} bar", _("baz"))
+     *    Do not double the single quotes in the parameter.
+     *    Use autoboxing to call with ints, longs, floats, etc.
+     */
+    public String getString(String s, Object o) {
+        return Translate.getString(s, o, _context, BUNDLE_NAME);
+    }
+
+    /** {0} and {1} */
+    public String getString(String s, Object o, Object o2) {
+        return Translate.getString(s, o, o2, _context, BUNDLE_NAME);
+    }
+
+    /** ngettext @since 0.7.14 */
+    public String getString(int n, String s, String p) {
+        return Translate.getString(n, s, p, _context, BUNDLE_NAME);
+    }
 }

apps/i2psnark/java/src/org/klomp/snark/Message.java

@@ -110,6 +110,7 @@ class Message
       dos.write(data, off, len);
   }
 
+    @Override
   public String toString()
   {
     switch (type)

apps/i2psnark/java/src/org/klomp/snark/MetaInfo.java

@@ -30,6 +30,7 @@ import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 
+import net.i2p.I2PAppContext;
 import net.i2p.crypto.SHA1;
 import net.i2p.data.Base64;
 import net.i2p.util.Log;
@@ -47,7 +48,7 @@ import org.klomp.snark.bencode.InvalidBEncodingException;
  */
 public class MetaInfo
 {  
-  private static final Log _log = new Log(MetaInfo.class);
+  private final Log _log = I2PAppContext.getGlobalContext().logManager().getLog(MetaInfo.class);
   private final String announce;
   private final byte[] info_hash;
   private final String name;
@@ -108,7 +109,8 @@ public class MetaInfo
    */
   public MetaInfo(Map m) throws InvalidBEncodingException
   {
-    _log.debug("Creating a metaInfo: " + m, new Exception("source"));
+    if (_log.shouldLog(Log.DEBUG))
+        _log.debug("Creating a metaInfo: " + m, new Exception("source"));
     BEValue val = (BEValue)m.get("announce");
     if (val == null)
         throw new InvalidBEncodingException("Missing announce string");
@@ -345,6 +347,7 @@ public class MetaInfo
     return length;
   }
 
+    @Override
   public String toString()
   {
     return "MetaInfo[info_hash='" + hexencode(info_hash)
@@ -362,7 +365,7 @@ public class MetaInfo
    */
   private static String hexencode(byte[] bs)
   {
-    StringBuffer sb = new StringBuffer(bs.length*2);
+    StringBuilder sb = new StringBuilder(bs.length*2);
     for (int i = 0; i < bs.length; i++)
       {
         int c = bs[i] & 0xFF;
@@ -432,7 +435,7 @@ public class MetaInfo
   private byte[] calculateInfoHash()
   {
     Map info = createInfoMap();
-    StringBuffer buf = new StringBuffer(128);
+    StringBuilder buf = new StringBuilder(128);
     buf.append("info: ");
     for (Iterator iter = info.entrySet().iterator(); iter.hasNext(); ) {
         Map.Entry entry = (Map.Entry)iter.next();
@@ -444,14 +447,16 @@ public class MetaInfo
         else
             buf.append(val.toString());
     }
-    _log.debug(buf.toString());
+    if (_log.shouldLog(Log.DEBUG))
+        _log.debug(buf.toString());
     byte[] infoBytes = BEncoder.bencode(info);
     //_log.debug("info bencoded: [" + Base64.encode(infoBytes, true) + "]");
     try
       {
         MessageDigest digest = MessageDigest.getInstance("SHA");
         byte hash[] = digest.digest(infoBytes);
-        _log.debug("info hash: [" + net.i2p.data.Base64.encode(hash) + "]");
+        if (_log.shouldLog(Log.DEBUG))
+            _log.debug("info hash: [" + net.i2p.data.Base64.encode(hash) + "]");
         return hash;
       }
     catch(NoSuchAlgorithmException nsa)

apps/i2psnark/java/src/org/klomp/snark/Peer.java

@@ -56,8 +56,8 @@ public class Peer implements Comparable
   private long _id;
   final static long CHECK_PERIOD = PeerCoordinator.CHECK_PERIOD; // 40 seconds
   final static int RATE_DEPTH = PeerCoordinator.RATE_DEPTH; // make following arrays RATE_DEPTH long
-  private long uploaded_old[] = {-1,-1,-1,-1,-1,-1};
-  private long downloaded_old[] = {-1,-1,-1,-1,-1,-1};
+  private long uploaded_old[] = {-1,-1,-1};
+  private long downloaded_old[] = {-1,-1,-1};
 
   /**
    * Creates a disconnected peer given a PeerID, your own id and the
@@ -92,7 +92,8 @@ public class Peer implements Comparable
     byte[] id  = handshake(in, out);
     this.peerID = new PeerID(id, sock.getPeerDestination());
     _id = ++__id;
-    _log.debug("Creating a new peer with " + peerID.getAddress().calculateHash().toBase64(), new Exception("creating " + _id));
+    if (_log.shouldLog(Log.DEBUG))
+        _log.debug("Creating a new peer with " + peerID.getAddress().calculateHash().toBase64(), new Exception("creating " + _id));
   }
 
   /**
@@ -106,6 +107,7 @@ public class Peer implements Comparable
   /**
    * Returns the String representation of the peerID.
    */
+    @Override
   public String toString()
   {
     if (peerID != null)
@@ -115,25 +117,32 @@ public class Peer implements Comparable
   }
 
   /**
-   * Returns socket (for debug printing)
+   * @return socket debug string (for debug printing)
    */
   public String getSocket()
   {
+    if (state != null) {
+        String r = state.getRequests();
+        if (r != null)
+            return sock.toString() + "<br>Requests: " + r;
+    }
     return sock.toString();
   }
 
   /**
    * The hash code of a Peer is the hash code of the peerID.
    */
+    @Override
   public int hashCode()
   {
-    return peerID.hashCode() ^ (2 << _id);
+    return peerID.hashCode() ^ (7777 * (int)_id);
   }
 
   /**
    * Two Peers are equal when they have the same PeerID.
    * All other properties are ignored.
    */
+    @Override
   public boolean equals(Object o)
   {
     if (o instanceof Peer)
@@ -147,6 +156,7 @@ public class Peer implements Comparable
 
   /**
    * Compares the PeerIDs.
+   * @deprecated unused?
    */
   public int compareTo(Object o)
   {
@@ -178,14 +188,16 @@ public class Peer implements Comparable
     if (state != null)
       throw new IllegalStateException("Peer already started");
 
-    _log.debug("Running connection to " + peerID.getAddress().calculateHash().toBase64(), new Exception("connecting"));    
+    if (_log.shouldLog(Log.DEBUG))
+        _log.debug("Running connection to " + peerID.getAddress().calculateHash().toBase64(), new Exception("connecting"));    
     try
       {
         // Do we need to handshake?
         if (din == null)
           {
             sock = util.connect(peerID);
-            _log.debug("Connected to " + peerID + ": " + sock);
+            if (_log.shouldLog(Log.DEBUG))
+                _log.debug("Connected to " + peerID + ": " + sock);
             if ((sock == null) || (sock.isClosed())) {
                 throw new IOException("Unable to reach " + peerID);
             }
@@ -204,14 +216,20 @@ public class Peer implements Comparable
             //  = new BufferedOutputStream(sock.getOutputStream());
             byte [] id = handshake(in, out); //handshake(bis, bos);
             byte [] expected_id = peerID.getID();
-            if (!Arrays.equals(expected_id, id))
-              throw new IOException("Unexpected peerID '"
+            if (expected_id == null) {
+                peerID.setID(id);
+            } else if (Arrays.equals(expected_id, id)) {
+                if (_log.shouldLog(Log.DEBUG))
+                    _log.debug("Handshake got matching IDs with " + toString());
+            } else {
+                throw new IOException("Unexpected peerID '"
                                     + PeerID.idencode(id)
                                     + "' expected '"
                                     + PeerID.idencode(expected_id) + "'");
-            _log.debug("Handshake got matching IDs with " + toString());
+            }
           } else {
-            _log.debug("Already have din [" + sock + "] with " + toString());
+            if (_log.shouldLog(Log.DEBUG))
+                _log.debug("Already have din [" + sock + "] with " + toString());
           }
         
         PeerConnectionIn in = new PeerConnectionIn(this, din);
@@ -226,7 +244,8 @@ public class Peer implements Comparable
         state = s;
         listener.connected(this);
   
-        _log.debug("Start running the reader with " + toString());
+        if (_log.shouldLog(Log.DEBUG))
+            _log.debug("Start running the reader with " + toString());
         // Use this thread for running the incomming connection.
         // The outgoing connection creates its own Thread.
         out.startup();
@@ -276,7 +295,8 @@ public class Peer implements Comparable
     dout.write(my_id);
     dout.flush();
     
-    _log.debug("Wrote my shared hash and ID to " + toString());
+    if (_log.shouldLog(Log.DEBUG))
+        _log.debug("Wrote my shared hash and ID to " + toString());
     
     // Handshake read - header
     byte b = din.readByte();
@@ -303,7 +323,8 @@ public class Peer implements Comparable
 
     // Handshake read - peer id
     din.readFully(bs);
-    _log.debug("Read the remote side's hash and peerID fully from " + toString());
+    if (_log.shouldLog(Log.DEBUG))
+        _log.debug("Read the remote side's hash and peerID fully from " + toString());
     return bs;
   }
 
@@ -371,6 +392,37 @@ public class Peer implements Comparable
       s.havePiece(piece);
   }
 
+  /**
+   * Tell the other side that we are no longer interested in any of
+   * the outstanding requests (if any) for this piece.
+   * @since 0.8.1
+   */
+  void cancel(int piece) {
+    PeerState s = state;
+    if (s != null)
+      s.cancelPiece(piece);
+  }
+
+  /**
+   * Are we currently requesting the piece?
+   * @since 0.8.1
+   */
+  boolean isRequesting(int p) {
+    PeerState s = state;
+    return s != null && s.isRequesting(p);
+  }
+
+  /**
+   * Update the request queue.
+   * Call after adding wanted pieces.
+   * @since 0.8.1
+   */
+  void request() {
+    PeerState s = state;
+    if (s != null)
+      s.addRequest();
+  }
+
   /**
    * Whether or not the peer is interested in pieces we have. Returns
    * false if not connected.
@@ -385,6 +437,7 @@ public class Peer implements Comparable
    * Sets whether or not we are interested in pieces from this peer.
    * Defaults to false. When interest is true and this peer unchokes
    * us then we start downloading from it. Has no effect when not connected.
+   * @deprecated unused
    */
   public void setInteresting(boolean interest)
   {
@@ -528,17 +581,8 @@ public class Peer implements Comparable
    */
   public void setRateHistory(long up, long down)
   {
-    setRate(up, uploaded_old);
-    setRate(down, downloaded_old);
-  }
-
-  private void setRate(long val, long array[])
-  {
-    synchronized(array) {
-      for (int i = RATE_DEPTH-1; i > 0; i--)
-        array[i] = array[i-1];
-      array[0] = val;
-    }
+    PeerCoordinator.setRate(up, uploaded_old);
+    PeerCoordinator.setRate(down, downloaded_old);
   }
 
   /**
@@ -546,28 +590,11 @@ public class Peer implements Comparable
    */
   public long getUploadRate()
   {
-    return getRate(uploaded_old);
+    return PeerCoordinator.getRate(uploaded_old);
   }
 
   public long getDownloadRate()
   {
-    return getRate(downloaded_old);
+    return PeerCoordinator.getRate(downloaded_old);
   }
-
-  private long getRate(long array[])
-  {
-    long rate = 0;
-    int i = 0;
-    synchronized(array) {
-      for ( ; i < RATE_DEPTH; i++){
-        if (array[i] < 0)
-            break;
-        rate += array[i];
-      }
-    }
-    if (i == 0)
-        return 0;
-    return rate / (i * CHECK_PERIOD / 1000);
-  }
-
 }

apps/i2psnark/java/src/org/klomp/snark/PeerAcceptor.java

@@ -28,6 +28,7 @@ import java.io.OutputStream;
 import java.io.SequenceInputStream;
 import java.util.Iterator;
 
+import net.i2p.I2PAppContext;
 import net.i2p.client.streaming.I2PSocket;
 import net.i2p.data.Base64;
 import net.i2p.data.DataHelper;
@@ -41,7 +42,7 @@ import net.i2p.util.Log;
  */
 public class PeerAcceptor
 {
-  private static final Log _log = new Log(PeerAcceptor.class);
+  private final Log _log = I2PAppContext.getGlobalContext().logManager().getLog(PeerAcceptor.class);
   private final PeerCoordinator coordinator;
   final PeerCoordinatorSet coordinators;
 
@@ -75,10 +76,12 @@ public class PeerAcceptor
         // is this working right?
         try {
           peerInfoHash = readHash(in);
-          _log.info("infohash read from " + socket.getPeerDestination().calculateHash().toBase64() 
-                    + ": " + Base64.encode(peerInfoHash));
+          if (_log.shouldLog(Log.INFO))
+              _log.info("infohash read from " + socket.getPeerDestination().calculateHash().toBase64() 
+                        + ": " + Base64.encode(peerInfoHash));
         } catch (IOException ioe) {
-            _log.info("Unable to read the infohash from " + socket.getPeerDestination().calculateHash().toBase64());
+            if (_log.shouldLog(Log.INFO))
+                _log.info("Unable to read the infohash from " + socket.getPeerDestination().calculateHash().toBase64());
             throw ioe;
         }
         in = new SequenceInputStream(new ByteArrayInputStream(peerInfoHash), in);

apps/i2psnark/java/src/org/klomp/snark/PeerCheckerTask.java

@@ -26,6 +26,8 @@ import java.util.List;
 import java.util.Random;
 import java.util.TimerTask;
 
+import net.i2p.I2PAppContext;
+
 /**
  * TimerTask that checks for good/bad up/downloader. Works together
  * with the PeerCoordinator to select which Peers get (un)choked.
@@ -43,7 +45,7 @@ class PeerCheckerTask extends TimerTask
     this.coordinator = coordinator;
   }
 
-  private Random random = new Random();
+  private static final Random random = I2PAppContext.getGlobalContext().random();
 
   public void run()
   {
@@ -105,15 +107,15 @@ class PeerCheckerTask extends TimerTask
             peer.resetCounters();
 
             _util.debug(peer + ":", Snark.DEBUG);
-            _util.debug(" ul: " + upload/KILOPERSECOND
-                        + " dl: " + download/KILOPERSECOND
+            _util.debug(" ul: " + upload*1024/KILOPERSECOND
+                        + " dl: " + download*1024/KILOPERSECOND
                         + " i: " + peer.isInterested()
                         + " I: " + peer.isInteresting()
                         + " c: " + peer.isChoking()
                         + " C: " + peer.isChoked(),
                         Snark.DEBUG);
 
-            // Choke half of them rather than all so it isn't so drastic...
+            // Choke a percentage of them rather than all so it isn't so drastic...
             // unless this torrent is over the limit all by itself.
             boolean overBWLimitChoke = upload > 0 &&
                                        ((overBWLimit && random.nextBoolean()) ||

apps/i2psnark/java/src/org/klomp/snark/PeerConnectionIn.java

@@ -23,11 +23,12 @@ package org.klomp.snark;
 import java.io.DataInputStream;
 import java.io.IOException;
 
+import net.i2p.I2PAppContext;
 import net.i2p.util.Log;
 
 class PeerConnectionIn implements Runnable
 {
-  private Log _log = new Log(PeerConnectionIn.class);
+  private final Log _log = I2PAppContext.getGlobalContext().logManager().getLog(PeerConnectionIn.class);
   private final Peer peer;
   private final DataInputStream din;
 
@@ -129,7 +130,7 @@ class PeerConnectionIn implements Runnable
                 din.readFully(bitmap);
                 ps.bitfieldMessage(bitmap);
                 if (_log.shouldLog(Log.DEBUG)) 
-                    _log.debug("Received bitmap from " + peer + " on " + peer.metainfo.getName() + ": size=" + (i-1) + ": " + ps.bitfield);
+                    _log.debug("Received bitmap from " + peer + " on " + peer.metainfo.getName() + ": size=" + (i-1) /* + ": " + ps.bitfield */ );
                 break;
               case 6:
                 piece = din.readInt();

apps/i2psnark/java/src/org/klomp/snark/PeerConnectionOut.java

@@ -26,6 +26,7 @@ import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
 
+import net.i2p.I2PAppContext;
 import net.i2p.util.I2PAppThread;
 import net.i2p.util.Log;
 import net.i2p.util.SimpleScheduler;
@@ -33,7 +34,7 @@ import net.i2p.util.SimpleTimer;
 
 class PeerConnectionOut implements Runnable
 {
-  private Log _log = new Log(PeerConnectionOut.class);
+  private final Log _log = I2PAppContext.getGlobalContext().logManager().getLog(PeerConnectionOut.class);
   private final Peer peer;
   private final DataOutputStream dout;
 
@@ -41,7 +42,7 @@ class PeerConnectionOut implements Runnable
   private boolean quit;
 
   // Contains Messages.
-  private List sendQueue = new ArrayList();
+  private final List sendQueue = new ArrayList();
   
   private static long __id = 0;
   private long _id;
@@ -141,7 +142,7 @@ class PeerConnectionOut implements Runnable
                             it.remove();
                           }
                       }
-                    if (m == null && sendQueue.size() > 0) {
+                    if (m == null && !sendQueue.isEmpty()) {
                       m = (Message)sendQueue.remove(0);
                       SimpleTimer.getInstance().removeEvent(m.expireEvent);
                     }
@@ -151,7 +152,11 @@ class PeerConnectionOut implements Runnable
               {
                 if (_log.shouldLog(Log.DEBUG))
                     _log.debug("Send " + peer + ": " + m + " on " + peer.metainfo.getName());
-                m.sendMessage(dout);
+
+                // This can block for quite a while.
+                // To help get slow peers going, and track the bandwidth better,
+                // move this _after_ state.uploaded() and see how it works.
+                //m.sendMessage(dout);
                 lastSent = System.currentTimeMillis();
 
                 // Remove all piece messages after sending a choke message.
@@ -159,9 +164,22 @@ class PeerConnectionOut implements Runnable
                   removeMessage(Message.PIECE);
 
                 // XXX - Should also register overhead...
-                if (m.type == Message.PIECE)
-                  state.uploaded(m.len);
+                // Don't let other clients requesting big chunks get an advantage
+                // when we are seeding;
+                // only count the rest of the upload after sendMessage().
+                int remainder = 0;
+                if (m.type == Message.PIECE) {
+                  if (m.len <= PeerState.PARTSIZE) {
+                     state.uploaded(m.len);
+                  } else {
+                     state.uploaded(PeerState.PARTSIZE);
+                     remainder = m.len - PeerState.PARTSIZE;
+                  }
+                }
 
+                m.sendMessage(dout);
+                if (remainder > 0)
+                  state.uploaded(remainder);
                 m = null;
               }
           }

apps/i2psnark/java/src/org/klomp/snark/PeerCoordinator.java

@@ -29,6 +29,7 @@ import java.util.List;
 import java.util.Random;
 import java.util.Timer;
 
+import net.i2p.I2PAppContext;
 import net.i2p.util.I2PAppThread;
 import net.i2p.util.Log;
 
@@ -37,7 +38,7 @@ import net.i2p.util.Log;
  */
 public class PeerCoordinator implements PeerListener
 {
-  private final Log _log = new Log(PeerCoordinator.class);
+  private final Log _log = I2PAppContext.getGlobalContext().logManager().getLog(PeerCoordinator.class);
   final MetaInfo metainfo;
   final Storage storage;
   final Snark snark;
@@ -56,12 +57,12 @@ public class PeerCoordinator implements PeerListener
 
   private long uploaded;
   private long downloaded;
-  final static int RATE_DEPTH = 6; // make following arrays RATE_DEPTH long
-  private long uploaded_old[] = {-1,-1,-1,-1,-1,-1};
-  private long downloaded_old[] = {-1,-1,-1,-1,-1,-1};
+  final static int RATE_DEPTH = 3; // make following arrays RATE_DEPTH long
+  private long uploaded_old[] = {-1,-1,-1};
+  private long downloaded_old[] = {-1,-1,-1};
 
   // synchronize on this when changing peers or downloaders
-  final List peers = new ArrayList();
+  final List<Peer> peers = new ArrayList();
   /** estimate of the peers, without requiring any synchronization */
   volatile int peerCount;
 
@@ -71,12 +72,13 @@ public class PeerCoordinator implements PeerListener
   private final byte[] id;
 
   // Some random wanted pieces
-  private List wantedPieces;
+  private List<Piece> wantedPieces;
 
   private boolean halted = false;
 
   private final CoordinatorListener listener;
   public I2PSnarkUtil _util;
+  private static final Random _random = I2PAppContext.getGlobalContext().random();
   
   public String trackerProblems = null;
   public int trackerSeenPeers = 0;
@@ -96,27 +98,36 @@ public class PeerCoordinator implements PeerListener
     // Install a timer to check the uploaders.
     // Randomize the first start time so multiple tasks are spread out,
     // this will help the behavior with global limits
-    Random r = new Random();
-    timer.schedule(new PeerCheckerTask(_util, this), (CHECK_PERIOD / 2) + r.nextInt((int) CHECK_PERIOD), CHECK_PERIOD);
+    timer.schedule(new PeerCheckerTask(_util, this), (CHECK_PERIOD / 2) + _random.nextInt((int) CHECK_PERIOD), CHECK_PERIOD);
   }
   
   // only called externally from Storage after the double-check fails
   public void setWantedPieces()
   {
     // Make a list of pieces
+    // FIXME synchronize, clear and re-add instead?
+    // Don't replace something we are synchronizing on.
     wantedPieces = new ArrayList();
     BitField bitfield = storage.getBitField();
-    for(int i = 0; i < metainfo.getPieces(); i++)
-      if (!bitfield.get(i))
-        wantedPieces.add(new Piece(i));
-    Collections.shuffle(wantedPieces);
+    int[] pri = storage.getPiecePriorities();
+    for(int i = 0; i < metainfo.getPieces(); i++) {
+      // only add if we don't have and the priority is >= 0
+      if ((!bitfield.get(i)) &&
+          (pri == null || pri[i] >= 0)) {
+        Piece p = new Piece(i);
+        if (pri != null)
+            p.setPriority(pri[i]);
+        wantedPieces.add(p);
+      }
+    }
+    Collections.shuffle(wantedPieces, _random);
   }
 
   public Storage getStorage() { return storage; }
   public CoordinatorListener getListener() { return listener; }
 
   // for web page detailed stats
-  public List peerList()
+  public List<Peer> peerList()
   {
     synchronized(peers)
       {
@@ -134,8 +145,10 @@ public class PeerCoordinator implements PeerListener
     return storage.complete();
   }
 
+  /** might be wrong */
   public int getPeerCount() { return peerCount; }
 
+  /** should be right */
   public int getPeers()
   {
     synchronized(peers)
@@ -180,7 +193,7 @@ public class PeerCoordinator implements PeerListener
     setRate(down, downloaded_old);
   }
 
-  private static void setRate(long val, long array[])
+  static void setRate(long val, long array[])
   {
     synchronized(array) {
       for (int i = RATE_DEPTH-1; i > 0; i--)
@@ -211,20 +224,23 @@ public class PeerCoordinator implements PeerListener
     return (r * 1000) / CHECK_PERIOD;
   }
 
-  private long getRate(long array[])
+  static long getRate(long array[])
   {
     long rate = 0;
     int i = 0;
+    int factor = 0;
     synchronized(array) {
       for ( ; i < RATE_DEPTH; i++) {
         if (array[i] < 0)
             break;
-        rate += array[i];
+        int f = RATE_DEPTH - i;
+        rate += array[i] * f;
+        factor += f;
       }
     }
     if (i == 0)
         return 0;
-    return rate / (i * CHECK_PERIOD / 1000);
+    return rate / (factor * CHECK_PERIOD / 1000);
   }
 
   public MetaInfo getMetaInfo()
@@ -236,16 +252,30 @@ public class PeerCoordinator implements PeerListener
   {
     synchronized(peers)
       {
-        return !halted && peers.size() < _util.getMaxConnections();
+        return !halted && peers.size() < getMaxConnections();
       }
   }
   
+  /**
+   *  Reduce max if huge pieces to keep from ooming when leeching
+   *  @return 512K: 16; 1M: 11; 2M: 6
+   */
+  private int getMaxConnections() {
+    int size = metainfo.getPieceLength(0);
+    int max = _util.getMaxConnections();
+    if (size <= 512*1024 || completed())
+      return max;
+    if (size <= 1024*1024)
+      return (max + max + 2) / 3;
+    return (max + 2) / 3;
+  }
+
   public boolean halted() { return halted; }
 
   public void halt()
   {
     halted = true;
-    List removed = new ArrayList();
+    List<Peer> removed = new ArrayList();
     synchronized(peers)
       {
         // Stop peer checker task.
@@ -257,8 +287,8 @@ public class PeerCoordinator implements PeerListener
         peerCount = 0;
       }
 
-    while (removed.size() > 0) {
-        Peer peer = (Peer)removed.remove(0);
+    while (!removed.isEmpty()) {
+        Peer peer = removed.remove(0);
         peer.disconnect();
         removePeerFromPieces(peer);
     }
@@ -294,7 +324,7 @@ public class PeerCoordinator implements PeerListener
             peer.disconnect(false); // Don't deregister this connection/peer.
           }
         // This is already checked in addPeer() but we could have gone over the limit since then
-        else if (peers.size() >= _util.getMaxConnections())
+        else if (peers.size() >= getMaxConnections())
           {
             if (_log.shouldLog(Log.WARN))
               _log.warn("Already at MAX_CONNECTIONS in connected() with peer: " + peer);
@@ -325,9 +355,9 @@ public class PeerCoordinator implements PeerListener
   // caller must synchronize on peers
   private static Peer peerIDInList(PeerID pid, List peers)
   {
-    Iterator it = peers.iterator();
+    Iterator<Peer> it = peers.iterator();
     while (it.hasNext()) {
-      Peer cur = (Peer)it.next();
+      Peer cur = it.next();
       if (pid.sameID(cur.getPeerID()))
         return cur;
     }
@@ -350,7 +380,7 @@ public class PeerCoordinator implements PeerListener
         peersize = peers.size();
         // This isn't a strict limit, as we may have several pending connections;
         // thus there is an additional check in connected()
-        need_more = (!peer.isConnected()) && peersize < _util.getMaxConnections();
+        need_more = (!peer.isConnected()) && peersize < getMaxConnections();
         // Check if we already have this peer before we build the connection
         Peer old = peerIDInList(peer.getPeerID(), peers);
         need_more = need_more && ((old == null) || (old.getInactiveTime() > 8*60*1000));
@@ -358,7 +388,8 @@ public class PeerCoordinator implements PeerListener
 
     if (need_more)
       {
-        _log.debug("Adding a peer " + peer.getPeerID().getAddress().calculateHash().toBase64() + " for " + metainfo.getName(), new Exception("add/run"));
+        if (_log.shouldLog(Log.DEBUG))
+            _log.debug("Adding a peer " + peer.getPeerID().toString() + " for " + metainfo.getName(), new Exception("add/run"));
 
         // Run the peer with us as listener and the current bitfield.
         final PeerListener listener = this;
@@ -378,7 +409,7 @@ public class PeerCoordinator implements PeerListener
       if (peer.isConnected())
         _log.info("Add peer already connected: " + peer);
       else
-        _log.info("Connections: " + peersize + "/" + _util.getMaxConnections()
+        _log.info("Connections: " + peersize + "/" + getMaxConnections()
                   + " not accepting extra peer: " + peer);
     }
     return false;
@@ -391,21 +422,21 @@ public class PeerCoordinator implements PeerListener
     // linked list will contain all interested peers that we choke.
     // At the start are the peers that have us unchoked at the end the
     // other peer that are interested, but are choking us.
-    List interested = new LinkedList();
+    List<Peer> interested = new LinkedList();
     synchronized (peers) {
         int count = 0;
         int unchokedCount = 0;
         int maxUploaders = allowedUploaders();
-        Iterator it = peers.iterator();
+        Iterator<Peer> it = peers.iterator();
         while (it.hasNext())
           {
-            Peer peer = (Peer)it.next();
+            Peer peer = it.next();
             if (peer.isChoking() && peer.isInterested())
               {
                 count++;
                 if (uploaders < maxUploaders)
                   {
-                    if (!peer.isChoked())
+                    if (peer.isInteresting() && !peer.isChoked())
                       interested.add(unchokedCount++, peer);
                     else
                       interested.add(peer);
@@ -413,9 +444,9 @@ public class PeerCoordinator implements PeerListener
               }
           }
 
-        while (uploaders < maxUploaders && interested.size() > 0)
+        while (uploaders < maxUploaders && !interested.isEmpty())
           {
-            Peer peer = (Peer)interested.remove(0);
+            Peer peer = interested.remove(0);
             if (_log.shouldLog(Log.DEBUG))
               _log.debug("Unchoke: " + peer);
             peer.setChoking(false);
@@ -436,7 +467,7 @@ public class PeerCoordinator implements PeerListener
   }
 
   /**
-   * Returns true if we don't have the given piece yet.
+   * @return true if we still want the given piece
    */
   public boolean gotHave(Peer peer, int piece)
   {
@@ -460,10 +491,10 @@ public class PeerCoordinator implements PeerListener
 
     synchronized(wantedPieces)
       {
-        Iterator it = wantedPieces.iterator();
+        Iterator<Piece> it = wantedPieces.iterator();
         while (it.hasNext())
           {
-            Piece p = (Piece)it.next();
+            Piece p = it.next();
             int i = p.getId();
             if (bitfield.get(i)) {
               p.addPeer(peer);
@@ -474,6 +505,19 @@ public class PeerCoordinator implements PeerListener
     return false;
   }
 
+  /**
+   *  This should be somewhat less than the max conns per torrent,
+   *  but not too much less, so a torrent doesn't get stuck near the end.
+   *  @since 0.7.14
+   */
+  private static final int END_GAME_THRESHOLD = 8;
+
+  /**
+   *  Max number of peers to get a piece from when in end game
+   *  @since 0.8.1
+   */
+  private static final int MAX_PARALLEL_REQUESTS = 4;
+
   /**
    * Returns one of pieces in the given BitField that is still wanted or
    * -1 if none of the given pieces are wanted.
@@ -490,11 +534,14 @@ public class PeerCoordinator implements PeerListener
       {
         Piece piece = null;
         Collections.sort(wantedPieces); // Sort in order of rarest first.
-        List requested = new ArrayList(); 
-        Iterator it = wantedPieces.iterator();
+        List<Piece> requested = new ArrayList(); 
+        Iterator<Piece> it = wantedPieces.iterator();
         while (piece == null && it.hasNext())
           {
-            Piece p = (Piece)it.next();
+            Piece p = it.next();
+            // sorted by priority, so when we hit a disabled piece we are done
+            if (p.isDisabled())
+                break;
             if (havePieces.get(p.getId()) && !p.isRequested())
               {
                 piece = p;
@@ -507,16 +554,38 @@ public class PeerCoordinator implements PeerListener
         
         //Only request a piece we've requested before if there's no other choice.
         if (piece == null) {
+            // AND if there are almost no wanted pieces left (real end game).
+            // If we do end game all the time, we generate lots of extra traffic
+            // when the seeder is super-slow and all the peers are "caught up"
+            if (wantedPieces.size() > END_GAME_THRESHOLD)
+                return -1;  // nothing to request and not in end game
             // let's not all get on the same piece
-            Collections.shuffle(requested);
-            Iterator it2 = requested.iterator();
+            // Even better would be to sort by number of requests
+            Collections.shuffle(requested, _random);
+            Iterator<Piece> it2 = requested.iterator();
             while (piece == null && it2.hasNext())
               {
-                Piece p = (Piece)it2.next();
-                if (havePieces.get(p.getId()))
-                  {
+                Piece p = it2.next();
+                if (havePieces.get(p.getId())) {
+                    // limit number of parallel requests
+                    int requestedCount = 0;
+                    synchronized(peers) {
+                        for (Peer pr : peers) {
+                            if (pr.isRequesting(p.getId())) {
+                                if (pr.equals(peer)) {
+                                    // don't give it to him again
+                                    requestedCount = MAX_PARALLEL_REQUESTS;
+                                    break;
+                                }
+                                if (++requestedCount >= MAX_PARALLEL_REQUESTS)
+                                    break;
+                            }
+                        }
+                    }
+                    if (requestedCount >= MAX_PARALLEL_REQUESTS)
+                        continue;
                     piece = p;
-                  }
+                }
               }
             if (piece == null) {
                 if (_log.shouldLog(Log.WARN))
@@ -525,7 +594,7 @@ public class PeerCoordinator implements PeerListener
                 //            + " wanted = " + wantedPieces + " peerHas = " + havePieces);
                 return -1; //If we still can't find a piece we want, so be it.
             } else {
-                // Should be a lot smarter here - limit # of parallel attempts and
+                // Should be a lot smarter here -
                 // share blocks rather than starting from 0 with each peer.
                 // This is where the flaws of the snark data model are really exposed.
                 // Could also randomize within the duplicate set rather than strict rarest-first
@@ -533,11 +602,83 @@ public class PeerCoordinator implements PeerListener
                     _log.debug("parallel request (end game?) for " + peer + ": piece = " + piece);
             }
         }
+        if (_log.shouldLog(Log.DEBUG))
+            _log.debug("Now requesting: piece " + piece + " priority " + piece.getPriority());
         piece.setRequested(true);
         return piece.getId();
       }
   }
 
+  /**
+   *  Maps file priorities to piece priorities.
+   *  Call after updating file priorities Storage.setPriority()
+   *  @since 0.8.1
+   */
+  public void updatePiecePriorities() {
+      int[] pri = storage.getPiecePriorities();
+      if (pri == null) {
+          _log.debug("Updated piece priorities called but no priorities to set?");
+          return;
+      }
+      synchronized(wantedPieces) {
+          // Add incomplete and previously unwanted pieces to the list
+          // Temp to avoid O(n**2)
+          BitField want = new BitField(pri.length);
+          for (Piece p : wantedPieces) {
+              want.set(p.getId());
+          }
+          BitField bitfield = storage.getBitField();
+          for (int i = 0; i < pri.length; i++) {
+              if (pri[i] >= 0 && !bitfield.get(i)) {
+                  if (!want.get(i)) {
+                      Piece piece = new Piece(i);
+                      wantedPieces.add(piece);
+                      // As connections are already up, new Pieces will
+                      // not have their PeerID list populated, so do that.
+                      synchronized(peers) {
+                          for (Peer p : peers) {
+                              PeerState s = p.state;
+                              if (s != null) {
+                                  BitField bf = s.bitfield;
+                                  if (bf != null && bf.get(i))
+                                      piece.addPeer(p);
+                              }
+                          }
+                      }
+                  }
+              }
+          }
+          // now set the new priorities and remove newly unwanted pieces
+          for (Iterator<Piece> iter = wantedPieces.iterator(); iter.hasNext(); ) {
+               Piece p = iter.next();
+               int priority = pri[p.getId()];
+               if (priority >= 0) {
+                   p.setPriority(priority);
+               } else {
+                   iter.remove();
+                   // cancel all peers
+                   synchronized(peers) {
+                       for (Peer peer : peers) {
+                           peer.cancel(p.getId());
+                       }
+                   }
+               }
+          }
+          if (_log.shouldLog(Log.DEBUG))
+              _log.debug("Updated piece priorities, now wanted: " + wantedPieces);
+          // if we added pieces, they will be in-order unless we shuffle
+          Collections.shuffle(wantedPieces, _random);
+
+          // update request queues, in case we added wanted pieces
+          // and we were previously uninterested
+          synchronized(peers) {
+              for (Peer peer : peers) {
+                  peer.request();
+              }
+          }
+      }
+  }
+
   /**
    * Returns a byte array containing the requested piece or null of
    * the piece is unknown.
@@ -602,14 +743,18 @@ public class PeerCoordinator implements PeerListener
             
             // No need to announce have piece to peers.
             // Assume we got a good piece, we don't really care anymore.
-            return true;
+            // Well, this could be caused by a change in priorities, so
+            // only return true if we already have it, otherwise might as well keep it.
+            if (storage.getBitField().get(piece))
+                return true;
           }
         
         try
           {
             if (storage.putPiece(piece, bs))
               {
-                _log.info("Got valid piece " + piece + "/" + metainfo.getPieces() +" from " + peer + " for " + metainfo.getName());
+                if (_log.shouldLog(Log.INFO))
+                    _log.info("Got valid piece " + piece + "/" + metainfo.getPieces() +" from " + peer + " for " + metainfo.getName());
               }
             else
               {
@@ -632,11 +777,11 @@ public class PeerCoordinator implements PeerListener
     // Disconnect from other seeders when we get the last piece
     synchronized(peers)
       {
-        List toDisconnect = new ArrayList(); 
-        Iterator it = peers.iterator();
+        List<Peer> toDisconnect = new ArrayList(); 
+        Iterator<Peer> it = peers.iterator();
         while (it.hasNext())
           {
-            Peer p = (Peer)it.next();
+            Peer p = it.next();
             if (p.isConnected())
               {
                   if (completed() && p.isCompleted())
@@ -648,7 +793,7 @@ public class PeerCoordinator implements PeerListener
         it = toDisconnect.iterator();
         while (it.hasNext())
           {
-            Peer p = (Peer)it.next();
+            Peer p = it.next();
             p.disconnect(true);
           }
       }
@@ -714,8 +859,8 @@ public class PeerCoordinator implements PeerListener
    */
   public void removePeerFromPieces(Peer peer) {
       synchronized(wantedPieces) {
-          for(Iterator iter = wantedPieces.iterator(); iter.hasNext(); ) {
-              Piece piece = (Piece)iter.next();
+          for(Iterator<Piece> iter = wantedPieces.iterator(); iter.hasNext(); ) {
+              Piece piece = iter.next();
               piece.removePeer(peer);
           }
       } 
@@ -769,8 +914,8 @@ public class PeerCoordinator implements PeerListener
     }
     synchronized(wantedPieces)
       {
-        for(Iterator iter = wantedPieces.iterator(); iter.hasNext(); ) {
-          Piece piece = (Piece)iter.next();
+        for(Iterator<Piece> iter = wantedPieces.iterator(); iter.hasNext(); ) {
+          Piece piece = iter.next();
           if (piece.getId() == savedRequest.piece) {
             Request req = savedRequest;
             piece.setRequested(true);
@@ -795,9 +940,9 @@ public class PeerCoordinator implements PeerListener
     // see if anybody else is requesting
     synchronized (peers)
       {
-        Iterator it = peers.iterator();
+        Iterator<Peer> it = peers.iterator();
         while (it.hasNext()) {
-          Peer p = (Peer)it.next();
+          Peer p = it.next();
           if (p.equals(peer))
             continue;
           if (p.state == null)
@@ -815,9 +960,9 @@ public class PeerCoordinator implements PeerListener
     // nobody is, so mark unrequested
     synchronized(wantedPieces)
       {
-        Iterator it = wantedPieces.iterator();
+        Iterator<Piece> it = wantedPieces.iterator();
         while (it.hasNext()) {
-          Piece p = (Piece)it.next();
+          Piece p = it.next();
           if (p.getId() == piece) {
             p.setRequested(false);
             if (_log.shouldLog(Log.DEBUG))

apps/i2psnark/java/src/org/klomp/snark/PeerCoordinatorSet.java

@@ -12,7 +12,7 @@ import java.util.Set;
  * from it there too)
  */
 public class PeerCoordinatorSet {
-    private Set _coordinators;
+    private final Set _coordinators;
     
     public PeerCoordinatorSet() {
         _coordinators = new HashSet();

apps/i2psnark/java/src/org/klomp/snark/PeerID.java

@@ -24,19 +24,33 @@ import java.io.IOException;
 import java.net.UnknownHostException;
 import java.util.Map;
 
+import net.i2p.I2PAppContext;
+import net.i2p.data.Base32;
 import net.i2p.data.Base64;
+import net.i2p.data.DataHelper;
 import net.i2p.data.Destination;
 
 import org.klomp.snark.bencode.BDecoder;
 import org.klomp.snark.bencode.BEValue;
 import org.klomp.snark.bencode.InvalidBEncodingException;
 
+/**
+ *  Store the address information about a peer.
+ *  Prior to 0.8.1, an instantiation required a peer ID, and full Destination address.
+ *  Starting with 0.8.1, to support compact tracker responses,
+ *  a PeerID can be instantiated with a Destination Hash alone.
+ *  The full destination lookup is deferred until getAddress() is called,
+ *  and the PeerID is not required.
+ *  Equality is now determined solely by the dest hash.
+ */
 public class PeerID implements Comparable
 {
-  private final byte[] id;
-  private final Destination address;
+  private byte[] id;
+  private Destination address;
   private final int port;
-
+  private byte[] destHash;
+  /** whether we have tried to get the dest from the hash - only do once */
+  private boolean triedDestLookup;
   private final int hash;
 
   public PeerID(byte[] id, Destination address)
@@ -44,7 +58,7 @@ public class PeerID implements Comparable
     this.id = id;
     this.address = address;
     this.port = 6881;
-
+    this.destHash = address.calculateHash().getData();
     hash = calculateHash();
   }
 
@@ -77,17 +91,49 @@ public class PeerID implements Comparable
         throw new InvalidBEncodingException("Invalid destination [" + bevalue.getString() + "]");
 
     port = 6881;
-
+    this.destHash = address.calculateHash().getData();
     hash = calculateHash();
   }
 
+  /**
+   * Creates a PeerID from a destHash
+   * @since 0.8.1
+   */
+  public PeerID(byte[] dest_hash) throws InvalidBEncodingException
+  {
+    // id and address remain null
+    port = 6881;
+    if (dest_hash.length != 32)
+        throw new InvalidBEncodingException("bad hash length");
+    destHash = dest_hash;
+    hash = DataHelper.hashCode(dest_hash);
+  }
+
   public byte[] getID()
   {
     return id;
   }
 
-  public Destination getAddress()
+  /** for connecting out to peer based on desthash @since 0.8.1 */
+  public void setID(byte[] xid)
   {
+    id = xid;
+  }
+
+  /**
+   *  Get the destination.
+   *  If this PeerId was instantiated with a destHash,
+   *  and we have not yet done so, lookup the full destination, which may take
+   *  up to 10 seconds.
+   *  @return Dest or null if unknown
+   */
+  public synchronized Destination getAddress()
+  {
+    if (address == null && destHash != null && !triedDestLookup) {
+        String b32 = Base32.encode(destHash) + ".b32.i2p";
+        address = I2PAppContext.getGlobalContext().namingService().lookup(b32);
+        triedDestLookup = true;
+    }
     return address;
   }
 
@@ -96,17 +142,21 @@ public class PeerID implements Comparable
     return port;
   }
 
+  /** @since 0.8.1 */
+  public byte[] getDestHash()
+  {
+    return destHash;
+  }
+
   private int calculateHash()
   {
-    int b = 0;
-    for (int i = 0; i < id.length; i++)
-      b ^= id[i];
-    return (b ^ address.hashCode()) ^ port;
+    return DataHelper.hashCode(destHash);
   }
 
   /**
-   * The hash code of a PeerID is the exclusive or of all id bytes.
+   * The hash code of a PeerID is the hashcode of the desthash
    */
+    @Override
   public int hashCode()
   {
     return hash;
@@ -114,28 +164,24 @@ public class PeerID implements Comparable
 
   /**
    * Returns true if and only if this peerID and the given peerID have
-   * the same 20 bytes as ID.
+   * the same destination hash
    */
   public boolean sameID(PeerID pid)
   {
-    boolean equal = true;
-    for (int i = 0; equal && i < id.length; i++)
-      equal = id[i] == pid.id[i];
-    return equal;
+    return DataHelper.eq(destHash, pid.getDestHash());
   }
 
   /**
-   * Two PeerIDs are equal when they have the same id, address and port.
+   * Two PeerIDs are equal when they have the same dest hash
    */
+    @Override
   public boolean equals(Object o)
   {
     if (o instanceof PeerID)
       {
         PeerID pid = (PeerID)o;
 
-        return port == pid.port
-          && address.equals(pid.address)
-          && sameID(pid);
+        return sameID(pid);
       }
     else
       return false;
@@ -143,6 +189,7 @@ public class PeerID implements Comparable
 
   /**
    * Compares port, address and id.
+   * @deprecated unused? and will NPE now that address can be null?
    */
   public int compareTo(Object o)
   {
@@ -171,8 +218,11 @@ public class PeerID implements Comparable
    * and address is the base64 dest (was the base64 hash of the dest) which
    * should match what the bytemonsoon tracker reports on its web pages.
    */
+    @Override
   public String toString()
   {
+    if (id == null || address == null)
+        return "unkn@" + Base64.encode(destHash).substring(0, 6);
     int nonZero = 0;
     for (int i = 0; i < id.length; i++) {
         if (id[i] != 0) {
@@ -190,7 +240,7 @@ public class PeerID implements Comparable
   {
     boolean leading_zeros = true;
 
-    StringBuffer sb = new StringBuffer(bs.length*2);
+    StringBuilder sb = new StringBuilder(bs.length*2);
     for (int i = 0; i < bs.length; i++)
       {
         int c = bs[i] & 0xFF;

apps/i2psnark/java/src/org/klomp/snark/PeerListener.java

@@ -151,7 +151,7 @@ public interface PeerListener
    *
    * @param state the PeerState for the peer
    */
-  void savePeerPartial(PeerState state);
+  void savePeerPartial(PeerState state); /* FIXME Exporting non-public type through public API FIXME */
 
   /**
    * Called when a peer has connected and there may be a partially
@@ -161,7 +161,7 @@ public interface PeerListener
    *
    * @return request (contains the partial data and valid length)
    */
-  Request getPeerPartial(BitField havePieces);
+  Request getPeerPartial(BitField havePieces); /* FIXME Exporting non-public type through public API FIXME */
 
   /** Mark a peer's requested pieces unrequested when it is disconnected
    *  This prevents premature end game

apps/i2psnark/java/src/org/klomp/snark/PeerState.java

@@ -24,11 +24,12 @@ import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
 
+import net.i2p.I2PAppContext;
 import net.i2p.util.Log;
 
 class PeerState
 {
-  private Log _log = new Log(PeerState.class);
+  private final Log _log = I2PAppContext.getGlobalContext().logManager().getLog(PeerState.class);
   final Peer peer;
   final PeerListener listener;
   final MetaInfo metainfo;
@@ -54,12 +55,10 @@ class PeerState
   final PeerConnectionOut out;
 
   // Outstanding request
-  private final List outstandingRequests = new ArrayList();
+  private final List<Request> outstandingRequests = new ArrayList();
+  /** the tail (NOT the head) of the request queue */
   private Request lastRequest = null;
 
-  // If we have te resend outstanding requests (true after we got choked).
-  private boolean resend = false;
-
   private final static int MAX_PIPELINE = 5;               // this is for outbound requests
   private final static int MAX_PIPELINE_BYTES = 128*1024;  // this is for inbound requests
   public final static int PARTSIZE = 16*1024; // outbound request
@@ -90,14 +89,13 @@ class PeerState
     if (_log.shouldLog(Log.DEBUG))
         _log.debug(peer + " rcv " + (choke ? "" : "un") + "choked");
 
+    boolean resend = choked && !choke;
     choked = choke;
-    if (choked)
-      resend = true;
 
     listener.gotChoke(peer, choke);
 
-    if (!choked && interesting)
-      request();
+    if (interesting && !choked)
+      request(resend);
   }
 
   void interestedMessage(boolean interest)
@@ -152,7 +150,16 @@ class PeerState
         // XXX - Check for weird bitfield and disconnect?
         bitfield = new BitField(bitmap, metainfo.getPieces());
       }
-    setInteresting(listener.gotBitField(peer, bitfield));
+    boolean interest = listener.gotBitField(peer, bitfield);
+    setInteresting(interest);
+    if (bitfield.complete() && !interest) {
+        // They are seeding and we are seeding,
+        // why did they contact us? (robert)
+        // Dump them quick before we send our whole bitmap
+        if (_log.shouldLog(Log.WARN))
+            _log.warn("Disconnecting seed that connects to seeds: " + peer);
+        peer.disconnect(true);
+    }
   }
 
   void requestMessage(int piece, int begin, int length)
@@ -186,6 +193,7 @@ class PeerState
 
     // Limit total pipelined requests to MAX_PIPELINE bytes
     // to conserve memory and prevent DOS
+    // Todo: limit number of requests also? (robert 64 x 4KB)
     if (out.queuedBytes() + length > MAX_PIPELINE_BYTES)
       {
         if (_log.shouldLog(Log.WARN))
@@ -267,7 +275,7 @@ class PeerState
   synchronized private int getFirstOutstandingRequest(int piece)
   {
     for (int i = 0; i < outstandingRequests.size(); i++)
-      if (((Request)outstandingRequests.get(i)).piece == piece)
+      if (outstandingRequests.get(i).piece == piece)
         return i;
     return -1;
   }
@@ -302,12 +310,12 @@ class PeerState
     Request req;
     synchronized(this)
       {
-        req = (Request)outstandingRequests.get(r);
+        req = outstandingRequests.get(r);
         while (req.piece == piece && req.off != begin
                && r < outstandingRequests.size() - 1)
           {
             r++;
-            req = (Request)outstandingRequests.get(r);
+            req = outstandingRequests.get(r);
           }
         
         // Something wrong?
@@ -331,7 +339,7 @@ class PeerState
                                + ", wanted for peer: " + peer);
             for (int i = 0; i < r; i++)
               {
-                Request dropReq = (Request)outstandingRequests.remove(0);
+                Request dropReq = outstandingRequests.remove(0);
                 outstandingRequests.add(dropReq);
                 if (!choked)
                   out.sendRequest(dropReq);
@@ -355,11 +363,11 @@ class PeerState
   {
     Request req = null;
     for (int i = 0; i < outstandingRequests.size(); i++) {
-      Request r1 = (Request)outstandingRequests.get(i);
+      Request r1 = outstandingRequests.get(i);
       int j = getFirstOutstandingRequest(r1.piece);
       if (j == -1)
         continue;
-      Request r2 = (Request)outstandingRequests.get(j);
+      Request r2 = outstandingRequests.get(j);
       if (r2.off > 0 && ((req == null) || (r2.off > req.off)))
         req = r2;
     }
@@ -387,7 +395,7 @@ class PeerState
     }
     Request req = null;
     for (int i = 0; i < size; i++) {
-      Request r1 = (Request)outstandingRequests.get(i);
+      Request r1 = outstandingRequests.get(i);
       if (pc != r1.piece) {
         pc = r1.piece;
         arr[pos++] = pc;
@@ -412,32 +420,19 @@ class PeerState
                   + " length: " + bs.length);
   }
 
+  /**
+   *  We now have this piece.
+   *  Tell the peer and cancel any requests for the piece.
+   */
   void havePiece(int piece)
   {
     if (_log.shouldLog(Log.DEBUG))
       _log.debug("Tell " + peer + " havePiece(" + piece + ")");
 
-    synchronized(this)
-      {
         // Tell the other side that we are no longer interested in any of
         // the outstanding requests for this piece.
-        if (lastRequest != null && lastRequest.piece == piece)
-          lastRequest = null;
-        
-        Iterator it = outstandingRequests.iterator();
-        while (it.hasNext())
-          {
-            Request req = (Request)it.next();
-            if (req.piece == piece)
-              {
-                it.remove();
-                // Send cancel even when we are choked to make sure that it is
-                // really never ever send.
-                out.sendCancel(req);
-              }
-          }
-      }
-    
+    cancelPiece(piece);
+
     // Tell the other side that we really have this piece.
     out.sendHave(piece);
     
@@ -452,8 +447,46 @@ class PeerState
       }
   }
 
-  // Starts or resumes requesting pieces.
-  private void request()
+  /**
+   * Tell the other side that we are no longer interested in any of
+   * the outstanding requests (if any) for this piece.
+   * @since 0.8.1
+   */
+  synchronized void cancelPiece(int piece) {
+        if (lastRequest != null && lastRequest.piece == piece)
+          lastRequest = null;
+        
+        Iterator<Request> it = outstandingRequests.iterator();
+        while (it.hasNext())
+          {
+            Request req = it.next();
+            if (req.piece == piece)
+              {
+                it.remove();
+                // Send cancel even when we are choked to make sure that it is
+                // really never ever send.
+                out.sendCancel(req);
+              }
+          }
+  }
+
+  /**
+   * Are we currently requesting the piece?
+   * @since 0.8.1
+   */
+  synchronized boolean isRequesting(int piece) {
+      for (Request req : outstandingRequests) {
+          if (req.piece == piece)
+              return true;
+      }
+      return false;
+  }
+
+  /**
+   * Starts or resumes requesting pieces.
+   * @param resend should we resend outstanding requests?
+   */
+  private void request(boolean resend)
   {
     // Are there outstanding requests that have to be resend?
     if (resend)
@@ -461,7 +494,6 @@ class PeerState
         synchronized (this) {
             out.sendRequests(outstandingRequests);
         }
-        resend = false;
       }
 
     // Add/Send some more requests if necessary.
@@ -470,8 +502,11 @@ class PeerState
 
   /**
    * Adds a new request to the outstanding requests list.
+   * Then send interested if we weren't.
+   * Then send new requests if not choked.
+   * If nothing to request, send not interested if we were.
    */
-  synchronized private void addRequest()
+  synchronized void addRequest()
   {
     boolean more_pieces = true;
     while (more_pieces)
@@ -512,8 +547,11 @@ class PeerState
       _log.debug(peer + " requests " + outstandingRequests);
   }
 
-  // Starts requesting first chunk of next piece. Returns true if
-  // something has been added to the requests, false otherwise.
+  /**
+   * Starts requesting first chunk of next piece. Returns true if
+   * something has been added to the requests, false otherwise.
+   * Caller should synchronize.
+   */
   private boolean requestNextPiece()
   {
     // Check that we already know what the other side has.
@@ -540,11 +578,19 @@ class PeerState
               }
         }
         int nextPiece = listener.wantPiece(peer, bitfield);
-        if (_log.shouldLog(Log.DEBUG))
-          _log.debug(peer + " want piece " + nextPiece);
-            if (nextPiece != -1
-                && (lastRequest == null || lastRequest.piece != nextPiece))
-              {
+        if (nextPiece != -1
+            && (lastRequest == null || lastRequest.piece != nextPiece)) {
+                if (_log.shouldLog(Log.DEBUG))
+                    _log.debug(peer + " want piece " + nextPiece);
+                // Fail safe to make sure we are interested
+                // When we transition into the end game we may not be interested...
+                if (!interesting) {
+                    if (_log.shouldLog(Log.DEBUG))
+                        _log.debug(peer + " transition to end game, setting interesting");
+                    interesting = true;
+                    out.sendInterest(true);
+                }
+
                 int piece_length = metainfo.getPieceLength(nextPiece);
                 //Catch a common place for OOMs esp. on 1MB pieces
                 byte[] bs;
@@ -562,9 +608,25 @@ class PeerState
                   out.sendRequest(req);
                 lastRequest = req;
                 return true;
-              }
+          } else {
+                if (_log.shouldLog(Log.DEBUG))
+                    _log.debug(peer + " no more pieces to request");
+          }
       }
 
+    // failsafe
+    if (outstandingRequests.isEmpty())
+        lastRequest = null;
+
+    // If we are not in the end game, we may run out of things to request
+    // because we are asking other peers. Set not-interesting now rather than
+    // wait for those other requests to be satisfied via havePiece()
+    if (interesting && lastRequest == null) {
+        interesting = false;
+        out.sendInterest(false);
+        if (_log.shouldLog(Log.DEBUG))
+            _log.debug(peer + " nothing more to request, now uninteresting");
+    }
     return false;
   }
 
@@ -579,7 +641,7 @@ class PeerState
         out.sendInterest(interest);
 
         if (interesting && !choked)
-          request();
+          request(true);  // we shouldnt have any pending requests, but if we do, resend them
       }
   }
 
@@ -605,4 +667,16 @@ class PeerState
       if (interesting && !choked)
         out.retransmitRequests(outstandingRequests);
   }
+
+  /**
+   *  debug
+   *  @return string or null
+   *  @since 0.8.1
+   */
+  synchronized String getRequests() {
+      if (outstandingRequests.isEmpty())
+          return null;
+      else
+          return outstandingRequests.toString();
+  }
 }

apps/i2psnark/java/src/org/klomp/snark/Piece.java

@@ -1,41 +1,71 @@
 package org.klomp.snark;
 
 import java.util.Collections;
-import java.util.HashSet;
 import java.util.Set;
 
+import net.i2p.util.ConcurrentHashSet;
+
 public class Piece implements Comparable {
 
     private int id;
-    private Set peers;
+    private Set<PeerID> peers;
     private boolean requested;
+    /** @since 0.8.1 */
+    private int priority;
     
     public Piece(int id) {
         this.id = id;
-        this.peers = Collections.synchronizedSet(new HashSet());
-        this.requested = false;
+        this.peers = new ConcurrentHashSet();
     }
     
+    /**
+     *  Highest priority first,
+     *  then rarest first
+     */
     public int compareTo(Object o) throws ClassCastException {
+        int pdiff = ((Piece)o).priority - this.priority;   // reverse
+        if (pdiff != 0)
+            return pdiff;
         return this.peers.size() - ((Piece)o).peers.size();
     }
     
+    @Override
     public boolean equals(Object o) {
-        if (o == null) return false;
-        try {
+        if (o instanceof Piece) {
+            if (o == null) return false;
             return this.id == ((Piece)o).id;
-        } catch (ClassCastException cce) {
-            return false;
         }
+        return false;
+    }
+
+    @Override
+    public int hashCode() {
+        int hash = 5;
+        hash = 31 * hash + this.id;
+        return hash;
     }
     
     public int getId() { return this.id; }
-    public Set getPeers() { return this.peers; }
+    /** @deprecated unused */
+    public Set<PeerID> getPeers() { return this.peers; }
     public boolean addPeer(Peer peer) { return this.peers.add(peer.getPeerID()); }
     public boolean removePeer(Peer peer) { return this.peers.remove(peer.getPeerID()); }
     public boolean isRequested() { return this.requested; }
     public void setRequested(boolean requested) { this.requested = requested; } 
     
+    /** @return default 0 @since 0.8.1 */
+    public int getPriority() { return this.priority; }
+
+    /** @since 0.8.1 */
+    public void setPriority(int p) { this.priority = p; }
+
+    /** @since 0.8.1 */
+    public boolean isDisabled() { return this.priority < 0; }
+
+    /** @since 0.8.1 */
+    public void setDisabled() { this.priority = -1; }
+
+    @Override
     public String toString() {
         return String.valueOf(id);
     }

apps/i2psnark/java/src/org/klomp/snark/Request.java

@@ -51,11 +51,13 @@ class Request
       throw new IndexOutOfBoundsException("Illegal Request " + toString());
   }
 
+    @Override
   public int hashCode()
   {
     return piece ^ off ^ len;
   }
 
+    @Override
   public boolean equals(Object o)
   {
     if (o instanceof Request)
@@ -67,6 +69,7 @@ class Request
     return false;
   }
 
+    @Override
   public String toString()
   {
     return "(" + piece + "," + off + "," + len + ")";

apps/i2psnark/java/src/org/klomp/snark/Snark.java

@@ -28,7 +28,6 @@ import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.util.Iterator;
 import java.util.List;
-import java.util.Map;
 import java.util.Properties;
 import java.util.Random;
 import java.util.StringTokenizer;
@@ -322,7 +321,7 @@ public class Snark
     // sixteen random bytes.
     byte snark = (((3 + 7 + 10) * (1000 - 8)) / 992) - 17;
     id = new byte[20];
-    Random random = new Random();
+    Random random = I2PAppContext.getGlobalContext().random();
     int i;
     for (i = 0; i < 9; i++)
       id[i] = 0;
@@ -438,7 +437,7 @@ public class Snark
             try { storage.close(); } catch (IOException ioee) {
                 ioee.printStackTrace();
             }
-            fatal("Could not create storage", ioe);
+            fatal("Could not check or create storage", ioe);
           }
       }
 
@@ -619,14 +618,14 @@ public class Snark
             command_interpreter = false;
             i++;
           }
-        else if (args[i].equals("--eepproxy"))
-          {
-            String proxyHost = args[i+1];
-            String proxyPort = args[i+2];
-            if (!configured)
-                util.setProxy(proxyHost, Integer.parseInt(proxyPort));
-            i += 3;
-          }
+        //else if (args[i].equals("--eepproxy"))
+        //  {
+        //    String proxyHost = args[i+1];
+        //    String proxyPort = args[i+2];
+        //    if (!configured)
+        //        util.setProxy(proxyHost, Integer.parseInt(proxyPort));
+        //    i += 3;
+        //  }
         else if (args[i].equals("--i2cp"))
           {
             String i2cpHost = args[i+1];
@@ -735,7 +734,7 @@ public class Snark
     //if (debug >= INFO && t != null)
     //  t.printStackTrace();
     stopTorrent();
-    throw new RuntimeException("die bart die");
+    throw new RuntimeException(s + (t == null ? "" : ": " + t));
   }
 
   /**

apps/i2psnark/java/src/org/klomp/snark/SnarkManager.java

@@ -20,6 +20,8 @@ import net.i2p.data.Base64;
 import net.i2p.data.DataHelper;
 import net.i2p.util.I2PAppThread;
 import net.i2p.util.Log;
+import net.i2p.util.OrderedProperties;
+import net.i2p.util.SecureDirectory;
 
 /**
  * Manage multiple snarks
@@ -28,37 +30,42 @@ public class SnarkManager implements Snark.CompleteListener {
     private static SnarkManager _instance = new SnarkManager();
     public static SnarkManager instance() { return _instance; }
     
-    /** map of (canonical) filename to Snark instance (unsynchronized) */
-    private Map _snarks;
-    private Object _addSnarkLock;
-    private String _configFile = "i2psnark.config";
+    /** map of (canonical) filename of the .torrent file to Snark instance (unsynchronized) */
+    private final Map<String, Snark> _snarks;
+    private final Object _addSnarkLock;
+    private /* FIXME final FIXME */ File _configFile;
     private Properties _config;
     private I2PAppContext _context;
     private Log _log;
-    private List _messages;
+    private final List _messages;
     private I2PSnarkUtil _util;
     private PeerCoordinatorSet _peerCoordinatorSet;
     private ConnectionAcceptor _connectionAcceptor;
+    private Thread _monitor;
+    private boolean _running;
     
     public static final String PROP_I2CP_HOST = "i2psnark.i2cpHost";
     public static final String PROP_I2CP_PORT = "i2psnark.i2cpPort";
     public static final String PROP_I2CP_OPTS = "i2psnark.i2cpOptions";
-    public static final String PROP_EEP_HOST = "i2psnark.eepHost";
-    public static final String PROP_EEP_PORT = "i2psnark.eepPort";
+    //public static final String PROP_EEP_HOST = "i2psnark.eepHost";
+    //public static final String PROP_EEP_PORT = "i2psnark.eepPort";
     public static final String PROP_UPLOADERS_TOTAL = "i2psnark.uploaders.total";
     public static final String PROP_UPBW_MAX = "i2psnark.upbw.max";
     public static final String PROP_DIR = "i2psnark.dir";
     public static final String PROP_META_PREFIX = "i2psnark.zmeta.";
     public static final String PROP_META_BITFIELD_SUFFIX = ".bitfield";
+    public static final String PROP_META_PRIORITY_SUFFIX = ".priority";
 
+    private static final String CONFIG_FILE = "i2psnark.config";
     public static final String PROP_AUTO_START = "i2snark.autoStart";   // oops
     public static final String DEFAULT_AUTO_START = "false";
     public static final String PROP_LINK_PREFIX = "i2psnark.linkPrefix";
     public static final String DEFAULT_LINK_PREFIX = "file:///";
-    
+    public static final String PROP_STARTUP_DELAY = "i2psnark.startupDelay";
+   
     public static final int MIN_UP_BW = 2;
     public static final int DEFAULT_MAX_UP_BW = 10;
-
+    public static final int DEFAULT_STARTUP_DELAY = 3; 
     private SnarkManager() {
         _snarks = new HashMap();
         _addSnarkLock = new Object();
@@ -66,6 +73,9 @@ public class SnarkManager implements Snark.CompleteListener {
         _log = _context.logManager().getLog(SnarkManager.class);
         _messages = new ArrayList(16);
         _util = new I2PSnarkUtil(_context);
+        _configFile = new File(CONFIG_FILE);
+        if (!_configFile.isAbsolute())
+            _configFile = new File(_context.getConfigDir(), CONFIG_FILE);
         loadConfig(null);
     }
 
@@ -73,15 +83,22 @@ public class SnarkManager implements Snark.CompleteListener {
      *  for i2cp host/port or i2psnark.dir
      */
     public void start() {
+        _running = true;
         _peerCoordinatorSet = new PeerCoordinatorSet();
         _connectionAcceptor = new ConnectionAcceptor(_util);
         int minutes = getStartupDelayMinutes();
-        _messages.add("Adding torrents in " + minutes + (minutes == 1 ? " minute" : " minutes"));
-        I2PAppThread monitor = new I2PAppThread(new DirMonitor(), "Snark DirMonitor");
-        monitor.setDaemon(true);
-        monitor.start();
+        _messages.add(_("Adding torrents in {0} minutes", minutes));
+        _monitor = new I2PAppThread(new DirMonitor(), "Snark DirMonitor", true);
+        _monitor.start();
         _context.addShutdownTask(new SnarkManagerShutdown());
     }
+
+    public void stop() {
+        _running = false;
+        _monitor.interrupt();
+        _connectionAcceptor.halt();
+        (new SnarkManagerShutdown()).run();
+    }
     
     /** hook to I2PSnarkUtil for the servlet */
     public I2PSnarkUtil util() { return _util; }
@@ -110,21 +127,26 @@ public class SnarkManager implements Snark.CompleteListener {
     public String linkPrefix() {
         return _config.getProperty(PROP_LINK_PREFIX, DEFAULT_LINK_PREFIX + getDataDir().getAbsolutePath() + File.separatorChar);
     }
-    private int getStartupDelayMinutes() { return 3; }
+    private int getStartupDelayMinutes() { 
+	return Integer.valueOf(_config.getProperty(PROP_STARTUP_DELAY)).intValue(); 
+    }
     public File getDataDir() { 
-        String dir = _config.getProperty(PROP_DIR);
-        if ( (dir == null) || (dir.trim().length() <= 0) )
-            dir = "i2psnark";
-        return new File(dir); 
+        String dir = _config.getProperty(PROP_DIR, "i2psnark");
+        File f = new SecureDirectory(dir);
+        if (!f.isAbsolute())
+            f = new SecureDirectory(_context.getAppDir(), dir);
+        return f; 
     }
     
     /** null to set initial defaults */
     public void loadConfig(String filename) {
         if (_config == null)
-            _config = new Properties();
+            _config = new OrderedProperties();
         if (filename != null) {
-            _configFile = filename;
             File cfg = new File(filename);
+            if (!cfg.isAbsolute())
+                cfg = new File(_context.getConfigDir(), filename);
+            _configFile = cfg;
             if (cfg.exists()) {
                 try {
                     DataHelper.loadProps(_config, cfg);
@@ -140,16 +162,19 @@ public class SnarkManager implements Snark.CompleteListener {
             _config.setProperty(PROP_I2CP_PORT, "7654");
         if (!_config.containsKey(PROP_I2CP_OPTS))
             _config.setProperty(PROP_I2CP_OPTS, "inbound.length=2 inbound.lengthVariance=0 outbound.length=2 outbound.lengthVariance=0 inbound.quantity=3 outbound.quantity=3");
-        if (!_config.containsKey(PROP_EEP_HOST))
-            _config.setProperty(PROP_EEP_HOST, "127.0.0.1");
-        if (!_config.containsKey(PROP_EEP_PORT))
-            _config.setProperty(PROP_EEP_PORT, "4444");
+        //if (!_config.containsKey(PROP_EEP_HOST))
+        //    _config.setProperty(PROP_EEP_HOST, "127.0.0.1");
+        //if (!_config.containsKey(PROP_EEP_PORT))
+        //    _config.setProperty(PROP_EEP_PORT, "4444");
         if (!_config.containsKey(PROP_UPLOADERS_TOTAL))
             _config.setProperty(PROP_UPLOADERS_TOTAL, "" + Snark.MAX_TOTAL_UPLOADERS);
         if (!_config.containsKey(PROP_DIR))
             _config.setProperty(PROP_DIR, "i2psnark");
         if (!_config.containsKey(PROP_AUTO_START))
             _config.setProperty(PROP_AUTO_START, DEFAULT_AUTO_START);
+	if (!_config.containsKey(PROP_STARTUP_DELAY))
+            _config.setProperty(PROP_STARTUP_DELAY, "" + DEFAULT_STARTUP_DELAY);
+
         updateConfig();
     }
 
@@ -178,15 +203,21 @@ public class SnarkManager implements Snark.CompleteListener {
         }
         if (i2cpHost != null) {
             _util.setI2CPConfig(i2cpHost, i2cpPort, i2cpOpts);
-            _log.debug("Configuring with I2CP options " + i2cpOpts);
+            if (_log.shouldLog(Log.DEBUG))
+                _log.debug("Configuring with I2CP options " + i2cpOpts);
         }
         //I2PSnarkUtil.instance().setI2CPConfig("66.111.51.110", 7654, new Properties());
-        String eepHost = _config.getProperty(PROP_EEP_HOST);
-        int eepPort = getInt(PROP_EEP_PORT, 4444);
-        if (eepHost != null)
-            _util.setProxy(eepHost, eepPort);
+        //String eepHost = _config.getProperty(PROP_EEP_HOST);
+        //int eepPort = getInt(PROP_EEP_PORT, 4444);
+        //if (eepHost != null)
+        //    _util.setProxy(eepHost, eepPort);
         _util.setMaxUploaders(getInt(PROP_UPLOADERS_TOTAL, Snark.MAX_TOTAL_UPLOADERS));
         _util.setMaxUpBW(getInt(PROP_UPBW_MAX, DEFAULT_MAX_UP_BW));
+        _util.setStartupDelay(getInt(PROP_STARTUP_DELAY, DEFAULT_STARTUP_DELAY));
+        String ot = _config.getProperty(I2PSnarkUtil.PROP_OPENTRACKERS);
+        if (ot != null)
+            _util.setOpenTrackerString(ot);
+        // FIXME set util use open trackers property somehow
         getDataDir().mkdirs();
     }
     
@@ -201,23 +232,24 @@ public class SnarkManager implements Snark.CompleteListener {
         return defaultVal;
     }
     
-    public void updateConfig(String dataDir, boolean autoStart, String seedPct, String eepHost, 
+    public void updateConfig(String dataDir, boolean autoStart, String startDelay, String seedPct, String eepHost, 
                              String eepPort, String i2cpHost, String i2cpPort, String i2cpOpts,
                              String upLimit, String upBW, boolean useOpenTrackers, String openTrackers) {
         boolean changed = false;
-        if (eepHost != null) {
-            int port = _util.getEepProxyPort();
-            try { port = Integer.parseInt(eepPort); } catch (NumberFormatException nfe) {}
-            String host = _util.getEepProxyHost();
-            if ( (eepHost.trim().length() > 0) && (port > 0) &&
-                 ((!host.equals(eepHost) || (port != _util.getEepProxyPort()) )) ) {
-                _util.setProxy(eepHost, port);
-                changed = true;
-                _config.setProperty(PROP_EEP_HOST, eepHost);
-                _config.setProperty(PROP_EEP_PORT, eepPort+"");
-                addMessage("EepProxy location changed to " + eepHost + ":" + port);
-            }
-        }
+        //if (eepHost != null) {
+        //    // unused, we use socket eepget
+        //    int port = _util.getEepProxyPort();
+        //    try { port = Integer.parseInt(eepPort); } catch (NumberFormatException nfe) {}
+        //    String host = _util.getEepProxyHost();
+        //    if ( (eepHost.trim().length() > 0) && (port > 0) &&
+        //         ((!host.equals(eepHost) || (port != _util.getEepProxyPort()) )) ) {
+        //        _util.setProxy(eepHost, port);
+        //        changed = true;
+        //        _config.setProperty(PROP_EEP_HOST, eepHost);
+        //        _config.setProperty(PROP_EEP_PORT, eepPort+"");
+        //        addMessage("EepProxy location changed to " + eepHost + ":" + port);
+        //    }
+        //}
         if (upLimit != null) {
             int limit = _util.getMaxUploaders();
             try { limit = Integer.parseInt(upLimit); } catch (NumberFormatException nfe) {}
@@ -226,9 +258,9 @@ public class SnarkManager implements Snark.CompleteListener {
                     _util.setMaxUploaders(limit);
                     changed = true;
                     _config.setProperty(PROP_UPLOADERS_TOTAL, "" + limit);
-                    addMessage("Total uploaders limit changed to " + limit);
+                    addMessage(_("Total uploaders limit changed to {0}", limit));
                 } else {
-                    addMessage("Minimum total uploaders limit is " + Snark.MIN_TOTAL_UPLOADERS);
+                    addMessage(_("Minimum total uploaders limit is {0}", Snark.MIN_TOTAL_UPLOADERS));
                 }
             }
         }
@@ -240,13 +272,25 @@ public class SnarkManager implements Snark.CompleteListener {
                     _util.setMaxUpBW(limit);
                     changed = true;
                     _config.setProperty(PROP_UPBW_MAX, "" + limit);
-                    addMessage("Up BW limit changed to " + limit + "KBps");
+                    addMessage(_("Up BW limit changed to {0}KBps", limit));
                 } else {
-                    addMessage("Minimum Up BW limit is " + MIN_UP_BW + "KBps");
+                    addMessage(_("Minimum up bandwidth limit is {0}KBps", MIN_UP_BW));
                 }
             }
         }
-        if (i2cpHost != null) {
+        
+	if (startDelay != null){
+		int minutes = _util.getStartupDelay();
+                try { minutes = Integer.parseInt(startDelay); } catch (NumberFormatException nfe) {}
+	        if ( minutes != _util.getStartupDelay()) {
+                	    _util.setStartupDelay(minutes);
+	                    changed = true;
+        	            _config.setProperty(PROP_STARTUP_DELAY, "" + minutes);
+                	    addMessage(_("Startup delay limit changed to {0} minutes", minutes));
+                	}
+
+	}
+	if (i2cpHost != null) {
             int oldI2CPPort = _util.getI2CPPort();
             String oldI2CPHost = _util.getI2CPHost();
             int port = oldI2CPPort;
@@ -286,27 +330,31 @@ public class SnarkManager implements Snark.CompleteListener {
                     }
                 }
                 if (snarksActive) {
-                    addMessage("Cannot change the I2CP settings while torrents are active");
-                    _log.debug("i2cp host [" + i2cpHost + "] i2cp port " + port + " opts [" + opts 
-                               + "] oldOpts [" + oldOpts + "]");
+                    Properties p = new Properties();
+                    p.putAll(opts);
+                    _util.setI2CPConfig(i2cpHost, port, p);
+                    addMessage(_("I2CP and tunnel changes will take effect after stopping all torrents"));
+                    if (_log.shouldLog(Log.DEBUG))
+                        _log.debug("i2cp host [" + i2cpHost + "] i2cp port " + port + " opts [" + opts 
+                                   + "] oldOpts [" + oldOpts + "]");
                 } else {
                     if (_util.connected()) {
                         _util.disconnect();
-                        addMessage("Disconnecting old I2CP destination");
+                        addMessage(_("Disconnecting old I2CP destination"));
                     }
                     Properties p = new Properties();
                     p.putAll(opts);
-                    addMessage("I2CP settings changed to " + i2cpHost + ":" + port + " (" + i2cpOpts.trim() + ")");
+                    addMessage(_("I2CP settings changed to {0}", i2cpHost + ":" + port + " (" + i2cpOpts.trim() + ")"));
                     _util.setI2CPConfig(i2cpHost, port, p);
                     boolean ok = _util.connect();
                     if (!ok) {
-                        addMessage("Unable to connect with the new settings, reverting to the old I2CP settings");
+                        addMessage(_("Unable to connect with the new settings, reverting to the old I2CP settings"));
                         _util.setI2CPConfig(oldI2CPHost, oldI2CPPort, oldOpts);
                         ok = _util.connect();
                         if (!ok)
-                            addMessage("Unable to reconnect with the old settings!");
+                            addMessage(_("Unable to reconnect with the old settings!"));
                     } else {
-                        addMessage("Reconnected on the new I2CP destination");
+                        addMessage(_("Reconnected on the new I2CP destination"));
                         _config.setProperty(PROP_I2CP_HOST, i2cpHost.trim());
                         _config.setProperty(PROP_I2CP_PORT, "" + port);
                         _config.setProperty(PROP_I2CP_OPTS, i2cpOpts.trim());
@@ -317,7 +365,7 @@ public class SnarkManager implements Snark.CompleteListener {
                             Snark snark = getTorrent(name);
                             if ( (snark != null) && (snark.acceptor != null) ) {
                                 snark.acceptor.restart();
-                                addMessage("I2CP listener restarted for " + snark.meta.getName());
+                                addMessage(_("I2CP listener restarted for \"{0}\"", snark.meta.getName()));
                             }
                         }
                     }
@@ -327,35 +375,42 @@ public class SnarkManager implements Snark.CompleteListener {
         }
         if (shouldAutoStart() != autoStart) {
             _config.setProperty(PROP_AUTO_START, autoStart + "");
-            addMessage("Adjusted autostart to " + autoStart);
+            if (autoStart)
+                addMessage(_("Enabled autostart"));
+            else
+                addMessage(_("Disabled autostart"));
             changed = true;
         }
         if (_util.shouldUseOpenTrackers() != useOpenTrackers) {
             _config.setProperty(I2PSnarkUtil.PROP_USE_OPENTRACKERS, useOpenTrackers + "");
-            addMessage((useOpenTrackers ? "En" : "Dis") + "abled open trackers - torrent restart required to take effect");
+            if (useOpenTrackers)
+                addMessage(_("Enabled open trackers - torrent restart required to take effect."));
+            else
+                addMessage(_("Disabled open trackers - torrent restart required to take effect."));
             changed = true;
         }
         if (openTrackers != null) {
             if (openTrackers.trim().length() > 0 && !openTrackers.trim().equals(_util.getOpenTrackerString())) {
                 _config.setProperty(I2PSnarkUtil.PROP_OPENTRACKERS, openTrackers.trim());
-                addMessage("Open Tracker list changed - torrent restart required to take effect");
+                _util.setOpenTrackerString(openTrackers);
+                addMessage(_("Open Tracker list changed - torrent restart required to take effect."));
                 changed = true;
             }
         }
         if (changed) {
             saveConfig();
         } else {
-            addMessage("Configuration unchanged");
+            addMessage(_("Configuration unchanged."));
         }
     }
     
     public void saveConfig() {
         try {
             synchronized (_configFile) {
-                DataHelper.storeProps(_config, new File(_configFile));
+                DataHelper.storeProps(_config, _configFile);
             }
         } catch (IOException ioe) {
-            addMessage("Unable to save the config to '" + _configFile + "'");
+            addMessage(_("Unable to save the config to {0}", _configFile.getAbsolutePath()));
         }
     }
     
@@ -364,19 +419,40 @@ public class SnarkManager implements Snark.CompleteListener {
     /** hardcoded for sanity.  perhaps this should be customizable, for people who increase their ulimit, etc. */
     private static final int MAX_FILES_PER_TORRENT = 512;
     
-    /** set of filenames that we are dealing with */
-    public Set listTorrentFiles() { synchronized (_snarks) { return new HashSet(_snarks.keySet()); } }
+    /** set of canonical .torrent filenames that we are dealing with */
+    public Set<String> listTorrentFiles() { synchronized (_snarks) { return new HashSet(_snarks.keySet()); } }
+
     /**
-     * Grab the torrent given the (canonical) filename
+     * Grab the torrent given the (canonical) filename of the .torrent file
+     * @return Snark or null
      */
     public Snark getTorrent(String filename) { synchronized (_snarks) { return (Snark)_snarks.get(filename); } }
+
+    /**
+     * Grab the torrent given the base name of the storage
+     * @return Snark or null
+     * @since 0.7.14
+     */
+    public Snark getTorrentByBaseName(String filename) {
+        synchronized (_snarks) {
+            for (Snark s : _snarks.values()) {
+                if (s.storage.getBaseName().equals(filename))
+                    return s;
+            }
+        }
+        return null;
+    }
+
+    /** @throws RuntimeException via Snark.fatal() */
     public void addTorrent(String filename) { addTorrent(filename, false); }
+
+    /** @throws RuntimeException via Snark.fatal() */
     public void addTorrent(String filename, boolean dontAutoStart) {
         if ((!dontAutoStart) && !_util.connected()) {
-            addMessage("Connecting to I2P");
+            addMessage(_("Connecting to I2P"));
             boolean ok = _util.connect();
             if (!ok) {
-                addMessage("Error connecting to I2P - check your I2CP settings");
+                addMessage(_("Error connecting to I2P - check your I2CP settings!"));
                 return;
             }
         }
@@ -385,7 +461,7 @@ public class SnarkManager implements Snark.CompleteListener {
             filename = sfile.getCanonicalPath();
         } catch (IOException ioe) {
             _log.error("Unable to add the torrent " + filename, ioe);
-            addMessage("ERR: Could not add the torrent '" + filename + "': " + ioe.getMessage());
+            addMessage(_("Error: Could not add the torrent {0}", filename) + ": " + ioe.getMessage());
             return;
         }
         File dataDir = getDataDir();
@@ -405,10 +481,27 @@ public class SnarkManager implements Snark.CompleteListener {
                 FileInputStream fis = null;
                 try {
                     fis = new FileInputStream(sfile);
+                } catch (IOException ioe) {
+                    // catch this here so we don't try do delete it below
+                    addMessage(_("Cannot open \"{0}\"", sfile.getName()) + ": " + ioe.getMessage());
+                    return;
+                }
+
+                try {
                     MetaInfo info = new MetaInfo(fis);
-                    fis.close();
-                    fis = null;
+                    try {
+                        fis.close();
+                        fis = null;
+                    } catch (IOException e) {}
                     
+                    if (!TrackerClient.isValidAnnounce(info.getAnnounce())) {
+                        if (_util.shouldUseOpenTrackers() && _util.getOpenTrackers() != null) {
+                            addMessage(_("Warning - Ignoring non-i2p tracker in \"{0}\", will announce to i2p open trackers only", info.getName()));
+                        } else {
+                            addMessage(_("Warning - Ignoring non-i2p tracker in \"{0}\", and open trackers are disabled, you must enable open trackers before starting the torrent!", info.getName()));
+                            dontAutoStart = true;
+                        }
+                    }
                     String rejectMessage = locked_validateTorrent(info);
                     if (rejectMessage != null) {
                         sfile.delete();
@@ -418,13 +511,14 @@ public class SnarkManager implements Snark.CompleteListener {
                         torrent = new Snark(_util, filename, null, -1, null, null, this,
                                             _peerCoordinatorSet, _connectionAcceptor,
                                             false, dataDir.getPath());
+                        loadSavedFilePriorities(torrent);
                         torrent.completeListener = this;
                         synchronized (_snarks) {
                             _snarks.put(filename, torrent);
                         }
                     }
                 } catch (IOException ioe) {
-                    addMessage("Torrent in " + sfile.getName() + " is invalid: " + ioe.getMessage());
+                    addMessage(_("Torrent in \"{0}\" is invalid", sfile.getName()) + ": " + ioe.getMessage());
                     if (sfile.exists())
                         sfile.delete();
                     return;
@@ -439,9 +533,9 @@ public class SnarkManager implements Snark.CompleteListener {
         File f = new File(filename);
         if (!dontAutoStart && shouldAutoStart()) {
             torrent.startTorrent();
-            addMessage("Torrent added and started: '" + f.getName() + "'");
+            addMessage(_("Torrent added and started: \"{0}\"", f.getName()));
         } else {
-            addMessage("Torrent added: '" + f.getName() + "'");
+            addMessage(_("Torrent added: \"{0}\"", f.getName()));
         }
     }
     
@@ -495,6 +589,33 @@ public class SnarkManager implements Snark.CompleteListener {
         return new BitField(bitfield, len);
     }
     
+    /**
+     * Get the saved priorities for a torrent from the config file.
+     * @since 0.8.1
+     */
+    public void loadSavedFilePriorities(Snark snark) {
+        MetaInfo metainfo = snark.meta;
+        if (metainfo.getFiles() == null)
+            return;
+        byte[] ih = metainfo.getInfoHash();
+        String infohash = Base64.encode(ih);
+        infohash = infohash.replace('=', '$');
+        String pri = _config.getProperty(PROP_META_PREFIX + infohash + PROP_META_PRIORITY_SUFFIX);
+        if (pri == null)
+            return;
+        int filecount = metainfo.getFiles().size();
+        int[] rv = new int[filecount];
+        String[] arr = pri.split(",");
+        for (int i = 0; i < filecount && i < arr.length; i++) {
+            if (arr[i].length() > 0) {
+                try {
+                    rv[i] = Integer.parseInt(arr[i]);
+                } catch (Throwable t) {}
+            }
+        }
+        snark.storage.setFilePriorities(rv);
+    }
+    
     /**
      * Save the completion status of a torrent and the current time in the config file
      * in the form "i2psnark.zmeta.$base64infohash=$time,$base64bitfield".
@@ -503,8 +624,9 @@ public class SnarkManager implements Snark.CompleteListener {
      * The time is a standard long converted to string.
      * The status is either a bitfield converted to Base64 or "." for a completed
      * torrent to save space in the config file and in memory.
+     * @param priorities may be null
      */
-    public void saveTorrentStatus(MetaInfo metainfo, BitField bitfield) {
+    public void saveTorrentStatus(MetaInfo metainfo, BitField bitfield, int[] priorities) {
         byte[] ih = metainfo.getInfoHash();
         String infohash = Base64.encode(ih);
         infohash = infohash.replace('=', '$');
@@ -517,6 +639,34 @@ public class SnarkManager implements Snark.CompleteListener {
           bfs = Base64.encode(bf);
         }
         _config.setProperty(PROP_META_PREFIX + infohash + PROP_META_BITFIELD_SUFFIX, now + "," + bfs);
+
+        // now the file priorities
+        String prop = PROP_META_PREFIX + infohash + PROP_META_PRIORITY_SUFFIX;
+        if (priorities != null) {
+            boolean nonzero = false;
+            for (int i = 0; i < priorities.length; i++) {
+                if (priorities[i] != 0) {
+                    nonzero = true;
+                    break;
+                }
+            }
+            if (nonzero) {
+                // generate string like -5,,4,3,,,,,,-2 where no number is zero.
+                StringBuilder buf = new StringBuilder(2 * priorities.length);
+                for (int i = 0; i < priorities.length; i++) {
+                    if (priorities[i] != 0)
+                        buf.append(Integer.toString(priorities[i]));
+                    if (i != priorities.length - 1)
+                        buf.append(',');
+                }
+                _config.setProperty(prop, buf.toString());
+            } else {
+                _config.remove(prop);
+            }
+        } else {
+            _config.remove(prop);
+        }
+
         saveConfig();
     }
     
@@ -529,32 +679,34 @@ public class SnarkManager implements Snark.CompleteListener {
         String infohash = Base64.encode(ih);
         infohash = infohash.replace('=', '$');
         _config.remove(PROP_META_PREFIX + infohash + PROP_META_BITFIELD_SUFFIX);
+        _config.remove(PROP_META_PREFIX + infohash + PROP_META_PRIORITY_SUFFIX);
         saveConfig();
     }
     
+    /**
+     *  Warning - does not validate announce URL - use TrackerClient.isValidAnnounce()
+     */
     private String locked_validateTorrent(MetaInfo info) throws IOException {
-        String announce = info.getAnnounce();
-        // basic validation of url
-        if ((!announce.startsWith("http://")) ||
-            (announce.indexOf(".i2p/") < 0)) // need to do better than this
-            return "Non-i2p tracker in " + info.getName() + ", deleting it";
         List files = info.getFiles();
         if ( (files != null) && (files.size() > MAX_FILES_PER_TORRENT) ) {
-            return "Too many files in " + info.getName() + " (" + files.size() + "), deleting it";
+            return _("Too many files in \"{0}\" ({1}), deleting it!", info.getName(), files.size());
+        } else if ( (files == null) && (info.getName().endsWith(".torrent")) ) {
+            return _("Torrent file \"{0}\" cannot end in \".torrent\", deleting it!", info.getName());
         } else if (info.getPieces() <= 0) {
-            return "No pieces in " + info.getName() + "?  deleting it";
+            return _("No pieces in \"{0}\",  deleting it!", info.getName());
+        } else if (info.getPieces() > Storage.MAX_PIECES) {
+            return _("Too many pieces in \"{0}\", limit is {1}, deleting it!", info.getName(), Storage.MAX_PIECES);
         } else if (info.getPieceLength(0) > Storage.MAX_PIECE_SIZE) {
-            return "Pieces are too large in " + info.getName() + " (" + DataHelper.formatSize(info.getPieceLength(0)) +
-                   "B), deleting it";
+            return _("Pieces are too large in \"{0}\" ({1}B), deleting it.", info.getName(), DataHelper.formatSize2(info.getPieceLength(0))) + ' ' +
+                   _("Limit is {0}B", DataHelper.formatSize2(Storage.MAX_PIECE_SIZE));
         } else if (info.getTotalLength() > Storage.MAX_TOTAL_SIZE) {
             System.out.println("torrent info: " + info.toString());
             List lengths = info.getLengths();
             if (lengths != null)
                 for (int i = 0; i < lengths.size(); i++)
-                    System.out.println("File " + i + " is " + lengths.get(i) + " long");
+                    System.out.println("File " + i + " is " + lengths.get(i) + " long.");
             
-            return "Torrents larger than " + DataHelper.formatSize(Storage.MAX_TOTAL_SIZE) +
-                   "B are not supported yet (because we're paranoid): " + info.getName() + ", deleting it";
+            return _("Torrents larger than {0}B are not supported yet, deleting \"{1}\"", Storage.MAX_TOTAL_SIZE, info.getName());
         } else {
             // ok
             return null;
@@ -570,7 +722,7 @@ public class SnarkManager implements Snark.CompleteListener {
             filename = sfile.getCanonicalPath();
         } catch (IOException ioe) {
             _log.error("Unable to remove the torrent " + filename, ioe);
-            addMessage("ERR: Could not remove the torrent '" + filename + "': " + ioe.getMessage());
+            addMessage(_("Error: Could not remove the torrent {0}", filename) + ": " + ioe.getMessage());
             return null;
         }
         int remaining = 0;
@@ -591,7 +743,7 @@ public class SnarkManager implements Snark.CompleteListener {
                 ////_util.
             }
             if (!wasStopped)
-                addMessage("Torrent stopped: '" + sfile.getName() + "'");
+                addMessage(_("Torrent stopped: \"{0}\"", sfile.getName()));
         }
         return torrent;
     }
@@ -606,7 +758,7 @@ public class SnarkManager implements Snark.CompleteListener {
             torrentFile.delete();
             if (torrent.storage != null)
                 removeTorrentStatus(torrent.storage.getMetaInfo());
-            addMessage("Torrent removed: '" + torrentFile.getName() + "'");
+            addMessage(_("Torrent removed: \"{0}\"", torrentFile.getName()));
         }
     }
     
@@ -624,7 +776,8 @@ public class SnarkManager implements Snark.CompleteListener {
             getBWLimit();
             while (true) {
                 File dir = getDataDir();
-                _log.debug("Directory Monitor loop over " + dir.getAbsolutePath());
+                if (_log.shouldLog(Log.DEBUG))
+                    _log.debug("Directory Monitor loop over " + dir.getAbsolutePath());
                 try {
                     monitorTorrents(dir);
                 } catch (Exception e) {
@@ -637,19 +790,23 @@ public class SnarkManager implements Snark.CompleteListener {
     
     /** two listeners */
     public void torrentComplete(Snark snark) {
-        File f = new File(snark.torrent);
+        StringBuilder buf = new StringBuilder(256);
+        buf.append("<a href=\"/i2psnark/").append(snark.storage.getBaseName());
+        if (snark.meta.getFiles() != null)
+            buf.append('/');
+        buf.append("\">").append(snark.storage.getBaseName()).append("</a>");
         long len = snark.meta.getTotalLength();
-        addMessage("Download complete of " + f.getName() + " (size: " + DataHelper.formatSize(len) + "B)");
+        addMessage(_("Download finished: {0}", buf.toString()) + " (" + _("size: {0}B", DataHelper.formatSize2(len)) + ')');
         updateStatus(snark);
     }
     
     public void updateStatus(Snark snark) {
-        saveTorrentStatus(snark.meta, snark.storage.getBitField());
+        saveTorrentStatus(snark.meta, snark.storage.getBitField(), snark.storage.getFilePriorities());
     }
     
     private void monitorTorrents(File dir) {
         String fileNames[] = dir.list(TorrentFilenameFilter.instance());
-        List foundNames = new ArrayList(0);
+        List<String> foundNames = new ArrayList(0);
         if (fileNames != null) {
             for (int i = 0; i < fileNames.length; i++) {
                 try {
@@ -660,15 +817,21 @@ public class SnarkManager implements Snark.CompleteListener {
             }
         }
         
-        Set existingNames = listTorrentFiles();
+        Set<String> existingNames = listTorrentFiles();
         // lets find new ones first...
         for (int i = 0; i < foundNames.size(); i++) {
             if (existingNames.contains(foundNames.get(i))) {
                 // already known.  noop
             } else {
                 if (shouldAutoStart() && !_util.connect())
-                    addMessage("Unable to connect to I2P");
-                addTorrent((String)foundNames.get(i), !shouldAutoStart());
+                    addMessage(_("Unable to connect to I2P!"));
+                try {
+                    // Snark.fatal() throws a RuntimeException
+                    // don't let one bad torrent kill the whole loop
+                    addTorrent(foundNames.get(i), !shouldAutoStart());
+                } catch (Exception e) {
+                    addMessage(_("Unable to add {0}", foundNames.get(i)) + ": " + e);
+                }
             }
         }
         // now lets see which ones have been removed...
@@ -678,24 +841,48 @@ public class SnarkManager implements Snark.CompleteListener {
                 // known and still there.  noop
             } else {
                 // known, but removed.  drop it
-                stopTorrent(name, true);
+                try {
+                    // Snark.fatal() throws a RuntimeException
+                    // don't let one bad torrent kill the whole loop
+                    stopTorrent(name, true);
+                } catch (Exception e) {
+                    // don't bother with message
+                }
             }
         }
     }
 
+    /** translate */
+    private String _(String s) {
+        return _util.getString(s);
+    }
+
+    /** translate */
+    private String _(String s, Object o) {
+        return _util.getString(s, o);
+    }
+
+    /** translate */
+    private String _(String s, Object o, Object o2) {
+        return _util.getString(s, o, o2);
+    }
+
+    /**
+     *  "name", "announceURL=websiteURL" pairs
+     */
     private static final String DEFAULT_TRACKERS[] = { 
-       "Postman", "http://YRgrgTLGnbTq2aZOZDJQ~o6Uk5k6TK-OZtx0St9pb0G-5EGYURZioxqYG8AQt~LgyyI~NCj6aYWpPO-150RcEvsfgXLR~CxkkZcVpgt6pns8SRc3Bi-QSAkXpJtloapRGcQfzTtwllokbdC-aMGpeDOjYLd8b5V9Im8wdCHYy7LRFxhEtGb~RL55DA8aYOgEXcTpr6RPPywbV~Qf3q5UK55el6Kex-6VCxreUnPEe4hmTAbqZNR7Fm0hpCiHKGoToRcygafpFqDw5frLXToYiqs9d4liyVB-BcOb0ihORbo0nS3CLmAwZGvdAP8BZ7cIYE3Z9IU9D1G8JCMxWarfKX1pix~6pIA-sp1gKlL1HhYhPMxwyxvuSqx34o3BqU7vdTYwWiLpGM~zU1~j9rHL7x60pVuYaXcFQDR4-QVy26b6Pt6BlAZoFmHhPcAuWfu-SFhjyZYsqzmEmHeYdAwa~HojSbofg0TMUgESRXMw6YThK1KXWeeJVeztGTz25sL8AAAA.i2p/announce.php=http://tracker.postman.i2p/"
+//       "Postman", "http://YRgrgTLGnbTq2aZOZDJQ~o6Uk5k6TK-OZtx0St9pb0G-5EGYURZioxqYG8AQt~LgyyI~NCj6aYWpPO-150RcEvsfgXLR~CxkkZcVpgt6pns8SRc3Bi-QSAkXpJtloapRGcQfzTtwllokbdC-aMGpeDOjYLd8b5V9Im8wdCHYy7LRFxhEtGb~RL55DA8aYOgEXcTpr6RPPywbV~Qf3q5UK55el6Kex-6VCxreUnPEe4hmTAbqZNR7Fm0hpCiHKGoToRcygafpFqDw5frLXToYiqs9d4liyVB-BcOb0ihORbo0nS3CLmAwZGvdAP8BZ7cIYE3Z9IU9D1G8JCMxWarfKX1pix~6pIA-sp1gKlL1HhYhPMxwyxvuSqx34o3BqU7vdTYwWiLpGM~zU1~j9rHL7x60pVuYaXcFQDR4-QVy26b6Pt6BlAZoFmHhPcAuWfu-SFhjyZYsqzmEmHeYdAwa~HojSbofg0TMUgESRXMw6YThK1KXWeeJVeztGTz25sL8AAAA.i2p/announce.php=http://tracker.postman.i2p/"
 //       , "eBook", "http://E71FRom6PZNEqTN2Lr8P-sr23b7HJVC32KoGnVQjaX6zJiXwhJy2HsXob36Qmj81TYFZdewFZa9mSJ533UZgGyQkXo2ahctg82JKYZfDe5uDxAn1E9YPjxZCWJaFJh0S~UwSs~9AZ7UcauSJIoNtpxrtbmRNVFLqnkEDdLZi26TeucfOmiFmIWnVblLniWv3tG1boE9Abd-6j3FmYVrRucYuepAILYt6katmVNOk6sXmno1Eynrp~~MBuFq0Ko6~jsc2E2CRVYXDhGHEMdt-j6JUz5D7S2RIVzDRqQyAZLKJ7OdQDmI31przzmne1vOqqqLC~1xUumZVIvF~yOeJUGNjJ1Vx0J8i2BQIusn1pQJ6UCB~ZtZZLQtEb8EPVCfpeRi2ri1M5CyOuxN0V5ekmPHrYIBNevuTCRC26NP7ZS5VDgx1~NaC3A-CzJAE6f1QXi0wMI9aywNG5KGzOPifcsih8eyGyytvgLtrZtV7ykzYpPCS-rDfITncpn5hliPUAAAA.i2p/pub/bt/announce.php=http://de-ebook-archiv.i2p/pub/bt/"
 //       , "Gaytorrents", "http://uxPWHbK1OIj9HxquaXuhMiIvi21iK0~ZiG9d8G0840ZXIg0r6CbiV71xlsqmdnU6wm0T2LySriM0doW2gUigo-5BNkUquHwOjLROiETnB3ZR0Ml4IGa6QBPn1aAq2d9~g1r1nVjLE~pcFnXB~cNNS7kIhX1d6nLgYVZf0C2cZopEow2iWVUggGGnAA9mHjE86zLEnTvAyhbAMTqDQJhEuLa0ZYSORqzJDMkQt90MV4YMjX1ICY6RfUSFmxEqu0yWTrkHsTtRw48l~dz9wpIgc0a0T9C~eeWvmBFTqlJPtQZwntpNeH~jF7nlYzB58olgV2HHFYpVYD87DYNzTnmNWxCJ5AfDorm6AIUCV2qaE7tZtI1h6fbmGpGlPyW~Kw5GXrRfJwNvr6ajwAVi~bPVnrBwDZezHkfW4slOO8FACPR28EQvaTu9nwhAbqESxV2hCTq6vQSGjuxHeOuzBOEvRWkLKOHWTC09t2DbJ94FSqETmZopTB1ukEmaxRWbKSIaAAAA.i2p/announce.php=http://gaytorrents.i2p/"
 //       , "NickyB", "http://9On6d3cZ27JjwYCtyJJbowe054d5tFnfMjv4PHsYs-EQn4Y4mk2zRixatvuAyXz2MmRfXG-NAUfhKr0KCxRNZbvHmlckYfT-WBzwwpiMAl0wDFY~Pl8cqXuhfikSG5WrqdPfDNNIBuuznS0dqaczf~OyVaoEOpvuP3qV6wKqbSSLpjOwwAaQPHjlRtNIW8-EtUZp-I0LT45HSoowp~6b7zYmpIyoATvIP~sT0g0MTrczWhbVTUZnEkZeLhOR0Duw1-IRXI2KHPbA24wLO9LdpKKUXed05RTz0QklW5ROgR6TYv7aXFufX8kC0-DaKvQ5JKG~h8lcoHvm1RCzNqVE-2aiZnO2xH08H-iCWoLNJE-Td2kT-Tsc~3QdQcnEUcL5BF-VT~QYRld2--9r0gfGl-yDrJZrlrihHGr5J7ImahelNn9PpkVp6eIyABRmJHf2iicrk3CtjeG1j9OgTSwaNmEpUpn4aN7Kx0zNLdH7z6uTgCGD9Kmh1MFYrsoNlTp4AAAA.i2p/bittorrent/announce.php=http://nickyb.i2p/bittorrent/"
 //       , "Orion", "http://gKik1lMlRmuroXVGTZ~7v4Vez3L3ZSpddrGZBrxVriosCQf7iHu6CIk8t15BKsj~P0JJpxrofeuxtm7SCUAJEr0AIYSYw8XOmp35UfcRPQWyb1LsxUkMT4WqxAT3s1ClIICWlBu5An~q-Mm0VFlrYLIPBWlUFnfPR7jZ9uP5ZMSzTKSMYUWao3ejiykr~mtEmyls6g-ZbgKZawa9II4zjOy-hdxHgP-eXMDseFsrym4Gpxvy~3Fv9TuiSqhpgm~UeTo5YBfxn6~TahKtE~~sdCiSydqmKBhxAQ7uT9lda7xt96SS09OYMsIWxLeQUWhns-C~FjJPp1D~IuTrUpAFcVEGVL-BRMmdWbfOJEcWPZ~CBCQSO~VkuN1ebvIOr9JBerFMZSxZtFl8JwcrjCIBxeKPBmfh~xYh16BJm1BBBmN1fp2DKmZ2jBNkAmnUbjQOqWvUcehrykWk5lZbE7bjJMDFH48v3SXwRuDBiHZmSbsTY6zhGY~GkMQHNGxPMMSIAAAA.i2p/bt/announce.php=http://orion.i2p/bt/"
 //       , "anonymity", "http://8EoJZIKrWgGuDrxA3nRJs1jsPfiGwmFWL91hBrf0HA7oKhEvAna4Ocx47VLUR9retVEYBAyWFK-eZTPcvhnz9XffBEiJQQ~kFSCqb1fV6IfPiV3HySqi9U5Caf6~hC46fRd~vYnxmaBLICT3N160cxBETqH3v2rdxdJpvYt8q4nMk9LUeVXq7zqCTFLLG5ig1uKgNzBGe58iNcsvTEYlnbYcE930ABmrzj8G1qQSgSwJ6wx3tUQNl1z~4wSOUMan~raZQD60lRK70GISjoX0-D0Po9WmPveN3ES3g72TIET3zc3WPdK2~lgmKGIs8GgNLES1cXTolvbPhdZK1gxddRMbJl6Y6IPFyQ9o4-6Rt3Lp-RMRWZ2TG7j2OMcNSiOmATUhKEFBDfv-~SODDyopGBmfeLw16F4NnYednvn4qP10dyMHcUASU6Zag4mfc2-WivrOqeWhD16fVAh8MoDpIIT~0r9XmwdaVFyLcjbXObabJczxCAW3fodQUnvuSkwzAAAA.i2p/anonymityTracker/announce.php=http://anonymityweb.i2p/anonymityTracker/"
 //       , "The freak's tracker", "http://mHKva9x24E5Ygfey2llR1KyQHv5f8hhMpDMwJDg1U-hABpJ2NrQJd6azirdfaR0OKt4jDlmP2o4Qx0H598~AteyD~RJU~xcWYdcOE0dmJ2e9Y8-HY51ie0B1yD9FtIV72ZI-V3TzFDcs6nkdX9b81DwrAwwFzx0EfNvK1GLVWl59Ow85muoRTBA1q8SsZImxdyZ-TApTVlMYIQbdI4iQRwU9OmmtefrCe~ZOf4UBS9-KvNIqUL0XeBSqm0OU1jq-D10Ykg6KfqvuPnBYT1BYHFDQJXW5DdPKwcaQE4MtAdSGmj1epDoaEBUa9btQlFsM2l9Cyn1hzxqNWXELmx8dRlomQLlV4b586dRzW~fLlOPIGC13ntPXogvYvHVyEyptXkv890jC7DZNHyxZd5cyrKC36r9huKvhQAmNABT2Y~pOGwVrb~RpPwT0tBuPZ3lHYhBFYmD8y~AOhhNHKMLzea1rfwTvovBMByDdFps54gMN1mX4MbCGT4w70vIopS9yAAAA.i2p/bytemonsoon/announce.php"
-       , "welterde", "http://BGKmlDOoH3RzFbPRfRpZV2FjpVj8~3moFftw5-dZfDf2070TOe8Tf2~DAVeaM6ZRLdmFEt~9wyFL8YMLMoLoiwGEH6IGW6rc45tstN68KsBDWZqkTohV1q9XFgK9JnCwE~Oi89xLBHsLMTHOabowWM6dkC8nI6QqJC2JODqLPIRfOVrDdkjLwtCrsckzLybNdFmgfoqF05UITDyczPsFVaHtpF1sRggOVmdvCM66otyonlzNcJbn59PA-R808vUrCPMGU~O9Wys0i-NoqtIbtWfOKnjCRFMNw5ex4n9m5Sxm9e20UkpKG6qzEuvKZWi8vTLe1NW~CBrj~vG7I3Ok4wybUFflBFOaBabxYJLlx4xTE1zJIVxlsekmAjckB4v-cQwulFeikR4LxPQ6mCQknW2HZ4JQIq6hL9AMabxjOlYnzh7kjOfRGkck8YgeozcyTvcDUcUsOuSTk06L4kdrv8h2Cozjbloi5zl6KTbj5ZTciKCxi73Pn9grICn-HQqEAAAA.i2p/a=http://tracker.welterde.i2p/stats?mode=top5"
 //       , "mastertracker", "http://VzXD~stRKbL3MOmeTn1iaCQ0CFyTmuFHiKYyo0Rd~dFPZFCYH-22rT8JD7i-C2xzYFa4jT5U2aqHzHI-Jre4HL3Ri5hFtZrLk2ax3ji7Qfb6qPnuYkuiF2E2UDmKUOppI8d9Ye7tjdhQVCy0izn55tBaB-U7UWdcvSK2i85sauyw3G0Gfads1Rvy5-CAe2paqyYATcDmGjpUNLoxbfv9KH1KmwRTNH6k1v4PyWYYnhbT39WfKMbBjSxVQRdi19cyJrULSWhjxaQfJHeWx5Z8Ev4bSPByBeQBFl2~4vqy0S5RypINsRSa3MZdbiAAyn5tr5slWR6QdoqY3qBQgBJFZppy-3iWkFqqKgSxCPundF8gdDLC5ddizl~KYcYKl42y9SGFHIukH-TZs8~em0~iahzsqWVRks3zRG~tlBcX2U3M2~OJs~C33-NKhyfZT7-XFBREvb8Szmd~p66jDxrwOnKaku-G6DyoQipJqIz4VHmY9-y5T8RrUcJcM-5lVoMpAAAA.i2p/announce.php=http://tracker.mastertracker.i2p/"
 //       , "Galen", "http://5jpwQMI5FT303YwKa5Rd38PYSX04pbIKgTaKQsWbqoWjIfoancFdWCShXHLI5G5ofOb0Xu11vl2VEMyPsg1jUFYSVnu4-VfMe3y4TKTR6DTpetWrnmEK6m2UXh91J5DZJAKlgmO7UdsFlBkQfR2rY853-DfbJtQIFl91tbsmjcA5CGQi4VxMFyIkBzv-pCsuLQiZqOwWasTlnzey8GcDAPG1LDcvfflGV~6F5no9mnuisZPteZKlrv~~TDoXTj74QjByWc4EOYlwqK8sbU9aOvz~s31XzErbPTfwiawiaZ0RUI-IDrKgyvmj0neuFTWgjRGVTH8bz7cBZIc3viy6ioD-eMQOrXaQL0TCWZUelRwHRvgdPiQrxdYQs7ixkajeHzxi-Pq0EMm5Vbh3j3Q9kfUFW3JjFDA-MLB4g6XnjCbM5J1rC0oOBDCIEfhQkszru5cyLjHiZ5yeA0VThgu~c7xKHybv~OMXION7V8pBKOgET7ZgAkw1xgYe3Kkyq5syAAAA.i2p/tr/announce.php=http://galen.i2p/tr/"
-       , "crstrack", "http://b4G9sCdtfvccMAXh~SaZrPqVQNyGQbhbYMbw6supq2XGzbjU4NcOmjFI0vxQ8w1L05twmkOvg5QERcX6Mi8NQrWnR0stLExu2LucUXg1aYjnggxIR8TIOGygZVIMV3STKH4UQXD--wz0BUrqaLxPhrm2Eh9Hwc8TdB6Na4ShQUq5Xm8D4elzNUVdpM~RtChEyJWuQvoGAHY3ppX-EJJLkiSr1t77neS4Lc-KofMVmgI9a2tSSpNAagBiNI6Ak9L1T0F9uxeDfEG9bBSQPNMOSUbAoEcNxtt7xOW~cNOAyMyGydwPMnrQ5kIYPY8Pd3XudEko970vE0D6gO19yoBMJpKx6Dh50DGgybLQ9CpRaynh2zPULTHxm8rneOGRcQo8D3mE7FQ92m54~SvfjXjD2TwAVGI~ae~n9HDxt8uxOecAAvjjJ3TD4XM63Q9TmB38RmGNzNLDBQMEmJFpqQU8YeuhnS54IVdUoVQFqui5SfDeLXlSkh4vYoMU66pvBfWbAAAA.i2p/tracker/announce.php=http://crstrack.i2p/tracker/"
-       , "Postman2", "http://lnQ6yoBTxQuQU8EQ1FlF395ITIQF-HGJxUeFvzETLFnoczNjQvKDbtSB7aHhn853zjVXrJBgwlB9sO57KakBDaJ50lUZgVPhjlI19TgJ-CxyHhHSCeKx5JzURdEW-ucdONMynr-b2zwhsx8VQCJwCEkARvt21YkOyQDaB9IdV8aTAmP~PUJQxRwceaTMn96FcVenwdXqleE16fI8CVFOV18jbJKrhTOYpTtcZKV4l1wNYBDwKgwPx5c0kcrRzFyw5~bjuAKO~GJ5dR7BQsL7AwBoQUS4k1lwoYrG1kOIBeDD3XF8BWb6K3GOOoyjc1umYKpur3G~FxBuqtHAsDRICkEbKUqJ9mPYQlTSujhNxiRIW-oLwMtvayCFci99oX8MvazPS7~97x0Gsm-onEK1Td9nBdmq30OqDxpRtXBimbzkLbR1IKObbg9HvrKs3L-kSyGwTUmHG9rSQSoZEvFMA-S0EXO~o4g21q1oikmxPMhkeVwQ22VHB0-LZJfmLr4SAAAA.i2p/announce.php=http://tracker2.postman.i2p/"
+       "POSTMAN", "http://tracker2.postman.i2p/announce.php=http://tracker2.postman.i2p/"
+       ,"WELTERDE", "http://tracker.welterde.i2p/a=http://tracker.welterde.i2p/stats?mode=top5"
+//       , "CRSTRACK", "http://b4G9sCdtfvccMAXh~SaZrPqVQNyGQbhbYMbw6supq2XGzbjU4NcOmjFI0vxQ8w1L05twmkOvg5QERcX6Mi8NQrWnR0stLExu2LucUXg1aYjnggxIR8TIOGygZVIMV3STKH4UQXD--wz0BUrqaLxPhrm2Eh9Hwc8TdB6Na4ShQUq5Xm8D4elzNUVdpM~RtChEyJWuQvoGAHY3ppX-EJJLkiSr1t77neS4Lc-KofMVmgI9a2tSSpNAagBiNI6Ak9L1T0F9uxeDfEG9bBSQPNMOSUbAoEcNxtt7xOW~cNOAyMyGydwPMnrQ5kIYPY8Pd3XudEko970vE0D6gO19yoBMJpKx6Dh50DGgybLQ9CpRaynh2zPULTHxm8rneOGRcQo8D3mE7FQ92m54~SvfjXjD2TwAVGI~ae~n9HDxt8uxOecAAvjjJ3TD4XM63Q9TmB38RmGNzNLDBQMEmJFpqQU8YeuhnS54IVdUoVQFqui5SfDeLXlSkh4vYoMU66pvBfWbAAAA.i2p/tracker/announce.php=http://crstrack.i2p/tracker/"
     };
     
     /** comma delimited list of name=announceURL=baseURL for the trackers to be displayed */
@@ -739,6 +926,7 @@ public class SnarkManager implements Snark.CompleteListener {
     }
 
     public class SnarkManagerShutdown extends I2PAppThread {
+        @Override
         public void run() {
             Set names = listTorrentFiles();
             for (Iterator iter = names.iterator(); iter.hasNext(); ) {

apps/i2psnark/java/src/org/klomp/snark/SnarkShutdown.java

@@ -36,6 +36,7 @@ public class SnarkShutdown extends I2PAppThread
 
   private final ShutdownListener listener;
 
+  /* FIXME Exporting non-public type through public API FIXME */
   public SnarkShutdown(Storage storage,
                        PeerCoordinator coordinator,
                        ConnectionAcceptor acceptor,
@@ -49,6 +50,7 @@ public class SnarkShutdown extends I2PAppThread
     this.listener = listener;
   }
 
+    @Override
   public void run()
   {
     //Snark.debug("Shutting down...", Snark.NOTICE);

apps/i2psnark/java/src/org/klomp/snark/Storage.java

@@ -42,11 +42,13 @@ public class Storage
   private Object[] RAFlock;  // lock on RAF access
   private long[] RAFtime;    // when was RAF last accessed, or 0 if closed
   private File[] RAFfile;    // File to make it easier to reopen
+  /** priorities by file; default 0; may be null. @since 0.8.1 */
+  private int[] priorities;
 
   private final StorageListener listener;
   private I2PSnarkUtil _util;
 
-  private BitField bitfield; // BitField to represent the pieces
+  private /* FIXME final FIXME */ BitField bitfield; // BitField to represent the pieces
   private int needed; // Number of pieces needed
   private boolean _probablyComplete;  // use this to decide whether to open files RO
 
@@ -57,7 +59,8 @@ public class Storage
 
   /** The default piece size. */
   private static final int MIN_PIECE_SIZE = 256*1024;
-  public static final int MAX_PIECE_SIZE = 1024*1024;
+  /** note that we start reducing max number of peer connections above 1MB */
+  public static final int MAX_PIECE_SIZE = 2*1024*1024;
   /** The maximum number of pieces in a torrent. */
   public static final int MAX_PIECES = 10*1024;
   public static final long MAX_TOTAL_SIZE = MAX_PIECE_SIZE * (long) MAX_PIECES;
@@ -190,6 +193,9 @@ public class Storage
   }
 */
 
+  /** FIXME we can run out of fd's doing this,
+   *  maybe some sort of global close-RAF-right-away flag
+   *  would do the trick */
   private void fast_digestCreate() throws IOException {
     // Calculate piece_hashes
     SHA1 digest = new SHA1();
@@ -224,6 +230,8 @@ public class Storage
     RAFlock = new Object[size];
     RAFtime = new long[size];
     RAFfile = new File[size];
+    priorities = new int[size];
+
 
     int i = 0;
     Iterator it = files.iterator();
@@ -282,6 +290,146 @@ public class Storage
     return needed == 0;
   }
 
+  /**
+   *  @param file canonical path (non-directory)
+   *  @return number of bytes remaining; -1 if unknown file
+   *  @since 0.7.14
+   */
+  public long remaining(String file) {
+      long bytes = 0;
+      for (int i = 0; i < rafs.length; i++) {
+          File f = RAFfile[i];
+          // use canonical in case snark dir or sub dirs are symlinked
+          String canonical = null;
+          if (f != null) {
+              try {
+                  canonical = f.getCanonicalPath();
+              } catch (IOException ioe) {
+                  f = null;
+              }
+          }
+          if (f != null && canonical.equals(file)) {
+              if (complete())
+                  return 0;
+              int psz = metainfo.getPieceLength(0);
+              long start = bytes;
+              long end = start + lengths[i];
+              int pc = (int) (bytes / psz);
+              long rv = 0;
+              if (!bitfield.get(pc))
+                  rv = Math.min(psz - (start % psz), lengths[i]);
+              int pieces = metainfo.getPieces();
+              for (int j = pc + 1; (((long)j) * psz) < end && j < pieces; j++) {
+                  if (!bitfield.get(j)) {
+                      if (((long)(j+1))*psz < end)
+                          rv += psz;
+                      else
+                          rv += end - (((long)j) * psz);
+                  }
+              }
+              return rv;
+          }
+          bytes += lengths[i];
+      }
+      return -1;
+  }
+
+  /**
+   *  @param file canonical path (non-directory)
+   *  @since 0.8.1
+   */
+  public int getPriority(String file) {
+      if (complete() || metainfo.getFiles() == null || priorities == null)
+          return 0;
+      for (int i = 0; i < rafs.length; i++) {
+          File f = RAFfile[i];
+          // use canonical in case snark dir or sub dirs are symlinked
+          if (f != null) {
+              try {
+                  String canonical = f.getCanonicalPath();
+                  if (canonical.equals(file))
+                      return priorities[i];
+              } catch (IOException ioe) {}
+          }
+      }
+      return 0;
+  }
+
+  /**
+   *  Must call setPiecePriorities() after calling this
+   *  @param file canonical path (non-directory)
+   *  @param pri default 0; <0 to disable
+   *  @since 0.8.1
+   */
+  public void setPriority(String file, int pri) {
+      if (complete() || metainfo.getFiles() == null || priorities == null)
+          return;
+      for (int i = 0; i < rafs.length; i++) {
+          File f = RAFfile[i];
+          // use canonical in case snark dir or sub dirs are symlinked
+          if (f != null) {
+              try {
+                  String canonical = f.getCanonicalPath();
+                  if (canonical.equals(file)) {
+                      priorities[i] = pri;
+                      return;
+                  }
+              } catch (IOException ioe) {}
+          }
+      }
+  }
+
+  /**
+   *  Get the file priorities array.
+   *  @return null on error, if complete, or if only one file
+   *  @since 0.8.1
+   */
+  public int[] getFilePriorities() {
+      return priorities;
+  }
+
+  /**
+   *  Set the file priorities array.
+   *  Only call this when stopped, but after check()
+   *  @param p may be null
+   *  @since 0.8.1
+   */
+  void setFilePriorities(int[] p) {
+      priorities = p;
+  }
+
+  /**
+   *  Call setPriority() for all changed files first,
+   *  then call this.
+   *  Set the piece priority to the highest priority
+   *  of all files spanning the piece.
+   *  Caller must pass array to the PeerCoordinator.
+   *  @return null on error, if complete, or if only one file
+   *  @since 0.8.1
+   */
+  public int[] getPiecePriorities() {
+      if (complete() || metainfo.getFiles() == null || priorities == null)
+          return null;
+      int[] rv = new int[metainfo.getPieces()];
+      int file = 0;
+      long pcEnd = -1;
+      long fileEnd = lengths[0] - 1;
+      int psz = metainfo.getPieceLength(0);
+      for (int i = 0; i < rv.length; i++) {
+          pcEnd += psz;
+          int pri = priorities[file];
+          while (fileEnd <= pcEnd && file < lengths.length - 1) {
+              file++;
+              long oldFileEnd = fileEnd;
+              fileEnd += lengths[file];
+              if (priorities[file] > pri && oldFileEnd < pcEnd)
+                  pri = priorities[file];
+          }
+          rv[i] = pri;
+      }
+      return rv;
+  }
+
   /**
    * The BitField that tells which pieces this storage contains.
    * Do not change this since this is the current state of the storage.
@@ -291,6 +439,18 @@ public class Storage
     return bitfield;
   }
 
+  /**
+   *  The base file or directory name of the data,
+   *  as specified in the .torrent file, but filtered to remove
+   *  illegal characters. This is where the data actually is,
+   *  relative to the snark base dir.
+   *
+   *  @since 0.7.14
+   */
+  public String getBaseName() {
+      return filterName(metainfo.getName());
+  }
+
   /**
    * Creates (and/or checks) all files from the metainfo file list.
    */
@@ -376,10 +536,14 @@ public class Storage
       changed = true;
       checkCreateFiles();
     }
-    if (complete())
+    if (complete()) {
         _util.debug("Torrent is complete", Snark.NOTICE);
-    else
+    } else {
+        // fixme saved priorities
+        if (files != null)
+            priorities = new int[files.size()];
         _util.debug("Still need " + needed + " out of " + metainfo.getPieces() + " pieces", Snark.NOTICE);
+    }
   }
 
   /**
@@ -416,13 +580,29 @@ public class Storage
       }
   }
 
+  private static final char[] ILLEGAL = new char[] {
+        '<', '>', ':', '"', '/', '\\', '|', '?', '*',
+        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+        16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31 };
+
   /**
-   * Removes 'suspicious' characters from the give file name.
+   * Removes 'suspicious' characters from the given file name.
+   * http://msdn.microsoft.com/en-us/library/aa365247%28VS.85%29.aspx
    */
   private static String filterName(String name)
   {
-    // XXX - Is this enough?
-    return name.replace(File.separatorChar, '_');
+    if (name.equals(".") || name.equals(" "))
+        return "_";
+    String rv = name;
+    if (rv.startsWith("."))
+        rv = '_' + rv.substring(1);
+    if (rv.endsWith(".") || rv.endsWith(" "))
+        rv = rv.substring(0, rv.length() - 1) + '_';
+    for (int i = 0; i < ILLEGAL.length; i++) {
+        if (rv.indexOf(ILLEGAL[i]) >= 0)
+            rv = rv.replace(ILLEGAL[i], '_');
+    }
+    return rv;
   }
 
   private File createFileFromNames(File base, List names) throws IOException
@@ -489,6 +669,10 @@ public class Storage
           changed = true;
           synchronized(RAFlock[i]) {
               allocateFile(i);
+              // close as we go so we don't run out of file descriptors
+              try {
+                  closeRAF(i);
+              } catch (IOException ioe) {}
           }
         } else {
           _util.debug("File '" + names[i] + "' exists, but has wrong length - repairing corruption", Snark.ERROR);
@@ -497,8 +681,10 @@ public class Storage
           synchronized(RAFlock[i]) {
               checkRAF(i);
               rafs[i].setLength(lengths[i]);
+              try {
+                  closeRAF(i);
+              } catch (IOException ioe) {}
           }
-          // will be closed below
         }
       }
 
@@ -507,10 +693,25 @@ public class Storage
       {
         pieces = metainfo.getPieces();
         byte[] piece = new byte[metainfo.getPieceLength(0)];
+        int file = 0;
+        long fileEnd = lengths[0];
+        long pieceEnd = 0;
         for (int i = 0; i < pieces; i++)
           {
             int length = getUncheckedPiece(i, piece);
             boolean correctHash = metainfo.checkPiece(i, piece, 0, length);
+            // close as we go so we don't run out of file descriptors
+            pieceEnd += length;
+            while (fileEnd <= pieceEnd) {
+                synchronized(RAFlock[file]) {
+                    try {
+                        closeRAF(file);
+                    } catch (IOException ioe) {}
+                }
+                if (++file >= rafs.length)
+                    break;
+                fileEnd += lengths[file];
+            }
             if (correctHash)
               {
                 bitfield.set(i);
@@ -525,13 +726,14 @@ public class Storage
     _probablyComplete = complete();
     // close all the files so we don't end up with a zillion open ones;
     // we will reopen as needed
-    for (int i = 0; i < rafs.length; i++) {
-      synchronized(RAFlock[i]) {
-        try {
-          closeRAF(i);
-        } catch (IOException ioe) {}
-      }
-    }
+    // Now closed above to avoid running out of file descriptors
+    //for (int i = 0; i < rafs.length; i++) {
+    //  synchronized(RAFlock[i]) {
+    //    try {
+    //      closeRAF(i);
+    //    } catch (IOException ioe) {}
+    //  }
+    //}
 
     if (listener != null) {
       listener.storageAllChecked(this);
@@ -540,6 +742,7 @@ public class Storage
     }
   }
 
+  /** this calls openRAF(); caller must synnchronize and call closeRAF() */
   private void allocateFile(int nr) throws IOException
   {
     // caller synchronized
@@ -548,7 +751,12 @@ public class Storage
     // the whole file?
     listener.storageCreateFile(this, names[nr], lengths[nr]);
     final int ZEROBLOCKSIZE = metainfo.getPieceLength(0);
-    byte[] zeros = new byte[ZEROBLOCKSIZE];
+    byte[] zeros;
+    try {
+        zeros = new byte[ZEROBLOCKSIZE];
+    } catch (OutOfMemoryError oom) {
+        throw new IOException(oom.toString());
+    }
     int i;
     for (i = 0; i < lengths[nr]/ZEROBLOCKSIZE; i++)
       {
@@ -573,6 +781,9 @@ public class Storage
     if (rafs == null) return;
     for (int i = 0; i < rafs.length; i++)
       {
+        // if we had an IOE in check(), the RAFlock may be null
+        if (RAFlock[i] == null)
+            continue;
         try {
           synchronized(RAFlock[i]) {
             closeRAF(i);

apps/i2psnark/java/src/org/klomp/snark/TrackerClient.java

@@ -24,6 +24,8 @@ import java.io.File;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;
+import java.net.MalformedURLException;
+import java.net.URL;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Iterator;
@@ -31,6 +33,7 @@ import java.util.List;
 import java.util.Random;
 import java.util.Set;
 
+import net.i2p.I2PAppContext;
 import net.i2p.util.I2PAppThread;
 import net.i2p.util.Log;
 
@@ -42,7 +45,7 @@ import net.i2p.util.Log;
  */
 public class TrackerClient extends I2PAppThread
 {
-  private static final Log _log = new Log(TrackerClient.class);
+  private final Log _log = I2PAppContext.getGlobalContext().logManager().getLog(TrackerClient.class);
   private static final String NO_EVENT = "";
   private static final String STARTED_EVENT = "started";
   private static final String COMPLETED_EVENT = "completed";
@@ -81,6 +84,7 @@ public class TrackerClient extends I2PAppThread
     started = false;
   }
 
+    @Override
   public void start() {
       if (stop) throw new RuntimeException("Dont rerun me, create a copy");
       super.start();
@@ -109,6 +113,7 @@ public class TrackerClient extends I2PAppThread
     return !stop && _util.connected();
   }
   
+    @Override
   public void run()
   {
     String infoHash = urlencode(meta.getInfoHash());
@@ -121,13 +126,19 @@ public class TrackerClient extends I2PAppThread
     // followed by the secondary open trackers
     // It's painful, but try to make sure if an open tracker is also
     // the primary tracker, that we don't add it twice.
+    // todo: check for b32 matches as well
     trackers = new ArrayList(2);
-    trackers.add(new Tracker(meta.getAnnounce(), true));
+    String primary = meta.getAnnounce();
+    if (isValidAnnounce(primary)) {
+        trackers.add(new Tracker(meta.getAnnounce(), true));
+    } else {
+        _log.warn("Skipping invalid or non-i2p announce: " + primary);
+    }
     List tlist = _util.getOpenTrackers();
     if (tlist != null) {
         for (int i = 0; i < tlist.size(); i++) {
              String url = (String)tlist.get(i);
-             if (!url.startsWith("http://")) {
+             if (!isValidAnnounce(url)) {
                 _log.error("Bad announce URL: [" + url + "]");
                 continue;
              }
@@ -136,22 +147,29 @@ public class TrackerClient extends I2PAppThread
                 _log.error("Bad announce URL: [" + url + "]");
                 continue;
              }
-             if (meta.getAnnounce().startsWith(url.substring(0, slash)))
+             if (primary.startsWith(url.substring(0, slash)))
                 continue;
              String dest = _util.lookup(url.substring(7, slash));
              if (dest == null) {
-                _log.error("Announce host unknown: [" + url + "]");
+                _log.error("Announce host unknown: [" + url.substring(7, slash) + "]");
                 continue;
              }
-             if (meta.getAnnounce().startsWith("http://" + dest))
+             if (primary.startsWith("http://" + dest))
                 continue;
-             if (meta.getAnnounce().startsWith("http://i2p/" + dest))
+             if (primary.startsWith("http://i2p/" + dest))
                 continue;
              trackers.add(new Tracker(url, false));
              _log.debug("Additional announce: [" + url + "] for infoHash: " + infoHash);
         }
     }
 
+    if (tlist.isEmpty()) {
+        // FIXME really need to get this message to the gui
+        stop = true;
+        _log.error("No valid trackers for infoHash: " + infoHash);
+        return;
+    }
+
     long uploaded = coordinator.getUploaded();
     long downloaded = coordinator.getDownloaded();
     long left = coordinator.getLeft();
@@ -162,10 +180,10 @@ public class TrackerClient extends I2PAppThread
     try
       {
         if (!verifyConnected()) return;
-        boolean started = false;
+        boolean runStarted = false;
         boolean firstTime = true;
         int consecutiveFails = 0;
-        Random r = new Random();
+        Random r = I2PAppContext.getGlobalContext().random();
         while(!stop)
           {
             try
@@ -178,7 +196,7 @@ public class TrackerClient extends I2PAppThread
                 if (firstTime) {
                   delay = r.nextInt(30*1000);
                   firstTime = false;
-                } else if (completed && started)
+                } else if (completed && runStarted)
                   delay = 3*SLEEP*60*1000 + random;
                 else if (coordinator.trackerProblems != null && ++consecutiveFails < MAX_CONSEC_FAILS)
                   delay = INITIAL_SLEEP;
@@ -221,7 +239,7 @@ public class TrackerClient extends I2PAppThread
               Tracker tr = (Tracker)iter.next();
               if ((!stop) && (!tr.stop) &&
                   (completed || coordinator.needPeers()) &&
-                  (event == COMPLETED_EVENT || System.currentTimeMillis() > tr.lastRequestTime + tr.interval))
+                  (event.equals(COMPLETED_EVENT) || System.currentTimeMillis() > tr.lastRequestTime + tr.interval))
               {
                 try
                   {
@@ -237,21 +255,22 @@ public class TrackerClient extends I2PAppThread
                     tr.consecutiveFails = 0;
                     if (tr.isPrimary)
                         consecutiveFails = 0;
-                    started = true;
+                    runStarted = true;
                     tr.started = true;
 
                     Set peers = info.getPeers();
-                    tr.seenPeers = peers.size();
+                    tr.seenPeers = info.getPeerCount();
                     if (coordinator.trackerSeenPeers < tr.seenPeers) // update rising number quickly
                         coordinator.trackerSeenPeers = tr.seenPeers;
                     if ( (left > 0) && (!completed) ) {
                         // we only want to talk to new people if we need things
                         // from them (duh)
                         List ordered = new ArrayList(peers);
-                        Collections.shuffle(ordered);
+                        Collections.shuffle(ordered, r);
                         Iterator it = ordered.iterator();
-                        while (it.hasNext()) {
+                        while ((!stop) && it.hasNext()) {
                           Peer cur = (Peer)it.next();
+                          // FIXME if id == us || dest == us continue;
                           // only delay if we actually make an attempt to add peer
                           if(coordinator.addPeer(cur)) {
                             int delay = DELAY_MUL;
@@ -296,7 +315,7 @@ public class TrackerClient extends I2PAppThread
 
             // we could try and total the unique peers but that's too hard for now
             coordinator.trackerSeenPeers = maxSeenPeers;
-            if (!started)
+            if (!runStarted)
                 _util.debug("         Retrying in one minute...", Snark.DEBUG);
           } // *** end of while loop
       } // try
@@ -311,9 +330,9 @@ public class TrackerClient extends I2PAppThread
         try
           {
             // try to contact everybody we can
-            // We don't need I2CP connection for eepget
-            // if (!verifyConnected()) return;
+            // Don't try to restart I2CP connection just to say goodbye
             for (Iterator iter = trackers.iterator(); iter.hasNext(); ) {
+              if (!_util.connected()) return;
               Tracker tr = (Tracker)iter.next();
               if (tr.started && (!tr.stop) && tr.trackerProblems == null)
                   doRequest(tr, infoHash, peerID, uploaded,
@@ -338,7 +357,12 @@ public class TrackerClient extends I2PAppThread
       + "&uploaded=" + uploaded
       + "&downloaded=" + downloaded
       + "&left=" + left
-      + ((event != NO_EVENT) ? ("&event=" + event) : "");
+      + "&compact=1"   // NOTE: opentracker will return 400 for &compact alone
+      + ((! event.equals(NO_EVENT)) ? ("&event=" + event) : "");
+    if (left <= 0 || event.equals(STOPPED_EVENT) || !coordinator.needPeers())
+        s += "&numwant=0";
+    else
+        s += "&numwant=" + _util.getMaxConnections();
     _util.debug("Sending TrackerClient request: " + s, Snark.INFO);
       
     tr.lastRequestTime = System.currentTimeMillis();
@@ -368,25 +392,52 @@ public class TrackerClient extends I2PAppThread
   }
 
   /**
-   * Very lazy byte[] to URL encoder.  Just encodes everything, even
-   * "normal" chars.
+   * Very lazy byte[] to URL encoder.  Just encodes almost everything, even
+   * some "normal" chars.
+   * By not encoding about 1/4 of the chars, we make random data like hashes about 16% smaller.
+   *
+   * RFC1738: 0-9a-zA-Z$-_.+!*'(),
+   * Us:      0-9a-zA-Z
+   *
    */
   public static String urlencode(byte[] bs)
   {
-    StringBuffer sb = new StringBuffer(bs.length*3);
+    StringBuilder sb = new StringBuilder(bs.length*3);
     for (int i = 0; i < bs.length; i++)
       {
         int c = bs[i] & 0xFF;
-        sb.append('%');
-        if (c < 16)
-          sb.append('0');
-        sb.append(Integer.toHexString(c));
+        if ((c >= '0' && c <= '9') ||
+            (c >= 'A' && c <= 'Z') ||
+            (c >= 'a' && c <= 'z')) {
+            sb.append((char)c);
+        } else {
+            sb.append('%');
+            if (c < 16)
+              sb.append('0');
+            sb.append(Integer.toHexString(c));
+        }
       }
          
     return sb.toString();
   }
 
-  private class Tracker
+  /**
+   *  @return true for i2p hosts only
+   *  @since 0.7.12
+   */
+  static boolean isValidAnnounce(String ann) {
+    URL url;
+    try {
+       url = new URL(ann);
+    } catch (MalformedURLException mue) {
+       return false;
+    }
+    return url.getProtocol().equals("http") &&
+           (url.getHost().endsWith(".i2p") || url.getHost().equals("i2p")) &&
+           url.getPort() < 0;
+  }
+
+  private static class Tracker
   {
       String announce;
       boolean isPrimary;

apps/i2psnark/java/src/org/klomp/snark/TrackerInfo.java

@@ -23,7 +23,7 @@ package org.klomp.snark;
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.HashSet;
-import java.util.Iterator;
+import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -32,11 +32,19 @@ import org.klomp.snark.bencode.BDecoder;
 import org.klomp.snark.bencode.BEValue;
 import org.klomp.snark.bencode.InvalidBEncodingException;
 
+/**
+ *  The data structure for the tracker response.
+ *  Handles both traditional and compact formats.
+ *  Compact format 1 - a list of hashes - early format for testing
+ *  Compact format 2 - One big string of concatenated hashes - official format
+ */
 public class TrackerInfo
 {
   private final String failure_reason;
   private final int interval;
-  private final Set peers;
+  private final Set<Peer> peers;
+  private int complete;
+  private int incomplete;
 
   public TrackerInfo(InputStream in, byte[] my_id, MetaInfo metainfo)
     throws IOException
@@ -68,40 +76,100 @@ public class TrackerInfo
           throw new InvalidBEncodingException("No interval given");
         else
           interval = beInterval.getInt();
+
         BEValue bePeers = (BEValue)m.get("peers");
-        if (bePeers == null)
-          throw new InvalidBEncodingException("No peer list");
-        else
-          peers = getPeers(bePeers.getList(), my_id, metainfo);
+        if (bePeers == null) {
+          peers = Collections.EMPTY_SET;
+        } else {
+            Set<Peer> p;
+            try {
+              // One big string (the official compact format)
+              p = getPeers(bePeers.getBytes(), my_id, metainfo);
+            } catch (InvalidBEncodingException ibe) {
+              // List of Dictionaries or List of Strings
+              p = getPeers(bePeers.getList(), my_id, metainfo);
+            }
+            peers = p;
+        }
+
+        BEValue bev = (BEValue)m.get("complete");
+        if (bev != null) try {
+          complete = bev.getInt();
+          if (complete < 0)
+              complete = 0;
+        } catch (InvalidBEncodingException ibe) {}
+
+        bev = (BEValue)m.get("incomplete");
+        if (bev != null) try {
+          incomplete = bev.getInt();
+          if (incomplete < 0)
+              incomplete = 0;
+        } catch (InvalidBEncodingException ibe) {}
       }
   }
 
-  public static Set getPeers(InputStream in, byte[] my_id, MetaInfo metainfo)
+/******
+  public static Set<Peer> getPeers(InputStream in, byte[] my_id, MetaInfo metainfo)
     throws IOException
   {
     return getPeers(new BDecoder(in), my_id, metainfo);
   }
 
-  public static Set getPeers(BDecoder be, byte[] my_id, MetaInfo metainfo)
+  public static Set<Peer> getPeers(BDecoder be, byte[] my_id, MetaInfo metainfo)
     throws IOException
   {
     return getPeers(be.bdecodeList().getList(), my_id, metainfo);
   }
+******/
 
-  public static Set getPeers(List l, byte[] my_id, MetaInfo metainfo)
+  /** List of Dictionaries or List of Strings */
+  private static Set<Peer> getPeers(List<BEValue> l, byte[] my_id, MetaInfo metainfo)
     throws IOException
   {
-    Set peers = new HashSet(l.size());
+    Set<Peer> peers = new HashSet(l.size());
 
-    Iterator it = l.iterator();
-    while (it.hasNext())
-      {
+    for (BEValue bev : l) {
         PeerID peerID;
         try {
-            peerID = new PeerID(((BEValue)it.next()).getMap());
+            // Case 1 - non-compact - A list of dictionaries (maps)
+            peerID = new PeerID(bev.getMap());
         } catch (InvalidBEncodingException ibe) {
-            // don't let one bad entry spoil the whole list
-            //Snark.debug("Discarding peer from list: " + ibe, Snark.ERROR);
+            try {
+                // Case 2 - compact - A list of 32-byte binary strings (hashes)
+                // This was just for testing and is not the official format
+                peerID = new PeerID(bev.getBytes());
+            } catch (InvalidBEncodingException ibe2) {
+                // don't let one bad entry spoil the whole list
+                //Snark.debug("Discarding peer from list: " + ibe, Snark.ERROR);
+                continue;
+            }
+        }
+        peers.add(new Peer(peerID, my_id, metainfo));
+      }
+
+    return peers;
+  }
+
+  private static final int HASH_LENGTH = 32;
+
+  /**
+   *  One big string of concatenated 32-byte hashes
+   *  @since 0.8.1
+   */
+  private static Set<Peer> getPeers(byte[] l, byte[] my_id, MetaInfo metainfo)
+    throws IOException
+  {
+    int count = l.length / HASH_LENGTH;
+    Set<Peer> peers = new HashSet(count);
+
+    for (int i = 0; i < count; i++) {
+        PeerID peerID;
+        byte[] hash = new byte[HASH_LENGTH];
+        System.arraycopy(l, i * HASH_LENGTH, hash, 0, HASH_LENGTH);
+        try {
+            peerID = new PeerID(hash);
+        } catch (InvalidBEncodingException ibe) {
+            // won't happen
             continue;
         }
         peers.add(new Peer(peerID, my_id, metainfo));
@@ -110,11 +178,17 @@ public class TrackerInfo
     return peers;
   }
 
-  public Set getPeers()
+  public Set<Peer> getPeers()
   {
     return peers;
   }
 
+  public int getPeerCount()
+  {
+    int pc = peers == null ? 0 : peers.size();
+    return Math.max(pc, complete + incomplete - 1);
+  }
+
   public String getFailureReason()
   {
     return failure_reason;
@@ -125,12 +199,15 @@ public class TrackerInfo
     return interval;
   }
 
+    @Override
   public String toString()
   {
     if (failure_reason != null)
       return "TrackerInfo[FAILED: " + failure_reason + "]";
     else
       return "TrackerInfo[interval=" + interval
+        + (complete > 0 ? (", complete=" + complete) : "" )
+        + (incomplete > 0 ? (", incomplete=" + incomplete) : "" )
         + ", peers=" + peers + "]";
   }
 }

apps/i2psnark/java/src/org/klomp/snark/bencode/BDecoder.java

@@ -279,7 +279,9 @@ public class BDecoder
   public BEValue bdecodeMap() throws IOException
   {
     int c = getNextIndicator();
-    if (c != 'd')
+    if (c == '<')
+      throw new InvalidBEncodingException("Expected a .torrent metainfo file but found HTML? Check URL or file!");
+    else if (c != 'd')
       throw new InvalidBEncodingException("Expected 'd', not '"
                                           + (char)c + "'");
     indicator = 0;

apps/i2psnark/java/src/org/klomp/snark/bencode/BEValue.java

@@ -140,7 +140,7 @@ public class BEValue
    * succeeds when the BEValue is actually a List, otherwise it will
    * throw a InvalidBEncodingException.
    */
-  public List getList() throws InvalidBEncodingException
+  public List<BEValue> getList() throws InvalidBEncodingException
   {
     try
       {
@@ -157,7 +157,7 @@ public class BEValue
    * values. This operation only succeeds when the BEValue is actually
    * a Map, otherwise it will throw a InvalidBEncodingException.
    */
-  public Map getMap() throws InvalidBEncodingException
+  public Map<BEValue, BEValue> getMap() throws InvalidBEncodingException
   {
     try
       {
@@ -172,13 +172,14 @@ public class BEValue
   /** return the untyped value */
   public Object getValue() { return value; }
   
+    @Override
   public String toString()
   {
     String valueString;
     if (value instanceof byte[])
       {
         byte[] bs = (byte[])value;
-        // XXX - Stupid heuristic...
+        // XXX - Stupid heuristic... and not UTF-8
         if (bs.length <= 12)
           valueString = new String(bs);
         else