From b2fadf8c7db18c02814526bf02b3cd05d4389c67 Mon Sep 17 00:00:00 2001 From: Bart Polot Date: Tue, 8 Oct 2013 11:08:09 +0000 Subject: [PATCH] - export core handlers from connection: all p2p messages are connection related but core is connected to peers --- src/mesh/gnunet-service-mesh_connection.c | 83 +++++-------- src/mesh/gnunet-service-mesh_connection.h | 131 ++++++++++++++++++++ src/mesh/gnunet-service-mesh_peer.c | 142 +++++++++++++--------- 3 files changed, 242 insertions(+), 114 deletions(-) diff --git a/src/mesh/gnunet-service-mesh_connection.c b/src/mesh/gnunet-service-mesh_connection.c index 31e11879e..843acf09e 100644 --- a/src/mesh/gnunet-service-mesh_connection.c +++ b/src/mesh/gnunet-service-mesh_connection.c @@ -1001,9 +1001,9 @@ connection_reset_timeout (struct MeshConnection *c, int fwd) * @return GNUNET_OK to keep the connection open, * GNUNET_SYSERR to close it (signal serious error) */ -static int -handle_create (void *cls, const struct GNUNET_PeerIdentity *peer, - const struct GNUNET_MessageHeader *message) +int +GMC_handle_create (void *cls, const struct GNUNET_PeerIdentity *peer, + const struct GNUNET_MessageHeader *message) { struct GNUNET_MESH_ConnectionCreate *msg; struct GNUNET_PeerIdentity *id; @@ -1140,9 +1140,9 @@ handle_create (void *cls, const struct GNUNET_PeerIdentity *peer, * @return GNUNET_OK to keep the connection open, * GNUNET_SYSERR to close it (signal serious error) */ -static int -handle_confirm (void *cls, const struct GNUNET_PeerIdentity *peer, - const struct GNUNET_MessageHeader *message) +int +GMC_handle_confirm (void *cls, const struct GNUNET_PeerIdentity *peer, + const struct GNUNET_MessageHeader *message) { struct GNUNET_MESH_ConnectionACK *msg; struct MeshConnection *c; @@ -1243,9 +1243,9 @@ handle_confirm (void *cls, const struct GNUNET_PeerIdentity *peer, * @return GNUNET_OK to keep the connection open, * GNUNET_SYSERR to close it (signal serious error) */ -static int -handle_broken (void *cls, const struct GNUNET_PeerIdentity *peer, - const struct GNUNET_MessageHeader *message) +int +GMC_handle_broken (void *cls, const struct GNUNET_PeerIdentity *peer, + const struct GNUNET_MessageHeader *message) { struct GNUNET_MESH_ConnectionBroken *msg; struct MeshConnection *c; @@ -1280,9 +1280,9 @@ handle_broken (void *cls, const struct GNUNET_PeerIdentity *peer, * @return GNUNET_OK to keep the connection open, * GNUNET_SYSERR to close it (signal serious error) */ -static int -handle_destroy (void *cls, const struct GNUNET_PeerIdentity *peer, - const struct GNUNET_MessageHeader *message) +int +GMC_handle_destroy (void *cls, const struct GNUNET_PeerIdentity *peer, + const struct GNUNET_MessageHeader *message) { struct GNUNET_MESH_ConnectionDestroy *msg; struct MeshConnection *c; @@ -1457,9 +1457,9 @@ handle_mesh_encrypted (const struct GNUNET_PeerIdentity *peer, * @return GNUNET_OK to keep the connection open, * GNUNET_SYSERR to close it (signal serious error) */ -static int -handle_fwd (void *cls, const struct GNUNET_PeerIdentity *peer, - const struct GNUNET_MessageHeader *message) +int +GMC_handle_fwd (void *cls, const struct GNUNET_PeerIdentity *peer, + const struct GNUNET_MessageHeader *message) { return handle_mesh_encrypted (peer, (struct GNUNET_MESH_Encrypted *)message, @@ -1476,9 +1476,9 @@ handle_fwd (void *cls, const struct GNUNET_PeerIdentity *peer, * @return GNUNET_OK to keep the connection open, * GNUNET_SYSERR to close it (signal serious error) */ -static int -handle_bck (void *cls, const struct GNUNET_PeerIdentity *peer, - const struct GNUNET_MessageHeader *message) +int +GMC_handle_bck (void *cls, const struct GNUNET_PeerIdentity *peer, + const struct GNUNET_MessageHeader *message) { return handle_mesh_encrypted (peer, (struct GNUNET_MESH_Encrypted *)message, @@ -1496,9 +1496,9 @@ handle_bck (void *cls, const struct GNUNET_PeerIdentity *peer, * @return GNUNET_OK to keep the connection open, * GNUNET_SYSERR to close it (signal serious error) */ -static int -handle_ack (void *cls, const struct GNUNET_PeerIdentity *peer, - const struct GNUNET_MessageHeader *message) +int +GMC_handle_ack (void *cls, const struct GNUNET_PeerIdentity *peer, + const struct GNUNET_MessageHeader *message) { struct GNUNET_MESH_ACK *msg; struct MeshConnection *c; @@ -1573,9 +1573,9 @@ handle_ack (void *cls, const struct GNUNET_PeerIdentity *peer, * @return GNUNET_OK to keep the connection open, * GNUNET_SYSERR to close it (signal serious error) */ -static int -handle_poll (void *cls, const struct GNUNET_PeerIdentity *peer, - const struct GNUNET_MessageHeader *message) +int +GMC_handle_poll (void *cls, const struct GNUNET_PeerIdentity *peer, + const struct GNUNET_MessageHeader *message) { struct GNUNET_MESH_Poll *msg; struct MeshConnection *c; @@ -1644,9 +1644,9 @@ handle_poll (void *cls, const struct GNUNET_PeerIdentity *peer, * * TODO: Check who we got this from, to validate route. */ -static int -handle_keepalive (void *cls, const struct GNUNET_PeerIdentity *peer, - const struct GNUNET_MessageHeader *message) +int +GMC_handle_keepalive (void *cls, const struct GNUNET_PeerIdentity *peer, + const struct GNUNET_MessageHeader *message) { struct GNUNET_MESH_ConnectionKeepAlive *msg; struct MeshConnection *c; @@ -1689,33 +1689,6 @@ handle_keepalive (void *cls, const struct GNUNET_PeerIdentity *peer, } -/** - * Functions to handle messages from core - */ -static struct GNUNET_CORE_MessageHandler core_handlers[] = { - {&handle_create, GNUNET_MESSAGE_TYPE_MESH_CONNECTION_CREATE, - 0}, - {&handle_confirm, GNUNET_MESSAGE_TYPE_MESH_CONNECTION_ACK, - sizeof (struct GNUNET_MESH_ConnectionACK)}, - {&handle_broken, GNUNET_MESSAGE_TYPE_MESH_CONNECTION_BROKEN, - sizeof (struct GNUNET_MESH_ConnectionBroken)}, - {&handle_destroy, GNUNET_MESSAGE_TYPE_MESH_CONNECTION_DESTROY, - sizeof (struct GNUNET_MESH_ConnectionDestroy)}, - {&handle_keepalive, GNUNET_MESSAGE_TYPE_MESH_FWD_KEEPALIVE, - sizeof (struct GNUNET_MESH_ConnectionKeepAlive)}, - {&handle_keepalive, GNUNET_MESSAGE_TYPE_MESH_BCK_KEEPALIVE, - sizeof (struct GNUNET_MESH_ConnectionKeepAlive)}, - {&handle_ack, GNUNET_MESSAGE_TYPE_MESH_ACK, - sizeof (struct GNUNET_MESH_ACK)}, - {&handle_poll, GNUNET_MESSAGE_TYPE_MESH_POLL, - sizeof (struct GNUNET_MESH_Poll)}, - {&handle_fwd, GNUNET_MESSAGE_TYPE_MESH_FWD, 0}, - {&handle_bck, GNUNET_MESSAGE_TYPE_MESH_BCK, 0}, - {NULL, 0, 0} -}; - - - /** * Send an ACK on the appropriate connection/channel, depending on * the direction and the position of the peer. @@ -1979,7 +1952,7 @@ GMC_count (const struct MeshConnection *head) * @param fwd Is this a fwd message? */ void -GMC_send_prebuilt_message (const struct GNUNET_MessageHeader *message, +GMC_send_prebuilt_message ( const struct GNUNET_MessageHeader *message, struct MeshConnection *c, struct MeshChannel *ch, int fwd) diff --git a/src/mesh/gnunet-service-mesh_connection.h b/src/mesh/gnunet-service-mesh_connection.h index 8395010fd..f4fd83f98 100644 --- a/src/mesh/gnunet-service-mesh_connection.h +++ b/src/mesh/gnunet-service-mesh_connection.h @@ -44,6 +44,137 @@ extern "C" */ struct MeshConnection; + + + +/** + * Core handler for connection creation. + * + * @param cls Closure (unused). + * @param peer Sender (neighbor). + * @param message Message. + * + * @return GNUNET_OK to keep the connection open, + * GNUNET_SYSERR to close it (signal serious error) + */ +int +GMC_handle_create (void *cls, const struct GNUNET_PeerIdentity *peer, + const struct GNUNET_MessageHeader *message); + +/** + * Core handler for path confirmations. + * + * @param cls closure + * @param message message + * @param peer peer identity this notification is about + * + * @return GNUNET_OK to keep the connection open, + * GNUNET_SYSERR to close it (signal serious error) + */ +int +GMC_handle_confirm (void *cls, const struct GNUNET_PeerIdentity *peer, + const struct GNUNET_MessageHeader *message); + +/** + * Core handler for notifications of broken paths + * + * @param cls Closure (unused). + * @param peer Peer identity of sending neighbor. + * @param message Message. + * + * @return GNUNET_OK to keep the connection open, + * GNUNET_SYSERR to close it (signal serious error) + */ +int +GMC_handle_broken (void *cls, const struct GNUNET_PeerIdentity *peer, + const struct GNUNET_MessageHeader *message); + +/** + * Core handler for tunnel destruction + * + * @param cls Closure (unused). + * @param peer Peer identity of sending neighbor. + * @param message Message. + * + * @return GNUNET_OK to keep the connection open, + * GNUNET_SYSERR to close it (signal serious error) + */ +int +GMC_handle_destroy (void *cls, const struct GNUNET_PeerIdentity *peer, + const struct GNUNET_MessageHeader *message); + +/** + * Core handler for mesh network traffic going orig->dest. + * + * @param cls Closure (unused). + * @param message Message received. + * @param peer Peer who sent the message. + * + * @return GNUNET_OK to keep the connection open, + * GNUNET_SYSERR to close it (signal serious error) + */ +int +GMC_handle_fwd (void *cls, const struct GNUNET_PeerIdentity *peer, + const struct GNUNET_MessageHeader *message); + + +/** + * Core handler for mesh network traffic going dest->orig. + * + * @param cls Closure (unused). + * @param message Message received. + * @param peer Peer who sent the message. + * + * @return GNUNET_OK to keep the connection open, + * GNUNET_SYSERR to close it (signal serious error) + */ +int +GMC_handle_bck (void *cls, const struct GNUNET_PeerIdentity *peer, + const struct GNUNET_MessageHeader *message); + +/** + * Core handler for mesh network traffic point-to-point acks. + * + * @param cls closure + * @param message message + * @param peer peer identity this notification is about + * + * @return GNUNET_OK to keep the connection open, + * GNUNET_SYSERR to close it (signal serious error) + */ +int +GMC_handle_ack (void *cls, const struct GNUNET_PeerIdentity *peer, + const struct GNUNET_MessageHeader *message); + +/** + * Core handler for mesh network traffic point-to-point ack polls. + * + * @param cls closure + * @param message message + * @param peer peer identity this notification is about + * + * @return GNUNET_OK to keep the connection open, + * GNUNET_SYSERR to close it (signal serious error) + */ +int +GMC_handle_poll (void *cls, const struct GNUNET_PeerIdentity *peer, + const struct GNUNET_MessageHeader *message); + +/** + * Core handler for mesh keepalives. + * + * @param cls closure + * @param message message + * @param peer peer identity this notification is about + * @return GNUNET_OK to keep the connection open, + * GNUNET_SYSERR to close it (signal serious error) + * + * TODO: Check who we got this from, to validate route. + */ +int +GMC_handle_keepalive (void *cls, const struct GNUNET_PeerIdentity *peer, + const struct GNUNET_MessageHeader *message); + /** * Initialize the connections subsystem * diff --git a/src/mesh/gnunet-service-mesh_peer.c b/src/mesh/gnunet-service-mesh_peer.c index 0de74bb12..22887f012 100644 --- a/src/mesh/gnunet-service-mesh_peer.c +++ b/src/mesh/gnunet-service-mesh_peer.c @@ -24,6 +24,8 @@ #include "gnunet_core_service.h" +#include "mesh_protocol_enc.h" + #include "gnunet-service-mesh_peer.h" #include "gnunet-service-mesh_dht.h" #include "gnunet-service-mesh_connection.h" @@ -154,6 +156,7 @@ notify_broken (void *cls, return GNUNET_YES; } + /** * Method called whenever a given peer connects. * @@ -171,12 +174,12 @@ core_connect (void *cls, const struct GNUNET_PeerIdentity *peer) pi = peer_get (peer); if (myid == pi->id) { - DEBUG_CONN (" (self)\n"); + LOG (" (self)\n"); path = path_new (1); } else { - DEBUG_CONN (" %s\n", GNUNET_i2s (peer)); + LOG (" %s\n", GNUNET_i2s (peer)); path = path_new (2); path->peers[1] = pi->id; GNUNET_PEER_change_rc (pi->id, 1); @@ -202,7 +205,7 @@ core_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer) { struct MeshPeer *pi; - DEBUG_CONN ("Peer disconnected\n"); + LOG ("Peer disconnected\n"); pi = GNUNET_CONTAINER_multipeermap_get (peers, peer); if (NULL == pi) { @@ -220,7 +223,7 @@ core_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer) } if (myid == pi->id) { - DEBUG_CONN (" (self)\n"); + LOG (" (self)\n"); } GNUNET_STATISTICS_update (stats, "# peers", -1, GNUNET_NO); @@ -228,6 +231,31 @@ core_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer) } +/** + * Functions to handle messages from core + */ +static struct GNUNET_CORE_MessageHandler core_handlers[] = { + {&GMC_handle_create, GNUNET_MESSAGE_TYPE_MESH_CONNECTION_CREATE, + 0}, + {&GMC_handle_confirm, GNUNET_MESSAGE_TYPE_MESH_CONNECTION_ACK, + sizeof (struct GNUNET_MESH_ConnectionACK)}, + {&GMC_handle_broken, GNUNET_MESSAGE_TYPE_MESH_CONNECTION_BROKEN, + sizeof (struct GNUNET_MESH_ConnectionBroken)}, + {&GMC_handle_destroy, GNUNET_MESSAGE_TYPE_MESH_CONNECTION_DESTROY, + sizeof (struct GNUNET_MESH_ConnectionDestroy)}, + {&GMC_handle_keepalive, GNUNET_MESSAGE_TYPE_MESH_FWD_KEEPALIVE, + sizeof (struct GNUNET_MESH_ConnectionKeepAlive)}, + {&GMC_handle_keepalive, GNUNET_MESSAGE_TYPE_MESH_BCK_KEEPALIVE, + sizeof (struct GNUNET_MESH_ConnectionKeepAlive)}, + {&GMC_handle_ack, GNUNET_MESSAGE_TYPE_MESH_ACK, + 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}, + {NULL, 0, 0} +}; + /** * To be called on core init/fail. @@ -242,16 +270,12 @@ core_init (void *cls, const struct GNUNET_CONFIGURATION_Handle *c = cls; static int i = 0; - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Core init\n"); + LOG (GNUNET_ERROR_TYPE_DEBUG, "Core init\n"); if (0 != memcmp (identity, &my_full_id, sizeof (my_full_id))) { - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Wrong CORE service\n")); - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, - " core id %s\n", - GNUNET_i2s (identity)); - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, - " my id %s\n", - GNUNET_i2s (&my_full_id)); + LOG (GNUNET_ERROR_TYPE_ERROR, _("Wrong CORE service\n")); + LOG (GNUNET_ERROR_TYPE_ERROR, " core id %s\n", GNUNET_i2s (identity)); + LOG (GNUNET_ERROR_TYPE_ERROR, " my id %s\n", GNUNET_i2s (&my_full_id)); GNUNET_CORE_disconnect (core_handle); core_handle = GNUNET_CORE_connect (c, /* Main configuration */ NULL, /* Closure passed to MESH functions */ @@ -316,7 +340,7 @@ send_core_connection_create (struct MeshConnection *c, size_t size, void *buf) size_t size_needed; int i; - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending CONNECTION CREATE...\n"); + LOG (GNUNET_ERROR_TYPE_DEBUG, "Sending CONNECTION CREATE...\n"); size_needed = sizeof (struct GNUNET_MESH_ConnectionCreate) + p->length * sizeof (struct GNUNET_PeerIdentity); @@ -337,7 +361,7 @@ send_core_connection_create (struct MeshConnection *c, size_t size, void *buf) GNUNET_PEER_resolve (p->peers[i], peer_ptr++); } - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + LOG (GNUNET_ERROR_TYPE_DEBUG, "CONNECTION CREATE (%u bytes long) sent!\n", size_needed); return size_needed; } @@ -358,7 +382,7 @@ send_core_connection_ack (struct MeshConnection *c, size_t size, void *buf) struct GNUNET_MESH_ConnectionACK *msg = buf; struct MeshTunnel2 *t = c->t; - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending CONNECTION ACK...\n"); + LOG (GNUNET_ERROR_TYPE_DEBUG, "Sending CONNECTION ACK...\n"); GNUNET_assert (NULL != t); if (sizeof (struct GNUNET_MESH_ConnectionACK) > size) { @@ -372,7 +396,7 @@ send_core_connection_ack (struct MeshConnection *c, size_t size, void *buf) /* TODO add signature */ - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "CONNECTION ACK sent!\n"); + LOG (GNUNET_ERROR_TYPE_DEBUG, "CONNECTION ACK sent!\n"); return sizeof (struct GNUNET_MESH_ConnectionACK); } @@ -426,7 +450,7 @@ peer_destroy (struct MeshPeer *peer) GNUNET_CONTAINER_multipeermap_remove (peers, &id, peer)) { GNUNET_break (0); - GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + LOG (GNUNET_ERROR_TYPE_WARNING, "removing peer %s, not in peermap\n", GNUNET_i2s (&id)); } if (NULL != peer->search_h) @@ -703,7 +727,7 @@ peer_add_path (struct MeshPeer *peer_info, struct MeshPeerPath *path, { if (path->peers[l] == myid) { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "shortening path by %u\n", l); + 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]; @@ -715,7 +739,7 @@ peer_add_path (struct MeshPeer *peer_info, struct MeshPeerPath *path, } } - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "adding path [%u] to peer %s\n", + LOG (GNUNET_ERROR_TYPE_DEBUG, "adding path [%u] to peer %s\n", path->length, peer2s (peer_info)); l = path_get_length (path); @@ -823,7 +847,7 @@ search_handler (void *cls, struct MeshPeerPath *path) if (peer->tunnel->state == MESH_TUNNEL_SEARCHING) { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " ... connect!\n"); + LOG (GNUNET_ERROR_TYPE_DEBUG, " ... connect!\n"); GMP_connect (peer); } return; @@ -856,11 +880,11 @@ queue_send (void *cls, size_t size, void *buf) int fwd; peer->core_transmit = NULL; - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "* Queue send (max %u)\n", size); + LOG (GNUNET_ERROR_TYPE_DEBUG, "* Queue send (max %u)\n", size); if (NULL == buf || 0 == size) { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "* Buffer size 0.\n"); + LOG (GNUNET_ERROR_TYPE_DEBUG, "* Buffer size 0.\n"); return 0; } @@ -876,11 +900,11 @@ queue_send (void *cls, size_t size, void *buf) fc = fwd ? &c->fwd_fc : &c->bck_fc; dst_id = GNUNET_PEER_resolve2 (peer->id); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "* towards %s\n", GNUNET_i2s (dst_id)); + LOG (GNUNET_ERROR_TYPE_DEBUG, "* towards %s\n", GNUNET_i2s (dst_id)); /* Check if buffer size is enough for the message */ if (queue->size > size) { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "* not enough room, reissue\n"); + LOG (GNUNET_ERROR_TYPE_DEBUG, "* not enough room, reissue\n"); peer->core_transmit = GNUNET_CORE_notify_transmit_ready (core_handle, GNUNET_NO, @@ -892,7 +916,7 @@ queue_send (void *cls, size_t size, void *buf) peer); return 0; } - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "* size %u ok\n", queue->size); + LOG (GNUNET_ERROR_TYPE_DEBUG, "* size %u ok\n", queue->size); t = (NULL != c) ? c->t : NULL; type = 0; @@ -907,7 +931,7 @@ queue_send (void *cls, size_t size, void *buf) case GNUNET_MESSAGE_TYPE_MESH_BCK: case GNUNET_MESSAGE_TYPE_MESH_ACK: case GNUNET_MESSAGE_TYPE_MESH_POLL: - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + LOG (GNUNET_ERROR_TYPE_DEBUG, "* raw: %s\n", GNUNET_MESH_DEBUG_M2S (queue->type)); data_size = send_core_data_raw (queue->cls, size, buf); @@ -915,14 +939,14 @@ queue_send (void *cls, size_t size, void *buf) type = ntohs (msg->type); break; case GNUNET_MESSAGE_TYPE_MESH_CONNECTION_CREATE: - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "* path create\n"); + LOG (GNUNET_ERROR_TYPE_DEBUG, "* path create\n"); if (GMC_is_origin (c, GNUNET_YES)) data_size = send_core_connection_create (queue->c, size, buf); else data_size = send_core_data_raw (queue->cls, size, buf); break; case GNUNET_MESSAGE_TYPE_MESH_CONNECTION_ACK: - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "* path ack\n"); + LOG (GNUNET_ERROR_TYPE_DEBUG, "* path ack\n"); if (GMC_is_origin (c, GNUNET_NO) || GMC_is_origin (c, GNUNET_YES)) data_size = send_core_connection_ack (queue->c, size, buf); @@ -938,7 +962,7 @@ queue_send (void *cls, size_t size, void *buf) break; default: GNUNET_break (0); - GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "* type unknown: %u\n", + LOG (GNUNET_ERROR_TYPE_WARNING, "* type unknown: %u\n", queue->type); data_size = 0; } @@ -946,7 +970,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_log (GNUNET_ERROR_TYPE_WARNING, + LOG (GNUNET_ERROR_TYPE_WARNING, "Dropping message of type %s\n", GNUNET_MESH_DEBUG_M2S (queue->type)); data_size = 0; @@ -962,7 +986,7 @@ queue_send (void *cls, size_t size, void *buf) case GNUNET_MESSAGE_TYPE_MESH_FWD: case GNUNET_MESSAGE_TYPE_MESH_BCK: pid = ntohl ( ((struct GNUNET_MESH_Encrypted *) buf)->pid ); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "* accounting pid %u\n", pid); + LOG (GNUNET_ERROR_TYPE_DEBUG, "* accounting pid %u\n", pid); fc->last_pid_sent = pid; send_ack (c, ch, fwd); break; @@ -974,7 +998,7 @@ queue_send (void *cls, size_t size, void *buf) queue = peer_get_first_message (peer); if (NULL != queue) { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "* more data!\n"); + LOG (GNUNET_ERROR_TYPE_DEBUG, "* more data!\n"); if (NULL == peer->core_transmit) { peer->core_transmit = GNUNET_CORE_notify_transmit_ready(core_handle, @@ -988,12 +1012,12 @@ queue_send (void *cls, size_t size, void *buf) } else { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + LOG (GNUNET_ERROR_TYPE_DEBUG, "* tmt rdy called somewhere else\n"); } if (GNUNET_SCHEDULER_NO_TASK == fc->poll_task) { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "* starting poll timeout\n"); + LOG (GNUNET_ERROR_TYPE_DEBUG, "* starting poll timeout\n"); fc->poll_task = GNUNET_SCHEDULER_add_delayed (fc->poll_time, &connection_poll, fc); } @@ -1011,7 +1035,7 @@ queue_send (void *cls, size_t size, void *buf) c->pending_messages--; if (GNUNET_YES == c->destroy && 0 == c->pending_messages) { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "* destroying connection!\n"); + LOG (GNUNET_ERROR_TYPE_DEBUG, "* destroying connection!\n"); GMC_destroy (c); } } @@ -1021,11 +1045,11 @@ queue_send (void *cls, size_t size, void *buf) t->pending_messages--; if (GNUNET_YES == t->destroy && 0 == t->pending_messages) { -// GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "* destroying tunnel!\n"); +// LOG (GNUNET_ERROR_TYPE_DEBUG, "* destroying tunnel!\n"); tunnel_destroy (t); } } - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "* Return %d\n", data_size); + LOG (GNUNET_ERROR_TYPE_DEBUG, "* Return %d\n", data_size); return data_size; } @@ -1101,13 +1125,13 @@ GMP_queue_destroy (struct MeshPeerQueue *queue, int clear_cls) if (GNUNET_YES == clear_cls) { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " queue destroy type %s\n", + 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: - GNUNET_log (GNUNET_ERROR_TYPE_INFO, "destroying a DESTROY message\n"); + 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: @@ -1117,13 +1141,13 @@ GMP_queue_destroy (struct MeshPeerQueue *queue, int clear_cls) case GNUNET_MESSAGE_TYPE_MESH_CONNECTION_ACK: case GNUNET_MESSAGE_TYPE_MESH_CONNECTION_CREATE: case GNUNET_MESSAGE_TYPE_MESH_CONNECTION_BROKEN: - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " prebuilt message\n");; + LOG (GNUNET_ERROR_TYPE_DEBUG, " prebuilt message\n");; GNUNET_free_non_null (queue->cls); break; default: GNUNET_break (0); - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, " type %s unknown!\n", + LOG (GNUNET_ERROR_TYPE_ERROR, " type %s unknown!\n", GNUNET_MESH_DEBUG_M2S (queue->type)); } @@ -1133,7 +1157,7 @@ GMP_queue_destroy (struct MeshPeerQueue *queue, int clear_cls) if (queue->type != GNUNET_MESSAGE_TYPE_MESH_ACK && queue->type != GNUNET_MESSAGE_TYPE_MESH_POLL) { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " Q_N- %p %u\n", fc, fc->queue_n); + LOG (GNUNET_ERROR_TYPE_DEBUG, " Q_N- %p %u\n", fc, fc->queue_n); fc->queue_n--; peer->queue_n--; } @@ -1173,7 +1197,7 @@ GMP_queue_add (void *cls, uint16_t type, size_t size, int priority; int call_core; - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + LOG (GNUNET_ERROR_TYPE_DEBUG, "queue add %s %s (%u) on c %p, ch %p\n", fwd ? "FWD" : "BCK", GNUNET_MESH_DEBUG_M2S (type), size, c, ch); GNUNET_assert (NULL != c); @@ -1202,28 +1226,28 @@ GMP_queue_add (void *cls, uint16_t type, size_t size, priority = 100; } - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "priority %d\n", priority); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "fc %p\n", fc); + 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); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + LOG (GNUNET_ERROR_TYPE_DEBUG, "queue full: %u/%u\n", fc->queue_n, fc->queue_max); return; /* Drop this message */ } - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "last pid %u\n", fc->last_pid_sent); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " ack %u\n", fc->last_ack_recv); + 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) { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + 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, @@ -1260,14 +1284,14 @@ GMP_queue_add (void *cls, uint16_t type, size_t size, else { GNUNET_CONTAINER_DLL_insert_tail (peer->queue_head, peer->queue_tail, queue); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " Q_N+ %p %u\n", fc, fc->queue_n); + LOG (GNUNET_ERROR_TYPE_DEBUG, " Q_N+ %p %u\n", fc, fc->queue_n); fc->queue_n++; peer->queue_n++; } if (NULL == peer->core_transmit && GNUNET_YES == call_core) { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + LOG (GNUNET_ERROR_TYPE_DEBUG, "calling core tmt rdy towards %s for %u bytes\n", peer2s (peer), size); peer->core_transmit = @@ -1282,7 +1306,7 @@ GMP_queue_add (void *cls, uint16_t type, size_t size, } else { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + LOG (GNUNET_ERROR_TYPE_DEBUG, "core tmt rdy towards %s already called\n", peer2s (peer)); @@ -1310,7 +1334,7 @@ GMP_init (const struct GNUNET_CONFIGURATION_Handle *c, GNUNET_CONFIGURATION_get_value_number (c, "MESH", "MAX_PEERS", &max_peers)) { - GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_WARNING, + LOG_config_invalid (GNUNET_ERROR_TYPE_WARNING, "MESH", "MAX_PEERS", "USING DEFAULT"); max_peers = 1000; } @@ -1323,7 +1347,7 @@ GMP_init (const struct GNUNET_CONFIGURATION_Handle *c, } else { - GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + LOG (GNUNET_ERROR_TYPE_WARNING, "\n***************************************\n" "Mesh is running with drop mode enabled.\n" "This is NOT a good idea!\n" @@ -1374,7 +1398,7 @@ GMP_connect (struct MeshPeer *peer) struct MeshConnection *c; int rerun_search; - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + LOG (GNUNET_ERROR_TYPE_DEBUG, "peer_connect towards %s\n", peer2s (peer)); t = peer->tunnel; @@ -1383,11 +1407,11 @@ GMP_connect (struct MeshPeer *peer) if (NULL != peer->path_head) { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "path exists\n"); + LOG (GNUNET_ERROR_TYPE_DEBUG, "path exists\n"); p = peer_get_best_path (peer); if (NULL != p) { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " %u hops\n", p->length); + LOG (GNUNET_ERROR_TYPE_DEBUG, " %u hops\n", p->length); c = tunnel_use_path (t, p); if (NULL == c) { @@ -1418,7 +1442,7 @@ GMP_connect (struct MeshPeer *peer) { GMD_search_stop (peer->search_h); peer->search_h = NULL; - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + LOG (GNUNET_ERROR_TYPE_DEBUG, " Stopping DHT GET for peer %s\n", peer2s (peer)); } @@ -1427,7 +1451,7 @@ GMP_connect (struct MeshPeer *peer) const struct GNUNET_PeerIdentity *id; id = GNUNET_PEER_resolve2 (peer->id); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + LOG (GNUNET_ERROR_TYPE_DEBUG, " Starting DHT GET for peer %s\n", peer2s (peer)); peer->search_h = GMD_search (id, &search_handler, peer); if (MESH_TUNNEL_NEW == t->state) -- 2.25.1