/*
This file is part of GNUnet
- (C) 2010, 2011 Christian Grothoff (and other contributing authors)
+ (C) 2010-2013 Christian Grothoff (and other contributing authors)
GNUnet is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
*/
#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.
*/
/**
- * Start session timeout
+ * Cancel timeout
*/
static void
-start_session_timeout (struct Session *s);
+stop_session_timeout (struct Session *s)
+{
+ GNUNET_assert (NULL != s);
-/**
- * Increment session timeout due to activity
- */
-static void
-reschedule_session_timeout (struct Session *s);
+ if (GNUNET_SCHEDULER_NO_TASK != s->timeout_task)
+ {
+ GNUNET_SCHEDULER_cancel (s->timeout_task);
+ s->timeout_task = GNUNET_SCHEDULER_NO_TASK;
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Timeout stopped for session %p canceled\n",
+ s);
+ }
+}
-/**
- * Cancel timeout
- */
-static void
-stop_session_timeout (struct Session *s);
/**
* (re)schedule select tasks for this plugin.
* - timeout minimum delay */
plugin->select_task =
GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
- (0 == min_delay.rel_value) ? GNUNET_TIME_UNIT_FOREVER_REL : min_delay,
+ (0 == min_delay.rel_value_us) ? GNUNET_TIME_UNIT_FOREVER_REL : min_delay,
plugin->rs_v4,
- (0 == min_delay.rel_value) ? plugin->ws_v4 : NULL,
+ (0 == min_delay.rel_value_us) ? plugin->ws_v4 : NULL,
&udp_plugin_select, plugin);
}
if ((GNUNET_YES == plugin->enable_ipv6) && (NULL != plugin->sockv6))
GNUNET_SCHEDULER_cancel(plugin->select_task_v6);
plugin->select_task_v6 =
GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
- (0 == min_delay.rel_value) ? GNUNET_TIME_UNIT_FOREVER_REL : min_delay,
+ (0 == min_delay.rel_value_us) ? GNUNET_TIME_UNIT_FOREVER_REL : min_delay,
plugin->rs_v6,
- (0 == min_delay.rel_value) ? plugin->ws_v6 : NULL,
+ (0 == min_delay.rel_value_us) ? plugin->ws_v6 : NULL,
&udp_plugin_select_v6, plugin);
}
}
uint16_t port;
uint32_t options;
- options = 0;
if (addrlen == sizeof (struct IPv6UdpAddress))
{
t6 = addr;
sb = &a4;
}
else if (addrlen == 0)
- {
- GNUNET_snprintf (rbuf, sizeof (rbuf), "%s", "<inbound>");
- return rbuf;
- }
+ {
+ 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" : "%s.%u.%s:%u",
+ GNUNET_snprintf (rbuf, sizeof (rbuf),
+ (af == AF_INET6) ? "%s.%u.[%s]:%u" : "%s.%u.%s:%u",
PLUGIN_NAME, options, buf, port);
return rbuf;
}
address = NULL;
plugin = NULL;
optionstr = NULL;
- options = 0;
+
if ((NULL == addr) || (addrlen == 0))
{
GNUNET_break (0);
}
+static 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;
}
+ 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_free (ret);
}
-
/**
* Convert the transports address to a nice, human-readable
* format.
uint16_t port;
uint32_t options;
- options = 0;
if (addrlen == sizeof (struct IPv6UdpAddress))
{
u6 = addr;
}
else if (0 == addrlen)
{
- asc (asc_cls, "<inbound connection>");
+ asc (asc_cls, TRANSPORT_SESSION_INBOUND_STRING);
asc (asc_cls, NULL);
return;
}
ppc->ipv6 = GNUNET_YES;
else
ppc->ipv6 = GNUNET_NO;
- GNUNET_RESOLVER_hostname_get (sb, sbs, !numeric, timeout, &append_port, ppc);
+ 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);
+
}
if ((addrlen != sizeof (struct IPv4UdpAddress)) &&
(addrlen != sizeof (struct IPv6UdpAddress)))
{
- GNUNET_break_op (0);
return GNUNET_SYSERR;
}
if (addrlen == sizeof (struct IPv4UdpAddress))
plugin->ipv6_queue_tail, udpw);
}
+
static void
fragmented_message_done (struct UDP_FragmentationContext *fc, int result)
{
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");
+ 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));
call_continuation(udpw, GNUNET_SYSERR);
GNUNET_free (udpw);
}
- udpw = next;
}
plugin->env->session_end (plugin->env->cls, &s->target, s);
s->timeout_task = GNUNET_SCHEDULER_NO_TASK;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Session %p was idle for %llu ms, disconnecting\n",
- s, (unsigned long long) GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT.rel_value);
+ "Session %p was idle for %s, disconnecting\n",
+ s,
+ GNUNET_STRINGS_relative_time_to_string (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
+ GNUNET_YES));
/* call session destroy function */
disconnect_session (s);
}
&session_timeout,
s);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Timeout for session %p set to %llu ms\n",
- s, (unsigned long long) GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT.rel_value);
+ "Timeout for session %p set to %s\n",
+ s,
+ GNUNET_STRINGS_relative_time_to_string (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
+ GNUNET_YES));
}
&session_timeout,
s);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Timeout rescheduled for session %p set to %llu ms\n",
- s, (unsigned long long) GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT.rel_value);
-}
-
-
-/**
- * Cancel timeout
- */
-static void
-stop_session_timeout (struct Session *s)
-{
- GNUNET_assert (NULL != s);
-
- if (GNUNET_SCHEDULER_NO_TASK != s->timeout_task)
- {
- GNUNET_SCHEDULER_cancel (s->timeout_task);
- s->timeout_task = GNUNET_SCHEDULER_NO_TASK;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Timeout stopped for session %p canceled\n",
- s, (unsigned long long) GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT.rel_value);
- }
+ "Timeout rescheduled for session %p set to %s\n",
+ s,
+ GNUNET_STRINGS_relative_time_to_string (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
+ GNUNET_YES));
}
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;
- s =
- GNUNET_malloc (sizeof (struct Session) + sizeof (struct sockaddr_in6));
+ s = GNUNET_malloc (sizeof (struct Session) + sizeof (struct sockaddr_in6));
len = sizeof (struct sockaddr_in6);
v6 = (struct sockaddr_in6 *) &s[1];
v6->sin6_family = AF_INET6;
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;
socklen_t s_addrlen = s->addrlen;
- LOG (GNUNET_ERROR_TYPE_DEBUG, "Comparing address %s <-> %s\n",
- udp_address_to_string (NULL, (void *) address->address, address->address_length),
- GNUNET_a2s (s->sock_addr, s->addrlen));
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Comparing address %s <-> %s\n",
+ udp_address_to_string (NULL, (void *) address->address,
+ address->address_length),
+ GNUNET_a2s (s->sock_addr, s->addrlen));
if ((address->address_length == sizeof (struct IPv4UdpAddress)) &&
(s_addrlen == sizeof (struct sockaddr_in)))
{
return GNUNET_YES;
}
+
/**
* Function obtain the network type for a session
*
* @return the network type in HBO or GNUNET_SYSERR
*/
static enum GNUNET_ATS_Network_Type
-udp_get_network (void *cls, void *session)
+udp_get_network (void *cls,
+ struct Session *session)
{
- struct Session *s = (struct Session *) session;
-
- return ntohl(s->ats.value);
+ return ntohl (session->ats.value);
}
+
/**
* Creates a new outbound session the transport service will use to send data to the
* peer
*/
static struct Session *
udp_plugin_lookup_session (void *cls,
- const struct GNUNET_HELLO_Address *address)
+ const struct GNUNET_HELLO_Address *address)
{
struct Plugin * plugin = cls;
struct IPv6UdpAddress * udp_a6;
return NULL;
}
+
static struct Session *
udp_plugin_create_session (void *cls,
- const struct GNUNET_HELLO_Address *address)
+ const struct GNUNET_HELLO_Address *address)
{
- struct Session * s = NULL;
+ struct Session *s;
- /* otherwise create new */
s = create_session (plugin,
- &address->peer,
- address->address,
- address->address_length,
- NULL, NULL);
+ &address->peer,
+ 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,
}
-
/**
* Creates a new outbound session the transport service will use to send data to the
* peer
*/
static struct Session *
udp_plugin_get_session (void *cls,
- const struct GNUNET_HELLO_Address *address)
+ const struct GNUNET_HELLO_Address *address)
{
- struct Session * s = NULL;
+ struct Session *s;
if (NULL == address)
{
- GNUNET_break (0);
- return NULL;
+ GNUNET_break (0);
+ return NULL;
}
if ((address->address_length != sizeof (struct IPv4UdpAddress)) &&
- (address->address_length != sizeof (struct IPv6UdpAddress)))
- return NULL;
+ (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);
+ if (NULL != (s = udp_plugin_lookup_session (cls, address)))
+ return s;
+ return udp_plugin_create_session (cls, address);
}
int result, size_t payload, size_t physical)
{
struct UDP_MessageWrapper *udpw = cls;
+
GNUNET_FRAGMENT_context_transmission_done (udpw->frag_ctx->frag);
}
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 (struct IPv4UdpAddress);
break;
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;
if (NULL == s)
return;
- if (s->flow_delay_for_other_peer.rel_value <= UINT32_MAX)
- delay = s->flow_delay_for_other_peer.rel_value;
+ if (s->flow_delay_for_other_peer.rel_value_us <= UINT32_MAX)
+ delay = s->flow_delay_for_other_peer.rel_value_us;
LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Sending ACK to `%s' including delay of %u ms\n",
+ "Sending ACK to `%s' including delay of %s\n",
GNUNET_a2s (rc->src_addr,
(rc->src_addr->sa_family ==
AF_INET) ? sizeof (struct sockaddr_in) : sizeof (struct
sockaddr_in6)),
- delay);
+ GNUNET_STRINGS_relative_time_to_string (s->flow_delay_for_other_peer,
+ GNUNET_YES));
udpw = GNUNET_malloc (sizeof (struct UDP_MessageWrapper) + msize);
udpw->msg_size = msize;
udpw->payload_size = 0;
return;
}
- flow_delay.rel_value = (uint64_t) ntohl (udp_ack->delay);
+ flow_delay.rel_value_us = (uint64_t) ntohl (udp_ack->delay);
LOG (GNUNET_ERROR_TYPE_DEBUG,
- "We received a sending delay of %llu\n",
- flow_delay.rel_value);
+ "We received a sending delay of %s\n",
+ GNUNET_STRINGS_relative_time_to_string (flow_delay,
+ GNUNET_YES));
s->flow_delay_from_other_peer =
GNUNET_TIME_relative_to_absolute (flow_delay);
d_ctx->hnode =
GNUNET_CONTAINER_heap_insert (plugin->defrag_ctxs, d_ctx,
(GNUNET_CONTAINER_HeapCostType)
- now.abs_value);
+ now.abs_value_us);
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Created new defragmentation context for %u-byte fragment from `%s'\n",
(unsigned int) ntohs (msg->size),
/* keep this 'rc' from expiring */
GNUNET_CONTAINER_heap_update_cost (plugin->defrag_ctxs, d_ctx->hnode,
(GNUNET_CONTAINER_HeapCostType)
- now.abs_value);
+ now.abs_value_us);
}
if (GNUNET_CONTAINER_heap_get_size (plugin->defrag_ctxs) >
UDP_MAX_SENDER_ADDRESSES_WITH_DEFRAG)
}
}
+
static struct UDP_MessageWrapper *
remove_timeout_messages_and_select (struct UDP_MessageWrapper *head,
struct GNUNET_NETWORK_Handle *sock)
{
/* Find messages with timeout */
remaining = GNUNET_TIME_absolute_get_remaining (udpw->timeout);
- if (GNUNET_TIME_UNIT_ZERO.rel_value == remaining.rel_value)
+ if (GNUNET_TIME_UNIT_ZERO.rel_value_us == remaining.rel_value_us)
{
/* Message timed out */
switch (udpw->msg_type) {
{
/* Message did not time out, check flow delay */
remaining = GNUNET_TIME_absolute_get_remaining (udpw->session->flow_delay_from_other_peer);
- if (GNUNET_TIME_UNIT_ZERO.rel_value == remaining.rel_value)
+ if (GNUNET_TIME_UNIT_ZERO.rel_value_us == remaining.rel_value_us)
{
/* this message is not delayed */
LOG (GNUNET_ERROR_TYPE_DEBUG,
{
/* Message is delayed, try next */
LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Message for peer `%s' (%u bytes) is delayed for %llu \n",
- GNUNET_i2s(&udpw->session->target), udpw->payload_size, remaining.rel_value);
+ "Message for peer `%s' (%u bytes) is delayed for %s\n",
+ GNUNET_i2s(&udpw->session->target), udpw->payload_size,
+ GNUNET_STRINGS_relative_time_to_string (remaining,
+ GNUNET_YES));
udpw = udpw->next;
}
}
}
}
+
static size_t
udp_select_send (struct Plugin *plugin, struct GNUNET_NETWORK_Handle *sock)
{
{
struct GNUNET_TRANSPORT_PluginFunctions *api = cls;
struct Plugin *plugin = api->cls;
+ struct PrettyPrinterContext *cur;
+ struct PrettyPrinterContext *next;
if (NULL == plugin)
{
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);
projects / oweals / gnunet.git / blobdiff