- adapted source tree structure to gradle/maven conventions

- added gradle wrapper
- fixes to adapt to GNUnet changes (new time unit, ...)
- helper process in util
- started implementing testbed
- skeleton for voting tools
- use new mq api
- implemented some more transport api
- mesh

257 files changed, 4545 insertions, 1437 deletions

diff --git a/src/org/gnunet/consensus/ConcludeCallback.java b/src/main/java/org/gnunet/consensus/ConcludeCallback.java
index 7660c49..7660c49 100644
--- a/src/org/gnunet/consensus/ConcludeCallback.java
+++ b/src/main/java/org/gnunet/consensus/ConcludeCallback.java
diff --git a/src/org/gnunet/consensus/ConcludeDoneMessage.java b/src/main/java/org/gnunet/consensus/ConcludeDoneMessage.java
index 51757aa..51757aa 100644
--- a/src/org/gnunet/consensus/ConcludeDoneMessage.java
+++ b/src/main/java/org/gnunet/consensus/ConcludeDoneMessage.java
diff --git a/src/org/gnunet/consensus/ConcludeMessage.java b/src/main/java/org/gnunet/consensus/ConcludeMessage.java
index 7b43928..7b43928 100644
--- a/src/org/gnunet/consensus/ConcludeMessage.java
+++ b/src/main/java/org/gnunet/consensus/ConcludeMessage.java
diff --git a/src/org/gnunet/consensus/Consensus.java b/src/main/java/org/gnunet/consensus/Consensus.java
index 2047454..322599c 100644
--- a/src/org/gnunet/consensus/Consensus.java
+++ b/src/main/java/org/gnunet/consensus/Consensus.java
@@ -1,6 +1,5 @@
 package org.gnunet.consensus;
 
-import org.gnunet.mq.ClientMessageQueue;
 import org.gnunet.mq.Envelope;
 import org.gnunet.mq.MessageQueue;
 import org.gnunet.mq.NotifySentHandler;
@@ -30,11 +29,6 @@ public class Consensus {
     private Client client;
 
     /**
-     * Message queue for 'client'.
-     */
-    private MessageQueue client_mq;
-
-    /**
      * Called when conclude has finished.
      */
     private ConcludeCallback concludeCallback;
@@ -81,7 +75,7 @@ public class Consensus {
     public Consensus(Configuration cfg, int num_peers, PeerIdentity[] peers, HashCode sessionId,
                      NewElementCallback newElementCallback) {
         client = new Client("consensus", cfg);
-        client_mq = new ClientMessageQueue(client, new ConsensusMessageReceiver());
+        client.installReceiver(new ConsensusMessageReceiver());
         this.newElementCallback = newElementCallback;
     }
 
@@ -102,7 +96,7 @@ public class Consensus {
                 idc.onInsertDone();
             }
         });
-        client_mq.send(ev);
+        client.send(ev);
     }
 
     /**
@@ -119,7 +113,7 @@ public class Consensus {
             throw new AssertionError("called conclude twice");
         this.concludeCallback = concludeCallback;
         ConcludeMessage m = new ConcludeMessage();
-        client_mq.send(m);
+        client.send(m);
     }
 
     /**
@@ -128,8 +122,6 @@ public class Consensus {
      * it, no longer call any of the callbacks.
      */
     public void destroy() {
-        client_mq.destroy();
-        client_mq = null;
         client.disconnect();
         client = null;
     }
