/*
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
*/
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;
+ /**
+ * 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))
+ if ((NULL != addr) && (addrlen == sizeof (struct IPv6UdpAddress)))
{
t6 = addr;
af = AF_INET6;
memcpy (&a6, &t6->ipv6_addr, sizeof (a6));
sb = &a6;
}
- else if (addrlen == sizeof (struct IPv4UdpAddress))
+ else if ((NULL != addr) && (addrlen == sizeof (struct IPv4UdpAddress)))
{
t4 = addr;
af = AF_INET;
sb = &a4;
}
else if (addrlen == 0)
- {
- GNUNET_snprintf (rbuf, sizeof (rbuf), "%s", TRANSPORT_SESSION_INBOUND_STRING);
- return rbuf;
- }
+ {
+ GNUNET_snprintf (rbuf, sizeof (rbuf), "%s", TRANSPORT_SESSION_INBOUND_STRING);
+ return rbuf;
+ }
else
{
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);
}
-void
+static void
ppc_cancel_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct PrettyPrinterContext *ppc = cls;
uint16_t port;
uint32_t options;
- options = 0;
if (addrlen == sizeof (struct IPv6UdpAddress))
{
u6 = addr;
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));
}
struct sockaddr_in6 *v6;
size_t len;
+ if (NULL == addr)
+ {
+ GNUNET_break (0);
+ return NULL;
+ }
+
switch (addrlen)
{
case sizeof (struct IPv4UdpAddress):
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;
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)))
{
struct IPv4UdpAddress * u4 = NULL;
u4 = (struct IPv4UdpAddress *) address->address;
+ GNUNET_assert (NULL != u4);
const struct sockaddr_in *s4 = (const struct sockaddr_in *) s->sock_addr;
if ((0 == memcmp ((const void *) &u4->ipv4_addr,(const void *) &s4->sin_addr, sizeof (struct in_addr))) &&
(u4->u4_port == s4->sin_port))
{
struct IPv6UdpAddress * u6 = NULL;
u6 = (struct IPv6UdpAddress *) address->address;
+ GNUNET_assert (NULL != u6);
const struct sockaddr_in6 *s6 = (const struct sockaddr_in6 *) s->sock_addr;
if ((0 == memcmp (&u6->ipv6_addr, &s6->sin6_addr, sizeof (struct in6_addr))) &&
(u6->u6_port == s6->sin6_port))
*/
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 */
+ 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);
}
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)
{