more parts of Core implemented, still major problems

23 files changed, 478 insertions, 120 deletions

diff --git a/.classpath b/.classpath
index 48b3153..cc831fb 100644
--- a/.classpath
+++ b/.classpath
@@ -11,6 +11,7 @@
         <classpathentry kind="con" path="org.eclipse.jdt.USER_LIBRARY/commons-io-2.1"/>
         <classpathentry kind="lib" path="lib/log4j-1.2.16.jar"/>
         <classpathentry kind="lib" path="lib/slf4j-log4j12-1.6.4.jar"/>
-        <classpathentry kind="lib" path="lib/commons-io-2.1.jar"/>
+        <classpathentry kind="lib" path="/home/dold/gnunet-java/lib/commons-io-2.1.jar"/>
+        <classpathentry kind="con" path="org.eclipse.jdt.USER_LIBRARY/commons-io-2.2"/>
         <classpathentry kind="output" path="build"/>
 </classpath>
diff --git a/ISSUES b/ISSUES
index 4506d97..f68ad51 100644
--- a/ISSUES
+++ b/ISSUES
@@ -347,12 +347,27 @@ public interface GnunetMessageBody extends MessageUnion { }
 
 ========================================================================================
 
-* why is installing gnunet so compilicated?
- * e.g. stuff like "base of XYZ installation" in ./configure is very confusing
- * many dependencies with out-of-date packages on common distros
+* client_api.c
+  * pr = GNUNET_CONTAINER_multihashmap_get (handle->peers, &target->hashPubKey);
+  * the above line crashes when target==NULL, but comment indicates that NULL is valid for target
+
+* ...NOTIFY_PRE_CONNECT.. message type not used
+
+* what about allocation of message IDs for extesions / what about clashes?
 
