#define LOG(kind,...) GNUNET_log_from (kind, "transport-udp", __VA_ARGS__)
+#define PLUGIN_NAME "udp"
/**
* Number of messages we can defragment in parallel. We only really
*/
#define UDP_MAX_SENDER_ADDRESSES_WITH_DEFRAG 128
+/**
+ * Running pretty printers: head
+ */
+static struct PrettyPrinterContext *ppc_dll_head;
+/**
+ * Running pretty printers: tail
+ */
+static struct PrettyPrinterContext *ppc_dll_tail;
/**
* Closure for 'append_port'.
*/
struct PrettyPrinterContext
{
+ /**
+ * DLL
+ */
+ struct PrettyPrinterContext *next;
+
+ /**
+ * DLL
+ */
+ struct PrettyPrinterContext *prev;
+
+ /**
+ * Timeout task
+ */
+ GNUNET_SCHEDULER_TaskIdentifier timeout_task;
+
+ /**
+ * Resolver handle
+ */
+ struct GNUNET_RESOLVER_RequestHandle *resolver_handle;
+
/**
* Function to call with the result.
*/
* Port to add after the IP address.
*/
uint16_t port;
+
+ /**
+ * IPv6 address
+ */
+
+ int ipv6;
+
+ /**
+ * Options
+ */
+ uint32_t options;
};
+enum UDP_MessageType
+{
+ UNDEFINED = 0,
+ MSG_FRAGMENTED = 1,
+ MSG_FRAGMENTED_COMPLETE = 2,
+ MSG_UNFRAGMENTED = 3,
+ MSG_ACK = 4,
+ MSG_BEACON = 5
+};
+
struct Session
{
/**
/**
* expected delay for ACKs
*/
- struct GNUNET_TIME_Relative last_expected_delay;
+ struct GNUNET_TIME_Relative last_expected_ack_delay;
+
+ /**
+ * desired delay between UDP messages
+ */
+ struct GNUNET_TIME_Relative last_expected_msg_delay;
struct GNUNET_ATS_Information ats;
unsigned int rc;
int in_destroy;
+
+ int inbound;
};
* Bytes used to send all fragments on wire including UDP overhead
*/
size_t on_wire_size;
+
+ unsigned int fragments_used;
+
};
*/
struct UDP_MessageWrapper *next;
+ /**
+ * Message type
+ * According to UDP_MessageType
+ */
+ int msg_type;
+
/**
* Message with size msg_size including UDP specific overhead
*/
};
+/**
+ * Address options
+ */
+static uint32_t myoptions;
+
+
/**
* Encapsulation of all of the state of the plugin.
*/
static void
stop_session_timeout (struct Session *s);
-
/**
* (re)schedule select tasks for this plugin.
*
struct GNUNET_TIME_Relative min_delay;
struct UDP_MessageWrapper *udpw;
- if (NULL != plugin->sockv4)
+ if ((GNUNET_YES == plugin->enable_ipv4) && (NULL != plugin->sockv4))
{
/* Find a message ready to send:
* Flow delay from other peer is expired or not set (0) */
(0 == min_delay.rel_value) ? plugin->ws_v4 : NULL,
&udp_plugin_select, plugin);
}
- if (NULL != plugin->sockv6)
+ if ((GNUNET_YES == plugin->enable_ipv6) && (NULL != plugin->sockv6))
{
min_delay = GNUNET_TIME_UNIT_FOREVER_REL;
for (udpw = plugin->ipv6_queue_head; NULL != udpw; udpw = udpw->next)
const struct IPv6UdpAddress *t6;
int af;
uint16_t port;
+ uint32_t options;
+ options = 0;
if (addrlen == sizeof (struct IPv6UdpAddress))
{
t6 = addr;
af = AF_INET6;
+ options = ntohl (t6->options);
port = ntohs (t6->u6_port);
memcpy (&a6, &t6->ipv6_addr, sizeof (a6));
sb = &a6;
{
t4 = addr;
af = AF_INET;
+ options = ntohl (t4->options);
port = ntohs (t4->u4_port);
memcpy (&a4, &t4->ipv4_addr, sizeof (a4));
sb = &a4;
}
+ else if (addrlen == 0)
+ {
+ GNUNET_snprintf (rbuf, sizeof (rbuf), "%s", TRANSPORT_SESSION_INBOUND_STRING);
+ return rbuf;
+ }
else
{
- GNUNET_break_op (0);
return NULL;
}
inet_ntop (af, sb, buf, INET6_ADDRSTRLEN);
- GNUNET_snprintf (rbuf, sizeof (rbuf), (af == AF_INET6) ? "[%s]:%u" : "%s:%u",
- buf, port);
+
+ GNUNET_snprintf (rbuf, sizeof (rbuf), (af == AF_INET6) ? "%s.%u.[%s]:%u" : "%s.%u.%s:%u",
+ PLUGIN_NAME, options, buf, port);
return rbuf;
}
void **buf, size_t *added)
{
struct sockaddr_storage socket_address;
-
- if ((NULL == addr) || (0 == addrlen))
+ char *address;
+ char *plugin;
+ char *optionstr;
+ uint32_t options;
+
+ /* Format tcp.options.address:port */
+ address = NULL;
+ plugin = NULL;
+ optionstr = NULL;
+ options = 0;
+ if ((NULL == addr) || (addrlen == 0))
{
GNUNET_break (0);
return GNUNET_SYSERR;
}
-
if ('\0' != addr[addrlen - 1])
{
+ GNUNET_break (0);
return GNUNET_SYSERR;
}
-
if (strlen (addr) != addrlen - 1)
{
+ GNUNET_break (0);
+ return GNUNET_SYSERR;
+ }
+ plugin = GNUNET_strdup (addr);
+ optionstr = strchr (plugin, '.');
+ if (NULL == optionstr)
+ {
+ GNUNET_break (0);
+ GNUNET_free (plugin);
+ return GNUNET_SYSERR;
+ }
+ optionstr[0] = '\0';
+ optionstr ++;
+ options = atol (optionstr);
+ address = strchr (optionstr, '.');
+ if (NULL == address)
+ {
+ GNUNET_break (0);
+ GNUNET_free (plugin);
return GNUNET_SYSERR;
}
+ address[0] = '\0';
+ address ++;
- if (GNUNET_OK != GNUNET_STRINGS_to_address_ip (addr, strlen (addr),
- &socket_address))
+ if (GNUNET_OK !=
+ GNUNET_STRINGS_to_address_ip (address, strlen (address),
+ &socket_address))
{
+ GNUNET_break (0);
+ GNUNET_free (plugin);
return GNUNET_SYSERR;
}
+ GNUNET_free (plugin);
+
switch (socket_address.ss_family)
{
case AF_INET:
struct IPv4UdpAddress *u4;
struct sockaddr_in *in4 = (struct sockaddr_in *) &socket_address;
u4 = GNUNET_malloc (sizeof (struct IPv4UdpAddress));
+ u4->options = htonl (options);
u4->ipv4_addr = in4->sin_addr.s_addr;
u4->u4_port = in4->sin_port;
*buf = u4;
struct IPv6UdpAddress *u6;
struct sockaddr_in6 *in6 = (struct sockaddr_in6 *) &socket_address;
u6 = GNUNET_malloc (sizeof (struct IPv6UdpAddress));
+ u6->options = htonl (options);
u6->ipv6_addr = in6->sin6_addr;
u6->u6_port = in6->sin6_port;
*buf = u6;
}
+void
+ppc_cancel_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+ struct PrettyPrinterContext *ppc = cls;
+ /* GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "PPC %p was not removed!\n", ppc); */
+ ppc->timeout_task = GNUNET_SCHEDULER_NO_TASK;
+ if (NULL != ppc->resolver_handle)
+ {
+ GNUNET_RESOLVER_request_cancel (ppc->resolver_handle);
+ ppc->resolver_handle = NULL;
+ }
+
+ GNUNET_CONTAINER_DLL_remove (ppc_dll_head, ppc_dll_tail, ppc);
+ GNUNET_free (ppc);
+}
+
+
/**
* Append our port and forward the result.
*
append_port (void *cls, const char *hostname)
{
struct PrettyPrinterContext *ppc = cls;
+ struct PrettyPrinterContext *cur;
char *ret;
-
+ /* GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "PPC callback: %p `%s'\n",ppc, hostname); */
if (hostname == NULL)
{
ppc->asc (ppc->asc_cls, NULL);
+ GNUNET_CONTAINER_DLL_remove (ppc_dll_head, ppc_dll_tail, ppc);
+ GNUNET_SCHEDULER_cancel (ppc->timeout_task);
+ ppc->timeout_task = GNUNET_SCHEDULER_NO_TASK;
+ ppc->resolver_handle = NULL;
+ /* GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "PPC %p was removed!\n", ppc); */
GNUNET_free (ppc);
return;
}
- GNUNET_asprintf (&ret, "%s:%d", hostname, ppc->port);
+ for (cur = ppc_dll_head; (NULL != cur); cur = cur->next)
+ {
+ if (cur == ppc)
+ break;
+ }
+ if (NULL == cur)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Invalid callback for PPC %p \n", ppc);
+ return;
+ }
+
+ if (GNUNET_YES == ppc->ipv6)
+ GNUNET_asprintf (&ret, "%s.%u.[%s]:%d", PLUGIN_NAME, ppc->options, hostname, ppc->port);
+ else
+ GNUNET_asprintf (&ret, "%s.%u.%s:%d", PLUGIN_NAME, ppc->options, hostname, ppc->port);
ppc->asc (ppc->asc_cls, ret);
GNUNET_free (ret);
}
-
/**
* Convert the transports address to a nice, human-readable
* format.
const struct IPv4UdpAddress *u4;
const struct IPv6UdpAddress *u6;
uint16_t port;
+ uint32_t options;
+ options = 0;
if (addrlen == sizeof (struct IPv6UdpAddress))
{
u6 = addr;
a6.sin6_port = u6->u6_port;
memcpy (&a6.sin6_addr, &u6->ipv6_addr, sizeof (struct in6_addr));
port = ntohs (u6->u6_port);
+ options = ntohl (u6->options);
sb = &a6;
sbs = sizeof (a6);
}
a4.sin_port = u4->u4_port;
a4.sin_addr.s_addr = u4->ipv4_addr;
port = ntohs (u4->u4_port);
+ options = ntohl (u4->options);
sb = &a4;
sbs = sizeof (a4);
}
else if (0 == addrlen)
{
- asc (asc_cls, "<inbound connection>");
+ asc (asc_cls, TRANSPORT_SESSION_INBOUND_STRING);
asc (asc_cls, NULL);
return;
}
ppc->asc = asc;
ppc->asc_cls = asc_cls;
ppc->port = port;
- GNUNET_RESOLVER_hostname_get (sb, sbs, !numeric, timeout, &append_port, ppc);
+ ppc->options = options;
+ if (addrlen == sizeof (struct IPv6UdpAddress))
+ ppc->ipv6 = GNUNET_YES;
+ else
+ ppc->ipv6 = GNUNET_NO;
+ ppc->timeout_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(timeout, 2),
+ &ppc_cancel_task, ppc);
+ GNUNET_CONTAINER_DLL_insert (ppc_dll_head, ppc_dll_tail, ppc);
+ /* GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "PPC %p was created!\n", ppc); */
+ ppc->resolver_handle = GNUNET_RESOLVER_hostname_get (sb, sbs, !numeric, timeout, &append_port, ppc);
+
}
static void
call_continuation (struct UDP_MessageWrapper *udpw, int result)
{
+ size_t overhead;
+
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Calling continuation for %u byte message to `%s' with result %s\n",
udpw->payload_size, GNUNET_i2s (&udpw->session->target),
(GNUNET_OK == result) ? "OK" : "SYSERR");
- if (NULL == udpw->frag_ctx)
- {
- /* Not fragmented message */
- if (GNUNET_OK == result)
- {
- GNUNET_STATISTICS_update (plugin->env->stats,
- "# unfragmented messages transmit with success via UDP",
- 1, GNUNET_NO);
- if (udpw->msg_size >= udpw->payload_size)
- {
- GNUNET_STATISTICS_update (plugin->env->stats,
- "# bytes overhead transmitted via UDP",
- udpw->msg_size - udpw->payload_size, GNUNET_NO);
- }
- GNUNET_STATISTICS_update (plugin->env->stats,
- "# bytes payload transmitted via UDP",
- udpw->payload_size, GNUNET_NO);
- }
- else
- {
+ if (udpw->msg_size >= udpw->payload_size)
+ overhead = udpw->msg_size - udpw->payload_size;
+ else
+ overhead = udpw->msg_size;
+
+ switch (result) {
+ case GNUNET_OK:
+ switch (udpw->msg_type) {
+ case MSG_UNFRAGMENTED:
+ if (NULL != udpw->cont)
+ {
+ /* Transport continuation */
+ udpw->cont (udpw->cont_cls, &udpw->session->target, result,
+ udpw->payload_size, udpw->msg_size);
+ }
GNUNET_STATISTICS_update (plugin->env->stats,
- "# unfragmented messages transmit with failure via UDP",
+ "# UDP, unfragmented msgs, messages, sent, success",
1, GNUNET_NO);
- }
- if (NULL != udpw->cont)
- udpw->cont (udpw->cont_cls, &udpw->session->target, result,
- udpw->payload_size, udpw->msg_size);
- }
- else
- {
- /* Fragmented message */
- if (GNUNET_OK == result)
- {
- /* Fragmented message: only call next_fragment continuation on success */
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, unfragmented msgs, bytes payload, sent, success",
+ udpw->payload_size, GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, unfragmented msgs, bytes overhead, sent, success",
+ overhead, GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, total, bytes overhead, sent",
+ overhead, GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, total, bytes payload, sent",
+ udpw->payload_size, GNUNET_NO);
+ break;
+ case MSG_FRAGMENTED_COMPLETE:
+ GNUNET_assert (NULL != udpw->frag_ctx);
+ if (udpw->frag_ctx->cont != NULL)
+ udpw->frag_ctx->cont (udpw->frag_ctx->cont_cls, &udpw->session->target, GNUNET_OK,
+ udpw->frag_ctx->payload_size, udpw->frag_ctx->on_wire_size);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, fragmented msgs, messages, sent, success",
+ 1, GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, fragmented msgs, bytes payload, sent, success",
+ udpw->payload_size, GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, fragmented msgs, bytes overhead, sent, success",
+ overhead, GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, total, bytes overhead, sent",
+ overhead, GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, total, bytes payload, sent",
+ udpw->payload_size, GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, fragmented msgs, messages, pending",
+ -1, GNUNET_NO);
+ break;
+ case MSG_FRAGMENTED:
+ /* Fragmented message: enqueue next fragment */
if (NULL != udpw->cont)
udpw->cont (udpw->cont_cls, &udpw->session->target, result,
udpw->payload_size, udpw->msg_size);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, fragmented msgs, fragments, sent, success",
+ 1, GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, fragmented msgs, fragments bytes, sent, success",
+ udpw->msg_size, GNUNET_NO);
+ break;
+ case MSG_ACK:
+ /* No continuation */
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, ACK msgs, messages, sent, success",
+ 1, GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, ACK msgs, bytes overhead, sent, success",
+ overhead, GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, total, bytes overhead, sent",
+ overhead, GNUNET_NO);
+ break;
+ case MSG_BEACON:
+ GNUNET_break (0);
+ break;
+ default:
+ LOG (GNUNET_ERROR_TYPE_ERROR,
+ "ERROR: %u\n", udpw->msg_type);
+ GNUNET_break (0);
+ break;
}
+ break;
+ case GNUNET_SYSERR:
+ switch (udpw->msg_type) {
+ case MSG_UNFRAGMENTED:
+ /* Unfragmented message: failed to send */
+ if (NULL != udpw->cont)
+ udpw->cont (udpw->cont_cls, &udpw->session->target, result,
+ udpw->payload_size, overhead);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, unfragmented msgs, messages, sent, failure",
+ 1, GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, unfragmented msgs, bytes payload, sent, failure",
+ udpw->payload_size, GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, unfragmented msgs, bytes overhead, sent, failure",
+ overhead, GNUNET_NO);
+ break;
+ case MSG_FRAGMENTED_COMPLETE:
+ GNUNET_assert (NULL != udpw->frag_ctx);
+ if (udpw->frag_ctx->cont != NULL)
+ udpw->frag_ctx->cont (udpw->frag_ctx->cont_cls, &udpw->session->target, GNUNET_SYSERR,
+ udpw->frag_ctx->payload_size, udpw->frag_ctx->on_wire_size);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, fragmented msgs, messages, sent, failure",
+ 1, GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, fragmented msgs, bytes payload, sent, failure",
+ udpw->payload_size, GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, fragmented msgs, bytes payload, sent, failure",
+ overhead, GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, fragmented msgs, bytes payload, sent, failure",
+ overhead, GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, fragmented msgs, messages, pending",
+ -1, GNUNET_NO);
+ break;
+ case MSG_FRAGMENTED:
+ GNUNET_assert (NULL != udpw->frag_ctx);
+ /* Fragmented message: failed to send */
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, fragmented msgs, fragments, sent, failure",
+ 1, GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, fragmented msgs, fragments bytes, sent, failure",
+ udpw->msg_size, GNUNET_NO);
+ break;
+ case MSG_ACK:
+ /* ACK message: failed to send */
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, ACK msgs, messages, sent, failure",
+ 1, GNUNET_NO);
+ break;
+ case MSG_BEACON:
+ /* Beacon message: failed to send */
+ GNUNET_break (0);
+ break;
+ default:
+ GNUNET_break (0);
+ break;
+ }
+ break;
+ default:
+ GNUNET_break (0);
+ break;
}
}
if ((addrlen != sizeof (struct IPv4UdpAddress)) &&
(addrlen != sizeof (struct IPv6UdpAddress)))
{
- GNUNET_break_op (0);
return GNUNET_SYSERR;
}
if (addrlen == sizeof (struct IPv4UdpAddress))
static void
free_session (struct Session *s)
{
- if (s->frag_ctx != NULL)
+ if (NULL != s->frag_ctx)
{
- GNUNET_FRAGMENT_context_destroy(s->frag_ctx->frag);
+ GNUNET_FRAGMENT_context_destroy(s->frag_ctx->frag, NULL, NULL);
GNUNET_free (s->frag_ctx);
s->frag_ctx = NULL;
}
static void
dequeue (struct Plugin *plugin, struct UDP_MessageWrapper * udpw)
{
+ if (plugin->bytes_in_buffer < udpw->msg_size)
+ GNUNET_break (0);
+ else
+ {
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, total, bytes in buffers",
+ - (long long) udpw->msg_size, GNUNET_NO);
+ plugin->bytes_in_buffer -= udpw->msg_size;
+ }
GNUNET_STATISTICS_update (plugin->env->stats,
- "# bytes currently in UDP buffers",
- -udpw->msg_size, GNUNET_NO);
- GNUNET_STATISTICS_update (plugin->env->stats,
- "# msgs currently in UDP buffers",
+ "# UDP, total, msgs in buffers",
-1, GNUNET_NO);
if (udpw->session->addrlen == sizeof (struct sockaddr_in))
GNUNET_CONTAINER_DLL_remove (plugin->ipv4_queue_head,
plugin->ipv6_queue_tail, udpw);
}
+static void
+fragmented_message_done (struct UDP_FragmentationContext *fc, int result)
+{
+ struct UDP_MessageWrapper *udpw;
+ struct UDP_MessageWrapper *tmp;
+ struct UDP_MessageWrapper dummy;
+ struct Session *s = fc->session;
+
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "%p : Fragmented message removed with result %s\n", fc, (result == GNUNET_SYSERR) ? "FAIL" : "SUCCESS");
+
+ /* Call continuation for fragmented message */
+ memset (&dummy, 0, sizeof (dummy));
+ dummy.msg_type = MSG_FRAGMENTED_COMPLETE;
+ dummy.msg_size = s->frag_ctx->on_wire_size;
+ dummy.payload_size = s->frag_ctx->payload_size;
+ dummy.frag_ctx = s->frag_ctx;
+ dummy.cont = NULL;
+ dummy.cont_cls = NULL;
+ dummy.session = s;
+
+ call_continuation (&dummy, result);
+
+ /* Remove leftover fragments from queue */
+ if (s->addrlen == sizeof (struct sockaddr_in6))
+ {
+ udpw = plugin->ipv6_queue_head;
+ while (NULL != udpw)
+ {
+ tmp = udpw->next;
+ if ((udpw->frag_ctx != NULL) && (udpw->frag_ctx == s->frag_ctx))
+ {
+ dequeue (plugin, udpw);
+ call_continuation (udpw, GNUNET_SYSERR);
+ GNUNET_free (udpw);
+ }
+ udpw = tmp;
+ }
+ }
+ if (s->addrlen == sizeof (struct sockaddr_in))
+ {
+ udpw = plugin->ipv4_queue_head;
+ while (udpw!= NULL)
+ {
+ tmp = udpw->next;
+ if ((NULL != udpw->frag_ctx) && (udpw->frag_ctx == s->frag_ctx))
+ {
+ dequeue (plugin, udpw);
+ call_continuation (udpw, GNUNET_SYSERR);
+ GNUNET_free (udpw);
+ }
+ udpw = tmp;
+ }
+ }
+
+ /* Destroy fragmentation context */
+ GNUNET_FRAGMENT_context_destroy (fc->frag,
+ &s->last_expected_msg_delay,
+ &s->last_expected_ack_delay);
+ s->frag_ctx = NULL;
+ GNUNET_free (fc );
+}
+
/**
* Functions with this signature are called whenever we need
* to close a session due to a disconnect or failure to
GNUNET_i2s (&s->target),
GNUNET_a2s (s->sock_addr, s->addrlen));
stop_session_timeout (s);
+
+ if (NULL != s->frag_ctx)
+ {
+ /* Remove fragmented message due to disconnect */
+ fragmented_message_done (s->frag_ctx, GNUNET_SYSERR);
+ }
+
next = plugin->ipv4_queue_head;
while (NULL != (udpw = next))
{
&s->target.hashPubKey,
s));
GNUNET_STATISTICS_set(plugin->env->stats,
- "# UDP sessions active",
+ "# UDP, sessions active",
GNUNET_CONTAINER_multihashmap_size(plugin->sessions),
GNUNET_NO);
if (s->rc > 0)
case sizeof (struct IPv4UdpAddress):
if (NULL == plugin->sockv4)
{
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Could not create session for peer `%s' address `%s': IPv4 is not enabled\n",
+ GNUNET_i2s(target),
+ udp_address_to_string(NULL, addr, addrlen));
return NULL;
}
t4 = addr;
case sizeof (struct IPv6UdpAddress):
if (NULL == plugin->sockv6)
{
+ LOG (GNUNET_ERROR_TYPE_INFO,
+ "Could not create session for peer `%s' address `%s': IPv6 is not enabled\n",
+ GNUNET_i2s(target),
+ udp_address_to_string(NULL, addr, addrlen));
return NULL;
}
t6 = addr;
break;
default:
/* Must have a valid address to send to */
- GNUNET_break_op (0);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ gettext_noop
+ ("# requests to create session with invalid address"),
+ 1, GNUNET_NO);
return NULL;
}
s->addrlen = len;
s->target = *target;
s->sock_addr = (const struct sockaddr *) &s[1];
- s->last_expected_delay = GNUNET_TIME_UNIT_SECONDS;
+ s->last_expected_ack_delay = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 250);
+ s->last_expected_msg_delay = GNUNET_TIME_UNIT_MILLISECONDS;
s->flow_delay_from_other_peer = GNUNET_TIME_UNIT_ZERO_ABS;
s->flow_delay_for_other_peer = GNUNET_TIME_UNIT_ZERO;
+ s->inbound = GNUNET_NO;
start_session_timeout (s);
return s;
}
}
+/**
+ * Function obtain the network type for a session
+ *
+ * @param cls closure ('struct Plugin*')
+ * @param session the session
+ * @return the network type in HBO or GNUNET_SYSERR
+ */
+static enum GNUNET_ATS_Network_Type
+udp_get_network (void *cls,
+ struct Session *session)
+{
+ return ntohl (session->ats.value);
+}
+
+
/**
* Creates a new outbound session the transport service will use to send data to the
* peer
* @return the session or NULL of max connections exceeded
*/
static struct Session *
-udp_plugin_get_session (void *cls,
- const struct GNUNET_HELLO_Address *address)
+udp_plugin_lookup_session (void *cls,
+ const struct GNUNET_HELLO_Address *address)
{
- struct Session * s = NULL;
struct Plugin * plugin = cls;
struct IPv6UdpAddress * udp_a6;
struct IPv4UdpAddress * udp_a4;
((address->address_length != sizeof (struct IPv4UdpAddress)) &&
(address->address_length != sizeof (struct IPv6UdpAddress))))
{
- GNUNET_break (0);
+ LOG (GNUNET_ERROR_TYPE_WARNING,
+ _("Trying to create session for address of unexpected length %u (should be %u or %u)\n"),
+ address->address_length,
+ sizeof (struct IPv4UdpAddress),
+ sizeof (struct IPv6UdpAddress));
return NULL;
}
LOG (GNUNET_ERROR_TYPE_DEBUG, "Found existing session %p\n", cctx.res);
return cctx.res;
}
+ return NULL;
+}
+
+static struct Session *
+udp_plugin_create_session (void *cls,
+ const struct GNUNET_HELLO_Address *address)
+{
+ struct Session * s = NULL;
/* otherwise create new */
s = create_session (plugin,
address->address,
address->address_length,
NULL, NULL);
+ if (NULL == s)
+ return NULL; /* protocol not supported or address invalid */
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Creating new session %p for peer `%s' address `%s'\n",
s,
s,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
GNUNET_STATISTICS_set(plugin->env->stats,
- "# UDP sessions active",
+ "# UDP, sessions active",
GNUNET_CONTAINER_multihashmap_size(plugin->sessions),
GNUNET_NO);
return s;
}
+
+/**
+ * Creates a new outbound session the transport service will use to send data to the
+ * peer
+ *
+ * @param cls the plugin
+ * @param address the address
+ * @return the session or NULL of max connections exceeded
+ */
+static struct Session *
+udp_plugin_get_session (void *cls,
+ const struct GNUNET_HELLO_Address *address)
+{
+ struct Session * s = NULL;
+
+ if (NULL == address)
+ {
+ GNUNET_break (0);
+ return NULL;
+ }
+ if ((address->address_length != sizeof (struct IPv4UdpAddress)) &&
+ (address->address_length != sizeof (struct IPv6UdpAddress)))
+ return NULL;
+
+ /* otherwise create new */
+ if (NULL != (s = udp_plugin_lookup_session(cls, address)))
+ return s;
+ else
+ return udp_plugin_create_session (cls, address);
+}
+
+
static void
enqueue (struct Plugin *plugin, struct UDP_MessageWrapper * udpw)
{
+ if (plugin->bytes_in_buffer + udpw->msg_size > INT64_MAX)
+ GNUNET_break (0);
+ else
+ {
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, total, bytes in buffers",
+ udpw->msg_size, GNUNET_NO);
+ plugin->bytes_in_buffer += udpw->msg_size;
+ }
GNUNET_STATISTICS_update (plugin->env->stats,
- "# bytes currently in UDP buffers",
- udpw->msg_size, GNUNET_NO);
- GNUNET_STATISTICS_update (plugin->env->stats,
- "# msgs currently in UDP buffers",
+ "# UDP, total, msgs in buffers",
1, GNUNET_NO);
if (udpw->session->addrlen == sizeof (struct sockaddr_in))
GNUNET_CONTAINER_DLL_insert (plugin->ipv4_queue_head,
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Enqueuing fragment with %u bytes\n", msg_len);
+ frag_ctx->fragments_used ++;
udpw = GNUNET_malloc (sizeof (struct UDP_MessageWrapper) + msg_len);
udpw->session = frag_ctx->session;
udpw->msg_buf = (char *) &udpw[1];
udpw->cont_cls = udpw;
udpw->timeout = frag_ctx->timeout;
udpw->frag_ctx = frag_ctx;
+ udpw->msg_type = MSG_FRAGMENTED;
memcpy (udpw->msg_buf, msg, msg_len);
enqueue (plugin, udpw);
schedule_select (plugin);
udpmlen,
GNUNET_i2s (&s->target),
GNUNET_a2s(s->sock_addr, s->addrlen));
-
- GNUNET_STATISTICS_update (plugin->env->stats,
- "# bytes payload asked to transmit via UDP",
- msgbuf_size, GNUNET_NO);
+
/* Message */
udp = (struct UDPMessage *) mbuf;
if (udpmlen <= UDP_MTU)
{
/* unfragmented message */
- GNUNET_STATISTICS_update (plugin->env->stats,
- "# unfragmented messages asked to transmit via UDP",
- 1, GNUNET_NO);
udpw = GNUNET_malloc (sizeof (struct UDP_MessageWrapper) + udpmlen);
udpw->session = s;
udpw->msg_buf = (char *) &udpw[1];
udpw->cont = cont;
udpw->cont_cls = cont_cls;
udpw->frag_ctx = NULL;
+ udpw->msg_type = MSG_UNFRAGMENTED;
memcpy (udpw->msg_buf, udp, sizeof (struct UDPMessage));
memcpy (&udpw->msg_buf[sizeof (struct UDPMessage)], msgbuf, msgbuf_size);
enqueue (plugin, udpw);
+
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, unfragmented msgs, messages, attempt",
+ 1, GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, unfragmented msgs, bytes payload, attempt",
+ udpw->payload_size, GNUNET_NO);
}
else
{
/* fragmented message */
- GNUNET_STATISTICS_update (plugin->env->stats,
- "# fragmented messages asked to transmit via UDP",
- 1, GNUNET_NO);
if (s->frag_ctx != NULL)
return GNUNET_SYSERR;
memcpy (&udp[1], msgbuf, msgbuf_size);
frag_ctx->payload_size = msgbuf_size; /* unfragmented message size without UDP overhead */
frag_ctx->on_wire_size = 0; /* bytes with UDP and fragmentation overhead */
frag_ctx->frag = GNUNET_FRAGMENT_context_create (plugin->env->stats,
- UDP_MTU,
- &plugin->tracker,
- s->last_expected_delay,
- &udp->header,
- &enqueue_fragment,
- frag_ctx);
+ UDP_MTU,
+ &plugin->tracker,
+ s->last_expected_msg_delay,
+ s->last_expected_ack_delay,
+ &udp->header,
+ &enqueue_fragment,
+ frag_ctx);
s->frag_ctx = frag_ctx;
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, fragmented msgs, messages, pending",
+ 1, GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, fragmented msgs, messages, attempt",
+ 1, GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, fragmented msgs, bytes payload, attempt",
+ frag_ctx->payload_size, GNUNET_NO);
}
schedule_select (plugin);
return udpmlen;
void *arg;
size_t args;
+ LOG (GNUNET_ERROR_TYPE_INFO,
+ "NAT notification to %s address `%s'\n",
+ (GNUNET_YES == add_remove) ? "add" : "remove",
+ GNUNET_a2s (addr, addrlen));
+
/* convert 'addr' to our internal format */
switch (addr->sa_family)
{
case AF_INET:
GNUNET_assert (addrlen == sizeof (struct sockaddr_in));
+ memset (&u4, 0, sizeof (u4));
+ u4.options = htonl(myoptions);
u4.ipv4_addr = ((struct sockaddr_in *) addr)->sin_addr.s_addr;
u4.u4_port = ((struct sockaddr_in *) addr)->sin_port;
+ if (0 == ((struct sockaddr_in *) addr)->sin_port)
+ return;
arg = &u4;
- args = sizeof (u4);
+ args = sizeof (struct IPv4UdpAddress);
break;
case AF_INET6:
GNUNET_assert (addrlen == sizeof (struct sockaddr_in6));
+ memset (&u4, 0, sizeof (u4));
+ u6.options = htonl(myoptions);
+ if (0 == ((struct sockaddr_in6 *) addr)->sin6_port)
+ return;
memcpy (&u6.ipv6_addr, &((struct sockaddr_in6 *) addr)->sin6_addr,
sizeof (struct in6_addr));
u6.u6_port = ((struct sockaddr_in6 *) addr)->sin6_port;
arg = &u6;
- args = sizeof (u6);
+ args = sizeof (struct IPv6UdpAddress);
break;
default:
GNUNET_break (0);
{
struct Plugin *plugin = cls;
struct SourceInformation *si = client;
- struct GNUNET_ATS_Information ats[2];
struct GNUNET_TIME_Relative delay;
GNUNET_assert (si->session != NULL);
if (GNUNET_YES == si->session->in_destroy)
return GNUNET_OK;
/* setup ATS */
- ats[0].type = htonl (GNUNET_ATS_QUALITY_NET_DISTANCE);
- ats[0].value = htonl (1);
- ats[1] = si->session->ats;
- GNUNET_break (ntohl(ats[1].value) != GNUNET_ATS_NET_UNSPECIFIED);
+ GNUNET_break (ntohl(si->session->ats.value) != GNUNET_ATS_NET_UNSPECIFIED);
delay = plugin->env->receive (plugin->env->cls,
&si->sender,
hdr,
- (const struct GNUNET_ATS_Information *) &ats, 2,
si->session,
- si->arg,
- si->args);
+ (GNUNET_YES == si->session->inbound) ? NULL : si->arg,
+ (GNUNET_YES == si->session->inbound) ? 0 : si->args);
+
+ plugin->env->update_address_metrics (plugin->env->cls,
+ &si->sender,
+ (GNUNET_YES == si->session->inbound) ? NULL : si->arg,
+ (GNUNET_YES == si->session->inbound) ? 0 : si->args,
+ si->session,
+ &si->session->ats, 1);
+
si->session->flow_delay_for_other_peer = delay;
reschedule_session_timeout(si->session);
return GNUNET_OK;
{
case AF_INET:
GNUNET_assert (sender_addr_len == sizeof (struct sockaddr_in));
+ memset (&u4, 0, sizeof (u4));
+ u6.options = htonl (0);
u4.ipv4_addr = ((struct sockaddr_in *) sender_addr)->sin_addr.s_addr;
u4.u4_port = ((struct sockaddr_in *) sender_addr)->sin_port;
arg = &u4;
break;
case AF_INET6:
GNUNET_assert (sender_addr_len == sizeof (struct sockaddr_in6));
+ memset (&u6, 0, sizeof (u6));
+ u6.options = htonl (0);
u6.ipv6_addr = ((struct sockaddr_in6 *) sender_addr)->sin6_addr;
u6.u6_port = ((struct sockaddr_in6 *) sender_addr)->sin6_port;
arg = &u6;
GNUNET_a2s (sender_addr, sender_addr_len));
struct GNUNET_HELLO_Address * address = GNUNET_HELLO_address_allocate(&msg->sender, "udp", arg, args);
- s = udp_plugin_get_session(plugin, address);
+ if (NULL == (s = udp_plugin_lookup_session (plugin, address)))
+ {
+ s = udp_plugin_create_session(plugin, address);
+ s->inbound = GNUNET_YES;
+ plugin->env->session_start (NULL, &address->peer, PLUGIN_NAME,
+ (GNUNET_YES == s->inbound) ? NULL : address->address,
+ (GNUNET_YES == s->inbound) ? 0 : address->address_length,
+ s, NULL, 0);
+ }
GNUNET_free (address);
/* iterate over all embedded messages */
uint32_t delay = 0;
struct UDP_MessageWrapper *udpw;
struct Session *s;
-
struct LookupContext l_ctx;
+
l_ctx.addr = rc->src_addr;
l_ctx.addrlen = rc->addr_len;
l_ctx.res = NULL;
udpw->session = s;
udpw->timeout = GNUNET_TIME_UNIT_FOREVER_ABS;
udpw->msg_buf = (char *)&udpw[1];
+ udpw->msg_type = MSG_ACK;
udp_ack = (struct UDP_ACK_Message *) udpw->msg_buf;
udp_ack->header.size = htons ((uint16_t) msize);
udp_ack->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_ACK);
udp_ack->delay = htonl (delay);
udp_ack->sender = *rc->plugin->env->my_identity;
memcpy (&udp_ack[1], msg, ntohs (msg->size));
-
- GNUNET_STATISTICS_update (plugin->env->stats,
- "# messages ACKs transmitted via UDP",
- 1, GNUNET_NO);
-
enqueue (rc->plugin, udpw);
}
l_ctx.addrlen = fromlen;
l_ctx.res = NULL;
GNUNET_CONTAINER_multihashmap_iterate (plugin->sessions,
- &lookup_session_by_addr_it,
- &l_ctx);
+ &lookup_session_by_addr_it,
+ &l_ctx);
s = l_ctx.res;
- if ((s == NULL) || (s->frag_ctx == NULL))
+ if ((NULL == s) || (NULL == s->frag_ctx))
+ {
return;
+ }
flow_delay.rel_value = (uint64_t) ntohl (udp_ack->delay);
- LOG (GNUNET_ERROR_TYPE_DEBUG, "We received a sending delay of %llu\n",
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "We received a sending delay of %llu\n",
flow_delay.rel_value);
s->flow_delay_from_other_peer =
GNUNET_TIME_relative_to_absolute (flow_delay);
return;
}
+ if (0 != memcmp (&l_ctx.res->target, &udp_ack->sender, sizeof (struct GNUNET_PeerIdentity)))
+ GNUNET_break (0);
if (GNUNET_OK != GNUNET_FRAGMENT_process_ack (s->frag_ctx->frag, ack))
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Message full ACK'ed\n",
(unsigned int) ntohs (msg->size), GNUNET_i2s (&udp_ack->sender),
GNUNET_a2s ((const struct sockaddr *) addr, fromlen));
- s->last_expected_delay = GNUNET_FRAGMENT_context_destroy (s->frag_ctx->frag);
-
- struct UDP_MessageWrapper * udpw;
- struct UDP_MessageWrapper * tmp;
- if (s->addrlen == sizeof (struct sockaddr_in6))
- {
- udpw = plugin->ipv6_queue_head;
- while (NULL != udpw)
- {
- tmp = udpw->next;
- if ((udpw->frag_ctx != NULL) && (udpw->frag_ctx == s->frag_ctx))
- {
- dequeue (plugin, udpw);
- GNUNET_free (udpw);
- }
- udpw = tmp;
- }
- }
- if (s->addrlen == sizeof (struct sockaddr_in))
- {
- udpw = plugin->ipv4_queue_head;
- while (udpw!= NULL)
- {
- tmp = udpw->next;
- if ((udpw->frag_ctx != NULL) && (udpw->frag_ctx == s->frag_ctx))
- {
- dequeue (plugin, udpw);
- GNUNET_free (udpw);
- }
- udpw = tmp;
- }
- }
-
- GNUNET_STATISTICS_update (plugin->env->stats,
- "# bytes payload transmitted via UDP",
- s->frag_ctx->payload_size, GNUNET_NO);
- if (s->frag_ctx->on_wire_size >= s->frag_ctx->payload_size)
- {
- GNUNET_STATISTICS_update (plugin->env->stats,
- "# bytes overhead transmitted via UDP",
- s->frag_ctx->on_wire_size - s->frag_ctx->payload_size, GNUNET_NO);
- }
-
- if (s->frag_ctx->cont != NULL)
- {
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Calling continuation for fragmented message to `%s' with result %s\n",
- GNUNET_i2s (&s->target), "OK");
-
- s->frag_ctx->cont (s->frag_ctx->cont_cls, &udp_ack->sender, GNUNET_OK,
- s->frag_ctx->payload_size, s->frag_ctx->on_wire_size);
- }
-
- GNUNET_free (s->frag_ctx);
- s->frag_ctx = NULL;
+ /* Remove fragmented message after successful sending */
+ fragmented_message_done (s->frag_ctx, GNUNET_OK);
}
(struct sockaddr *) &addr, &fromlen);
#if MINGW
/* On SOCK_DGRAM UDP sockets recvfrom might fail with a
- * WSAECONNRESET error to indicate that previous sendto() (???)
+ * WSAECONNRESET error to indicate that previous sendto() (yes, sendto!)
* on this socket has failed.
+ * Quote from MSDN:
+ * WSAECONNRESET - The virtual circuit was reset by the remote side
+ * executing a hard or abortive close. The application should close
+ * the socket; it is no longer usable. On a UDP-datagram socket this
+ * error indicates a previous send operation resulted in an ICMP Port
+ * Unreachable message.
*/
if ( (-1 == size) && (ECONNRESET == errno) )
return;
#endif
- if ( (-1 == size) || (size < sizeof (struct GNUNET_MessageHeader)))
+ if (-1 == size)
{
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "UDP failed to receive data: %s\n", STRERROR (errno));
+ /* Connection failure or something. Not a protocol violation. */
+ return;
+ }
+ if (size < sizeof (struct GNUNET_MessageHeader))
+ {
+ LOG (GNUNET_ERROR_TYPE_WARNING,
+ "UDP got %u bytes, which is not enough for a GNUnet message header\n",
+ (unsigned int) size);
+ /* _MAY_ be a connection failure (got partial message) */
+ /* But it _MAY_ also be that the other side uses non-GNUnet protocol. */
GNUNET_break_op (0);
return;
}
}
GNUNET_STATISTICS_update (plugin->env->stats,
- "# bytes received via UDP",
+ "# UDP, total, bytes, received",
size, GNUNET_NO);
switch (ntohs (msg->type))
if (GNUNET_TIME_UNIT_ZERO.rel_value == remaining.rel_value)
{
/* Message timed out */
- call_continuation (udpw, GNUNET_SYSERR);
- if (NULL == udpw->frag_ctx)
- {
- /* Not fragmented message */
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Message for peer `%s' with size %u timed out\n",
- GNUNET_i2s(&udpw->session->target), udpw->payload_size);
- }
- else
- {
+ switch (udpw->msg_type) {
+ case MSG_UNFRAGMENTED:
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, total, bytes, sent, timeout",
+ udpw->msg_size, GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, total, messages, sent, timeout",
+ 1, GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, unfragmented msgs, messages, sent, timeout",
+ 1, GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, unfragmented msgs, bytes, sent, timeout",
+ udpw->payload_size, GNUNET_NO);
+ /* Not fragmented message */
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Message for peer `%s' with size %u timed out\n",
+ GNUNET_i2s(&udpw->session->target), udpw->payload_size);
+ call_continuation (udpw, GNUNET_SYSERR);
+ /* Remove message */
+ dequeue (plugin, udpw);
+ GNUNET_free (udpw);
+ break;
+ case MSG_FRAGMENTED:
/* Fragmented message */
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, total, bytes, sent, timeout",
+ udpw->frag_ctx->on_wire_size, GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, total, messages, sent, timeout",
+ 1, GNUNET_NO);
+ call_continuation (udpw, GNUNET_SYSERR);
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Fragment for message for peer `%s' with size %u timed out\n",
GNUNET_i2s(&udpw->session->target), udpw->frag_ctx->payload_size);
- udpw->session->last_expected_delay = GNUNET_FRAGMENT_context_destroy (udpw->frag_ctx->frag);
- GNUNET_free (udpw->frag_ctx);
- udpw->session->frag_ctx = NULL;
- }
- GNUNET_STATISTICS_update (plugin->env->stats,
- "# messages dismissed due to timeout",
- 1, GNUNET_NO);
- /* Remove message */
+
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, fragmented msgs, messages, sent, timeout",
+ 1, GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, fragmented msgs, bytes, sent, timeout",
+ udpw->frag_ctx->payload_size, GNUNET_NO);
+ /* Remove fragmented message due to timeout */
+ fragmented_message_done (udpw->frag_ctx, GNUNET_SYSERR);
+ break;
+ case MSG_ACK:
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, total, bytes, sent, timeout",
+ udpw->msg_size, GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, total, messages, sent, timeout",
+ 1, GNUNET_NO);
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "ACK Message for peer `%s' with size %u timed out\n",
+ GNUNET_i2s(&udpw->session->target), udpw->payload_size);
+ call_continuation (udpw, GNUNET_SYSERR);
+ dequeue (plugin, udpw);
+ GNUNET_free (udpw);
+ break;
+ default:
+ break;
+ }
if (sock == plugin->sockv4)
- {
- dequeue (plugin, udpw);
- GNUNET_free (udpw);
udpw = plugin->ipv4_queue_head;
- }
- if (sock == plugin->sockv6)
- {
- dequeue (plugin, udpw);
- GNUNET_free (udpw);
+ else if (sock == plugin->sockv6)
udpw = plugin->ipv6_queue_head;
+ else
+ {
+ GNUNET_break (0); /* should never happen */
+ udpw = NULL;
}
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# messages dismissed due to timeout",
+ 1, GNUNET_NO);
}
else
{
/* Failure */
analyze_send_error (plugin, sa, slen, errno);
call_continuation(udpw, GNUNET_SYSERR);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, total, bytes, sent, failure",
+ sent, GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, total, messages, sent, failure",
+ 1, GNUNET_NO);
}
else
{
(unsigned int) (udpw->msg_size), GNUNET_i2s(&udpw->session->target) ,GNUNET_a2s (sa, slen), (int) sent,
(sent < 0) ? STRERROR (errno) : "ok");
GNUNET_STATISTICS_update (plugin->env->stats,
- "# bytes transmitted via UDP",
+ "# UDP, total, bytes, sent, success",
sent, GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, total, messages, sent, success",
+ 1, GNUNET_NO);
if (NULL != udpw->frag_ctx)
udpw->frag_ctx->on_wire_size += udpw->msg_size;
call_continuation (udpw, GNUNET_OK);
}
+/**
+ *
+ * @return number of sockets that were successfully bound
+ */
static int
-setup_sockets (struct Plugin *plugin, struct sockaddr_in6 *serverAddrv6, struct sockaddr_in *serverAddrv4)
+setup_sockets (struct Plugin *plugin,
+ const struct sockaddr_in6 *bind_v6,
+ const struct sockaddr_in *bind_v4)
{
int tries;
int sockets_created = 0;
+ struct sockaddr_in6 serverAddrv6;
+ struct sockaddr_in serverAddrv4;
struct sockaddr *serverAddr;
struct sockaddr *addrs[2];
socklen_t addrlens[2];
socklen_t addrlen;
+ int eno;
/* Create IPv6 socket */
+ eno = EINVAL;
if (plugin->enable_ipv6 == GNUNET_YES)
{
plugin->sockv6 = GNUNET_NETWORK_socket_create (PF_INET6, SOCK_DGRAM, 0);
if (NULL == plugin->sockv6)
{
+ GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "socket");
LOG (GNUNET_ERROR_TYPE_WARNING, "Disabling IPv6 since it is not supported on this system!\n");
plugin->enable_ipv6 = GNUNET_NO;
}
else
{
+ memset (&serverAddrv6, '\0', sizeof (struct sockaddr_in6));
#if HAVE_SOCKADDR_IN_SIN_LEN
- serverAddrv6->sin6_len = sizeof (serverAddrv6);
+ serverAddrv6.sin6_len = sizeof (struct sockaddr_in6);
#endif
- serverAddrv6->sin6_family = AF_INET6;
- serverAddrv6->sin6_addr = in6addr_any;
- serverAddrv6->sin6_port = htons (plugin->port);
+ serverAddrv6.sin6_family = AF_INET6;
+ if (NULL != bind_v6)
+ serverAddrv6.sin6_addr = bind_v6->sin6_addr;
+ else
+ serverAddrv6.sin6_addr = in6addr_any;
+
+ if (0 == plugin->port) /* autodetect */
+ serverAddrv6.sin6_port = htons (GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_STRONG, 33537) + 32000);
+ else
+ serverAddrv6.sin6_port = htons (plugin->port);
addrlen = sizeof (struct sockaddr_in6);
- serverAddr = (struct sockaddr *) serverAddrv6;
- LOG (GNUNET_ERROR_TYPE_DEBUG, "Binding to IPv6 port %d\n",
- ntohs (serverAddrv6->sin6_port));
+ serverAddr = (struct sockaddr *) &serverAddrv6;
+
tries = 0;
- while (GNUNET_NETWORK_socket_bind (plugin->sockv6, serverAddr, addrlen) !=
- GNUNET_OK)
+ while (tries < 10)
{
- serverAddrv6->sin6_port = htons (GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_STRONG, 33537) + 32000); /* Find a good, non-root port */
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "IPv6 Binding failed, trying new port %d\n",
- ntohs (serverAddrv6->sin6_port));
- tries++;
- if (tries > 10)
- {
- GNUNET_NETWORK_socket_close (plugin->sockv6);
- plugin->sockv6 = NULL;
- break;
- }
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Binding to IPv6 `%s'\n",
+ GNUNET_a2s (serverAddr, addrlen));
+ /* binding */
+ if (GNUNET_OK == GNUNET_NETWORK_socket_bind (plugin->sockv6,
+ serverAddr, addrlen, 0))
+ break;
+ eno = errno;
+ if (0 != plugin->port)
+ {
+ tries = 10; /* fail */
+ break; /* bind failed on specific port */
+ }
+ /* autodetect */
+ serverAddrv6.sin6_port = htons (GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_STRONG, 33537) + 32000);
+ tries ++;
+ }
+ if (tries >= 10)
+ {
+ GNUNET_NETWORK_socket_close (plugin->sockv6);
+ plugin->enable_ipv6 = GNUNET_NO;
+ plugin->sockv6 = NULL;
}
+
if (plugin->sockv6 != NULL)
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
- "IPv6 socket created on port %d\n",
- ntohs (serverAddrv6->sin6_port));
- addrs[sockets_created] = (struct sockaddr *) serverAddrv6;
+ "IPv6 socket created on port %s\n",
+ GNUNET_a2s (serverAddr, addrlen));
+ addrs[sockets_created] = (struct sockaddr *) &serverAddrv6;
addrlens[sockets_created] = sizeof (struct sockaddr_in6);
sockets_created++;
}
+ else
+ {
+ LOG (GNUNET_ERROR_TYPE_ERROR,
+ "Failed to bind UDP socket to %s: %s\n",
+ GNUNET_a2s (serverAddr, addrlen),
+ STRERROR (eno));
+ }
}
}
/* Create IPv4 socket */
+ eno = EINVAL;
plugin->sockv4 = GNUNET_NETWORK_socket_create (PF_INET, SOCK_DGRAM, 0);
if (NULL == plugin->sockv4)
{
GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "socket");
+ LOG (GNUNET_ERROR_TYPE_WARNING, "Disabling IPv4 since it is not supported on this system!\n");
+ plugin->enable_ipv4 = GNUNET_NO;
}
else
{
+ memset (&serverAddrv4, '\0', sizeof (struct sockaddr_in));
#if HAVE_SOCKADDR_IN_SIN_LEN
- serverAddrv4->sin_len = sizeof (serverAddrv4);
+ serverAddrv4.sin_len = sizeof (struct sockaddr_in);
#endif
- serverAddrv4->sin_family = AF_INET;
- serverAddrv4->sin_addr.s_addr = INADDR_ANY;
- serverAddrv4->sin_port = htons (plugin->port);
+ serverAddrv4.sin_family = AF_INET;
+ if (NULL != bind_v4)
+ serverAddrv4.sin_addr = bind_v4->sin_addr;
+ else
+ serverAddrv4.sin_addr.s_addr = INADDR_ANY;
+
+ if (0 == plugin->port)
+ /* autodetect */
+ serverAddrv4.sin_port = htons (GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_STRONG, 33537) + 32000);
+ else
+ serverAddrv4.sin_port = htons (plugin->port);
+
+
addrlen = sizeof (struct sockaddr_in);
- serverAddr = (struct sockaddr *) serverAddrv4;
-
- LOG (GNUNET_ERROR_TYPE_DEBUG, "Binding to IPv4 port %d\n",
- ntohs (serverAddrv4->sin_port));
+ serverAddr = (struct sockaddr *) &serverAddrv4;
+
tries = 0;
- while (GNUNET_NETWORK_socket_bind (plugin->sockv4, serverAddr, addrlen) !=
- GNUNET_OK)
+ while (tries < 10)
{
- serverAddrv4->sin_port = htons (GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_STRONG, 33537) + 32000); /* Find a good, non-root port */
- LOG (GNUNET_ERROR_TYPE_DEBUG, "IPv4 Binding failed, trying new port %d\n",
- ntohs (serverAddrv4->sin_port));
- tries++;
- if (tries > 10)
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Binding to IPv4 `%s'\n",
+ GNUNET_a2s (serverAddr, addrlen));
+
+ /* binding */
+ if (GNUNET_OK == GNUNET_NETWORK_socket_bind (plugin->sockv4,
+ serverAddr, addrlen, 0))
+ break;
+ eno = errno;
+ if (0 != plugin->port)
{
- GNUNET_NETWORK_socket_close (plugin->sockv4);
- plugin->sockv4 = NULL;
- break;
+ tries = 10; /* fail */
+ break; /* bind failed on specific port */
}
+
+ /* autodetect */
+ serverAddrv4.sin_port = htons (GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_STRONG, 33537) + 32000);
+ tries ++;
+ }
+
+ if (tries >= 10)
+ {
+ GNUNET_NETWORK_socket_close (plugin->sockv4);
+ plugin->enable_ipv4 = GNUNET_NO;
+ plugin->sockv4 = NULL;
}
+
if (plugin->sockv4 != NULL)
{
- addrs[sockets_created] = (struct sockaddr *) serverAddrv4;
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "IPv4 socket created on port %s\n", GNUNET_a2s (serverAddr, addrlen));
+ addrs[sockets_created] = (struct sockaddr *) &serverAddrv4;
addrlens[sockets_created] = sizeof (struct sockaddr_in);
sockets_created++;
}
+ else
+ {
+ LOG (GNUNET_ERROR_TYPE_ERROR,
+ "Failed to bind UDP socket to %s: %s\n",
+ GNUNET_a2s (serverAddr, addrlen), STRERROR (eno));
+ }
+ }
+
+ if (0 == sockets_created)
+ {
+ LOG (GNUNET_ERROR_TYPE_WARNING, _("Failed to open UDP sockets\n"));
+ return 0; /* No sockets created, return */
}
/* Create file descriptors */
- plugin->rs_v4 = GNUNET_NETWORK_fdset_create ();
- plugin->ws_v4 = GNUNET_NETWORK_fdset_create ();
- GNUNET_NETWORK_fdset_zero (plugin->rs_v4);
- GNUNET_NETWORK_fdset_zero (plugin->ws_v4);
- if (NULL != plugin->sockv4)
+ if (plugin->enable_ipv4 == GNUNET_YES)
{
- GNUNET_NETWORK_fdset_set (plugin->rs_v4, plugin->sockv4);
- GNUNET_NETWORK_fdset_set (plugin->ws_v4, plugin->sockv4);
+ plugin->rs_v4 = GNUNET_NETWORK_fdset_create ();
+ plugin->ws_v4 = GNUNET_NETWORK_fdset_create ();
+ GNUNET_NETWORK_fdset_zero (plugin->rs_v4);
+ GNUNET_NETWORK_fdset_zero (plugin->ws_v4);
+ if (NULL != plugin->sockv4)
+ {
+ GNUNET_NETWORK_fdset_set (plugin->rs_v4, plugin->sockv4);
+ GNUNET_NETWORK_fdset_set (plugin->ws_v4, plugin->sockv4);
+ }
}
- if (0 == sockets_created)
- LOG (GNUNET_ERROR_TYPE_WARNING, _("Failed to open UDP sockets\n"));
if (plugin->enable_ipv6 == GNUNET_YES)
{
plugin->rs_v6 = GNUNET_NETWORK_fdset_create ();
GNUNET_NETWORK_fdset_set (plugin->ws_v6, plugin->sockv6);
}
}
+
schedule_select (plugin);
plugin->nat = GNUNET_NAT_register (plugin->env->cfg,
GNUNET_NO, plugin->port,
struct sockaddr_in serverAddrv4;
struct sockaddr_in6 serverAddrv6;
int res;
+ int have_bind4;
+ int have_bind6;
if (NULL == env->receive)
{
return api;
}
- GNUNET_assert( NULL != env->stats);
+ GNUNET_assert (NULL != env->stats);
- /* Get port number */
+ /* Get port number: port == 0 : autodetect a port,
+ * > 0 : use this port,
+ * not given : 2086 default */
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_number (env->cfg, "transport-udp", "PORT",
&port))
if ((GNUNET_YES ==
GNUNET_CONFIGURATION_get_value_yesno (env->cfg, "nat",
"DISABLEV6")))
- {
enable_v6 = GNUNET_NO;
- }
else
enable_v6 = GNUNET_YES;
/* Addresses */
- memset (&serverAddrv6, 0, sizeof (serverAddrv6));
+ have_bind4 = GNUNET_NO;
memset (&serverAddrv4, 0, sizeof (serverAddrv4));
-
if (GNUNET_YES ==
GNUNET_CONFIGURATION_get_value_string (env->cfg, "transport-udp",
"BINDTO", &bind4_address))
GNUNET_free (bind4_address);
return NULL;
}
+ have_bind4 = GNUNET_YES;
}
-
+ GNUNET_free_non_null (bind4_address);
+ have_bind6 = GNUNET_NO;
+ memset (&serverAddrv6, 0, sizeof (serverAddrv6));
if (GNUNET_YES ==
GNUNET_CONFIGURATION_get_value_string (env->cfg, "transport-udp",
"BINDTO6", &bind6_address))
{
LOG (GNUNET_ERROR_TYPE_ERROR, _("Invalid IPv6 address: `%s'\n"),
bind6_address);
- GNUNET_free_non_null (bind4_address);
GNUNET_free (bind6_address);
return NULL;
}
+ have_bind6 = GNUNET_YES;
}
+ GNUNET_free_non_null (bind6_address);
+
+ /* Initialize my flags */
+ myoptions = 0;
/* Enable neighbour discovery */
broadcast = GNUNET_CONFIGURATION_get_value_yesno (env->cfg, "transport-udp",
}
p = GNUNET_malloc (sizeof (struct Plugin));
- api = GNUNET_malloc (sizeof (struct GNUNET_TRANSPORT_PluginFunctions));
-
- GNUNET_BANDWIDTH_tracker_init (&p->tracker,
- GNUNET_BANDWIDTH_value_init ((uint32_t)udp_max_bps), 30);
- p->sessions = GNUNET_CONTAINER_multihashmap_create (10, GNUNET_NO);
- p->defrag_ctxs = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
- p->mst = GNUNET_SERVER_mst_create (&process_inbound_tokenized_messages, p);
p->port = port;
p->aport = aport;
p->broadcast_interval = interval;
p->enable_ipv6 = enable_v6;
+ p->enable_ipv4 = GNUNET_YES; /* default */
p->env = env;
-
+ p->sessions = GNUNET_CONTAINER_multihashmap_create (10, GNUNET_NO);
+ p->defrag_ctxs = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
+ p->mst = GNUNET_SERVER_mst_create (&process_inbound_tokenized_messages, p);
+ GNUNET_BANDWIDTH_tracker_init (&p->tracker,
+ GNUNET_BANDWIDTH_value_init ((uint32_t)udp_max_bps), 30);
plugin = p;
- api->cls = p;
- api->send = NULL;
- api->disconnect = &udp_disconnect;
- api->address_pretty_printer = &udp_plugin_address_pretty_printer;
- api->address_to_string = &udp_address_to_string;
- api->string_to_address = &udp_string_to_address;
- api->check_address = &udp_plugin_check_address;
- api->get_session = &udp_plugin_get_session;
- api->send = &udp_plugin_send;
-
LOG (GNUNET_ERROR_TYPE_DEBUG, "Setting up sockets\n");
- res = setup_sockets (p, &serverAddrv6, &serverAddrv4);
+ res = setup_sockets (p, (GNUNET_YES == have_bind6) ? &serverAddrv6 : NULL,
+ (GNUNET_YES == have_bind4) ? &serverAddrv4 : NULL);
if ((res == 0) || ((p->sockv4 == NULL) && (p->sockv6 == NULL)))
{
- LOG (GNUNET_ERROR_TYPE_ERROR, "Failed to create network sockets, plugin failed\n");
+ LOG (GNUNET_ERROR_TYPE_ERROR,
+ _("Failed to create network sockets, plugin failed\n"));
+ GNUNET_CONTAINER_multihashmap_destroy (p->sessions);
+ GNUNET_CONTAINER_heap_destroy (p->defrag_ctxs);
+ GNUNET_SERVER_mst_destroy (p->mst);
GNUNET_free (p);
- GNUNET_free (api);
return NULL;
}
-
- if (broadcast == GNUNET_YES)
+ else if (broadcast == GNUNET_YES)
{
LOG (GNUNET_ERROR_TYPE_DEBUG, "Starting broadcasting\n");
setup_broadcast (p, &serverAddrv6, &serverAddrv4);
}
- GNUNET_free_non_null (bind4_address);
- GNUNET_free_non_null (bind6_address);
+ api = GNUNET_malloc (sizeof (struct GNUNET_TRANSPORT_PluginFunctions));
+ api->cls = p;
+ api->send = NULL;
+ api->disconnect = &udp_disconnect;
+ api->address_pretty_printer = &udp_plugin_address_pretty_printer;
+ api->address_to_string = &udp_address_to_string;
+ api->string_to_address = &udp_string_to_address;
+ api->check_address = &udp_plugin_check_address;
+ api->get_session = &udp_plugin_get_session;
+ api->send = &udp_plugin_send;
+ api->get_network = &udp_get_network;
+
return api;
}
{
struct GNUNET_TRANSPORT_PluginFunctions *api = cls;
struct Plugin *plugin = api->cls;
+ struct PrettyPrinterContext *cur;
+ struct PrettyPrinterContext *next;
if (NULL == plugin)
{
}
/* Closing sockets */
- if (plugin->sockv4 != NULL)
+ if (GNUNET_YES ==plugin->enable_ipv4)
{
- GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (plugin->sockv4));
- plugin->sockv4 = NULL;
+ if (plugin->sockv4 != NULL)
+ {
+ GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (plugin->sockv4));
+ plugin->sockv4 = NULL;
+ }
+ GNUNET_NETWORK_fdset_destroy (plugin->rs_v4);
+ GNUNET_NETWORK_fdset_destroy (plugin->ws_v4);
}
- GNUNET_NETWORK_fdset_destroy (plugin->rs_v4);
- GNUNET_NETWORK_fdset_destroy (plugin->ws_v4);
-
- if (plugin->sockv6 != NULL)
+ if (GNUNET_YES ==plugin->enable_ipv6)
{
- GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (plugin->sockv6));
- plugin->sockv6 = NULL;
+ if (plugin->sockv6 != NULL)
+ {
+ GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (plugin->sockv6));
+ plugin->sockv6 = NULL;
- GNUNET_NETWORK_fdset_destroy (plugin->rs_v6);
- GNUNET_NETWORK_fdset_destroy (plugin->ws_v6);
+ GNUNET_NETWORK_fdset_destroy (plugin->rs_v6);
+ GNUNET_NETWORK_fdset_destroy (plugin->ws_v6);
+ }
}
-
- GNUNET_NAT_unregister (plugin->nat);
+ if (NULL != plugin->nat)
+ GNUNET_NAT_unregister (plugin->nat);
if (plugin->defrag_ctxs != NULL)
{
GNUNET_CONTAINER_multihashmap_iterate (plugin->sessions, &disconnect_and_free_it, plugin);
GNUNET_CONTAINER_multihashmap_destroy (plugin->sessions);
+ next = ppc_dll_head;
+ for (cur = next; NULL != cur; cur = next)
+ {
+ next = cur->next;
+ GNUNET_CONTAINER_DLL_remove (ppc_dll_head, ppc_dll_tail, cur);
+ GNUNET_RESOLVER_request_cancel (cur->resolver_handle);
+ GNUNET_SCHEDULER_cancel (cur->timeout_task);
+ GNUNET_free (cur);
+ GNUNET_break (0);
+ }
+
plugin->nat = NULL;
GNUNET_free (plugin);
GNUNET_free (api);
+#if DEBUG_MALLOC
+ struct Allocation *allocation;
+ while (NULL != ahead)
+ {
+ allocation = ahead;
+ GNUNET_CONTAINER_DLL_remove (ahead, atail, allocation);
+ GNUNET_free (allocation);
+ }
+ struct Allocator *allocator;
+ while (NULL != aehead)
+ {
+ allocator = aehead;
+ GNUNET_CONTAINER_DLL_remove (aehead, aetail, allocator);
+ GNUNET_free (allocator);
+ }
+#endif
return NULL;
}