1 files changed, 143 insertions, 15 deletions

diff --git a/src/org/gnunet/mesh/Mesh.java b/src/org/gnunet/mesh/Mesh.java
index d739b61..4b43c97 100644
--- a/src/org/gnunet/mesh/Mesh.java
+++ b/src/org/gnunet/mesh/Mesh.java
@@ -25,36 +25,122 @@ import org.gnunet.requests.RequestQueue;
 import org.gnunet.util.*;
 import org.grothoff.Runabout;
 
-import java.util.List;
-
 /**
+ *
+ *
  * @author Florian Dold
  */
 public class Mesh {
     private RequestQueue requestQueue;
     private TunnelEndHandler tunnelEndHandler;
     private Runabout messageReceiver;
-    private List<Integer> applications;
+    private int[] applications;
     private InboundTunnelHandler inboundTunnelHandler;
 
 
-    public static class RootTunnel {
-        int tunnel_id;
+    private int nextTunnelId = 0x80000000;
+
+
+    public class RootTunnel extends Tunnel {
         public void addPeer(PeerIdentity peerIdentity) {
 
         }
+        /**
+         * Request that the given peer isn't added to this tunnel in calls to
+         * connect_by_* calls, (due to misbehaviour, bad performance, ...).
+         *
+         * @param peerIdentity peer identity of the peer which should be blacklisted
+         *                  for the tunnel.
+         */
         public void blacklist(PeerIdentity peerIdentity) {
 
         }
-        public void destroy() {
-            // ...
+        /**
+         * Request that the given peer isn't blacklisted anymore from this tunnel,
+         * and therefore can be added in future calls to connect*.
+         * The peer must have been previously blacklisted for this tunnel.
+         *
+         * @param peerIdentity peer identity of the peer which shouldn't be blacklisted
+         *                  for the tunnel anymore.
+         */
+        public void unblacklist(PeerIdentity peerIdentity) {
+
+        }
+        /**
+         * Request that the mesh should try to connect to a peer supporting the given
+         * message type.
+         *
+         * @param appType application type that must be supported by the peer
+         *                 (MESH should discover peer in proximity handling this type)
+         */
+        public void requestConnectByType (int appType) {
+
+        }
+
+        /**
+         * Request that the mesh should try to connect to a peer matching the
+         * description given in the service string.
+         *
+         * @param description string describing the destination node requirements
+         */
+        public void requestConnectByType (String description) {
+
+        }
+
+        /**
+         * Request that a peer should be added to the tunnel.  The connect handler
+         * will be called when the peer connects
+         *
+         * @param peer peer to add
+         */
+        public void requestConnectAdd (PeerIdentity peer) {
+
+        }
+
+        /**
+         * Request that a peer should be removed from the tunnel.  The existing
+         * disconnect handler will be called ONCE if we were connected.
+         *
+         * @param peer peer to remove
+         */
+        public void requestConnectDel (PeerIdentity peer) {
+
+        }
+
+        private void registerWithService() {
+            requestQueue.add(new TunnelCreateRequest(this));
         }
     }
 
-    public static class Tunnel extends RootTunnel {
-        public Cancelable notifyTransmitReady(PeerIdentity target) {
+    public class Tunnel {
+        int tunnel_id;
+
+        /**
+         * Ask the mesh to call "notify" once it is ready to transmit the
+         * given number of bytes to the specified tunnel or target.
+         * Only one call can be active at any time, to issue another request,
+         * wait for the callback or cancel the current request.
+         *
+         * @param maxdelay how long can the message wait?
+         * @param target destination for the message
+         *               NULL for multicast to all tunnel targets
+         * @param notify_size how many bytes of buffer space does notify want?
+         * @param transmitter handler to call when buffer space is available;
+         *        will be called with NULL on timeout or if the overall queue
+         *        for this peer is larger than queue_size and this is currently
+         *        the message with the lowest priority
+         * @return non-NULL if the notify callback was queued,
+         *         NULL if we can not even queue the request (insufficient
+         *         memory); if NULL is returned, "notify" will NOT be called.
+         */
+        public Cancelable notifyTransmitReady(RelativeTime maxdelay, PeerIdentity target, int notify_size, MessageTransmitter transmitter) {
             return null;
         }
+
+        public void destroy() {
+            // ...
+        }
+
     }
 
 
@@ -62,7 +148,28 @@ public class Mesh {
 
         @Override
         public void transmit(Connection.MessageSink sink) {
-            //To change body of implemented methods use File | Settings | File Templates.
+            ClientConnectMessage ccm = new ClientConnectMessage();
+            ccm.applications_length = applications.length;
+            ccm.apps_list = applications;
+            int[] types = RunaboutUtil.getRunaboutMessageTypes(messageReceiver);
+            ccm.types_list = types;
+            ccm.types_length = types.length;
+            sink.send(ccm);
+        }
+    }
+
+    public class TunnelCreateRequest extends Request {
+        public RootTunnel tunnel;
+
+        public TunnelCreateRequest(RootTunnel rootTunnel) {
+            tunnel = rootTunnel;
+        }
+
+        @Override
+        public void transmit(Connection.MessageSink sink) {
+            TunnelCreateMessage tcm = new TunnelCreateMessage();
+            tcm.tunnel_id = tunnel.tunnel_id;
+            sink.send(tcm);
         }
     }
 
@@ -76,7 +183,7 @@ public class Mesh {
 
 
     public Mesh(Configuration cfg, InboundTunnelHandler inboundTunnelHandler,
-                TunnelEndHandler tunnelEndHandler, Runabout messageReceiver, List<Integer> applications) {
+                TunnelEndHandler tunnelEndHandler, Runabout messageReceiver, int... applications) {
         this.tunnelEndHandler = tunnelEndHandler;
         this.messageReceiver = messageReceiver;
         this.applications = applications;
@@ -86,17 +193,38 @@ public class Mesh {
         requestQueue = new RequestQueue(client, new MeshMessageReceiver());
 
         requestQueue.add(new ClientConnectRequest());
-
     }
 
     /**
      * Create a new tunnel (we're initiator and will be allowed to add/remove peers
      * and to broadcast).
+     *
+     * @param connectHandler function to call when peers are actually connected
+     * @param disconnectHandler function to call when peers are disconnected
      */
-    public RootTunnel createTunnel(/* ... */) {
-        return null;
+    public RootTunnel createTunnel(ConnectHandler connectHandler, DisconnectHandler disconnectHandler) {
+        RootTunnel tunnel = new RootTunnel();
+        tunnel.tunnel_id = nextTunnelId++;
+        tunnel.registerWithService();
+        return tunnel;
     }
 
+
+    /**
+     * Announce to ther peer the availability of services described by the regex,
+     * in order to be reachable to other peers via connect_by_string.
+     *
+     * Note that the first 8 characters are considered to be part of a prefix,
+     * (for instance 'gnunet://'). If you put a variable part in there (*, +. ()),
+     * all matching strings will be stored in the DHT.
+     *
+     * @param regex string with the regular expression describing local services.
+     */
+    public void announceRegex(String regex) {
+
+    }
+
+
     /**
      * Disconnect from the mesh service. All tunnels will be destroyed. All tunnel
      * disconnect callbacks will be called on any still connected peers, notifying
@@ -104,6 +232,6 @@ public class Mesh {
      * called should any inbound tunnels still exist.
      */
     public void disconnect() {
-
+        requestQueue.destroy();
     }
 }