diff --git a/src/org/gnunet/consensus/ConsensusElement.java b/src/main/java/org/gnunet/consensus/ConsensusElement.java
index 846e72a..846e72a 100644
--- a/src/org/gnunet/consensus/ConsensusElement.java
+++ b/src/main/java/org/gnunet/consensus/ConsensusElement.java
diff --git a/src/org/gnunet/consensus/InsertDoneCallback.java b/src/main/java/org/gnunet/consensus/InsertDoneCallback.java
index f0e86ca..f0e86ca 100644
--- a/src/org/gnunet/consensus/InsertDoneCallback.java
+++ b/src/main/java/org/gnunet/consensus/InsertDoneCallback.java
diff --git a/src/org/gnunet/consensus/InsertElementMessage.java b/src/main/java/org/gnunet/consensus/InsertElementMessage.java
index fd0ff67..fd0ff67 100644
--- a/src/org/gnunet/consensus/InsertElementMessage.java
+++ b/src/main/java/org/gnunet/consensus/InsertElementMessage.java
diff --git a/src/org/gnunet/consensus/NewElementCallback.java b/src/main/java/org/gnunet/consensus/NewElementCallback.java
index 4b07a71..4b07a71 100644
--- a/src/org/gnunet/consensus/NewElementCallback.java
+++ b/src/main/java/org/gnunet/consensus/NewElementCallback.java
diff --git a/src/org/gnunet/consensus/NewElementMessage.java b/src/main/java/org/gnunet/consensus/NewElementMessage.java
index deb3634..deb3634 100644
--- a/src/org/gnunet/consensus/NewElementMessage.java
+++ b/src/main/java/org/gnunet/consensus/NewElementMessage.java
diff --git a/src/org/gnunet/construct/Construct.java b/src/main/java/org/gnunet/construct/Construct.java
index a74a5c2..a74a5c2 100644
--- a/src/org/gnunet/construct/Construct.java
+++ b/src/main/java/org/gnunet/construct/Construct.java
diff --git a/src/org/gnunet/construct/DoubleValue.java b/src/main/java/org/gnunet/construct/DoubleValue.java
index 0856fe8..0856fe8 100644
--- a/src/org/gnunet/construct/DoubleValue.java
+++ b/src/main/java/org/gnunet/construct/DoubleValue.java
diff --git a/src/org/gnunet/construct/FillWith.java b/src/main/java/org/gnunet/construct/FillWith.java
index f95aa3d..f95aa3d 100644
--- a/src/org/gnunet/construct/FillWith.java
+++ b/src/main/java/org/gnunet/construct/FillWith.java
diff --git a/src/org/gnunet/construct/FixedSizeArray.java b/src/main/java/org/gnunet/construct/FixedSizeArray.java
index 699ae68..699ae68 100644
--- a/src/org/gnunet/construct/FixedSizeArray.java
+++ b/src/main/java/org/gnunet/construct/FixedSizeArray.java
diff --git a/src/org/gnunet/construct/FixedSizeIntegerArray.java b/src/main/java/org/gnunet/construct/FixedSizeIntegerArray.java
index b2418b8..b2418b8 100644
--- a/src/org/gnunet/construct/FixedSizeIntegerArray.java
+++ b/src/main/java/org/gnunet/construct/FixedSizeIntegerArray.java
diff --git a/src/org/gnunet/construct/FrameSize.java b/src/main/java/org/gnunet/construct/FrameSize.java
index 0533d0b..0533d0b 100644
--- a/src/org/gnunet/construct/FrameSize.java
+++ b/src/main/java/org/gnunet/construct/FrameSize.java
diff --git a/src/org/gnunet/construct/Int16.java b/src/main/java/org/gnunet/construct/Int16.java
index 677324b..677324b 100644
--- a/src/org/gnunet/construct/Int16.java
+++ b/src/main/java/org/gnunet/construct/Int16.java
diff --git a/src/org/gnunet/construct/Int32.java b/src/main/java/org/gnunet/construct/Int32.java
index da993ca..da993ca 100644
--- a/src/org/gnunet/construct/Int32.java
+++ b/src/main/java/org/gnunet/construct/Int32.java
diff --git a/src/org/gnunet/construct/Int64.java b/src/main/java/org/gnunet/construct/Int64.java
index be5d940..be5d940 100644
--- a/src/org/gnunet/construct/Int64.java
+++ b/src/main/java/org/gnunet/construct/Int64.java
diff --git a/src/org/gnunet/construct/Int8.java b/src/main/java/org/gnunet/construct/Int8.java
index a0aaa14..a0aaa14 100644
--- a/src/org/gnunet/construct/Int8.java
+++ b/src/main/java/org/gnunet/construct/Int8.java
diff --git a/src/org/gnunet/construct/IntegerFill.java b/src/main/java/org/gnunet/construct/IntegerFill.java
index 4564c83..4564c83 100644
--- a/src/org/gnunet/construct/IntegerFill.java
+++ b/src/main/java/org/gnunet/construct/IntegerFill.java
diff --git a/src/org/gnunet/construct/Message.java b/src/main/java/org/gnunet/construct/Message.java
index d0068b5..d0068b5 100644
--- a/src/org/gnunet/construct/Message.java
+++ b/src/main/java/org/gnunet/construct/Message.java
diff --git a/src/org/gnunet/construct/MessageIdAnnotationProcessor.java b/src/main/java/org/gnunet/construct/MessageIdAnnotationProcessor.java
index 8a17ba9..ab80be3 100644
--- a/src/org/gnunet/construct/MessageIdAnnotationProcessor.java
+++ b/src/main/java/org/gnunet/construct/MessageIdAnnotationProcessor.java
@@ -47,8 +47,6 @@ import java.util.*;
 @SupportedAnnotationTypes("org.gnunet.construct.UnionCase")
 @SupportedSourceVersion(SourceVersion.RELEASE_6)
 public class MessageIdAnnotationProcessor extends AbstractProcessor {
-    // a mapping from (union, id) to member
-    //private final Map<String, Map<Integer, String>> unionmap = new HashMap<String, Map<Integer, String>>(100);
     private final Table<String, Integer, String> idToMember = HashBasedTable.create();
 
     @Override
diff --git a/src/org/gnunet/construct/MessageLoader.java b/src/main/java/org/gnunet/construct/MessageLoader.java
index 71e2719..71e2719 100644
--- a/src/org/gnunet/construct/MessageLoader.java
+++ b/src/main/java/org/gnunet/construct/MessageLoader.java
diff --git a/src/org/gnunet/construct/MessageUnion.java b/src/main/java/org/gnunet/construct/MessageUnion.java
index 0481df2..0481df2 100644
--- a/src/org/gnunet/construct/MessageUnion.java
+++ b/src/main/java/org/gnunet/construct/MessageUnion.java
diff --git a/src/org/gnunet/construct/MsgMap.txt b/src/main/java/org/gnunet/construct/MsgMap.txt
index 7f3d2f4..30a4656 100644
--- a/src/org/gnunet/construct/MsgMap.txt
+++ b/src/main/java/org/gnunet/construct/MsgMap.txt
@@ -43,4 +43,4 @@ org.gnunet.util.GnunetMessage$Body|521=org.gnunet.consensus.InsertElementMessage
 org.gnunet.util.GnunetMessage$Body|523=org.gnunet.consensus.NewElementMessage
 org.gnunet.util.GnunetMessage$Body|360=org.gnunet.transport.StartMessage
 org.gnunet.construct.MessageUnion|525=org.gnunet.consensus.ConcludeDoneMessage
-# generated 2013/08/13 20:15:12
+# generated 2013/08/22 21:14:59
diff --git a/src/org/gnunet/construct/NestedMessage.java b/src/main/java/org/gnunet/construct/NestedMessage.java
index fe65323..fe65323 100644
--- a/src/org/gnunet/construct/NestedMessage.java
+++ b/src/main/java/org/gnunet/construct/NestedMessage.java
diff --git a/src/org/gnunet/construct/ProtocolViolationException.java b/src/main/java/org/gnunet/construct/ProtocolViolationException.java
index 9de46d4..9de46d4 100644
--- a/src/org/gnunet/construct/ProtocolViolationException.java
+++ b/src/main/java/org/gnunet/construct/ProtocolViolationException.java
diff --git a/src/org/gnunet/construct/ReflectUtil.java b/src/main/java/org/gnunet/construct/ReflectUtil.java
index 1115641..1115641 100644
--- a/src/org/gnunet/construct/ReflectUtil.java
+++ b/src/main/java/org/gnunet/construct/ReflectUtil.java
diff --git a/src/org/gnunet/construct/UInt16.java b/src/main/java/org/gnunet/construct/UInt16.java
index 18c24b2..18c24b2 100644
--- a/src/org/gnunet/construct/UInt16.java
+++ b/src/main/java/org/gnunet/construct/UInt16.java
diff --git a/src/org/gnunet/construct/UInt32.java b/src/main/java/org/gnunet/construct/UInt32.java
index ab4a278..ab4a278 100644
--- a/src/org/gnunet/construct/UInt32.java
+++ b/src/main/java/org/gnunet/construct/UInt32.java
diff --git a/src/org/gnunet/construct/UInt64.java b/src/main/java/org/gnunet/construct/UInt64.java
index d45cf69..d45cf69 100644
--- a/src/org/gnunet/construct/UInt64.java
+++ b/src/main/java/org/gnunet/construct/UInt64.java
diff --git a/src/org/gnunet/construct/UInt8.java b/src/main/java/org/gnunet/construct/UInt8.java
index 58b8335..58b8335 100644
--- a/src/org/gnunet/construct/UInt8.java
+++ b/src/main/java/org/gnunet/construct/UInt8.java
diff --git a/src/org/gnunet/construct/Union.java b/src/main/java/org/gnunet/construct/Union.java
index d35512e..d35512e 100644
--- a/src/org/gnunet/construct/Union.java
+++ b/src/main/java/org/gnunet/construct/Union.java
diff --git a/src/org/gnunet/construct/UnionCase.java b/src/main/java/org/gnunet/construct/UnionCase.java
index 7622dd4..7622dd4 100644
--- a/src/org/gnunet/construct/UnionCase.java
+++ b/src/main/java/org/gnunet/construct/UnionCase.java
diff --git a/src/org/gnunet/construct/VariableSizeArray.java b/src/main/java/org/gnunet/construct/VariableSizeArray.java
index 64daece..64daece 100644
--- a/src/org/gnunet/construct/VariableSizeArray.java
+++ b/src/main/java/org/gnunet/construct/VariableSizeArray.java
diff --git a/src/org/gnunet/construct/VariableSizeIntegerArray.java b/src/main/java/org/gnunet/construct/VariableSizeIntegerArray.java
index a3a9f28..a3a9f28 100644
--- a/src/org/gnunet/construct/VariableSizeIntegerArray.java
+++ b/src/main/java/org/gnunet/construct/VariableSizeIntegerArray.java
diff --git a/src/org/gnunet/construct/ZeroTerminatedString.java b/src/main/java/org/gnunet/construct/ZeroTerminatedString.java
index 2d70d71..2d70d71 100644
--- a/src/org/gnunet/construct/ZeroTerminatedString.java
+++ b/src/main/java/org/gnunet/construct/ZeroTerminatedString.java
diff --git a/src/org/gnunet/construct/package-info.java b/src/main/java/org/gnunet/construct/package-info.java
index add5d40..add5d40 100644
--- a/src/org/gnunet/construct/package-info.java
+++ b/src/main/java/org/gnunet/construct/package-info.java
diff --git a/src/org/gnunet/construct/parsers/DoubleParser.java b/src/main/java/org/gnunet/construct/parsers/DoubleParser.java
index c6cc835..c6cc835 100644
--- a/src/org/gnunet/construct/parsers/DoubleParser.java
+++ b/src/main/java/org/gnunet/construct/parsers/DoubleParser.java
diff --git a/src/org/gnunet/construct/parsers/FillParser.java b/src/main/java/org/gnunet/construct/parsers/FillParser.java
index 156e120..156e120 100644
--- a/src/org/gnunet/construct/parsers/FillParser.java
+++ b/src/main/java/org/gnunet/construct/parsers/FillParser.java
diff --git a/src/org/gnunet/construct/parsers/FixedSizeArrayParser.java b/src/main/java/org/gnunet/construct/parsers/FixedSizeArrayParser.java
index 3dbc720..3dbc720 100644
--- a/src/org/gnunet/construct/parsers/FixedSizeArrayParser.java
+++ b/src/main/java/org/gnunet/construct/parsers/FixedSizeArrayParser.java
diff --git a/src/org/gnunet/construct/parsers/FixedSizeIntegerArrayParser.java b/src/main/java/org/gnunet/construct/parsers/FixedSizeIntegerArrayParser.java
index ae633b0..ae633b0 100644
--- a/src/org/gnunet/construct/parsers/FixedSizeIntegerArrayParser.java
+++ b/src/main/java/org/gnunet/construct/parsers/FixedSizeIntegerArrayParser.java
diff --git a/src/org/gnunet/construct/parsers/IntegerFillParser.java b/src/main/java/org/gnunet/construct/parsers/IntegerFillParser.java
index 7027afc..7027afc 100644
--- a/src/org/gnunet/construct/parsers/IntegerFillParser.java
+++ b/src/main/java/org/gnunet/construct/parsers/IntegerFillParser.java
diff --git a/src/org/gnunet/construct/parsers/IntegerParser.java b/src/main/java/org/gnunet/construct/parsers/IntegerParser.java
index 4f71aa5..4f71aa5 100644
--- a/src/org/gnunet/construct/parsers/IntegerParser.java
+++ b/src/main/java/org/gnunet/construct/parsers/IntegerParser.java
diff --git a/src/org/gnunet/construct/parsers/IntegerUtil.java b/src/main/java/org/gnunet/construct/parsers/IntegerUtil.java
index 83391de..83391de 100644
--- a/src/org/gnunet/construct/parsers/IntegerUtil.java
+++ b/src/main/java/org/gnunet/construct/parsers/IntegerUtil.java
diff --git a/src/org/gnunet/construct/parsers/NestedParser.java b/src/main/java/org/gnunet/construct/parsers/NestedParser.java
index 733bf9e..76aa397 100644
--- a/src/org/gnunet/construct/parsers/NestedParser.java
+++ b/src/main/java/org/gnunet/construct/parsers/NestedParser.java
@@ -50,7 +50,7 @@ public class NestedParser implements Parser {
         if (inner == null) {
             if (optional)
                 return 0;
-            throw new AssertionError();
+            throw new AssertionError(String.format("empty non-optional nested message in field '%s'", targetField));
         }
         return nestedParser.getSize(inner);
     }
diff --git a/src/org/gnunet/construct/parsers/Parser.java b/src/main/java/org/gnunet/construct/parsers/Parser.java
index 3eb02a6..3eb02a6 100644
--- a/src/org/gnunet/construct/parsers/Parser.java
+++ b/src/main/java/org/gnunet/construct/parsers/Parser.java
diff --git a/src/org/gnunet/construct/parsers/SequenceParser.java b/src/main/java/org/gnunet/construct/parsers/SequenceParser.java
index 4128e1b..4128e1b 100644
--- a/src/org/gnunet/construct/parsers/SequenceParser.java
+++ b/src/main/java/org/gnunet/construct/parsers/SequenceParser.java
diff --git a/src/org/gnunet/construct/parsers/StringParser.java b/src/main/java/org/gnunet/construct/parsers/StringParser.java
index 8df171e..46d98ae 100644
--- a/src/org/gnunet/construct/parsers/StringParser.java
+++ b/src/main/java/org/gnunet/construct/parsers/StringParser.java
@@ -81,7 +81,6 @@ public class StringParser implements Parser {
 
         int length = 0;
 
-
         while (srcBuf.get(srcBuf.position() + length) != 0) {
             length++;
         }
diff --git a/src/org/gnunet/construct/parsers/UnionParser.java b/src/main/java/org/gnunet/construct/parsers/UnionParser.java
index e9fcc92..e9fcc92 100644
--- a/src/org/gnunet/construct/parsers/UnionParser.java
+++ b/src/main/java/org/gnunet/construct/parsers/UnionParser.java
diff --git a/src/org/gnunet/construct/parsers/VariableSizeArrayParser.java b/src/main/java/org/gnunet/construct/parsers/VariableSizeArrayParser.java
index fd55925..fd55925 100644
--- a/src/org/gnunet/construct/parsers/VariableSizeArrayParser.java
+++ b/src/main/java/org/gnunet/construct/parsers/VariableSizeArrayParser.java
diff --git a/src/org/gnunet/construct/parsers/VariableSizeIntegerArrayParser.java b/src/main/java/org/gnunet/construct/parsers/VariableSizeIntegerArrayParser.java
index b3f134d..b3f134d 100644
--- a/src/org/gnunet/construct/parsers/VariableSizeIntegerArrayParser.java
+++ b/src/main/java/org/gnunet/construct/parsers/VariableSizeIntegerArrayParser.java
diff --git a/src/org/gnunet/construct/parsers/package-info.java b/src/main/java/org/gnunet/construct/parsers/package-info.java
index 5da3a94..5da3a94 100644
--- a/src/org/gnunet/construct/parsers/package-info.java
+++ b/src/main/java/org/gnunet/construct/parsers/package-info.java
diff --git a/src/org/gnunet/core/ConnectHandler.java b/src/main/java/org/gnunet/core/ConnectHandler.java
index a36d798..a36d798 100644
--- a/src/org/gnunet/core/ConnectHandler.java
+++ b/src/main/java/org/gnunet/core/ConnectHandler.java
diff --git a/src/org/gnunet/core/ConnectNotifyMessage.java b/src/main/java/org/gnunet/core/ConnectNotifyMessage.java
index 4eafe02..4eafe02 100644
--- a/src/org/gnunet/core/ConnectNotifyMessage.java
+++ b/src/main/java/org/gnunet/core/ConnectNotifyMessage.java
diff --git a/src/org/gnunet/core/Core.java b/src/main/java/org/gnunet/core/Core.java
index 8fffe08..2895e41 100644
--- a/src/org/gnunet/core/Core.java
+++ b/src/main/java/org/gnunet/core/Core.java
@@ -20,17 +20,18 @@
 
 package org.gnunet.core;
 
+import com.google.common.collect.Maps;
 import org.gnunet.construct.Construct;
 import org.gnunet.construct.MessageLoader;
-import org.gnunet.requests.Request;
-import org.gnunet.requests.RequestQueue;
+import org.gnunet.mq.Envelope;
+import org.gnunet.requests.MatchingRequestContainer;
+import org.gnunet.requests.RequestContainer;
 import org.gnunet.util.*;
 import org.grothoff.Runabout;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.util.HashMap;
-import java.util.Map;
 
 
 /**
@@ -39,158 +40,111 @@ import java.util.Map;
  * Sends messages to connected peers.
  */
 public class Core {
+    /**
+     * Logger for org.gnunet.Core.
+     */
     private static final Logger logger = LoggerFactory
             .getLogger(Core.class);
 
+    /**
+     * Client for connecting to the core service
+     */
     private final Client client;
 
-    private final RequestQueue requestQueue;
-
     /*
      * set to null once connected for the first time
      */
     private InitCallback initCallback;
 
     /*
-     * Callbacks for traffic notifications. null if not used.
+     * Callback for traffic notifications. null if not interested.
      */
     private HeaderNotify notifyOutboundHeaders;
+
+    /*
+     * Callback for traffic notifications. null if not interested.
+     */
     private HeaderNotify notifyInboundHeaders;
+
+    /*
+     * Callback for traffic notifications. null if not interested.
+     */
     private MessageNotify notifyOutboundMessages;
-    private MessageNotify notifyInboundMessages;
 
+    /*
+     * Callback for traffic notifications. null if not interested.
+     */
+    private MessageNotify notifyInboundMessages;
 
     /*
-     * Callbacks for connect/disconnect events
+     * Callbacks for connect events
      */
     private ConnectHandler connectHandler;
-    private DisconnectHandler disconnectHandler;
-
 
-    // per default we are interested in all messages => specific interest set is empty
-    private int[] interested = new int[0];
     /**
-     * Handler for the messages we are interested in.
+     * Callback for disconnect events.
      */
-    private Runabout messageHandler;
-
+    private DisconnectHandler disconnectHandler;
 
     /**
-     * All currently connected peers with information about them attached
+     * Messages we are interested in.
+     * Per default we are interested in all messages => specific interest set is empty.
      */
-    HashMap<PeerIdentity, ConnectedPeerInfo> connectedPeers = new HashMap<PeerIdentity, ConnectedPeerInfo>(10);
-
+    private int[] interested = new int[0];
 
     /**
-     * Information about the requests on connected peers.
+     * Handler for the messages we are interested in.
      */
-    private static class ConnectedPeerInfo {
-        public Map<Integer, NotifyTransmitReadyRequest> requestsToPeer = new HashMap<Integer,
-                NotifyTransmitReadyRequest>(1);
-        public int nextSmrId;
-    }
-
+    private Runabout messageHandler;
 
     /**
-     * Request to transmit a message, sent after the corresponding NotifyTransmitRequest has been
-     * approved by core.
+     * Peers that we were notified about being connected to them.
+     * Every connected peer is mapped to a generator for unique request IDs.
      */
-    private static class TransmitRequest extends Request {
-        public NotifyTransmitReadyRequest origin;
-        public GnunetMessage message;
-
-        @Override
-        public AbsoluteTime getDeadline() {
-            return origin.getDeadline();
-        }
-
-        @Override
-        public void transmit(Connection.MessageSink sink) {
-            SendMessage sm = new SendMessage();
-            sm.cork = 0;
-            sm.deadline = origin.getDeadline().asMessage();
-            sm.peer = origin.target;
-            sm.priority = origin.priority;
-            sm.payloadMessage = message;
-
-            sink.send(sm);
-        }
-
-        @Override
-        public void onCancel(boolean alreadyTransmitted) {
-            throw new AssertionError("TransmitRequest cannot be canceled");
-        }
-    }
+    private HashMap<PeerIdentity, Integer> connectedPeers = Maps.newHashMap();
 
     /**
-     * Sent after we get a SendMessageReady
+     * Request container for notify transmit requests.
      */
-    private static class NotifyTransmitReadyRequest extends Request {
-        public int size;
-        public int priority;
-        public PeerIdentity target;
-        public MessageTransmitter transmitter;
-        public int smrId;
-        public Cancelable transmitRequestCancel;
-
-
-        @Override
-        public void transmit(Connection.MessageSink sink) {
-            SendMessageRequest smr = new SendMessageRequest();
-            smr.queueSize = 0;
-            smr.priority = priority;
-            smr.deadline = deadline.asMessage();
-            smr.smrId = smrId;
-            smr.peer = target;
-
-            sink.send(smr);
-        }
-
-        @Override
-        public void onCancel(boolean alreadyTransmitted) {
-            // only thing we have to do is cancel the following transmitRequest, if any!
-            if (transmitRequestCancel != null) {
-                transmitRequestCancel.cancel();
-            }
-        }
-    }
-
-    private class InitRequest extends Request {
-        @Override
-        public AbsoluteTime getDeadline() {
-            return AbsoluteTime.FOREVER;
-        }
-
-        @Override
-        public void transmit(Connection.MessageSink sink) {
-            InitMessage initMessage = new InitMessage();
-
-            initMessage.interested = interested;
-            initMessage.options = 0;
-
-            for (int i : interested) {
-                logger.info("we are interested in " + i);
-            }
+    private MatchingRequestContainer<RequestIdentification, NotifyTransmitReadyRequest> ntr_requests;
 
-            sink.send(initMessage);
+    public static class NotifyTransmitReadyRequest extends RequestContainer.Request {
+        private final int size;
+        final public PeerIdentity target;
+        final public long priority;
+        public int smrId;
+        final public MessageTransmitter transmitter;
+        final public AbsoluteTime deadline;
+
+        public NotifyTransmitReadyRequest(int priority, int size, PeerIdentity target, RelativeTime timeout, MessageTransmitter transmitter) {
+            this.deadline = timeout.toAbsolute();
+            this.priority = priority;
+            this.size = size;
+            this.target = target;
+            this.transmitter = transmitter;
         }
 
         @Override
-        public void onCancel(boolean alreadyTransmitted) {
-            throw new AssertionError("init request can't be canceled");
+        public Envelope assembleRequest() {
+            SendMessageRequest m = new SendMessageRequest();
+            m.peer = target;
+            m.smrId = smrId;
+            m.priority = priority;
+            m.size = size;
+            m.deadline = deadline.asMessage();
+            return new Envelope(m);
         }
 
-        @Override
-        public boolean onReconnect() {
-            // keep the init message on reconnect.
-            return true;
+        public void cancel() {
+            // do nothing
         }
     }
 
-    public class CoreReceiver extends RunaboutMessageReceiver {
+
+    public final class CoreReceiver extends RunaboutMessageReceiver {
         public void visit(InitReplyMessage m) {
             PeerIdentity myIdentity = m.myIdentity;
-            connectedPeers.put(myIdentity, new ConnectedPeerInfo());
+            connectedPeers.put(myIdentity, 1);
 
             if (initCallback != null) {
                 initCallback.onInit(m.myIdentity);
@@ -243,12 +197,14 @@ public class Core {
         }
 
         public void visit(SendMessageReady m) {
-            ConnectedPeerInfo cpi = connectedPeers.get(m.peer);
-            NotifyTransmitReadyRequest req = cpi.requestsToPeer.get(m.smrId);
-
-            final TransmitRequest transmitRequest = new TransmitRequest();
-            transmitRequest.origin = req;
+            RequestIdentification rid = new RequestIdentification(m.smrId, m.peer);
+            NotifyTransmitReadyRequest req = ntr_requests.getRequest(rid);
 
+            final SendMessage sm = new SendMessage();
+            sm.cork = 0;
+            sm.peer = req.target;
+            sm.priority = req.priority;
+            sm.deadline = req.deadline.asMessage();
 
             req.transmitter.transmit(new Connection.MessageSink() {
                 boolean sent;
@@ -257,12 +213,16 @@ public class Core {
                     if (sent) {
                         throw new AssertionError("sending multiple messages not supported");
                     }
-                    transmitRequest.message = GnunetMessage.fromBody(m);
+                    sm.payloadMessage =  GnunetMessage.fromBody(m);
                     sent = true;
                 }
             });
 
-            req.transmitRequestCancel = requestQueue.add(transmitRequest);
+
+            if (sm.payloadMessage == null)
+                throw new AssertionError();
+
+            client.send(sm);
         }
 
         @Override
@@ -273,8 +233,8 @@ public class Core {
         @Override
         public void handleError() {
             if (disconnectHandler != null) {
-                for (Map.Entry<PeerIdentity, ConnectedPeerInfo> e : connectedPeers.entrySet()) {
-                    disconnectHandler.onDisconnect(e.getKey());
+                for (PeerIdentity e : connectedPeers.keySet()) {
+                    disconnectHandler.onDisconnect(e);
                 }
             }
             connectedPeers.clear();
@@ -283,12 +243,26 @@ public class Core {
 
     public Core(Configuration cfg) {
         client = new Client("core", cfg);
-        requestQueue = new RequestQueue(client, new CoreReceiver());
+        client.installReceiver(new CoreReceiver());
+        ntr_requests = new MatchingRequestContainer<RequestIdentification, NotifyTransmitReadyRequest>(client);
     }
 
+    /**
+     * Send to the service which messages are we interested in.
+     *
+     * @param initCallback called after the init message has been sent
+     */
     public void init(InitCallback initCallback) {
         this.initCallback = initCallback;
-        requestQueue.sendNext(new InitRequest());
+        InitMessage initMessage = new InitMessage();
+
+        initMessage.interested = interested;
+        initMessage.options = 0;
+
+        for (int i : interested) {
+            logger.debug("we are interested in " + i);
+        }
+        client.sendPrefered(initMessage);
     }
 
     /**
@@ -306,27 +280,21 @@ public class Core {
      */
     public Cancelable notifyTransmitReady(int priority, RelativeTime maxdelay,
                                           PeerIdentity target, int size, final MessageTransmitter transmitter) {
-        NotifyTransmitReadyRequest notifyRequest = new NotifyTransmitReadyRequest();
-        notifyRequest.priority = priority;
-        notifyRequest.size = size;
-        notifyRequest.target = target;
-        notifyRequest.transmitter = transmitter;
-        notifyRequest.setDeadline(maxdelay.toAbsolute());
-
-        ConnectedPeerInfo cpi = connectedPeers.get(target);
-        if (cpi == null) {
+        if (!connectedPeers.containsKey(target)) {
             throw new AssertionError("notifyTransmitReady called for unconnected peer");
         }
-
-        notifyRequest.smrId = cpi.nextSmrId;
-        cpi.nextSmrId++;
-
-        cpi.requestsToPeer.put(notifyRequest.smrId, notifyRequest);
-
-        return requestQueue.add(notifyRequest);
+        int id = connectedPeers.get(target);
+        connectedPeers.put(target, id+1);
+        NotifyTransmitReadyRequest notifyRequest = new NotifyTransmitReadyRequest(priority, size, target, maxdelay, transmitter);
+        notifyRequest.smrId = id;
+        RequestIdentification rid = new RequestIdentification(notifyRequest.smrId, target);
+        return ntr_requests.addRequest(rid, notifyRequest);
     }
 
-
+    /**
+     * Observe outgoing message headers from core.
+     * @param h callback
+     */
     public void observeOutboundHeaders(HeaderNotify h) {
         this.notifyOutboundHeaders = h;
     }
@@ -353,7 +321,8 @@ public class Core {
 
     /**
      * Handle all incoming messages with the specified runabout.
-     * Has to be called before init.
+     * Has to be called before init, as the service has to know which messages we
+     * are interested in.
      */
     public void setMessageHandler(Runabout runabout) {
         if (messageHandler != null) {
@@ -373,7 +342,6 @@ public class Core {
      * requests have been explicitly cancelled.
      */
     public void disconnect() {
-        requestQueue.destroy();
         client.disconnect();
     }
 }
diff --git a/src/org/gnunet/core/DisconnectHandler.java b/src/main/java/org/gnunet/core/DisconnectHandler.java
index c7ca407..c7ca407 100644
--- a/src/org/gnunet/core/DisconnectHandler.java
+++ b/src/main/java/org/gnunet/core/DisconnectHandler.java
diff --git a/src/org/gnunet/core/DisconnectNotifyMessage.java b/src/main/java/org/gnunet/core/DisconnectNotifyMessage.java
index e4c3209..e4c3209 100644
--- a/src/org/gnunet/core/DisconnectNotifyMessage.java
+++ b/src/main/java/org/gnunet/core/DisconnectNotifyMessage.java
diff --git a/src/org/gnunet/core/HeaderNotify.java b/src/main/java/org/gnunet/core/HeaderNotify.java
index 4f536e3..4f536e3 100644
--- a/src/org/gnunet/core/HeaderNotify.java
+++ b/src/main/java/org/gnunet/core/HeaderNotify.java
diff --git a/src/org/gnunet/core/InitCallback.java b/src/main/java/org/gnunet/core/InitCallback.java
index 889f8cf..889f8cf 100644
--- a/src/org/gnunet/core/InitCallback.java
+++ b/src/main/java/org/gnunet/core/InitCallback.java
diff --git a/src/org/gnunet/core/InitMessage.java b/src/main/java/org/gnunet/core/InitMessage.java
index 5546088..5546088 100644
--- a/src/org/gnunet/core/InitMessage.java
+++ b/src/main/java/org/gnunet/core/InitMessage.java
diff --git a/src/org/gnunet/core/InitReplyMessage.java b/src/main/java/org/gnunet/core/InitReplyMessage.java
index 02e8eef..02e8eef 100644
--- a/src/org/gnunet/core/InitReplyMessage.java
+++ b/src/main/java/org/gnunet/core/InitReplyMessage.java
diff --git a/src/org/gnunet/core/MessageNotify.java b/src/main/java/org/gnunet/core/MessageNotify.java
index b14ce29..b14ce29 100644
--- a/src/org/gnunet/core/MessageNotify.java
+++ b/src/main/java/org/gnunet/core/MessageNotify.java
diff --git a/src/org/gnunet/core/NotifyInboundTrafficMessage.java b/src/main/java/org/gnunet/core/NotifyInboundTrafficMessage.java
index 2bdd428..2bdd428 100644
--- a/src/org/gnunet/core/NotifyInboundTrafficMessage.java
+++ b/src/main/java/org/gnunet/core/NotifyInboundTrafficMessage.java
diff --git a/src/org/gnunet/core/NotifyOutboundTrafficMessage.java b/src/main/java/org/gnunet/core/NotifyOutboundTrafficMessage.java
index 900f8be..900f8be 100644
--- a/src/org/gnunet/core/NotifyOutboundTrafficMessage.java
+++ b/src/main/java/org/gnunet/core/NotifyOutboundTrafficMessage.java
diff --git a/src/main/java/org/gnunet/core/RequestIdentification.java b/src/main/java/org/gnunet/core/RequestIdentification.java
new file mode 100644
index 0000000..4f6a734
--- /dev/null
+++ b/src/main/java/org/gnunet/core/RequestIdentification.java
@@ -0,0 +1,35 @@
+package org.gnunet.core;
+
+import org.gnunet.peerinfo.PeerInfo;
+import org.gnunet.util.PeerIdentity;
+
+
+final class RequestIdentification {
+    public final int requestIdentifier;
+    public final PeerIdentity peerIdentity;
+
+    public RequestIdentification(int requestIdentifier, PeerIdentity peerIdentity) {
+        this.requestIdentifier = requestIdentifier;
+        this.peerIdentity = peerIdentity;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        RequestIdentification that = (RequestIdentification) o;
+
+        if (requestIdentifier != that.requestIdentifier) return false;
+        if (!peerIdentity.equals(that.peerIdentity)) return false;
+
+        return true;
+    }
+
+    @Override
+    public int hashCode() {
+        int result = requestIdentifier;
+        result = 31 * result + peerIdentity.hashCode();
+        return result;
+    }
+}
diff --git a/src/org/gnunet/core/SendMessage.java b/src/main/java/org/gnunet/core/SendMessage.java
index e4c6215..e4c6215 100644
--- a/src/org/gnunet/core/SendMessage.java
+++ b/src/main/java/org/gnunet/core/SendMessage.java
diff --git a/src/org/gnunet/core/SendMessageReady.java b/src/main/java/org/gnunet/core/SendMessageReady.java
index aa5bf44..aa5bf44 100644
--- a/src/org/gnunet/core/SendMessageReady.java
+++ b/src/main/java/org/gnunet/core/SendMessageReady.java
diff --git a/src/org/gnunet/core/SendMessageRequest.java b/src/main/java/org/gnunet/core/SendMessageRequest.java
index 17087d3..7a95127 100644
--- a/src/org/gnunet/core/SendMessageRequest.java
+++ b/src/main/java/org/gnunet/core/SendMessageRequest.java
@@ -57,7 +57,7 @@ public class SendMessageRequest implements GnunetMessage.Body {
      * How large is the client's message queue for this peer?
      */
     @UInt32
-    public long queueSize;
+    public byte reserved;
 
     /**
      * How large is the message?
diff --git a/src/org/gnunet/core/package-info.java b/src/main/java/org/gnunet/core/package-info.java
index 64e5d59..64e5d59 100644
--- a/src/org/gnunet/core/package-info.java
+++ b/src/main/java/org/gnunet/core/package-info.java
diff --git a/src/org/gnunet/dht/BlockType.java b/src/main/java/org/gnunet/dht/BlockType.java
index cf00d38..cf00d38 100644
--- a/src/org/gnunet/dht/BlockType.java
+++ b/src/main/java/org/gnunet/dht/BlockType.java
diff --git a/src/org/gnunet/dht/ClientGetMessage.java b/src/main/java/org/gnunet/dht/ClientGetMessage.java
index cd317fb..cd317fb 100644
--- a/src/org/gnunet/dht/ClientGetMessage.java
+++ b/src/main/java/org/gnunet/dht/ClientGetMessage.java
diff --git a/src/org/gnunet/dht/ClientGetStopMessage.java b/src/main/java/org/gnunet/dht/ClientGetStopMessage.java
index 4cdee12..4cdee12 100644
--- a/src/org/gnunet/dht/ClientGetStopMessage.java
+++ b/src/main/java/org/gnunet/dht/ClientGetStopMessage.java
diff --git a/src/org/gnunet/dht/ClientPutConfirmationMessage.java b/src/main/java/org/gnunet/dht/ClientPutConfirmationMessage.java
index 45bbe60..45bbe60 100644
--- a/src/org/gnunet/dht/ClientPutConfirmationMessage.java
+++ b/src/main/java/org/gnunet/dht/ClientPutConfirmationMessage.java
diff --git a/src/org/gnunet/dht/ClientPutMessage.java b/src/main/java/org/gnunet/dht/ClientPutMessage.java
index 4b63e92..4b63e92 100644
--- a/src/org/gnunet/dht/ClientPutMessage.java
+++ b/src/main/java/org/gnunet/dht/ClientPutMessage.java
diff --git a/src/org/gnunet/dht/ClientResultMessage.java b/src/main/java/org/gnunet/dht/ClientResultMessage.java
index fab614f..fab614f 100644
--- a/src/org/gnunet/dht/ClientResultMessage.java
+++ b/src/main/java/org/gnunet/dht/ClientResultMessage.java
diff --git a/src/org/gnunet/dht/DistributedHashTable.java b/src/main/java/org/gnunet/dht/DistributedHashTable.java
index 3f42492..0a561bf 100644
--- a/src/org/gnunet/dht/DistributedHashTable.java
+++ b/src/main/java/org/gnunet/dht/DistributedHashTable.java
@@ -21,10 +21,10 @@
 package org.gnunet.dht;
 
 import com.google.common.base.Charsets;
-import com.google.common.collect.Lists;
-import com.google.common.collect.Maps;
-import org.gnunet.requests.Request;
-import org.gnunet.requests.RequestQueue;
+import org.gnunet.mq.Envelope;
+import org.gnunet.requests.MatchingRequestContainer;
+import org.gnunet.requests.RequestContainer;
+import org.gnunet.requests.SequentialRequestContainer;
 import org.gnunet.util.*;
 import org.gnunet.util.getopt.Argument;
 import org.gnunet.util.getopt.ArgumentAction;
@@ -43,36 +43,18 @@ public class DistributedHashTable {
     private static final Logger logger = LoggerFactory
             .getLogger(DistributedHashTable.class);
 
-
     private Client client;
 
-    private RequestQueue requestQueue;
-
     /**
      * next UID used on get/monitor requests, incremented after each use.
      */
     private long nextUID = 1;
 
-    private Map<Long, PutRequest> putRequests = Maps.newTreeMap();
-    private Map<Long, GetRequest> getRequests = Maps.newTreeMap();
-
-    /**
-     * monitor requests are kind of special, responses from the dht don't include the UID!
-     */
-    private List<MonitorRequest> monitorRequests = Lists.newLinkedList();
-
-
-    /**
-     * Create a connection with the DHT service.
-     *
-     * @param cfg the configuration to use
-     */
-    public DistributedHashTable(Configuration cfg) {
-        client = new Client("dht", cfg);
-        requestQueue = new RequestQueue(client, new DHTMessageReceiver());
-    }
+    private MatchingRequestContainer<Long, PutRequest> putRequests;
+    private MatchingRequestContainer<Long, GetRequest> getRequests;
+    private SequentialRequestContainer<MonitorRequest> monitorRequests;
 
-    private class PutRequest extends Request {
+    private class PutRequest extends RequestContainer.Request {
         public byte[] data;
         public HashCode key;
         public int replicationLevel;
@@ -83,11 +65,10 @@ public class DistributedHashTable {
 
         public PutRequest() {
             this.uid = nextUID++;
-            putRequests.put(uid, this);
         }
 
         @Override
-        public void transmit(Connection.MessageSink sink) {
+        public Envelope assembleRequest() {
             final ClientPutMessage cpm = new ClientPutMessage();
             cpm.data = data;
             cpm.hash = key;
@@ -95,16 +76,15 @@ public class DistributedHashTable {
             cpm.expiration = expiration.asMessage();
             cpm.type = type;
             cpm.uid = uid;
-            sink.send(cpm);
+            return new Envelope(cpm);
         }
 
-        public boolean onDestroy() {
-            return true; // keep!
+        public void cancel() {
         }
     }
 
 
-    private class GetRequest extends Request {
+    private class GetRequest extends RequestContainer.Request {
         public long uid;
         public HashCode key;
         public ResultCallback cb;
@@ -114,23 +94,24 @@ public class DistributedHashTable {
 
         public GetRequest() {
             uid = DistributedHashTable.this.nextUID++;
-            getRequests.put(uid, this);
         }
 
         @Override
-        public void transmit(Connection.MessageSink sink) {
+        public Envelope assembleRequest() {
             ClientGetMessage gm = new ClientGetMessage();
             gm.desiredReplicationLevel = replication;
             gm.type = type;
             gm.xquery = xquery == null ? new byte[0] : xquery;
             gm.key = key;
             gm.uniqueId = uid;
+            return new Envelope(gm);
+        }
+        public void cancel() {
 
-            sink.send(gm);
         }
     }
 
-    private class MonitorRequest extends Request {
+    private class MonitorRequest extends RequestContainer.Request {
         public int blockType;
         public HashCode key;
         public MonitorGetHandler getHandler;
@@ -138,16 +119,7 @@ public class DistributedHashTable {
         public MonitorPutHandler putHandler;
 
         @Override
-        public AbsoluteTime getDeadline() {
-            return AbsoluteTime.FOREVER;
-        }
-
-        public MonitorRequest() {
-            monitorRequests.add(this);
-        }
-
-        @Override
-        public void transmit(Connection.MessageSink sink) {
+        public Envelope assembleRequest() {
             MonitorStartStop mss = new MonitorStartStop();
             if (key != null) {
                 mss.filter_key = 1;
@@ -165,25 +137,24 @@ public class DistributedHashTable {
                 mss.put = 1;
             }
             mss.type = blockType;
-
-            sink.send(mss);
+            return new Envelope(mss);
         }
 
-        @Override
-        public void onCancel(boolean alreadyTransmitted) {
-            if (alreadyTransmitted) {
-                MonitorRequest cancelRequest = new MonitorRequest();
-                cancelRequest.getHandler = null;
-                cancelRequest.getResponseHandler = null;
-                cancelRequest.putHandler = null;
-                requestQueue.add(new MonitorRequest());
-            }
+        public void cancel() {
+            // todo: use priority requests
+            MonitorRequest cancelRequest = new MonitorRequest();
+            cancelRequest.getHandler = null;
+            cancelRequest.getResponseHandler = null;
+            cancelRequest.putHandler = null;
+            monitorRequests.addRequest(cancelRequest);
+
+            monitorRequests.addRequest(cancelRequest);
         }
     }
 
-    public class DHTMessageReceiver extends RunaboutMessageReceiver {
+    private class DHTMessageReceiver extends RunaboutMessageReceiver {
         public void visit(ClientPutConfirmationMessage pcm) {
-            PutRequest thePutRequest = putRequests.get(pcm.uid);
+            PutRequest thePutRequest = putRequests.getRequest(pcm.uid);
             if (thePutRequest == null) {
                 logger.warn("request UID not found");
                 return;
@@ -194,7 +165,7 @@ public class DistributedHashTable {
         }
 
         public void visit(ClientResultMessage rm) {
-            GetRequest theGetRequest = getRequests.get(rm.uid);
+            GetRequest theGetRequest = getRequests.getRequest(rm.uid);
             if (theGetRequest == null) {
                 logger.warn("request UID not found");
                 return;
@@ -205,7 +176,7 @@ public class DistributedHashTable {
         }
 
         public void visit(MonitorGetMessage monitorGetMessage) {
-            for (MonitorRequest monitorRequest : monitorRequests) {
+            for (MonitorRequest monitorRequest : monitorRequests.iter()) {
                 boolean type_ok = (monitorGetMessage.type == BlockType.ANY.val)
                         || (monitorGetMessage.type == monitorRequest.blockType);
                 boolean key_ok = monitorGetMessage.key.isAllZero()
@@ -220,7 +191,7 @@ public class DistributedHashTable {
         }
 
         public void visit(MonitorGetRespMessage monitorGetRespMessage) {
-            for (MonitorRequest monitorRequest : monitorRequests) {
+            for (MonitorRequest monitorRequest : monitorRequests.iter()) {
                 boolean type_ok = (monitorGetRespMessage.type == BlockType.ANY.val)
                         || (monitorGetRespMessage.type == monitorRequest.blockType);
                 boolean key_ok = monitorGetRespMessage.key.isAllZero()
@@ -240,7 +211,7 @@ public class DistributedHashTable {
         }
 
         public void visit(MonitorPutMessage monitorPutMessage) {
-            for (MonitorRequest monitorRequest : monitorRequests) {
+            for (MonitorRequest monitorRequest : monitorRequests.iter()) {
                 boolean type_ok = (monitorPutMessage.type == BlockType.ANY.val)
                         || (monitorPutMessage.type == monitorRequest.blockType);
                 boolean key_ok = monitorPutMessage.key.isAllZero()
@@ -256,10 +227,23 @@ public class DistributedHashTable {
 
         @Override
         public void handleError() {
-            requestQueue.reconnect();
         }
     }
 
+
+    /**
+     * Create a connection with the DHT service.
+     *
+     * @param cfg the configuration to use
+     */
+    public DistributedHashTable(Configuration cfg) {
+        client = new Client("dht", cfg);
+        client.installReceiver(new DHTMessageReceiver());
+        putRequests = new MatchingRequestContainer<Long, PutRequest>(client);
+        getRequests = new MatchingRequestContainer<Long, GetRequest>(client);
+        monitorRequests = new SequentialRequestContainer<MonitorRequest>(client);
+    }
+
     /**
      * Put data into the dht.
      *
@@ -279,12 +263,11 @@ public class DistributedHashTable {
         pr.key = key;
         pr.data = data;
         pr.replicationLevel = replicationLevel;
-        pr.setDeadline(timeout.toAbsolute());
         pr.expiration = expiration;
         pr.type = type;
         pr.cont = cont;
 
-        requestQueue.add(pr);
+        putRequests.addRequest(pr.uid, pr);
     }
 
 
@@ -310,9 +293,8 @@ public class DistributedHashTable {
         getRequest.type = type;
         getRequest.replication = type;
         getRequest.xquery = xquery;
-        getRequest.setDeadline(timeout.toAbsolute());
 
-        return requestQueue.add(getRequest);
+        return getRequests.addRequest(getRequest.uid, getRequest);
     }
 
     public Cancelable startMonitor(int blockType, HashCode key, MonitorGetHandler getHandler,
@@ -325,8 +307,7 @@ public class DistributedHashTable {
         monitorRequest.getResponseHandler = getResponseHandler;
         monitorRequest.putHandler = putHandler;
 
-        return requestQueue.add(monitorRequest);
-
+        return monitorRequests.addRequest(monitorRequest);
     }
 
 
@@ -335,7 +316,6 @@ public class DistributedHashTable {
      */
     public void destroy() {
         // there's nothing to sync, just destroy!
-        requestQueue.destroy();
         client.disconnect();
     }
 
diff --git a/src/org/gnunet/dht/MonitorGetHandler.java b/src/main/java/org/gnunet/dht/MonitorGetHandler.java
index c7dad7c..c7dad7c 100644
--- a/src/org/gnunet/dht/MonitorGetHandler.java
+++ b/src/main/java/org/gnunet/dht/MonitorGetHandler.java
diff --git a/src/org/gnunet/dht/MonitorGetMessage.java b/src/main/java/org/gnunet/dht/MonitorGetMessage.java
index e96ec96..e96ec96 100644
--- a/src/org/gnunet/dht/MonitorGetMessage.java
+++ b/src/main/java/org/gnunet/dht/MonitorGetMessage.java
diff --git a/src/org/gnunet/dht/MonitorGetRespMessage.java b/src/main/java/org/gnunet/dht/MonitorGetRespMessage.java
index 3bf145b..3bf145b 100644
--- a/src/org/gnunet/dht/MonitorGetRespMessage.java
+++ b/src/main/java/org/gnunet/dht/MonitorGetRespMessage.java
diff --git a/src/org/gnunet/dht/MonitorGetResponseHandler.java b/src/main/java/org/gnunet/dht/MonitorGetResponseHandler.java
index ff03cce..ff03cce 100644
--- a/src/org/gnunet/dht/MonitorGetResponseHandler.java
+++ b/src/main/java/org/gnunet/dht/MonitorGetResponseHandler.java
diff --git a/src/org/gnunet/dht/MonitorPutHandler.java b/src/main/java/org/gnunet/dht/MonitorPutHandler.java
index 0abb79b..0abb79b 100644
--- a/src/org/gnunet/dht/MonitorPutHandler.java
+++ b/src/main/java/org/gnunet/dht/MonitorPutHandler.java
diff --git a/src/org/gnunet/dht/MonitorPutMessage.java b/src/main/java/org/gnunet/dht/MonitorPutMessage.java
index 103c05b..103c05b 100644
--- a/src/org/gnunet/dht/MonitorPutMessage.java
+++ b/src/main/java/org/gnunet/dht/MonitorPutMessage.java
diff --git a/src/org/gnunet/dht/MonitorStartStop.java b/src/main/java/org/gnunet/dht/MonitorStartStop.java
index b3f3268..b3f3268 100644
--- a/src/org/gnunet/dht/MonitorStartStop.java
+++ b/src/main/java/org/gnunet/dht/MonitorStartStop.java
diff --git a/src/org/gnunet/dht/ResultCallback.java b/src/main/java/org/gnunet/dht/ResultCallback.java
index fa5c7ef..fa5c7ef 100644
--- a/src/org/gnunet/dht/ResultCallback.java
+++ b/src/main/java/org/gnunet/dht/ResultCallback.java
diff --git a/src/org/gnunet/dht/RouteOption.java b/src/main/java/org/gnunet/dht/RouteOption.java
index b74b528..b74b528 100644
--- a/src/org/gnunet/dht/RouteOption.java
+++ b/src/main/java/org/gnunet/dht/RouteOption.java
diff --git a/src/org/gnunet/dht/package-info.java b/src/main/java/org/gnunet/dht/package-info.java
index 3d8c6ed..3d8c6ed 100644
--- a/src/org/gnunet/dht/package-info.java
+++ b/src/main/java/org/gnunet/dht/package-info.java
diff --git a/src/org/gnunet/hello/HelloMessage.java b/src/main/java/org/gnunet/hello/HelloMessage.java
index 0d90912..0d90912 100644
--- a/src/org/gnunet/hello/HelloMessage.java
+++ b/src/main/java/org/gnunet/hello/HelloMessage.java
diff --git a/src/org/gnunet/hello/package-info.java b/src/main/java/org/gnunet/hello/package-info.java
index 78a5193..78a5193 100644
--- a/src/org/gnunet/hello/package-info.java
+++ b/src/main/java/org/gnunet/hello/package-info.java
diff --git a/src/org/gnunet/mesh/ClientConnectMessage.java b/src/main/java/org/gnunet/mesh/ClientConnectMessage.java
index 1a56ebb..1a56ebb 100644
--- a/src/org/gnunet/mesh/ClientConnectMessage.java
+++ b/src/main/java/org/gnunet/mesh/ClientConnectMessage.java
diff --git a/src/org/gnunet/mesh/ConnectHandler.java b/src/main/java/org/gnunet/mesh/ConnectHandler.java
index 021e8f0..021e8f0 100644
--- a/src/org/gnunet/mesh/ConnectHandler.java
+++ b/src/main/java/org/gnunet/mesh/ConnectHandler.java
diff --git a/src/org/gnunet/mesh/DataMessage.java b/src/main/java/org/gnunet/mesh/DataMessage.java
index 92546c8..92546c8 100644
--- a/src/org/gnunet/mesh/DataMessage.java
+++ b/src/main/java/org/gnunet/mesh/DataMessage.java
diff --git a/src/org/gnunet/mesh/DisconnectHandler.java b/src/main/java/org/gnunet/mesh/DisconnectHandler.java
index 8fd6428..8fd6428 100644
--- a/src/org/gnunet/mesh/DisconnectHandler.java
+++ b/src/main/java/org/gnunet/mesh/DisconnectHandler.java
diff --git a/src/org/gnunet/mesh/InboundTunnelHandler.java b/src/main/java/org/gnunet/mesh/InboundTunnelHandler.java
index ebcf225..ebcf225 100644
--- a/src/org/gnunet/mesh/InboundTunnelHandler.java
+++ b/src/main/java/org/gnunet/mesh/InboundTunnelHandler.java
diff --git a/src/org/gnunet/mesh/LocalAckMessage.java b/src/main/java/org/gnunet/mesh/LocalAckMessage.java
index 6a09411..6a09411 100644
--- a/src/org/gnunet/mesh/LocalAckMessage.java
+++ b/src/main/java/org/gnunet/mesh/LocalAckMessage.java
diff --git a/src/org/gnunet/mesh/Mesh.java b/src/main/java/org/gnunet/mesh/Mesh.java
index b272b0b..a6bf602 100644
--- a/src/org/gnunet/mesh/Mesh.java
+++ b/src/main/java/org/gnunet/mesh/Mesh.java
@@ -21,11 +21,9 @@
 package org.gnunet.mesh;
 
 import org.gnunet.construct.Construct;
-import org.gnunet.mq.ClientMessageQueue;
 import org.gnunet.mq.Envelope;
 import org.gnunet.mq.MessageQueue;
-import org.gnunet.requests.Request;
-import org.gnunet.requests.RequestQueue;
+import org.gnunet.mq.NotifySentHandler;
 import org.gnunet.util.*;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -75,11 +73,6 @@ public class Mesh {
     private final Client client;
 
     /**
-     * Message queue for the client.
-     */
-    private final ClientMessageQueue client_mq;
-
-    /**
      * Called whenever a tunnel was destroyed.
      */
     private TunnelEndHandler tunnelEndHandler;
@@ -103,13 +96,13 @@ public class Mesh {
     /**
      * Mapping from the tunnel's ID to the tunnel object.
      */
-    private Map<Integer,Tunnel> tunnelMap = new HashMap<>();
+    private Map<Integer,Tunnel> tunnelMap = new HashMap<Integer,Tunnel>();
 
     /**
      * Counter for generating fresh tunnel ID's
      * when creating new tunnels.
      */
-    int next_tid = 1;
+    private int next_tid = 1;
 
     /**
      * A tunnel to a remote peer.
@@ -122,7 +115,12 @@ public class Mesh {
         public final int port;
         protected int tunnelId;
         private boolean receive_done_expected = false;
-        int ack_count = 0;
+        int ack_count = 1;
+
+        /**
+         * Canceler for the currently submitted envelope.
+         */
+        public Cancelable envelopeCanceler;
 
         /**
          * Create a new tunnel (we're initiator and will be allowed to add/remove peers
@@ -142,7 +140,7 @@ public class Mesh {
             tcm.opt = opt;
             tcm.port = port;
             tcm.tunnel_id = tunnelId;
-            client_mq.send(tcm);
+            client.send(tcm);
         }
 
         /**
@@ -155,7 +153,7 @@ public class Mesh {
          * @param nobuffer
          * @param reliable
          */
-        private Tunnel(PeerIdentity peer, int tunnelId, int port, boolean nobuffer, boolean reliable) {
+        public Tunnel(PeerIdentity peer, int tunnelId, int port, boolean nobuffer, boolean reliable) {
             int my_opt = 0;
             if (reliable)
                 my_opt |= OPTION_RELIABLE;
@@ -175,27 +173,42 @@ public class Mesh {
                 throw new AssertionError("unexpected call to receiveDone");
             LocalAckMessage am = new LocalAckMessage();
             am.tid = tunnelId;
-            client_mq.send(am);
+            client.send(am);
             receive_done_expected = false;
         }
 
         public void destroy() {
             TunnelDestroyMessage m = new TunnelDestroyMessage();
             m.tunnel_id = tunnelId;
-            client_mq.send(m);
+            client.send(m);
         }
 
         @Override
-        protected void sendImmediate(Envelope ev) {
+        protected void submit(Envelope ev) {
             if (ack_count <= 0)
                 throw new AssertionError();
             DataMessage m = new DataMessage();
             m.payload = Construct.toBinary(GnunetMessage.fromBody(ev.message));
             Envelope mesh_ev = new Envelope(m);
-            client_mq.send(mesh_ev);
+            mesh_ev.notifySent(new NotifySentHandler() {
+                @Override
+                public void onSent() {
+                    envelopeCanceler = null;
+                }
+            });
+            client.send(mesh_ev);
+            envelopeCanceler = mesh_ev;
             ack_count -= 1;
         }
 
+        @Override
+        protected void retract() {
+            if (envelopeCanceler == null)
+                throw new AssertionError();
+            envelopeCanceler.cancel();
+            envelopeCanceler = null;
+        }
+
         public T getContext() {
             return context;
         }
@@ -253,7 +266,7 @@ public class Mesh {
             client.reconnect();
             ClientConnectMessage ccm = new ClientConnectMessage();
             ccm.apps_list = ports;
-            client_mq.send(ccm);
+            client.send(ccm);
         }
     }
 
@@ -274,10 +287,14 @@ public class Mesh {
         this.inboundTunnelHandler = inboundTunnelHandler;
 
         client = new Client("mesh", cfg);
-        client_mq = new ClientMessageQueue(client, new MeshMessageReceiver());
+        client.installReceiver(new MeshMessageReceiver());
         ClientConnectMessage ccm = new ClientConnectMessage();
         ccm.apps_list = ports;
-        client_mq.send(ccm);
+        client.send(ccm);
+    }
+
+    public <T> Tunnel<T> createTunnel(PeerIdentity peer, int port, boolean nobuffer, boolean reliable, T initialContext) {
+        return new Tunnel<T>(peer, port, nobuffer, reliable, initialContext);
     }
 
     /**
@@ -286,8 +303,7 @@ public class Mesh {
      * All tunnel disconnect callbacks will be called on any still connected peers, notifying
      * about their disconnection.
      */
-    public void disconnect() {
-        client_mq.destroy();
+    public void destroy() {
         client.disconnect();
     }
 }
diff --git a/src/org/gnunet/mesh/MeshRunabout.java b/src/main/java/org/gnunet/mesh/MeshRunabout.java
index ea4248c..ea4248c 100644
--- a/src/org/gnunet/mesh/MeshRunabout.java
+++ b/src/main/java/org/gnunet/mesh/MeshRunabout.java
diff --git a/src/org/gnunet/mesh/TunnelCreateMessage.java b/src/main/java/org/gnunet/mesh/TunnelCreateMessage.java
index eaa4d6c..eaa4d6c 100644
--- a/src/org/gnunet/mesh/TunnelCreateMessage.java
+++ b/src/main/java/org/gnunet/mesh/TunnelCreateMessage.java
diff --git a/src/org/gnunet/mesh/TunnelDestroyMessage.java b/src/main/java/org/gnunet/mesh/TunnelDestroyMessage.java
index bce60bb..bce60bb 100644
--- a/src/org/gnunet/mesh/TunnelDestroyMessage.java
+++ b/src/main/java/org/gnunet/mesh/TunnelDestroyMessage.java
diff --git a/src/org/gnunet/mesh/TunnelEndHandler.java b/src/main/java/org/gnunet/mesh/TunnelEndHandler.java
index e56fdd4..e56fdd4 100644
--- a/src/org/gnunet/mesh/TunnelEndHandler.java
+++ b/src/main/java/org/gnunet/mesh/TunnelEndHandler.java
diff --git a/src/org/gnunet/mesh/TunnelNotificationMessage.java b/src/main/java/org/gnunet/mesh/TunnelNotificationMessage.java
index 8846088..8846088 100644
--- a/src/org/gnunet/mesh/TunnelNotificationMessage.java
+++ b/src/main/java/org/gnunet/mesh/TunnelNotificationMessage.java
diff --git a/src/org/gnunet/mesh/package-info.java b/src/main/java/org/gnunet/mesh/package-info.java
index fb5a8a4..fb5a8a4 100644
--- a/src/org/gnunet/mesh/package-info.java
+++ b/src/main/java/org/gnunet/mesh/package-info.java
diff --git a/src/org/gnunet/mq/Envelope.java b/src/main/java/org/gnunet/mq/Envelope.java
index 09c0c2c..fa19225 100644
--- a/src/org/gnunet/mq/Envelope.java
+++ b/src/main/java/org/gnunet/mq/Envelope.java
@@ -1,11 +1,12 @@
 package org.gnunet.mq;
 
+import org.gnunet.util.Cancelable;
 import org.gnunet.util.GnunetMessage;
 
 /**
  * Container for a message to be sent by a message queue.
  */
-public class Envelope {
+public class Envelope implements Cancelable {
     public final GnunetMessage.Body message;
     private MessageQueue parent_queue;
     private NotifySentHandler notify_sent_handler;
@@ -24,7 +25,8 @@ public class Envelope {
     }
 
     public void cancel() {
-        // TODO
+        if (parent_queue == null)
+            throw new AssertionError("can not cancel an unqueued message");
     }
 
     /* pkg-private */ void invokeSentNotification() {
diff --git a/src/main/java/org/gnunet/mq/MessageQueue.java b/src/main/java/org/gnunet/mq/MessageQueue.java
new file mode 100644
index 0000000..4df3ae4
--- /dev/null
+++ b/src/main/java/org/gnunet/mq/MessageQueue.java
@@ -0,0 +1,84 @@
+package org.gnunet.mq;
+
+
+import org.gnunet.util.GnunetMessage;
+
+import java.util.LinkedList;
+
+/**
+ * General-purpose message queue
+ */
+public abstract class MessageQueue {
+    private LinkedList<Envelope> queued_envelopes = new LinkedList<Envelope>();
+    private LinkedList<Envelope> prefered_queued_envelopes = new LinkedList<Envelope>();
+    protected Envelope current_envelope;
+
+    protected abstract void submit(Envelope ev);
+
+    protected abstract void retract();
+
+    public void send(GnunetMessage.Body body) {
+        send(new Envelope(body));
+    }
+
+    public void sendPrefered(GnunetMessage.Body body) {
+        sendPrefered(new Envelope(body));
+    }
+
+    private Envelope pollNextEnvelope() {
+        if (!prefered_queued_envelopes.isEmpty())
+            return prefered_queued_envelopes.removeFirst();
+        if (!queued_envelopes.isEmpty())
+            return queued_envelopes.removeFirst();
+        return null;
+    }
+
+    public void send(Envelope ev) {
+        if (null == current_envelope) {
+            current_envelope = ev;
+            submit(current_envelope);
+        } else {
+            queued_envelopes.addLast(ev);
+        }
+    }
+
+    public void sendPrefered(Envelope ev) {
+        if (null == current_envelope) {
+            current_envelope = ev;
+            submit(current_envelope);
+        } else {
+            prefered_queued_envelopes.addLast(ev);
+        }
+    }
+
+    protected void reportMessageSent() {
+        if (null == current_envelope)
+            throw new AssertionError();
+        current_envelope.invokeSentNotification();
+        next();
+    }
+
+    private void next() {
+        current_envelope = pollNextEnvelope();
+        if (current_envelope == null)
+            return;
+        submit(current_envelope);
+    }
+
+    /**
+     * Cancel sending an envelope. The envelope must be queued in this message queue.
+     *
+     * @param ev the envelope to cancel
+     */
+    /* pkg-private */ void cancelEnvelope(Envelope ev) {
+        if (null == current_envelope)
+            throw new AssertionError();
+        if (ev == current_envelope) {
+            retract();
+            next();
+        } else {
+            queued_envelopes.remove(ev);
+            prefered_queued_envelopes.remove(ev);
+        }
+    }
+}
diff --git a/src/org/gnunet/mq/NotifySentHandler.java b/src/main/java/org/gnunet/mq/NotifySentHandler.java
index 7ec13b2..7ec13b2 100644
--- a/src/org/gnunet/mq/NotifySentHandler.java
+++ b/src/main/java/org/gnunet/mq/NotifySentHandler.java
diff --git a/src/org/gnunet/nse/NetworkSizeEstimation.java b/src/main/java/org/gnunet/nse/NetworkSizeEstimation.java
index 366ab80..5fc7453 100644
--- a/src/org/gnunet/nse/NetworkSizeEstimation.java
+++ b/src/main/java/org/gnunet/nse/NetworkSizeEstimation.java
@@ -21,7 +21,6 @@
 package org.gnunet.nse;
 
 
-import org.gnunet.construct.ProtocolViolationException;
 import org.gnunet.util.*;
 import org.gnunet.util.getopt.Argument;
 import org.gnunet.util.getopt.ArgumentAction;
@@ -53,7 +52,7 @@ public class NetworkSizeEstimation {
             }
 
             if (!disconnected) {
-                client.receive(RelativeTime.FOREVER, this);
+                client.receiveOne(RelativeTime.FOREVER, this);
             }
         }
 
@@ -70,7 +69,7 @@ public class NetworkSizeEstimation {
         public void transmit(Connection.MessageSink sink) {
             StartMessage m = new StartMessage();
             sink.send(m);
-            client.receive(RelativeTime.FOREVER, new NSE_Receiver());
+            client.receiveOne(RelativeTime.FOREVER, new NSE_Receiver());
         }
 
         @Override
@@ -139,7 +138,6 @@ public class NetworkSizeEstimation {
      */
     public void disconnect() {
         disconnected = true;
-
     }
 
     public static void main(String[] args) {
diff --git a/src/org/gnunet/nse/StartMessage.java b/src/main/java/org/gnunet/nse/StartMessage.java
index 9f5b79e..9f5b79e 100644
--- a/src/org/gnunet/nse/StartMessage.java
+++ b/src/main/java/org/gnunet/nse/StartMessage.java
diff --git a/src/org/gnunet/nse/UpdateMessage.java b/src/main/java/org/gnunet/nse/UpdateMessage.java
index 5c64a54..5c64a54 100644
--- a/src/org/gnunet/nse/UpdateMessage.java
+++ b/src/main/java/org/gnunet/nse/UpdateMessage.java
diff --git a/src/org/gnunet/nse/package-info.java b/src/main/java/org/gnunet/nse/package-info.java
index 3bbc064..3bbc064 100644
--- a/src/org/gnunet/nse/package-info.java
+++ b/src/main/java/org/gnunet/nse/package-info.java
diff --git a/src/org/gnunet/peerinfo/InfoEnd.java b/src/main/java/org/gnunet/peerinfo/InfoEnd.java
index b59e194..b59e194 100644
--- a/src/org/gnunet/peerinfo/InfoEnd.java
+++ b/src/main/java/org/gnunet/peerinfo/InfoEnd.java
diff --git a/src/org/gnunet/peerinfo/InfoMessage.java b/src/main/java/org/gnunet/peerinfo/InfoMessage.java
index d8d7daa..d8d7daa 100644
--- a/src/org/gnunet/peerinfo/InfoMessage.java
+++ b/src/main/java/org/gnunet/peerinfo/InfoMessage.java
diff --git a/src/org/gnunet/peerinfo/ListAllPeersMessage.java b/src/main/java/org/gnunet/peerinfo/ListAllPeersMessage.java
index e384c93..e384c93 100644
--- a/src/org/gnunet/peerinfo/ListAllPeersMessage.java
+++ b/src/main/java/org/gnunet/peerinfo/ListAllPeersMessage.java
diff --git a/src/org/gnunet/peerinfo/ListPeerMessage.java b/src/main/java/org/gnunet/peerinfo/ListPeerMessage.java
index 56e6b5d..56e6b5d 100644
--- a/src/org/gnunet/peerinfo/ListPeerMessage.java
+++ b/src/main/java/org/gnunet/peerinfo/ListPeerMessage.java
diff --git a/src/main/java/org/gnunet/peerinfo/PeerInfo.java b/src/main/java/org/gnunet/peerinfo/PeerInfo.java
new file mode 100644
index 0000000..46d35bf
--- /dev/null
+++ b/src/main/java/org/gnunet/peerinfo/PeerInfo.java
@@ -0,0 +1,159 @@
+/*
+ This file is part of GNUnet.
+ (C) 2011, 2012 Christian Grothoff (and other contributing authors)
+
+ GNUnet is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published
+ by the Free Software Foundation; either version 3, or (at your
+ option) any later version.
+
+ GNUnet is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with GNUnet; see the file COPYING.  If not, write to the
+ Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA.
+ */
+
+package org.gnunet.peerinfo;
+
+import org.gnunet.hello.HelloMessage;
+import org.gnunet.mq.Envelope;
+import org.gnunet.mq.MessageQueue;
+import org.gnunet.requests.RequestContainer;
+import org.gnunet.requests.SequentialRequestContainer;
+import org.gnunet.util.*;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Interface to the service that maintains all known hosts.
+ *
+ * @author Florian Dold
+ */
+public class PeerInfo {
+    private static final Logger logger = LoggerFactory
+            .getLogger(AbsoluteTime.class);
+
+    /**
+     * Client that connects to the peerinfo service.
+     */
+    private final Client client;
+
+    /**
+     * All currently active iterate requests.
+     */
+    private SequentialRequestContainer<PeerIterateRequest> iterate_requests;
+
+    private class PeerIterateRequest extends RequestContainer.Request {
+        public PeerIdentity peer;
+        public PeerProcessor peerProcessor;
+        public boolean friend_only;
+        public boolean canceled;
+
+        public PeerIterateRequest(PeerIdentity peer, boolean friend_only, PeerProcessor peerProcessor) {
+            this.peer = peer;
+            this.peerProcessor = peerProcessor;
+            this.friend_only = friend_only;
+        }
+
+        @Override
+        public Envelope assembleRequest() {
+            if (peer == null) {
+                ListAllPeersMessage m = new ListAllPeersMessage();
+                m.include_friend_only = friend_only ? 1 : 0;
+                return new Envelope(m);
+            } else {
+                ListPeerMessage m = new ListPeerMessage();
+                m.peer = peer;
+                return new Envelope(m);
+            }
+        }
+
+        public void cancel() {
+            canceled = true;
+        }
+    }
+
+    private class PeerInfoMessageReceiver extends RunaboutMessageReceiver {
+        public void visit(InfoEnd infoEnd) {
+            PeerIterateRequest r = iterate_requests.getRequest();
+            if (!r.canceled)
+                r.peerProcessor.onEnd();
+            iterate_requests.next();
+        }
+        public void visit(InfoMessage infoMessage) {
+            PeerIterateRequest r = iterate_requests.getRequest();
+            if (!r.canceled)
+                r.peerProcessor.onPeer(infoMessage.peerIdentity, infoMessage.hello);
+        }
+
+        @Override
+        public void handleError() {
+            client.reconnect();
+            iterate_requests.restart();
+        }
+    }
+
+
+    public PeerInfo(Configuration cfg) {
+        client = new Client("peerinfo", cfg);
+        client.installReceiver(new PeerInfoMessageReceiver());
+        iterate_requests = new SequentialRequestContainer<PeerIterateRequest>(client);
+        // Make sure that new requests are only sent once the old request has finished.
+        // Otherwise, the peerinfo service would send the answers interleaved.
+        iterate_requests.setOverlap(false);
+    }
+
+    /**
+     * Iterates over the HELLOs of all peers.
+     *
+     * @param timeout
+     * @param processor
+     * @return
+     */
+    public Cancelable iterate(RelativeTime timeout, boolean friend_only, PeerProcessor processor) {
+        return iterate(timeout, null, friend_only, processor);
+    }
+
+    /**
+     * Iterates over the HELLOs of the given peer.
+     * Can be called with peer=null to iterate over all peers.
+     * @param timeout
+     * @param peer
+     * @param processor
+     * @return
+     */
+    public Cancelable iterate(RelativeTime timeout, PeerIdentity peer, boolean friend_only, PeerProcessor processor) {
+        PeerIterateRequest r = new PeerIterateRequest(peer, friend_only, processor);
+        return iterate_requests.addRequest(r);
+    }
+
+    public void disconnect() {
+        client.disconnect();
+    }
+
+    public static void main(String... args) {
+        new Program(args) {
+            @Override
+            public void run() {
+                final PeerInfo peerInfo = new PeerInfo(getConfiguration());
+                peerInfo.iterate(RelativeTime.FOREVER, false, new PeerProcessor() {
+                    @Override
+                    public void onPeer(PeerIdentity peerIdentity, HelloMessage hello) {
+                        System.out.println("peer " + peerIdentity.toString());
+                    }
+
+                    @Override
+                    public void onEnd() {
+                        System.out.println("got peer end");
+                        peerInfo.disconnect();
+                    }
+                });
+            }
+        }.start();
+    }
+}
diff --git a/src/org/gnunet/peerinfo/PeerProcessor.java b/src/main/java/org/gnunet/peerinfo/PeerProcessor.java
index b096c37..b096c37 100644
--- a/src/org/gnunet/peerinfo/PeerProcessor.java
+++ b/src/main/java/org/gnunet/peerinfo/PeerProcessor.java
diff --git a/src/org/gnunet/peerinfo/RsaPublicKeyBinaryEncoded.java b/src/main/java/org/gnunet/peerinfo/RsaPublicKeyBinaryEncoded.java
index 86985f3..86985f3 100644
--- a/src/org/gnunet/peerinfo/RsaPublicKeyBinaryEncoded.java
+++ b/src/main/java/org/gnunet/peerinfo/RsaPublicKeyBinaryEncoded.java
diff --git a/src/org/gnunet/peerinfo/package-info.java b/src/main/java/org/gnunet/peerinfo/package-info.java
index 19cebdb..19cebdb 100644
--- a/src/org/gnunet/peerinfo/package-info.java
+++ b/src/main/java/org/gnunet/peerinfo/package-info.java
diff --git a/src/main/java/org/gnunet/requests/MatchingRequestContainer.java b/src/main/java/org/gnunet/requests/MatchingRequestContainer.java
new file mode 100644
index 0000000..656d162
--- /dev/null
+++ b/src/main/java/org/gnunet/requests/MatchingRequestContainer.java
@@ -0,0 +1,51 @@
+package org.gnunet.requests;
+
+import com.google.common.collect.Maps;
+import org.gnunet.mq.MessageQueue;
+import org.gnunet.util.Cancelable;
+
+import java.util.Map;
+
+
+public class MatchingRequestContainer<K, T extends RequestContainer.Request> extends RequestContainer {
+    private Map<K,T> requests = Maps.newHashMap();
+    private final MessageQueue mq;
+
+    public MatchingRequestContainer(MessageQueue mq) {
+        this.mq = mq;
+    }
+
+    public Cancelable addRequest(K key, final T request) {
+        if (requests.containsKey(key))
+            throw new AssertionError("key already present in request container");
+        requests.put(key, request);
+        mq.send(request.assembleRequest());
+        return new Cancelable() {
+            @Override
+            public void cancel() {
+                setRequestCancelled(request);
+                if (isRequestTransmitting(request)) {
+                    cancelRequestTransmission(request);
+                } else {
+                    request.cancel();
+                }
+            }
+        };
+    }
+
+    @Override
+    public void restart() {
+        Map<K,T> requestsOld = requests;
+        requests = Maps.newHashMap();
+        for (Map.Entry<K,T> e : requestsOld.entrySet()) {
+            if (!isRequestCancelled(e.getValue())) {
+                setRequestTransmitting(e.getValue(), false);
+                addRequest(e.getKey(), e.getValue());
+            }
+        }
+    }
+
+    public T getRequest(K key) {
+        return requests.get(key);
+    }
+}
diff --git a/src/main/java/org/gnunet/requests/RequestContainer.java b/src/main/java/org/gnunet/requests/RequestContainer.java
new file mode 100644
index 0000000..c7627f0
--- /dev/null
+++ b/src/main/java/org/gnunet/requests/RequestContainer.java
@@ -0,0 +1,59 @@
+package org.gnunet.requests;
+
+
+import org.gnunet.mq.Envelope;
+import org.gnunet.util.Cancelable;
+
+public abstract class RequestContainer {
+    protected boolean overlap = true;
+
+    public abstract static class Request {
+        private boolean transmitting;
+        private boolean canceled;
+        private Cancelable cancelRequest;
+        public abstract Envelope assembleRequest();
+        public void cancel() {
+            throw new AssertionError("request of type " + this.getClass() + " can not be canceled (not implemented)");
+        }
+    }
+
+    /**
+     * Re-send all requests in the queue that have not been canceled.
+     */
+    public abstract void restart();
+
+    /**
+     * Allow or disallow requests to be send while other requests in the queue have not been completed.
+     *
+     * @param overlap true to allow overlapped requests, false to disallow them
+     */
+    public void setOverlap(boolean overlap) {
+        this.overlap = overlap;
+    }
+
+    protected boolean isRequestTransmitting(Request r) {
+        return r.transmitting;
+    }
+
+    protected void setRequestTransmitting(Request r, boolean transmitting) {
+        r.transmitting = transmitting;
+    }
+
+    protected void setRequestTransmissionCancel(Request request, Cancelable cancel) {
+        request.cancelRequest = cancel;
+    }
+
+    protected void cancelRequestTransmission(Request r) {
+        r.cancelRequest.cancel();
+        r.cancelRequest = null;
+    }
+
+    protected void setRequestCancelled(Request r) {
+        r.canceled = true;
+    }
+
+    protected boolean isRequestCancelled(Request r) {
+        return r.canceled;
+    }
+
+}
diff --git a/src/main/java/org/gnunet/requests/SequentialRequestContainer.java b/src/main/java/org/gnunet/requests/SequentialRequestContainer.java
new file mode 100644
index 0000000..037055f
--- /dev/null
+++ b/src/main/java/org/gnunet/requests/SequentialRequestContainer.java
@@ -0,0 +1,86 @@
+package org.gnunet.requests;
+
+import org.gnunet.mq.Envelope;
+import org.gnunet.mq.MessageQueue;
+import org.gnunet.mq.NotifySentHandler;
+import org.gnunet.util.Cancelable;
+
+import java.util.LinkedList;
+
+/**
+ * Container for requests that are responded to in sequential order.
+ */
+public class SequentialRequestContainer<T extends RequestContainer.Request> extends RequestContainer {
+    private LinkedList<T> requests = new LinkedList<T>();
+    private MessageQueue mq;
+
+    int requestsActive = 0;
+
+    public SequentialRequestContainer(MessageQueue mq) {
+        this.mq = mq;
+    }
+
+    public T getRequest() {
+        return requests.getFirst();
+    }
+
+    public void next() {
+        if (requestsActive == 0 || requests.isEmpty())
+            throw new AssertionError();
+        requestsActive--;
+        requests.removeFirst();
+        if (requestsActive == 0 && !requests.isEmpty()) {
+            Request r = requests.getFirst();
+            setRequestTransmitting(r, true);
+            Envelope ev = r.assembleRequest();
+            setRequestTransmissionCancel(r, ev);
+            mq.send(r.assembleRequest());
+            requestsActive++;
+        }
+    }
+
+    public Cancelable addRequest(final T request) {
+        requests.addLast(request);
+        if (overlap || requestsActive == 0) {
+            requestsActive++;
+            setRequestTransmitting(request, true);
+            Envelope ev = request.assembleRequest();
+            ev.notifySent(new NotifySentHandler() {
+                @Override
+                public void onSent() {
+                    setRequestTransmitting(request, false);
+                }
+            });
+            setRequestTransmissionCancel(request, ev);
+            mq.send(request.assembleRequest());
+        }
+        return new Cancelable() {
+            @Override
+            public void cancel() {
+                setRequestCancelled(request);
+                if (isRequestTransmitting(request)) {
+                    cancelRequestTransmission(request);
+                } else {
+                    request.cancel();
+                }
+            }
+        };
+    }
+
+    @Override
+    public void restart() {
+        LinkedList<T> requestsOld = requests;
+        requests = new LinkedList<T>();
+        for (T r : requestsOld) {
+            if (!isRequestCancelled(r)) {
+                setRequestTransmitting(r, false);
+                addRequest(r);
+            }
+        }
+    }
+
+
+    public Iterable<T> iter() {
+        return requests;
+    }
+}
diff --git a/src/org/gnunet/requests/package-info.java b/src/main/java/org/gnunet/requests/package-info.java
index 892a606..892a606 100644
--- a/src/org/gnunet/requests/package-info.java
+++ b/src/main/java/org/gnunet/requests/package-info.java
diff --git a/src/org/gnunet/statistics/GetMessage.java b/src/main/java/org/gnunet/statistics/GetMessage.java
index eb44fbd..eb44fbd 100644
--- a/src/org/gnunet/statistics/GetMessage.java
+++ b/src/main/java/org/gnunet/statistics/GetMessage.java
diff --git a/src/main/java/org/gnunet/statistics/GetRequest.java b/src/main/java/org/gnunet/statistics/GetRequest.java
new file mode 100644
index 0000000..8f421b1
--- /dev/null
+++ b/src/main/java/org/gnunet/statistics/GetRequest.java
@@ -0,0 +1,31 @@
+package org.gnunet.statistics;
+
+import org.gnunet.mq.Envelope;
+import org.gnunet.mq.MessageQueue;
+import org.gnunet.requests.RequestContainer;
+
+/**
+ */
+public class GetRequest extends RequestContainer.Request {
+    private final String subsystem;
+    private final String name;
+    public final StatisticsReceiver receiver;
+    private RequestContainer parent;
+
+    public GetRequest(String subsystem, String name, StatisticsReceiver receiver) {
+        this.subsystem = subsystem;
+        this.name = name;
+        this.receiver = receiver;
+    }
+
+    @Override
+    public Envelope assembleRequest() {
+        GetMessage m = new GetMessage();
+        m.subsystemName = subsystem;
+        m.statisticsName = name;
+        return new Envelope(m);
+    }
+
+    public void cancel() {
+    }
+}
diff --git a/src/org/gnunet/statistics/GetResponseEndMessage.java b/src/main/java/org/gnunet/statistics/GetResponseEndMessage.java
index eebe16e..eebe16e 100644
--- a/src/org/gnunet/statistics/GetResponseEndMessage.java
+++ b/src/main/java/org/gnunet/statistics/GetResponseEndMessage.java
diff --git a/src/org/gnunet/statistics/GetResponseMessage.java b/src/main/java/org/gnunet/statistics/GetResponseMessage.java
index 2a722e6..2a722e6 100644
--- a/src/org/gnunet/statistics/GetResponseMessage.java
+++ b/src/main/java/org/gnunet/statistics/GetResponseMessage.java
diff --git a/src/org/gnunet/statistics/SetMessage.java b/src/main/java/org/gnunet/statistics/SetMessage.java
index d75e3bf..d75e3bf 100644
--- a/src/org/gnunet/statistics/SetMessage.java
+++ b/src/main/java/org/gnunet/statistics/SetMessage.java
diff --git a/src/main/java/org/gnunet/statistics/SetRequest.java b/src/main/java/org/gnunet/statistics/SetRequest.java
new file mode 100644
index 0000000..4aa4a82
--- /dev/null
+++ b/src/main/java/org/gnunet/statistics/SetRequest.java
@@ -0,0 +1,48 @@
+package org.gnunet.statistics;
+
+import org.gnunet.mq.Envelope;
+import org.gnunet.mq.MessageQueue;
+import org.gnunet.requests.RequestContainer;
+import org.gnunet.util.RelativeTime;
+
+
+public class SetRequest extends RequestContainer.Request {
+    /**
+     * Time after we give up on setting values in statistics
+     */
+    private static final RelativeTime SET_TIMEOUT = RelativeTime.SECOND.multiply(10);
+
+    private final static int SETFLAG_RELATIVE = 1;
+    private final static int SETFLAG_PERSIST = 2;
+    private final String subsystem;
+    private final String name;
+    private final boolean persist;
+    private final long value;
+    private final boolean relative;
+
+    public SetRequest(String subsystem, String name, long value, boolean relative, boolean persist) {
+        this.subsystem = subsystem;
+        this.name = name;
+        this.persist = persist;
+        this.value = value;
+        this.relative = relative;
+
+    }
+
+    @Override
+    public Envelope assembleRequest() {
+        SetMessage m = new SetMessage();
+        m.statisticName = name;
+        m.subsystemName = subsystem;
+        m.value = value;
+        if (relative)
+            m.flags |= SETFLAG_RELATIVE;
+        if (persist)
+            m.flags |= SETFLAG_PERSIST;
+        return new Envelope(m);
+    }
+
+    public void cancel() {
+        //To change body of implemented methods use File | Settings | File Templates.
+    }
+}
diff --git a/src/main/java/org/gnunet/statistics/Statistics.java b/src/main/java/org/gnunet/statistics/Statistics.java
new file mode 100644
index 0000000..416db0c
--- /dev/null
+++ b/src/main/java/org/gnunet/statistics/Statistics.java
@@ -0,0 +1,310 @@
+/*
+ This file is part of GNUnet.
+ (C) 2011, 2012 Christian Grothoff (and other contributing authors)
+
+ GNUnet is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published
+ by the Free Software Foundation; either version 3, or (at your
+ option) any later version.
+
+ GNUnet is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with GNUnet; see the file COPYING.  If not, write to the
+ Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA.
+ */
+
+/*
+ * The stuff below does nothing whatsoever, first milestone of
+ * this project is to implement the StatisticsService api
+ * 
+ */
+
+package org.gnunet.statistics;
+
+import org.gnunet.requests.MatchingRequestContainer;
+import org.gnunet.requests.SequentialRequestContainer;
+import org.gnunet.util.*;
+import org.gnunet.util.getopt.Argument;
+import org.gnunet.util.getopt.ArgumentAction;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * API for the GNUnet statistics service.
+ * <p/>
+ * Set, get and monitor statistics values, represented as unsigned 64bit integer.
+ * Note that {@literal long}, java's largest primitive type, can only store signed 64bit integers.
+ * With absolute operation, its negative values are interpreted as large numbers by the statistics api.
+ */
+public class  Statistics {
+    private static final Logger logger = LoggerFactory
+            .getLogger(Statistics.class);
+
+    /**
+     * Client connecting us to the statistics service.
+     */
+    private final Client client;
+
+    SequentialRequestContainer<SetRequest> set_requests;
+    SequentialRequestContainer<GetRequest> get_requests;
+    MatchingRequestContainer<Long,WatchRequest> watch_requests;
+
+    private boolean destroy_requested;
+
+    private long wid = 0;
+
+    public class StatisticsMessageReceiver extends RunaboutMessageReceiver {
+        public void visit(GetResponseMessage m) {
+            GetRequest r = get_requests.getRequest();
+            if (r != null)
+                    r.receiver.onReceive(m.subsystemName, m.statisticName, m.value);
+        }
+
+        public void visit(GetResponseEndMessage m) {
+            GetRequest r = get_requests.getRequest();
+            if (r != null)
+                r.receiver.onDone();
+            //noinspection ConstantConditions
+            if (get_requests != null)
+                get_requests.next();
+        }
+
+        public void visit(TestMessage m) {
+            System.out.println("got back TEST message");
+            client.disconnect();
+        }
+
+        public void visit(WatchResponseMessage wrm) {
+            WatchRequest r = watch_requests.getRequest((long) wrm.wid);
+            if (r != null) {
+                r.watcher.onReceive(r.subsystem, r.name, wrm.value);
+            }
+        }
+
+        @Override
+        public void handleError() {
+            if (!destroy_requested) {
+                client.reconnect();
+                get_requests.restart();
+                set_requests.restart();
+                watch_requests.restart();
+            }
+        }
+    }
+
+    public Statistics(Configuration cfg) {
+        client = new Client("statistics", cfg);
+        client.installReceiver(new StatisticsMessageReceiver());
+        get_requests = new SequentialRequestContainer<GetRequest>(client);
+        set_requests = new SequentialRequestContainer<SetRequest>(client);
+        watch_requests = new MatchingRequestContainer<Long, WatchRequest>(client);
+    }
+
+    /**
+     * Retrieve values from statistics.
+     * Only one instance of this request may be active simultaneously.
+     * Upon cancellation
+     *
+     * @param timeout      time after we give up and call receiver.onTimeout
+     * @param subsystem    the subsystem of interest
+     * @param name         name of the statistics value belongs to
+     * @param receiver     callback
+     * @return handle to cancel the request
+     */
+    public Cancelable get(RelativeTime timeout, final String subsystem, final String name,
+                          final StatisticsReceiver receiver) {
+        if (destroy_requested)
+            throw new AssertionError("already destroyed");
+        return get_requests.addRequest(new GetRequest(subsystem, name, receiver));
+    }
+
+    /**
+     * Sets a statistics value asynchronously.
+     *
+     * @param name    name of the entry
+     * @param value   desired value
+     * @param persist keep value even if the statistics service restarts
+     * @return a handle to cancel the request
+     */
+    public Cancelable set(final String subsystem, final String name, final long value, boolean persist) {
+        if (destroy_requested)
+            throw new AssertionError("already destroyed");
+        return set_requests.addRequest(new SetRequest(subsystem, name, value, false, persist));
+    }
+
+    /**
+     * Changes a statistics value asynchronously.
+     *
+     * @param name    name of the entry
+     * @param delta   relative difference to the old value
+     * @param persist keep value even if the statistics service restarts
+     * @return a handle to cancel the request
+     */
+    public Cancelable update(final String subsystem, final String name, final long delta, boolean persist) {
+        if (destroy_requested)
+            throw new AssertionError("already destroyed");
+        return set_requests.addRequest(new SetRequest(subsystem, name, delta, true, persist));
+    }
+
+    /**
+     * Receive updates about changing statistics values.
+     *
+     * @param subsystem the subsystem to watch
+     * @param name the value to watch
+     * @param watcher the object that receives the updates
+     * @return a handle to cancel the request
+     */
+    public Cancelable watch(final String subsystem, final String name, StatisticsWatcher watcher) {
+        if (destroy_requested)
+            throw new AssertionError("already destroyed");
+        WatchRequest r = new WatchRequest(subsystem, name, watcher);
+        return watch_requests.addRequest(wid++, r);
+    }
+
+    /**
+     * Destroy handle to the statistics service. Always finishes writing pending values.
+     */
+    public void destroy() {
+        destroy_requested = true;
+        client.send(new TestMessage());
+        // wait until the service responds
+        // TODO: or timeout
+        System.out.println("destroying statistics");
+    }
+
+
+    /**
+     * Statistics command line utility entry point
+     *
+     * @param args command line arguments
+     */
+    public static void main(String[] args) {
+        new Program(args) {
+            @Argument(
+                    shortname = "x",
+                    longname = "set",
+                    action = ArgumentAction.SET,
+                    description = "watch a value")
+            boolean set;
+            @Argument(
+                    shortname = "w",
+                    longname = "watch",
+                    action = ArgumentAction.SET,
+                    description = "set a value")
+            boolean watch;
+            @Argument(
+                    shortname = "n",
+                    longname = "name",
+                    action = ArgumentAction.STORE_STRING,
+                    argumentName = "NAME",
+                    description = "statistics name")
+            String statisticsName = "";
+            @Argument(
+                    shortname = "s",
+                    longname = "subsystem",
+                    argumentName = "SUBSYS",
+                    action = ArgumentAction.STORE_STRING,
+                    description = "subsystem name")
+            String subsystemName = "";
+            @Argument(
+                    shortname = "p",
+                    longname = "persistent",
+                    action = ArgumentAction.SET,
+                    description = "set value persistently (used with -x)")
+            boolean persistent = false;
+            @Argument(
+                    shortname = "r",
+                    longname = "relative",
+                    action = ArgumentAction.SET,
+                    description = "set value relative to old value (used with -x)")
+            boolean relative = false;
+
+            @Override
+            protected String makeHelpText() {
+                return "Get, set and watch GNUnet's statistics.";
+            }
+
+            public void run() {
+                final Statistics statistics = new Statistics(cfg);
+
+                if (set && watch) {
+                    System.err.println("--watch/-w and --set/-s cannot be used together");
+                    return;
+                }
+
+                if (set) {
+                    if (subsystemName.isEmpty() || statisticsName.isEmpty()) {
+                        System.err.println("both subsystem and name must be given for --set/-x");
+                        return;
+                    }
+                    if (unprocessedArgs.length != 1) {
+                        System.err.println("must specify exactly one value to set");
+                        return;
+                    }
+                    long value;
+                    try {
+                        value = Long.parseLong(unprocessedArgs[0]);
+                    } catch (NumberFormatException e) {
+                        System.err.println("invalid value (not a long)");
+                        return;
+                    }
+                    if (relative)
+                        statistics.update(subsystemName, statisticsName, value, persistent);
+                     else
+                        statistics.set(subsystemName, statisticsName, value, persistent);
+                    statistics.destroy();
+                    return;
+                }
+
+                if (unprocessedArgs.length != 0) {
+                    System.err.println("dumping statistics does not take any positional parameters");
+                    return;
+                }
+
+                if (watch) {
+                    if (subsystemName.isEmpty() || statisticsName.isEmpty()) {
+                        System.err.println("both subsystem and name must be given for --watch/-w");
+                        return;
+                    }
+                    statistics.watch(subsystemName, statisticsName,
+                            new StatisticsWatcher() {
+                                @Override
+                                public void onReceive(String subsystem, String name, long value) {
+                                    System.out.println(subsystem + "(" + name + ") = " + value);
+                                }
+
+                                @Override
+                                public void onTimeout() {
+                                   System.err.println("timeout");
+                                }
+                            }
+                    );
+                } else {
+                    statistics.get(RelativeTime.SECOND, subsystemName, statisticsName,
+                            new StatisticsReceiver() {
+                                @Override
+                                public void onReceive(String subsystem, String name, long value) {
+                                    System.out.println(subsystem + "(" + name + ") = " + value);
+                                }
+
+                                @Override
+                                public void onTimeout() {
+                                    System.err.println("timeout");
+                                }
+
+                                @Override
+                                public void onDone() {
+                                    statistics.destroy();
+                                }
+                            }
+                    );
+                }
+            }
+        }.start();
+    }
+}
diff --git a/src/org/gnunet/statistics/StatisticsReceiver.java b/src/main/java/org/gnunet/statistics/StatisticsReceiver.java
index 87fbdd6..0c25acc 100644
--- a/src/org/gnunet/statistics/StatisticsReceiver.java
+++ b/src/main/java/org/gnunet/statistics/StatisticsReceiver.java
@@ -24,4 +24,6 @@ package org.gnunet.statistics;
 
 public interface StatisticsReceiver {
     public void onReceive(String subsystem, String name, long value);
+    public void onTimeout();
+    public void onDone();
 }
diff --git a/src/main/java/org/gnunet/statistics/StatisticsWatcher.java b/src/main/java/org/gnunet/statistics/StatisticsWatcher.java
new file mode 100644
index 0000000..d3fb645
--- /dev/null
+++ b/src/main/java/org/gnunet/statistics/StatisticsWatcher.java
@@ -0,0 +1,13 @@
+package org.gnunet.statistics;
+
+/**
+ * Created with IntelliJ IDEA.
+ * User: dold
+ * Date: 8/24/13
+ * Time: 5:56 PM
+ * To change this template use File | Settings | File Templates.
+ */
+public interface StatisticsWatcher {
+    public void onReceive(String subsystem, String name, long value);
+    public void onTimeout();
+}
diff --git a/src/org/gnunet/statistics/WatchMessage.java b/src/main/java/org/gnunet/statistics/WatchMessage.java
index 814f263..814f263 100644
--- a/src/org/gnunet/statistics/WatchMessage.java
+++ b/src/main/java/org/gnunet/statistics/WatchMessage.java
diff --git a/src/main/java/org/gnunet/statistics/WatchRequest.java b/src/main/java/org/gnunet/statistics/WatchRequest.java
new file mode 100644
index 0000000..49e1615
--- /dev/null
+++ b/src/main/java/org/gnunet/statistics/WatchRequest.java
@@ -0,0 +1,31 @@
+package org.gnunet.statistics;
+
+import org.gnunet.mq.Envelope;
+import org.gnunet.mq.MessageQueue;
+import org.gnunet.requests.RequestContainer;
+
+/**
+ */
+public class WatchRequest extends RequestContainer.Request {
+    public String subsystem;
+    public String name;
+    public StatisticsWatcher watcher;
+
+    public WatchRequest(String subsystem, String name, StatisticsWatcher watcher) {
+        this.subsystem = subsystem;
+        this.name = name;
+        this.watcher = watcher;
+    }
+
+    @Override
+    public Envelope assembleRequest() {
+        WatchMessage m = new WatchMessage();
+        m.statisticsName = name;
+        m.subsystemName = subsystem;
+        return new Envelope(m);
+    }
+
+    public void cancel() {
+
+    }
+}
diff --git a/src/org/gnunet/statistics/WatchResponseMessage.java b/src/main/java/org/gnunet/statistics/WatchResponseMessage.java
index 19c56b5..19c56b5 100644
--- a/src/org/gnunet/statistics/WatchResponseMessage.java
+++ b/src/main/java/org/gnunet/statistics/WatchResponseMessage.java
diff --git a/src/org/gnunet/statistics/package-info.java b/src/main/java/org/gnunet/statistics/package-info.java
index fce59e7..fce59e7 100644
--- a/src/org/gnunet/statistics/package-info.java
+++ b/src/main/java/org/gnunet/statistics/package-info.java
diff --git a/src/main/java/org/gnunet/testbed/Controller.java b/src/main/java/org/gnunet/testbed/Controller.java
new file mode 100644
index 0000000..7372986
--- /dev/null
+++ b/src/main/java/org/gnunet/testbed/Controller.java
@@ -0,0 +1,84 @@
+package org.gnunet.testbed;
+
+import org.gnunet.util.Client;
+import org.gnunet.util.Configuration;
+
+/**
+ * Handle to interact with a GNUnet testbed controller.  Each
+ * controller has at least one master handle which is created when the
+ * controller is created; this master handle interacts with the
+ * controller process, destroying it destroys the controller (by
+ * closing stdin of the controller process).  Additionally,
+ * controllers can interact with each other (in a P2P fashion); those
+ * links are established via TCP/IP on the controller's service port.
+ */
+public class Controller {
+
+    /**
+     * Client connecting to the testbed service.
+     */
+    Client client;
+
+    /**
+     * Connect to a controller process.  The configuration to use for the connection
+     * is retreived from the given host where a controller is started using
+     * GNUNET_TESTBED_controller_start().
+     *
+     * @param host host to run the controller on; This should be the same host if
+     *          the controller was previously started with
+     *          GNUNET_TESTBED_controller_start()
+     * @param event_mask bit mask with set of events to call 'cc' for;
+     *                   or-ed values of "1LL" shifted by the
+     *                   respective 'enum GNUNET_TESTBED_EventType'
+     *                   (i.e.  "(1LL << GNUNET_TESTBED_ET_CONNECT) | ...")
+     * @param cb controller callback to invoke on events
+     */
+    public Controller(Host host, long event_mask, ControllerEventCallback cb) {
+        client = new Client("testbed", host.cfg);
+    }
+
+
+    /**
+     * Create the given peer at the specified host using the given
+     * controller.  If the given controller is not running on the target
+     * host, it should find or create a controller at the target host and
+     * delegate creating the peer.  Explicit delegation paths can be setup
+     * using 'GNUNET_TESTBED_controller_link'.  If no explicit delegation
+     * path exists, a direct link with a subordinate controller is setup
+     * for the first delegated peer to a particular host; the subordinate
+     * controller is then destroyed once the last peer that was delegated
+     * to the remote host is stopped.
+     *
+     * Creating the peer only creates the handle to manipulate and further
+     * configure the peer; use "GNUNET_TESTBED_peer_start" and
+     * "GNUNET_TESTBED_peer_stop" to actually start/stop the peer's
+     * processes.
+     *
+     * Note that the given configuration will be adjusted by the
+     * controller to avoid port/path conflicts with other peers.
+     * The "final" configuration can be obtained using
+     * 'GNUNET_TESTBED_peer_get_information'.
+     *
+     * @param host host to run the peer on; cannot be NULL
+     * @param cfg Template configuration to use for the peer. Should exist until
+     *          operation is cancelled or GNUNET_TESTBED_operation_done() is called
+     * @param cb the callback to call when the peer has been created
+     * @return the operation handle
+     */
+
+    public Operation createPeer(Host host, Configuration cfg, PeerCreateCallback cb) {
+        return null;
+    }
+
+
+    /**
+     * Stop the given controller (also will terminate all peers and
+     * controllers dependent on this controller).  This function
+     * blocks until the testbed has been fully terminated (!).
+     */
+    public void disconnect () {
+
+    }
+
+
+}
diff --git a/src/main/java/org/gnunet/testbed/ControllerEventCallback.java b/src/main/java/org/gnunet/testbed/ControllerEventCallback.java
new file mode 100644
index 0000000..099977f
--- /dev/null
+++ b/src/main/java/org/gnunet/testbed/ControllerEventCallback.java
@@ -0,0 +1,21 @@
+package org.gnunet.testbed;
+
+
+
+public abstract class ControllerEventCallback {
+    void onPeerStart() {
+        throw new AssertionError("event not handled");
+    }
+    void onPeerStop() {
+        throw new AssertionError("event not handled");
+    }
+    void onPeerConnect() {
+        throw new AssertionError("event not handled");
+    }
+    void onPeerDisconnect() {
+        throw new AssertionError("event not handled");
+    }
+    void onOperationFinished() {
+        throw new AssertionError("event not handled");
+    }
+}
diff --git a/src/main/java/org/gnunet/testbed/ControllerInitMessage.java b/src/main/java/org/gnunet/testbed/ControllerInitMessage.java
new file mode 100644
index 0000000..95114d7
--- /dev/null
+++ b/src/main/java/org/gnunet/testbed/ControllerInitMessage.java
@@ -0,0 +1,30 @@
+package org.gnunet.testbed;
+
+
+import org.gnunet.construct.UInt32;
+import org.gnunet.construct.UInt64;
+import org.gnunet.construct.UnionCase;
+import org.gnunet.construct.ZeroTerminatedString;
+import org.gnunet.util.GnunetMessage;
+
+@UnionCase(460)
+public class ControllerInitMessage implements GnunetMessage.Body {
+    /**
+     * Host ID that the controller is either given (if this is the
+     * dominating client) or assumed to have (for peer-connections
+     * between controllers).  A controller must check that all
+     * connections make consistent claims...
+     */
+    @UInt32
+    public int host_id;
+
+    /**
+     * Event mask that specifies which events this client is interested in.
+     */
+    @UInt64
+    public long event_mask;
+
+    @ZeroTerminatedString
+    public String controler_hostname;
+
+}
diff --git a/src/main/java/org/gnunet/testbed/ControllerProc.java b/src/main/java/org/gnunet/testbed/ControllerProc.java
new file mode 100644
index 0000000..9eaca2c
--- /dev/null
+++ b/src/main/java/org/gnunet/testbed/ControllerProc.java
@@ -0,0 +1,89 @@
+package org.gnunet.testbed;
+
+import com.google.common.base.Charsets;
+import org.gnunet.util.Helper;
+import org.gnunet.util.RunaboutMessageReceiver;
+
+import java.io.ByteArrayOutputStream;
+import java.util.zip.Deflater;
+
+/**
+ * A controller process.
+ * The controller process is either a local helper process, or an ssh process that starts and controls
+ * the testbed helper on a remote machine.
+ */
+public class ControllerProc {
+    final Helper helper;
+
+
+    public class ControllerProcReceiver extends RunaboutMessageReceiver {
+        public void visit(HelperReplyMessage m) {
+
+        }
+        @Override
+        public void handleError() {
+
+        }
+    }
+
+    /**
+     * Starts a controller process at the given host.  The given host's configration
+     * is used as a Template configuration to use for the remote controller; the
+     * remote controller will be started with a slightly modified configuration
+     * (port numbers, unix domain sockets and service home values are changed as per
+     * TESTING library on the remote host).  The modified configuration replaces the
+     * host's existing configuration before signalling success through the
+     * GNUNET_TESTBED_ControllerStatusCallback()
+     *
+     * @param trustedIP the ip address of the controller which will be set as TRUSTED
+     *          HOST(all connections form this ip are permitted by the testbed) when
+     *          starting testbed controller at host. This can either be a single ip
+     *          address or a network address in CIDR notation.
+     * @param host the host where the controller has to be started.  CANNOT be NULL.
+     * @param cb function called when the controller is successfully started or
+     *          dies unexpectedly; GNUNET_TESTBED_controller_stop shouldn't be
+     *          called if cb is called with GNUNET_SYSERR as status. Will never be
+     *          called in the same task as 'GNUNET_TESTBED_controller_start'
+     *          (synchronous errors will be signalled by returning NULL). This
+     *          parameter cannot be NULL.
+     */
+    public ControllerProc(String trustedIP, Host host, ControllerStatusCallback cb) {
+        if (host.isLocal()) {
+            helper = new Helper(false, "gnunet-testbed-helper", null, new ControllerProcReceiver());
+        } else {
+            throw new AssertionError("not implemented yet");
+        }
+    }
+
+
+    private HelperInitMessage makeHelperInitMessage(String trustedIP, Host host) {
+        HelperInitMessage m = new HelperInitMessage();
+        if (host.hostname == null) {
+            m.hostname = null;
+            m.hostname_size = 0;
+        } else {
+            m.hostname_size =  host.hostname.length();
+            m.hostname = host.hostname.getBytes(Charsets.UTF_8);
+        }
+        m.trusted_ip_size = trustedIP.length();
+        m.trusted_ip = trustedIP;
+
+        byte[] serialized_config = host.cfg.serialize().getBytes();
+
+        Deflater compresser = new Deflater();
+        compresser.setInput(serialized_config);
+        compresser.finish();
+
+        ByteArrayOutputStream s = new ByteArrayOutputStream();
+        byte[] buf = new byte[1024];
+        while (!compresser.finished()) {
+            int n = compresser.deflate(buf);
+            s.write(buf, 0, n);
+        }
+
+        m.compressed_config = s.toByteArray();
+        m.config_size = serialized_config.length;
+
+        return m;
+    }
+}
diff --git a/src/main/java/org/gnunet/testbed/ControllerStatusCallback.java b/src/main/java/org/gnunet/testbed/ControllerStatusCallback.java
new file mode 100644
index 0000000..ba9e56f
--- /dev/null
+++ b/src/main/java/org/gnunet/testbed/ControllerStatusCallback.java
@@ -0,0 +1,9 @@
+package org.gnunet.testbed;
+
+
+import org.gnunet.util.Configuration;
+
+public interface ControllerStatusCallback {
+    void onStartupSuccess(Configuration cfg);
+    void onStartupFailure();
+}
diff --git a/src/main/java/org/gnunet/testbed/HelperInitMessage.java b/src/main/java/org/gnunet/testbed/HelperInitMessage.java
new file mode 100644
index 0000000..29d8bb6
--- /dev/null
+++ b/src/main/java/org/gnunet/testbed/HelperInitMessage.java
@@ -0,0 +1,37 @@
+package org.gnunet.testbed;
+
+import org.gnunet.construct.*;
+import org.gnunet.util.GnunetMessage;
+
+/**
+ * Initialization message for gnunet-helper-testbed to start testbed service
+ */
+@UnionCase(495)
+public class HelperInitMessage implements GnunetMessage.Body {
+    /**
+     * The controller hostname size excluding the NULL termination character -
+     * strlen (hostname); cannot be zero
+     */
+    @UInt16
+    int trusted_ip_size;
+    /**
+     * The hostname size excluding the NULL termination character - strlen
+     * (hostname); cannot be zero
+     */
+    @UInt16
+    int hostname_size;
+    /**
+     * The size of the uncompressed configuration
+     */
+    @UInt16
+    public int config_size;
+
+    @ZeroTerminatedString(optional = true)
+    public String trusted_ip;
+
+    @VariableSizeIntegerArray(signed = true, bitSize = 8, lengthField = "hostname_size")
+    public byte[] hostname;
+
+    @FillWith @UInt8
+    public byte[] compressed_config;
+}
diff --git a/src/main/java/org/gnunet/testbed/HelperReplyMessage.java b/src/main/java/org/gnunet/testbed/HelperReplyMessage.java
new file mode 100644
index 0000000..bb50860
--- /dev/null
+++ b/src/main/java/org/gnunet/testbed/HelperReplyMessage.java
@@ -0,0 +1,17 @@
+package org.gnunet.testbed;
+
+
+import org.gnunet.construct.FillWith;
+import org.gnunet.construct.UInt16;
+import org.gnunet.construct.UInt8;
+import org.gnunet.construct.UnionCase;
+import org.gnunet.util.GnunetMessage;
+
+@UnionCase(496)
+public class HelperReplyMessage implements GnunetMessage.Body {
+    @UInt16
+    int uncompressed_config_size;
+
+    @FillWith @UInt8
+    byte[] compressed_config;
+}
diff --git a/src/main/java/org/gnunet/testbed/Host.java b/src/main/java/org/gnunet/testbed/Host.java
new file mode 100644
index 0000000..fb89028
--- /dev/null
+++ b/src/main/java/org/gnunet/testbed/Host.java
@@ -0,0 +1,51 @@
+package org.gnunet.testbed;
+
+import org.gnunet.util.Configuration;
+
+/**
+ * Opaque handle to a host running experiments managed by the testing framework.
+ * The master process must be able to SSH to this host without password (via
+ * ssh-agent).
+ */
+public class Host {
+    static int nextUID = 1;
+    final Configuration cfg;
+    final String hostname;
+    final String username;
+    final int port;
+
+    private boolean controllerStarted;
+
+    /**
+     * Create a host to run peers and controllers on.
+     *
+     * @param hostname name of the host, use "NULL" for localhost
+     * @param username username to use for the login; may be NULL
+     * @param cfg the configuration to use as a template while starting a controller
+     *          on this host.  Operation queue sizes specific to a host are also
+     *          read from this configuration handle
+     * @param port port number to use for ssh; use 0 to let ssh decide
+     */
+    public Host(String hostname, String username, Configuration cfg, int port) {
+        this.port = (port == 0) ? 22 : port;
+        this.hostname = hostname;
+        this.username = username;
+        this.cfg = cfg;
+    }
+
+    /**
+     * Create a host handle for the local machine.
+     *
+     * @param cfg the configuration to use as a template while starting a controller
+     *          on this host.  Operation queue sizes specific to a host are also
+     *          read from this configuration handle
+     * @param port port number to use for ssh; use 0 to let ssh decide
+     */
+    public Host(Configuration cfg, int port) {
+        this(null, null, cfg, port);
+    }
+
+    public boolean isLocal() {
+        return hostname == null;
+    }
+}
diff --git a/src/main/java/org/gnunet/testbed/Operation.java b/src/main/java/org/gnunet/testbed/Operation.java
new file mode 100644
index 0000000..4403540
--- /dev/null
+++ b/src/main/java/org/gnunet/testbed/Operation.java
@@ -0,0 +1,11 @@
+package org.gnunet.testbed;
+
+/**
+ * Created with IntelliJ IDEA.
+ * User: dold
+ * Date: 8/25/13
+ * Time: 1:26 PM
+ * To change this template use File | Settings | File Templates.
+ */
+public interface Operation {
+}
diff --git a/src/main/java/org/gnunet/testbed/OperationCompletionCallback.java b/src/main/java/org/gnunet/testbed/OperationCompletionCallback.java
new file mode 100644
index 0000000..413be06
--- /dev/null
+++ b/src/main/java/org/gnunet/testbed/OperationCompletionCallback.java
@@ -0,0 +1,11 @@
+package org.gnunet.testbed;
+
+/**
+ * Created with IntelliJ IDEA.
+ * User: dold
+ * Date: 8/25/13
+ * Time: 1:35 PM
+ * To change this template use File | Settings | File Templates.
+ */
+public interface OperationCompletionCallback {
+}
diff --git a/src/main/java/org/gnunet/testbed/Peer.java b/src/main/java/org/gnunet/testbed/Peer.java
new file mode 100644
index 0000000..f9cfc3e
--- /dev/null
+++ b/src/main/java/org/gnunet/testbed/Peer.java
@@ -0,0 +1,57 @@
+package org.gnunet.testbed;
+
+import org.gnunet.util.Configuration;
+
+/**
+ * Opaque handle to a peer controlled by the testbed framework.  A peer runs
+ * at a particular host.
+ */
+public class Peer {
+    public Operation start(PeerChurnCallback peerChurnCallback) {
+        return null;
+    }
+
+    public Operation stop(PeerChurnCallback peerChurnCallback) {
+        return null;
+    }
+
+    public Operation getInformation() {
+        return null;
+    }
+
+    /*
+     * Change peer configuration.  Must only be called while the
+     * peer is stopped.  Ports and paths cannot be changed this
+     * way.
+     */
+    public Operation updateConfiguration(Configuration cfg) {
+        return null;
+    }
+
+    /*
+     * Change peer configuration.  Must only be called while the
+     * peer is stopped.  Ports and paths cannot be changed this
+     * way.
+     */
+    public Operation destroy() {
+        return null;
+    }
+
+    public Operation manageService(String serviceName, boolean start) {
+        return null;
+    }
+
+    /**
+     * Both peers must have been started before calling this function.
+     * This function then obtains a HELLO from this peer, gives it to 'otherPeer'
+     * and asks 'otherPeer' to connect to this peer..
+     */
+    public Operation connectOverlay(OperationCompletionCallback cb, Peer otherPeer) {
+        return null;
+    }
+
+    public Operation getServiceConnection(String serviceName /*,... */) {
+        return null;
+    }
+
+}
diff --git a/src/main/java/org/gnunet/testbed/PeerChurnCallback.java b/src/main/java/org/gnunet/testbed/PeerChurnCallback.java
new file mode 100644
index 0000000..a5dacbd
--- /dev/null
+++ b/src/main/java/org/gnunet/testbed/PeerChurnCallback.java
@@ -0,0 +1,7 @@
+package org.gnunet.testbed;
+
+
+public interface PeerChurnCallback {
+    void onChurnSuccess();
+    void onChurnError(String emsg);
+}
diff --git a/src/main/java/org/gnunet/testbed/PeerCreateCallback.java b/src/main/java/org/gnunet/testbed/PeerCreateCallback.java
new file mode 100644
index 0000000..b6100f6
--- /dev/null
+++ b/src/main/java/org/gnunet/testbed/PeerCreateCallback.java
@@ -0,0 +1,7 @@
+package org.gnunet.testbed;
+
+
+public interface PeerCreateCallback {
+    void onPeerCreated(Peer peer);
+    void onError(String errorMessage);
+}
diff --git a/src/main/java/org/gnunet/testing/TestingFixture.java b/src/main/java/org/gnunet/testing/TestingFixture.java
new file mode 100644
index 0000000..4303512
--- /dev/null
+++ b/src/main/java/org/gnunet/testing/TestingFixture.java
@@ -0,0 +1,21 @@
+package org.gnunet.testing;
+
+import org.gnunet.util.Scheduler;
+import org.junit.After;
+import org.junit.Before;
+
+/**
+ * Default JUnit4 fixture methods for gnunet-java tests.
+ * Resets the scheduler properly.
+ */
+public class TestingFixture {
+    @Before
+    public void beginGNJTest() {
+        Scheduler.forceReset();
+    }
+
+    @After
+    public void endGNJTest() {
+        Scheduler.forceReset();
+    }
+}
diff --git a/src/org/gnunet/testing/TestingServer.java b/src/main/java/org/gnunet/testing/TestingServer.java
index 97b6bc0..97b6bc0 100644
--- a/src/org/gnunet/testing/TestingServer.java
+++ b/src/main/java/org/gnunet/testing/TestingServer.java
diff --git a/src/org/gnunet/testing/TestingSetup.java b/src/main/java/org/gnunet/testing/TestingSetup.java
index 6f8d578..6f8d578 100644
--- a/src/org/gnunet/testing/TestingSetup.java
+++ b/src/main/java/org/gnunet/testing/TestingSetup.java
diff --git a/src/org/gnunet/testing/TestingSubsystem.java b/src/main/java/org/gnunet/testing/TestingSubsystem.java
index 29de0bc..da7f2e4 100644
--- a/src/org/gnunet/testing/TestingSubsystem.java
+++ b/src/main/java/org/gnunet/testing/TestingSubsystem.java
@@ -51,7 +51,7 @@ public class TestingSubsystem {
 
     public TestingSubsystem(String service) {
         try {
-            p = Runtime.getRuntime().exec(new String[]{"gnunet-testing-run-service", "-s", service});
+            p = Runtime.getRuntime().exec(new String[]{"gnunet-testing", "-r", service});
         } catch (IOException e) {
             throw new TestingSetup.SetupException(e);
         }
@@ -101,23 +101,13 @@ public class TestingSubsystem {
         } catch (IOException e) {
             throw new TestingSetup.SetupException(e);
         }
-        String line;
-        try {
-            line = reader.readLine();
-        } catch (IOException e) {
-            throw new TestingSetup.SetupException(e);
-        }
-        if (line == null || !line.equals("bye")) {
-            throw new TestingSetup.SetupException("service not destroyed correctly");
-        }
-        System.out.println("read bye");
         try {
             p.waitFor();
         } catch (InterruptedException e) {
             throw new TestingSetup.SetupException(e);
         }
         if (p.exitValue() != 0) {
-            throw new TestingSetup.SetupException("gnunet-testing-run-service exit value unsuccessful");
+            throw new TestingSetup.SetupException("gnunet-testing exit value unsuccessful");
         }
     }
 
@@ -129,7 +119,7 @@ public class TestingSubsystem {
             throw new TestingSetup.SetupException(e);
         }
         String response;
-        logger.debug("waiting for gnunet-testing-run-service to respond to restart");
+        logger.debug("waiting for gnunet-testing to respond to restart");
         try {
             response = reader.readLine();
         } catch (IOException e) {
diff --git a/src/org/gnunet/testing/package-info.java b/src/main/java/org/gnunet/testing/package-info.java
index 1a91586..1a91586 100644
--- a/src/org/gnunet/testing/package-info.java
+++ b/src/main/java/org/gnunet/testing/package-info.java
diff --git a/src/main/java/org/gnunet/transport/AddressIterateMessage.java b/src/main/java/org/gnunet/transport/AddressIterateMessage.java
new file mode 100644
index 0000000..59ea6a8
--- /dev/null
+++ b/src/main/java/org/gnunet/transport/AddressIterateMessage.java
@@ -0,0 +1,34 @@
+package org.gnunet.transport;
+
+
+import org.gnunet.construct.NestedMessage;
+import org.gnunet.construct.UInt32;
+import org.gnunet.construct.UnionCase;
+import org.gnunet.util.AbsoluteTime;
+import org.gnunet.util.PeerIdentity;
+
+
+/**
+ * Message from the client to the transport service
+ * asking for binary addresses known for a peer.
+ */
+@UnionCase(380)
+public class AddressIterateMessage {
+    /**
+     * One shot call or continous replies?
+     */
+    @UInt32
+    public int one_shot;
+
+    /**
+     * FIXME: This field seems to be deprecated in the C API?
+     */
+    @NestedMessage
+    public AbsoluteTime timeout;
+
+    /**
+     * The identity of the peer to look up.
+     */
+    @NestedMessage
+    public PeerIdentity peer;
+}
diff --git a/src/main/java/org/gnunet/transport/BlacklistCallback.java b/src/main/java/org/gnunet/transport/BlacklistCallback.java
new file mode 100644
index 0000000..b763dec
--- /dev/null
+++ b/src/main/java/org/gnunet/transport/BlacklistCallback.java
@@ -0,0 +1,12 @@
+package org.gnunet.transport;
+
+import org.gnunet.util.PeerIdentity;
+
+/**
+ * ...
+ *
+ * @author Florian Dold
+ */
+public interface BlacklistCallback {
+    boolean isAllowed(PeerIdentity peerIdentity);
+}
diff --git a/src/main/java/org/gnunet/transport/BlacklistInitMessage.java b/src/main/java/org/gnunet/transport/BlacklistInitMessage.java
new file mode 100644
index 0000000..be3209e
--- /dev/null
+++ b/src/main/java/org/gnunet/transport/BlacklistInitMessage.java
@@ -0,0 +1,9 @@
+package org.gnunet.transport;
+
+import org.gnunet.construct.UnionCase;
+import org.gnunet.util.GnunetMessage;
+
+@UnionCase(369)
+public class BlacklistInitMessage implements GnunetMessage.Body {
+    // message body is empty
+}
diff --git a/src/org/gnunet/transport/HelloUpdateCallback.java b/src/main/java/org/gnunet/transport/HelloUpdateCallback.java
index d5253b7..d5253b7 100644
--- a/src/org/gnunet/transport/HelloUpdateCallback.java
+++ b/src/main/java/org/gnunet/transport/HelloUpdateCallback.java
diff --git a/src/main/java/org/gnunet/transport/PeerIterateCallback.java b/src/main/java/org/gnunet/transport/PeerIterateCallback.java
new file mode 100644
index 0000000..25bea5a
--- /dev/null
+++ b/src/main/java/org/gnunet/transport/PeerIterateCallback.java
@@ -0,0 +1,12 @@
+package org.gnunet.transport;
+
+import org.gnunet.util.PeerIdentity;
+
+/**
+ * ...
+ *
+ * @author Florian Dold
+ */
+public interface PeerIterateCallback {
+    void processPeerAddress(PeerIdentity peer, Object hello);
+}
diff --git a/src/org/gnunet/transport/RequestConnectMessage.java b/src/main/java/org/gnunet/transport/RequestConnectMessage.java
index 63bbc39..63bbc39 100644
--- a/src/org/gnunet/transport/RequestConnectMessage.java
+++ b/src/main/java/org/gnunet/transport/RequestConnectMessage.java
diff --git a/src/org/gnunet/transport/StartMessage.java b/src/main/java/org/gnunet/transport/StartMessage.java
index 2169565..2169565 100644
--- a/src/org/gnunet/transport/StartMessage.java
+++ b/src/main/java/org/gnunet/transport/StartMessage.java
diff --git a/src/org/gnunet/transport/Transport.java b/src/main/java/org/gnunet/transport/Transport.java
index 5ccbc77..b9881b6 100644
--- a/src/org/gnunet/transport/Transport.java
+++ b/src/main/java/org/gnunet/transport/Transport.java
@@ -2,6 +2,7 @@ package org.gnunet.transport;
 
 import org.gnunet.hello.HelloMessage;
 import org.gnunet.mq.Envelope;
+import org.gnunet.mq.NotifySentHandler;
 import org.gnunet.util.*;
 
 /**
@@ -11,8 +12,35 @@ import org.gnunet.util.*;
  */
 public class Transport {
 
-    public Transport(Configuration cfg) {
+    /**
+     * Client that connects to the transport service,
+     */
+    private final Client client;
 
+    boolean init_requested;
+
+    /**
+     * Blacklist callback, null if there is no active blacklist
+     * for this handle.
+     */
+    BlacklistCallback blacklistCallback;
+
+    private final class TransportReceiver extends RunaboutMessageReceiver {
+        @Override
+        public void handleError() {
+            client.reconnect();
+            // FIXME: complete
+        }
+    }
+
+    /**
+     * Create a handle to the transport service.
+     *
+     * @param cfg configuration to use for connecting
+     */
+    public Transport(Configuration cfg) {
+        client = new Client("transport", cfg);
+        client.installReceiver(new TransportReceiver());
     }
 
     /**
@@ -22,16 +50,20 @@ public class Transport {
      * @param target who we should try to connect to
      * @param cb     callback to be called when request was transmitted to transport
      *               service
-     * @return a GNUNET_TRANSPORT_TryConnectHandle handle or
-     *         NULL on failure (cb will not be called)
+     * @return a handle to cancel the operation
      */
-    Cancelable tryConnect(PeerIdentity target, TryConnectCallback cb) {
+    Cancelable tryConnect(PeerIdentity target, final TryConnectCallback cb) {
         RequestConnectMessage m = new RequestConnectMessage();
         m.peer = target;
         m.reserved = 0;
         final Envelope ev = new Envelope(m);
-        ev.notifySent(null /* FIXME */);
-        //client_mq.send(ev);
+        ev.notifySent(new NotifySentHandler() {
+            @Override
+            public void onSent() {
+                cb.onDone();
+            }
+        });
+        client.send(ev);
 
         return new Cancelable() {
             @Override
@@ -41,6 +73,13 @@ public class Transport {
         };
     }
 
+    /**
+     * ... (discuss first)
+     */
+    public void init(Object receiveCallback, Object notifyConnect, Object notifyDisconnect) {
+
+    }
+
 
     /**
      * Obtain the HELLO message for this peer.
@@ -76,39 +115,40 @@ public class Transport {
     /**
      * Install a blacklist callback.  The service will be queried for all
      * existing connections as well as any fresh connections to check if
-     * they are permitted.  If the blacklisting callback is unregistered,
+     * they are permitted.
+     * The blacklist is active until the Transport handle is destroyed.
+     * When the transport handle that installed the blacklist is destroyed,
      * all hosts that were denied in the past will automatically be
-     * whitelisted again.  Cancelling the blacklist handle is also the
-     * only way to re-enable connections from peers that were previously
-     * blacklisted.
+     * whitelisted again.  This is the only way to re-enable
+     * connections from peers that were previously blacklisted.
      *
-     * @param cfg configuration to use
-     * @param cb  callback to invoke to check if connections are allowed
-     * @return NULL on error, otherwise handle for cancellation
+     * @param blacklistCallback  callback to invoke to check if connections are allowed
      */
-    static Cancelable blacklist(Configuration cfg,
-                                BlacklistCallback cb) {
-        throw new UnsupportedOperationException();
+    public void blacklist(BlacklistCallback blacklistCallback) {
+        if (this.blacklistCallback != null)
+            throw new AssertionError("there is already a blacklist");
+        if (blacklistCallback == null)
+            throw new AssertionError("blacklist callback may not be null");
+        this.blacklistCallback = blacklistCallback;
+        client.send(new BlacklistInitMessage());
     }
 
     /**
      * Return all the known addresses for a specific peer or all peers.
-     * Returns continuously all address if one_shot is set to GNUNET_NO
+     * Returns continuously all address if one_shot is set to false
      * <p/>
-     * CHANGE: Returns the address(es) that we are currently using for this
+     * Returns the address(es) that we are currently using for this
      * peer.  Upon completion, the 'AddressLookUpCallback' is called one more
      * time with 'NULL' for the address and the peer.  After this, the operation must no
      * longer be explicitly canceled.
      *
-     * @param cfg                       configuration to use
      * @param peer                      peer identity to look up the addresses of, CHANGE: allow NULL for all (connected) peers
      * @param one_shot                  GNUNET_YES to return the current state and then end (with NULL+NULL),
      *                                  GNUNET_NO to monitor the set of addresses used (continuously, must be explicitly canceled)
      * @param timeout                   how long is the lookup allowed to take at most (irrelevant if one_shot is set to GNUNET_NO)
      * @param peer_address_callback     function to call with the results
      */
-    Cancelable
-    peer_get_active_addresses(Configuration cfg, PeerIdentity peer, int one_shot,
+    Cancelable getActiveAddresses(PeerIdentity peer, int one_shot,
                               RelativeTime timeout, PeerIterateCallback peer_address_callback) {
         throw new UnsupportedOperationException();
     }
diff --git a/src/org/gnunet/transport/TryConnectCallback.java b/src/main/java/org/gnunet/transport/TryConnectCallback.java
index 93c0f76..41e743b 100644
--- a/src/org/gnunet/transport/TryConnectCallback.java
+++ b/src/main/java/org/gnunet/transport/TryConnectCallback.java
@@ -5,5 +5,6 @@ package org.gnunet.transport;
  *
  * @author Florian Dold
  */
-public class TryConnectCallback {
+public interface TryConnectCallback {
+    void onDone();
 }
diff --git a/src/org/gnunet/util/ATSInformation.java b/src/main/java/org/gnunet/util/ATSInformation.java
index b93931b..b93931b 100644
--- a/src/org/gnunet/util/ATSInformation.java
+++ b/src/main/java/org/gnunet/util/ATSInformation.java
diff --git a/src/org/gnunet/util/AbsoluteTime.java b/src/main/java/org/gnunet/util/AbsoluteTime.java
index 06f41ac..9d22d36 100644
--- a/src/org/gnunet/util/AbsoluteTime.java
+++ b/src/main/java/org/gnunet/util/AbsoluteTime.java
@@ -51,7 +51,7 @@ public class AbsoluteTime implements Comparable<AbsoluteTime> {
      * @return the current time
      */
     public static AbsoluteTime now() {
-        return new AbsoluteTime(System.currentTimeMillis());
+        return new AbsoluteTime(System.currentTimeMillis() * 1000);
     }
 
     public AbsoluteTime(final long abs_value_us) {
@@ -264,6 +264,6 @@ public class AbsoluteTime implements Comparable<AbsoluteTime> {
     }
 
     public Date toDate() {
-        return new Date(abs_value_us);
+        return new Date(abs_value_us / 1000);
     }
 }
diff --git a/src/org/gnunet/util/AbsoluteTimeMessage.java b/src/main/java/org/gnunet/util/AbsoluteTimeMessage.java
index f46d577..f46d577 100644
--- a/src/org/gnunet/util/AbsoluteTimeMessage.java
+++ b/src/main/java/org/gnunet/util/AbsoluteTimeMessage.java
diff --git a/src/org/gnunet/util/Cancelable.java b/src/main/java/org/gnunet/util/Cancelable.java
index 173f4c0..173f4c0 100644
--- a/src/org/gnunet/util/Cancelable.java
+++ b/src/main/java/org/gnunet/util/Cancelable.java
diff --git a/src/org/gnunet/util/Client.java b/src/main/java/org/gnunet/util/Client.java
index 182c797..18c206b 100644
--- a/src/org/gnunet/util/Client.java
+++ b/src/main/java/org/gnunet/util/Client.java
@@ -20,40 +20,46 @@
 package org.gnunet.util;
 
 import com.google.common.base.Optional;
+import org.gnunet.mq.Envelope;
+import org.gnunet.mq.MessageQueue;
+import org.gnunet.statistics.Statistics;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 
 /**
- * A connection to a gnunet service.
+ * A connection to a GNUnet service.
  *
  * Wraps a Connection, and is responsible for waiting until the underlying connection has been made
  * and allows reconnects.
  */
-public class Client {
+public class Client extends MessageQueue {
     private static final Logger logger = LoggerFactory
             .getLogger(Client.class);
 
     /**
      * Underlying connection to the service.
+     * May be NULL if the client is currently not connected.
      */
     private Connection connection;
 
     /**
      * Host this client should be connected to.
      */
-    private final int port;
     private final String hostname;
 
     /**
+     * Port of the host the client should connect to.
+     */
+    private final int port;
+
+    /**
      * Initial value for connectBackoff.
-     *
      */
     private static final RelativeTime INITAL_BACKOFF = RelativeTime.MILLISECOND.multiply(5);
 
     /**
      * Maximum value for connectBackoff.
-     *
      */
     private static final RelativeTime MAX_BACKOFF = RelativeTime.SECOND.multiply(5);
 
@@ -71,12 +77,25 @@ public class Client {
     private boolean notifyTransmitReadyDelayed;
 
     /**
-     * When notifyTransmitReadyDelayed is true, this can be used to cancel the task
+     * When notifyTransmitReadyDelayed is true, This can be used to cancel the task
      * waiting for the connection to be established.
      */
     private Cancelable delayedNotifyTransmitHandle;
 
     /**
+     * Currently installed persistent receiver.
+     * Will receive all messages sent to the client.
+     */
+    private RunaboutMessageReceiver receiver;
+
+    private boolean receiver_active;
+
+    /**
+     * Handle to cancel the message currently submitted in the queue,
+     */
+    private Cancelable currentSubmit;
+
+    /**
      * Create a connection to a service.
      *
      * @param serviceName name of the service
@@ -123,7 +142,7 @@ public class Client {
      * @param timeout  deadline after which MessageReceiver.deadline will be called
      * @param receiver MessageReceiver that is responsible for the received message
      */
-    public Cancelable receive(RelativeTime timeout, MessageReceiver receiver) {
+    public Cancelable receiveOne(RelativeTime timeout, MessageReceiver receiver) {
         return connection.receive(timeout, receiver);
     }
 
@@ -161,6 +180,7 @@ public class Client {
                 public void cont(boolean success) {
                     delayedNotifyTransmitHandle = null;
                     if (success) {
+                        activateReceiver();
                         notifyTransmitReadyDelayed = false;
                         delayedNotifyTransmitHandle = connection.notifyTransmitReady(0, timeout, new MessageTransmitter() {
                             @Override
@@ -176,6 +196,7 @@ public class Client {
                             }
                         });
                     } else {
+                        logger.debug("connect timed out, trying again");
                         if (deadline.isDue()) {
                             transmitter.handleError();
                         } else {
@@ -236,7 +257,6 @@ public class Client {
         return transmitWhenReady(RelativeTime.FOREVER, message, cont);
     }
 
-
     public final void reconnect() {
         if (connection != null) {
             connection.disconnect();
@@ -244,7 +264,6 @@ public class Client {
         connection = new Connection(hostname, port);
     }
 
-
     /**
      * Disconnect from the service. Cancel all pending receive/transmit requests.
      */
@@ -259,4 +278,52 @@ public class Client {
     public boolean isConnected() {
         return (connection != null) && connection.isConnected();
     }
+
+    @Override
+    protected void submit(Envelope ev) {
+        currentSubmit = transmitWhenReady(RelativeTime.FOREVER, ev.message, new Continuation() {
+            @Override
+            public void cont(boolean success) {
+                currentSubmit = null;
+                reportMessageSent();
+            }
+        });
+    }
+
+    @Override
+    protected void retract() {
+        if (currentSubmit == null)
+            throw new AssertionError();
+        currentSubmit.cancel();
+        currentSubmit = null;
+    }
+
+    private void activateReceiver() {
+        if (receiver_active || receiver == null)
+            return;
+        final MessageReceiver proxyReceiver = new MessageReceiver() {
+            @Override
+            public void process(GnunetMessage.Body msg) {
+                Client.this.receiver.process(msg);
+                if (connection != null && connection.isConnected())
+                    connection.receive(RelativeTime.FOREVER, this);
+                else
+                    receiver_active = false;
+            }
+
+            @Override
+            public void handleError() {
+                Client.this.receiver.handleError();
+                receiver_active = false;
+            }
+        };
+        connection.receive(RelativeTime.FOREVER, proxyReceiver);
+        receiver_active = true;
+    }
+
+    public void installReceiver(RunaboutMessageReceiver receiver) {
+        this.receiver = receiver;
+        if (connection != null && connection.isConnected())
+            activateReceiver();
+    }
 }
diff --git a/src/org/gnunet/util/Configuration.java b/src/main/java/org/gnunet/util/Configuration.java
index 5cf950c..ea67e1b 100644
--- a/src/org/gnunet/util/Configuration.java
+++ b/src/main/java/org/gnunet/util/Configuration.java
@@ -346,6 +346,17 @@ public class Configuration {
         }
     }
 
+    public String serialize() {
+        StringBuffer buf = new StringBuffer();
+        for (Map.Entry<String, Map<String,String>> section : sections.rowMap().entrySet()) {
+            buf.append("[" + section.getKey() + "]\n");
+            for (Map.Entry<String, String> option : section.getValue().entrySet()) {
+                buf.append(option.getKey() + " = " + option.getValue() + "\n");
+            }
+        }
+        return buf.toString();
+    }
+
 
     public void loadDefaults() {
         Collection<File> dirs = new ArrayList<File>(5);
diff --git a/src/org/gnunet/util/Connection.java b/src/main/java/org/gnunet/util/Connection.java
index f969cbe..1fd1458 100644
--- a/src/org/gnunet/util/Connection.java
+++ b/src/main/java/org/gnunet/util/Connection.java
@@ -48,6 +48,10 @@ public class Connection {
      */
     private SocketChannel connectionChannel = null;
 
+    /**
+     * The list of all address probes.
+     * Each address probe tries to connect via a different address.
+     */
     private List<AddressProbe> addressProbes = null;
 
     /**
@@ -73,11 +77,11 @@ public class Connection {
      */
     private ByteBuffer recvBuffer = ByteBuffer.allocate(GnunetMessage.Header.SIZE);
 
-
     /**
      * The handle for the current transmission. Writes data to the socket.
      */
     private TransmitHelper currentTransmitHelper = null;
+
     /**
      * The handle for the next transmission. The next transmission will become the current
      * transmission once the current transmission has completed.
@@ -173,7 +177,6 @@ public class Connection {
             recvBuffer.flip();
 
             boolean found = true;
-
             Class unionClass = null;
 
             try {
@@ -541,7 +544,6 @@ public class Connection {
 
 
     public interface ReceiveHandle extends Cancelable {
-        public void cancel();
     }
 
     /**
@@ -691,5 +693,4 @@ public class Connection {
             connectionChannel = null;
         }
     }
-
 }
diff --git a/src/org/gnunet/util/Continuation.java b/src/main/java/org/gnunet/util/Continuation.java
index e1027c0..e1027c0 100644
--- a/src/org/gnunet/util/Continuation.java
+++ b/src/main/java/org/gnunet/util/Continuation.java
diff --git a/src/org/gnunet/util/GnunetMessage.java b/src/main/java/org/gnunet/util/GnunetMessage.java
index 89c7a80..89c7a80 100644
--- a/src/org/gnunet/util/GnunetMessage.java
+++ b/src/main/java/org/gnunet/util/GnunetMessage.java
diff --git a/src/org/gnunet/util/HashCode.java b/src/main/java/org/gnunet/util/HashCode.java
index 0c2790f..0c2790f 100644
--- a/src/org/gnunet/util/HashCode.java
+++ b/src/main/java/org/gnunet/util/HashCode.java
diff --git a/src/main/java/org/gnunet/util/Helper.java b/src/main/java/org/gnunet/util/Helper.java
new file mode 100644
index 0000000..e8c1723
--- /dev/null
+++ b/src/main/java/org/gnunet/util/Helper.java
@@ -0,0 +1,208 @@
+package org.gnunet.util;
+
+import org.gnunet.construct.Construct;
+import org.gnunet.construct.Message;
+import org.gnunet.construct.MessageLoader;
+import org.gnunet.construct.ProtocolViolationException;
+import org.gnunet.mq.Envelope;
+import org.gnunet.mq.MessageQueue;
+
+import java.io.IOError;
+import java.io.IOException;
+import java.nio.Buffer;
+import java.nio.ByteBuffer;
+import java.nio.channels.Channels;
+import java.nio.channels.ReadableByteChannel;
+import java.util.EnumSet;
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * Process that we can communicate with standard GNUnet messages over stdin/stdout.
+ */
+public class Helper extends MessageQueue {
+
+    private final ProcessBuilder processBuilder;
+    private final RunaboutMessageReceiver receiver;
+    private Process process;
+
+    private volatile GnunetMessage.Body writeMessage;
+
+    private final class WriteThread implements Runnable {
+        @Override
+        public void run() {
+            GnunetMessage.Body msg;
+            while (true) {
+                synchronized (Helper.this) {
+                    while (writeMessage == null) {
+                        try {
+                            wait();
+                        } catch (InterruptedException e) {
+                            // do nothing
+                        }
+                    }
+                    // we now have a message we can send
+                    msg = writeMessage;
+                    writeMessage = null;
+                    // somebody can set the next send message
+                }
+                byte[] data = Construct.toBinary(GnunetMessage.fromBody(msg));
+                try {
+                    process.getOutputStream().write(data);
+                } catch (IOException e) {
+                    // fixme: what now?
+                }
+                Scheduler.addContinuation(new Scheduler.Task() {
+                    @Override
+                    public void run(Scheduler.RunContext ctx) {
+                        reportMessageSent();
+                    }
+                }, EnumSet.noneOf(Scheduler.Reason.class));
+            }
+        }
+    }
+
+    private final class ReadThread implements Runnable {
+        private ByteBuffer buffer;
+        ReadableByteChannel channel;
+
+        private void fillBuffer() {
+            while (buffer.hasRemaining()) {
+                try {
+                    channel.read(buffer);
+                } catch (IOException e) {
+                    // FIXME
+                    return;
+                }
+            }
+        }
+
+        private void scheduleInvokeReceiver(final GnunetMessage.Body body) {
+            Scheduler.addContinuation(new Scheduler.Task() {
+                @Override
+                public void run(Scheduler.RunContext ctx) {
+                    receiver.process(body);
+                }
+            }, EnumSet.noneOf(Scheduler.Reason.class));
+
+        }
+
+        @Override
+        public void run() {
+            // allocate just enough for the message header
+            buffer = ByteBuffer.allocate(4);
+            channel = Channels.newChannel(process.getInputStream());
+            while (true) {
+                buffer.clear();
+                buffer.limit(4);
+                fillBuffer();
+                buffer.rewind();
+                GnunetMessage.Header msgh = Construct.parseAs(buffer, GnunetMessage.Header.class);
+                if (msgh.messageSize > GnunetMessage.Header.SIZE) {
+                    if (buffer.capacity() < msgh.messageSize) {
+                        ByteBuffer newBuf = ByteBuffer.allocate(msgh.messageSize);
+                        buffer.flip();
+                        newBuf.put(buffer);
+                        buffer = newBuf;
+                    }
+                    buffer.limit(msgh.messageSize);
+                    fillBuffer();
+                }
+                // we now have a complete message
+                // prepare for reading again
+                buffer.flip();
+
+                boolean found = true;
+                Class unionClass = null;
+
+                try {
+                    unionClass = MessageLoader.getUnionClass(GnunetMessage.Body.class, msgh.messageType);
+                } catch (ProtocolViolationException e) {
+                    found = false;
+                }
+                if (found) {
+                    GnunetMessage msg;
+                    msg = Construct.parseAs(buffer, GnunetMessage.class);
+                    scheduleInvokeReceiver(msg.body);
+                } else {
+                    UnknownMessageBody b = new UnknownMessageBody();
+                    b.id = msgh.messageType;
+                    scheduleInvokeReceiver(b);
+                }
+            }
+        }
+    }
+
+
+    public Helper(boolean withControlPipe, String binaryName, List<String> argv,
+                  RunaboutMessageReceiver receiver) {
+        this.receiver = receiver;
+        List<String> command = new LinkedList<String>();
+        if (binaryName == null) {
+            throw new AssertionError();
+        }
+        command.add(binaryName);
+        if (argv != null)
+            command.addAll(argv);
+        processBuilder = new ProcessBuilder(command);
+        try {
+            process = processBuilder.start();
+        } catch (IOException e) {
+            throw new IOError(e);
+        }
+    }
+
+    /**
+     * Sends termination signal to the helper process.  The helper process is not
+     * reaped; call GNUNET_HELPER_wait() for reaping the dead helper process.
+     *
+     * @param softkill if GNUNET_YES, signals termination by closing the helper's
+     *          stdin; GNUNET_NO to signal termination by sending SIGTERM to helper
+     * @return true on success, false on failure
+     */
+    public boolean kill(boolean softkill) {
+        if (softkill) {
+            try {
+                process.getInputStream().close();
+            } catch (IOException e) {
+                return false;
+            }
+            return true;
+        }
+        process.destroy();
+        return true;
+    }
+
+    /**
+     * Reap the helper process.  This call is blocking(!).  The helper process
+     * should either be sent a termination signal before or should be dead before
+     * calling this function
+     *
+     * @return true on success, false on failure
+     */
+    public boolean waitFor() {
+        try {
+            process.waitFor();
+        } catch (InterruptedException e) {
+            return false;
+        }
+        return true;
+    }
+
+    @Override
+    protected void submit(Envelope ev) {
+        synchronized (this) {
+            if (writeMessage != null)
+                throw new AssertionError("message queue not implemented correctly");
+            writeMessage = ev.message;
+            notifyAll();
+        }
+    }
+
+    @Override
+    protected void retract() {
+        synchronized (this) {
+            writeMessage = null;
+        }
+    }
+}
diff --git a/src/org/gnunet/util/MessageReceiver.java b/src/main/java/org/gnunet/util/MessageReceiver.java
index 548695f..548695f 100644
--- a/src/org/gnunet/util/MessageReceiver.java
+++ b/src/main/java/org/gnunet/util/MessageReceiver.java
diff --git a/src/org/gnunet/util/MessageTransmitter.java b/src/main/java/org/gnunet/util/MessageTransmitter.java
index 54a6555..54a6555 100644
--- a/src/org/gnunet/util/MessageTransmitter.java
+++ b/src/main/java/org/gnunet/util/MessageTransmitter.java
diff --git a/src/org/gnunet/util/PeerIdentity.java b/src/main/java/org/gnunet/util/PeerIdentity.java
index 46a67cd..46a67cd 100644
--- a/src/org/gnunet/util/PeerIdentity.java
+++ b/src/main/java/org/gnunet/util/PeerIdentity.java
diff --git a/src/org/gnunet/util/Program.java b/src/main/java/org/gnunet/util/Program.java
index c54322b..bd413b9 100644
--- a/src/org/gnunet/util/Program.java
+++ b/src/main/java/org/gnunet/util/Program.java
@@ -78,6 +78,8 @@ public abstract class Program {
 
     private final String[] args;
 
+    private int returnValue = 0;
+
 
     /**
      * A program with the desired environment for a gnunet utility.
@@ -169,6 +171,10 @@ public abstract class Program {
         return "development version of gnunet-java";
     }
 
+    final protected void setReturnValue(int x) {
+        returnValue = x;
+    }
+
     /**
      * Start the Program as the initial task of the Scheduler.
      */
@@ -198,6 +204,8 @@ public abstract class Program {
                 }
             });
         }
+
+        System.exit(returnValue);
     }
 
     /**
diff --git a/src/org/gnunet/util/RelativeTime.java b/src/main/java/org/gnunet/util/RelativeTime.java
index 0faedfc..512ed01 100644
--- a/src/org/gnunet/util/RelativeTime.java
+++ b/src/main/java/org/gnunet/util/RelativeTime.java
@@ -59,6 +59,14 @@ public final class RelativeTime implements Comparable<RelativeTime> {
         this.rel_value_us = abs_value;
     }
 
+    public static RelativeTime fromMilliseconds(final long ms) {
+        return new RelativeTime(ms * 1000);
+    }
+
+    public static RelativeTime fromMicroseconds(final long us) {
+        return new RelativeTime(us);
+    }
+
     /**
      * Add relative times together.
      * 
diff --git a/src/org/gnunet/util/RelativeTimeMessage.java b/src/main/java/org/gnunet/util/RelativeTimeMessage.java
index ac4e66c..ac4e66c 100644
--- a/src/org/gnunet/util/RelativeTimeMessage.java
+++ b/src/main/java/org/gnunet/util/RelativeTimeMessage.java
diff --git a/src/org/gnunet/util/Resolver.java b/src/main/java/org/gnunet/util/Resolver.java
index 1d8ec87..22047aa 100644
--- a/src/org/gnunet/util/Resolver.java
+++ b/src/main/java/org/gnunet/util/Resolver.java
@@ -278,7 +278,7 @@ public class Resolver {
                 rh.transmitTask = null;
 
                 logger.debug("recv in notifyTransmitReady cb");
-                rh.receiveTask = client.receive(deadline.getRemaining(), new MessageReceiver() {
+                rh.receiveTask = client.receiveOne(deadline.getRemaining(), new MessageReceiver() {
                     @Override
                     public void process(GnunetMessage.Body msg) {
                         rh.receiveTask = null;
@@ -294,7 +294,7 @@ public class Resolver {
                                 }
 
                                 rh.cb.onAddress(in_addr);
-                                rh.receiveTask = client.receive(deadline.getRemaining(), this);
+                                rh.receiveTask = client.receiveOne(deadline.getRemaining(), this);
                             } catch (UnknownHostException e) {
                                 throw new ProtocolViolationException("malformed address");
                             }
diff --git a/src/org/gnunet/util/RunaboutMessageReceiver.java b/src/main/java/org/gnunet/util/RunaboutMessageReceiver.java
index 2a0f067..2a0f067 100644
--- a/src/org/gnunet/util/RunaboutMessageReceiver.java
+++ b/src/main/java/org/gnunet/util/RunaboutMessageReceiver.java
diff --git a/src/org/gnunet/util/RunaboutUtil.java b/src/main/java/org/gnunet/util/RunaboutUtil.java
index a82dc0a..a82dc0a 100644
--- a/src/org/gnunet/util/RunaboutUtil.java
+++ b/src/main/java/org/gnunet/util/RunaboutUtil.java
diff --git a/src/org/gnunet/util/Scheduler.java b/src/main/java/org/gnunet/util/Scheduler.java
index 6998633..78ea288 100644
--- a/src/org/gnunet/util/Scheduler.java
+++ b/src/main/java/org/gnunet/util/Scheduler.java
@@ -41,8 +41,8 @@ public class Scheduler {
     // only valid while a task is executing
     private static TaskConfiguration activeTask = null;
 
-    // number of tasks in the ready queue
-    private static int readyCount = 0;
+    // cumulative number of tasks in the ready lists
+    private static volatile int readyCount = 0;
 
     // for every priority, there is a list of tasks that is definitely ready to run
     @SuppressWarnings("unchecked")
@@ -82,7 +82,6 @@ public class Scheduler {
     private static boolean scheduler_running = false;
 
 
-
     // tasks that are waiting for an event, which are executed anyway after the deadline has occurred
     final private static Queue<TaskConfiguration> pending = new PriorityQueue<TaskConfiguration>(5, new Comparator
             <TaskConfiguration>() {
@@ -94,6 +93,21 @@ public class Scheduler {
 
 
     /**
+     * Reset the scheduler forcefully.
+     * Intended to be used internally in the Scheduler, as well as in test teardown.
+     */
+    public static void forceReset() {
+        scheduler_running = false;
+        readyCount = 0;
+        activeTask = null;
+        for (int i = 0; i < Priority.numberOfPriorities; ++i) {
+            readyLists[i] = new LinkedList<TaskConfiguration>();
+        }
+        pending.clear();
+    }
+
+
+    /**
      * Priority for Tasks.
      */
     public enum Priority {
@@ -149,26 +163,17 @@ public class Scheduler {
         /**
          * Create a TaskIdentifier.
          *
+         * @param delay when will the task be run?
+         *              may be null to indicate that this task may not be run
+         *              (but only queued directly)
          * @param task task to run with this TaskIdentifier
          */
         TaskConfiguration(RelativeTime delay, Task task) {
             this.task = task;
-            this.deadline = delay.toAbsolute();
-        }
-
-        /**
-         * Create a light-weight task identifier that is not registered as pending in the Scheduler,
-         * used for continuations.
-         *
-         * @param t   task
-         * @param ctx the RunContext
-         */
-        TaskConfiguration(Task t, RunContext ctx) {
-            this.task = t;
-            this.ctx = ctx;
-            this.deadline = AbsoluteTime.ZERO;
-            this.priority = (activeTask == null) ? Priority.DEFAULT : activeTask.priority;
-            this.lifeness = true;
+            if (delay == null)
+                this.deadline = null;
+            else
+                this.deadline = delay.toAbsolute();
         }
 
         private void addChannelEvent(SelectableChannel channel, int eventType) {
@@ -232,6 +237,8 @@ public class Scheduler {
         }
 
         public Cancelable schedule() {
+            if (this.deadline == null)
+                throw new AssertionError("a task without deadline may not be scheduled");
             if (priority == null) {
                 if (activeTask != null) {
                     priority = activeTask.priority;
@@ -280,11 +287,11 @@ public class Scheduler {
      * Run the task regardless of any prerequisites, before any other task of
      * the same priority.
      */
-    public static void addContinuation(Task task,
-                                       EnumSet<Reason> reasons) {
-        RunContext ctx = new RunContext();
-        ctx.reasons = reasons;
-        queueReady(new TaskConfiguration(task, ctx));
+    public static synchronized void addContinuation(Task task, EnumSet<Reason> reasons) {
+        TaskConfiguration t = new TaskConfiguration(null, task);
+        t.ctx.reasons = reasons;
+        t.priority = Priority.DEFAULT;
+        queueReady(t);
     }
 
     /**
@@ -299,7 +306,6 @@ public class Scheduler {
         return addDelayed(RelativeTime.ZERO, task);
     }
 
-
     /**
      * Add a task to run after the specified delay.
      *
@@ -360,11 +366,10 @@ public class Scheduler {
      *
      * @param tid TaskIdentifier of the ready task
      */
-    private static void queueReady(TaskConfiguration tid) {
+    private static synchronized void queueReady(TaskConfiguration tid) {
         int idx = tid.priority.ordinal();
         readyLists[idx].add(tid);
         readyCount++;
-
         pending.remove(tid);
     }
 
@@ -405,15 +410,21 @@ public class Scheduler {
         subscribers[eventType].ctx.reasons.add(eventToReason[eventType]);
     }
 
+    /**
+     * Select on channels and queue tasks that become executable.
+     *
+     * @param timeout timeout for select
+     */
     private static void handleSelect(RelativeTime timeout) {
+        long timeout_ms = timeout.getMicroseconds() / 1000;
         try {
             // selector.select(0) would block indefinitely (counter-intuitive, java's fault)
-            if (timeout.getMicroseconds() == 0) {
+            if (timeout_ms == 0) {
                 selector.selectNow();
             } else if (timeout.isForever()) {
                 selector.select(0);
             } else {
-                selector.select(timeout.getMicroseconds());
+                selector.select(timeout_ms);
             }
         } catch (IOException e) {
             throw new IOError(e);
@@ -472,13 +483,7 @@ public class Scheduler {
             logger.info("cleaning up after scheduler ran");
             // ensure that after run returns, the scheduler is in its initial state,
             // even though there was an exception (e.g. after a test case that expects an exception)
-            scheduler_running = false;
-            readyCount = 0;
-            activeTask = null;
-            for (int i = 0; i < Priority.numberOfPriorities; ++i) {
-                readyLists[i] = new LinkedList<TaskConfiguration>();
-            }
-            pending.clear();
+            forceReset();
         }
     }
 
@@ -495,25 +500,29 @@ public class Scheduler {
         }
 
         // the gnunet main loop
-        while (checkLiveness()) {
-            RelativeTime nextTimeout = handleTimeouts();
-            if (nextTimeout.getMicroseconds() < 0) {
-                logger.warn("negative timeout for select");
-            }
+        while (true) {
+            synchronized (Scheduler.class) {
+                if (checkLiveness() == false)
+                    break;
+                RelativeTime nextTimeout = handleTimeouts();
+                if (nextTimeout.getMicroseconds() < 0) {
+                    logger.warn("negative timeout for select");
+                }
 
-            // don't select if there are no tasks; we are done!
-            if (readyCount == 0 && pending.isEmpty()) {
-                return;
-            }
+                // don't select if there are no tasks; we are done!
+                if (readyCount == 0 && pending.isEmpty()) {
+                    return;
+                }
 
-            // don't block in select if we have tasks ready to run!
-            if (readyCount > 0) {
-                handleSelect(RelativeTime.ZERO);
-            } else {
-                handleSelect(nextTimeout);
-            }
+                // don't block in select if we have tasks ready to run!
+                if (readyCount > 0) {
+                    handleSelect(RelativeTime.ZERO);
+                } else {
+                    handleSelect(nextTimeout);
+                }
 
-            runReady();
+                runReady();
+            }
         }
 
         if (readyCount != 0) {
@@ -563,7 +572,7 @@ public class Scheduler {
     }
 
     /**
-     * Request the shutdown of a scheduler. Marks all currently pending tasks as
+     * Request the shutdown of the scheduler. Marks all currently pending tasks as
      * ready because of disconnect. This will cause all tasks to run (as soon as
      * possible, respecting priorities and prerequisite tasks). Note that tasks
      * scheduled AFTER this call may still be delayed arbitrarily.
@@ -594,6 +603,9 @@ public class Scheduler {
 
     }
 
+    /**
+     * A thread that reads from a file pipe.
+     */
     private static class FilePipeThread extends Thread {
         public File file;
         public Pipe pipe;
@@ -662,13 +674,5 @@ public class Scheduler {
         fpt.start();
         return new FilePipe(fpt);
     }
-
-    public static class AsyncProcess {
-        // getIn, getOut, getErr
-
-    }
-
-    public static AsyncProcess openAsyncProcess(/*...*/) {
-        throw new UnsupportedOperationException("not implemented yet");
-    }
 }
+
diff --git a/src/org/gnunet/util/Server.java b/src/main/java/org/gnunet/util/Server.java
index 8a86b45..8a86b45 100644
--- a/src/org/gnunet/util/Server.java
+++ b/src/main/java/org/gnunet/util/Server.java
diff --git a/src/org/gnunet/util/Service.java b/src/main/java/org/gnunet/util/Service.java
index d93e296..d93e296 100644
--- a/src/org/gnunet/util/Service.java
+++ b/src/main/java/org/gnunet/util/Service.java
diff --git a/src/org/gnunet/util/Strings.java b/src/main/java/org/gnunet/util/Strings.java
index a35568a..a35568a 100644
--- a/src/org/gnunet/util/Strings.java
+++ b/src/main/java/org/gnunet/util/Strings.java
diff --git a/src/org/gnunet/util/TestMessage.java b/src/main/java/org/gnunet/util/TestMessage.java
index b08a706..b08a706 100644
--- a/src/org/gnunet/util/TestMessage.java
+++ b/src/main/java/org/gnunet/util/TestMessage.java
diff --git a/src/org/gnunet/util/UnknownMessageBody.java b/src/main/java/org/gnunet/util/UnknownMessageBody.java
index b978ec6..b978ec6 100644
--- a/src/org/gnunet/util/UnknownMessageBody.java
+++ b/src/main/java/org/gnunet/util/UnknownMessageBody.java
diff --git a/src/org/gnunet/util/getopt/Argument.java b/src/main/java/org/gnunet/util/getopt/Argument.java
index 34159d0..34159d0 100644
--- a/src/org/gnunet/util/getopt/Argument.java
+++ b/src/main/java/org/gnunet/util/getopt/Argument.java
diff --git a/src/org/gnunet/util/getopt/ArgumentAction.java b/src/main/java/org/gnunet/util/getopt/ArgumentAction.java
index 077e71c..077e71c 100644
--- a/src/org/gnunet/util/getopt/ArgumentAction.java
+++ b/src/main/java/org/gnunet/util/getopt/ArgumentAction.java
diff --git a/src/org/gnunet/util/getopt/Parser.java b/src/main/java/org/gnunet/util/getopt/Parser.java
index 6ecc220..6ecc220 100644
--- a/src/org/gnunet/util/getopt/Parser.java
+++ b/src/main/java/org/gnunet/util/getopt/Parser.java
diff --git a/src/org/gnunet/util/getopt/package-info.java b/src/main/java/org/gnunet/util/getopt/package-info.java
index 0e3bdf5..0e3bdf5 100644
--- a/src/org/gnunet/util/getopt/package-info.java
+++ b/src/main/java/org/gnunet/util/getopt/package-info.java
diff --git a/src/org/gnunet/util/package-info.java b/src/main/java/org/gnunet/util/package-info.java
index df61afd..df61afd 100644
--- a/src/org/gnunet/util/package-info.java
+++ b/src/main/java/org/gnunet/util/package-info.java
diff --git a/src/main/java/org/gnunet/voting/CertificateAuthorityService.java b/src/main/java/org/gnunet/voting/CertificateAuthorityService.java
new file mode 100644
index 0000000..559bd97
--- /dev/null
+++ b/src/main/java/org/gnunet/voting/CertificateAuthorityService.java
@@ -0,0 +1,7 @@
+package org.gnunet.voting;
+
+/**
+ * Permits or denies a voter to participate in an election.
+ */
+public class CertificateAuthorityService {
+}
diff --git a/src/main/java/org/gnunet/voting/ElectionCallTool.java b/src/main/java/org/gnunet/voting/ElectionCallTool.java
new file mode 100644
index 0000000..52ad5fb
--- /dev/null
+++ b/src/main/java/org/gnunet/voting/ElectionCallTool.java
@@ -0,0 +1,50 @@
+package org.gnunet.voting;
+
+
+import org.gnunet.util.Program;
+import org.gnunet.util.getopt.Argument;
+import org.gnunet.util.getopt.ArgumentAction;
+
+public class ElectionCallTool {
+
+    public static void main(String[] args) {
+        new Program(args) {
+            @Argument(
+                    shortname = "t",
+                    longname = "template",
+                    action = ArgumentAction.SET,
+                    description = "output election template")
+            boolean template = false;
+            @Argument(
+                    shortname = "o",
+                    longname = "outfile",
+                    argumentName = "FILE",
+                    action = ArgumentAction.STORE_STRING,
+                    description = "write spec to FILE instead of standard output")
+            String outfilename = null;
+            @Argument(
+                    shortname = "V",
+                    longname = "verify",
+                    action = ArgumentAction.SET,
+                    description = "verify that the ESPEC is valid")
+            boolean verify = false;
+            @Argument(
+                    shortname = "a",
+                    longname = "authorize",
+                    action = ArgumentAction.SET,
+                    description = "authorize the ESPEC with the authorities")
+            boolean authorize = false;
+
+            @Override
+            protected String makeHelpText() {
+                return "gnunet-vote-call [OPTIONS]... ESPEC\n" +
+                        "Create, authorize and verify an election specification";
+            }
+
+            @Override
+            public void run() {
+            }
+
+        }.start();
+    }
+}
diff --git a/src/main/java/org/gnunet/voting/ElectionSpecification.java b/src/main/java/org/gnunet/voting/ElectionSpecification.java
new file mode 100644
index 0000000..8671ad5
--- /dev/null
+++ b/src/main/java/org/gnunet/voting/ElectionSpecification.java
@@ -0,0 +1,5 @@
+package org.gnunet.voting;
+
+public class ElectionSpecification {
+
+}
diff --git a/src/main/java/org/gnunet/voting/TallyAuthorityService.java b/src/main/java/org/gnunet/voting/TallyAuthorityService.java
new file mode 100644
index 0000000..435c318
--- /dev/null
+++ b/src/main/java/org/gnunet/voting/TallyAuthorityService.java
@@ -0,0 +1,5 @@
+package org.gnunet.voting;
+
+
+public class TallyAuthorityService {
+}
diff --git a/src/main/java/org/gnunet/voting/VotingTool.java b/src/main/java/org/gnunet/voting/VotingTool.java
new file mode 100644
index 0000000..02874b6
--- /dev/null
+++ b/src/main/java/org/gnunet/voting/VotingTool.java
@@ -0,0 +1,49 @@
+package org.gnunet.voting;
+
+
+import org.gnunet.util.Program;
+import org.gnunet.util.getopt.Argument;
+import org.gnunet.util.getopt.ArgumentAction;
+
+public class VotingTool {
+    public static void main(String[] args) {
+        new Program(args) {
+            @Argument(
+                    shortname = "q",
+                    longname = "query",
+                    action = ArgumentAction.SET,
+                    description = "query election result")
+            boolean query = false;
+
+            @Argument(
+                    shortname = "s",
+                    longname = "submit",
+                    action = ArgumentAction.STORE_STRING,
+                    argumentName = "CHOICE",
+                    description = "submit vote to the election")
+            String vote = null;
+
+            @Argument(
+                    shortname = "p",
+                    longname = "certificate",
+                    action = ArgumentAction.STORE_STRING,
+                    argumentName = "FILE",
+                    description = "certificate file with the permission to vote")
+            String certfile = null;
+
+            @Override
+            protected String makeHelpText() {
+                return "gnunet-vote [OPTIONS]... ESPEC\n" +
+                        "Submit a vote or query an election's result.\n" +
+                        "The election is identified in the ESPEC file.";
+            }
+
+            @Override
+            public void run() {
+
+            }
+        }.start();
+
+    }
+
+}
diff --git a/src/org/gnunet/voting/Authority.java b/src/main/java/org/gnunet/voting/simulation/Authority.java
index 8c39100..792dbbd 100644
--- a/src/org/gnunet/voting/Authority.java
+++ b/src/main/java/org/gnunet/voting/simulation/Authority.java
@@ -1,4 +1,4 @@
-package org.gnunet.voting;
+package org.gnunet.voting.simulation;
 
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
diff --git a/src/org/gnunet/voting/Ballot.java b/src/main/java/org/gnunet/voting/simulation/Ballot.java
index fbc6e11..1c2bfbe 100644
--- a/src/org/gnunet/voting/Ballot.java
+++ b/src/main/java/org/gnunet/voting/simulation/Ballot.java
@@ -1,4 +1,4 @@
-package org.gnunet.voting;
+package org.gnunet.voting.simulation;
 
 import java.math.BigInteger;
 
diff --git a/src/org/gnunet/voting/BogusAuthority.java b/src/main/java/org/gnunet/voting/simulation/BogusAuthority.java
index 8c0363d..d59f0cf 100644
--- a/src/org/gnunet/voting/BogusAuthority.java
+++ b/src/main/java/org/gnunet/voting/simulation/BogusAuthority.java
@@ -1,4 +1,4 @@
-package org.gnunet.voting;
+package org.gnunet.voting.simulation;
 
 /**
  * ...
diff --git a/src/org/gnunet/voting/CallForVoters.java b/src/main/java/org/gnunet/voting/simulation/CallForVoters.java
index d6436eb..a84484d 100644
--- a/src/org/gnunet/voting/CallForVoters.java
+++ b/src/main/java/org/gnunet/voting/simulation/CallForVoters.java
@@ -1,4 +1,4 @@
-package org.gnunet.voting;
+package org.gnunet.voting.simulation;
 
 import java.util.List;
 
diff --git a/src/org/gnunet/voting/CryptoUtil.java b/src/main/java/org/gnunet/voting/simulation/CryptoUtil.java
index 6f15bf6..87ecd9f 100644
--- a/src/org/gnunet/voting/CryptoUtil.java
+++ b/src/main/java/org/gnunet/voting/simulation/CryptoUtil.java
@@ -1,4 +1,4 @@
-package org.gnunet.voting;
+package org.gnunet.voting.simulation;
 
 import java.math.BigInteger;
 import java.security.MessageDigest;
diff --git a/src/org/gnunet/voting/Cyphertext.java b/src/main/java/org/gnunet/voting/simulation/Cyphertext.java
index 218252c..6e7d72f 100644
--- a/src/org/gnunet/voting/Cyphertext.java
+++ b/src/main/java/org/gnunet/voting/simulation/Cyphertext.java
@@ -1,4 +1,4 @@
-package org.gnunet.voting;
+package org.gnunet.voting.simulation;
 
 import java.math.BigInteger;
 
diff --git a/src/org/gnunet/voting/ElectionSupervisor.java b/src/main/java/org/gnunet/voting/simulation/ElectionSupervisor.java
index 106095b..ee0b181 100644
--- a/src/org/gnunet/voting/ElectionSupervisor.java
+++ b/src/main/java/org/gnunet/voting/simulation/ElectionSupervisor.java
@@ -1,4 +1,4 @@
-package org.gnunet.voting;
+package org.gnunet.voting.simulation;
 
 import com.google.common.collect.Lists;
 
diff --git a/src/org/gnunet/voting/GroupPublicKey.java b/src/main/java/org/gnunet/voting/simulation/GroupPublicKey.java
index a7b0cae..a6f2c74 100644
--- a/src/org/gnunet/voting/GroupPublicKey.java
+++ b/src/main/java/org/gnunet/voting/simulation/GroupPublicKey.java
@@ -1,4 +1,4 @@
-package org.gnunet.voting;
+package org.gnunet.voting.simulation;
 
 import java.math.BigInteger;
 
diff --git a/src/org/gnunet/voting/TallyKeyShare.java b/src/main/java/org/gnunet/voting/simulation/TallyKeyShare.java
index d67cfa9..1982358 100644
--- a/src/org/gnunet/voting/TallyKeyShare.java
+++ b/src/main/java/org/gnunet/voting/simulation/TallyKeyShare.java
@@ -1,4 +1,4 @@
-package org.gnunet.voting;
+package org.gnunet.voting.simulation;
 
 import java.math.BigInteger;
 
diff --git a/src/org/gnunet/voting/TransmitShareVerification.java b/src/main/java/org/gnunet/voting/simulation/TransmitShareVerification.java
index a30e327..13da325 100644
--- a/src/org/gnunet/voting/TransmitShareVerification.java
+++ b/src/main/java/org/gnunet/voting/simulation/TransmitShareVerification.java
@@ -1,4 +1,4 @@
-package org.gnunet.voting;
+package org.gnunet.voting.simulation;
 
 import java.math.BigInteger;
 
diff --git a/src/org/gnunet/voting/Voter.java b/src/main/java/org/gnunet/voting/simulation/Voter.java
index fa658dd..53a5640 100644
--- a/src/org/gnunet/voting/Voter.java
+++ b/src/main/java/org/gnunet/voting/simulation/Voter.java
@@ -1,4 +1,4 @@
-package org.gnunet.voting;
+package org.gnunet.voting.simulation;
 
 import java.math.BigInteger;
 
diff --git a/src/org/gnunet/voting/VotingParameters.java b/src/main/java/org/gnunet/voting/simulation/VotingParameters.java
index b563bff..bc6b987 100644
--- a/src/org/gnunet/voting/VotingParameters.java
+++ b/src/main/java/org/gnunet/voting/simulation/VotingParameters.java
@@ -1,8 +1,7 @@
-package org.gnunet.voting;
+package org.gnunet.voting.simulation;
 
 import java.math.BigInteger;
 import java.security.SecureRandom;
-import java.util.Random;
 
 /**
  * Utilities for the modified ElGamal algorithm.
diff --git a/src/org/gnunet/voting/VotingSimulation.java b/src/main/java/org/gnunet/voting/simulation/VotingSimulation.java
index 853fdff..607c653 100644
--- a/src/org/gnunet/voting/VotingSimulation.java
+++ b/src/main/java/org/gnunet/voting/simulation/VotingSimulation.java
@@ -1,4 +1,4 @@
-package org.gnunet.voting;
+package org.gnunet.voting.simulation;
 
 import com.google.common.collect.Lists;
 
diff --git a/src/org/grothoff/Runabout.java b/src/main/java/org/grothoff/Runabout.java
index 2a1dbb0..2a1dbb0 100644
--- a/src/org/grothoff/Runabout.java
+++ b/src/main/java/org/grothoff/Runabout.java
diff --git a/src/org/grothoff/package-info.java b/src/main/java/org/grothoff/package-info.java
index 2a8b8f0..2a8b8f0 100644
--- a/src/org/grothoff/package-info.java
+++ b/src/main/java/org/grothoff/package-info.java
diff --git a/src/main/resources/org/gnunet/construct/MsgMap.txt b/src/main/resources/org/gnunet/construct/MsgMap.txt
new file mode 100644
index 0000000..2ca1246
--- /dev/null
+++ b/src/main/resources/org/gnunet/construct/MsgMap.txt
@@ -0,0 +1,46 @@
+org.gnunet.util.Resolver$Address|0=org.gnunet.util.Resolver$TextualAddress
+org.gnunet.util.Resolver$Address|1=org.gnunet.util.Resolver$NumericAddress
+org.gnunet.util.GnunetMessage$Body|68=org.gnunet.core.DisconnectNotifyMessage
+org.gnunet.util.GnunetMessage$Body|274=org.gnunet.mesh.TunnelDestroyMessage
+org.gnunet.util.GnunetMessage$Body|1=org.gnunet.util.TestMessage
+org.gnunet.util.GnunetMessage$Body|70=org.gnunet.core.NotifyInboundTrafficMessage
+org.gnunet.util.GnunetMessage$Body|273=org.gnunet.mesh.TunnelCreateMessage
+org.gnunet.util.GnunetMessage$Body|71=org.gnunet.core.NotifyOutboundTrafficMessage
+org.gnunet.util.GnunetMessage$Body|272=org.gnunet.mesh.ClientConnectMessage
+org.gnunet.util.GnunetMessage$Body|64=org.gnunet.core.InitMessage
+org.gnunet.util.GnunetMessage$Body|4=org.gnunet.util.Resolver$GetMessage
+org.gnunet.util.GnunetMessage$Body|65=org.gnunet.core.InitReplyMessage
+org.gnunet.util.GnunetMessage$Body|5=org.gnunet.util.Resolver$ResolverResponse
+org.gnunet.util.GnunetMessage$Body|143=org.gnunet.dht.ClientGetMessage
+org.gnunet.util.GnunetMessage$Body|67=org.gnunet.core.ConnectNotifyMessage
+org.gnunet.util.GnunetMessage$Body|142=org.gnunet.dht.ClientPutMessage
+org.gnunet.util.GnunetMessage$Body|76=org.gnunet.core.SendMessage
+org.gnunet.util.GnunetMessage$Body|286=org.gnunet.mesh.LocalAckMessage
+org.gnunet.util.GnunetMessage$Body|74=org.gnunet.core.SendMessageRequest
+org.gnunet.util.GnunetMessage$Body|75=org.gnunet.core.SendMessageReady
+org.gnunet.util.GnunetMessage$Body|153=org.gnunet.dht.MonitorStartStop
+org.gnunet.util.GnunetMessage$Body|155=org.gnunet.dht.ClientPutConfirmationMessage
+org.gnunet.util.GnunetMessage$Body|323=org.gnunet.nse.UpdateMessage
+org.gnunet.util.GnunetMessage$Body|260=org.gnunet.mesh.DataMessage
+org.gnunet.util.GnunetMessage$Body|321=org.gnunet.nse.StartMessage
+org.gnunet.util.GnunetMessage$Body|144=org.gnunet.dht.ClientGetStopMessage
+org.gnunet.util.GnunetMessage$Body|145=org.gnunet.dht.ClientResultMessage
+org.gnunet.util.GnunetMessage$Body|332=org.gnunet.peerinfo.InfoMessage
+org.gnunet.util.GnunetMessage$Body|333=org.gnunet.peerinfo.InfoEnd
+org.gnunet.util.GnunetMessage$Body|149=org.gnunet.dht.MonitorGetMessage
+org.gnunet.util.GnunetMessage$Body|331=org.gnunet.peerinfo.ListAllPeersMessage
+org.gnunet.util.GnunetMessage$Body|150=org.gnunet.dht.MonitorGetRespMessage
+org.gnunet.util.GnunetMessage$Body|151=org.gnunet.dht.MonitorPutMessage
+org.gnunet.util.GnunetMessage$Body|171=org.gnunet.statistics.GetResponseEndMessage
+org.gnunet.util.GnunetMessage$Body|170=org.gnunet.statistics.GetResponseMessage
+org.gnunet.util.GnunetMessage$Body|169=org.gnunet.statistics.GetMessage
+org.gnunet.util.GnunetMessage$Body|168=org.gnunet.statistics.SetMessage
+org.gnunet.util.GnunetMessage$Body|374=org.gnunet.transport.RequestConnectMessage
+org.gnunet.util.GnunetMessage$Body|173=org.gnunet.statistics.WatchResponseMessage
+org.gnunet.util.GnunetMessage$Body|172=org.gnunet.statistics.WatchMessage
+org.gnunet.util.GnunetMessage$Body|524=org.gnunet.consensus.ConcludeMessage
+org.gnunet.util.GnunetMessage$Body|521=org.gnunet.consensus.InsertElementMessage
+org.gnunet.util.GnunetMessage$Body|523=org.gnunet.consensus.NewElementMessage
+org.gnunet.util.GnunetMessage$Body|360=org.gnunet.transport.StartMessage
+org.gnunet.construct.MessageUnion|525=org.gnunet.consensus.ConcludeDoneMessage
+# generated 2013/08/22 21:29:40
diff --git a/src/org/gnunet/mq/ClientMessageQueue.java b/src/org/gnunet/mq/ClientMessageQueue.java
deleted file mode 100644
index b3fccc7..0000000
--- a/src/org/gnunet/mq/ClientMessageQueue.java
+++ /dev/null
@@ -1,44 +0,0 @@
-package org.gnunet.mq;
-
-
-import org.gnunet.construct.Construct;
-import org.gnunet.util.*;
-
-/**
- * Message queue for org.util.Connection
- */
-public class ClientMessageQueue extends MessageQueue {
-    private final Client client;
-    private final RunaboutMessageReceiver receiver;
-
-    public ClientMessageQueue(Client client, RunaboutMessageReceiver receiver) {
-        this.client = client;
-        this.receiver = receiver;
-    }
-
-    public ClientMessageQueue(Client client) {
-        this(client, null);
-    }
-
-    @Override
-    protected void sendImmediate(final Envelope ev) {
-        int size = Construct.getSize(ev.message);
-        client.notifyTransmitReady(RelativeTime.FOREVER, false, size, new MessageTransmitter() {
-            @Override
-            public void transmit(Connection.MessageSink sink) {
-                sink.send(ev.message);
-                reportMessageSent();
-            }
-
-            @Override
-            public void handleError() {
-                // FIXME
-            }
-        });
-    }
-
-    @Override
-    public void destroy() {
-
-    }
-}
diff --git a/src/org/gnunet/mq/MessageQueue.java b/src/org/gnunet/mq/MessageQueue.java
deleted file mode 100644
index de08edf..0000000
--- a/src/org/gnunet/mq/MessageQueue.java
+++ /dev/null
@@ -1,41 +0,0 @@
-package org.gnunet.mq;
-
-
-import org.gnunet.util.GnunetMessage;
-
-import java.util.LinkedList;
-
-/**
- * General-purpose message queue
- */
-public abstract class MessageQueue {
-    private LinkedList<Envelope> queued_envelopes = new LinkedList<>();
-    protected Envelope current_envelope;
-
-    protected abstract void sendImmediate(Envelope ev);
-
-    public void send(GnunetMessage.Body body) {
-        send(new Envelope(body));
-    }
-
-    public void send(Envelope ev) {
-        if (null == current_envelope) {
-            current_envelope = ev;
-            sendImmediate(current_envelope);
-        } else {
-            queued_envelopes.addLast(ev);
-        }
-    }
-
-    protected void reportMessageSent() {
-        if (null == current_envelope)
-            throw new AssertionError();
-        current_envelope.invokeSentNotification();
-        if (queued_envelopes.isEmpty())
-            return;
-        current_envelope = queued_envelopes.pop();
-        sendImmediate(current_envelope);
-    }
-
-    public abstract void destroy();
-}
diff --git a/src/org/gnunet/peerinfo/PeerInfo.java b/src/org/gnunet/peerinfo/PeerInfo.java
deleted file mode 100644
index 9d92763..0000000
--- a/src/org/gnunet/peerinfo/PeerInfo.java
+++ /dev/null
@@ -1,123 +0,0 @@
-/*
- This file is part of GNUnet.
- (C) 2011, 2012 Christian Grothoff (and other contributing authors)
-
- GNUnet is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published
- by the Free Software Foundation; either version 3, or (at your
- option) any later version.
-
- GNUnet is distributed in the hope that it will be useful, but
- WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with GNUnet; see the file COPYING.  If not, write to the
- Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA.
- */
-
-package org.gnunet.peerinfo;
-
-
-import org.gnunet.hello.HelloMessage;
-import org.gnunet.requests.Request;
-import org.gnunet.requests.RequestQueue;
-import org.gnunet.util.*;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/**
- * Interface to the service that maintains all known hosts.
- *
- * @author Florian Dold
- */
-public class PeerInfo {
-    private static final Logger logger = LoggerFactory
-            .getLogger(AbsoluteTime.class);
-
-    private final RequestQueue requests;
-    private PeerIterateRequest activeRequest;
-
-    private class PeerIterateRequest extends Request {
-        public PeerIdentity peer;
-        public PeerProcessor peerProcessor;
-        @Override
-        public void transmit(Connection.MessageSink sink) {
-            if (peer == null) {
-                ListAllPeersMessage lapm = new ListAllPeersMessage();
-                sink.send(lapm);
-            } else {
-                ListPeerMessage lpm = new ListPeerMessage();
-                lpm.peer = peer;
-                sink.send(lpm);
-            }
-            activeRequest = this;
-            requests.clog();
-        }
-    }
-
-    private class PeerInfoMessageReceiver extends RunaboutMessageReceiver {
-        public void visit(InfoEnd infoEnd) {
-            activeRequest.peerProcessor.onEnd();
-            activeRequest = null;
-            requests.unclog();
-        }
-        public void visit(InfoMessage infoMessage) {
-            if (activeRequest == null) {
-                logger.warn("PEERINFO sent info message, but no request is active");
-            }
-            activeRequest.peerProcessor.onPeer(infoMessage.peerIdentity, infoMessage.hello);
-        }
-
-        @Override
-        public void handleError() {
-        }
-    }
-
-
-    public PeerInfo(Configuration cfg) {
-        Client client = new Client("peerinfo", cfg);
-        requests = new RequestQueue(client, new PeerInfoMessageReceiver());
-    }
-
-    public Cancelable iterate(RelativeTime timeout, PeerProcessor processor) {
-        return iterate(timeout, null, processor);
-    }
-
-    public Cancelable iterate(RelativeTime timeout, PeerIdentity peer, PeerProcessor processor) {
-        PeerIterateRequest peerIterateRequest = new PeerIterateRequest();
-        peerIterateRequest.peer = peer;
-        peerIterateRequest.peerProcessor = processor;
-        peerIterateRequest.setDeadline(timeout.toAbsolute());
-        return requests.add(peerIterateRequest);
-    }
-
-    public void disconnect() {
-        requests.destroy();
-    }
-
-    public static void main(String... args) {
-        new Program(args) {
-
-            @Override
-            public void run() {
-                final PeerInfo peerInfo = new PeerInfo(getConfiguration());
-                peerInfo.iterate(RelativeTime.FOREVER, new PeerProcessor() {
-                    @Override
-                    public void onPeer(PeerIdentity peerIdentity, HelloMessage hello) {
-                        System.out.println("peer " + peerIdentity.toString());
-                    }
-
-                    @Override
-                    public void onEnd() {
-                        System.out.println("got peer end");
-                        peerInfo.disconnect();
-                    }
-                });
-            }
-        }.start();
-
-    }
-}
diff --git a/src/org/gnunet/requests/FixedMessageRequest.java b/src/org/gnunet/requests/FixedMessageRequest.java
deleted file mode 100644
index 1420e28..0000000
--- a/src/org/gnunet/requests/FixedMessageRequest.java
+++ /dev/null
@@ -1,23 +0,0 @@
-package org.gnunet.requests;
-
-import org.gnunet.util.Connection;
-import org.gnunet.util.GnunetMessage;
-
-/**
- * A request that sends a message, pre-determined at construction of the FixedMessageRequest.
- *
- * @author Florian Dold
- */
-public class FixedMessageRequest extends Request {
-    private final GnunetMessage.Body msg;
-
-    public FixedMessageRequest(GnunetMessage.Body msg) {
-        this.msg = msg;
-    }
-
-    final
-    @Override
-    public void transmit(Connection.MessageSink sink) {
-        sink.send(msg);
-    }
-}
diff --git a/src/org/gnunet/requests/Request.java b/src/org/gnunet/requests/Request.java
deleted file mode 100644
index 953b5e1..0000000
--- a/src/org/gnunet/requests/Request.java
+++ /dev/null
@@ -1,82 +0,0 @@
-package org.gnunet.requests;
-
-import org.gnunet.util.AbsoluteTime;
-import org.gnunet.util.Connection;
-import org.gnunet.util.RelativeTime;
-
-/**
- * Abstract base class for a Request.
- *
- * Every request defines what happens when one of the following happens:
- * <ul>
- *     <li>
- *         The request is canceled. There may be some cleanup necessary, depending on whether the request has already been
- *         sent to the service or not.
- *     </li>
- *     <li>
- *         On timeout.
- *     </li>
- *     <li>
- *         On reconnect. In particular, every Request has to decide whether it will be kept after a reconnect to the service.
- *     </li>
- *     <li>
- *         On destruction of the request queue. Some request may be important enough to delay the destruction until they have been sent.
- *     </li>
- * </ul>
- *
- * @author Florian Dold
-*/
-public abstract class Request {
-    protected AbsoluteTime deadline = AbsoluteTime.FOREVER;
-
-    /**
-     * Called whenever the request could not be transmitted due to timeout.
-     *
-     * @return true if the request should be queued again
-     */
-    public boolean onTransmitTimeout() {
-        // per default, just drop the message on timeout!
-        return false;
-    }
-
-    /**
-     *
-     *
-     * @return true if the request should be kept after the destroy request
-     */
-    public boolean onDestroy() {
-        // per default, do not keep on destroy
-        return false;
-    }
-
-    /**
-     * @return true if the request should be kept after the reconnect
-     */
-    public boolean onReconnect() {
-        // per default, do not keep on reconnect
-        return false;
-    }
-
-    /**
-     * @param alreadyTransmitted true if message has already been sent over the network
-     */
-    public void onCancel(boolean alreadyTransmitted) {
-        // do nothing
-    }
-
-    public void setDeadline(AbsoluteTime deadline) {
-        this.deadline = deadline;
-    }
-
-    /**
-     * Called to determine after how long the request should time out.
-     * Per default, the deadline is FOREVER.
-     *
-     * @return the deadline for this request
-     */
-    public AbsoluteTime getDeadline() {
-        return deadline;
-    }
-
-    public abstract void transmit(Connection.MessageSink sink);
-}
diff --git a/src/org/gnunet/requests/RequestQueue.java b/src/org/gnunet/requests/RequestQueue.java
deleted file mode 100644
index 6f7102d..0000000
--- a/src/org/gnunet/requests/RequestQueue.java
+++ /dev/null
@@ -1,294 +0,0 @@
-/*
- This file is part of GNUnet.
- (C) 2011, 2012 Christian Grothoff (and other contributing authors)
-
- GNUnet is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published
- by the Free Software Foundation; either version 3, or (at your
- option) any later version.
-
- GNUnet is distributed in the hope that it will be useful, but
- WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with GNUnet; see the file COPYING.  If not, write to the
- Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA.
- */
-
-package org.gnunet.requests;
-
-import org.gnunet.util.*;
-
-import java.util.LinkedList;
-
-/**
- * Generic queues for Requests to be sent to the service.
- */
-public class RequestQueue {
-
-    /**
-     * Requests to be transmitted to the service.
-     */
-    private final LinkedList<Request> requestsAwaitingTransmit = new LinkedList<Request>();
-
-    /**
-     * Persistent requests. Will be informed about reconnect / destroy events even
-     * if already transmitted. Have to be canceled manually.
-     */
-    private final LinkedList<Request> persistentRequests = new LinkedList<Request>();
-
-    /**
-     * List of all requests from requestAwaitingTransmit and persistentRequest, containing no duplicates.
-     */
-    private final LinkedList<Request> allRequests = new LinkedList<Request>();
-
-    /**
-     * The designated receiver for all messages.
-     */
-    private MessageReceiver receiver;
-
-    /**
-     * The active transmit request handle, if any.
-     */
-    private Cancelable currentTransmit;
-
-    /**
-     * Current receive handler.
-     */
-    private Cancelable currentReceive;
-
-    /**
-     * True if we should not send further requests until queue is unclogged.
-     */
-    private boolean clogged = false;
-
-    private boolean destroyed = false;
-    private final Client client;
-
-    public RequestQueue(Client client, MessageReceiver receiver) {
-        this.client = client;
-        this.receiver = receiver;
-    }
-
-    /**
-     * Handle next request.
-     */
-    private void handleNextTransmit() {
-
-        if (clogged) {
-            return;
-        }
-
-        // return if we are already transmitting something
-        if (currentTransmit != null) {
-            return;
-        }
-
-        final Request request = requestsAwaitingTransmit.poll();
-        if (request == null) {
-            handleReceive();
-            return;
-        }
-
-        AbsoluteTime deadline = request.getDeadline();
-        if (deadline == null) {
-            throw new AssertionError("getDeadline() must return a non-null AbsoluteTime");
-        }
-
-        currentTransmit = client.notifyTransmitReady(deadline.getRemaining(), true, 0, new MessageTransmitter() {
-            @Override
-            public void transmit(Connection.MessageSink sink) {
-                currentTransmit = null;
-
-                try {
-                    request.transmit(sink);
-                } finally {
-                    handleReceive();
-                    handleNextTransmit();
-                }
-            }
-
-            @Override
-            public void handleError() {
-                throw new AssertionError("not implemented");
-            }
-        });
-    }
-
-    /**
-     * Continue receiving if necessary.
-     */
-    private void handleReceive() {
-        if (currentReceive != null || destroyed || !client.isConnected()) {
-            return;
-        }
-        currentReceive = client.receive(RelativeTime.FOREVER, new MessageReceiver() {
-            @Override
-            public void process(GnunetMessage.Body msg) {
-                currentReceive = null;
-
-                try {
-                    receiver.process(msg);
-                } finally {
-                    handleNextTransmit();
-                    handleReceive();
-                }
-            }
-
-            @Override
-            public void handleError() {
-                receiver.handleError();
-            }
-        });
-    }
-
-    /**
-     * Add a request to the end of the queue.
-     *
-     * @param request request to be added
-     * @return a handle to cancel the request
-     */
-    public Cancelable add(final Request request) {
-        allRequests.add(request);
-        requestsAwaitingTransmit.add(request);
-        handleNextTransmit();
-
-        return new Cancelable() {
-            @Override
-            public void cancel() {
-                RequestQueue.this.requestsAwaitingTransmit.remove(request);
-                RequestQueue.this.persistentRequests.remove(request);
-                RequestQueue.this.allRequests.remove(request);
-                request.onCancel(!requestsAwaitingTransmit.contains(request));
-            }
-        };
-    }
-
-
-    /**
-     * Add a request so that it will get notified about reconnect/destroy events,
-     * even if it already has been transmitted.
-     */
-    public Cancelable addPersistent(final Request request) {
-        persistentRequests.add(request);
-        return add(request);
-    }
-
-
-    /**
-     * Add a request to the front of the queue, this request will be sent as
-     * the next message (if not preempted by another sendNext).
-     *
-     * @param request request to be sent next
-     * @return a handle to cancel the request
-     */
-    public Cancelable sendNext(final Request request) {
-        requestsAwaitingTransmit.addFirst(request);
-        handleNextTransmit();
-        // todo: should this really return Cancelable? When do we want to cancel a request added by sendNext?
-        return new Cancelable() {
-            @Override
-            public void cancel() {
-                RequestQueue.this.requestsAwaitingTransmit.remove(request);
-                RequestQueue.this.persistentRequests.remove(request);
-                RequestQueue.this.allRequests.remove(request);
-                request.onCancel(!requestsAwaitingTransmit.contains(request));
-            }
-        };
-    }
-
-    /**
-     * Reconnect the client and notify all pending request of the reconnect.
-     */
-    public void reconnect() {
-        client.reconnect();
-        currentReceive = null;
-        currentTransmit = null;
-
-        final LinkedList<Request> remove = new LinkedList<Request>();
-
-
-        for (Request r : allRequests) {
-            boolean keep = r.onReconnect();
-            if (!keep) {
-                remove.add(r);
-            } else {
-                // retransmit an apparently persistent request.
-                if (!requestsAwaitingTransmit.contains(r)) {
-                    requestsAwaitingTransmit.add(r);
-                }
-            }
-        }
-        requestsAwaitingTransmit.removeAll(remove);
-        persistentRequests.removeAll(remove);
-        allRequests.removeAll(remove);
-
-        // only transmit, receive should only be called after the first transmit
-        handleNextTransmit();
-    }
-
-    /**
-     * Notify all request of the shutdown. Does not actually destroy the connection.
-     */
-    public void shutdown() {
-        final LinkedList<Request> remove = new LinkedList<Request>();
-
-        for (Request r : allRequests) {
-            boolean keep = r.onDestroy();
-            if (!keep) {
-                remove.add(r);
-            } else {
-                // retransmit an apparently persistent request.
-                if (!requestsAwaitingTransmit.contains(r)) {
-                    requestsAwaitingTransmit.add(r);
-                }
-            }
-        }
-        requestsAwaitingTransmit.removeAll(remove);
-        persistentRequests.removeAll(remove);
-        allRequests.removeAll(remove);
-
-        handleNextTransmit();
-        handleReceive();
-    }
-
-    /**
-     * Cancel all requests and destroy the connection.
-     */
-    public void destroy() {
-        destroyed = true;
-        allRequests.clear();
-        persistentRequests.clear();
-        requestsAwaitingTransmit.clear();
-        if (currentTransmit != null) {
-            currentTransmit.cancel();
-        }
-        if (currentReceive != null) {
-            currentReceive.cancel();
-        }
-    }
-
-    /**
-     * Allow no further requests to be transmitted until the queue is unclogged.
-     */
-    public void clog() {
-        if (clogged) {
-            throw new AssertionError("double clog");
-        }
-        clogged = true;
-    }
-
-    /**
-     * Unclog the queue, must have been previously clogged.
-     */
-    public void unclog() {
-        if (!clogged) {
-            throw new AssertionError("unclogg before clog");
-        }
-        clogged = false;
-        handleNextTransmit();
-    }
-}
diff --git a/src/org/gnunet/statistics/Statistics.java b/src/org/gnunet/statistics/Statistics.java
deleted file mode 100644
index d755dd7..0000000
--- a/src/org/gnunet/statistics/Statistics.java
+++ /dev/null
@@ -1,408 +0,0 @@
-/*
- This file is part of GNUnet.
- (C) 2011, 2012 Christian Grothoff (and other contributing authors)
-
- GNUnet is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published
- by the Free Software Foundation; either version 3, or (at your
- option) any later version.
-
- GNUnet is distributed in the hope that it will be useful, but
- WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with GNUnet; see the file COPYING.  If not, write to the
- Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA.
- */
-
-/*
- * The stuff below does nothing whatsoever, first milestone of
- * this project is to implement the StatisticsService api
- * 
- */
-
-package org.gnunet.statistics;
-
-import org.gnunet.requests.Request;
-import org.gnunet.requests.RequestQueue;
-import org.gnunet.util.*;
-import org.gnunet.util.getopt.Argument;
-import org.gnunet.util.getopt.ArgumentAction;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.util.ArrayList;
-
-/**
- * API for the gnunet statistics service.
- * <p/>
- * Set, get and monitor statistics values, represented as unsigned 64bit integer.
- * Note that {@literal long}, java's largest primitive type, can only store signed 64bit integers.
- * With absolute operation, its negative values are interpreted as large numbers by the statistics api.
- */
-public class  Statistics {
-    private static final Logger logger = LoggerFactory
-            .getLogger(Statistics.class);
-
-    /**
-     * Time after we give up on setting values in statistics
-     */
-    private static final RelativeTime SET_TIMEOUT = RelativeTime.SECOND.multiply(10);
-
-    private final static int SETFLAG_RELATIVE = 1;
-    private final static int SETFLAG_PERSIST = 2;
-
-    private final Client client;
-
-    private final RequestQueue requestQueue;
-
-    /**
-     * Callback for the current get request. Only one get request ist allowed at a time.
-     */
-    private StatisticsReceiver currentGetReceiver;
-    /**
-     * Success/Error continuation for the current get request.
-     */
-    private Continuation currentGetContinuation;
-
-    /**
-     * List of all watch requests, canceled watch requests are null (but stay due to protocol limitations)
-     */
-    private ArrayList<StatisticsWatchRequest> watchRequests = new ArrayList<StatisticsWatchRequest>();
-
-    /**
-     * A request to the statistics service.
-     */
-    private abstract class StatisticsRequest extends Request {
-        public String name;
-        public String subsystem;
-    }
-
-    private class StatisticsGetRequest extends StatisticsRequest {
-        public StatisticsReceiver receiver;
-
-        public void onCancel(boolean alreadyTransmitted) {
-            currentGetReceiver = null;
-        }
-
-        public void transmit(Connection.MessageSink sink) {
-            GetMessage rm = new GetMessage();
-            rm.statisticsName = name;
-            rm.subsystemName = subsystem;
-
-            sink.send(rm);
-        }
-
-        public boolean onReconnect() {
-            return true;
-        }
-    }
-
-    private class StatisticsSetRequest extends StatisticsRequest {
-        public long value;
-        public int flags;
-
-        public AbsoluteTime getDeadline() {
-            return SET_TIMEOUT.toAbsolute();
-        }
-
-        public void transmit(Connection.MessageSink sink) {
-            SetMessage sm = new SetMessage();
-            sm.statisticName = name;
-            sm.subsystemName = subsystem;
-            sm.value = value;
-            sm.flags = flags;
-            sink.send(sm);
-        }
-
-        public boolean onDestroy() {
-            // keep the request
-            return true;
-        }
-
-        public boolean onReconnect() {
-            // just keep the request on reconnect
-            return true;
-        }
-    }
-
-
-    private class StatisticsWatchRequest extends StatisticsRequest {
-        public StatisticsReceiver receiver;
-
-        public AbsoluteTime getDeadline() {
-            return AbsoluteTime.FOREVER;
-        }
-
-        public void onCancel(boolean alreadyTransmitted) {
-            System.out.println("already transmitted: " + alreadyTransmitted);
-            if (alreadyTransmitted) {
-                watchRequests.set(watchRequests.indexOf(this), null);
-            }
-
-        }
-
-        public boolean onReconnect() {
-            // do this because we'll probably get new WatchIDs for every watch request on reconnect
-            if (watchRequests.contains(this)) {
-                watchRequests.clear();
-            }
-
-            watchRequests.add(this);
-
-            return true;
-        }
-
-        public void transmit(Connection.MessageSink sink) {
-            WatchMessage wm = new WatchMessage();
-            wm.statisticsName = name;
-            wm.subsystemName = subsystem;
-            sink.send(wm);
-
-
-            watchRequests.add(this);
-        }
-    }
-
-    private static class TESTRequest extends Request {
-        private AbsoluteTime deadline;
-
-        public TESTRequest(AbsoluteTime deadline) {
-            this.deadline = deadline;
-        }
-
-        public boolean onDestroy() {
-            // keep on destroy
-            return true;
-        }
-
-        public AbsoluteTime getDeadline() {
-            return deadline;
-        }
-
-        public void transmit(Connection.MessageSink sink) {
-            sink.send(new TestMessage());
-            // todo: disconnect when not receiving the TEST message back after timeout
-        }
-    }
-
-
-    public class StatisticsMessageReceiver extends RunaboutMessageReceiver {
-        public void visit(GetResponseMessage m) {
-            currentGetReceiver.onReceive(m.subsystemName, m.statisticName, m.value);
-        }
-
-        public void visit(GetResponseEndMessage m) {
-            currentGetReceiver = null;
-            if (currentGetContinuation != null) {
-                currentGetContinuation.cont(true);
-            }
-        }
-
-        public void visit(TestMessage m) {
-            client.disconnect();
-        }
-
-        public void visit(WatchResponseMessage wrm) {
-            if (watchRequests.size() <= wrm.wid) {
-                logger.warn("statistics service got confused with watch request");
-                return;
-            }
-            StatisticsWatchRequest wr = watchRequests.get(wrm.wid);
-            // request may have been canceled by the api (but not by the server)
-            if (wr != null) {
-                wr.receiver.onReceive(wr.subsystem, wr.name, wrm.value);
-            }
-        }
-
-        @Override
-        public void handleError() {
-            requestQueue.reconnect();
-        }
-    }
-
-    public Statistics(Configuration cfg) {
-        client = new Client("statistics", cfg);
-        requestQueue = new RequestQueue(this.client, new StatisticsMessageReceiver());
-    }
-
-    /**
-     * Retrieve values from statistics.
-     *
-     * @param timeout      time after we give up and call receiver.onTimeout
-     * @param subsystem    the subsystem of interest
-     * @param name         name of the statistics value belongs to
-     * @param receiver     callback
-     * @param continuation
-     * @return handle to cancel the request
-     */
-    public Cancelable get(RelativeTime timeout, final String subsystem, final String name,
-                          final StatisticsReceiver receiver, Continuation continuation) {
-
-        if (currentGetReceiver != null) {
-            throw new AssertionError("only one Statistics get request can be active at a time");
-        }
-        currentGetReceiver = receiver;
-        currentGetContinuation = continuation;
-
-        final StatisticsGetRequest getRequest = new StatisticsGetRequest();
-        getRequest.setDeadline(timeout.toAbsolute());
-        getRequest.name = (name == null) ? "" : name;
-        getRequest.subsystem = (subsystem == null) ? "" : subsystem;
-        getRequest.receiver = receiver;
-
-        return requestQueue.add(getRequest);
-    }
-
-
-    /**
-     * Sets a statistics value asynchronously.
-     *
-     * @param name    name of the entry
-     * @param value   desired value
-     * @param persist keep value even if the statistics service restarts
-     * @return a handle to cancel the request
-     */
-    public Cancelable set(final String subsystem, final String name, final long value, boolean persist) {
-        StatisticsSetRequest setRequest = new StatisticsSetRequest();
-        setRequest.setDeadline(SET_TIMEOUT.toAbsolute());
-        setRequest.subsystem = subsystem;
-        setRequest.name = name;
-        setRequest.value = value;
-        setRequest.flags = persist ? SETFLAG_PERSIST : 0;
-
-        return requestQueue.add(setRequest);
-    }
-
-    /**
-     * Changes a statistics value asynchronously.
-     *
-     * @param name    name of the entry
-     * @param delta   relative difference to the old value
-     * @param persist keep value even if the statistics service restarts
-     * @return a handle to cancel the request
-     */
-    public Cancelable update(final String subsystem, final String name, final long delta, boolean persist) {
-        StatisticsSetRequest setRequest = new StatisticsSetRequest();
-        setRequest.setDeadline(SET_TIMEOUT.toAbsolute());
-        setRequest.subsystem = subsystem;
-        setRequest.name = name;
-        setRequest.value = delta;
-        setRequest.flags = (persist ? SETFLAG_PERSIST : 0) | SETFLAG_RELATIVE;
-
-        return requestQueue.add(setRequest);
-    }
-
-    public Cancelable watch(final String subsystem, final String name, StatisticsReceiver receiver) {
-        StatisticsWatchRequest watchRequest = new StatisticsWatchRequest();
-        watchRequest.setDeadline(AbsoluteTime.FOREVER);
-        watchRequest.name = name;
-        watchRequest.subsystem = subsystem;
-        watchRequest.receiver = receiver;
-
-        // even after the request has been sent, we want to keep it
-        // (e.g. for retransmission on reconnect)
-        return requestQueue.addPersistent(watchRequest);
-    }
-
-    /**
-     * Destroy handle to the statistics service. Always finishes writing pending values.
-     */
-    public void destroy() {
-        // the request queue handles the destruction, maybe we still have important messages pending etc.
-        requestQueue.add(new TESTRequest(SET_TIMEOUT.toAbsolute()));
-        requestQueue.shutdown();
-    }
-
-
-    /**
-     * Statistics command line utility entry point
-     *
-     * @param args command line arguments
-     */
-    public static void main(String[] args) {
-        new Program(args) {
-            @Argument(
-                    shortname = "x",
-                    longname = "set",
-                    action = ArgumentAction.SET,
-                    description = "set a value")
-            boolean test;
-            @Argument(
-                    shortname = "w",
-                    longname = "watch",
-                    action = ArgumentAction.SET,
-                    description = "set a value")
-            boolean watch;
-            @Argument(
-                    shortname = "n",
-                    longname = "name",
-                    action = ArgumentAction.STORE_STRING,
-                    description = "statistics name")
-            String statisticsName = "";
-            @Argument(
-                    shortname = "s",
-                    longname = "subsystem",
-                    action = ArgumentAction.STORE_STRING,
-                    description = "subsystem name")
-            String subsystemName = "";
-
-            public void run() {
-                final Statistics statistics = new Statistics(cfg);
-                if (test) {
-                    if (subsystemName.isEmpty() || statisticsName.isEmpty()) {
-                        System.err.println("must specify non-empty subsystem and name");
-                        return;
-                    }
-                    if (unprocessedArgs.length != 1) {
-                        System.err.println("must specify exactly one value to set");
-                        return;
-                    }
-                    long value;
-                    try {
-                        value = Long.parseLong(unprocessedArgs[0]);
-                    } catch (NumberFormatException e) {
-                        System.err.println("invalid value (not a long)");
-                        return;
-                    }
-                    statistics.set(subsystemName, statisticsName, value, false);
-                    statistics.destroy();
-                } else {
-                    if (unprocessedArgs.length == 0) {
-                        if (watch) {
-                            statistics.watch(subsystemName, statisticsName,
-                                    new StatisticsReceiver() {
-                                        @Override
-                                        public void onReceive(String subsystem, String name, long value) {
-                                            System.out.println(subsystem + "(" + name + ") = " + value);
-                                        }
-                                    }
-                            );
-                        } else {
-                            statistics.get(RelativeTime.SECOND, subsystemName, statisticsName,
-                                    new StatisticsReceiver() {
-                                        @Override
-                                        public void onReceive(String subsystem, String name, long value) {
-                                            System.out.println(subsystem + "(" + name + ") = " + value);
-                                        }
-                                    },
-                                    new Continuation() {
-                                        @Override
-                                        public void cont(boolean success) {
-                                            statistics.destroy();
-                                        }
-                                    }
-                            );
-                        }
-                    } else {
-                        System.err.println("dumping statistics does not take any positional parameters");
-                    }
-                }
-            }
-        }.start();
-    }
-
-}
diff --git a/src/org/gnunet/transport/BlacklistCallback.java b/src/org/gnunet/transport/BlacklistCallback.java
deleted file mode 100644
index a9da35f..0000000
--- a/src/org/gnunet/transport/BlacklistCallback.java
+++ /dev/null
@@ -1,9 +0,0 @@
-package org.gnunet.transport;
-
-/**
- * ...
- *
- * @author Florian Dold
- */
-public class BlacklistCallback {
-}
diff --git a/src/org/gnunet/transport/PeerIterateCallback.java b/src/org/gnunet/transport/PeerIterateCallback.java
deleted file mode 100644
index da9a3ae..0000000
--- a/src/org/gnunet/transport/PeerIterateCallback.java
+++ /dev/null
@@ -1,9 +0,0 @@
-package org.gnunet.transport;
-
-/**
- * ...
- *
- * @author Florian Dold
- */
-public class PeerIterateCallback {
-}
diff --git a/src/org/gnunet/util/HelperProcess.java b/src/org/gnunet/util/HelperProcess.java
deleted file mode 100644
index 5b0458f..0000000
--- a/src/org/gnunet/util/HelperProcess.java
+++ /dev/null
@@ -1,21 +0,0 @@
-package org.gnunet.util;
-
-/**
- * A helper process is a process that can be started, shut down and communicated with asynchronously.
- *
- * @author Florian Dold
- */
-public class HelperProcess {
-
-    public void HelperProcess(String name, String... args) {
-
-    }
-
-    public void readLine() {
-
-    }
-
-    public void write(String s) {
-
-    }
-}
diff --git a/src/test/java/org/gnunet/construct/ByteFillMessage.java b/src/test/java/org/gnunet/construct/ByteFillMessage.java
new file mode 100644
index 0000000..090f7d0
--- /dev/null
+++ b/src/test/java/org/gnunet/construct/ByteFillMessage.java
@@ -0,0 +1,32 @@
+/*
+ This file is part of GNUnet.
+ (C) 2011, 2012 Christian Grothoff (and other contributing authors)
+
+ GNUnet is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published
+ by the Free Software Foundation; either version 3, or (at your
+ option) any later version.
+
+ GNUnet is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with GNUnet; see the file COPYING.  If not, write to the
+ Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA.
+ */
+
+package org.gnunet.construct;
+
+
+public class ByteFillMessage implements Message {
+    
+    @UInt32
+    public int someValue;
+
+    @FillWith @UInt8
+    public byte[] rest;
+    
+}
diff --git a/src/test/java/org/gnunet/construct/ConstructTest.java b/src/test/java/org/gnunet/construct/ConstructTest.java
new file mode 100644
index 0000000..ed6ac51
--- /dev/null
+++ b/src/test/java/org/gnunet/construct/ConstructTest.java
@@ -0,0 +1,82 @@
+package org.gnunet.construct;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.Random;
+
+/**
+ * @author Florian Dold
+ */
+public class ConstructTest {
+    public static class ByteFillTestMessage implements Message {
+        @FrameSize
+        @UInt32
+        public int frameSize;
+        @FillWith @UInt8
+        public byte[] bytes;
+    }
+
+    @Test
+    public void test_ByteFill() {
+        ByteFillTestMessage msg = new ByteFillTestMessage();
+        msg.bytes = new byte[]{0,1,2,3};
+        Construct.patch(msg);
+        byte[] bin = Construct.toBinary(msg);
+
+        ByteFillTestMessage msg_r = Construct.parseAs(bin, ByteFillTestMessage.class);
+
+        Assert.assertArrayEquals(new byte[]{0,1,2,3}, msg_r.bytes);
+    }
+
+
+    @Test
+    public void test_IntMessage() {
+        IntMessage im = new IntMessage();
+        Random r = new Random();
+        im.i1 = r.nextLong();
+        im.i2 = r.nextLong();
+        im.i3 = r.nextLong();
+        im.i4 = r.nextLong();
+        im.i5 = r.nextLong();
+        im.i6 = r.nextLong();
+        im.i7 = r.nextLong();
+        im.i8 = r.nextLong();
+
+        byte[] data = Construct.toBinary(im);
+
+        Construct.parseAs(data, IntMessage.class);
+
+        Assert.assertEquals((1+2+4+8)*2, data.length);
+        Assert.assertEquals((1+2+4+8)*2, Construct.getStaticSize(im));
+    }
+
+    @Test(expected = AssertionError.class)
+    public void test_PrivateMemberMessage() {
+        PrivateMemberMessage m1 = new PrivateMemberMessage();
+        byte[] data = Construct.toBinary(m1);
+        Construct.parseAs(data, PrivateMemberMessage.class);
+    }
+
+
+    @Test
+    public void test_variable_size() {
+        VariableSizeMessage m1 = new VariableSizeMessage();
+        m1.n1 = 2;
+        m1.n2 = 3;
+        m1.a1 = new int[]{42,43};
+        m1.a2 = new int[]{1,2,1000};
+
+        byte[] data = Construct.toBinary(m1);
+
+        VariableSizeMessage m2 = Construct.parseAs(data, VariableSizeMessage.class);
+
+        Assert.assertEquals(m1.n1, m2.n1);
+        Assert.assertEquals(m1.n2, m2.n2);
+        Assert.assertArrayEquals(m1.a1, m2.a1);
+        Assert.assertArrayEquals(m1.a2, m2.a2);
+    }
+
+
+}
+
diff --git a/src/test/java/org/gnunet/construct/DoubleTest.java b/src/test/java/org/gnunet/construct/DoubleTest.java
new file mode 100644
index 0000000..c66bd93
--- /dev/null
+++ b/src/test/java/org/gnunet/construct/DoubleTest.java
@@ -0,0 +1,35 @@
+package org.gnunet.construct;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * ...
+ *
+ * @author Florian Dold
+ */
+public class DoubleTest {
+    public static class DoubleMessage implements Message {
+        @DoubleValue
+        public double d1;
+        @DoubleValue
+        public double d2;
+    }
+
+    @Test
+    public void test_double() {
+        DoubleMessage m = new DoubleMessage();
+        m.d1 = 1.123;
+        m.d2 = java.lang.Double.NaN;
+
+        byte[] data = Construct.toBinary(m);
+
+        DoubleMessage m2 = Construct.parseAs(data, DoubleMessage.class);
+
+        Assert.assertEquals(m.d1, m2.d1, 0);
+        Assert.assertEquals(m.d2, m2.d2, 0);
+
+        Assert.assertEquals(8+8, data.length);
+    }
+
+}
diff --git a/src/test/java/org/gnunet/construct/FillParserTest.java b/src/test/java/org/gnunet/construct/FillParserTest.java
new file mode 100644
index 0000000..d982088
--- /dev/null
+++ b/src/test/java/org/gnunet/construct/FillParserTest.java
@@ -0,0 +1,37 @@
+package org.gnunet.construct;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * ...
+ *
+ * @author Florian Dold
+ */
+public class FillParserTest {
+
+    public static class FillTestMessage implements Message {
+        @FrameSize
+        @UInt32
+        public int size;
+        @FillWith
+        public StringTuple[] strings;
+    }
+
+    @Test
+    public void test_fillParser() {
+        FillTestMessage m = new FillTestMessage();
+        m.strings = new StringTuple[]{new StringTuple("foo", "bar"), new StringTuple("quux", "spam")};
+        Construct.patch(m);
+        System.out.println(m.size);
+        byte[] data = Construct.toBinary(m);
+        Assert.assertEquals(m.size, data.length);
+
+        FillTestMessage m2 = Construct.parseAs(data, FillTestMessage.class);
+
+        Assert.assertEquals(m.strings.length, m2.strings.length);
+
+        Assert.assertEquals(m.strings[0], m2.strings[0]);
+        Assert.assertEquals(m.strings[1], m2.strings[1]);
+    }
+}
diff --git a/src/test/java/org/gnunet/construct/FixedSizeTest.java b/src/test/java/org/gnunet/construct/FixedSizeTest.java
new file mode 100644
index 0000000..149862c
--- /dev/null
+++ b/src/test/java/org/gnunet/construct/FixedSizeTest.java
@@ -0,0 +1,52 @@
+package org.gnunet.construct;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * ...
+ *
+ * @author Florian Dold
+ */
+public class FixedSizeTest {
+
+    public static class Msg implements Message {
+        @UInt8
+        public int v;
+
+        public Msg() {
+            // default ctor required by Construct
+        }
+
+        public Msg(int v) {
+            this.v = v;
+        }
+    }
+
+    public static class FixedSizeTestMessage implements Message {
+        @FixedSizeArray(length = 4)
+        public Msg[] msgs;
+    }
+
+
+    @Test
+    public void test_fixedNested() {
+        FixedSizeTestMessage m = new FixedSizeTestMessage();
+        m.msgs = new Msg[]{new Msg(1), new Msg(2), new Msg(3), new Msg(4)};
+        byte[] bytes = Construct.toBinary(m);
+
+        FixedSizeTestMessage m2 = Construct.parseAs(bytes, FixedSizeTestMessage.class);
+
+        Assert.assertEquals(m.msgs[0].v, m2.msgs[0].v);
+        Assert.assertEquals(m.msgs[1].v, m2.msgs[1].v);
+        Assert.assertEquals(m.msgs[2].v, m2.msgs[2].v);
+        Assert.assertEquals(m.msgs[3].v, m2.msgs[3].v);
+    }
+
+    @Test(expected = AssertionError.class)
+    public void test_sizeMismatch() {
+        FixedSizeTestMessage m = new FixedSizeTestMessage();
+        m.msgs = new Msg[]{new Msg(1), new Msg(2)};
+        Construct.toBinary(m);
+    }
+}
diff --git a/src/test/java/org/gnunet/construct/FrameSizeTest.java b/src/test/java/org/gnunet/construct/FrameSizeTest.java
new file mode 100644
index 0000000..1aa53e2
--- /dev/null
+++ b/src/test/java/org/gnunet/construct/FrameSizeTest.java
@@ -0,0 +1,50 @@
+package org.gnunet.construct;
+
+import org.junit.Assert;
+import org.gnunet.util.GnunetMessage;
+import org.junit.Test;
+
+/**
+ * ...
+ *
+ * @author Florian Dold
+ */
+public class FrameSizeTest {
+    public static class CoordMessage implements Message {
+        @FrameSize
+        @UInt32
+        public int size;
+        @UInt32
+        public int x;
+        @UInt8
+        public int y;
+    }
+
+    public static class RecursiveMessage implements Message {
+        @FrameSize
+        @UInt32
+        public int size;
+
+        @ZeroTerminatedString
+        public String data;
+
+        @NestedMessage(newFrame = true, optional = true)
+        public RecursiveMessage rec;
+
+    }
+
+    @Test
+    public void test_simple() {
+        CoordMessage m = new CoordMessage();
+        Construct.patch(m);
+        Assert.assertEquals(9, m.size);
+    }
+
+
+    //@Test
+    public void test_recursive_1() {
+        RecursiveMessage rm = new RecursiveMessage();
+        rm.data = "foo";
+        Construct.patch(rm);
+    }
+}
diff --git a/src/test/java/org/gnunet/construct/IntMessage.java b/src/test/java/org/gnunet/construct/IntMessage.java
new file mode 100644
index 0000000..14971b2
--- /dev/null
+++ b/src/test/java/org/gnunet/construct/IntMessage.java
@@ -0,0 +1,25 @@
+package org.gnunet.construct;
+
+/**
+ * ...
+ *
+ * @author Florian Dold
+ */
+public class IntMessage implements Message {
+    @UInt64
+    public long i1;
+    @UInt32
+    public long i2;
+    @UInt16
+    public long i3;
+    @UInt8
+    public long i4;
+    @Int64
+    public long i5;
+    @Int32
+    public long i6;
+    @Int16
+    public long i7;
+    @Int8
+    public long i8;
+}
diff --git a/src/test/java/org/gnunet/construct/OptionalUnionTest.java b/src/test/java/org/gnunet/construct/OptionalUnionTest.java
new file mode 100644
index 0000000..1c45972
--- /dev/null
+++ b/src/test/java/org/gnunet/construct/OptionalUnionTest.java
@@ -0,0 +1,72 @@
+package org.gnunet.construct;
+
+import org.junit.Assert;
+import org.gnunet.util.GnunetMessage;
+import org.junit.Test;
+
+/**
+ * ...
+ *
+ * @author Florian Dold
+ */
+public class OptionalUnionTest {
+    public interface TestUnion extends MessageUnion {}
+    @UnionCase(1)
+    public static class UnionMember1 implements TestUnion {
+        @ZeroTerminatedString
+        public String str;
+    }
+    @UnionCase(2)
+    public static class UnionMember2 implements TestUnion {
+        @Int32
+        public int i;
+    }
+
+    public static class OptionalUnionMessage implements Message {
+        @FrameSize
+        @UInt32
+        public int size;
+        @UInt32
+        public int tag;
+        @Union(tag = "tag", optional = true)
+        public TestUnion x;
+    }
+
+    public void setupMessageMap() {
+        MessageLoader.registerUnionCase(TestUnion.class, UnionMember1.class, 1);
+        MessageLoader.registerUnionCase(TestUnion.class, UnionMember2.class, 2);
+    }
+
+    @Test
+    public void test_optional_union1() {
+        setupMessageMap();
+
+        OptionalUnionMessage m = new OptionalUnionMessage();
+        UnionMember1 u1 = new UnionMember1();
+        u1.str = "foo";
+        m.x = u1;
+
+        Construct.patch(m);
+        byte[] data = Construct.toBinary(m);
+
+        System.out.println(data.length);
+
+        OptionalUnionMessage m2 = Construct.parseAs(data, OptionalUnionMessage.class);
+
+        Assert.assertNotNull(m2.x);
+    }
+
+    @Test
+    public void test_optional_union2() {
+        setupMessageMap();
+
+        OptionalUnionMessage m = new OptionalUnionMessage();
+
+        byte[] data = Construct.toBinary(m);
+
+        OptionalUnionMessage m2 = Construct.parseAs(data, OptionalUnionMessage.class);
+
+        Assert.assertNull(m2.x);
+
+    }
+}
diff --git a/src/test/java/org/gnunet/construct/PrivateMemberMessage.java b/src/test/java/org/gnunet/construct/PrivateMemberMessage.java
new file mode 100644
index 0000000..726d1b7
--- /dev/null
+++ b/src/test/java/org/gnunet/construct/PrivateMemberMessage.java
@@ -0,0 +1,13 @@
+package org.gnunet.construct;
+
+/**
+ * ...
+ *
+ * @author Florian Dold
+ */
+public class PrivateMemberMessage implements Message {
+    @UInt32
+    public int foo;
+    @UInt32
+    private int bar;
+}
diff --git a/src/test/java/org/gnunet/construct/QueryMessage.java b/src/test/java/org/gnunet/construct/QueryMessage.java
new file mode 100644
index 0000000..4bf9af5
--- /dev/null
+++ b/src/test/java/org/gnunet/construct/QueryMessage.java
@@ -0,0 +1,31 @@
+/*
+ This file is part of GNUnet.
+ (C) 2011, 2012 Christian Grothoff (and other contributing authors)
+
+ GNUnet is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published
+ by the Free Software Foundation; either version 3, or (at your
+ option) any later version.
+
+ GNUnet is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with GNUnet; see the file COPYING.  If not, write to the
+ Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA.
+ */
+
+package org.gnunet.construct;
+
+public class QueryMessage implements Message {
+
+
+    @UInt8
+    public int query;
+
+    @FillWith @UInt8
+    public byte[] varsize;
+}
diff --git a/src/test/java/org/gnunet/construct/SendMessageTest.java b/src/test/java/org/gnunet/construct/SendMessageTest.java
new file mode 100644
index 0000000..b95cc78
--- /dev/null
+++ b/src/test/java/org/gnunet/construct/SendMessageTest.java
@@ -0,0 +1,34 @@
+package org.gnunet.construct;
+
+import org.gnunet.core.SendMessage;
+import org.gnunet.util.AbsoluteTime;
+import org.gnunet.util.GnunetMessage;
+import org.gnunet.util.PeerIdentity;
+import org.gnunet.util.TestMessage;
+import org.junit.Test;
+
+/**
+ * Regression test for a message class in org.gnunet.core
+ *
+ * todo: should this test be really here?
+ *
+ * @author Florian Dold
+ */
+public class SendMessageTest {
+
+    @Test
+    public void test_patch() {
+        SendMessage m = new SendMessage();
+        m.deadline = AbsoluteTime.FOREVER.asMessage();
+        m.peer = new PeerIdentity(); // null identity
+        m.payloadMessage = new GnunetMessage();
+        m.payloadMessage.body = new TestMessage();
+        m.payloadMessage.header = new GnunetMessage.Header();
+
+        GnunetMessage container = new GnunetMessage();
+        container.body = m;
+        container.header = new GnunetMessage.Header();
+
+        Construct.patch(container);
+    }
+}
diff --git a/src/test/java/org/gnunet/construct/StringMessage.java b/src/test/java/org/gnunet/construct/StringMessage.java
new file mode 100644
index 0000000..20158a1
--- /dev/null
+++ b/src/test/java/org/gnunet/construct/StringMessage.java
@@ -0,0 +1,32 @@
+/*
+ This file is part of GNUnet.
+ (C) 2011, 2012 Christian Grothoff (and other contributing authors)
+
+ GNUnet is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published
+ by the Free Software Foundation; either version 3, or (at your
+ option) any later version.
+
+ GNUnet is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with GNUnet; see the file COPYING.  If not, write to the
+ Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA.
+ */
+
+package org.gnunet.construct;
+
+public class StringMessage implements Message {
+    @UInt8
+    public int num;
+    
+    @ZeroTerminatedString
+    public String str;
+    
+    @UInt8
+    public int num2;
+}
diff --git a/src/test/java/org/gnunet/construct/StringTest.java b/src/test/java/org/gnunet/construct/StringTest.java
new file mode 100644
index 0000000..7dbedab
--- /dev/null
+++ b/src/test/java/org/gnunet/construct/StringTest.java
@@ -0,0 +1,50 @@
+package org.gnunet.construct;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * ...
+ *
+ * @author Florian Dold
+ */
+public class StringTest {
+    public static class StrMsg implements Message {
+        @FrameSize
+        @UInt32
+        public int len;
+        @ZeroTerminatedString(optional = false)
+        public String str1;
+        @ZeroTerminatedString(optional = true)
+        public String str2;
+    }
+
+
+    @Test
+    public void test_empty() {
+        StrMsg m = new StrMsg();
+        m.str1 = "";
+        m.str2 = "";
+        Construct.patch(m);
+        byte[] data = Construct.toBinary(m);
+        Assert.assertEquals(4+1+1, data.length);
+        StrMsg m2 = Construct.parseAs(data, StrMsg.class);
+        Assert.assertEquals("", m2.str1);
+        Assert.assertEquals("", m2.str2);
+    }
+
+    @Test
+    public void test_null() {
+        StrMsg m = new StrMsg();
+        m.str1 = "";
+        m.str2 = null;
+        Construct.patch(m);
+        byte[] data = Construct.toBinary(m);
+        Assert.assertEquals(4+1, data.length);
+        Assert.assertEquals(4+1, m.len);
+        StrMsg m2 = Construct.parseAs(data, StrMsg.class);
+        Assert.assertEquals("", m2.str1);
+        Assert.assertEquals(null, m2.str2);
+    }
+}
+
diff --git a/src/test/java/org/gnunet/construct/StringTuple.java b/src/test/java/org/gnunet/construct/StringTuple.java
new file mode 100644
index 0000000..1820ae1
--- /dev/null
+++ b/src/test/java/org/gnunet/construct/StringTuple.java
@@ -0,0 +1,37 @@
+package org.gnunet.construct;
+
+import com.google.common.base.Objects;
+import com.google.common.hash.HashCodes;
+
+/**
+* ...
+*
+* @author Florian Dold
+*/
+public class StringTuple implements Message {
+    @ZeroTerminatedString
+    public String str1;
+    @ZeroTerminatedString
+    public String str2;
+
+    public StringTuple() {
+        // empty default ctor needed by Construct
+    }
+    public StringTuple(String str1, String str2) {
+        this.str1 = str1;
+        this.str2 = str2;
+    }
+    @Override
+    public boolean equals(Object other) {
+        if (!(other instanceof StringTuple)) {
+            return false;
+        }
+        StringTuple otherT = (StringTuple) other;
+        return otherT.str1.equals(this.str1) && otherT.str2.equals(this.str2);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(str1, str2);
+    }
+}
diff --git a/src/test/java/org/gnunet/construct/VariableSizeArrayTest.java b/src/test/java/org/gnunet/construct/VariableSizeArrayTest.java
new file mode 100644
index 0000000..e6772a1
--- /dev/null
+++ b/src/test/java/org/gnunet/construct/VariableSizeArrayTest.java
@@ -0,0 +1,33 @@
+package org.gnunet.construct;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * ...
+ *
+ * @author Florian Dold
+ */
+public class VariableSizeArrayTest {
+    public static class VariableTestMessage implements Message {
+        @UInt32
+        public int num;
+        @VariableSizeArray(lengthField = "num")
+        public StringTuple[] msgs;
+    }
+
+    @Test
+    public void test_variableSizeArray() {
+        VariableTestMessage m = new VariableTestMessage();
+        m.msgs = new StringTuple[]{new StringTuple("foo", "bar"), new StringTuple("quux", "baz"), new StringTuple("spam", "eggs")};
+        Construct.patch(m);
+        Assert.assertEquals(3, m.num);
+        byte[] data = Construct.toBinary(m);
+        VariableTestMessage m2 = Construct.parseAs(data, VariableTestMessage.class);
+        Assert.assertEquals(m2.num, 3);
+        Assert.assertEquals(m.msgs[0], m2.msgs[0]);
+        Assert.assertEquals(m.msgs[1], m2.msgs[1]);
+        Assert.assertEquals(m.msgs[2], m2.msgs[2]);
+
+    }
+}
diff --git a/src/test/java/org/gnunet/construct/VariableSizeMessage.java b/src/test/java/org/gnunet/construct/VariableSizeMessage.java
new file mode 100644
index 0000000..9444108
--- /dev/null
+++ b/src/test/java/org/gnunet/construct/VariableSizeMessage.java
@@ -0,0 +1,17 @@
+package org.gnunet.construct;
+
+/**
+ * ...
+ *
+ * @author Florian Dold
+ */
+public class VariableSizeMessage implements Message {
+    @UInt16
+    public int n1;
+    @VariableSizeIntegerArray(lengthField = "n1", signed = false, bitSize = 16)
+    public int[] a1;
+    @UInt16
+    public int n2;
+    @VariableSizeIntegerArray(lengthField = "n2", signed = false, bitSize = 16)
+    public int[] a2;
+}
diff --git a/src/test/java/org/gnunet/core/CoreTest.java b/src/test/java/org/gnunet/core/CoreTest.java
new file mode 100644
index 0000000..0cb7817
--- /dev/null
+++ b/src/test/java/org/gnunet/core/CoreTest.java
@@ -0,0 +1,111 @@
+/*
+ This file is part of GNUnet.
+ (C) 2011, 2012 Christian Grothoff (and other contributing authors)
+
+ GNUnet is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published
+ by the Free Software Foundation; either version 3, or (at your
+ option) any later version.
+
+ GNUnet is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with GNUnet; see the file COPYING.  If not, write to the
+ Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA.
+ */
+
+package org.gnunet.core;
+
+
+import org.gnunet.testing.TestingFixture;
+import org.gnunet.testing.TestingSetup;
+import org.gnunet.testing.TestingSubsystem;
+import org.gnunet.util.*;
+import org.grothoff.Runabout;
+import org.junit.Assert;
+import org.junit.Test;
+
+import static org.junit.Assert.assertTrue;
+
+public class CoreTest extends TestingFixture {
+    @Test(timeout = 10000)
+    public void test_core_init() {
+        Program.configureLogging("DEBUG");
+        TestingSubsystem ts = new TestingSubsystem("core");
+
+        final Wrapper<Boolean> res = new Wrapper<Boolean>(false);
+
+        final Core core = new Core(ts.getConfiguration());
+        core.observeConnect(new ConnectHandler() {
+            @Override
+            public void onConnect(PeerIdentity peerIdentity) {
+            }
+        });
+        core.init(new InitCallback() {
+            @Override
+            public void onInit(PeerIdentity myIdentity) {
+                res.value = true;
+                System.out.println("in core init");
+                assertTrue(myIdentity != null);
+                core.disconnect();
+            }
+        });
+
+        Scheduler.run();
+
+        ts.destroy();
+
+        assertTrue(res.value);
+    }
+
+
+    @Test(timeout = 10000)
+    public void test_core_echo() {
+        Program.configureLogging("DEBUG");
+        new TestingSubsystem("core");
+        new TestingSubsystem("core");
+        new TestingSubsystem("core");
+        new TestingSubsystem("core");
+        TestingSubsystem ts = new TestingSubsystem("core");
+
+        final Wrapper<Boolean> gotResponse = new Wrapper<Boolean>(false);
+
+        final Core core = new Core(ts.getConfiguration());
+        core.setMessageHandler(new Runabout() {
+            public void visit(TestMessage t) {
+                gotResponse.set(true);
+                core.disconnect();
+            }
+        });
+
+        core.init(new InitCallback() {
+            @Override
+            public void onInit(PeerIdentity myIdentity) {
+                System.out.println("in core init");
+                core.notifyTransmitReady(0, RelativeTime.FOREVER, myIdentity, 4, new MessageTransmitter() {
+                    @Override
+                    public void transmit(Connection.MessageSink sink) {
+                        System.out.println("ntr called, calling send");
+                        sink.send(new TestMessage());
+                    }
+
+                    @Override
+                    public void handleError() {
+                        Assert.fail();
+                    }
+                });
+            }
+        });
+
+        Scheduler.run();
+
+        ts.destroy();
+
+        assertTrue(gotResponse.get());
+
+    }
+}
diff --git a/src/test/java/org/gnunet/dht/DHTTest.java b/src/test/java/org/gnunet/dht/DHTTest.java
new file mode 100644
index 0000000..9540af1
--- /dev/null
+++ b/src/test/java/org/gnunet/dht/DHTTest.java
@@ -0,0 +1,171 @@
+/*
+ This file is part of GNUnet.
+ (C) 2011, 2012 Christian Grothoff (and other contributing authors)
+
+ GNUnet is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published
+ by the Free Software Foundation; either version 3, or (at your
+ option) any later version.
+
+ GNUnet is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with GNUnet; see the file COPYING.  If not, write to the
+ Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA.
+ */
+
+package org.gnunet.dht;
+
+import static org.junit.Assert.*;
+
+import org.gnunet.testing.TestingFixture;
+import org.gnunet.testing.TestingSubsystem;
+import org.gnunet.util.*;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.EnumSet;
+import java.util.List;
+
+public class DHTTest extends TestingFixture  {
+    @Test(timeout = 1000)
+    public void test_dht_put() {
+        Program.configureLogging();
+
+        final Wrapper<Boolean> putFinished = new Wrapper<Boolean>(true);
+
+        TestingSubsystem ts = new TestingSubsystem("dht");
+
+        final DistributedHashTable dht = new DistributedHashTable(ts.getConfiguration());
+        dht.put(new HashCode("gnj-test"), new byte[]{1, 2, 3}, 1, EnumSet.noneOf(RouteOption.class),
+                BlockType.TEST.val, RelativeTime.HOUR.toAbsolute(), RelativeTime.FOREVER, new Continuation() {
+            @Override
+            public void cont(boolean success) {
+                putFinished.set(true);
+                dht.destroy();
+            }
+        });
+
+        Scheduler.run();
+        Assert.assertTrue(putFinished.get());
+    }
+
+    @Test
+    public void test_dht_put_get() {
+        Program.configureLogging();
+
+        final Wrapper<Boolean> getFinished = new Wrapper<Boolean>(true);
+
+        TestingSubsystem ts = new TestingSubsystem("dht");
+
+        final HashCode hash1 = new HashCode("gnj-test");
+        final byte[] data = new byte[]{1, 2, 3};
+
+        final DistributedHashTable dht = new DistributedHashTable(ts.getConfiguration());
+        dht.put(hash1, data, 1, EnumSet.noneOf(RouteOption.class),
+                BlockType.TEST.val, RelativeTime.HOUR.toAbsolute(), RelativeTime.FOREVER, new Continuation() {
+            @Override
+            public void cont(boolean success) {
+                dht.startGet(RelativeTime.FOREVER, BlockType.TEST.val, hash1, 1, EnumSet.noneOf(RouteOption.class), null, new ResultCallback() {
+                    @Override
+                    public void handleResult(AbsoluteTime expiration, HashCode key, List<PeerIdentity> getPath, List<PeerIdentity> putPath, BlockType type, byte[] recData) {
+                        assertArrayEquals(data, recData);
+                        getFinished.set(true);
+                        dht.destroy();
+                    }
+                });
+            }
+        });
+
+        Scheduler.run();
+        Assert.assertTrue(getFinished.get());
+    }
+
+
+    @Test(timeout = 500)
+    public void test_dht_monitor_put() {
+        Program.configureLogging();
+
+        final Wrapper<Integer> putMonitorCount = new Wrapper<Integer>(0);
+
+        TestingSubsystem ts = new TestingSubsystem("dht");
+
+        final HashCode hash = new HashCode("gnj-test");
+        final byte[] data1 = new byte[]{1, 2, 3};
+
+        final byte[] data2 = new byte[]{5, 4, 1, 2, 6};
+
+        final DistributedHashTable dht = new DistributedHashTable(ts.getConfiguration());
+
+        dht.startMonitor(BlockType.TEST.val, hash, null, null, new MonitorPutHandler() {
+            @Override
+            public void onPut(int options, int type, int hop_count, AbsoluteTimeMessage expirationTime, PeerIdentity[] putPath, HashCode key, byte[] data) {
+                putMonitorCount.set(putMonitorCount.get() + 1);
+                if (putMonitorCount.get() == 2) {
+                    dht.destroy();
+                }
+            }
+        });
+
+        Scheduler.addDelayed(new RelativeTime(50), new Scheduler.Task() {
+            @Override
+            public void run(Scheduler.RunContext ctx) {
+                dht.put(hash, data1, 1, EnumSet.noneOf(RouteOption.class), BlockType.TEST.val, RelativeTime.HOUR.toAbsolute(), RelativeTime.FOREVER, null);
+            }
+        });
+
+
+        Scheduler.addDelayed(new RelativeTime(100), new Scheduler.Task() {
+            @Override
+            public void run(Scheduler.RunContext ctx) {
+                dht.put(hash, data2, 1, EnumSet.noneOf(RouteOption.class), BlockType.TEST.val, RelativeTime.HOUR.toAbsolute(), RelativeTime.FOREVER, null);
+            }
+        });
+
+
+        Scheduler.run();
+        Assert.assertTrue(putMonitorCount.get() == 2);
+    }
+
+    @Test(timeout = 500)
+    public void test_dht_monitor_get() {
+        Program.configureLogging("debug");
+
+        final Wrapper<Boolean> ok = new Wrapper<Boolean>(false);
+
+        TestingSubsystem ts = new TestingSubsystem("dht");
+
+        final HashCode hash = new HashCode("gnj-test");
+
+        final DistributedHashTable dht1 = new DistributedHashTable(ts.getConfiguration());
+        final DistributedHashTable dht2 = new DistributedHashTable(ts.getConfiguration());
+
+        dht1.startMonitor(BlockType.TEST.val, hash, new MonitorGetHandler() {
+            @Override
+            public void onGet(int options, int type, int hop_count, int desired_replication_level, PeerIdentity[] getPath, HashCode key) {
+                System.out.println("here!");
+                ok.set(true);
+                dht2.destroy();
+                dht1.destroy();
+            }
+        }, null, null);
+
+        Scheduler.addDelayed(RelativeTime.fromMilliseconds(50), new Scheduler.Task() {
+            @Override
+            public void run(Scheduler.RunContext ctx) {
+                dht2.startGet(RelativeTime.FOREVER, BlockType.TEST.val, hash, 1, EnumSet.noneOf(RouteOption.class), null, null);
+            }
+        });
+
+
+        Scheduler.run();
+        Assert.assertTrue(ok.get());
+    }
+
+
+}
+
diff --git a/src/test/java/org/gnunet/mesh/MeshTest.java b/src/test/java/org/gnunet/mesh/MeshTest.java
new file mode 100644
index 0000000..ad5eaa3
--- /dev/null
+++ b/src/test/java/org/gnunet/mesh/MeshTest.java
@@ -0,0 +1,47 @@
+package org.gnunet.mesh;
+
+import org.gnunet.testing.TestingFixture;
+import org.gnunet.testing.TestingSubsystem;
+import org.gnunet.util.*;
+import org.junit.Test;
+import java.lang.Void;
+
+/**
+ * ...
+ *
+ * @author Florian Dold
+ */
+public class MeshTest extends TestingFixture {
+    public static class MessageHandler1 extends MeshRunabout {
+        public Mesh m1;
+        public Mesh m2;
+        public void visit(TestMessage m) {
+            m1.destroy();
+            m2.destroy();
+        }
+    }
+    //@Test
+    public void test_mesh_send() {
+        Program.configureLogging("DEBUG");
+        final TestingSubsystem ts = new TestingSubsystem("mesh");
+        Configuration cfg = ts.getConfiguration();
+        MessageHandler1 mh = new MessageHandler1();
+        final Mesh mesh1 = new Mesh(cfg, null, null, null);
+        final Mesh mesh2 = new Mesh(cfg, new InboundTunnelHandler() {
+            @Override
+            public void onInboundTunnel(Mesh.Tunnel tunnel, PeerIdentity initiator) {
+
+            }
+        }, new TunnelEndHandler() {
+            @Override
+            public void onTunnelEnd(Mesh.Tunnel tunnel) {
+
+            }
+        }, mh, 42);
+        mh.m1 = mesh1;
+        mh.m2 = mesh2;
+        Mesh.Tunnel<Void> tunnel = mesh2.createTunnel(null, 42, false, true, null);
+        tunnel.send(new TestMessage());
+        Scheduler.run();
+    }
+}
diff --git a/src/test/java/org/gnunet/nse/NSETest.java b/src/test/java/org/gnunet/nse/NSETest.java
new file mode 100644
index 0000000..c3e6512
--- /dev/null
+++ b/src/test/java/org/gnunet/nse/NSETest.java
@@ -0,0 +1,56 @@
+/*
+ This file is part of GNUnet.
+ (C) 2011, 2012 Christian Grothoff (and other contributing authors)
+
+ GNUnet is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published
+ by the Free Software Foundation; either version 3, or (at your
+ option) any later version.
+
+ GNUnet is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with GNUnet; see the file COPYING.  If not, write to the
+ Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA.
+ */
+
+package org.gnunet.nse;
+
+import org.gnunet.testing.TestingSetup;
+import org.gnunet.testing.TestingSubsystem;
+import org.gnunet.util.AbsoluteTime;
+import org.gnunet.util.Scheduler;
+import org.gnunet.util.Wrapper;
+import org.junit.Test;
+
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * @author Florian Dold
+ */
+public class NSETest {
+    @Test
+    public void test_nse() {
+        final Wrapper<Boolean> gotResult = new Wrapper<Boolean>(false);
+        TestingSubsystem ts = new TestingSubsystem("nse");
+
+        final NetworkSizeEstimation nse = new NetworkSizeEstimation(ts.getConfiguration());
+        nse.subscribe(new NetworkSizeEstimation.Subscriber() {
+            @Override
+            public void update(AbsoluteTime timestamp, double estimate, double deviation) {
+                assertNotNull(timestamp);
+                gotResult.set(true);
+                nse.disconnect();
+            }
+        });
+
+        Scheduler.run();
+
+        assertTrue(gotResult.get());
+    }
+}
diff --git a/src/test/java/org/gnunet/peerinfo/PeerInfoTest.java b/src/test/java/org/gnunet/peerinfo/PeerInfoTest.java
new file mode 100644
index 0000000..4239731
--- /dev/null
+++ b/src/test/java/org/gnunet/peerinfo/PeerInfoTest.java
@@ -0,0 +1,41 @@
+package org.gnunet.peerinfo;
+
+import org.gnunet.hello.HelloMessage;
+import org.gnunet.testing.TestingSubsystem;
+import org.gnunet.util.*;
+import org.junit.Test;
+
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * ...
+ *
+ * @author Florian Dold
+ */
+public class PeerInfoTest {
+
+    @Test
+    public void test_peerinfo() {
+        Program.configureLogging("debug");
+        final Wrapper<Boolean> ended = new Wrapper<Boolean>(false);
+        TestingSubsystem ts = new TestingSubsystem("peerinfo");
+        final PeerInfo peerInfo = new PeerInfo(ts.getConfiguration());
+
+        peerInfo.iterate(RelativeTime.FOREVER, false, new PeerProcessor() {
+            @Override
+            public void onPeer(PeerIdentity peerIdentity, HelloMessage hello) {
+                // we can't expect to get anything here, peerinfo is the only running service in this setup
+            }
+
+            @Override
+            public void onEnd() {
+                peerInfo.disconnect();
+                ended.set(true);
+            }
+        });
+
+        Scheduler.run();
+        assertTrue(ended.get());
+    }
+}
diff --git a/src/test/java/org/gnunet/statistics/StatisticsTest.java b/src/test/java/org/gnunet/statistics/StatisticsTest.java
new file mode 100644
index 0000000..f4bdbe9
--- /dev/null
+++ b/src/test/java/org/gnunet/statistics/StatisticsTest.java
@@ -0,0 +1,180 @@
+/*
+ This file is part of GNUnet.
+ (C) 2011, 2012 Christian Grothoff (and other contributing authors)
+
+ GNUnet is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published
+ by the Free Software Foundation; either version 3, or (at your
+ option) any later version.
+
+ GNUnet is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with GNUnet; see the file COPYING.  If not, write to the
+ Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA.
+ */
+
+package org.gnunet.statistics;
+
+import org.junit.Assert;
+import org.gnunet.testing.TestingFixture;
+import org.gnunet.testing.TestingSetup;
+import org.gnunet.testing.TestingSubsystem;
+import org.gnunet.util.*;
+import org.junit.Test;
+
+
+public class StatisticsTest extends TestingFixture {
+    public interface Next {
+        void next();
+    }
+
+    public void assertStatisticsGet(AssertionList assertions, Statistics stat, final String subsystem,
+                                    final String name,
+                                    final long expectedValue, final Next next) {
+        Program.configureLogging();
+        final Assertion getAssertion = assertions.create("get %s:%s -> %s", subsystem, name, expectedValue);
+        stat.get(RelativeTime.FOREVER, subsystem, name, new StatisticsReceiver() {
+                    @Override
+                    public void onReceive(String rsubsystem, String rname, long rvalue) {
+                        if (rsubsystem.equals(subsystem) && rname.equals(name) && rvalue == expectedValue) {
+                            getAssertion.assertTrue(true);
+                        } else {
+                            getAssertion.assertTrue(false);
+                        }
+                    }
+
+                    @Override
+                    public void onTimeout() {
+                        Assert.fail();
+                    }
+
+                    @Override
+                    public void onDone() {
+                        if (next != null) {
+                            next.next();
+                        }
+                    }
+                });
+    }
+
+
+    @Test(timeout = 1000)
+    public void test_simple() {
+        Program.configureLogging("DEBUG");
+        final TestingSubsystem ts = new TestingSubsystem("statistics");
+
+        final Statistics stat = new Statistics(ts.getConfiguration());
+
+        final Wrapper<Boolean> contReached = new Wrapper<Boolean>(false);
+
+        stat.set("gnj-test", "test", 42, false);
+
+        stat.get(RelativeTime.FOREVER, "gnj-test", "test",
+                new StatisticsReceiver() {
+                    @Override
+                    public void onReceive(String subsystem, String name, long value) {
+                        Assert.assertEquals("gnj-test", subsystem);
+                        Assert.assertEquals("test", name);
+                        Assert.assertEquals(42, value);
+                    }
+
+                    @Override
+                    public void onTimeout() {
+
+                    }
+
+                    public void onDone() {
+                        contReached.set(true);
+                        stat.destroy();
+
+                    }
+                });
+
+        Scheduler.run();
+
+        Assert.assertTrue(contReached.get());
+    }
+
+    /**
+     * Test setting, updating and getting values with two statistics handles.
+     * This test is somewhat fragile, as we have a fixed time we wait for
+     * the values to be set in the service.
+     */
+    @Test(timeout = 1000)
+    public void test_statistics_get_set() {
+        Program.configureLogging();
+        final TestingSubsystem ts = new TestingSubsystem("statistics");
+
+        final AssertionList assertions = new AssertionList();
+
+        final Statistics stat1 = new Statistics(ts.getConfiguration());
+
+        stat1.set("gnj-test", "test1", 5, false);
+        stat1.set("gnj-test", "test2", 7, false);
+        stat1.set("gnj-test", "test3", 0, false);
+        stat1.update("gnj-test", "test3", 5, false);
+        stat1.update("gnj-test", "test3", -1, false);
+
+        Scheduler.addDelayed(RelativeTime.fromMilliseconds(200), new Scheduler.Task() {
+            @Override
+            public void run(Scheduler.RunContext ctx) {
+                stat1.destroy();
+                final Statistics stat2 = new Statistics(ts.getConfiguration());
+                assertStatisticsGet(assertions, stat2, "gnj-test", "test1", 5, new Next() {
+                    @Override
+                    public void next() {
+                        assertStatisticsGet(assertions, stat2, "gnj-test", "test2", 7, new Next() {
+                            @Override
+                            public void next() {
+                                assertStatisticsGet(assertions, stat2, "gnj-test", "test3", 4, new Next() {
+                                    @Override
+                                    public void next() {
+                                        stat2.destroy();
+                                    }
+                                });
+                            }
+                        });
+
+                    }
+                });
+            }
+        });
+
+
+        Scheduler.run();
+        assertions.assertAll();
+    }
+
+
+    @Test(timeout = 1000)
+    public void test_watch() {
+        Program.configureLogging("DEBUG");
+        final TestingSubsystem ts = new TestingSubsystem("statistics");
+
+        final Statistics stat = new Statistics(ts.getConfiguration());
+
+        stat.watch("gnj-test", "test", new StatisticsWatcher() {
+            @Override
+            public void onReceive(String subsystem, String name, long value) {
+                System.out.println("received update!");
+                stat.destroy();
+            }
+
+            @Override
+            public void onTimeout() {
+                Assert.fail();
+            }
+        });
+
+        // the set is sent after the watch, thus it is guaranteed we
+        // well get the update
+        stat.set("gnj-test", "test", 42, false);
+
+        Scheduler.run();
+    }
+}
diff --git a/src/test/java/org/gnunet/testing/TestingSetupTest.java b/src/test/java/org/gnunet/testing/TestingSetupTest.java
new file mode 100644
index 0000000..263d88f
--- /dev/null
+++ b/src/test/java/org/gnunet/testing/TestingSetupTest.java
@@ -0,0 +1,54 @@
+/*
+ This file is part of GNUnet.
+ (C) 2011, 2012 Christian Grothoff (and other contributing authors)
+
+ GNUnet is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published
+ by the Free Software Foundation; either version 3, or (at your
+ option) any later version.
+
+ GNUnet is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with GNUnet; see the file COPYING.  If not, write to the
+ Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA.
+ */
+
+package org.gnunet.testing;
+
+import org.gnunet.util.Program;
+import org.junit.Test;
+
+/**
+ * @author Florian Dold
+ */
+public class TestingSetupTest {
+    static final String service = "nse";
+
+    @Test(timeout = 1000)
+    public void test_testing() {
+        Program.configureLogging();
+        // could be any service, just use statistics
+        TestingSubsystem ts = new TestingSubsystem(service);
+        String port = ts.getConfiguration().getValueString(service, "PORT").get();
+        org.junit.Assert.assertTrue(port != null);
+
+        ts.destroy();
+    }
+
+    @Test(expected = TestingSetup.SetupException.class)
+    public void test_no_service() {
+        new TestingSubsystem("foobar _ !!!");
+    }
+
+    @Test(timeout = 1000)
+    public void test_restart() {
+        TestingSubsystem ts = new TestingSubsystem(service);
+        ts.restart();
+        ts.destroy();
+    }
+}
diff --git a/src/test/java/org/gnunet/util/Assertion.java b/src/test/java/org/gnunet/util/Assertion.java
new file mode 100644
index 0000000..3636aa8
--- /dev/null
+++ b/src/test/java/org/gnunet/util/Assertion.java
@@ -0,0 +1,37 @@
+/*
+ This file is part of GNUnet.
+ (C) 2011, 2012 Christian Grothoff (and other contributing authors)
+
+ GNUnet is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published
+ by the Free Software Foundation; either version 3, or (at your
+ option) any later version.
+
+ GNUnet is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with GNUnet; see the file COPYING.  If not, write to the
+ Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA.
+ */
+
+package org.gnunet.util;
+
+
+public class Assertion {
+    public boolean success;
+    public int asserted;
+    public String message;
+
+    public Assertion(String message) {
+        this.message = message;
+    }
+
+    public void assertTrue(boolean b) {
+        success = b;
+        asserted += 1;
+    }
+}
diff --git a/src/test/java/org/gnunet/util/AssertionList.java b/src/test/java/org/gnunet/util/AssertionList.java
new file mode 100644
index 0000000..d80ed0e
--- /dev/null
+++ b/src/test/java/org/gnunet/util/AssertionList.java
@@ -0,0 +1,30 @@
+package org.gnunet.util;
+
+import java.util.LinkedList;
+import java.util.List;
+
+public class AssertionList {
+
+    List<Assertion> asyncAssertions = new LinkedList<Assertion>();
+
+
+    public Assertion create(String message, Object... args) {
+        Assertion assertion = new Assertion(String.format(message, args));
+        asyncAssertions.add(assertion);
+        return assertion;
+    }
+
+    public void assertAll() {
+        for (Assertion assertion : asyncAssertions) {
+            if (assertion.asserted != 1) {
+                throw new AssertionError(
+                        String.format("Assertion '%s' asserted %s times", assertion.message, assertion.asserted));
+            }
+            if (!assertion.success) {
+                throw new AssertionError(
+                        String.format("Assertion '%s' failed", assertion.message));
+            }
+        }
+    }
+
+}
diff --git a/src/test/java/org/gnunet/util/ClientServerTest.java b/src/test/java/org/gnunet/util/ClientServerTest.java
new file mode 100644
index 0000000..616ce98
--- /dev/null
+++ b/src/test/java/org/gnunet/util/ClientServerTest.java
@@ -0,0 +1,251 @@
+package org.gnunet.util;
+
+import com.google.common.collect.Lists;
+import org.gnunet.construct.UInt32;
+import org.gnunet.construct.UnionCase;
+import org.gnunet.testing.TestingServer;
+import org.gnunet.testing.TestingSetup;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.net.*;
+import java.nio.ByteBuffer;
+import java.nio.channels.Pipe;
+import java.nio.channels.spi.SelectorProvider;
+import java.util.ArrayList;
+
+/**
+ * ...
+ *
+ * @author Florian Dold
+ */
+public class ClientServerTest {
+
+    @Test
+    public void test_start_stop() {
+        Program.configureLogging("DEBUG", null);
+        final TestingServer srv = new TestingServer();
+        srv.server.stopListening();
+    }
+
+    /**
+     * Test if the server receives a message sent by a client.
+     */
+    @Test
+    public void test_testing_server() {
+        Program.configureLogging("DEBUG", null);
+
+        final TestingServer srv = new TestingServer();
+
+        final Wrapper<Boolean> gotMessage = new Wrapper<Boolean>(false);
+
+        srv.server.setHandler(new Server.MessageRunabout() {
+            public void visit(TestMessage tm) {
+                gotMessage.set(true);
+                srv.server.destroy();
+            }
+        });
+
+        Scheduler.run(new Scheduler.Task() {
+            @Override
+            public void run(Scheduler.RunContext ctx) {
+                final Client cli = srv.createClient();
+                cli.notifyTransmitReady(RelativeTime.FOREVER,true, 0, new MessageTransmitter() {
+                    @Override
+                    public void transmit(Connection.MessageSink sink) {
+                        System.out.println("ntr!");
+                        sink.send(new TestMessage());
+                    }
+
+                    @Override
+                    public void handleError() {
+                        Assert.fail();
+                    }
+                });
+                System.out.println("done");
+            }
+        });
+
+        Assert.assertTrue(gotMessage.get());
+    }
+
+
+    /**
+     * Test what happens when a client calls notifyTransmitReady, but does not send
+     * a message in the callback and disconnects.
+     */
+    @Test(timeout = 1000)
+    public void test_premature_disconnect() {
+        Program.configureLogging("DEBUG", null);
+        final TestingServer srv = new TestingServer();
+
+        srv.server.notifyDisconnect(new Server.DisconnectHandler() {
+            @Override
+            public void onDisconnect(Server.ClientHandle clientHandle) {
+                srv.server.destroy();
+            }
+        });
+
+        Scheduler.run(new Scheduler.Task() {
+            @Override
+            public void run(Scheduler.RunContext ctx) {
+                final Client cli = srv.createClient();
+                cli.notifyTransmitReady(RelativeTime.FOREVER,true, 0, new MessageTransmitter() {
+                    @Override
+                    public void transmit(Connection.MessageSink sink) {
+                        sink.send(new TestMessage());
+                        cli.disconnect();
+                    }
+
+                    @Override
+                    public void handleError() {
+                        Assert.fail();
+                    }
+                });
+            }
+        });
+    }
+
+
+    @Test
+    public void test_receiveDone() {
+        Program.configureLogging("DEBUG", null);
+        final TestingServer srv = new TestingServer();
+
+        final Wrapper<Integer> msgCount = new Wrapper<Integer>(0);
+
+        srv.server.setHandler(new Server.MessageRunabout() {
+            public void visit(TestMessage tm) {
+                msgCount.set(msgCount.get() + 1);
+                if (msgCount.get() == 3) {
+                    getSender().receiveDone(false);
+                    srv.server.stopListening();
+                } else {
+                    getSender().receiveDone(true);
+                }
+            }
+        });
+
+        Scheduler.run(new Scheduler.Task() {
+            @Override
+            public void run(Scheduler.RunContext ctx) {
+                final Client cli = srv.createClient();
+
+                cli.transmitWhenReady(RelativeTime.FOREVER, new TestMessage(), new Continuation() {
+                    @Override
+                    public void cont(boolean success) {
+                        cli.transmitWhenReady(RelativeTime.FOREVER, new TestMessage(), new Continuation() {
+                            @Override
+                            public void cont(boolean success) {
+                                cli.transmitWhenReady(RelativeTime.FOREVER, new TestMessage(), null);
+                            }
+                        });
+                    }
+                });
+            }
+        });
+    }
+
+    @Test
+    public void test_acceptFromAddresses() {
+        Program.configureLogging("DEBUG", null);
+
+        InetAddress localhost = null;
+        try {
+           localhost = Inet4Address.getLocalHost();
+        } catch (UnknownHostException e) {
+            Assert.fail();
+        }
+
+        // does this work on all operating systems?
+        SocketAddress addr = new InetSocketAddress(localhost, 0);
+
+        Server server = new Server(Lists.newArrayList(addr), RelativeTime.FOREVER, false);
+
+        server.destroy();
+
+    }
+
+
+    @Test
+    public void test_keep_drop() {
+        Program.configureLogging("DEBUG", null);
+        final TestingServer srv = new TestingServer();
+
+        final Wrapper<Integer> msgCount = new Wrapper<Integer>(0);
+
+
+
+        srv.server.setHandler(new Server.MessageRunabout() {
+            public void visit(TestMessage tm) {
+                srv.server.stopListening();
+                if (msgCount.get() == 0) {
+                    getSender().keep();
+                    getSender().drop();
+                    getSender().receiveDone(true);
+                } else if (msgCount.get() == 1) {
+                    getSender().receiveDone(false);
+
+                } else {
+                    Assert.fail();
+                }
+
+                msgCount.set(msgCount.get() + 1);
+            }
+        });
+
+        Scheduler.run(new Scheduler.Task() {
+            @Override
+            public void run(Scheduler.RunContext ctx) {
+                final Client cli = srv.createClient();
+                cli.transmitWhenReady(new TestMessage(), new Continuation() {
+                    @Override
+                    public void cont(boolean success) {
+                        cli.transmitWhenReady(new TestMessage(), null);
+                    }
+                });
+            }
+        });
+    }
+
+
+
+    /**
+    * test if markMonitor / soft shutdown works.
+    */
+    @Test
+    public void test_monitor_clients() {
+        Program.configureLogging("DEBUG", null);
+        final TestingServer srv = new TestingServer();
+
+        final Wrapper<Integer> msgCount = new Wrapper<Integer>(0);
+
+        srv.server.setHandler(new Server.MessageRunabout() {
+            public void visit(TestMessage tm) {
+                if (msgCount.get() == 0) {
+                    getSender().markMonitor();
+                    getSender().receiveDone(true);
+                } else if (msgCount.get() == 1) {
+                    srv.server.stopListening();
+                    getSender().receiveDone(false);
+                } else {
+                    Assert.fail();
+                }
+
+                msgCount.set(msgCount.get() + 1);
+            }
+        });
+
+        Scheduler.run(new Scheduler.Task() {
+            @Override
+            public void run(Scheduler.RunContext ctx) {
+                final Client cli1 = srv.createClient();
+                final Client cli2 = srv.createClient();
+
+                cli1.transmitWhenReady(new TestMessage(), null);
+                cli2.transmitWhenReady(new TestMessage(), null);
+            }
+        });
+    }
+}
diff --git a/src/test/java/org/gnunet/util/FilePipeExample.java b/src/test/java/org/gnunet/util/FilePipeExample.java
new file mode 100644
index 0000000..94696c9
--- /dev/null
+++ b/src/test/java/org/gnunet/util/FilePipeExample.java
@@ -0,0 +1,41 @@
+package org.gnunet.util;
+
+import java.io.File;
+import java.io.IOError;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+
+/**
+ * ...
+ *
+ * @author Florian Dold
+ */
+public class FilePipeExample {
+    public static void main(String... args) {
+
+        Program.configureLogging("DEBUG", null);
+
+        final Scheduler.FilePipe fp = Scheduler.openFilePipe(new File("test.pipe"));
+
+
+        Scheduler.addRead(RelativeTime.FOREVER, fp.getSource(), new Scheduler.Task() {
+            @Override
+            public void run(Scheduler.RunContext ctx) {
+                ByteBuffer b = ByteBuffer.allocate(1);
+                b.clear();
+                try {
+                    fp.getSource().read(b);
+                } catch (IOException e) {
+                    throw new IOError(e);
+                }
+                b.flip();
+                System.out.println("got: " + b.get());
+
+                Scheduler.addRead(RelativeTime.FOREVER, fp.getSource(), this);
+
+            }
+        });
+
+        Scheduler.run();
+    }
+}
diff --git a/src/test/java/org/gnunet/util/ResolverTest.java b/src/test/java/org/gnunet/util/ResolverTest.java
new file mode 100644
index 0000000..ae56b79
--- /dev/null
+++ b/src/test/java/org/gnunet/util/ResolverTest.java
@@ -0,0 +1,92 @@
+/*
+ This file is part of GNUnet.
+ (C) 2011, 2012 Christian Grothoff (and other contributing authors)
+
+ GNUnet is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published
+ by the Free Software Foundation; either version 3, or (at your
+ option) any later version.
+
+ GNUnet is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with GNUnet; see the file COPYING.  If not, write to the
+ Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA.
+ */
+
+package org.gnunet.util;
+
+import org.gnunet.testing.TestingSetup;
+import org.gnunet.testing.TestingSubsystem;
+import org.junit.Assert;
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.net.InetAddress;
+
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+/**
+ * @author Florian Dold
+ */
+public class ResolverTest {
+    private static final Logger logger = LoggerFactory
+            .getLogger(ResolverTest.class);
+    @Test
+    public void test_resolver() {
+        final Wrapper<Boolean> finished1 = new Wrapper<Boolean>(true);
+        final Wrapper<Boolean> finished2 = new Wrapper<Boolean>(true);
+
+        TestingSubsystem ts = new TestingSubsystem("resolver");
+
+
+        Resolver r = Resolver.getInstance();
+        r.setConfiguration(ts.getConfiguration());
+
+        r.resolveHostname("gnunet.org", RelativeTime.FOREVER, new Resolver.AddressCallback() {
+            @Override
+            public void onAddress(InetAddress addr) {
+                logger.info("Hostname resolved to " + addr.getHostAddress());
+            }
+
+            @Override
+            public void onFinished() {
+                finished1.set(true);
+            }
+
+            @Override
+            public void onTimeout() {
+                fail();
+            }
+        });
+        r.resolveHostname("gnu.org", RelativeTime.FOREVER, new Resolver.AddressCallback() {
+            @Override
+            public void onAddress(InetAddress addr) {
+                logger.info("Hostname resolved to " + addr.getHostAddress());
+            }
+
+            @Override
+            public void onFinished() {
+                finished2.set(true);
+            }
+
+            @Override
+            public void onTimeout() {
+                fail();
+            }
+        });
+
+        Scheduler.run();
+
+        assertTrue(finished1.get());
+
+        assertTrue(finished2.get());
+    }
+}
+
diff --git a/src/test/java/org/gnunet/util/ServerExample.java b/src/test/java/org/gnunet/util/ServerExample.java
new file mode 100644
index 0000000..a344e2a
--- /dev/null
+++ b/src/test/java/org/gnunet/util/ServerExample.java
@@ -0,0 +1,79 @@
+/*
+ This file is part of GNUnet.
+ (C) 2011, 2012 Christian Grothoff (and other contributing authors)
+
+ GNUnet is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published
+ by the Free Software Foundation; either version 3, or (at your
+ option) any later version.
+
+ GNUnet is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with GNUnet; see the file COPYING.  If not, write to the
+ Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA.
+ */
+
+package org.gnunet.util;
+
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.util.Arrays;
+
+import static org.gnunet.util.Server.*;
+
+/**
+ * Example server implementation.
+ *
+ * @author Florian Dold
+ */
+public class ServerExample {
+
+    public static void main(String[] args) {
+        // usually servers should run inside a service, this is just for testing
+        new Program(args) {
+            @Override
+            public void run() {
+                Server s = new Server(Arrays.asList(new SocketAddress[]{new InetSocketAddress("127.0.0.1", 3456)}),
+                        RelativeTime.MINUTE,
+                        false);
+                s.setHandler(new Server.MessageRunabout() {
+                    public void visit(TestMessage tm) {
+                        System.out.println("got TEST message");
+                        final Server.ClientHandle sender = getSender();
+                        sender.notifyTransmitReady(4, RelativeTime.FOREVER, new MessageTransmitter() {
+                            @Override
+                            public void transmit(Connection.MessageSink sink) {
+                                sink.send(new TestMessage());
+                                System.out.println("TEST message sent");
+                                sender.receiveDone(true);
+                            }
+
+                            @Override
+                            public void handleError() {
+                                System.out.println("error talking to client!");
+                            }
+                        });
+                    }
+
+                    public void visit(UnknownMessageBody b) {
+                        System.out.println("got message of unknown type " + b.id);
+                    }
+                });
+
+                s.notifyDisconnect(new DisconnectHandler() {
+                    @Override
+                    public void onDisconnect(Server.ClientHandle clientHandle) {
+                        System.out.println("client disconnected");
+
+                    }
+                });
+
+            }
+        }.start();
+    }
+}
diff --git a/src/test/java/org/gnunet/util/StringsTest.java b/src/test/java/org/gnunet/util/StringsTest.java
new file mode 100644
index 0000000..49cbfe9
--- /dev/null
+++ b/src/test/java/org/gnunet/util/StringsTest.java
@@ -0,0 +1,20 @@
+package org.gnunet.util;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * ...
+ *
+ * @author Florian Dold
+ */
+public class StringsTest {
+    @Test
+    public void test_inverse() {
+        byte[] data = "asdfgASDD$!123".getBytes();
+        String str = Strings.dataToString(data);
+        byte[] data2 = Strings.stringToData(str, data.length);
+        Assert.assertArrayEquals(data, data2);
+    }
+}
+
diff --git a/src/test/java/org/gnunet/util/TimeTest.java b/src/test/java/org/gnunet/util/TimeTest.java
new file mode 100644
index 0000000..92115a8
--- /dev/null
+++ b/src/test/java/org/gnunet/util/TimeTest.java
@@ -0,0 +1,29 @@
+package org.gnunet.util;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * ...
+ *
+ * @author Florian Dold
+ */
+public class TimeTest {
+
+    @Test
+    public void test_absolute_add_subtract() {
+        AbsoluteTime t1 = AbsoluteTime.now().add(RelativeTime.FOREVER);
+        Assert.assertEquals(t1, AbsoluteTime.FOREVER);
+        Assert.assertTrue(t1.isForever());
+
+        t1 = AbsoluteTime.FOREVER.add(RelativeTime.SECOND);
+        Assert.assertEquals(t1, AbsoluteTime.FOREVER);
+        Assert.assertTrue(t1.isForever());
+
+        AbsoluteTime t2 = (new AbsoluteTime(123000000)).add(RelativeTime.SECOND);
+        Assert.assertEquals(124000000, t2.getMicroseconds());
+
+        AbsoluteTime t3 = (new AbsoluteTime(123000000)).subtract(RelativeTime.SECOND);
+        Assert.assertEquals(122000000, t3.getMicroseconds());
+    }
+}
diff --git a/src/test/java/org/gnunet/util/Wrapper.java b/src/test/java/org/gnunet/util/Wrapper.java
new file mode 100644
index 0000000..be84b54
--- /dev/null
+++ b/src/test/java/org/gnunet/util/Wrapper.java
@@ -0,0 +1,43 @@
+/*
+ This file is part of GNUnet.
+ (C) 2011, 2012 Christian Grothoff (and other contributing authors)
+
+ GNUnet is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published
+ by the Free Software Foundation; either version 3, or (at your
+ option) any later version.
+
+ GNUnet is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with GNUnet; see the file COPYING.  If not, write to the
+ Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA.
+ */
+
+package org.gnunet.util;
+
+
+/**
+ * Wrapper, used when it is necessary to store a value in a final-variable.
+ *
+ * @param <E> type of the stored value
+ */
+public class Wrapper<E> {
+    public E value;
+    public Wrapper(E initialValue) {
+        value = initialValue;
+    }
+    public Wrapper() {
+        // default constructor
+    }
+    public void set(E newValue) {
+        value = newValue;
+    }
+    public E get() {
+        return value;
+    }
+}
diff --git a/src/test/java/org/gnunet/util/getopt/GetoptTest.java b/src/test/java/org/gnunet/util/getopt/GetoptTest.java
new file mode 100644
index 0000000..010c240
--- /dev/null
+++ b/src/test/java/org/gnunet/util/getopt/GetoptTest.java
@@ -0,0 +1,286 @@
+/*
+ This file is part of GNUnet.
+ (C) 2011, 2012 Christian Grothoff (and other contributing authors)
+
+ GNUnet is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published
+ by the Free Software Foundation; either version 3, or (at your
+ option) any later version.
+
+ GNUnet is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with GNUnet; see the file COPYING.  If not, write to the
+ Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA.
+ */
+
+package org.gnunet.util.getopt;
+
+
+import org.junit.Assert;
+import org.junit.Test;
+
+class Target {
+    @Argument(
+            action = ArgumentAction.STORE_STRING,
+            shortname = "s",
+            longname = "string",
+            argumentName = "SOME_STRING",
+            description = "just some string"
+    )
+    String someString;
+
+    @Argument(
+            action = ArgumentAction.SET,
+            shortname = "y",
+            longname = "set",
+            description = "enable, default disabled"
+    )
+    boolean set = false;
+
+    @Argument(
+            action = ArgumentAction.RESET,
+            shortname = "n",
+            longname = "reset",
+            description = "disable, default enabled"
+    )
+    boolean reset = true;
+
+
+    @Argument(
+            action = ArgumentAction.STORE_NUMBER,
+            shortname = "w",
+            longname = "value",
+            description = "some value"
+    )
+    int intVal = 0;
+
+    static int someConstant = 42;
+}
+
+class InvalidTarget {
+    @Argument(action = ArgumentAction.SET, shortname = "foo", longname = "bar", description = "bla bla")
+    boolean foo;
+}
+
+public class GetoptTest {
+    @Test
+    public void test_str() {
+        Target t = new Target();
+        Parser p = new Parser(t);
+
+
+        t.someString = null;
+        
+        // argument directly with shortopt
+        p.parse(new String[]{"-sfoo"});
+        Assert.assertEquals("foo", t.someString);
+
+        t.someString = null;
+
+        // argument after shortopt
+        p.parse(new String[]{"-s", "foo"});
+        Assert.assertEquals("foo", t.someString);
+
+        t.someString = null;
+
+        p.parse(new String[]{"--string=foo"});
+        Assert.assertEquals("foo", t.someString);
+
+        t.someString = null;
+
+        p.parse(new String[]{"--string", "foo"});
+        Assert.assertEquals("foo", t.someString);
+
+
+        t.someString = null;
+
+        // last argument counts
+        p.parse(new String[]{"--string", "bar", "--string", "foo"});
+        Assert.assertEquals("foo", t.someString);
+        
+        t.someString = null;
+        
+        boolean thrown;
+                
+        thrown = false;
+        
+        // absence of argument throws ArgumentError (longopt)
+        try {
+            p.parse(new String[]{"--string"});
+        } catch (Parser.ArgumentError e) {
+            thrown = true;
+        }
+        
+        Assert.assertTrue(thrown);
+        
+        thrown = false;
+        // absence of argument throws ArgumentError (shortopt)
+        try {
+            p.parse(new String[]{"-s"});
+        } catch (Parser.ArgumentError e) {
+            thrown = true;
+        }
+
+        Assert.assertTrue(thrown);
+        
+        t.someString = null;
+        
+        // a way to specify an empty string
+        p.parse(new String[]{"--string="});
+        Assert.assertEquals("", t.someString);
+    }
+
+    @Test
+    public void test_help() {
+        Target t = new Target();
+        Parser p = new Parser(t);
+        
+        String help = p.getHelp();
+        
+        Assert.assertTrue(help.contains("--string"));
+        Assert.assertTrue(help.contains("-s"));
+
+        Assert.assertTrue(help.contains("-y"));
+        Assert.assertTrue(help.contains("--set"));
+    }
+
+
+    @Test
+    public void test_bool() {
+        Target t = new Target();
+        Parser p = new Parser(t);
+        
+        p.parse(new String[]{"--set", "--reset"});
+        Assert.assertTrue(t.set);
+        Assert.assertTrue(!t.reset);
+        
+        t.set = false;
+        t.reset = true;
+
+        p.parse(new String[]{"-y", "-n"});
+
+        Assert.assertTrue(t.set);
+        Assert.assertTrue(!t.reset);
+
+        t.set = false;
+        t.reset = true;
+
+        p.parse(new String[]{"-yn"});
+
+        Assert.assertTrue(t.set);
+        Assert.assertTrue(!t.reset);
+    }
+    
+    @Test
+    public void test_positional() {
+        Target t = new Target();
+        Parser p = new Parser(t);
+        
+        String[] rest = p.parse(new String[]{"--string=bla", "foo", "bar", "--set", "--", "--reset", "baz"});
+        
+        Assert.assertArrayEquals(new String[]{"foo", "bar", "--reset", "baz"}, rest);
+    }
+
+
+    @Test(expected = Parser.ArgumentError.class)
+    public void test_missingLongopt() {
+        Target t = new Target();
+        Parser p = new Parser(t);
+        p.parse(new String[]{"--foobar"});
+    }
+
+    @Test(expected = Parser.ArgumentError.class)
+    public void test_missingShortopt_1() {
+        Target t = new Target();
+        Parser p = new Parser(t);
+        p.parse(new String[]{"-x"});
+    }
+
+    @Test
+    public void test_long() {
+        Target t = new Target();
+        Parser p = new Parser(t);
+
+        String[] rest;
+
+        rest = p.parse(new String[]{"-w5"});
+        Assert.assertEquals(5, t.intVal);
+
+        rest = p.parse(new String[]{"-w", "5"});
+        Assert.assertEquals(5, t.intVal);
+
+        rest = p.parse(new String[]{"--value=6"});
+        Assert.assertEquals(6, t.intVal);
+
+        rest = p.parse(new String[]{"--value", "7"});
+        Assert.assertEquals(7, t.intVal);
+
+        rest = p.parse(new String[]{"--value", "-7"});
+        Assert.assertEquals(-7, t.intVal);
+
+        boolean thrown = false;
+        try {
+            rest = p.parse(new String[]{"--value", "x"});
+        } catch (Parser.ArgumentError e) {
+            thrown = true;
+        }
+        Assert.assertTrue(thrown);
+    }
+
+
+    @Test(expected = Parser.ArgumentError.class)
+    public void test_missingNumberArgument_short() {
+        Target t = new Target();
+        Parser p = new Parser(t);
+
+        p.parse(new String[]{"-w"});
+        Assert.assertEquals(5, t.intVal);
+    }
+
+    @Test(expected = Parser.ArgumentError.class)
+    public void test_missingNumberArgument_long() {
+        Target t = new Target();
+        Parser p = new Parser(t);
+
+
+        p.parse(new String[]{"--w"});
+        Assert.assertEquals(5, t.intVal);
+    }
+
+
+    @Test(expected = Parser.ArgumentError.class)
+    public void test_invalidNumberFormat() {
+        Target t = new Target();
+        Parser p = new Parser(t);
+
+
+        p.parse(new String[]{"-w", "abc"});
+        Assert.assertEquals(5, t.intVal);
+    }
+
+
+    @Test
+    public void test_dashRest() {
+        Target t = new Target();
+        Parser p = new Parser(t);
+
+        String[] rest;
+
+        rest = p.parse(new String[]{"-w", "123", "-"});
+        Assert.assertArrayEquals(new String[]{"-"}, rest);
+    }
+
+
+    @Test(expected = AssertionError.class)
+    public void test_invalid() {
+        InvalidTarget it = new InvalidTarget();
+        Parser p = new Parser(it);
+
+        p.parse(new String[]{"-foo"});
+    }
+}
diff --git a/src/test/java/org/grothoff/RunaboutBenchmark.java b/src/test/java/org/grothoff/RunaboutBenchmark.java
new file mode 100644
index 0000000..18f456d
--- /dev/null
+++ b/src/test/java/org/grothoff/RunaboutBenchmark.java
@@ -0,0 +1,82 @@
+/*
+ This file is part of GNUnet.
+ (C) 2011, 2012 Christian Grothoff (and other contributing authors)
+
+ GNUnet is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published
+ by the Free Software Foundation; either version 3, or (at your
+ option) any later version.
+
+ GNUnet is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with GNUnet; see the file COPYING.  If not, write to the
+ Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA.
+ */
+
+package org.grothoff;
+
+
+public class RunaboutBenchmark {
+
+    public static class MyRunabout extends Runabout {
+        public void visit(String s) {
+
+        }
+        public void visit(Integer i) {
+
+        }
+    }
+
+
+    public static void main(String[] args) {
+        final int runs = 5000000;
+
+        Runabout r = new MyRunabout();
+
+        long start = System.currentTimeMillis();
+
+        Integer integer = 42;
+        for (int i = 0; i < runs; ++i) {
+            r.visitAppropriate("foo");
+            r.visitAppropriate(integer);
+        }
+
+        long end = System.currentTimeMillis();
+
+        long duration1 = end - start;
+
+
+        Runabout r2 = new Runabout() {
+            public void visit(String s) {
+
+            }
+            public void visit(Integer i) {
+
+            }
+        };
+
+
+        start = System.currentTimeMillis();
+
+        for (int i = 0; i < runs; ++i) {
+            r2.visitAppropriate("foo");
+            r2.visitAppropriate(integer);
+        }
+
+        end = System.currentTimeMillis();
+
+        long duration2 = end - start;
+
+
+        System.out.println("Runs: " + runs);
+        System.out.println("public: " + duration1);
+        System.out.println("Anon Inner Class: " + duration2);
+        System.out.println("Overhead: " + duration2 / (double) duration1);
+
+    }
+}