#include "gnunet_util_lib.h"
/**
- * All the states a tunnel can be in.
+ * All the connectivity states a tunnel can be in.
*/
-enum MeshTunnelState
+enum MeshTunnel3CState
{
/**
* Uninitialized status, should never appear in operation.
*/
- MESH_TUNNEL_NEW,
+ MESH_TUNNEL3_NEW,
/**
- * Path to the peer not known yet
+ * Path to the peer not known yet.
*/
- MESH_TUNNEL_SEARCHING,
+ MESH_TUNNEL3_SEARCHING,
/**
* Request sent, not yet answered.
*/
- MESH_TUNNEL_WAITING,
+ MESH_TUNNEL3_WAITING,
/**
- * Peer connected and ready to accept data
+ * Peer connected and ready to accept data.
*/
- MESH_TUNNEL_READY,
+ MESH_TUNNEL3_READY,
- /**
- * Peer connected previosly but not responding
- */
- MESH_TUNNEL_RECONNECTING
+ /**
+ * Tunnel being shut down, don't try to keep it alive.
+ */
+ MESH_TUNNEL3_SHUTDOWN
+};
+
+
+/**
+ * All the encryption states a tunnel can be in.
+ */
+enum MeshTunnel3EState
+{
+ /**
+ * Uninitialized status, should never appear in operation.
+ */
+ MESH_TUNNEL3_KEY_UNINITIALIZED,
+
+ /**
+ * Ephemeral key sent, waiting for peer's key.
+ */
+ MESH_TUNNEL3_KEY_SENT,
+
+ /**
+ * New ephemeral key and ping sent, waiting for pong.
+ * This means that we DO have the peer's ephemeral key, otherwise the
+ * state would be KEY_SENT.
+ */
+ MESH_TUNNEL3_KEY_PING,
+
+ /**
+ * Handshake completed: session key available.
+ */
+ MESH_TUNNEL3_KEY_OK,
};
/**
#include "gnunet-service-mesh_channel.h"
#include "gnunet-service-mesh_connection.h"
+#include "gnunet-service-mesh_peer.h"
+
+/**
+ * Handle for messages queued but not yet sent.
+ */
+struct MeshTunnel3Queue;
+
+/**
+ * Callback called when a queued message is sent.
+ *
+ * @param cls Closure.
+ * @param t Tunnel this message was on.
+ * @param type Type of message sent.
+ * @param size Size of the message.
+ */
+typedef void (*GMT_sent) (void *cls,
+ struct MeshTunnel3 *t,
+ struct MeshTunnel3Queue *q,
+ uint16_t type, size_t size);
+
+typedef void (*GMT_conn_iter) (void *cls, struct MeshConnection *c);
+typedef void (*GMT_chan_iter) (void *cls, struct MeshChannel *ch);
/******************************************************************************/
* Initialize tunnel subsystem.
*
* @param c Configuration handle.
- * @param id Peer identity.
* @param key ECC private key, to derive all other keys and do crypto.
*/
void
GMT_init (const struct GNUNET_CONFIGURATION_Handle *c,
- const struct GNUNET_PeerIdentity *id,
- const struct GNUNET_CRYPTO_EccPrivateKey *key);
+ const struct GNUNET_CRYPTO_EddsaPrivateKey *key);
/**
* Shut down the tunnel subsystem.
void
GMT_shutdown (void);
+/**
+ * Create a tunnel.
+ *
+ * @param destination Peer this tunnel is towards.
+ */
+struct MeshTunnel3 *
+GMT_new (struct MeshPeer *destination);
+
/**
* Tunnel is empty: destroy it.
*
void
GMT_destroy (struct MeshTunnel3 *t);
+
/**
- * Change the tunnel state.
+ * Change the tunnel's connection state.
*
- * @param t Tunnel whose state to change.
- * @param state New state.
+ * @param t Tunnel whose connection state to change.
+ * @param cstate New connection state.
*/
void
-GMT_change_state (struct MeshTunnel3* t, enum MeshTunnelState state);
+GMT_change_cstate (struct MeshTunnel3* t, enum MeshTunnel3CState cstate);
+
+
+/**
+ * Change the tunnel encryption state.
+ *
+ * @param t Tunnel whose encryption state to change.
+ * @param state New encryption state.
+ */
+void
+GMT_change_estate (struct MeshTunnel3* t, enum MeshTunnel3EState state);
/**
* Add a connection to a tunnel.
void
GMT_add_connection (struct MeshTunnel3 *t, struct MeshConnection *c);
+/**
+ * Mark a path as no longer valid for this tunnel: has been tried and failed.
+ *
+ * @param t Tunnel to update.
+ * @param path Invalid path to remove. Is destroyed after removal.
+ */
+void
+GMT_remove_path (struct MeshTunnel3 *t, struct MeshPeerPath *path);
+
/**
* Remove a connection from a tunnel.
*
struct MeshChannel *
GMT_get_channel (struct MeshTunnel3 *t, MESH_ChannelNumber chid);
-
/**
- * Cache a message to be sent once tunnel is online.
+ * Decrypt and demultiplex by message type. Call appropriate handler
+ * for a message
+ * towards a channel of a local tunnel.
*
- * @param t Tunnel to hold the message.
- * @param ch Channel the message is about.
- * @param msg Message itself (copy will be made).
- * @param fwd Is this fwd?
+ * @param t Tunnel this message came on.
+ * @param msg Message header.
*/
void
-GMT_queue_data (struct MeshTunnel3 *t,
- struct MeshChannel *ch,
- struct GNUNET_MessageHeader *msg,
- int fwd);
+GMT_handle_encrypted (struct MeshTunnel3 *t,
+ const struct GNUNET_MESH_Encrypted *msg);
/**
- * Send all cached messages that we can, tunnel is online.
+ * Demultiplex an encapsulated KX message by message type.
*
- * @param t Tunnel that holds the messages.
- * @param fwd Is this fwd?
+ * @param t Tunnel on which the message came.
+ * @param message KX message itself.
*/
void
-GMT_send_queued_data (struct MeshTunnel3 *t, int fwd);
+GMT_handle_kx (struct MeshTunnel3 *t,
+ const struct GNUNET_MessageHeader *message);
+
+/**
+ * @brief Use the given path for the tunnel.
+ * Update the next and prev hops (and RCs).
+ * (Re)start the path refresh in case the tunnel is locally owned.
+ *
+ * @param t Tunnel to update.
+ * @param p Path to use.
+ *
+ * @return Connection created.
+ */
+struct MeshConnection *
+GMT_use_path (struct MeshTunnel3 *t, struct MeshPeerPath *p);
/**
* Count established (ready) connections of a tunnel.
GMT_count_channels (struct MeshTunnel3 *t);
/**
- * Get the state of a tunnel.
+ * Get the connectivity state of a tunnel.
*
* @param t Tunnel.
*
- * @return Tunnel's state.
+ * @return Tunnel's connectivity state.
*/
-enum MeshTunnelState
-GMT_get_state (struct MeshTunnel3 *t);
+enum MeshTunnel3CState
+GMT_get_cstate (struct MeshTunnel3 *t);
/**
- * Get the total buffer space for a tunnel.
+ * Get the encryption state of a tunnel.
+ *
+ * @param t Tunnel.
+ *
+ * @return Tunnel's encryption state.
+ */
+enum MeshTunnel3EState
+GMT_get_estate (struct MeshTunnel3 *t);
+
+/**
+ * Get the maximum buffer space for a tunnel towards a local client.
+ *
+ * @param t Tunnel.
+ *
+ * @return Biggest buffer space offered by any channel in the tunnel.
+ */
+unsigned int
+GMT_get_channels_buffer (struct MeshTunnel3 *t);
+
+/**
+ * Get the total buffer space for a tunnel for P2P traffic.
*
* @param t Tunnel.
- * @param fwd Is this for FWD traffic?
*
* @return Buffer space offered by all connections in the tunnel.
*/
unsigned int
-GMT_get_buffer (struct MeshTunnel3 *t, int fwd);
+GMT_get_connections_buffer (struct MeshTunnel3 *t);
/**
* Get the tunnel's destination.
MESH_ChannelNumber
GMT_get_next_chid (struct MeshTunnel3 *t);
+/**
+ * Send ACK on one or more channels due to buffer in connections.
+ *
+ * @param t Channel which has some free buffer space.
+ */
+void
+GMT_unchoke_channels (struct MeshTunnel3 *t);
+
+/**
+ * Send ACK on one or more connections due to buffer space to the client.
+ *
+ * Iterates all connections of the tunnel and sends ACKs appropriately.
+ *
+ * @param t Tunnel which has some free buffer space.
+ */
+void
+GMT_send_connection_acks (struct MeshTunnel3 *t);
+
+/**
+ * Cancel a previously sent message while it's in the queue.
+ *
+ * ONLY can be called before the continuation given to the send function
+ * is called. Once the continuation is called, the message is no longer in the
+ * queue.
+ *
+ * @param q Handle to the queue.
+ */
+void
+GMT_cancel (struct MeshTunnel3Queue *q);
+
/**
* Sends an already built message on a tunnel, encrypting it and
* choosing the best connection.
*
* @param message Message to send. Function modifies it.
* @param t Tunnel on which this message is transmitted.
- * @param ch Channel on which this message is transmitted.
- * @param fwd Is this a fwd message?
+ * @param c Connection to use (autoselect if NULL).
+ * @param force Force the tunnel to take the message (buffer overfill).
+ * @param cont Continuation to call once message is really sent.
+ * @param cont_cls Closure for @c cont.
+ *
+ * @return Handle to cancel message. NULL if @c cont is NULL.
*/
-void
+struct MeshTunnel3Queue *
GMT_send_prebuilt_message (const struct GNUNET_MessageHeader *message,
- struct MeshTunnel3 *t,
- struct MeshChannel *ch,
- int fwd);
+ struct MeshTunnel3 *t, struct MeshConnection *c,
+ int force, GMT_sent cont, void *cont_cls);
/**
* Is the tunnel directed towards the local peer?
*
* @param t Tunnel.
*
- * @return GNUNET_YES if it is loopback.
+ * @return #GNUNET_YES if it is loopback.
*/
int
GMT_is_loopback (const struct MeshTunnel3 *t);
+/**
+ * Is the tunnel using this path already?
+ *
+ * @param t Tunnel.
+ * @param p Path.
+ *
+ * @return #GNUNET_YES a connection uses this path.
+ */
+int
+GMT_is_path_used (const struct MeshTunnel3 *t, const struct MeshPeerPath *p);
+
+/**
+ * Get a cost of a path for a tunnel considering existing connections.
+ *
+ * @param t Tunnel.
+ * @param path Candidate path.
+ *
+ * @return Cost of the path (path length + number of overlapping nodes)
+ */
+unsigned int
+GMT_get_path_cost (const struct MeshTunnel3 *t,
+ const struct MeshPeerPath *path);
+
/**
* Get the static string for the peer this tunnel is directed.
*
const char *
GMT_2s (const struct MeshTunnel3 *t);
+/**
+ * Log all possible info about the tunnel state.
+ *
+ * @param t Tunnel to debug.
+ */
+void
+GMT_debug (const struct MeshTunnel3 *t);
+
+/**
+ * Iterate all tunnels.
+ *
+ * @param iter Iterator.
+ * @param cls Closure for @c iter.
+ */
+void
+GMT_iterate_all (GNUNET_CONTAINER_PeerMapIterator iter, void *cls);
+
+/**
+ * Count all tunnels.
+ *
+ * @return Number of tunnels to remote peers kept by this peer.
+ */
+unsigned int
+GMT_count_all (void);
+
+/**
+ * Iterate all connections of a tunnel.
+ *
+ * @param t Tunnel whose connections to iterate.
+ * @param iter Iterator.
+ * @param cls Closure for @c iter.
+ */
+void
+GMT_iterate_connections (struct MeshTunnel3 *t, GMT_conn_iter iter, void *cls);
+
+/**
+ * Iterate all channels of a tunnel.
+ *
+ * @param t Tunnel whose channels to iterate.
+ * @param iter Iterator.
+ * @param cls Closure for @c iter.
+ */
+void
+GMT_iterate_channels (struct MeshTunnel3 *t, GMT_chan_iter iter, void *cls);
+
#if 0 /* keep Emacsens' auto-indent happy */
{
#endif
projects / oweals / gnunet.git / blobdiff