1 files changed, 156 insertions, 0 deletions

diff --git a/src/main/java/org/gnunet/transport/Transport.java b/src/main/java/org/gnunet/transport/Transport.java
new file mode 100644
index 0000000..b9881b6
--- /dev/null
+++ b/src/main/java/org/gnunet/transport/Transport.java
@@ -0,0 +1,156 @@
+package org.gnunet.transport;
+
+import org.gnunet.hello.HelloMessage;
+import org.gnunet.mq.Envelope;
+import org.gnunet.mq.NotifySentHandler;
+import org.gnunet.util.*;
+
+/**
+ * ...
+ *
+ * @author Florian Dold
+ */
+public class Transport {
+
+    /**
+     * 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());
+    }
+
+    /**
+     * Ask the transport service to establish a connection to
+     * the given peer.
+     *
+     * @param target who we should try to connect to
+     * @param cb     callback to be called when request was transmitted to transport
+     *               service
+     * @return a handle to cancel the operation
+     */
+    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(new NotifySentHandler() {
+            @Override
+            public void onSent() {
+                cb.onDone();
+            }
+        });
+        client.send(ev);
+
+        return new Cancelable() {
+            @Override
+            public void cancel() {
+                ev.cancel();
+            }
+        };
+    }
+
+    /**
+     * ... (discuss first)
+     */
+    public void init(Object receiveCallback, Object notifyConnect, Object notifyDisconnect) {
+
+    }
+
+
+    /**
+     * Obtain the HELLO message for this peer.
+     *
+     * @param rec function to call with the HELLO, sender will be our peer
+     *            identity; message and sender will be NULL on timeout
+     *            (handshake with transport service pending/failed).
+     *            cost estimate will be 0.
+     * @return handle to cancel the operation
+     */
+    Cancelable getHello(HelloUpdateCallback rec) {
+        throw new UnsupportedOperationException();
+    }
+
+    /**
+     * Offer the transport service the HELLO of another peer.  Note that
+     * the transport service may just ignore this message if the HELLO is
+     * malformed or useless due to our local configuration.
+     *
+     * @param hello the hello message
+     * @param cont  continuation to call when HELLO has been sent,
+     *              tc reason GNUNET_SCHEDULER_REASON_TIMEOUT for fail
+     *              tc reasong GNUNET_SCHEDULER_REASON_READ_READY for success
+     * @return a GNUNET_TRANSPORT_OfferHelloHandle handle or NULL on failure,
+     *         in case of failure cont will not be called
+     */
+
+    Cancelable offerHello(HelloMessage hello,
+                          Scheduler.Task cont) {
+        throw new UnsupportedOperationException();
+    }
+
+    /**
+     * 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.
+     * 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.  This is the only way to re-enable
+     * connections from peers that were previously blacklisted.
+     *
+     * @param blacklistCallback  callback to invoke to check if connections are allowed
+     */
+    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 false
+     * <p/>
+     * 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 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 getActiveAddresses(PeerIdentity peer, int one_shot,
+                              RelativeTime timeout, PeerIterateCallback peer_address_callback) {
+        throw new UnsupportedOperationException();
+    }
+}
+