From c13dfb403b26b07486953500103bccf9132654d6 Mon Sep 17 00:00:00 2001 From: "Nathan S. Evans" Date: Thu, 21 Jan 2010 13:48:14 +0000 Subject: still massively broken, but this stuff now compiles... transport_api.c needs work (who is going to do that?) --- src/transport/gnunet-service-transport.c | 371 +++++++++++++++++++------------ src/transport/plugin_transport.h | 13 +- src/transport/test_transport_api.c | 43 +++- 3 files changed, 273 insertions(+), 154 deletions(-) (limited to 'src/transport') diff --git a/src/transport/gnunet-service-transport.c b/src/transport/gnunet-service-transport.c index c106457d9..553ffb4d3 100644 --- a/src/transport/gnunet-service-transport.c +++ b/src/transport/gnunet-service-transport.c @@ -173,11 +173,11 @@ struct TransportPlugin int rebuild; }; -struct NeighbourList; +struct NeighborList; /** - * For each neighbour we keep a list of messages - * that we still want to transmit to the neighbour. + * For each neighbor we keep a list of messages + * that we still want to transmit to the neighbor. */ struct MessageQueue { @@ -200,9 +200,9 @@ struct MessageQueue struct TransportClient *client; /** - * Neighbour this entry belongs to. + * Neighbor this entry belongs to. */ - struct NeighbourList *neighbour; + struct NeighborList *neighbor; /** * Plugin that we used for the transmission. @@ -228,7 +228,7 @@ struct MessageQueue /** - * For a given Neighbour, which plugins are available + * For a given Neighbor, which plugins are available * to talk to this peer and what are their costs? */ struct ReadyList @@ -246,9 +246,9 @@ struct ReadyList struct TransportPlugin *plugin; /** - * Neighbour this entry belongs to. + * Neighbor this entry belongs to. */ - struct NeighbourList *neighbour; + struct NeighborList *neighbor; /** * What was the last latency observed for this plugin @@ -296,15 +296,15 @@ struct ReadyList /** - * Entry in linked list of all of our current neighbours. + * Entry in linked list of all of our current neighbors. */ -struct NeighbourList +struct NeighborList { /** * This is a linked list. */ - struct NeighbourList *next; + struct NeighborList *next; /** * Which of our transports is connected to this peer @@ -319,10 +319,20 @@ struct NeighbourList struct MessageQueue *messages; /** - * Identity of this neighbour. + * Identity of this neighbor. */ struct GNUNET_PeerIdentity id; + /* + * Opaque addr of this peer, only known to the plugin + */ + char *addr; + + /* + * Size of addr + */ + size_t addr_len; + /** * ID of task scheduled to run when this peer is about to * time out (will free resources associated with the peer). @@ -354,7 +364,7 @@ struct NeighbourList uint64_t last_received; /** - * Global quota for inbound traffic for the neighbour in bytes/ms. + * Global quota for inbound traffic for the neighbor in bytes/ms. */ uint32_t quota_in; @@ -367,12 +377,20 @@ struct NeighbourList unsigned int quota_violation_count; /** - * Have we seen an ACK from this neighbour in the past? + * Have we seen an ACK from this neighbor in the past? * (used to make up a fake ACK for clients connecting after - * the neighbour connected to us). + * the neighbor connected to us). */ int saw_ack; + /* The latency we have seen for this particular address for + * this particular peer. This latency may have been calculated + * over multiple transports. This value reflects how long it took + * us to receive a response when SENDING via this particular + * transport/neighbor/address combination! + */ + struct GNUNET_TIME_RelativeNBO latency; + }; @@ -517,7 +535,7 @@ static struct GNUNET_HELLO_Message *our_hello; /** * "version" of "our_hello". Used to see if a given - * neighbour has already been sent the latest version + * neighbor has already been sent the latest version * of our HELLO message. */ static unsigned int our_hello_version; @@ -563,28 +581,43 @@ static struct TransportPlugin *plugins; static struct GNUNET_SERVER_Handle *server; /** - * All known neighbours and their HELLOs. + * All known neighbors and their HELLOs. */ -static struct NeighbourList *neighbours; +static struct NeighborList *neighbors; /** - * Number of neighbours we'd like to have. + * Number of neighbors we'd like to have. */ static uint32_t max_connect_per_transport; /** - * Find an entry in the neighbour list for a particular peer. + * Find an entry in the neighbor list for a particular peer. + * if sender_address is not specified (NULL) then return the + * first matching entry. If sender_address is specified, then + * make sure that the address and address_len also matches. * * @return NULL if not found. */ -static struct NeighbourList * -find_neighbour (const struct GNUNET_PeerIdentity *key) +static struct NeighborList * +find_neighbor (const struct GNUNET_PeerIdentity *key, const char *sender_address, + size_t sender_address_len) { - struct NeighbourList *head = neighbours; - while ((head != NULL) && - (0 != memcmp (key, &head->id, sizeof (struct GNUNET_PeerIdentity)))) - head = head->next; + struct NeighborList *head = neighbors; + if (sender_address == NULL) + { + while ((head != NULL) && + (0 != memcmp (key, &head->id, sizeof (struct GNUNET_PeerIdentity)))) + head = head->next; + } + else + { + while ((head != NULL) && + (0 != memcmp (key, &head->id, sizeof (struct GNUNET_PeerIdentity))) && + (sender_address_len != head->addr_len) && + (0 != memcmp (sender_address, &head->addr, head->addr_len))) + head = head->next; + } return head; } @@ -605,10 +638,10 @@ find_transport (const char *short_name) /** - * Update the quota values for the given neighbour now. + * Update the quota values for the given neighbor now. */ static void -update_quota (struct NeighbourList *n) +update_quota (struct NeighborList *n) { struct GNUNET_TIME_Relative delta; uint64_t allowed; @@ -775,22 +808,22 @@ transmit_to_client (struct TransportClient *client, /** * Find alternative plugins for communication. * - * @param neighbour for which neighbour should we try to find + * @param neighbor for which neighbor should we try to find * more plugins? */ static void -try_alternative_plugins (struct NeighbourList *neighbour) +try_alternative_plugins (struct NeighborList *neighbor) { struct ReadyList *rl; - if ((neighbour->plugins != NULL) && - (neighbour->retry_plugins_time.value > + if ((neighbor->plugins != NULL) && + (neighbor->retry_plugins_time.value > GNUNET_TIME_absolute_get ().value)) return; /* don't try right now */ - neighbour->retry_plugins_time + neighbor->retry_plugins_time = GNUNET_TIME_relative_to_absolute (PLUGIN_RETRY_FREQUENCY); - rl = neighbour->plugins; + rl = neighbor->plugins; while (rl != NULL) { if (rl->connect_attempts > 0) @@ -802,29 +835,29 @@ try_alternative_plugins (struct NeighbourList *neighbour) /** - * The peer specified by the given neighbour has timed-out or a plugin + * The peer specified by the given neighbor has timed-out or a plugin * has disconnected. We may either need to do nothing (other plugins * still up), or trigger a full disconnect and clean up. This * function updates our state and do the necessary notifications. - * Also notifies our clients that the neighbour is now officially + * Also notifies our clients that the neighbor is now officially * gone. * - * @param n the neighbour list entry for the peer + * @param n the neighbor list entry for the peer * @param check should we just check if all plugins * disconnected or must we ask all plugins to * disconnect? */ -static void disconnect_neighbour (struct NeighbourList *n, int check); +static void disconnect_neighbor (struct NeighborList *n, int check); /** - * Check the ready list for the given neighbour and + * Check the ready list for the given neighbor and * if a plugin is ready for transmission (and if we * have a message), do so! * - * @param neighbour target peer for which to check the plugins + * @param neighbor target peer for which to check the plugins */ -static void try_transmission_to_peer (struct NeighbourList *neighbour); +static void try_transmission_to_peer (struct NeighborList *neighbor); /** @@ -849,10 +882,10 @@ transmit_send_continuation (void *cls, struct MessageQueue *mq = cls; struct ReadyList *rl; struct SendOkMessage send_ok_msg; - struct NeighbourList *n; + struct NeighborList *n; GNUNET_assert (mq != NULL); - n = mq->neighbour; + n = mq->neighbor; GNUNET_assert (n != NULL); GNUNET_assert (0 == memcmp (&n->id, target, @@ -894,17 +927,17 @@ transmit_send_continuation (void *cls, if (result == GNUNET_OK) try_transmission_to_peer (n); else - disconnect_neighbour (n, GNUNET_YES); + disconnect_neighbor (n, GNUNET_YES); } /** - * Check the ready list for the given neighbour and + * Check the ready list for the given neighbor and * if a plugin is ready for transmission (and if we * have a message), do so! */ static void -try_transmission_to_peer (struct NeighbourList *neighbour) +try_transmission_to_peer (struct NeighborList *neighbor) { struct ReadyList *pos; struct GNUNET_TIME_Relative min_latency; @@ -912,14 +945,14 @@ try_transmission_to_peer (struct NeighbourList *neighbour) struct MessageQueue *mq; struct GNUNET_TIME_Absolute now; - if (neighbour->messages == NULL) + if (neighbor->messages == NULL) return; /* nothing to do */ - try_alternative_plugins (neighbour); + try_alternative_plugins (neighbor); min_latency = GNUNET_TIME_UNIT_FOREVER_REL; rl = NULL; - mq = neighbour->messages; + mq = neighbor->messages; now = GNUNET_TIME_absolute_get (); - pos = neighbour->plugins; + pos = neighbor->plugins; while (pos != NULL) { /* set plugins that are inactive for a long time back to disconnected */ @@ -928,7 +961,7 @@ try_transmission_to_peer (struct NeighbourList *neighbour) #if DEBUG_TRANSPORT GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Marking long-time inactive connection to `%4s' as down.\n", - GNUNET_i2s (&neighbour->id)); + GNUNET_i2s (&neighbor->id)); #endif pos->connected = GNUNET_NO; } @@ -957,10 +990,10 @@ try_transmission_to_peer (struct NeighbourList *neighbour) #if DEBUG_TRANSPORT GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Establishing fresh connection with `%4s' via plugin `%s'\n", - GNUNET_i2s (&neighbour->id), rl->plugin->short_name); + GNUNET_i2s (&neighbor->id), rl->plugin->short_name); #endif } - neighbour->messages = mq->next; + neighbor->messages = mq->next; mq->plugin = rl->plugin; if (!mq->internal_msg) rl->transmit_ready = GNUNET_NO; @@ -968,13 +1001,17 @@ try_transmission_to_peer (struct NeighbourList *neighbour) GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Giving message of type `%u' for `%4s' to plugin `%s'\n", ntohs (mq->message->type), - GNUNET_i2s (&neighbour->id), rl->plugin->short_name); + GNUNET_i2s (&neighbor->id), rl->plugin->short_name); #endif + rl->plugin->api->send (rl->plugin->api->cls, - &neighbour->id, - mq->priority, + &neighbor->id, mq->message, + mq->priority, GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, + rl->neighbor->addr, + rl->neighbor->addr_len, + GNUNET_NO, &transmit_send_continuation, mq); } @@ -986,13 +1023,13 @@ try_transmission_to_peer (struct NeighbourList *neighbour) * @param priority how important is the message * @param msg message to send * @param is_internal is this an internal message - * @param neighbour handle to the neighbour for transmission + * @param neighbor handle to the neighbor for transmission */ static void transmit_to_peer (struct TransportClient *client, unsigned int priority, const struct GNUNET_MessageHeader *msg, - int is_internal, struct NeighbourList *neighbour) + int is_internal, struct NeighborList *neighbor) { struct MessageQueue *mq; struct MessageQueue *mqe; @@ -1001,12 +1038,12 @@ transmit_to_peer (struct TransportClient *client, #if DEBUG_TRANSPORT GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _("Sending message of type %u to peer `%4s'\n"), - ntohs (msg->type), GNUNET_i2s (&neighbour->id)); + ntohs (msg->type), GNUNET_i2s (&neighbor->id)); #endif if (client != NULL) { /* check for duplicate submission */ - mq = neighbour->messages; + mq = neighbor->messages; while (NULL != mq) { if (mq->client == client) @@ -1024,20 +1061,20 @@ transmit_to_peer (struct TransportClient *client, m = GNUNET_malloc (ntohs (msg->size)); memcpy (m, msg, ntohs (msg->size)); mq->message = m; - mq->neighbour = neighbour; + mq->neighbor = neighbor; mq->internal_msg = is_internal; mq->priority = priority; /* find tail */ - mqe = neighbour->messages; + mqe = neighbor->messages; if (mqe != NULL) while (mqe->next != NULL) mqe = mqe->next; if (mqe == NULL) { /* new head */ - neighbour->messages = mq; - try_transmission_to_peer (neighbour); + neighbor->messages = mq; + try_transmission_to_peer (neighbor); } else { @@ -1092,7 +1129,7 @@ refresh_hello () { struct GNUNET_HELLO_Message *hello; struct TransportClient *cpos; - struct NeighbourList *npos; + struct NeighborList *npos; struct GeneratorContext gc; #if DEBUG_TRANSPORT @@ -1116,12 +1153,12 @@ refresh_hello () our_hello = hello; our_hello_version++; GNUNET_PEERINFO_add_peer (cfg, sched, &my_identity, our_hello); - npos = neighbours; + npos = neighbors; while (npos != NULL) { #if DEBUG_TRANSPORT GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK, - "Transmitting updated `%s' to neighbour `%4s'\n", + "Transmitting updated `%s' to neighbor `%4s'\n", "HELLO", GNUNET_i2s (&npos->id)); #endif transmit_to_peer (NULL, 0, @@ -1365,7 +1402,7 @@ cleanup_validation (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) struct GNUNET_TIME_Absolute first; struct GNUNET_HELLO_Message *hello; struct GNUNET_PeerIdentity pid; - struct NeighbourList *n; + struct NeighborList *n; #if DEBUG_TRANSPORT GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK, @@ -1395,7 +1432,7 @@ cleanup_validation (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) "HELLO", GNUNET_i2s (&pid)); #endif GNUNET_PEERINFO_add_peer (cfg, sched, &pid, hello); - n = find_neighbour (&pid); + n = find_neighbor (&pid, NULL, 0); if (NULL != n) try_transmission_to_peer (n); GNUNET_free (hello); @@ -1452,10 +1489,10 @@ cleanup_validation (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) * by the other peer in human-readable format) */ static void -plugin_env_notify_validation (void *cls, - const char *name, - const struct GNUNET_PeerIdentity *peer, - uint32_t challenge, const char *sender_addr) +handle_pong (void *cls, const struct GNUNET_MessageHeader *message, + const struct GNUNET_PeerIdentity *peer, + const char *sender_address, + size_t sender_address_len) { unsigned int not_done; int matched; @@ -1463,6 +1500,7 @@ plugin_env_notify_validation (void *cls, struct ValidationAddress *va; struct GNUNET_PeerIdentity id; + int challenge = 1; /* FIXME: Pull this number out of the PONG message */ pos = pending_validations; while (pos != NULL) { @@ -1499,8 +1537,8 @@ plugin_env_notify_validation (void *cls, #endif GNUNET_log (GNUNET_ERROR_TYPE_INFO | GNUNET_ERROR_TYPE_BULK, _ - ("Another peer saw us using the address `%s' via `%s'. If this is not plausible, this address should be listed in the configuration as implausible to avoid MiM attacks.\n"), - sender_addr, name); + ("Another peer saw us using the address `%s' via `FIXME'. If this is not plausible, this address should be listed in the configuration as implausible to avoid MiM attacks.\n"), + sender_address); va->ok = GNUNET_YES; va->expiration = GNUNET_TIME_relative_to_absolute (HELLO_ADDRESS_EXPIRATION); @@ -1611,6 +1649,32 @@ run_validation (void *cls, return GNUNET_OK; } +/* + * @param cls handle to the plugin (for sending) + * @param target the peer identity of the peer we are sending to + * @param challenge the challenge number + * @param timeout how long to await validation? + * @param addr the address to validate + * @param addrlen the length of the address + * + * Perform address validation, which means sending a PING PONG to + * the address via the transport plugin. If not validated, then + * do not count this as a good peer/address... + * + */ +static void +validate_address (void *cls, struct ValidationAddress *va, + const struct GNUNET_PeerIdentity *target, + struct GNUNET_TIME_Relative timeout, + const void *addr, size_t addrlen) +{ + /* struct Plugin *plugin = cls; + int challenge = va->challenge; */ + + + return; +} + /** * Check if addresses in validated hello "h" overlap with @@ -1677,13 +1741,11 @@ check_hello_validated (void *cls, #endif tp = find_transport (va->transport_name); GNUNET_assert (tp != NULL); - if (GNUNET_OK != - tp->api->validate (tp->api->cls, - &apeer, - va->challenge, - HELLO_VERIFICATION_TIMEOUT, - &va[1], va->addr_len)) - va->ok = GNUNET_SYSERR; + /* This validation should happen inside the transport, not from the plugin! */ + validate_address (tp->api->cls, va, &apeer, + HELLO_VERIFICATION_TIMEOUT, + &va[1], va->addr_len); + /* va->ok = GNUNET_SYSERR; will be set by validate_address! */ va = va->next; } GNUNET_SCHEDULER_add_delayed (sched, @@ -1775,24 +1837,24 @@ process_hello (struct TransportPlugin *plugin, /** - * The peer specified by the given neighbour has timed-out or a plugin + * The peer specified by the given neighbor has timed-out or a plugin * has disconnected. We may either need to do nothing (other plugins * still up), or trigger a full disconnect and clean up. This * function updates our state and do the necessary notifications. - * Also notifies our clients that the neighbour is now officially + * Also notifies our clients that the neighbor is now officially * gone. * - * @param n the neighbour list entry for the peer + * @param n the neighbor list entry for the peer * @param check should we just check if all plugins * disconnected or must we ask all plugins to * disconnect? */ static void -disconnect_neighbour (struct NeighbourList *n, int check) +disconnect_neighbor (struct NeighborList *n, int check) { struct ReadyList *rpos; - struct NeighbourList *npos; - struct NeighbourList *nprev; + struct NeighborList *npos; + struct NeighborList *nprev; struct MessageQueue *mq; if (GNUNET_YES == check) @@ -1810,9 +1872,9 @@ disconnect_neighbour (struct NeighbourList *n, int check) GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK, "Disconnecting from `%4s'\n", GNUNET_i2s (&n->id)); #endif - /* remove n from neighbours list */ + /* remove n from neighbors list */ nprev = NULL; - npos = neighbours; + npos = neighbors; while ((npos != NULL) && (npos != n)) { nprev = npos; @@ -1820,7 +1882,7 @@ disconnect_neighbour (struct NeighbourList *n, int check) } GNUNET_assert (npos != NULL); if (nprev == NULL) - neighbours = n->next; + neighbors = n->next; else nprev->next = n->next; @@ -1831,7 +1893,7 @@ disconnect_neighbour (struct NeighbourList *n, int check) while (NULL != (rpos = n->plugins)) { n->plugins = rpos->next; - GNUNET_assert (rpos->neighbour == n); + GNUNET_assert (rpos->neighbor == n); if (GNUNET_YES == rpos->connected) rpos->plugin->api->disconnect (rpos->plugin->api->cls, &n->id); GNUNET_free (rpos); @@ -1841,7 +1903,7 @@ disconnect_neighbour (struct NeighbourList *n, int check) while (NULL != (mq = n->messages)) { n->messages = mq->next; - GNUNET_assert (mq->neighbour == n); + GNUNET_assert (mq->neighbor == n); GNUNET_free (mq); } if (n->timeout_task != GNUNET_SCHEDULER_NO_TASK) @@ -1854,17 +1916,17 @@ disconnect_neighbour (struct NeighbourList *n, int check) /** * Add an entry for each of our transport plugins * (that are able to send) to the list of plugins - * for this neighbour. + * for this neighbor. * - * @param neighbour to initialize + * @param neighbor to initialize */ static void -add_plugins (struct NeighbourList *neighbour) +add_plugins (struct NeighborList *neighbor) { struct TransportPlugin *tp; struct ReadyList *rl; - neighbour->retry_plugins_time + neighbor->retry_plugins_time = GNUNET_TIME_relative_to_absolute (PLUGIN_RETRY_FREQUENCY); tp = plugins; while (tp != NULL) @@ -1872,10 +1934,10 @@ add_plugins (struct NeighbourList *neighbour) if (tp->api->send != NULL) { rl = GNUNET_malloc (sizeof (struct ReadyList)); - rl->next = neighbour->plugins; - neighbour->plugins = rl; + rl->next = neighbor->plugins; + neighbor->plugins = rl; rl->plugin = tp; - rl->neighbour = neighbour; + rl->neighbor = neighbor; rl->transmit_ready = GNUNET_YES; } tp = tp->next; @@ -1884,42 +1946,42 @@ add_plugins (struct NeighbourList *neighbour) static void -neighbour_timeout_task (void *cls, +neighbor_timeout_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { - struct NeighbourList *n = cls; + struct NeighborList *n = cls; #if DEBUG_TRANSPORT GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK, - "Neighbour `%4s' has timed out!\n", GNUNET_i2s (&n->id)); + "Neighbor `%4s' has timed out!\n", GNUNET_i2s (&n->id)); #endif n->timeout_task = GNUNET_SCHEDULER_NO_TASK; - disconnect_neighbour (n, GNUNET_NO); + disconnect_neighbor (n, GNUNET_NO); } /** - * Create a fresh entry in our neighbour list for the given peer. - * Will try to transmit our current HELLO to the new neighbour. Also + * Create a fresh entry in our neighbor list for the given peer. + * Will try to transmit our current HELLO to the new neighbor. Also * notifies our clients about the new "connection". * * @param peer the peer for which we create the entry - * @return the new neighbour list entry + * @return the new neighbor list entry */ -static struct NeighbourList * -setup_new_neighbour (const struct GNUNET_PeerIdentity *peer) +static struct NeighborList * +setup_new_neighbor (const struct GNUNET_PeerIdentity *peer, const char *addr, size_t sender_address_len) { - struct NeighbourList *n; + struct NeighborList *n; #if DEBUG_TRANSPORT GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK, - "Setting up new neighbour `%4s', sending our HELLO to introduce ourselves\n", + "Setting up new neighbor `%4s', sending our HELLO to introduce ourselves\n", GNUNET_i2s (peer)); #endif GNUNET_assert (our_hello != NULL); - n = GNUNET_malloc (sizeof (struct NeighbourList)); - n->next = neighbours; - neighbours = n; + n = GNUNET_malloc (sizeof (struct NeighborList)); + n->next = neighbors; + neighbors = n; n->id = *peer; n->last_quota_update = GNUNET_TIME_absolute_get (); n->peer_timeout = @@ -1929,7 +1991,7 @@ setup_new_neighbour (const struct GNUNET_PeerIdentity *peer) add_plugins (n); n->timeout_task = GNUNET_SCHEDULER_add_delayed (sched, GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, - &neighbour_timeout_task, n); + &neighbor_timeout_task, n); transmit_to_peer (NULL, 0, (const struct GNUNET_MessageHeader *) our_hello, GNUNET_YES, n); @@ -1937,6 +1999,20 @@ setup_new_neighbour (const struct GNUNET_PeerIdentity *peer) return n; } +/* + * We have received a PING message from someone. Need to send a PONG message + * in response to the peer by any means necessary. Of course, with something + * like TCP where a connection exists, we may want to send it that way. But + * we may not be able to make that distinction... + */ +static int handle_ping(void *cls, const struct GNUNET_MessageHeader *message, + const struct GNUNET_PeerIdentity *peer, + const char *sender_address, + size_t sender_address_len) +{ + + return GNUNET_OK; +} /** * Function called by the plugin for each received message. @@ -1945,19 +2021,22 @@ setup_new_neighbour (const struct GNUNET_PeerIdentity *peer) * and generally forward to our receive callback. * * @param cls the "struct TransportPlugin *" we gave to the plugin - * @param latency estimated latency for communicating with the - * given peer - * @param peer (claimed) identity of the other peer * @param message the message, NULL if peer was disconnected + * @param distance the transport cost to this peer (not latency!) + * @param sender_address the address that the sender reported + * (opaque to transport service) + * @param sender_address_len the length of the sender address + * @param peer (claimed) identity of the other peer * @return the new service_context that the plugin should use * for future receive calls for messages from this * particular peer + * */ static void -plugin_env_receive (void *cls, - struct GNUNET_TIME_Relative latency, +plugin_env_receive (void *cls, const struct GNUNET_MessageHeader *message, const struct GNUNET_PeerIdentity *peer, - const struct GNUNET_MessageHeader *message) + unsigned int distance, const char *sender_address, + size_t sender_address_len) { const struct GNUNET_MessageHeader ack = { htons (sizeof (struct GNUNET_MessageHeader)), @@ -1968,14 +2047,14 @@ plugin_env_receive (void *cls, struct TransportClient *cpos; struct InboundMessage *im; uint16_t msize; - struct NeighbourList *n; + struct NeighborList *n; - n = find_neighbour (peer); + n = find_neighbor (peer, sender_address, sender_address_len); if (n == NULL) { if (message == NULL) return; /* disconnect of peer already marked down */ - n = setup_new_neighbour (peer); + n = setup_new_neighbor (peer, sender_address, sender_address_len); } service_context = n->plugins; while ((service_context != NULL) && (plugin != service_context->plugin)) @@ -1991,7 +2070,7 @@ plugin_env_receive (void *cls, /* TODO: call stats */ if (service_context != NULL) service_context->connected = GNUNET_NO; - disconnect_neighbour (n, GNUNET_YES); + disconnect_neighbor (n, GNUNET_YES); return; } #if DEBUG_TRANSPORT @@ -2011,7 +2090,7 @@ plugin_env_receive (void *cls, = GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT); - service_context->latency = latency; + /* service_context->latency = latency; */ /* This value should be set by us! */ } /* update traffic received amount ... */ msize = ntohs (message->size); @@ -2023,7 +2102,7 @@ plugin_env_receive (void *cls, n->timeout_task = GNUNET_SCHEDULER_add_delayed (sched, GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, - &neighbour_timeout_task, n); + &neighbor_timeout_task, n); update_quota (n); if (n->quota_violation_count > QUOTA_VIOLATION_DROP_THRESHOLD) { @@ -2034,7 +2113,7 @@ plugin_env_receive (void *cls, ("Dropping incoming message due to repeated bandwidth quota violations.\n")); /* TODO: call stats */ GNUNET_assert ((service_context == NULL) || - (NULL != service_context->neighbour)); + (NULL != service_context->neighbor)); return; } switch (ntohs (message->type)) @@ -2053,6 +2132,11 @@ plugin_env_receive (void *cls, #endif transmit_to_peer (NULL, 0, &ack, GNUNET_YES, n); break; + case GNUNET_MESSAGE_TYPE_TRANSPORT_PING: + handle_ping(plugin, message, peer, sender_address, sender_address_len); + case GNUNET_MESSAGE_TYPE_TRANSPORT_PONG: + handle_pong(plugin, message, peer, sender_address, sender_address_len); + //plugin_env_notify_validation(); case GNUNET_MESSAGE_TYPE_TRANSPORT_ACK: n->saw_ack = GNUNET_YES; /* intentional fall-through! */ @@ -2066,7 +2150,7 @@ plugin_env_receive (void *cls, im = GNUNET_malloc (sizeof (struct InboundMessage) + msize); im->header.size = htons (sizeof (struct InboundMessage) + msize); im->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_RECV); - im->latency = GNUNET_TIME_relative_hton (latency); + im->latency = n->latency; im->peer = *peer; memcpy (&im[1], message, msize); @@ -2079,7 +2163,7 @@ plugin_env_receive (void *cls, GNUNET_free (im); } GNUNET_assert ((service_context == NULL) || - (NULL != service_context->neighbour)); + (NULL != service_context->neighbor)); } @@ -2098,7 +2182,7 @@ handle_start (void *cls, { struct TransportClient *c; struct ConnectInfoMessage cim; - struct NeighbourList *n; + struct NeighborList *n; struct InboundMessage *im; struct GNUNET_MessageHeader *ack; @@ -2146,7 +2230,7 @@ handle_start (void *cls, ack = (struct GNUNET_MessageHeader *) &im[1]; ack->size = htons (sizeof (struct GNUNET_MessageHeader)); ack->type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_ACK); - for (n = neighbours; n != NULL; n = n->next) + for (n = neighbors; n != NULL; n = n->next) { cim.id = n->id; transmit_to_client (c, &cim.header, GNUNET_NO); @@ -2198,7 +2282,7 @@ handle_send (void *cls, const struct GNUNET_MessageHeader *message) { struct TransportClient *tc; - struct NeighbourList *n; + struct NeighborList *n; const struct OutboundMessage *obm; const struct GNUNET_MessageHeader *obmm; uint16_t size; @@ -2226,9 +2310,9 @@ handle_send (void *cls, GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); return; } - n = find_neighbour (&obm->peer); + n = find_neighbor (&obm->peer, NULL, 0); if (n == NULL) - n = setup_new_neighbour (&obm->peer); + n = setup_new_neighbor (&obm->peer, NULL, 0); tc = clients; while ((tc != NULL) && (tc->client != client)) tc = tc->next; @@ -2258,7 +2342,7 @@ handle_set_quota (void *cls, { const struct QuotaSetMessage *qsm = (const struct QuotaSetMessage *) message; - struct NeighbourList *n; + struct NeighborList *n; struct TransportPlugin *p; struct ReadyList *rl; @@ -2267,7 +2351,7 @@ handle_set_quota (void *cls, "Received `%s' request from client for peer `%4s'\n", "SET_QUOTA", GNUNET_i2s (&qsm->peer)); #endif - n = find_neighbour (&qsm->peer); + n = find_neighbor (&qsm->peer, NULL, 0); if (n == NULL) { GNUNET_SERVER_receive_done (client, GNUNET_OK); @@ -2309,8 +2393,14 @@ handle_try_connect (void *cls, "Received `%s' request from client %p asking to connect to `%4s'\n", "TRY_CONNECT", client, GNUNET_i2s (&tcm->peer)); #endif - if (NULL == find_neighbour (&tcm->peer)) - setup_new_neighbour (&tcm->peer); + if (NULL == find_neighbor (&tcm->peer, NULL, 0)) + setup_new_neighbor (&tcm->peer, NULL, 0); /* Can we set up a truly _new_ neighbor without + knowing its address? Should we ask the plugin + for more information about this peer? I don't + think we can... Or set up new peer should only + happen when transport notifies us of an address, + and this setup should check for an address in + the existing list only */ #if DEBUG_TRANSPORT else GNUNET_log (GNUNET_ERROR_TYPE_WARNING, @@ -2430,13 +2520,10 @@ create_environment (struct TransportPlugin *plug) { plug->env.cfg = cfg; plug->env.sched = sched; - plug->env.my_public_key = &my_public_key; - plug->env.my_private_key = my_private_key; plug->env.my_identity = &my_identity; plug->env.cls = plug; plug->env.receive = &plugin_env_receive; plug->env.notify_address = &plugin_env_notify_address; - plug->env.notify_validation = &plugin_env_notify_validation; plug->env.default_quota_in = (GNUNET_CONSTANTS_DEFAULT_BPM_IN_OUT + 59999) / (60 * 1000); plug->env.max_connections = max_connect_per_transport; diff --git a/src/transport/plugin_transport.h b/src/transport/plugin_transport.h index 25defc431..b04cab990 100644 --- a/src/transport/plugin_transport.h +++ b/src/transport/plugin_transport.h @@ -56,16 +56,15 @@ * @param peer (claimed) identity of the other peer * @param message the message, NULL if peer was disconnected */ -typedef void (*GNUNET_TRANSPORT_PluginReceiveCallback) (void *cls, - unsigned int distance, - const char *sender_address, - size_t sender_address_len, +typedef void (*GNUNET_TRANSPORT_PluginReceiveCallback) (void *cls, const struct + GNUNET_MessageHeader * + message, const struct GNUNET_PeerIdentity * peer, - const struct - GNUNET_MessageHeader * - message); + unsigned int distance, + const char *sender_address, + size_t sender_address_len); diff --git a/src/transport/test_transport_api.c b/src/transport/test_transport_api.c index 817077f58..7ce02c757 100644 --- a/src/transport/test_transport_api.c +++ b/src/transport/test_transport_api.c @@ -40,7 +40,7 @@ /** * How long until we give up on transmitting the message? */ -#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 300) +#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30) #define MTYPE 12345 @@ -159,6 +159,7 @@ setup_peer (struct PeerContext *p, const char *cfgname) "-c", cfgname, NULL); #endif GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname)); + p->th = GNUNET_TRANSPORT_connect (sched, p->cfg, p, ¬ify_receive, @@ -230,6 +231,31 @@ exchange_hello (void *cls, GNUNET_TRANSPORT_get_hello (p2.th, TIMEOUT, &exchange_hello_last, &p2); } +static void +setTransportOptions(char * filename) +{ + struct GNUNET_CONFIGURATION_Handle * tempcfg; + + tempcfg = GNUNET_CONFIGURATION_create(); + GNUNET_CONFIGURATION_load (tempcfg, filename); + + unsigned long long curr_port; + GNUNET_CONFIGURATION_get_value_number(tempcfg, "transport", "port", &curr_port); + + if (is_udp) + { + fprintf(stderr, "setting transport udp plugins\n"); + GNUNET_CONFIGURATION_set_value_string(tempcfg, "transport", "plugins", "udp"); + GNUNET_CONFIGURATION_set_value_number(tempcfg, "transport-udp", "PORT", curr_port + 3); + } + else if (is_tcp) + { + GNUNET_CONFIGURATION_set_value_string(tempcfg, "transport", "plugins", "tcp"); + GNUNET_CONFIGURATION_set_value_number(tempcfg, "transport-tcp", "port", curr_port + 3); + } + GNUNET_CONFIGURATION_write(tempcfg, filename); + return; +} static void run (void *cls, @@ -240,6 +266,10 @@ run (void *cls, GNUNET_assert (ok == 1); OKPP; sched = s; + + setTransportOptions("test_transport_api_peer1.conf"); + setTransportOptions("test_transport_api_peer2.conf"); + setup_peer (&p1, "test_transport_api_peer1.conf"); setup_peer (&p2, "test_transport_api_peer2.conf"); GNUNET_TRANSPORT_get_hello (p1.th, TIMEOUT, &exchange_hello, &p1); @@ -257,10 +287,10 @@ stop_arm (struct PeerContext *p) GNUNET_CONFIGURATION_destroy (p->cfg); } - static int check () { + char *const argv[] = { "test-transport-api", "-c", "test_transport_api_data.conf", @@ -269,6 +299,9 @@ check () #endif NULL }; + + setTransportOptions("test_transport_api_data.conf"); + struct GNUNET_GETOPT_CommandLineOption options[] = { GNUNET_GETOPT_OPTION_END }; @@ -287,13 +320,13 @@ main (int argc, char *argv[]) { int ret; - if (strstr(argv[0], "test_transport_api_tcp") == 0) + if (strstr(argv[0], "tcp") != NULL) { is_tcp = GNUNET_YES; } - else if (strstr(argv[0], "test_transport_api_udp") == 0) + else if (strstr(argv[0], "udp") != NULL) { - is_udp = GNUNET_NO; + is_udp = GNUNET_YES; } -- cgit v1.2.3