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
{
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.
/**
- * 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
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
/**
- * 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
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).
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;
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;
+
};
/**
* "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;
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;
}
/**
- * 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;
/**
* 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)
/**
- * 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);
/**
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,
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;
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 */
#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;
}
#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;
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);
}
* @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;
#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)
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
{
{
struct GNUNET_HELLO_Message *hello;
struct TransportClient *cpos;
- struct NeighbourList *npos;
+ struct NeighborList *npos;
struct GeneratorContext gc;
#if DEBUG_TRANSPORT
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,
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,
"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);
* 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;
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)
{
#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);
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
#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,
/**
- * 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)
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;
}
GNUNET_assert (npos != NULL);
if (nprev == NULL)
- neighbours = n->next;
+ neighbors = n->next;
else
nprev->next = n->next;
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);
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)
/**
* 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)
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;
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 =
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);
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.
* 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)),
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))
/* 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
=
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);
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)
{
("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))
#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! */
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);
GNUNET_free (im);
}
GNUNET_assert ((service_context == NULL) ||
- (NULL != service_context->neighbour));
+ (NULL != service_context->neighbor));
}
{
struct TransportClient *c;
struct ConnectInfoMessage cim;
- struct NeighbourList *n;
+ struct NeighborList *n;
struct InboundMessage *im;
struct GNUNET_MessageHeader *ack;
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);
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;
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;
{
const struct QuotaSetMessage *qsm =
(const struct QuotaSetMessage *) message;
- struct NeighbourList *n;
+ struct NeighborList *n;
struct TransportPlugin *p;
struct ReadyList *rl;
"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);
"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,
{
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;
projects / oweals / gnunet.git / commitdiff