/*
This file is part of GNUnet.
- (C) 2013 Christian Grothoff (and other contributing authors)
+ Copyright (C) 2013 GNUnet e.V.
GNUnet is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
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.
+ Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
*/
/**
#include "platform.h"
#include "gnunet_util_lib.h"
+#include "cadet_path.h"
/**
* Struct containing all information regarding a given peer
struct CadetPeer;
/**
- * Struct containing info about a queued transmission to this peer
+ * Handle to queued messages on a peer level.
*/
struct CadetPeerQueue;
#include "gnunet-service-cadet_connection.h"
+
/**
* Callback called when a queued message is sent.
*
* @param cls Closure.
* @param c Connection this message was on.
+ * @param fwd Was this a FWD going message?
* @param sent Was it really sent? (Could have been canceled)
* @param type Type of message sent.
- * @param pid Packet ID, or 0 if not applicable (create, destroy, etc).
- * @param fwd Was this a FWD going message?
+ * @param payload_type Type of payload, if applicable.
+ * @param pid Message ID, or 0 if not applicable (create, destroy, etc).
* @param size Size of the message.
* @param wait Time spent waiting for core (only the time for THIS message)
*/
-typedef void (*GMP_sent) (void *cls,
- struct CadetConnection *c, int sent,
- uint16_t type, uint32_t pid, int fwd, size_t size,
- struct GNUNET_TIME_Relative wait);
+typedef void
+(*GCP_sent) (void *cls,
+ struct CadetConnection *c, int fwd, int sent,
+ uint16_t type, uint16_t payload_type, uint32_t pid,
+ size_t size,
+ struct GNUNET_TIME_Relative wait);
+
+/**
+ * Peer path iterator.
+ *
+ * @param cls Closure.
+ * @param peer Peer this path is towards.
+ * @param path Path itself
+ * @return #GNUNET_YES if should keep iterating.
+ * #GNUNET_NO otherwise.
+ */
+typedef int
+(*GCP_path_iterator) (void *cls,
+ struct CadetPeer *peer,
+ struct CadetPeerPath *path);
+
/******************************************************************************/
/******************************** API ***********************************/
* @param c Configuration.
*/
void
-GMP_init (const struct GNUNET_CONFIGURATION_Handle *c);
+GCP_init (const struct GNUNET_CONFIGURATION_Handle *c);
/**
* Shut down the peer subsystem.
*/
void
-GMP_shutdown (void);
+GCP_shutdown (void);
/**
- * Retrieve the CadetPeer stucture associated with the peer, create one
- * and insert it in the appropriate structures if the peer is not known yet.
+ * Retrieve the CadetPeer stucture associated with the peer. Optionally create
+ * one and insert it in the appropriate structures if the peer is not known yet.
*
* @param peer_id Full identity of the peer.
+ * @param create #GNUNET_YES if a new peer should be created if unknown.
+ * #GNUNET_NO otherwise.
*
* @return Existing or newly created peer structure.
+ * NULL if unknown and not requested @a create
*/
struct CadetPeer *
-GMP_get (const struct GNUNET_PeerIdentity *peer_id);
-
+GCP_get (const struct GNUNET_PeerIdentity *peer_id, int create);
/**
- * Retrieve the CadetPeer stucture associated with the peer, create one
- * and insert it in the appropriate structures if the peer is not known yet.
+ * Retrieve the CadetPeer stucture associated with the peer. Optionally create
+ * one and insert it in the appropriate structures if the peer is not known yet.
*
* @param peer Short identity of the peer.
+ * @param create #GNUNET_YES if a new peer should be created if unknown.
+ * #GNUNET_NO otherwise.
*
* @return Existing or newly created peer structure.
+ * NULL if unknown and not requested @a create
*/
struct CadetPeer *
-GMP_get_short (const GNUNET_PEER_Id peer);
+GCP_get_short (const GNUNET_PEER_Id peer, int create);
/**
* Try to establish a new connection to this peer (in its tunnel).
* @param peer Peer to connect to.
*/
void
-GMP_connect (struct CadetPeer *peer);
-
-/**
- * Free a transmission that was already queued with all resources
- * associated to the request.
- *
- * @param queue Queue handler to cancel.
- * @param clear_cls Is it necessary to free associated cls?
- * @param sent Was it really sent? (Could have been canceled)
- * @param pid PID, if relevant (was sent and was a payload message).
- */
-void
-GMP_queue_destroy (struct CadetPeerQueue *queue, int clear_cls,
- int sent, uint32_t pid);
+GCP_connect (struct CadetPeer *peer);
/**
- * @brief Queue and pass message to core when possible.
+ * @brief Send a message to another peer (using CORE).
*
* @param peer Peer towards which to queue the message.
- * @param cls Closure (@c type dependant). It will be used by queue_send to
- * build the message to be sent if not already prebuilt.
- * @param type Type of the message, 0 for a raw message.
- * @param size Size of the message.
- * @param c Connection this message belongs to (cannot be NULL).
+ * @param message Message to send.
+ * @param payload_type Type of the message's payload, for debug messages.
+ * 0 if the message is a retransmission (unknown payload).
+ * UINT16_MAX if the message does not have payload.
+ * @param payload_id ID of the payload (MID, ACK #, etc)
+ * @param c Connection this message belongs to (can be NULL).
* @param fwd Is this a message going root->dest? (FWD ACK are NOT FWD!)
- * @param cont Continuation to be called once CORE has taken the message.
+ * @param cont Continuation to be called once CORE has sent the message.
* @param cont_cls Closure for @c cont.
- *
- * @return Handle to cancel the message before it is sent. Once cont is called
- * message has been sent and therefore the handle is no longer valid.
*/
struct CadetPeerQueue *
-GMP_queue_add (struct CadetPeer *peer, void *cls, uint16_t type,
- uint16_t payload_type, uint32_t payload_id,
- size_t size, struct CadetConnection *c, int fwd,
- GMP_sent cont, void *cont_cls);
+GCP_send (struct CadetPeer *peer,
+ const struct GNUNET_MessageHeader *message,
+ uint16_t payload_type,
+ uint32_t payload_id,
+ struct CadetConnection *c,
+ int fwd,
+ GCP_sent cont,
+ void *cont_cls);
/**
- * Cancel all queued messages to a peer that belong to a certain connection.
+ * Cancel sending a message. Message must have been sent with
+ * #GCP_send before. May not be called after the notify sent
+ * callback has been called.
*
- * @param peer Peer towards whom to cancel.
- * @param c Connection whose queued messages to cancel. Might be destroyed by
- * the sent continuation call.
- */
-void
-GMP_queue_cancel (struct CadetPeer *peer, struct CadetConnection *c);
-
-/**
- * Get the first message for a connection and unqueue it.
+ * It does NOT call the continuation given to #GCP_send.
*
- * @param peer Neighboring peer.
- * @param c Connection.
- *
- * @return First message for this connection.
+ * @param q Queue handle to cancel
*/
-struct GNUNET_MessageHeader *
-GMP_connection_pop (struct CadetPeer *peer, struct CadetConnection *c);
-
void
-GMP_queue_unlock (struct CadetPeer *peer, struct CadetConnection *c);
+GCP_send_cancel (struct CadetPeerQueue *q);
/**
* Set tunnel.
* @param t Tunnel.
*/
void
-GMP_set_tunnel (struct CadetPeer *peer, struct CadetTunnel3 *t);
+GCP_set_tunnel (struct CadetPeer *peer, struct CadetTunnel *t);
+
/**
* Check whether there is a direct (core level) connection to peer.
* @return #GNUNET_YES if there is a direct connection.
*/
int
-GMP_is_neighbor (const struct CadetPeer *peer);
+GCP_is_neighbor (const struct CadetPeer *peer);
+
/**
* Create and initialize a new tunnel towards a peer, in case it has none.
* @param peer Peer towards which to create the tunnel.
*/
void
-GMP_add_tunnel (struct CadetPeer *peer);
+GCP_add_tunnel (struct CadetPeer *peer);
+
/**
* Add a connection to a neighboring peer.
*
* @param peer Peer to add connection to.
* @param c Connection to add.
- *
- * @return GNUNET_OK on success.
+ * @param pred #GNUNET_YES if we are predecessor, #GNUNET_NO if we are successor
*/
-int
-GMP_add_connection (struct CadetPeer *peer, struct CadetConnection *c);
+void
+GCP_add_connection (struct CadetPeer *peer,
+ struct CadetConnection *c,
+ int pred);
+
/**
* Add the path to the peer and update the path used to reach it in case this
* NULL on error.
*/
struct CadetPeerPath *
-GMP_add_path (struct CadetPeer *peer, struct CadetPeerPath *p, int trusted);
+GCP_add_path (struct CadetPeer *peer,
+ struct CadetPeerPath *p,
+ int trusted);
+
/**
* Add the path to the origin peer and update the path used to reach it in case
* NULL on error.
*/
struct CadetPeerPath *
-GMP_add_path_to_origin (struct CadetPeer *peer,
+GCP_add_path_to_origin (struct CadetPeer *peer,
struct CadetPeerPath *path,
int trusted);
* @param confirmed Whether we know if the path works or not.
*/
void
-GMP_add_path_to_all (const struct CadetPeerPath *p, int confirmed);
+GCP_add_path_to_all (const struct CadetPeerPath *p, int confirmed);
+
/**
* Remove any path to the peer that has the extact same peers as the one given.
* @param path Path to remove. Is always destroyed .
*/
void
-GMP_remove_path (struct CadetPeer *peer, struct CadetPeerPath *path);
+GCP_remove_path (struct CadetPeer *peer,
+ struct CadetPeerPath *path);
+
+
+/**
+ * Check that we are aware of a connection from a neighboring peer.
+ *
+ * @param peer Peer to the connection is with
+ * @param c Connection that should be in the map with this peer.
+ */
+void
+GCP_check_connection (const struct CadetPeer *peer,
+ const struct CadetConnection *c);
+
/**
* Remove a connection from a neighboring peer.
*
* @param peer Peer to remove connection from.
* @param c Connection to remove.
- *
- * @return GNUNET_OK on success.
*/
-int
-GMP_remove_connection (struct CadetPeer *peer, const struct CadetConnection *c);
+void
+GCP_remove_connection (struct CadetPeer *peer,
+ const struct CadetConnection *c);
+
/**
* Start the DHT search for new paths towards the peer: we don't have
* @param peer Destination peer.
*/
void
-GMP_start_search (struct CadetPeer *peer);
+GCP_start_search (struct CadetPeer *peer);
+
/**
* Stop the DHT search for new paths towards the peer: we already have
* @param peer Destination peer.
*/
void
-GMP_stop_search (struct CadetPeer *peer);
+GCP_stop_search (struct CadetPeer *peer);
+
/**
* Get the Full ID of a peer.
* @return Full ID of peer.
*/
const struct GNUNET_PeerIdentity *
-GMP_get_id (const struct CadetPeer *peer);
+GCP_get_id (const struct CadetPeer *peer);
+
/**
* Get the Short ID of a peer.
* @return Short ID of peer.
*/
GNUNET_PEER_Id
-GMP_get_short_id (const struct CadetPeer *peer);
+GCP_get_short_id (const struct CadetPeer *peer);
+
/**
* Get the tunnel towards a peer.
*
* @return Tunnel towards peer.
*/
-struct CadetTunnel3 *
-GMP_get_tunnel (const struct CadetPeer *peer);
+struct CadetTunnel *
+GCP_get_tunnel (const struct CadetPeer *peer);
+
/**
* Set the hello message.
* @param hello Hello message.
*/
void
-GMP_set_hello (struct CadetPeer *peer, const struct GNUNET_HELLO_Message *hello);
+GCP_set_hello (struct CadetPeer *peer,
+ const struct GNUNET_HELLO_Message *hello);
+
/**
* Get the hello message.
* @return Hello message.
*/
struct GNUNET_HELLO_Message *
-GMP_get_hello (struct CadetPeer *peer);
+GCP_get_hello (struct CadetPeer *peer);
/**
* @param peer Peer to whom to connect.
*/
void
-GMP_try_connect (struct CadetPeer *peer);
+GCP_try_connect (struct CadetPeer *peer);
/**
* Notify a peer that a link between two other peers is broken. If any path
* @param peer2 Peer whose link is broken.
*/
void
-GMP_notify_broken_link (struct CadetPeer *peer,
- struct GNUNET_PeerIdentity *peer1,
- struct GNUNET_PeerIdentity *peer2);
+GCP_notify_broken_link (struct CadetPeer *peer,
+ const struct GNUNET_PeerIdentity *peer1,
+ const struct GNUNET_PeerIdentity *peer2);
+
/**
* Count the number of known paths toward the peer.
* @return Number of known paths.
*/
unsigned int
-GMP_count_paths (const struct CadetPeer *peer);
+GCP_count_paths (const struct CadetPeer *peer);
+
+/**
+ * Iterate over the paths to a peer.
+ *
+ * @param peer Peer to get path info.
+ * @param callback Function to call for every path.
+ * @param cls Closure for @a callback.
+ *
+ * @return Number of iterated paths.
+ */
+unsigned int
+GCP_iterate_paths (struct CadetPeer *peer,
+ GCP_path_iterator callback,
+ void *cls);
+
/**
* Iterate all known peers.
* @param cls Closure for @c iter.
*/
void
-GMP_iterate_all (GNUNET_CONTAINER_PeerMapIterator iter, void *cls);
+GCP_iterate_all (GNUNET_CONTAINER_PeerMapIterator iter, void *cls);
+
/**
* Get the static string for a peer ID.
* @return Static string for it's ID.
*/
const char *
-GMP_2s (const struct CadetPeer *peer);
+GCP_2s (const struct CadetPeer *peer);
+
+
+/**
+ * Log all kinds of info about a peer.
+ *
+ * @param peer Peer.
+ */
+void
+GCP_debug (const struct CadetPeer *p,
+ enum GNUNET_ErrorType level);
#if 0 /* keep Emacsens' auto-indent happy */