+core:
+* we seem to get all incoming messages if the handlers array is empty (even if we don't request anything)
+* being notified about outbound messages does not seem to work at all
 
 
+* how does the Hash ascii-encoding work?
+* => solved, ported C-code, encountered some problems because of the lack of unsigned in java
+  (had to use long instead of int in java code because of sign)
+* first implementation got some characters wrong, had to use
+  byte b = data[(int) rpos++];
+  int s = b >= 0 ? b : (256 + b);
+  to compensate for the signed-ness of byte
+* is the current implementation correct now? (it has the same output as peerinfo)
 
 
 @Fill
@@ -386,13 +401,16 @@ int[] foo;
   * also GNUNET_CORE_OPTION_SEND_STATUS_CHANGE
  * inconsistency in structs with trailing ATS information (NotifyTrafficMessage vs ConnectNotifyMessage)
   * why zero-termination *and* size field?
+  * what does zero-termination really mean? is it only one byte? a whole ats entry?
  * what happens when we can't connect to core / lose connection? in the c api implementation, this is never handeled?
   * why is there even the init callback if init can't fail?
 
 
-* GNUNET_SERVER_connect_socket: ?????
-* disabling cork in java? is it possible?
+* GNUNET_SERVER_connect_socket: what is it for?
+* how to disable corking in java? is corking the same as TCP_NODELAY?
 
 
-* what about allocation of message IDs for extesions / what about clashes?
+* why is installing gnunet so compilicated?
+ * e.g. stuff like "base of XYZ installation" in ./configure is very confusing
+ * many dependencies with out-of-date packages on common distros
 
diff --git a/gnunet-java.eml b/gnunet-java.eml
index 0fb6fee..8f5fb7b 100644
--- a/gnunet-java.eml
+++ b/gnunet-java.eml
@@ -13,7 +13,4 @@
         <lib name="slf4j-log4j12-1.6.4.jar" scope="COMPILE">
                 <relative-module-cls project-related="jar://$PROJECT_DIR$/lib/slf4j-log4j12-1.6.4.jar!/"/>
         </lib>
-        <lib name="commons-io-2.1.jar" scope="COMPILE">
-                <relative-module-cls project-related="jar://$PROJECT_DIR$/lib/commons-io-2.1.jar!/"/>
-        </lib>
 </component>
diff --git a/lib/commons-io-2.2.jar b/lib/commons-io-2.2.jar
new file mode 100644
index 0000000..84ca565
--- /dev/null
+++ b/lib/commons-io-2.2.jar
diff --git a/src/org/gnunet/construct/Construct.java b/src/org/gnunet/construct/Construct.java
index 3848e49..1b00922 100644
--- a/src/org/gnunet/construct/Construct.java
+++ b/src/org/gnunet/construct/Construct.java
@@ -229,6 +229,10 @@ public class Construct {
             parser = new StringParser(zts.charset(), zts.optional(), field);
         }
 
+        public void visit(IntegerFill i) {
+            parser = new IntegerFillParser(frameSizePath, field, i.signed(), i.bitSize()/8);
+        }
+
         public void visit(NestedMessage n) {
 
             Class<? extends Message> ct;
@@ -287,16 +291,26 @@ public class Construct {
             parser = new DoubleParser(field);
         }
 
+        public void visit(FillWith fw) {
+            Field f = field;
+            Class old_c = c;
+
+            Parser p = getParser((Class<? extends Message>) field.getType()
+                    .getComponentType(), this);
+
+            parser = new FillParser(p, frameSizePath ,f);
+        }
+
         public void visit(VariableSizeArray vsa) {
             Field f = field;
             Class old_c = c;
 
-            //noinspection unchecked
-            getParser((Class<? extends Message>) field.getType()
+
+            Parser p = getParser((Class<? extends Message>) field.getType()
                     .getComponentType(), this);
 
             try {
-                parser = new VariableSizeArrayParser(parser, old_c.getField(vsa
+                parser = new VariableSizeArrayParser(p, old_c.getField(vsa
                         .lengthField()), f);
 
             } catch (SecurityException e) {
diff --git a/src/org/gnunet/construct/IntegerFill.java b/src/org/gnunet/construct/IntegerFill.java
new file mode 100644
index 0000000..6976820
--- /dev/null
+++ b/src/org/gnunet/construct/IntegerFill.java
@@ -0,0 +1,13 @@
+package org.gnunet.construct;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+public @interface IntegerFill {
+    boolean signed();
+    int bitSize();
+}
diff --git a/src/org/gnunet/construct/MsgMap.txt b/src/org/gnunet/construct/MsgMap.txt
index f4da714..125cc2e 100644
--- a/src/org/gnunet/construct/MsgMap.txt
+++ b/src/org/gnunet/construct/MsgMap.txt
@@ -2,16 +2,25 @@ org.gnunet.construct.UnionTest$TestUnion|0=org.gnunet.construct.UnionTest$TestUn
 org.gnunet.construct.UnionTest$TestUnion|1=org.gnunet.construct.UnionTest$TestUnionCase1
 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.Core$DisconnectNotifyMessage
 org.gnunet.util.GnunetMessage$Body|171=org.gnunet.statistics.Statistics$ResponseEndMessage
 org.gnunet.util.GnunetMessage$Body|170=org.gnunet.statistics.Statistics$ResponseValueMessage
+org.gnunet.util.GnunetMessage$Body|70=org.gnunet.core.Core$NotifyInboundTrafficMessage
 org.gnunet.util.GnunetMessage$Body|169=org.gnunet.statistics.Statistics$RequestMessage
+org.gnunet.util.GnunetMessage$Body|71=org.gnunet.core.Core$NotifyOutboundTrafficMessage
 org.gnunet.util.GnunetMessage$Body|168=org.gnunet.statistics.Statistics$SetMessage
 org.gnunet.util.GnunetMessage$Body|4=org.gnunet.util.Resolver$GetMessage
-org.gnunet.util.GnunetMessage$Body|323=org.gnunet.nse.NetworkSizeEstimation$UpdateMessage
+org.gnunet.util.GnunetMessage$Body|64=org.gnunet.core.Core$InitMessage
+org.gnunet.util.GnunetMessage$Body|65=org.gnunet.core.Core$InitReplyMessage
 org.gnunet.util.GnunetMessage$Body|5=org.gnunet.util.Resolver$ResolverResponse
 org.gnunet.util.GnunetMessage$Body|143=org.gnunet.dht.DistributedHashTable$DHTClientGetMessage
+org.gnunet.util.GnunetMessage$Body|67=org.gnunet.core.Core$ConnectNotifyMessage
 org.gnunet.util.GnunetMessage$Body|142=org.gnunet.dht.DistributedHashTable$DHTClientPutMessage
+org.gnunet.util.GnunetMessage$Body|76=org.gnunet.core.Core$SendMessage
+org.gnunet.util.GnunetMessage$Body|74=org.gnunet.core.Core$SendMessageRequest
+org.gnunet.util.GnunetMessage$Body|75=org.gnunet.core.Core$SendMessageReady
+org.gnunet.util.GnunetMessage$Body|323=org.gnunet.nse.NetworkSizeEstimation$UpdateMessage
 org.gnunet.util.GnunetMessage$Body|321=org.gnunet.nse.NetworkSizeEstimation$StartMessage
 org.gnunet.util.GnunetMessage$Body|144=org.gnunet.dht.DistributedHashTable$DHTClientGetStopMessage
 org.gnunet.util.GnunetMessage$Body|145=org.gnunet.dht.DistributedHashTable$DHTClientResultMessage
-# generated 2012/03/28 21:13:11
+# generated 2012/04/11 15:38:56
diff --git a/src/org/gnunet/construct/parsers/FillIntegerParser.java b/src/org/gnunet/construct/parsers/FillIntegerParser.java
deleted file mode 100644
index ea8990b..0000000
--- a/src/org/gnunet/construct/parsers/FillIntegerParser.java
+++ /dev/null
@@ -1,48 +0,0 @@
-package org.gnunet.construct.parsers;
-
-
-import org.gnunet.construct.Message;
-import org.gnunet.construct.ReflectUtil;
-
-import java.lang.reflect.Array;
-import java.lang.reflect.Field;
-import java.nio.ByteBuffer;
-import java.util.List;
-
-public class FillIntegerParser implements Parser {
-    private final Field targetField;
-    private final boolean isSigned;
-    private final int byteSize;
-
-    private final List<Field> totalSizePath;
-    private final ReflectUtil.NumField totalSizeField;
-
-    public FillIntegerParser(Field targetField, List<Field> totalSizePath,  boolean isSigned, int byteSize) {
-        this.targetField = targetField;
-        this.isSigned = isSigned;
-        this.byteSize = byteSize;
-
-        this.totalSizePath = totalSizePath;
-        totalSizeField = new ReflectUtil.NumField(totalSizePath.get(totalSizePath.size() - 1));
-    }
-
-    @Override
-    public int getSize(Message srcObj) {
-        return byteSize * Array.getLength(ReflectUtil.justGet(srcObj, targetField));
-    }
-
-    @Override
-    public int parse(ByteBuffer srcBuf, int frameStart, Message frameObj, Message dstObj) {
-        return 0;
-    }
-
-    @Override
-    public int write(ByteBuffer dstBuf, Message srcObj) {
-        return 0;
-    }
-
-    @Override
-    public void patch(Message m, int frameSize, Message frameObj) {
-        totalSizeField.set(ReflectUtil.followFieldPathToParent(totalSizePath, m), frameSize);
-    }
-}
diff --git a/src/org/gnunet/construct/parsers/IntegerFillParser.java b/src/org/gnunet/construct/parsers/IntegerFillParser.java
new file mode 100644
index 0000000..587155c
--- /dev/null
+++ b/src/org/gnunet/construct/parsers/IntegerFillParser.java
@@ -0,0 +1,70 @@
+package org.gnunet.construct.parsers;
+
+import org.gnunet.construct.Message;
+import org.gnunet.construct.ReflectUtil;
+
+import java.lang.reflect.Array;
+import java.lang.reflect.Field;
+import java.nio.ByteBuffer;
+import java.util.List;
+
+public class IntegerFillParser implements Parser {
+
+    private final List<Field> totalSizePath;
+    private final ReflectUtil.NumField totalSizeField;
+    private final Field targetField;
+    private final boolean signed;
+    private final int byteSize;
+
+    public IntegerFillParser(List<Field> totalSizePath, Field targetField,
+                             boolean signed, int byteSize ) {
+
+        this.totalSizePath = totalSizePath;
+        this.totalSizeField = new ReflectUtil.NumField(totalSizePath.get(totalSizePath.size() - 1));
+        this.targetField = targetField;
+        this.signed = signed;
+        this.byteSize = byteSize;
+    }
+
+
+    @Override
+    public int getSize(Message srcObj) {
+        final Object arr = ReflectUtil.justGet(srcObj, targetField);
+
+        if (arr == null) {
+            throw new RuntimeException("array not initialized");
+        }
+
+        return byteSize * Array.getLength(arr);
+    }
+
+    @Override
+    public int parse(ByteBuffer srcBuf, int frameStart, Message frameObj, Message dstObj) {
+        final int frameSize = (int) totalSizeField.get(ReflectUtil.followFieldPathToParent(totalSizePath, frameObj));
+        int remaining = frameStart + frameSize - srcBuf.position();
+
+        throw new UnsupportedOperationException("not yet implemented");
+
+        // return getSize(dstObj);
+    }
+
+    @Override
+    public int write(ByteBuffer dstBuf, Message srcObj) {
+        final Object arr = ReflectUtil.justGet(srcObj, targetField);
+
+        if (arr == null) {
+            throw new RuntimeException("array not initialized");
+        }
+
+        for (int i = 0; i < Array.getLength(arr); ++i) {
+            IntegerUtil.writeLong(Array.getLong(arr, i), dstBuf, signed, byteSize);
+        }
+
+        return getSize(srcObj);
+    }
+
+    @Override
+    public void patch(Message m, int frameSize, Message frameObj) {
+        totalSizeField.set(ReflectUtil.followFieldPathToParent(totalSizePath, frameObj), frameSize);
+    }
+}
diff --git a/src/org/gnunet/core/Core.java b/src/org/gnunet/core/Core.java
index 7834f70..425336c 100644
--- a/src/org/gnunet/core/Core.java
+++ b/src/org/gnunet/core/Core.java
@@ -2,9 +2,13 @@ package org.gnunet.core;
 
 import org.gnunet.construct.*;
 import org.gnunet.util.*;
-import org.grothoff.Runabout;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 public class Core {
+    private static final Logger logger = LoggerFactory
+            .getLogger(Core.class);
+
 
     enum CoreOption {
         NOTHING(0),
@@ -26,8 +30,7 @@ public class Core {
         @UInt32
         public long options;
 
-        @FillWith
-        @UInt16
+        @IntegerFill(signed = false, bitSize = 16)
         public int[] interested;
     }
 
@@ -42,14 +45,14 @@ public class Core {
         public PeerIdentity myIdentity;
     }
 
-
+    @UnionCase(70)
     public static class NotifyInboundTrafficMessage implements GnunetMessage.Body {
         /**
          * Number of ATS key-value pairs that follow this struct
          * (excluding the 0-terminator).
          */
         @UInt32
-        long ats_count;
+        public long ats_count;
 
         /**
          * Identity of the receiver or sender.
@@ -66,6 +69,32 @@ public class Core {
     }
 
 
+    @UnionCase(71)
+    public static class NotifyOutboundTrafficMessage implements GnunetMessage.Body {
+        /**
+         * Number of ATS key-value pairs that follow this struct
+         * (excluding the 0-terminator).
+         */
+        @UInt32
+        public long ats_count;
+
+        /**
+         * Identity of the receiver or sender.
+         */
+        @NestedMessage
+        public PeerIdentity peer;
+
+        /**
+         * First of the ATS information blocks (we must have at least
+         * one due to the 0-termination requirement).
+         */
+        //@NestedMessage
+        //public ATSInformation atsInformation;
+        @ByteFill
+        public byte[] ats;
+    }
+
+
     /**
      * Message sent by the service to clients to notify them
      * about a peer connecting.
@@ -85,9 +114,13 @@ public class Core {
         @NestedMessage
         public PeerIdentity peer;
 
-        @FillWith
-        @NestedMessage
-        public ATSInformation atsInformation;
+
+        @ByteFill
+        public byte[] atsInfo;
+
+
+        //@FillWith
+        //public ATSInformation[] atsInformation;
 
     }
 
@@ -231,37 +264,213 @@ public class Core {
 
     }
 
-    public interface Init {
+    public interface InitCallback {
         void onInit(PeerIdentity myIdentity);
     }
 
-    private final Client client;
+    public interface ConnectHandler {
+        void onConnect(PeerIdentity peerIdentity);
+    }
+
+    public interface DisconnectHandler {
+        void onDisconnect(PeerIdentity peerIdentity);
+
+    }
 
+    private final Client client;
     /**
-     * Receive messages that have a visit method in messageHandler.
-     *
-     * @param cfg configuration to use
-     * @param init callback, called after handshake with core. called with identity of the local peer.
-     * @param init Called after handshake with the core service failed or succeeded.
-     *             Guaranteed to be called only after the constructur returns.
+     * set to null once connected for the first time
      */
-    public Core(Configuration cfg, Init init, MessageHandler[] handlers) {
-        client = new Client("core", cfg);
+    private InitCallback init;
+
+    private HeaderNotify notifyOutboundHeaders;
+    private HeaderNotify notifyInboundHeaders;
+
+    private MessageNotify notifyOutboundMessages;
+    private MessageNotify notifyInboundMessages;
+
+    private int initOptions;
+
+    private ConnectHandler connectHandler;
+    private DisconnectHandler disconnectHandler;
+
+    private PeerIdentity myIdentity;
+
+    private final CoreReceiver coreReceiver = new CoreReceiver();
+
+
+    public interface HeaderNotify {
+        void notify(GnunetMessage.Header header);
+    }
+
+    public interface MessageNotify {
+        void notify(GnunetMessage messageBody);
+    }
+
+    public static class Builder {
+        /**
+         * Configuration for a core connection.
+         *
+         * @param cfg Mandatory configuration
+         */
+        final private Configuration cfg;
+        private InitCallback init;
+        private HeaderNotify notifyOutboundHeaders;
+        private HeaderNotify notifyInboundHeaders;
+
+        private MessageNotify notifyOutboundMessages;
+        private MessageNotify notifyInboundMessages;
+        private ConnectHandler connectHandler;
+        private DisconnectHandler disconnectHandler;
+        private PeerIdentity myIdentity;
+
+        public Builder(Configuration cfg) {
+            this.cfg = cfg;
+        }
+
+        public Builder withInit(InitCallback init) {
+            this.init = init;
+            return this;
+        }
 
+        public Builder addHandler(MessageHandler handler) {
+            return this;
+        }
+
+        public Builder withNotifyOutboundFull(MessageNotify h) {
+            return this;
+        }
+
+        public Builder withNotifyOutboundHeaders(HeaderNotify h) {
+            notifyOutboundHeaders = h;
+            return this;
+        }
+
+        public Builder withNotifyConnect(ConnectHandler h) {
+            connectHandler = h;
+            return this;
+        }
+
+        public Builder withNotifyDisconnect(DisconnectHandler h) {
+            disconnectHandler = h;
+            return this;
+        }
+
+        public Core build() {
+            return new Core(this);
+        }
+
+    }
+
+    private Core(Builder b) {
+        client = new Client("core", b.cfg);
+        this.notifyOutboundHeaders = b.notifyOutboundHeaders;
+
+        initOptions = 0;
+
+        if (notifyOutboundHeaders != null) {
+            //initOptions |= CoreOption.SEND_HDR_OUTBOUND.val;
+        }
+        this.init = b.init;
+
+
+        // XXX: only temporary for debugging
+        initOptions |= CoreOption.SEND_FULL_INBOUND.val;
+        initOptions |= CoreOption.SEND_FULL_OUTBOUND.val;
+
+        this.connectHandler = b.connectHandler;
+        this.disconnectHandler = b.disconnectHandler;
+
+        reconnect();
+    }
+
+    void reconnect() {
         InitMessage initMessage = new InitMessage();
 
-        // ...
+        initMessage.interested = new int[0];
+        initMessage.options = initOptions;
 
-        client.transmitAndGetResponse(initMessage, RelativeTime.FOREVER, );
+        client.transmitAndGetResponse(initMessage, RelativeTime.FOREVER, true, new CoreReceiver());
     }
 
+    public class CoreReceiver extends RunaboutMessageReceiver {
+
+        public void visit(ConnectNotifyMessage m) {
+            if (connectHandler != null) {
+                connectHandler.onConnect(m.peer);
+            }
+            client.receive(RelativeTime.FOREVER, this);
+        }
+
+        public void visit(InitReplyMessage m) {
+            myIdentity = m.myIdentity;
+            if (init != null) {
+                init.onInit(m.myIdentity);
+                init = null;
+            }
+            client.receive(RelativeTime.FOREVER, this);
+        }
+
+        public void visit(NotifyInboundTrafficMessage m) {
+            client.receive(RelativeTime.FOREVER, this);
+        }
+
+        public void visit(NotifyOutboundTrafficMessage m) {
+            System.out.println("outbound");
+
+            client.receive(RelativeTime.FOREVER, this);
+        }
+
+        public void visit(SendMessageReady m) {
+
+            // todo: ...
+
+            client.receive(RelativeTime.FOREVER, this);
+        }
+
+        @Override
+        public void visitDefault(Object o) {
+            logger.warn("received unexpected message from core: {}", o.getClass());
+            client.receive(RelativeTime.FOREVER, this);
+        }
+
+        @Override
+        public void handleError() {
+        }
+    }
+
+
     public Cancelable notifyTransmitReady(boolean cork, long priority, RelativeTime maxdelay,
                                           PeerIdentity target, int size, MessageTransmitter transmitter) {
+        final SendMessageRequest smr = new SendMessageRequest();
+        smr.deadline = maxdelay.toAbsolute().asMessage();
+        if (target == null) {
+            smr.peer = myIdentity;
+        } else {
+            smr.peer = target;
+        }
+        smr.queueSize = 10;
+        smr.smrId = 1;
+        smr.size = size;
+
+        client.notifyTransmitReady(maxdelay, false, new MessageTransmitter() {
+            @Override
+            public void transmit(Client.MessageSink sink) {
+                sink.send(smr);
+            }
+
+            @Override
+            public void handleError(Client.TransmitError error) {
+                throw new RuntimeException("client error");
+            }
+        });
         return null;
     }
 
+
     public Cancelable transmitMessage(GnunetMessage.Body messageBody, RelativeTime timeout,
                                       PeerIdentity target, Continuation cont) {
+        return null;
 
     }
 
@@ -270,8 +479,53 @@ public class Core {
      * be called *after* all pending notifyTransmitReady
      * requests have been explicitly cancelled.
      */
-
     public void disconnect() {
 
     }
+
+    public static void main(String[] args) {
+        new Program(args) {
+            Core core;
+
+            public void run() {
+                Core.Builder b = new Core.Builder(cfg);
+
+                b.withInit(new InitCallback() {
+                    @Override
+                    public void onInit(PeerIdentity myIdentity) {
+                        System.out.print("Hello, I'm ");
+                        System.out.println(Strings.dataToString(myIdentity.data));
+
+                        core.notifyTransmitReady(true, 0, RelativeTime.SECOND, null, 4, new MessageTransmitter() {
+                            @Override
+                            public void transmit(Client.MessageSink sink) {
+                                System.out.println("ready to transmit");
+                            }
+
+                            @Override
+                            public void handleError(Client.TransmitError error) {
+                            }
+                        });
+                    }
+                });
+
+                b.withNotifyOutboundHeaders(new HeaderNotify() {
+                    @Override
+                    public void notify(GnunetMessage.Header header) {
+                        System.out.println("my peer sent message of type " + header.messageType);
+                    }
+                });
+
+
+                b.withNotifyConnect(new ConnectHandler() {
+                    @Override
+                    public void onConnect(PeerIdentity peerIdentity) {
+                        System.out.println("connected to " + Strings.dataToString(peerIdentity.data));
+                    }
+                });
+
+                core = b.build();
+            }
+        }.start();
+    }
 }
diff --git a/src/org/gnunet/dht/DistributedHashTable.java b/src/org/gnunet/dht/DistributedHashTable.java
index ce69c93..3c8a058 100644
--- a/src/org/gnunet/dht/DistributedHashTable.java
+++ b/src/org/gnunet/dht/DistributedHashTable.java
@@ -317,7 +317,7 @@ public class DistributedHashTable {
         }
 
         @Override
-        public void handleError(Client.ReceiveError e) {
+        public void handleError() {
         }
     }
 
diff --git a/src/org/gnunet/nse/NetworkSizeEstimation.java b/src/org/gnunet/nse/NetworkSizeEstimation.java
index c1030ad..1002dbe 100644
--- a/src/org/gnunet/nse/NetworkSizeEstimation.java
+++ b/src/org/gnunet/nse/NetworkSizeEstimation.java
@@ -68,12 +68,8 @@ public class NetworkSizeEstimation {
         }
 
         @Override
-        public void handleError(Client.ReceiveError e) {
-            if (e.equals(Client.ReceiveError.DISCONNECT)) {
-                logger.warn("NSE service disconnected us - trying to reconnect");
-            } else {
-                throw new RuntimeException("unexpected receive error");
-            }
+        public void handleError() {
+            logger.warn("NSE connection list - trying to reconnect");
             client.reconnect();
             requestUpdate();
         }
diff --git a/src/org/gnunet/statistics/Statistics.java b/src/org/gnunet/statistics/Statistics.java
index d280aaf..5d1e66c 100644
--- a/src/org/gnunet/statistics/Statistics.java
+++ b/src/org/gnunet/statistics/Statistics.java
@@ -104,7 +104,7 @@ public class Statistics {
                     }
 
                     @Override
-                    public void handleError(Client.ReceiveError e) {
+                    public void handleError() {
                         logger.error("unable to read from statistics service");
                     }
 
diff --git a/src/org/gnunet/util/Client.java b/src/org/gnunet/util/Client.java
index 4482e62..24b1ade 100644
--- a/src/org/gnunet/util/Client.java
+++ b/src/org/gnunet/util/Client.java
@@ -181,7 +181,7 @@ public class Client {
             recvTask = null;
             if (ctx.reasons.contains(Scheduler.Reason.TIMEOUT)) {
                 currentReceiveHelper = null;
-                receiver.handleError(ReceiveError.TIMEOUT);
+                receiver.handleError();
             } else if (ctx.reasons.contains(Scheduler.Reason.READ_READY)) {
                 try {
                     int n = chan.read(recvBuffer);
@@ -190,7 +190,7 @@ public class Client {
                                 recvBuffer.position());
                         chan.close();
                         chan = null;
-                        receiver.handleError(ReceiveError.DISCONNECT);
+                        receiver.handleError();
                         if (currentTransmitHelper != null
                                 && currentTransmitHelper.autoRetry && !currentTransmitHelper.notifyDone()) {
                             logger.debug("reconnecting due to transmitter autoRetry");
@@ -201,7 +201,7 @@ public class Client {
                     logger.debug(String.format("chan read %s bytes", n));
                 } catch (IOException e) {
                     logger.error("read failed with exception:", e);
-                    receiver.handleError(ReceiveError.MSG_FORMAT);
+                    receiver.handleError();
                     return;
                 }
                 if (recvBuffer.remaining() == 0) {
@@ -621,7 +621,7 @@ public class Client {
 
             @Override
             public void handleError(TransmitError error) {
-                receiver.handleError(null);
+                receiver.handleError();
             }
         });
 
diff --git a/src/org/gnunet/util/MessageReceiver.java b/src/org/gnunet/util/MessageReceiver.java
index 2dd1d5e..da6f225 100644
--- a/src/org/gnunet/util/MessageReceiver.java
+++ b/src/org/gnunet/util/MessageReceiver.java
@@ -34,5 +34,5 @@ public interface MessageReceiver {
      */
     public void process(GnunetMessage.Body msg);
 
-    public void handleError(Client.ReceiveError e);
+    public void handleError();
 }
diff --git a/src/org/gnunet/util/PeerIdentity.java b/src/org/gnunet/util/PeerIdentity.java
index 93f55be..dde35a7 100644
--- a/src/org/gnunet/util/PeerIdentity.java
+++ b/src/org/gnunet/util/PeerIdentity.java
@@ -8,4 +8,15 @@ public class PeerIdentity implements Message {
 
     @FixedSizeByteArray(length = 64)
     public byte[] data;
+
+    static final String HEXES = "0123456789ABCDEF";
+
+    public String getHex() {
+        final StringBuilder hex = new StringBuilder( 2 * data.length );
+        for (final byte b : data) {
+            hex.append(HEXES.charAt((b & 0xF0) >> 4))
+                    .append(HEXES.charAt((b & 0x0F)));
+        }
+        return hex.toString();
+    }
 }
diff --git a/src/org/gnunet/util/Resolver.java b/src/org/gnunet/util/Resolver.java
index 8f113d4..c8b86ab 100644
--- a/src/org/gnunet/util/Resolver.java
+++ b/src/org/gnunet/util/Resolver.java
@@ -354,12 +354,8 @@ public class Resolver {
                             }
 
                             @Override
-                            public void handleError(Client.ReceiveError e) {
-                                if (e.equals(Client.ReceiveError.TIMEOUT)) {
+                            public void handleError() {
                                     onTimeout(rh);
-                                } else {
-                                    throw new RuntimeException("unexpected receive error");
-                                }
                             }
                         });
 
diff --git a/src/org/gnunet/util/RunaboutMessageReceiver.java b/src/org/gnunet/util/RunaboutMessageReceiver.java
index 785f276..411bafd 100644
--- a/src/org/gnunet/util/RunaboutMessageReceiver.java
+++ b/src/org/gnunet/util/RunaboutMessageReceiver.java
@@ -1,10 +1,9 @@
 package org.gnunet.util;
 
-import org.gnunet.construct.Message;
 import org.grothoff.Runabout;
 
 public abstract class RunaboutMessageReceiver extends Runabout implements MessageReceiver  {
-    public void process(Message msg) {
+    public void process(GnunetMessage.Body msg) {
         this.visitAppropriate(msg);
     }
 }
diff --git a/src/org/gnunet/util/Server.java b/src/org/gnunet/util/Server.java
index 5ac6e77..f4d1aef 100644
--- a/src/org/gnunet/util/Server.java
+++ b/src/org/gnunet/util/Server.java
@@ -35,6 +35,10 @@ public class Server {
 
         }
 
+        public void injectMessage(/*msg*/) {
+
+        }
+
     }
 
 
@@ -61,7 +65,10 @@ public class Server {
 
     public Server(SocketAddress[] addresses, RelativeTime idleTimeout, boolean requireFound) {
         try {
-            ServerSocketChannel socket = ServerSocketChannel.open();
+            for (SocketAddress addr : addresses) {
+                ServerSocketChannel socket = ServerSocketChannel.open();
+            }
+
         } catch (IOException e) {
             e.printStackTrace();
         }
@@ -78,14 +85,11 @@ public class Server {
 
     }
 
+
     /**
      * Free resources held by this server.
      */
     public void destroy() {
 
     }
-
-    public void injectMessage() {
-
-    }
 }
diff --git a/src/org/gnunet/util/Strings.java b/src/org/gnunet/util/Strings.java
new file mode 100644
index 0000000..41255f7
--- /dev/null
+++ b/src/org/gnunet/util/Strings.java
@@ -0,0 +1,32 @@
+package org.gnunet.util;
+
+public class Strings {
+    public static String dataToString(byte[] data) {
+        StringBuilder sb = new StringBuilder();
+        final String encTable = "0123456789ABCDEFGHIJKLMNOPQRSTUV";
+        long rpos;
+        long bits;
+        long vbit;
+        long size = data.length;
+
+        vbit = 0;
+        rpos = 0;
+        bits = 0;
+        while ((rpos < size) || (vbit > 0)) {
+            if ((rpos < size) && (vbit < 5)) {
+                byte b = data[(int) rpos++];
+                int s = b >= 0 ? b : (256 + b);
+                bits = (bits << 8) | s;   /* eat 8 more bits */
+                vbit += 8;
+            }
+            if (vbit < 5) {
+                bits <<= (5 - vbit);      /* zero-padding */
+                assert (vbit == ((size * 8) % 5));
+                vbit = 5;
+            }
+            sb.append(encTable.charAt((int) (bits >>> (vbit - 5)) & 31));
+            vbit -= 5;
+        }
+        return sb.toString();
+    }
+}
diff --git a/test/org/gnunet/construct/ByteFillMessage.java b/test/org/gnunet/construct/ByteFillMessage.java
index 77bfde1..e2cfb0a 100644
--- a/test/org/gnunet/construct/ByteFillMessage.java
+++ b/test/org/gnunet/construct/ByteFillMessage.java
@@ -2,8 +2,6 @@ package org.gnunet.construct;
 
 
 public class ByteFillMessage implements Message {
-    @NestedMessage
-    public MessageHeader header;
     
     @UInt32
     public int someValue;
diff --git a/test/org/gnunet/construct/ConstructTest.java b/test/org/gnunet/construct/ConstructTest.java
index e0e7b85..11dc097 100644
--- a/test/org/gnunet/construct/ConstructTest.java
+++ b/test/org/gnunet/construct/ConstructTest.java
@@ -1,13 +1,7 @@
 package org.gnunet.construct;
 
-import org.junit.Assert;
-import org.junit.Test;
-
-import java.math.BigInteger;
-import java.nio.ByteBuffer;
-
 public class ConstructTest {
-    
+    /*
     
     @Test
     public void test_ByteFillMessage() {
@@ -172,4 +166,6 @@ public class ConstructTest {
         Assert.assertEquals(h1.messageSize, h2.messageSize);
         Assert.assertEquals(h1.messageType, h2.messageType);
     }
+
+    */
 }
diff --git a/test/org/gnunet/construct/QueryMessage.java b/test/org/gnunet/construct/QueryMessage.java
index 245dd70..2bc5b61 100644
--- a/test/org/gnunet/construct/QueryMessage.java
+++ b/test/org/gnunet/construct/QueryMessage.java
@@ -2,8 +2,6 @@ package org.gnunet.construct;
 
 public class QueryMessage implements Message {
 
-    @NestedMessage
-    public MessageHeader header;
 
     @UInt8
     public int query;