X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Fmesh%2Fgnunet-service-mesh_peer.c;h=515c4b4f0fdae87e218465702fca5530893d6019;hb=0f6d24a229e9149db26a4e667ed25032d19f533a;hp=008ba5a5192661e9eb690bba5f7db47478f7480a;hpb=b8cfe698546bd64e4e8a062cf923cf5351f2a49a;p=oweals%2Fgnunet.git diff --git a/src/mesh/gnunet-service-mesh_peer.c b/src/mesh/gnunet-service-mesh_peer.c index 008ba5a51..515c4b4f0 100644 --- a/src/mesh/gnunet-service-mesh_peer.c +++ b/src/mesh/gnunet-service-mesh_peer.c @@ -23,6 +23,7 @@ #include "gnunet_util_lib.h" #include "gnunet_core_service.h" +#include "gnunet_statistics_service.h" #include "mesh_protocol_enc.h" @@ -39,6 +40,72 @@ /******************************** STRUCTS **********************************/ /******************************************************************************/ +/** + * Struct containing info about a queued transmission to this peer + */ +struct MeshPeerQueue +{ + /** + * DLL next + */ + struct MeshPeerQueue *next; + + /** + * DLL previous + */ + struct MeshPeerQueue *prev; + + /** + * Peer this transmission is directed to. + */ + struct MeshPeer *peer; + + /** + * Connection this message belongs to. + */ + struct MeshConnection *c; + + /** + * Is FWD in c? + */ + int fwd; + + /** + * Channel this message belongs to, if known. + */ + struct MeshChannel *ch; + + /** + * Pointer to info stucture used as cls. + */ + void *cls; + + /** + * Type of message + */ + uint16_t type; + + /** + * Size of the message + */ + size_t size; + + /** + * Set when this message starts waiting for CORE. + */ + struct GNUNET_TIME_Absolute start_waiting; + + /** + * Function to call on sending. + */ + GMP_sent callback; + + /** + * Closure for callback. + */ + void *callback_cls; +}; + /** * Struct containing all information regarding a given peer */ @@ -72,7 +139,7 @@ struct MeshPeer /** * Tunnel to this peer, if any. */ - struct MeshTunnel2 *tunnel; + struct MeshTunnel3 *tunnel; /** * Connections that go through this peer, indexed by tid; @@ -105,6 +172,21 @@ struct MeshPeer /******************************* GLOBALS ***********************************/ /******************************************************************************/ +/** + * Global handle to the statistics service. + */ +extern struct GNUNET_STATISTICS_Handle *stats; + +/** + * Local peer own ID (full value). + */ +extern struct GNUNET_PeerIdentity my_full_id; + +/** + * Local peer own ID (short) + */ +extern GNUNET_PEER_Id myid; + /** * Peers known, indexed by PeerIdentity (MeshPeer). */ @@ -125,10 +207,6 @@ static unsigned long long drop_percent; */ static struct GNUNET_CORE_Handle *core_handle; -/** - * Local peer own ID (full value). - */ -const static struct GNUNET_PeerIdentity *my_full_id; /******************************************************************************/ /***************************** CORE CALLBACKS *********************************/ @@ -154,7 +232,7 @@ notify_broken (void *cls, struct MeshPeer *peer = cls; struct MeshConnection *c = value; - GMC_notify_broken (c, peer, my_full_id); + GMC_notify_broken (c, peer); return GNUNET_YES; } @@ -169,30 +247,30 @@ notify_broken (void *cls, static void core_connect (void *cls, const struct GNUNET_PeerIdentity *peer) { - struct MeshPeer *pi; + struct MeshPeer *mp; struct MeshPeerPath *path; - LOG ("Peer connected\n"); - LOG (" %s\n", GNUNET_i2s (&my_full_id)); - pi = peer_get (peer); - if (myid == pi->id) + LOG (GNUNET_ERROR_TYPE_DEBUG, "Peer connected\n"); + LOG (GNUNET_ERROR_TYPE_DEBUG, " %s\n", GNUNET_i2s (&my_full_id)); + mp = GMP_get (peer); + if (myid == mp->id) { - LOG (" (self)\n"); + LOG (GNUNET_ERROR_TYPE_DEBUG, " (self)\n"); path = path_new (1); } else { - LOG (" %s\n", GNUNET_i2s (peer)); + LOG (GNUNET_ERROR_TYPE_DEBUG, " %s\n", GNUNET_i2s (peer)); path = path_new (2); - path->peers[1] = pi->id; - GNUNET_PEER_change_rc (pi->id, 1); + path->peers[1] = mp->id; + GNUNET_PEER_change_rc (mp->id, 1); GNUNET_STATISTICS_update (stats, "# peers", 1, GNUNET_NO); } path->peers[0] = myid; GNUNET_PEER_change_rc (myid, 1); - peer_add_path (pi, path, GNUNET_YES); + GMP_add_path (mp, path, GNUNET_YES); - pi->connections = GNUNET_CONTAINER_multihashmap_create (32, GNUNET_YES); + mp->connections = GNUNET_CONTAINER_multihashmap_create (32, GNUNET_YES); return; } @@ -208,7 +286,7 @@ core_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer) { struct MeshPeer *pi; - LOG ("Peer disconnected\n"); + LOG (GNUNET_ERROR_TYPE_DEBUG, "Peer disconnected\n"); pi = GNUNET_CONTAINER_multipeermap_get (peers, peer); if (NULL == pi) { @@ -226,7 +304,7 @@ core_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer) } if (myid == pi->id) { - LOG (" (self)\n"); + LOG (GNUNET_ERROR_TYPE_DEBUG, " (self)\n"); } GNUNET_STATISTICS_update (stats, "# peers", -1, GNUNET_NO); @@ -254,8 +332,7 @@ static struct GNUNET_CORE_MessageHandler core_handlers[] = { sizeof (struct GNUNET_MESH_ACK)}, {&GMC_handle_poll, GNUNET_MESSAGE_TYPE_MESH_POLL, sizeof (struct GNUNET_MESH_Poll)}, - {&GMC_handle_fwd, GNUNET_MESSAGE_TYPE_MESH_FWD, 0}, - {&GMC_handle_bck, GNUNET_MESSAGE_TYPE_MESH_BCK, 0}, + {&GMC_handle_encrypted, GNUNET_MESSAGE_TYPE_MESH_ENCRYPTED, 0}, {NULL, 0, 0} }; @@ -339,7 +416,7 @@ send_core_connection_create (struct MeshConnection *c, size_t size, void *buf) { struct GNUNET_MESH_ConnectionCreate *msg; struct GNUNET_PeerIdentity *peer_ptr; - struct MeshPeerPath *p = c->path; + const struct MeshPeerPath *p = GMC_get_path (c); size_t size_needed; int i; @@ -356,7 +433,7 @@ send_core_connection_create (struct MeshConnection *c, size_t size, void *buf) msg = (struct GNUNET_MESH_ConnectionCreate *) buf; msg->header.size = htons (size_needed); msg->header.type = htons (GNUNET_MESSAGE_TYPE_MESH_CONNECTION_CREATE); - msg->cid = c->id; + msg->cid = *GMC_get_id (c); peer_ptr = (struct GNUNET_PeerIdentity *) &msg[1]; for (i = 0; i < p->length; i++) @@ -364,8 +441,9 @@ send_core_connection_create (struct MeshConnection *c, size_t size, void *buf) GNUNET_PEER_resolve (p->peers[i], peer_ptr++); } - LOG (GNUNET_ERROR_TYPE_DEBUG, - "CONNECTION CREATE (%u bytes long) sent!\n", size_needed); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "CONNECTION CREATE (%u bytes long) sent!\n", + size_needed); return size_needed; } @@ -383,10 +461,8 @@ static size_t send_core_connection_ack (struct MeshConnection *c, size_t size, void *buf) { struct GNUNET_MESH_ConnectionACK *msg = buf; - struct MeshTunnel2 *t = c->t; LOG (GNUNET_ERROR_TYPE_DEBUG, "Sending CONNECTION ACK...\n"); - GNUNET_assert (NULL != t); if (sizeof (struct GNUNET_MESH_ConnectionACK) > size) { GNUNET_break (0); @@ -394,7 +470,7 @@ send_core_connection_ack (struct MeshConnection *c, size_t size, void *buf) } msg->header.size = htons (sizeof (struct GNUNET_MESH_ConnectionACK)); msg->header.type = htons (GNUNET_MESSAGE_TYPE_MESH_CONNECTION_ACK); - msg->cid = c->id; + msg->cid = *GMC_get_id (c); msg->reserved = 0; /* TODO add signature */ @@ -423,7 +499,7 @@ shutdown_tunnel (void *cls, void *value) { struct MeshPeer *p = value; - struct MeshTunnel2 *t = p->tunnel; + struct MeshTunnel3 *t = p->tunnel; if (NULL != t) GMT_destroy (t); @@ -456,21 +532,21 @@ peer_destroy (struct MeshPeer *peer) LOG (GNUNET_ERROR_TYPE_WARNING, "removing peer %s, not in peermap\n", GNUNET_i2s (&id)); } - if (NULL != peer->search_h) - { - GMD_search_stop (peer->search_h); - } - p = peer->path_head; - while (NULL != p) - { - nextp = p->next; - GNUNET_CONTAINER_DLL_remove (peer->path_head, peer->path_tail, p); - path_destroy (p); - p = nextp; - } - tunnel_destroy_empty (peer->tunnel); - GNUNET_free (peer); - return GNUNET_OK; + if (NULL != peer->search_h) + { + GMD_search_stop (peer->search_h); + } + p = peer->path_head; + while (NULL != p) + { + nextp = p->next; + GNUNET_CONTAINER_DLL_remove (peer->path_head, peer->path_tail, p); + path_destroy (p); + p = nextp; + } + GMT_destroy_empty (peer->tunnel); + GNUNET_free (peer); + return GNUNET_OK; } @@ -568,93 +644,6 @@ peer_delete_oldest (void) } -/** - * Retrieve the MeshPeer stucture associated with the peer, create one - * and insert it in the appropriate structures if the peer is not known yet. - * - * @param peer Full identity of the peer. - * - * @return Existing or newly created peer info. - */ -static struct MeshPeer * -peer_get (const struct GNUNET_PeerIdentity *peer_id) -{ - struct MeshPeer *peer; - - peer = GNUNET_CONTAINER_multipeermap_get (peers, peer_id); - if (NULL == peer) - { - peer = GNUNET_new (struct MeshPeer); - if (GNUNET_CONTAINER_multipeermap_size (peers) > max_peers) - { - peer_delete_oldest (); - } - GNUNET_CONTAINER_multipeermap_put (peers, peer_id, peer, - GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST); - peer->id = GNUNET_PEER_intern (peer_id); - } - peer->last_contact = GNUNET_TIME_absolute_get(); - - return peer; -} - - -/** - * Retrieve the MeshPeer stucture associated with the peer, create one - * and insert it in the appropriate structures if the peer is not known yet. - * - * @param peer Short identity of the peer. - * - * @return Existing or newly created peer info. - */ -static struct MeshPeer * -peer_get_short (const GNUNET_PEER_Id peer) -{ - return peer_get (GNUNET_PEER_resolve2 (peer)); -} - - -/** - * Get a cost of a path for a peer considering existing tunnel connections. - * - * @param peer Peer towards which the path is considered. - * @param path Candidate path. - * - * @return Cost of the path (path length + number of overlapping nodes) - */ -static unsigned int -peer_get_path_cost (const struct MeshPeer *peer, - const struct MeshPeerPath *path) -{ - struct MeshConnection *c; - unsigned int overlap; - unsigned int i; - unsigned int j; - - if (NULL == path) - return 0; - - overlap = 0; - GNUNET_assert (NULL != peer->tunnel); - - for (i = 0; i < path->length; i++) - { - for (c = peer->tunnel->connection_head; NULL != c; c = c->next) - { - for (j = 0; j < c->path->length; j++) - { - if (path->peers[i] == c->path->peers[j]) - { - overlap++; - break; - } - } - } - } - return (path->length + overlap) * (path->score * -1); -} - - /** * Choose the best path towards a peer considering the tunnel properties. * @@ -667,7 +656,6 @@ peer_get_best_path (const struct MeshPeer *peer) { struct MeshPeerPath *best_p; struct MeshPeerPath *p; - struct MeshConnection *c; unsigned int best_cost; unsigned int cost; @@ -675,153 +663,56 @@ peer_get_best_path (const struct MeshPeer *peer) best_p = NULL; for (p = peer->path_head; NULL != p; p = p->next) { - for (c = peer->tunnel->connection_head; NULL != c; c = c->next) - if (c->path == p) - break; - if (NULL != c) - continue; /* If path is in use in a connection, skip it. */ - - if ((cost = peer_get_path_cost (peer, p)) < best_cost) - { - best_cost = cost; - best_p = p; - } + if (GNUNET_YES == GMT_is_path_used (peer->tunnel, p)) + continue; /* If path is already in use, skip it. */ + + if ((cost = GMT_get_path_cost (peer->tunnel, p)) < best_cost) + { + best_cost = cost; + best_p = p; + } } - return best_p; + return best_p; } -/** - * Add the path to the peer and update the path used to reach it in case this - * is the shortest. - * - * @param peer_info Destination peer to add the path to. - * @param path New path to add. Last peer must be the peer in arg 1. - * Path will be either used of freed if already known. - * @param trusted Do we trust that this path is real? - */ -void -peer_add_path (struct MeshPeer *peer_info, struct MeshPeerPath *path, - int trusted) +static int +queue_is_sendable (struct MeshPeerQueue *q) { - struct MeshPeerPath *aux; - unsigned int l; - unsigned int l2; - - if ((NULL == peer_info) || (NULL == path)) + /* Is PID-independent? */ + switch (q->type) { - GNUNET_break (0); - path_destroy (path); - return; + case GNUNET_MESSAGE_TYPE_MESH_ACK: + case GNUNET_MESSAGE_TYPE_MESH_POLL: + return GNUNET_YES; } - if (path->peers[path->length - 1] != peer_info->id) - { - GNUNET_break (0); - path_destroy (path); - return; - } - if (2 >= path->length && GNUNET_NO == trusted) - { - /* Only allow CORE to tell us about direct paths */ - path_destroy (path); - return; - } - for (l = 1; l < path->length; l++) - { - if (path->peers[l] == myid) - { - LOG (GNUNET_ERROR_TYPE_DEBUG, "shortening path by %u\n", l); - for (l2 = 0; l2 < path->length - l; l2++) - { - path->peers[l2] = path->peers[l + l2]; - } - path->length -= l; - l = 1; - path->peers = - GNUNET_realloc (path->peers, path->length * sizeof (GNUNET_PEER_Id)); - } - } - - LOG (GNUNET_ERROR_TYPE_DEBUG, "adding path [%u] to peer %s\n", - path->length, peer2s (peer_info)); - l = path_get_length (path); - if (0 == l) - { - path_destroy (path); - return; - } + if (GMC_is_sendable (q->c, q->fwd)) + return GNUNET_YES; - GNUNET_assert (peer_info->id == path->peers[path->length - 1]); - for (aux = peer_info->path_head; aux != NULL; aux = aux->next) - { - l2 = path_get_length (aux); - if (l2 > l) - { - GNUNET_CONTAINER_DLL_insert_before (peer_info->path_head, - peer_info->path_tail, aux, path); - return; - } - else - { - if (l2 == l && memcmp (path->peers, aux->peers, l) == 0) - { - path_destroy (path); - return; - } - } - } - GNUNET_CONTAINER_DLL_insert_tail (peer_info->path_head, peer_info->path_tail, - path); - return; + return GNUNET_NO; } /** - * Add the path to the origin peer and update the path used to reach it in case - * this is the shortest. - * The path is given in peer_info -> destination, therefore we turn the path - * upside down first. + * Get first sendable message. * - * @param peer_info Peer to add the path to, being the origin of the path. - * @param path New path to add after being inversed. - * Path will be either used or freed. - * @param trusted Do we trust that this path is real? - */ -static void -peer_add_path_to_origin (struct MeshPeer *peer_info, - struct MeshPeerPath *path, int trusted) -{ - if (NULL == path) - return; - path_invert (path); - peer_add_path (peer_info, path, trusted); -} - - -/** - * Adds a path to the peer_infos of all the peers in the path + * @param peer The destination peer. * - * @param p Path to process. - * @param confirmed Whether we know if the path works or not. + * @return Best current known path towards the peer, if any. */ -static void -path_add_to_peers (struct MeshPeerPath *p, int confirmed) +static struct MeshPeerQueue * +peer_get_first_message (const struct MeshPeer *peer) { - unsigned int i; + struct MeshPeerQueue *q; - /* TODO: invert and add */ - for (i = 0; i < p->length && p->peers[i] != myid; i++) /* skip'em */ ; - for (i++; i < p->length; i++) + for (q = peer->queue_head; NULL != q; q = q->next) { - struct MeshPeer *aux; - struct MeshPeerPath *copy; - - aux = peer_get_short (p->peers[i]); - copy = path_duplicate (p); - copy->length = i + 1; - peer_add_path (aux, copy, p->length < 3 ? GNUNET_NO : confirmed); + if (queue_is_sendable (q)) + return q; } + + return NULL; } @@ -834,21 +725,21 @@ path_add_to_peers (struct MeshPeerPath *p, int confirmed) * @param path */ static void -search_handler (void *cls, struct MeshPeerPath *path) +search_handler (void *cls, const struct MeshPeerPath *path) { struct MeshPeer *peer = cls; unsigned int connection_count; - path_add_to_peers (path, GNUNET_NO); + GMP_add_path_to_all (path, GNUNET_NO); /* Count connections */ - connection_count = GMC_count (peer->tunnel->connection_head); + connection_count = GMT_count_connections (peer->tunnel); /* If we already have 3 (or more (?!)) connections, it's enough */ if (3 <= connection_count) return; - if (peer->tunnel->state == MESH_TUNNEL_SEARCHING) + if (MESH_TUNNEL3_SEARCHING == GMT_get_state (peer->tunnel)) { LOG (GNUNET_ERROR_TYPE_DEBUG, " ... connect!\n"); GMP_connect (peer); @@ -858,49 +749,101 @@ search_handler (void *cls, struct MeshPeerPath *path) /** - * Core callback to write a queued packet to core buffer - * - * @param cls Closure (peer info). - * @param size Number of bytes available in buf. - * @param buf Where the to write the message. + * Free a transmission that was already queued with all resources + * associated to the request. * - * @return number of bytes written to buf + * @param queue Queue handler to cancel. + * @param clear_cls Is it necessary to free associated cls? */ -static size_t -queue_send (void *cls, size_t size, void *buf) +static void +queue_destroy (struct MeshPeerQueue *queue, int clear_cls) { - struct MeshPeer *peer = cls; - struct MeshFlowControl *fc; - struct MeshConnection *c; - struct GNUNET_MessageHeader *msg; - struct MeshPeerQueue *queue; - struct MeshTunnel2 *t; - struct MeshChannel *ch; - const struct GNUNET_PeerIdentity *dst_id; - size_t data_size; - uint32_t pid; - uint16_t type; - int fwd; - - peer->core_transmit = NULL; - LOG (GNUNET_ERROR_TYPE_DEBUG, "* Queue send (max %u)\n", size); + struct MeshPeer *peer; - if (NULL == buf || 0 == size) - { - LOG (GNUNET_ERROR_TYPE_DEBUG, "* Buffer size 0.\n"); - return 0; - } + peer = queue->peer; + GNUNET_assert (NULL != queue->c); - /* Initialize */ - queue = peer_get_first_message (peer); - if (NULL == queue) + if (GNUNET_YES == clear_cls) { - GNUNET_break (0); /* Core tmt_rdy should've been canceled */ - return 0; + LOG (GNUNET_ERROR_TYPE_DEBUG, "# queue destroy type %s\n", + GNUNET_MESH_DEBUG_M2S (queue->type)); + switch (queue->type) + { + case GNUNET_MESSAGE_TYPE_MESH_CONNECTION_DESTROY: + case GNUNET_MESSAGE_TYPE_MESH_TUNNEL_DESTROY: + LOG (GNUNET_ERROR_TYPE_INFO, "destroying a DESTROY message\n"); + /* fall through */ + case GNUNET_MESSAGE_TYPE_MESH_ENCRYPTED: + case GNUNET_MESSAGE_TYPE_MESH_ACK: + case GNUNET_MESSAGE_TYPE_MESH_POLL: + case GNUNET_MESSAGE_TYPE_MESH_CONNECTION_ACK: + case GNUNET_MESSAGE_TYPE_MESH_CONNECTION_CREATE: + case GNUNET_MESSAGE_TYPE_MESH_CONNECTION_BROKEN: + LOG (GNUNET_ERROR_TYPE_DEBUG, "# prebuilt message\n");; + GNUNET_free_non_null (queue->cls); + break; + + default: + GNUNET_break (0); + LOG (GNUNET_ERROR_TYPE_ERROR, "# type %s unknown!\n", + GNUNET_MESH_DEBUG_M2S (queue->type)); + } + } + GNUNET_CONTAINER_DLL_remove (peer->queue_head, peer->queue_tail, queue); + + if (queue->type != GNUNET_MESSAGE_TYPE_MESH_ACK && + queue->type != GNUNET_MESSAGE_TYPE_MESH_POLL) + { + peer->queue_n--; + } + + if (NULL != queue->callback) + { + LOG (GNUNET_ERROR_TYPE_DEBUG, "# Calling callback\n"); + queue->callback (queue->callback_cls, + queue->c, queue->type, + queue->fwd, queue->size, + GNUNET_TIME_absolute_get_duration (queue->start_waiting)); + } + + GNUNET_free (queue); +} + +/** + * Core callback to write a queued packet to core buffer + * + * @param cls Closure (peer info). + * @param size Number of bytes available in buf. + * @param buf Where the to write the message. + * + * @return number of bytes written to buf + */ +static size_t +queue_send (void *cls, size_t size, void *buf) +{ + struct MeshPeer *peer = cls; + struct MeshConnection *c; + struct MeshPeerQueue *queue; + const struct GNUNET_PeerIdentity *dst_id; + size_t data_size; + + peer->core_transmit = NULL; + LOG (GNUNET_ERROR_TYPE_DEBUG, "* Queue send (max %u)\n", size); + + if (NULL == buf || 0 == size) + { + LOG (GNUNET_ERROR_TYPE_DEBUG, "* Buffer size 0.\n"); + return 0; + } + + /* Initialize */ + queue = peer_get_first_message (peer); + if (NULL == queue) + { + GNUNET_break (0); /* Core tmt_rdy should've been canceled */ + return 0; } c = queue->c; - fwd = queue->fwd; - fc = fwd ? &c->fwd_fc : &c->bck_fc; dst_id = GNUNET_PEER_resolve2 (peer->id); LOG (GNUNET_ERROR_TYPE_DEBUG, "* towards %s\n", GNUNET_i2s (dst_id)); @@ -921,25 +864,19 @@ queue_send (void *cls, size_t size, void *buf) } LOG (GNUNET_ERROR_TYPE_DEBUG, "* size %u ok\n", queue->size); - t = (NULL != c) ? c->t : NULL; - type = 0; - /* Fill buf */ switch (queue->type) { case GNUNET_MESSAGE_TYPE_MESH_TUNNEL_DESTROY: case GNUNET_MESSAGE_TYPE_MESH_CONNECTION_DESTROY: case GNUNET_MESSAGE_TYPE_MESH_CONNECTION_BROKEN: - case GNUNET_MESSAGE_TYPE_MESH_FWD: - case GNUNET_MESSAGE_TYPE_MESH_BCK: + case GNUNET_MESSAGE_TYPE_MESH_ENCRYPTED: case GNUNET_MESSAGE_TYPE_MESH_ACK: case GNUNET_MESSAGE_TYPE_MESH_POLL: LOG (GNUNET_ERROR_TYPE_DEBUG, "* raw: %s\n", GNUNET_MESH_DEBUG_M2S (queue->type)); data_size = send_core_data_raw (queue->cls, size, buf); - msg = (struct GNUNET_MessageHeader *) buf; - type = ntohs (msg->type); break; case GNUNET_MESSAGE_TYPE_MESH_CONNECTION_CREATE: LOG (GNUNET_ERROR_TYPE_DEBUG, "* path create\n"); @@ -971,7 +908,7 @@ queue_send (void *cls, size_t size, void *buf) } if (0 < drop_percent && - GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, 101) < drop_percent) + GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 101) < drop_percent) { LOG (GNUNET_ERROR_TYPE_WARNING, "Dropping message of type %s\n", @@ -980,29 +917,15 @@ queue_send (void *cls, size_t size, void *buf) } /* Free queue, but cls was freed by send_core_* */ - ch = queue->ch; queue_destroy (queue, GNUNET_NO); - /* Send ACK if needed, after accounting for sent ID in fc->queue_n */ - switch (type) - { - case GNUNET_MESSAGE_TYPE_MESH_FWD: - case GNUNET_MESSAGE_TYPE_MESH_BCK: - pid = ntohl ( ((struct GNUNET_MESH_Encrypted *) buf)->pid ); - LOG (GNUNET_ERROR_TYPE_DEBUG, "* accounting pid %u\n", pid); - fc->last_pid_sent = pid; - send_ack (c, ch, fwd); - break; - default: - break; - } - /* If more data in queue, send next */ queue = peer_get_first_message (peer); if (NULL != queue) { LOG (GNUNET_ERROR_TYPE_DEBUG, "* more data!\n"); - if (NULL == peer->core_transmit) { + if (NULL == peer->core_transmit) + { peer->core_transmit = GNUNET_CORE_notify_transmit_ready(core_handle, 0, @@ -1012,174 +935,33 @@ queue_send (void *cls, size_t size, void *buf) queue->size, &queue_send, peer); + queue->start_waiting = GNUNET_TIME_absolute_get (); } else { LOG (GNUNET_ERROR_TYPE_DEBUG, "* tmt rdy called somewhere else\n"); } - if (GNUNET_SCHEDULER_NO_TASK == fc->poll_task) - { - LOG (GNUNET_ERROR_TYPE_DEBUG, "* starting poll timeout\n"); - fc->poll_task = - GNUNET_SCHEDULER_add_delayed (fc->poll_time, &connection_poll, fc); - } +// GMC_start_poll (); FIXME needed? } else { - if (GNUNET_SCHEDULER_NO_TASK != fc->poll_task) - { - GNUNET_SCHEDULER_cancel (fc->poll_task); - fc->poll_task = GNUNET_SCHEDULER_NO_TASK; - } - } - if (NULL != c) - { - c->pending_messages--; - if (GNUNET_YES == c->destroy && 0 == c->pending_messages) - { - LOG (GNUNET_ERROR_TYPE_DEBUG, "* destroying connection!\n"); - GMC_destroy (c); - } +// GMC_stop_poll(); FIXME needed? } - if (NULL != t) - { - t->pending_messages--; - if (GNUNET_YES == t->destroy && 0 == t->pending_messages) - { -// LOG (GNUNET_ERROR_TYPE_DEBUG, "* destroying tunnel!\n"); - tunnel_destroy (t); - } - } LOG (GNUNET_ERROR_TYPE_DEBUG, "* Return %d\n", data_size); return data_size; } - -/** - * Get first sendable message. - * - * @param peer The destination peer. - * - * @return Best current known path towards the peer, if any. - */ -static struct MeshPeerQueue * -peer_get_first_message (const struct MeshPeer *peer) -{ - struct MeshPeerQueue *q; - - for (q = peer->queue_head; NULL != q; q = q->next) - { - if (queue_is_sendable (q)) - return q; - } - - return NULL; -} - - -static int -queue_is_sendable (struct MeshPeerQueue *q) -{ - struct MeshFlowControl *fc; - - /* Is PID-independent? */ - switch (q->type) - { - case GNUNET_MESSAGE_TYPE_MESH_ACK: - case GNUNET_MESSAGE_TYPE_MESH_POLL: - return GNUNET_YES; - } - - /* Is PID allowed? */ - fc = q->fwd ? &q->c->fwd_fc : &q->c->bck_fc; - if (GMC_is_pid_bigger (fc->last_ack_recv, fc->last_pid_sent)) - return GNUNET_YES; - - return GNUNET_NO; -} - - /******************************************************************************/ /******************************** API ***********************************/ /******************************************************************************/ - -/** - * 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? - */ -void -GMP_queue_destroy (struct MeshPeerQueue *queue, int clear_cls) -{ - struct MeshPeer *peer; - struct MeshFlowControl *fc; - int fwd; - - fwd = queue->fwd; - peer = queue->peer; - GNUNET_assert (NULL != queue->c); - fc = fwd ? &queue->c->fwd_fc : &queue->c->bck_fc; - - if (GNUNET_YES == clear_cls) - { - LOG (GNUNET_ERROR_TYPE_DEBUG, " queue destroy type %s\n", - GNUNET_MESH_DEBUG_M2S (queue->type)); - switch (queue->type) - { - case GNUNET_MESSAGE_TYPE_MESH_CONNECTION_DESTROY: - case GNUNET_MESSAGE_TYPE_MESH_TUNNEL_DESTROY: - LOG (GNUNET_ERROR_TYPE_INFO, "destroying a DESTROY message\n"); - GNUNET_break (GNUNET_YES == queue->c->destroy); - /* fall through */ - case GNUNET_MESSAGE_TYPE_MESH_FWD: - case GNUNET_MESSAGE_TYPE_MESH_BCK: - case GNUNET_MESSAGE_TYPE_MESH_ACK: - case GNUNET_MESSAGE_TYPE_MESH_POLL: - case GNUNET_MESSAGE_TYPE_MESH_CONNECTION_ACK: - case GNUNET_MESSAGE_TYPE_MESH_CONNECTION_CREATE: - case GNUNET_MESSAGE_TYPE_MESH_CONNECTION_BROKEN: - LOG (GNUNET_ERROR_TYPE_DEBUG, " prebuilt message\n");; - GNUNET_free_non_null (queue->cls); - break; - - default: - GNUNET_break (0); - LOG (GNUNET_ERROR_TYPE_ERROR, " type %s unknown!\n", - GNUNET_MESH_DEBUG_M2S (queue->type)); - } - - } - GNUNET_CONTAINER_DLL_remove (peer->queue_head, peer->queue_tail, queue); - - if (queue->type != GNUNET_MESSAGE_TYPE_MESH_ACK && - queue->type != GNUNET_MESSAGE_TYPE_MESH_POLL) - { - LOG (GNUNET_ERROR_TYPE_DEBUG, " Q_N- %p %u\n", fc, fc->queue_n); - fc->queue_n--; - peer->queue_n--; - } - if (NULL != queue->c) - { - queue->c->pending_messages--; - if (NULL != queue->c->t) - { - queue->c->t->pending_messages--; - } - } - - GNUNET_free (queue); -} - - /** * @brief Queue and pass message to core when possible. * + * @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. @@ -1187,16 +969,15 @@ GMP_queue_destroy (struct MeshPeerQueue *queue, int clear_cls) * @param c Connection this message belongs to (cannot be NULL). * @param ch Channel this message belongs to, if applicable (otherwise 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_cls Closure for @c cont. */ void -GMP_queue_add (void *cls, uint16_t type, size_t size, - struct MeshConnection *c, - struct MeshChannel *ch, - int fwd) +GMP_queue_add (struct MeshPeer *peer, void *cls, uint16_t type, size_t size, + struct MeshConnection *c, struct MeshChannel *ch, int fwd, + GMP_sent cont, void *cont_cls) { struct MeshPeerQueue *queue; - struct MeshFlowControl *fc; - struct MeshPeer *peer; int priority; int call_core; @@ -1205,15 +986,6 @@ GMP_queue_add (void *cls, uint16_t type, size_t size, fwd ? "FWD" : "BCK", GNUNET_MESH_DEBUG_M2S (type), size, c, ch); GNUNET_assert (NULL != c); - fc = fwd ? &c->fwd_fc : &c->bck_fc; - peer = fwd ? connection_get_next_hop (c) : connection_get_prev_hop (c); - - if (NULL == fc) - { - GNUNET_break (0); - return; - } - if (NULL == peer->connections) { /* We are not connected to this peer, ignore request. */ @@ -1230,36 +1002,8 @@ GMP_queue_add (void *cls, uint16_t type, size_t size, } LOG (GNUNET_ERROR_TYPE_DEBUG, "priority %d\n", priority); - LOG (GNUNET_ERROR_TYPE_DEBUG, "fc %p\n", fc); - if (fc->queue_n >= fc->queue_max && 0 == priority) - { - GNUNET_STATISTICS_update (stats, "# messages dropped (buffer full)", - 1, GNUNET_NO); - GNUNET_break (0); - LOG (GNUNET_ERROR_TYPE_DEBUG, - "queue full: %u/%u\n", - fc->queue_n, fc->queue_max); - return; /* Drop this message */ - } - LOG (GNUNET_ERROR_TYPE_DEBUG, "last pid %u\n", fc->last_pid_sent); - LOG (GNUNET_ERROR_TYPE_DEBUG, " ack %u\n", fc->last_ack_recv); - if (GMC_is_pid_bigger (fc->last_pid_sent + 1, fc->last_ack_recv)) - { - call_core = GNUNET_NO; - if (GNUNET_SCHEDULER_NO_TASK == fc->poll_task && - GNUNET_MESSAGE_TYPE_MESH_POLL != type) - { - LOG (GNUNET_ERROR_TYPE_DEBUG, - "no buffer space (%u > %u): starting poll\n", - fc->last_pid_sent + 1, fc->last_ack_recv); - fc->poll_task = GNUNET_SCHEDULER_add_delayed (fc->poll_time, - &connection_poll, - fc); - } - } - else - call_core = GNUNET_YES; + call_core = GMC_is_sendable (c, fwd); queue = GNUNET_malloc (sizeof (struct MeshPeerQueue)); queue->cls = cls; queue->type = type; @@ -1268,6 +1012,8 @@ GMP_queue_add (void *cls, uint16_t type, size_t size, queue->c = c; queue->ch = ch; queue->fwd = fwd; + queue->callback = cont; + queue->callback_cls = cont_cls; if (100 <= priority) { struct MeshPeerQueue *copy; @@ -1287,8 +1033,6 @@ GMP_queue_add (void *cls, uint16_t type, size_t size, else { GNUNET_CONTAINER_DLL_insert_tail (peer->queue_head, peer->queue_tail, queue); - LOG (GNUNET_ERROR_TYPE_DEBUG, " Q_N+ %p %u\n", fc, fc->queue_n); - fc->queue_n++; peer->queue_n++; } @@ -1296,7 +1040,7 @@ GMP_queue_add (void *cls, uint16_t type, size_t size, { LOG (GNUNET_ERROR_TYPE_DEBUG, "calling core tmt rdy towards %s for %u bytes\n", - peer2s (peer), size); + GMP_2s (peer), size); peer->core_transmit = GNUNET_CORE_notify_transmit_ready (core_handle, 0, @@ -1306,20 +1050,107 @@ GMP_queue_add (void *cls, uint16_t type, size_t size, size, &queue_send, peer); + queue->start_waiting = GNUNET_TIME_absolute_get (); } else { LOG (GNUNET_ERROR_TYPE_DEBUG, "core tmt rdy towards %s already called\n", - peer2s (peer)); + GMP_2s (peer)); } - c->pending_messages++; - if (NULL != c->t) - c->t->pending_messages++; } +/** + * Cancel all queued messages to a peer that belong to a certain connection. + * + * @param peer Peer towards whom to cancel. + * @param c Connection whose queued messages to cancel. + */ +void +GMP_queue_cancel (struct MeshPeer *peer, struct MeshConnection *c) +{ + struct MeshPeerQueue *q; + struct MeshPeerQueue *next; + + for (q = peer->queue_head; NULL != q; q = next) + { + next = q->next; + if (q->c == c) + { + LOG (GNUNET_ERROR_TYPE_DEBUG, + "connection_cancel_queue %s\n", + GNUNET_MESH_DEBUG_M2S (q->type)); + queue_destroy (q, GNUNET_YES); + } + } + if (NULL == peer->queue_head) + { + if (NULL != peer->core_transmit) + { + GNUNET_CORE_notify_transmit_ready_cancel (peer->core_transmit); + peer->core_transmit = NULL; + } + } +} + + +/** + * Get the first transmittable message for a connection. + * + * @param peer Neighboring peer. + * @param c Connection. + * + * @return First transmittable message. + */ +static struct MeshPeerQueue * +connection_get_first_message (struct MeshPeer *peer, struct MeshConnection *c) +{ + struct MeshPeerQueue *q; + + for (q = peer->queue_head; NULL != q; q = q->next) + { + if (q->c != c) + continue; + if (queue_is_sendable (q)) + return q; + } + + return NULL; +} + +void +GMP_queue_unlock (struct MeshPeer *peer, struct MeshConnection *c) +{ + struct MeshPeerQueue *q; + size_t size; + + if (NULL != peer->core_transmit) + { + LOG (GNUNET_ERROR_TYPE_DEBUG, " already unlocked!\n"); + return; /* Already unlocked */ + } + + q = connection_get_first_message (peer, c); + if (NULL == q) + { + LOG (GNUNET_ERROR_TYPE_DEBUG, " queue empty!\n"); + return; /* Nothing to transmit */ + } + + size = q->size; + peer->core_transmit = + GNUNET_CORE_notify_transmit_ready (core_handle, + GNUNET_NO, + 0, + GNUNET_TIME_UNIT_FOREVER_REL, + GNUNET_PEER_resolve2 (peer->id), + size, + &queue_send, + peer); +} + /** * Initialize the peer subsystem. @@ -1328,16 +1159,15 @@ GMP_queue_add (void *cls, uint16_t type, size_t size, * @param id Peer identity */ void -GMP_init (const struct GNUNET_CONFIGURATION_Handle *c, - const struct GNUNET_PeerIdentity *id) +GMP_init (const struct GNUNET_CONFIGURATION_Handle *c) { - my_full_id = id; + LOG (GNUNET_ERROR_TYPE_DEBUG, "init\n"); peers = GNUNET_CONTAINER_multipeermap_create (128, GNUNET_NO); if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (c, "MESH", "MAX_PEERS", &max_peers)) { - LOG_config_invalid (GNUNET_ERROR_TYPE_WARNING, + GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_WARNING, "MESH", "MAX_PEERS", "USING DEFAULT"); max_peers = 1000; } @@ -1389,27 +1219,73 @@ GMP_shutdown (void) GNUNET_CORE_disconnect (core_handle); core_handle = NULL; } + GNUNET_PEER_change_rc (myid, -1); +} + +/** + * Retrieve the MeshPeer stucture associated with the peer, create one + * and insert it in the appropriate structures if the peer is not known yet. + * + * @param peer Full identity of the peer. + * + * @return Existing or newly created peer structure. + */ +struct MeshPeer * +GMP_get (const struct GNUNET_PeerIdentity *peer_id) +{ + struct MeshPeer *peer; + + peer = GNUNET_CONTAINER_multipeermap_get (peers, peer_id); + if (NULL == peer) + { + peer = GNUNET_new (struct MeshPeer); + if (GNUNET_CONTAINER_multipeermap_size (peers) > max_peers) + { + peer_delete_oldest (); + } + GNUNET_CONTAINER_multipeermap_put (peers, peer_id, peer, + GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST); + peer->id = GNUNET_PEER_intern (peer_id); + } + peer->last_contact = GNUNET_TIME_absolute_get(); + + return peer; } /** - * Try to establish a new connection to this peer in the given tunnel. + * Retrieve the MeshPeer stucture associated with the peer, create one + * and insert it in the appropriate structures if the peer is not known yet. + * + * @param peer Short identity of the peer. + * + * @return Existing or newly created peer structure. + */ +struct MeshPeer * +GMP_get_short (const GNUNET_PEER_Id peer) +{ + return GMP_get (GNUNET_PEER_resolve2 (peer)); +} + + +/** + * Try to establish a new connection to this peer (in its tunnel). * If the peer doesn't have any path to it yet, try to get one. * If the peer already has some path, send a CREATE CONNECTION towards it. * - * @param peer PeerInfo of the peer. + * @param peer Peer to connect to. */ void GMP_connect (struct MeshPeer *peer) { - struct MeshTunnel2 *t; + struct MeshTunnel3 *t; struct MeshPeerPath *p; struct MeshConnection *c; int rerun_search; LOG (GNUNET_ERROR_TYPE_DEBUG, "peer_connect towards %s\n", - peer2s (peer)); + GMP_2s (peer)); t = peer->tunnel; c = NULL; rerun_search = GNUNET_NO; @@ -1421,7 +1297,7 @@ GMP_connect (struct MeshPeer *peer) if (NULL != p) { LOG (GNUNET_ERROR_TYPE_DEBUG, " %u hops\n", p->length); - c = tunnel_use_path (t, p); + c = GMT_use_path (t, p); if (NULL == c) { /* This case can happen when the path includes a first hop that is @@ -1441,7 +1317,7 @@ GMP_connect (struct MeshPeer *peer) } else { - send_connection_create (c); + GMC_send_create (c); return; } } @@ -1451,8 +1327,9 @@ GMP_connect (struct MeshPeer *peer) { GMD_search_stop (peer->search_h); peer->search_h = NULL; - LOG (GNUNET_ERROR_TYPE_DEBUG, - " Stopping DHT GET for peer %s\n", peer2s (peer)); + LOG (GNUNET_ERROR_TYPE_DEBUG, + " Stopping DHT GET for peer %s\n", + GMP_2s (peer)); } if (NULL == peer->search_h) @@ -1461,10 +1338,10 @@ GMP_connect (struct MeshPeer *peer) id = GNUNET_PEER_resolve2 (peer->id); LOG (GNUNET_ERROR_TYPE_DEBUG, - " Starting DHT GET for peer %s\n", peer2s (peer)); + " Starting DHT GET for peer %s\n", GMP_2s (peer)); peer->search_h = GMD_search (id, &search_handler, peer); - if (MESH_TUNNEL_NEW == t->state) - GMT_change_state (t, MESH_TUNNEL_SEARCHING); + if (MESH_TUNNEL3_NEW == GMT_get_state (t)) + GMT_change_state (t, MESH_TUNNEL3_SEARCHING); } } @@ -1476,7 +1353,7 @@ GMP_connect (struct MeshPeer *peer) * @param t Tunnel. */ void -GMP_set_tunnel (struct MeshPeer *peer, struct MeshTunnel2 *t) +GMP_set_tunnel (struct MeshPeer *peer, struct MeshTunnel3 *t) { peer->tunnel = t; } @@ -1508,6 +1385,23 @@ GMP_is_neighbor (const struct MeshPeer *peer) } +/** + * Create and initialize a new tunnel towards a peer, in case it has none. + * In case the peer already has a tunnel, nothing is done. + * + * Does not generate any traffic, just creates the local data structures. + * + * @param peer Peer towards which to create the tunnel. + */ +void +GMP_add_tunnel (struct MeshPeer *peer) +{ + if (NULL != peer->tunnel) + return; + peer->tunnel = GMT_new (peer); +} + + /** * Add a connection to a neighboring peer. * @@ -1522,7 +1416,7 @@ GMP_is_neighbor (const struct MeshPeer *peer) */ int GMP_add_connection (struct MeshPeer *peer, - const struct MeshConnection *c) + struct MeshConnection *c) { if (NULL == peer->connections) { @@ -1535,6 +1429,245 @@ GMP_add_connection (struct MeshPeer *peer, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST); } + +/** + * Add the path to the peer and update the path used to reach it in case this + * is the shortest. + * + * @param peer_info Destination peer to add the path to. + * @param path New path to add. Last peer must be the peer in arg 1. + * Path will be either used of freed if already known. + * @param trusted Do we trust that this path is real? + */ +void +GMP_add_path (struct MeshPeer *peer_info, struct MeshPeerPath *path, + int trusted) +{ + struct MeshPeerPath *aux; + unsigned int l; + unsigned int l2; + + if ((NULL == peer_info) || (NULL == path)) + { + GNUNET_break (0); + path_destroy (path); + return; + } + if (path->peers[path->length - 1] != peer_info->id) + { + GNUNET_break (0); + path_destroy (path); + return; + } + if (2 >= path->length && GNUNET_NO == trusted) + { + /* Only allow CORE to tell us about direct paths */ + path_destroy (path); + return; + } + for (l = 1; l < path->length; l++) + { + if (path->peers[l] == myid) + { + LOG (GNUNET_ERROR_TYPE_DEBUG, "shortening path by %u\n", l); + for (l2 = 0; l2 < path->length - l; l2++) + { + path->peers[l2] = path->peers[l + l2]; + } + path->length -= l; + l = 1; + path->peers = + GNUNET_realloc (path->peers, path->length * sizeof (GNUNET_PEER_Id)); + } + } + + LOG (GNUNET_ERROR_TYPE_DEBUG, "adding path [%u] to peer %s\n", + path->length, GMP_2s (peer_info)); + + l = path_get_length (path); + if (0 == l) + { + path_destroy (path); + return; + } + + GNUNET_assert (peer_info->id == path->peers[path->length - 1]); + for (aux = peer_info->path_head; aux != NULL; aux = aux->next) + { + l2 = path_get_length (aux); + if (l2 > l) + { + GNUNET_CONTAINER_DLL_insert_before (peer_info->path_head, + peer_info->path_tail, aux, path); + return; + } + else + { + if (l2 == l && memcmp (path->peers, aux->peers, l) == 0) + { + path_destroy (path); + return; + } + } + } + GNUNET_CONTAINER_DLL_insert_tail (peer_info->path_head, peer_info->path_tail, + path); + return; +} + + +/** + * Add the path to the origin peer and update the path used to reach it in case + * this is the shortest. + * The path is given in peer_info -> destination, therefore we turn the path + * upside down first. + * + * @param peer_info Peer to add the path to, being the origin of the path. + * @param path New path to add after being inversed. + * Path will be either used or freed. + * @param trusted Do we trust that this path is real? + */ +void +GMP_add_path_to_origin (struct MeshPeer *peer, + struct MeshPeerPath *path, + int trusted) +{ + if (NULL == path) + return; + path_invert (path); + GMP_add_path (peer, path, trusted); +} + + +/** + * Adds a path to the info of all the peers in the path + * + * @param p Path to process. + * @param confirmed Whether we know if the path works or not. + */ +void +GMP_add_path_to_all (const struct MeshPeerPath *p, int confirmed) +{ + unsigned int i; + + /* TODO: invert and add */ + for (i = 0; i < p->length && p->peers[i] != myid; i++) /* skip'em */ ; + for (i++; i < p->length; i++) + { + struct MeshPeer *aux; + struct MeshPeerPath *copy; + + aux = GMP_get_short (p->peers[i]); + copy = path_duplicate (p); + copy->length = i + 1; + GMP_add_path (aux, copy, p->length < 3 ? GNUNET_NO : confirmed); + } +} + + +/** + * 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 MeshPeer *peer, + const struct MeshConnection *c) +{ + if (NULL == peer || NULL == peer->connections) + { + GNUNET_break (0); + return GNUNET_SYSERR; + } + return GNUNET_CONTAINER_multihashmap_remove (peer->connections, + GMC_get_id (c), + c); +} + +/** + * Start the DHT search for new paths towards the peer: we don't have + * enough good connections. + * + * @param peer Destination peer. + */ +void +GMP_start_search (struct MeshPeer *peer) +{ + if (NULL != peer->search_h) + { + GNUNET_break (0); + return; + } + + peer->search_h = GMD_search (GMP_get_id (peer), &search_handler, peer); +} + + +/** + * Stop the DHT search for new paths towards the peer: we already have + * enough good connections. + * + * @param peer Destination peer. + */ +void +GMP_stop_search (struct MeshPeer *peer) +{ + if (NULL == peer->search_h) + { + GNUNET_break (0); + return; + } + + GMD_search_stop (peer->search_h); + peer->search_h = NULL; +} + + +/** + * Get the Full ID of a peer. + * + * @param peer Peer to get from. + * + * @return Full ID of peer. + */ +const struct GNUNET_PeerIdentity * +GMP_get_id (const struct MeshPeer *peer) +{ + return GNUNET_PEER_resolve2 (peer->id); +} + + +/** + * Get the Short ID of a peer. + * + * @param peer Peer to get from. + * + * @return Short ID of peer. + */ +GNUNET_PEER_Id +GMP_get_short_id (const struct MeshPeer *peer) +{ + return peer->id; +} + + +/** + * Get the tunnel towards a peer. + * + * @param peer Peer to get from. + * + * @return Tunnel towards peer. + */ +struct MeshTunnel3 * +GMP_get_tunnel (const struct MeshPeer *peer) +{ + return peer->tunnel; +} + + /** * Get the static string for a peer ID. *