* Besides, if a single request to an address takes a long time,
* then the peer is unlikely worthwhile anyway.
*/
-#define HELLO_VERIFICATION_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 3)
+#define HELLO_VERIFICATION_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)
+
+/**
+ * How long will we allow sending of a ping to be delayed?
+ */
+#define TRANSPORT_DEFAULT_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 15)
+
+#define TRANSPORT_DEFAULT_PRIORITY 4 /* Tired of remembering arbitrary priority names */
/**
* How often do we re-add (cheaper) plugins to our list of plugins
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;
+
};
+/**
+ * Message used to ask a peer to validate receipt (to check an address
+ * from a HELLO). Followed by the address used. Note that the
+ * recipients response does not affirm that he has this address,
+ * only that he got the challenge message.
+ */
+struct TransportPingMessage
+{
+
+ /**
+ * Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_PING
+ */
+ struct GNUNET_MessageHeader header;
+
+ /**
+ * Random challenge number (in network byte order).
+ */
+ uint32_t challenge GNUNET_PACKED;
+
+ /**
+ * Who is the intended recipient?
+ */
+ struct GNUNET_PeerIdentity target;
+
+};
+
+
+/**
+ * Message used to validate a HELLO. The challenge is included in the
+ * confirmation to make matching of replies to requests possible. The
+ * signature signs the original challenge number, our public key, the
+ * sender's address (so that the sender can check that the address we
+ * saw is plausible for him and possibly detect a MiM attack) and a
+ * timestamp (to limit replay).<p>
+ *
+ * This message is followed by the address of the
+ * client that we are observing (which is part of what
+ * is being signed).
+ */
+struct TransportPongMessage
+{
+
+ /**
+ * Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_PONG
+ */
+ struct GNUNET_MessageHeader header;
+
+ /**
+ * For padding, always zero.
+ */
+ uint32_t reserved GNUNET_PACKED;
+
+ /**
+ * Signature.
+ */
+ struct GNUNET_CRYPTO_RsaSignature signature;
+
+ /**
+ * What are we signing and why?
+ */
+ struct GNUNET_CRYPTO_RsaSignaturePurpose purpose;
+
+ /**
+ * Random challenge number (in network byte order).
+ */
+ uint32_t challenge GNUNET_PACKED;
+
+ /**
+ * Who signed this message?
+ */
+ struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded signer;
+
+};
/**
* Linked list of messages to be transmitted to
/**
* "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,
rl->connected = GNUNET_NO;
}
if (!mq->internal_msg)
- rl->transmit_ready = GNUNET_YES;
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Setting transmit_ready on transport!\n");
+ rl->transmit_ready = GNUNET_YES;
+ }
+
if (mq->client != NULL)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
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->addr != NULL)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ _("try_transmission_to_peer entry: at this point neighbor->addr is NOT NULL\n"));
+ }
+ else
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _("try_transmission_to_peer entry: at this point neighbor->addr is NULL\n"));
+ }
+
+ 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 (GNUNET_YES == pos->transmit_ready)
+ {
+#if DEBUG_TRANSPORT
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Found transmit_ready flag...\n");
+#endif
+ }
if (((GNUNET_YES == pos->transmit_ready) ||
(mq->internal_msg)) &&
(pos->connect_attempts < MAX_CONNECT_RETRY) &&
#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
+
+ if (rl->neighbor->addr != NULL)
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _("try_transmission_to_peer pre-send: at this point rl->neighbor->addr is NOT NULL, addrlen is %d\n"), rl->neighbor->addr_len);
+ else
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _("try_transmission_to_peer pre-send: at this point rl->neighbor->addr is NULL\n"));
+ /* FIXME: Change MessageQueue to hold message buffer and size? */
rl->plugin->api->send (rl->plugin->api->cls,
- &neighbour->id,
+ &neighbor->id,
+ (char *)mq->message,
+ ntohs(mq->message->size),
mq->priority,
- mq->message,
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));
+ if (neighbor->addr != NULL)
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _("transmit_to_peer: at this point neighbor->addr is NOT NULL\n"));
#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;
}
else
{
/* append */
mqe->next = mq;
}
+ try_transmission_to_peer (neighbor);
}
gc->addr_pos = (gc->plug_pos != NULL) ? gc->plug_pos->addresses : NULL;
}
if (NULL == gc->plug_pos)
- return 0;
+ {
+#if DEBUG_TRANSPORT
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "In address_generator, gc->plug_pos is NULL!\n");
+#endif
+ return 0;
+ }
+#if DEBUG_TRANSPORT
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Should be adding an address...\n");
+#endif
ret = GNUNET_HELLO_add_address (gc->plug_pos->short_name,
gc->expiration,
gc->addr_pos->addr,
{
struct GNUNET_HELLO_Message *hello;
struct TransportClient *cpos;
- struct NeighbourList *npos;
+ struct NeighborList *npos;
struct GeneratorContext gc;
#if DEBUG_TRANSPORT
gc.addr_pos = plugins != NULL ? plugins->addresses : NULL;
gc.expiration = GNUNET_TIME_relative_to_absolute (HELLO_ADDRESS_EXPIRATION);
hello = GNUNET_HELLO_create (&my_public_key, &address_generator, &gc);
+#if DEBUG_TRANSPORT
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
+ "Refreshed my `%s', new size is %d\n", "HELLO", GNUNET_HELLO_size(hello));
+#endif
cpos = clients;
while (cpos != NULL)
{
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);
+ {
+ try_transmission_to_peer (n);
+ }
GNUNET_free (hello);
while (NULL != (va = pos->addresses))
{
}
-
-
/**
* Function that will be called if we receive a validation
* of an address challenge that we transmitted to another
* 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 ValidationList *pos;
struct ValidationAddress *va;
struct GNUNET_PeerIdentity id;
-
+ struct TransportPongMessage *pong = (struct TransportPongMessage *)message;
+ int count = 0;
+ unsigned int challenge = ntohl(pong->challenge);
pos = pending_validations;
while (pos != NULL)
{
if (0 == memcmp (peer, &id, sizeof (struct GNUNET_PeerIdentity)))
break;
pos = pos->next;
+ count++;
}
if (pos == NULL)
{
/* TODO: call statistics (unmatched PONG) */
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
_
- ("Received validation response but have no record of any validation request for `%4s'. Ignoring.\n"),
- GNUNET_i2s (peer));
+ ("Received validation response but have no record of any validation request for `%4s' (out of %d). Ignoring.\n"),
+ GNUNET_i2s (peer), count);
return;
}
not_done = 0;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Confirmed validity of address, peer `%4s' has address `%s'.\n",
GNUNET_i2s (peer),
- GNUNET_a2s ((const struct sockaddr *) &va[1],
- va->addr_len));
+ GNUNET_a2s ((const struct sockaddr *) sender_address,
+ sender_address_len));
#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"),
+ GNUNET_a2s ((const struct sockaddr *) &va[1],
+ va->addr_len));
va->ok = GNUNET_YES;
va->expiration =
GNUNET_TIME_relative_to_absolute (HELLO_ADDRESS_EXPIRATION);
struct TransportPlugin *tp;
struct ValidationAddress *va;
struct GNUNET_PeerIdentity id;
+ int sent;
+ struct TransportPingMessage *ping;
+ char * message_buf;
+ int hello_size;
+ int tsize;
tp = find_transport (tname);
if (tp == NULL)
va->challenge = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
(unsigned int) -1);
memcpy (&va[1], addr, addrlen);
+
+ hello_size = GNUNET_HELLO_size(our_hello);
+ tsize = sizeof(struct TransportPingMessage) + hello_size;
+
+ message_buf = GNUNET_malloc(tsize);
+
+ ping = GNUNET_malloc(sizeof(struct TransportPingMessage));
+ ping->challenge = htonl(va->challenge);
+ ping->header.size = htons(sizeof(struct TransportPingMessage));
+ ping->header.type = htons(GNUNET_MESSAGE_TYPE_TRANSPORT_PING);
+ memcpy(&ping->target, &id, sizeof(struct GNUNET_PeerIdentity));
+
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "hello size is %d, ping size is %d, total size is %d", hello_size, sizeof(struct TransportPingMessage), tsize);
+
+ memcpy(message_buf, our_hello, hello_size);
+ memcpy(&message_buf[hello_size], ping, sizeof(struct TransportPingMessage));
+
+
+
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending ping message to address `%s' via `%s' for `%4s'\n",
+ GNUNET_a2s (addr, addrlen), tname, GNUNET_i2s (&id));
+
+
+ sent = tp->api->send(tp->api->cls, &id, message_buf, tsize, GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+ TRANSPORT_DEFAULT_TIMEOUT, addr, addrlen, GNUNET_YES, NULL, NULL);
+
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Transport returned %d from send!\n", sent);
+
+ GNUNET_free(ping);
+ GNUNET_free(message_buf);
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...
+ *
+ * Currently this function is not used, ping/pongs get sent from the
+ * run_validation function. Haven't decided yet how to do this.
+ */
+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
struct ValidationAddress *va;
struct TransportPlugin *tp;
int first_call;
+ int count;
struct GNUNET_PeerIdentity apeer;
first_call = GNUNET_NO;
chvc->e->next = pending_validations;
pending_validations = chvc->e;
}
+ /* no existing HELLO, all addresses are new */
+ GNUNET_HELLO_iterate_addresses (chvc->hello,
+ GNUNET_NO, &run_validation, chvc->e);
+#if 0
if (h != NULL)
{
GNUNET_HELLO_iterate_new_addresses (chvc->hello,
GNUNET_HELLO_iterate_addresses (chvc->hello,
GNUNET_NO, &run_validation, chvc->e);
}
+#endif
if (h != NULL)
return; /* wait for next call */
/* finally, transmit validation attempts */
"HELLO", GNUNET_i2s (&apeer));
#endif
va = chvc->e->addresses;
+ count = 0;
while (va != NULL)
{
#if DEBUG_TRANSPORT
#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;
+ count++;
}
+
+#if DEBUG_TRANSPORT
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Found %d addresses in hello of size %d\n", count, GNUNET_HELLO_size(chvc->hello));
+#endif
GNUNET_SCHEDULER_add_delayed (sched,
GNUNET_TIME_absolute_get_remaining (chvc->
e->timeout),
&target.hashPubKey);
#if DEBUG_TRANSPORT
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Processing `%s' message for `%4s'\n",
- "HELLO", GNUNET_i2s (&target));
+ "Processing `%s' message for `%4s' of size %d (hsize is %d)\n",
+ "HELLO", GNUNET_i2s (&target), GNUNET_HELLO_size(hello), hsize);
#endif
/* check if a HELLO for this peer is already on the validation list */
e = pending_validations;
/**
- * 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)
+{
+ struct TransportPlugin *plugin = cls;
+ struct TransportPingMessage *ping;
+ struct TransportPongMessage *pong;
+ uint16_t msize;
+ struct NeighborList *n;
+ pong = GNUNET_malloc(sizeof(struct TransportPongMessage));
+
+#if DEBUG_TRANSPORT
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
+ "Processing `%s' from `%s'\n",
+ "PING", GNUNET_a2s ((const struct sockaddr *)sender_address, sender_address_len));
+#endif
+
+ msize = ntohs (message->size);
+ if (msize < sizeof (struct TransportPingMessage))
+ {
+ GNUNET_break_op (0);
+ return GNUNET_SYSERR;
+ }
+ ping = (struct TransportPingMessage *) message;
+ if (0 != memcmp (&ping->target,
+ plugin->env.my_identity,
+ sizeof (struct GNUNET_PeerIdentity)))
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ _("Received `%s' message not destined for me!\n"), "PING");
+ return GNUNET_SYSERR;
+ }
+
+ msize -= sizeof (struct TransportPingMessage);
+/*
+ * if (GNUNET_OK != tcp_plugin_address_suggested (plugin, &vcm[1], msize))
+ {
+ GNUNET_break_op (0);
+ GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+ return;
+ }
+
+ if (GNUNET_OK != GNUNET_SERVER_client_get_address (client, &addr, &addrlen))
+ {
+ GNUNET_break (0);
+ GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+ return;
+ }
+*/
+ pong = GNUNET_malloc (sizeof (struct TransportPongMessage) + sender_address_len);
+ pong->header.size = htons (sizeof (struct TransportPongMessage) + sender_address_len);
+ pong->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_PONG);
+ pong->purpose.size =
+ htonl (sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose) +
+ sizeof (uint32_t) +
+ sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded) + sender_address_len);
+ pong->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_TCP_PING);
+ pong->challenge = ping->challenge;
+
+ memcpy(&pong->signer, &my_public_key, sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded));
+ memcpy (&pong[1], sender_address, sender_address_len);
+ GNUNET_assert (GNUNET_OK ==
+ GNUNET_CRYPTO_rsa_sign (my_private_key,
+ &pong->purpose, &pong->signature));
+ /* Will this nonsense work, even for UDP?
+ * The idea is that we need an address to send to for UDP, but we may not know
+ * this peer yet. So in that case, we need to create a new neighbor with the
+ * current address, but is this address going to be correct, or will it have a
+ * random high port or something? Another question is, why didn't we get a WELCOME
+ * from this peer with its advertised addresses already? We don't want to
+ * differentiate based on transport... */
+ n = find_neighbor(peer, NULL, 0);
+ if (n == NULL)
+ {
+#if DEBUG_TRANSPORT
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Didn't find peer in list, adding...\n");
+#endif
+ setup_new_neighbor(peer, sender_address, sender_address_len);
+ n = find_neighbor(peer, sender_address, sender_address_len);
+ GNUNET_assert(n != NULL);
+ }
+ else if (n->addr == NULL)
+ {
+#if DEBUG_TRANSPORT
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Found peer in list, but without address, adding!\n");
+#endif
+ n->addr = GNUNET_malloc(sender_address_len);
+ memcpy(n->addr, sender_address, sender_address_len);
+ n->addr_len = sender_address_len;
+ }
+
+ transmit_to_peer(NULL, TRANSPORT_DEFAULT_PRIORITY, &pong->header, GNUNET_NO, n);
+
+ GNUNET_free(pong);
+ 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,
- const struct GNUNET_PeerIdentity *peer,
- const struct GNUNET_MessageHeader *message)
+plugin_env_receive (void *cls, 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);
+ break;
+ case GNUNET_MESSAGE_TYPE_TRANSPORT_PONG:
+ handle_pong(plugin, message, peer, sender_address, sender_address_len);
+ break;
+ //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);
}
GNUNET_free (im);
}
+ else
+ {
+ fprintf(stderr, "Our hello is NULL!\n");
+ }
GNUNET_SERVER_receive_done (client, GNUNET_OK);
}
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,
slen = 0;
else
slen = strlen (address) + 1;
- GNUNET_SERVER_transmit_context_append (tc, address, slen,
- GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY);
+ GNUNET_SERVER_transmit_context_append_data (tc, address, slen,
+ GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY);
if (NULL == address)
GNUNET_SERVER_transmit_context_run (tc, GNUNET_TIME_UNIT_FOREVER_REL);
}
if (NULL == lsPlugin)
{
tc = GNUNET_SERVER_transmit_context_create (client);
- GNUNET_SERVER_transmit_context_append (tc, NULL, 0,
- GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY);
+ GNUNET_SERVER_transmit_context_append_data (tc, NULL, 0,
+ GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY);
GNUNET_SERVER_transmit_context_run (tc, rtimeout);
return;
}
{
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;
struct TransportClient *prev;
struct ClientMessageQueueEntry *mqe;
+ if (client == NULL)
+ return;
#if DEBUG_TRANSPORT
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
"Client disconnected, cleaning up.\n");
&unload_plugins, NULL);
if (no_transports)
refresh_hello ();
+
#if DEBUG_TRANSPORT
GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Transport service ready.\n"));
#endif
projects / oweals / gnunet.git / blobdiff