/*
This file is part of GNUnet
- (C) 2010-2013 Christian Grothoff (and other contributing authors)
+ (C) 2010-2014 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
*/
static struct PrettyPrinterContext *ppc_dll_tail;
+
/**
- * Closure for 'append_port'.
+ * Closure for #append_port().
*/
struct PrettyPrinterContext
{
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
{
};
+
+/**
+ * Message types included in a `struct UDP_MessageWrapper`
+ */
+enum UDP_MessageType
+{
+ /**
+ * Uninitialized (error)
+ */
+ UMT_UNDEFINED = 0,
+
+ /**
+ * Fragment of a message.
+ */
+ UMT_MSG_FRAGMENTED = 1,
+
+ /**
+ *
+ */
+ UMT_MSG_FRAGMENTED_COMPLETE = 2,
+
+ /**
+ * Unfragmented message.
+ */
+ UMT_MSG_UNFRAGMENTED = 3,
+
+ /**
+ * Receipt confirmation.
+ */
+ UMT_MSG_ACK = 4
+
+};
+
+
struct UDP_MessageWrapper
{
/**
/**
* Message type
- * According to UDP_MessageType
*/
- int msg_type;
+ enum UDP_MessageType msg_type;
/**
* Message with size msg_size including UDP specific overhead
GNUNET_TRANSPORT_TransmitContinuation cont;
/**
- * Closure for 'cont'.
+ * Closure for @e cont.
*/
void *cont_cls;
struct UDP_FragmentationContext *frag_ctx;
};
+
/**
* UDP ACK Message-Packet header (after defragmentation).
*/
*/
struct Plugin * plugin;
+
/**
* We have been notified that our readset has something to read. We don't
* know which socket needs to be read, so we have to check each one
}
}
+
/**
* Function called for a quick conversion of the binary address to
* a numeric address. Note that the caller must not free the
* @return string representing the same address
*/
const char *
-udp_address_to_string (void *cls, const void *addr, size_t addrlen)
+udp_address_to_string (void *cls,
+ const void *addr,
+ size_t addrlen)
{
static char rbuf[INET6_ADDRSTRLEN + 10];
char buf[INET6_ADDRSTRLEN];
}
else
{
- return NULL ;
+ return NULL;
}
inet_ntop (af, sb, buf, INET6_ADDRSTRLEN);
return rbuf;
}
+
/**
* Function called to convert a string address to
* a binary address.
* @param addrlen length of the address
* @param buf location to store the buffer
* @param added location to store the number of bytes in the buffer.
- * If the function returns GNUNET_SYSERR, its contents are undefined.
- * @return GNUNET_OK on success, GNUNET_SYSERR on failure
+ * If the function returns #GNUNET_SYSERR, its contents are undefined.
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR on failure
*/
static int
-udp_string_to_address (void *cls, const char *addr, uint16_t addrlen,
- void **buf, size_t *added)
+udp_string_to_address (void *cls,
+ const char *addr,
+ uint16_t addrlen,
+ void **buf,
+ size_t *added)
{
struct sockaddr_storage socket_address;
char *address;
address[0] = '\0';
address++;
- if (GNUNET_OK
- != GNUNET_STRINGS_to_address_ip (address, strlen (address),
- &socket_address))
+ if (GNUNET_OK !=
+ GNUNET_STRINGS_to_address_ip (address, strlen (address),
+ &socket_address))
{
GNUNET_break(0);
GNUNET_free(plugin);
}
}
-static void
-ppc_cancel_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
-{
- struct PrettyPrinterContext *ppc = cls;
-
- 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;
- if (hostname == NULL )
+ if (NULL == hostname)
{
- 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;
+ /* Final call, done */
+ ppc->asc (ppc->asc_cls,
+ NULL,
+ GNUNET_OK);
+ GNUNET_CONTAINER_DLL_remove (ppc_dll_head,
+ ppc_dll_tail,
+ ppc);
ppc->resolver_handle = NULL;
- 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);
+ GNUNET_free (ppc);
return;
}
-
if (GNUNET_YES == ppc->ipv6)
- GNUNET_asprintf (&ret, "%s.%u.[%s]:%d", PLUGIN_NAME, ppc->options, hostname,
- ppc->port);
+ 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);
+ GNUNET_asprintf (&ret,
+ "%s.%u.%s:%d",
+ PLUGIN_NAME,
+ ppc->options,
+ hostname,
+ ppc->port);
+ ppc->asc (ppc->asc_cls,
+ ret,
+ GNUNET_OK);
+ GNUNET_free (ret);
}
+
/**
* Convert the transports address to a nice, human-readable
* format.
* @param asc_cls closure for @a asc
*/
static void
-udp_plugin_address_pretty_printer (void *cls, const char *type,
- const void *addr, size_t addrlen, int numeric,
- struct GNUNET_TIME_Relative timeout,
- GNUNET_TRANSPORT_AddressStringCallback asc, void *asc_cls)
+udp_plugin_address_pretty_printer (void *cls,
+ const char *type,
+ const void *addr,
+ size_t addrlen,
+ int numeric,
+ struct GNUNET_TIME_Relative timeout,
+ GNUNET_TRANSPORT_AddressStringCallback asc,
+ void *asc_cls)
{
struct PrettyPrinterContext *ppc;
const void *sb;
else
{
/* invalid address */
- GNUNET_break_op(0);
- asc (asc_cls, NULL );
+ GNUNET_break_op (0);
+ asc (asc_cls, NULL , GNUNET_SYSERR);
+ asc (asc_cls, NULL, GNUNET_OK);
return;
}
ppc = GNUNET_new (struct PrettyPrinterContext);
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);
- ppc->resolver_handle = GNUNET_RESOLVER_hostname_get (sb, sbs, !numeric,
- timeout, &append_port, ppc);
+ GNUNET_CONTAINER_DLL_insert (ppc_dll_head,
+ ppc_dll_tail,
+ 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)
+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");
+ 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 (udpw->msg_size >= udpw->payload_size)
overhead = udpw->msg_size - udpw->payload_size;
case GNUNET_OK:
switch (udpw->msg_type)
{
- case MSG_UNFRAGMENTED:
+ case UMT_MSG_UNFRAGMENTED:
if (NULL != udpw->cont)
{
/* Transport continuation */
GNUNET_STATISTICS_update (plugin->env->stats,
"# UDP, total, bytes payload, sent", udpw->payload_size, GNUNET_NO);
break;
- case MSG_FRAGMENTED_COMPLETE:
+ case UMT_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_STATISTICS_update (plugin->env->stats,
"# UDP, fragmented msgs, messages, pending", -1, GNUNET_NO);
break;
- case MSG_FRAGMENTED:
+ case UMT_MSG_FRAGMENTED:
/* Fragmented message: enqueue next fragment */
if (NULL != udpw->cont)
udpw->cont (udpw->cont_cls, &udpw->session->target, result,
"# UDP, fragmented msgs, fragments bytes, sent, success",
udpw->msg_size, GNUNET_NO);
break;
- case MSG_ACK:
+ case UMT_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, 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;
}
case GNUNET_SYSERR:
switch (udpw->msg_type)
{
- case MSG_UNFRAGMENTED:
+ case UMT_MSG_UNFRAGMENTED:
/* Unfragmented message: failed to send */
if (NULL != udpw->cont)
udpw->cont (udpw->cont_cls, &udpw->session->target, result,
"# UDP, unfragmented msgs, bytes overhead, sent, failure", overhead,
GNUNET_NO);
break;
- case MSG_FRAGMENTED_COMPLETE:
+ case UMT_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_STATISTICS_update (plugin->env->stats,
"# UDP, fragmented msgs, messages, pending", -1, GNUNET_NO);
break;
- case MSG_FRAGMENTED:
+ case UMT_MSG_FRAGMENTED:
GNUNET_assert(NULL != udpw->frag_ctx);
/* Fragmented message: failed to send */
GNUNET_STATISTICS_update (plugin->env->stats,
"# UDP, fragmented msgs, fragments bytes, sent, failure",
udpw->msg_size, GNUNET_NO);
break;
- case MSG_ACK:
+ case UMT_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;
}
}
+
/**
* Check if the given port is plausible (must be either our listen
* port or our advertised port). If it is neither, we return
return GNUNET_SYSERR;
}
+
/**
* Function that will be called to check if a binary address for this
* plugin is well-formed and corresponds to an address for THIS peer
return GNUNET_OK;
}
+
/**
* Function to free last resources associated with a session.
*
GNUNET_free(s);
}
+
static void
-dequeue (struct Plugin *plugin, struct UDP_MessageWrapper * udpw)
+dequeue (struct Plugin *plugin,
+ struct UDP_MessageWrapper * udpw)
{
if (plugin->bytes_in_buffer < udpw->msg_size)
GNUNET_break(0);
}
GNUNET_STATISTICS_update (plugin->env->stats, "# UDP, total, msgs in buffers",
-1, GNUNET_NO);
- if (udpw->session->address->address_length == sizeof(struct sockaddr_in))
+ if (udpw->session->address->address_length == sizeof(struct IPv4UdpAddress))
GNUNET_CONTAINER_DLL_remove(plugin->ipv4_queue_head,
plugin->ipv4_queue_tail, udpw);
- if (udpw->session->address->address_length == sizeof(struct sockaddr_in6))
+ else if (udpw->session->address->address_length == sizeof(struct IPv6UdpAddress))
GNUNET_CONTAINER_DLL_remove(plugin->ipv6_queue_head,
plugin->ipv6_queue_tail, udpw);
+ else
+ GNUNET_break (0);
}
+
static void
-fragmented_message_done (struct UDP_FragmentationContext *fc, int result)
+fragmented_message_done (struct UDP_FragmentationContext *fc,
+ int result)
{
struct UDP_MessageWrapper *udpw;
struct UDP_MessageWrapper *tmp;
/* Call continuation for fragmented message */
memset (&dummy, 0, sizeof(dummy));
- dummy.msg_type = MSG_FRAGMENTED_COMPLETE;
+ dummy.msg_type = UMT_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;
call_continuation (&dummy, result);
/* Remove leftover fragments from queue */
- if (s->address->address_length == sizeof(struct sockaddr_in6))
+ if (s->address->address_length == sizeof(struct IPv6UdpAddress))
{
udpw = plugin->ipv6_queue_head;
while (NULL != udpw)
udpw = tmp;
}
}
- if (s->address->address_length == sizeof(struct sockaddr_in))
+ if (s->address->address_length == sizeof(struct IPv4UdpAddress))
{
udpw = plugin->ipv4_queue_head;
while (udpw != NULL )
GNUNET_free(fc);
}
+/**
+ * Scan the heap for a receive context with the given address.
+ *
+ * @param cls the `struct FindReceiveContext`
+ * @param node internal node of the heap
+ * @param element value stored at the node (a 'struct ReceiveContext')
+ * @param cost cost associated with the node
+ * @return #GNUNET_YES if we should continue to iterate,
+ * #GNUNET_NO if not.
+ */
+static int
+find_receive_context (void *cls, struct GNUNET_CONTAINER_HeapNode *node,
+ void *element, GNUNET_CONTAINER_HeapCostType cost)
+{
+ struct FindReceiveContext *frc = cls;
+ struct DefragContext *e = element;
+
+ if ((frc->addr_len == e->addr_len)
+ && (0 == memcmp (frc->addr, e->src_addr, frc->addr_len)))
+ {
+ frc->rc = e;
+ return GNUNET_NO;
+ }
+ return GNUNET_YES;
+}
+
+
/**
* Functions with this signature are called whenever we need
* to close a session due to a disconnect or failure to
struct Plugin *plugin = cls;
struct UDP_MessageWrapper *udpw;
struct UDP_MessageWrapper *next;
+ struct FindReceiveContext frc;
GNUNET_assert(GNUNET_YES != s->in_destroy);
LOG(GNUNET_ERROR_TYPE_DEBUG, "Session %p to peer `%s' address ended\n", s,
fragmented_message_done (s->frag_ctx, GNUNET_SYSERR);
}
+ frc.rc = NULL;
+ frc.addr = s->address->address;
+ frc.addr_len = s->address->address_length;
+ /* Lookup existing receive context for this address */
+ if (NULL != plugin->defrag_ctxs)
+ {
+ GNUNET_CONTAINER_heap_iterate (plugin->defrag_ctxs,
+ &find_receive_context, &frc);
+ if (NULL != frc.rc)
+ {
+ struct DefragContext *d_ctx = frc.rc;
+ GNUNET_CONTAINER_heap_remove_node (d_ctx->hnode);
+ GNUNET_DEFRAGMENT_context_destroy (d_ctx->defrag);
+ GNUNET_free (d_ctx);
+ }
+ }
+
next = plugin->ipv4_queue_head;
while (NULL != (udpw = next))
{
GNUNET_free(udpw);
}
}
- plugin->env->session_end (plugin->env->cls, &s->target, s);
+ plugin->env->session_end (plugin->env->cls, s->address, s);
if (NULL != s->frag_ctx)
{
GNUNET_assert(
GNUNET_YES == GNUNET_CONTAINER_multipeermap_remove (plugin->sessions, &s->target, s));
- GNUNET_STATISTICS_set (plugin->env->stats, "# UDP, sessions active",
+ GNUNET_STATISTICS_set (plugin->env->stats, "# UDP sessions active",
GNUNET_CONTAINER_multipeermap_size (plugin->sessions), GNUNET_NO);
if (s->rc > 0)
s->in_destroy = GNUNET_YES;
return GNUNET_OK;
}
+
/**
* Function that is called to get the keepalive factor.
- * GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT is divided by this number to
+ * #GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT is divided by this number to
* calculate the interval between keepalive packets.
*
* @param cls closure with the `struct Plugin`
return 15;
}
+
/**
* Destroy a session, plugin is being unloaded.
*
* @return #GNUNET_OK (continue to iterate)
*/
static int
-disconnect_and_free_it (void *cls, const struct GNUNET_PeerIdentity *key,
- void *value)
+disconnect_and_free_it (void *cls,
+ const struct GNUNET_PeerIdentity *key,
+ void *value)
{
struct Plugin *plugin = cls;
return GNUNET_OK;
}
+
/**
* Disconnect from a remote node. Clean up session if we have one for
* this peer.
* @return #GNUNET_OK on success, #GNUNET_SYSERR if the operation failed
*/
static void
-udp_disconnect (void *cls, const struct GNUNET_PeerIdentity *target)
+udp_disconnect (void *cls,
+ const struct GNUNET_PeerIdentity *target)
{
struct Plugin *plugin = cls;
- LOG(GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from peer `%s'\n",
- GNUNET_i2s (target));
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Disconnecting from peer `%s'\n",
+ GNUNET_i2s (target));
/* Clean up sessions */
GNUNET_CONTAINER_multipeermap_get_multiple (plugin->sessions, target,
- &disconnect_and_free_it, plugin);
+ &disconnect_and_free_it, plugin);
}
+
/**
* Session was idle, so disconnect it
*
* @param tc scheduler context
*/
static void
-session_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+session_timeout (void *cls,
+ const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct Session *s = cls;
s->timeout_task = GNUNET_SCHEDULER_NO_TASK;
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "Session %p was idle for %s, disconnecting\n", s,
- GNUNET_STRINGS_relative_time_to_string (UDP_SESSION_TIME_OUT, GNUNET_YES));
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Session %p was idle for %s, disconnecting\n",
+ s,
+ GNUNET_STRINGS_relative_time_to_string (UDP_SESSION_TIME_OUT,
+ GNUNET_YES));
/* call session destroy function */
- udp_disconnect_session (s->plugin, s);
+ udp_disconnect_session (plugin, s);
}
+
/**
* Increment session timeout due to activity
*
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Timeout restarted for session %p\n", s);
}
+
static struct Session *
create_session (struct Plugin *plugin,
- const struct GNUNET_HELLO_Address *address)
+ const struct GNUNET_HELLO_Address *address)
{
struct Session *s;
s->flow_delay_from_other_peer = GNUNET_TIME_UNIT_ZERO_ABS;
s->flow_delay_for_other_peer = GNUNET_TIME_UNIT_ZERO;
s->timeout_task = GNUNET_SCHEDULER_add_delayed (UDP_SESSION_TIME_OUT,
- &session_timeout, s);
+ &session_timeout, s);
return s;
}
+
static int
-session_cmp_it (void *cls, const struct GNUNET_PeerIdentity * key, void *value)
+session_cmp_it (void *cls,
+ const struct GNUNET_PeerIdentity *key,
+ void *value)
{
- struct SessionCompareContext * cctx = cls;
+ struct SessionCompareContext *cctx = cls;
const struct GNUNET_HELLO_Address *address = cctx->address;
struct Session *s = value;
- LOG(GNUNET_ERROR_TYPE_DEBUG, "Comparing address %s <-> %s\n",
- udp_address_to_string (NULL, (void *) address->address, address->address_length),
- udp_address_to_string (NULL, s->address->address, s->address->address_length));
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Comparing address %s <-> %s\n",
+ udp_address_to_string (NULL, address->address, address->address_length),
+ udp_address_to_string (NULL, s->address->address, s->address->address_length));
if (0 == GNUNET_HELLO_address_cmp(s->address, cctx->address))
{
return GNUNET_YES;
}
+
/**
* Function obtain the network type for a session
*
* @return the network type
*/
static enum GNUNET_ATS_Network_Type
-udp_get_network (void *cls, struct Session *session)
+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
*
* @param cls the plugin
* @param address the address
- * @param inbound look for inbound session
* @return the session or NULL of max connections exceeded
*/
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;
GNUNET_assert(plugin != NULL);
GNUNET_assert(address != NULL);
- if ((address->address == NULL )||
- ((address->address_length != sizeof (struct IPv4UdpAddress)) &&
- (address->address_length != sizeof (struct IPv6UdpAddress)))){
- 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;
-}
+ if ( (address->address == NULL )||
+ ((address->address_length != sizeof (struct IPv4UdpAddress)) &&
+ (address->address_length != sizeof (struct IPv6UdpAddress))))
+ {
+ 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;
+ }
if (address->address_length == sizeof(struct IPv4UdpAddress))
{
- if (plugin->sockv4 == NULL )
- return NULL ;
+ if (plugin->sockv4 == NULL)
+ return NULL;
udp_a4 = (struct IPv4UdpAddress *) address->address;
if (udp_a4->u4_port == 0)
- return NULL ;
+ return NULL;
}
if (address->address_length == sizeof(struct IPv6UdpAddress))
{
- if (plugin->sockv6 == NULL )
- return NULL ;
+ if (plugin->sockv6 == NULL)
+ return NULL;
udp_a6 = (struct IPv6UdpAddress *) address->address;
if (udp_a6->u6_port == 0)
- return NULL ;
+ return NULL;
}
/* check if session already exists */
struct SessionCompareContext cctx;
cctx.address = address;
cctx.res = NULL;
- LOG(GNUNET_ERROR_TYPE_ERROR,
+ LOG(GNUNET_ERROR_TYPE_DEBUG,
"Looking for existing session for peer `%s' `%s' \n",
GNUNET_i2s (&address->peer),
udp_address_to_string(NULL, address->address, address->address_length));
session_cmp_it, &cctx);
if (cctx.res != NULL )
{
- LOG(GNUNET_ERROR_TYPE_ERROR, "Found existing session %p\n", cctx.res);
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Found existing session %p\n",
+ cctx.res);
return cctx.res;
}
- return NULL ;
+ 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;
struct IPv4UdpAddress *udp_v4;
memset (&v4, '\0', sizeof (v4));
v4.sin_family = AF_INET;
#if HAVE_SOCKADDR_IN_SIN_LEN
- v4->sin_len = sizeof (struct sockaddr_in);
+ v4.sin_len = sizeof (struct sockaddr_in);
#endif
v4.sin_port = udp_v4->u4_port;
v4.sin_addr.s_addr = udp_v4->ipv4_addr;
memset (&v6, '\0', sizeof (v6));
v6.sin6_family = AF_INET6;
#if HAVE_SOCKADDR_IN_SIN_LEN
- v6->sin_len = sizeof (struct sockaddr_in6);
+ v6.sin6_len = sizeof (struct sockaddr_in6);
#endif
v6.sin6_port = udp_v6->u6_port;
v6.sin6_addr = udp_v6->ipv6_addr;
}
if (NULL == s)
- return NULL ; /* protocol not supported or address invalid */
- LOG(GNUNET_ERROR_TYPE_ERROR,
+ return NULL; /* protocol not supported or address invalid */
+ LOG(GNUNET_ERROR_TYPE_DEBUG,
"Creating new %s session %p for peer `%s' address `%s'\n",
GNUNET_HELLO_address_check_option (address, GNUNET_HELLO_ADDRESS_INFO_INBOUND) ? "inbound" : "outbound",
s, GNUNET_i2s (&address->peer),
- udp_address_to_string(NULL,address->address,address->address_length));
+ udp_address_to_string( NULL,address->address,address->address_length));
GNUNET_assert(
GNUNET_OK == GNUNET_CONTAINER_multipeermap_put (plugin->sessions, &s->target, s, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
- GNUNET_STATISTICS_set (plugin->env->stats, "# UDP, sessions active",
+ GNUNET_STATISTICS_set (plugin->env->stats, "# UDP sessions active",
GNUNET_CONTAINER_multipeermap_size (plugin->sessions), GNUNET_NO);
return s;
}
+
static void
udp_plugin_update_session_timeout (void *cls,
- const struct GNUNET_PeerIdentity *peer, struct Session *session)
+ const struct GNUNET_PeerIdentity *peer,
+ struct Session *session)
{
- if (GNUNET_YES
- != GNUNET_CONTAINER_multipeermap_contains_value (plugin->sessions, peer,
- session))
+ if (GNUNET_YES !=
+ GNUNET_CONTAINER_multipeermap_contains_value (plugin->sessions, peer,
+ session))
{
GNUNET_break(0);
return;
reschedule_session_timeout (session);
}
+
/**
* 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_get_session (void *cls,
+ const struct GNUNET_HELLO_Address *address)
{
struct Session *s;
if (NULL == address)
{
GNUNET_break(0);
- return NULL ;
+ return NULL;
}
- if ((address->address_length != sizeof(struct IPv4UdpAddress))
- && (address->address_length != sizeof(struct IPv6UdpAddress)))
- 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 udp_plugin_create_session (cls, address);
}
+
static void
-enqueue (struct Plugin *plugin, struct UDP_MessageWrapper * udpw)
+enqueue (struct Plugin *plugin,
+ struct UDP_MessageWrapper *udpw)
{
if (plugin->bytes_in_buffer + udpw->msg_size > INT64_MAX)
GNUNET_break(0);
}
GNUNET_STATISTICS_update (plugin->env->stats, "# UDP, total, msgs in buffers",
1, GNUNET_NO);
- if (udpw->session->address->address_length == sizeof(struct sockaddr_in))
+ if (udpw->session->address->address_length == sizeof (struct IPv4UdpAddress))
GNUNET_CONTAINER_DLL_insert(plugin->ipv4_queue_head,
plugin->ipv4_queue_tail, udpw);
- if (udpw->session->address->address_length == sizeof(struct sockaddr_in6))
+ else if (udpw->session->address->address_length == sizeof (struct IPv6UdpAddress))
GNUNET_CONTAINER_DLL_insert(plugin->ipv6_queue_head,
plugin->ipv6_queue_tail, udpw);
+ else
+ GNUNET_break (0);
}
+
/**
* Fragment message was transmitted via UDP, let fragmentation know
* to send the next fragment now.
* @param physical bytes physical sent
*/
static void
-send_next_fragment (void *cls, const struct GNUNET_PeerIdentity *target,
- int result, size_t payload, size_t physical)
+send_next_fragment (void *cls,
+ const struct GNUNET_PeerIdentity *target,
+ int result,
+ size_t payload,
+ size_t physical)
{
struct UDP_MessageWrapper *udpw = cls;
GNUNET_FRAGMENT_context_transmission_done (udpw->frag_ctx->frag);
}
+
/**
* Function that is called with messages created by the fragmentation
* module. In the case of the 'proc' callback of the
udpw->cont_cls = udpw;
udpw->timeout = frag_ctx->timeout;
udpw->frag_ctx = frag_ctx;
- udpw->msg_type = MSG_FRAGMENTED;
+ udpw->msg_type = UMT_MSG_FRAGMENTED;
memcpy (udpw->msg_buf, msg, msg_len);
enqueue (plugin, udpw);
schedule_select (plugin);
}
+
/**
* Function that can be used by the transport service to transmit
* a message using the plugin. Note that in the case of a
* and does NOT mean that the message was not transmitted (DV)
*/
static ssize_t
-udp_plugin_send (void *cls, struct Session *s, const char *msgbuf,
- size_t msgbuf_size, unsigned int priority, struct GNUNET_TIME_Relative to,
- GNUNET_TRANSPORT_TransmitContinuation cont, void *cont_cls)
+udp_plugin_send (void *cls,
+ struct Session *s,
+ const char *msgbuf,
+ size_t msgbuf_size,
+ unsigned int priority,
+ struct GNUNET_TIME_Relative to,
+ GNUNET_TRANSPORT_TransmitContinuation cont, void *cont_cls)
{
struct Plugin *plugin = cls;
size_t udpmlen = msgbuf_size + sizeof(struct UDPMessage);
GNUNET_assert(plugin != NULL);
GNUNET_assert(s != NULL);
- if ((s->address->address_length == sizeof(struct sockaddr_in6)) && (plugin->sockv6 == NULL ))
+ if ( (s->address->address_length == sizeof(struct IPv6UdpAddress)) &&
+ (plugin->sockv6 == NULL) )
return GNUNET_SYSERR;
- if ((s->address->address_length == sizeof(struct sockaddr_in)) && (plugin->sockv4 == NULL ))
+ if ( (s->address->address_length == sizeof(struct IPv4UdpAddress)) &&
+ (plugin->sockv4 == NULL) )
return GNUNET_SYSERR;
if (udpmlen >= GNUNET_SERVER_MAX_MESSAGE_SIZE)
{
GNUNET_break(0);
return GNUNET_SYSERR;
}
- LOG(GNUNET_ERROR_TYPE_DEBUG,
- "UDP transmits %u-byte message to `%s' using address `%s'\n", udpmlen,
- GNUNET_i2s (&s->target), udp_address_to_string (NULL, s->address->address, s->address->address_length));
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "UDP transmits %u-byte message to `%s' using address `%s'\n", udpmlen,
+ GNUNET_i2s (&s->target),
+ udp_address_to_string (NULL, s->address->address,
+ s->address->address_length));
/* Message */
udp = (struct UDPMessage *) mbuf;
udpw->cont = cont;
udpw->cont_cls = cont_cls;
udpw->frag_ctx = NULL;
- udpw->msg_type = MSG_UNFRAGMENTED;
+ udpw->msg_type = UMT_MSG_UNFRAGMENTED;
memcpy (udpw->msg_buf, udp, sizeof(struct UDPMessage));
memcpy (&udpw->msg_buf[sizeof(struct UDPMessage)], msgbuf, msgbuf_size);
enqueue (plugin, udpw);
else
{
/* fragmented message */
- if (s->frag_ctx != NULL )
+ if (s->frag_ctx != NULL)
return GNUNET_SYSERR;
memcpy (&udp[1], msgbuf, msgbuf_size);
frag_ctx = GNUNET_new (struct UDP_FragmentationContext);
return udpmlen;
}
+
/**
* Our external IP address/port mapping has changed.
*
- * @param cls closure, the 'struct LocalAddrList'
- * @param add_remove GNUNET_YES to mean the new public IP address, GNUNET_NO to mean
+ * @param cls closure, the `struct LocalAddrList`
+ * @param add_remove #GNUNET_YES to mean the new public IP address, #GNUNET_NO to mean
* the previous (now invalid) one
- * @param address either the previous or the new public IP address
+ * @param addr either the previous or the new public IP address
* @param addrlen actual lenght of the address
*/
static void
udp_nat_port_map_callback (void *cls, int add_remove,
- const struct sockaddr *addr, socklen_t addrlen)
+ const struct sockaddr *addr,
+ socklen_t addrlen)
{
struct Plugin *plugin = cls;
struct GNUNET_HELLO_Address *address;
break;
case AF_INET6:
GNUNET_assert(addrlen == sizeof(struct sockaddr_in6));
- memset (&u4, 0, sizeof(u4));
+ memset (&u6, 0, sizeof(u6));
u6.options = htonl (myoptions);
if (0 == ((struct sockaddr_in6 *) addr)->sin6_port)
return;
GNUNET_HELLO_address_free (address);
}
+
/**
* Message tokenizer has broken up an incomming message. Pass it on
* to the service.
return GNUNET_OK;
}
+
/**
* We've received a UDP Message. Process it (pass contents to main service).
*
* @param sender_addr_len number of bytes in sender_addr
*/
static void
-process_udp_message (struct Plugin *plugin, const struct UDPMessage *msg,
- const struct sockaddr *sender_addr, socklen_t sender_addr_len)
+process_udp_message (struct Plugin *plugin,
+ const struct UDPMessage *msg,
+ const struct sockaddr *sender_addr,
+ socklen_t sender_addr_len)
{
struct SourceInformation si;
struct Session * s;
free_session (s);
}
-/**
- * Scan the heap for a receive context with the given address.
- *
- * @param cls the `struct FindReceiveContext`
- * @param node internal node of the heap
- * @param element value stored at the node (a 'struct ReceiveContext')
- * @param cost cost associated with the node
- * @return #GNUNET_YES if we should continue to iterate,
- * #GNUNET_NO if not.
- */
-static int
-find_receive_context (void *cls, struct GNUNET_CONTAINER_HeapNode *node,
- void *element, GNUNET_CONTAINER_HeapCostType cost)
-{
- struct FindReceiveContext *frc = cls;
- struct DefragContext *e = element;
-
- if ((frc->addr_len == e->addr_len)
- && (0 == memcmp (frc->addr, e->src_addr, frc->addr_len)))
- {
- frc->rc = e;
- return GNUNET_NO;
- }
- return GNUNET_YES;
-}
-
/**
* Process a defragmented message.
*
rc->src_addr, rc->addr_len);
}
+
+/**
+ * Context to lookup a session based on a IP address
+ */
struct LookupContext
{
+ /**
+ * The result
+ */
struct Session *res;
- const struct GNUNET_HELLO_Address *address;
+ /**
+ * The socket address
+ */
+ const struct sockaddr *address;
+
+ /**
+ * The socket address length
+ */
+ size_t addr_len;
+ /**
+ * Is a fragmentation context required for the session
+ */
int must_have_frag_ctx;
};
+
static int
-lookup_session_by_addr_it (void *cls, const struct GNUNET_PeerIdentity *key,
- void *value)
+lookup_session_by_sockaddr_it (void *cls,
+ const struct GNUNET_PeerIdentity *key,
+ void *value)
{
struct LookupContext *l_ctx = cls;
struct Session * s = value;
+ struct IPv4UdpAddress u4;
+ struct IPv6UdpAddress u6;
+ void *arg;
+ size_t args;
+
+ /* convert address */
+ switch (l_ctx->address->sa_family)
+ {
+ case AF_INET:
+ GNUNET_assert(l_ctx->addr_len == sizeof(struct sockaddr_in));
+ memset (&u4, 0, sizeof(u4));
+ u6.options = htonl (0);
+ u4.ipv4_addr = ((struct sockaddr_in *) l_ctx->address)->sin_addr.s_addr;
+ u4.u4_port = ((struct sockaddr_in *) l_ctx->address)->sin_port;
+ arg = &u4;
+ args = sizeof(u4);
+ break;
+ case AF_INET6:
+ GNUNET_assert(l_ctx->addr_len == sizeof(struct sockaddr_in6));
+ memset (&u6, 0, sizeof(u6));
+ u6.options = htonl (0);
+ u6.ipv6_addr = ((struct sockaddr_in6 *) l_ctx->address)->sin6_addr;
+ u6.u6_port = ((struct sockaddr_in6 *) l_ctx->address)->sin6_port;
+ arg = &u6;
+ args = sizeof(u6);
+ break;
+ default:
+ GNUNET_break(0);
+ return GNUNET_YES;
+ }
+
if ((GNUNET_YES == l_ctx->must_have_frag_ctx) && (NULL == s->frag_ctx))
return GNUNET_YES;
- if (0 == GNUNET_HELLO_address_cmp (s->address, l_ctx->address))
+ /* Does not compare peer identities but addresses */
+ if ((args == s->address->address_length) &&
+ (0 == memcmp (arg, s->address->address, args)))
{
l_ctx->res = s;
return GNUNET_YES;
return GNUNET_YES;
}
+
/**
* Transmit an acknowledgement.
*
struct Session *s;
struct LookupContext l_ctx;
- l_ctx.address = GNUNET_HELLO_address_allocate (NULL, PLUGIN_NAME, rc->src_addr,
- rc->addr_len, GNUNET_HELLO_ADDRESS_INFO_NONE);
- l_ctx.res = NULL;
+ l_ctx.address = rc->src_addr;
+ l_ctx.addr_len = rc->addr_len;
l_ctx.must_have_frag_ctx = GNUNET_NO;
+ l_ctx.res = NULL;
GNUNET_CONTAINER_multipeermap_iterate (rc->plugin->sessions,
- &lookup_session_by_addr_it, &l_ctx);
+ &lookup_session_by_sockaddr_it, &l_ctx);
s = l_ctx.res;
-
if (NULL == s)
- return;
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "Trying to transmit ACK to peer `%s' but not session found!\n",
+ GNUNET_a2s(rc->src_addr, rc->addr_len));
+
+ GNUNET_CONTAINER_heap_remove_node (rc->hnode);
+ GNUNET_DEFRAGMENT_context_destroy (rc->defrag);
+ GNUNET_free (rc);
+ return;
+ }
if (s->flow_delay_for_other_peer.rel_value_us <= UINT32_MAX)
delay = s->flow_delay_for_other_peer.rel_value_us;
udpw->session = s;
udpw->timeout = GNUNET_TIME_UNIT_FOREVER_ABS;
udpw->msg_buf = (char *) &udpw[1];
- udpw->msg_type = MSG_ACK;
+ udpw->msg_type = UMT_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->sender = *rc->plugin->env->my_identity;
memcpy (&udp_ack[1], msg, ntohs (msg->size));
enqueue (rc->plugin, udpw);
+ schedule_select (rc->plugin);
}
+
static void
-read_process_msg (struct Plugin *plugin, const struct GNUNET_MessageHeader *msg,
- const struct sockaddr *addr, socklen_t fromlen)
+read_process_msg (struct Plugin *plugin,
+ const struct GNUNET_MessageHeader *msg,
+ const struct sockaddr *addr,
+ socklen_t fromlen)
{
if (ntohs (msg->size) < sizeof(struct UDPMessage))
{
process_udp_message (plugin, (const struct UDPMessage *) msg, addr, fromlen);
}
+
static void
-read_process_ack (struct Plugin *plugin, const struct GNUNET_MessageHeader *msg,
- const struct sockaddr *addr, socklen_t fromlen)
+read_process_ack (struct Plugin *plugin,
+ const struct GNUNET_MessageHeader *msg,
+ const struct sockaddr *addr,
+ socklen_t fromlen)
{
const struct GNUNET_MessageHeader *ack;
const struct UDP_ACK_Message *udp_ack;
}
udp_ack = (const struct UDP_ACK_Message *) msg;
- l_ctx.address = GNUNET_HELLO_address_allocate (NULL, PLUGIN_NAME,
- (const struct sockaddr *) addr, fromlen, GNUNET_HELLO_ADDRESS_INFO_NONE);
+ /* Lookup session based on sockaddr */
+ l_ctx.address = addr;
+ l_ctx.addr_len = fromlen;
l_ctx.res = NULL;
l_ctx.must_have_frag_ctx = GNUNET_YES;
GNUNET_CONTAINER_multipeermap_iterate (plugin->sessions,
- &lookup_session_by_addr_it, &l_ctx);
+ &lookup_session_by_sockaddr_it, &l_ctx);
s = l_ctx.res;
if ((NULL == s) || (NULL == s->frag_ctx))
{
fragmented_message_done (s->frag_ctx, GNUNET_OK);
}
+
static void
read_process_fragment (struct Plugin *plugin,
- const struct GNUNET_MessageHeader *msg, const struct sockaddr *addr,
- socklen_t fromlen)
+ const struct GNUNET_MessageHeader *msg,
+ const struct sockaddr *addr,
+ socklen_t fromlen)
{
struct DefragContext *d_ctx;
struct GNUNET_TIME_Absolute now;
LOG(GNUNET_ERROR_TYPE_DEBUG, "UDP processes %u-byte fragment from `%s'\n",
(unsigned int ) ntohs (msg->size), GNUNET_a2s (addr, fromlen));
/* Lookup existing receive context for this address */
- GNUNET_CONTAINER_heap_iterate (plugin->defrag_ctxs, &find_receive_context,
- &frc);
+ GNUNET_CONTAINER_heap_iterate (plugin->defrag_ctxs,
+ &find_receive_context, &frc);
now = GNUNET_TIME_absolute_get ();
d_ctx = frc.rc;
}
}
+
/**
* Read and process a message from the given socket.
*
* @param rsock socket to read from
*/
static void
-udp_select_read (struct Plugin *plugin, struct GNUNET_NETWORK_Handle *rsock)
+udp_select_read (struct Plugin *plugin,
+ struct GNUNET_NETWORK_Handle *rsock)
{
socklen_t fromlen;
struct sockaddr_storage addr;
GNUNET_STATISTICS_update (plugin->env->stats, "# UDP, total, bytes, received",
size, GNUNET_NO);
+
+
+
switch (ntohs (msg->type))
{
case GNUNET_MESSAGE_TYPE_TRANSPORT_BROADCAST_BEACON:
}
}
+
static struct UDP_MessageWrapper *
remove_timeout_messages_and_select (struct UDP_MessageWrapper *head,
- struct GNUNET_NETWORK_Handle *sock)
+ struct GNUNET_NETWORK_Handle *sock)
{
struct UDP_MessageWrapper *udpw = NULL;
struct GNUNET_TIME_Relative remaining;
/* Message timed out */
switch (udpw->msg_type)
{
- case MSG_UNFRAGMENTED:
+ case UMT_MSG_UNFRAGMENTED:
GNUNET_STATISTICS_update (plugin->env->stats,
"# UDP, total, bytes, sent, timeout", udpw->msg_size, GNUNET_NO);
GNUNET_STATISTICS_update (plugin->env->stats,
dequeue (plugin, udpw);
GNUNET_free(udpw);
break;
- case MSG_FRAGMENTED:
+ case UMT_MSG_FRAGMENTED:
/* Fragmented message */
GNUNET_STATISTICS_update (plugin->env->stats,
"# UDP, total, bytes, sent, timeout", udpw->frag_ctx->on_wire_size,
/* Remove fragmented message due to timeout */
fragmented_message_done (udpw->frag_ctx, GNUNET_SYSERR);
break;
- case MSG_ACK:
+ case UMT_MSG_ACK:
GNUNET_STATISTICS_update (plugin->env->stats,
"# UDP, total, bytes, sent, timeout", udpw->msg_size, GNUNET_NO);
GNUNET_STATISTICS_update (plugin->env->stats,
return udpw;
}
+
static void
-analyze_send_error (struct Plugin *plugin, const struct sockaddr * sa,
- socklen_t slen, int error)
+analyze_send_error (struct Plugin *plugin,
+ const struct sockaddr *sa,
+ socklen_t slen, int error)
{
static int network_down_error;
struct GNUNET_ATS_Information type;
if (((GNUNET_ATS_NET_LAN == ntohl (type.value))
|| (GNUNET_ATS_NET_WAN == ntohl (type.value)))
&& ((ENETUNREACH == errno)|| (ENETDOWN == errno)))
- {
- if ((network_down_error == GNUNET_NO) && (slen == sizeof (struct sockaddr_in)))
- {
- /* IPv4: "Network unreachable" or "Network down"
- *
- * This indicates we do not have connectivity
- */
- LOG (GNUNET_ERROR_TYPE_WARNING | GNUNET_ERROR_TYPE_BULK,
- _("UDP could not transmit message to `%s': "
- "Network seems down, please check your network configuration\n"),
- GNUNET_a2s (sa, slen));
- }
- if ((network_down_error == GNUNET_NO) && (slen == sizeof (struct sockaddr_in6)))
- {
- /* IPv6: "Network unreachable" or "Network down"
- *
- * This indicates that this system is IPv6 enabled, but does not
- * have a valid global IPv6 address assigned or we do not have
- * connectivity
- */
-
- LOG (GNUNET_ERROR_TYPE_WARNING | GNUNET_ERROR_TYPE_BULK,
- _("UDP could not transmit IPv6 message! "
- "Please check your network configuration and disable IPv6 if your "
- "connection does not have a global IPv6 address\n"));
- }
- }
- else
- {
- LOG (GNUNET_ERROR_TYPE_WARNING,
- "UDP could not transmit message to `%s': `%s'\n",
- GNUNET_a2s (sa, slen), STRERROR (error));
- }
+ {
+ if ((network_down_error == GNUNET_NO) && (slen == sizeof (struct sockaddr_in)))
+ {
+ /* IPv4: "Network unreachable" or "Network down"
+ *
+ * This indicates we do not have connectivity
+ */
+ LOG (GNUNET_ERROR_TYPE_WARNING | GNUNET_ERROR_TYPE_BULK,
+ _("UDP could not transmit message to `%s': "
+ "Network seems down, please check your network configuration\n"),
+ GNUNET_a2s (sa, slen));
}
+ if ((network_down_error == GNUNET_NO) && (slen == sizeof (struct sockaddr_in6)))
+ {
+ /* IPv6: "Network unreachable" or "Network down"
+ *
+ * This indicates that this system is IPv6 enabled, but does not
+ * have a valid global IPv6 address assigned or we do not have
+ * connectivity
+ */
+
+ LOG (GNUNET_ERROR_TYPE_WARNING | GNUNET_ERROR_TYPE_BULK,
+ _("UDP could not transmit IPv6 message! "
+ "Please check your network configuration and disable IPv6 if your "
+ "connection does not have a global IPv6 address\n"));
+ }
+ }
+ else
+ {
+ LOG (GNUNET_ERROR_TYPE_WARNING,
+ "UDP could not transmit message to `%s': `%s'\n",
+ GNUNET_a2s (sa, slen), STRERROR (error));
+ }
+}
+
static size_t
-udp_select_send (struct Plugin *plugin, struct GNUNET_NETWORK_Handle *sock)
+udp_select_send (struct Plugin *plugin,
+ struct GNUNET_NETWORK_Handle *sock)
{
- const struct sockaddr * sa;
ssize_t sent;
socklen_t slen;
-
- struct UDP_MessageWrapper *udpw = NULL;
+ struct sockaddr *a;
+ const struct IPv4UdpAddress *u4;
+ struct sockaddr_in a4;
+ const struct IPv6UdpAddress *u6;
+ struct sockaddr_in6 a6;
+ struct UDP_MessageWrapper *udpw;
/* Find message to send */
- udpw = remove_timeout_messages_and_select (
- (sock == plugin->sockv4) ?
- plugin->ipv4_queue_head : plugin->ipv6_queue_head, sock);
+ udpw = remove_timeout_messages_and_select ((sock == plugin->sockv4)
+ ? plugin->ipv4_queue_head
+ : plugin->ipv6_queue_head,
+ sock);
if (NULL == udpw)
return 0; /* No message to send */
- sa = udpw->session->address->address;
- slen = udpw->session->address->address_length;
+ if (sizeof (struct IPv4UdpAddress) == udpw->session->address->address_length)
+ {
+ u4 = udpw->session->address->address;
+ memset (&a4, 0, sizeof(a4));
+ a4.sin_family = AF_INET;
+#if HAVE_SOCKADDR_IN_SIN_LEN
+ a4.sin_len = sizeof (a4);
+#endif
+ a4.sin_port = u4->u4_port;
+ memcpy (&a4.sin_addr, &u4->ipv4_addr, sizeof(struct in_addr));
+ a = (struct sockaddr *) &a4;
+ slen = sizeof (a4);
+ }
+ else if (sizeof (struct IPv6UdpAddress) == udpw->session->address->address_length)
+ {
+ u6 = udpw->session->address->address;
+ memset (&a6, 0, sizeof(a6));
+ a6.sin6_family = AF_INET6;
+#if HAVE_SOCKADDR_IN_SIN_LEN
+ a6.sin6_len = sizeof (a6);
+#endif
+ a6.sin6_port = u6->u6_port;
+ memcpy (&a6.sin6_addr, &u6->ipv6_addr, sizeof(struct in6_addr));
+ a = (struct sockaddr *) &a6;
+ slen = sizeof (a6);
+ }
+ else
+ {
+ call_continuation (udpw, GNUNET_OK);
+ dequeue (plugin, udpw);
+ GNUNET_free (udpw);
+ return GNUNET_SYSERR;
+ }
- sent = GNUNET_NETWORK_socket_sendto (sock, udpw->msg_buf, udpw->msg_size, sa,
+ sent = GNUNET_NETWORK_socket_sendto (sock, udpw->msg_buf, udpw->msg_size, a,
slen);
if (GNUNET_SYSERR == sent)
{
/* Failure */
- analyze_send_error (plugin, sa, slen, errno);
+ analyze_send_error (plugin, a, slen, errno);
call_continuation (udpw, GNUNET_SYSERR);
GNUNET_STATISTICS_update (plugin->env->stats,
"# UDP, total, bytes, sent, failure", sent, GNUNET_NO);
LOG(GNUNET_ERROR_TYPE_DEBUG,
"UDP transmitted %u-byte message to `%s' `%s' (%d: %s)\n",
(unsigned int ) (udpw->msg_size), GNUNET_i2s (&udpw->session->target),
- GNUNET_a2s (sa, slen), (int ) sent,
+ GNUNET_a2s (a, slen), (int ) sent,
(sent < 0) ? STRERROR (errno) : "ok");
GNUNET_STATISTICS_update (plugin->env->stats,
"# UDP, total, bytes, sent, success", sent, GNUNET_NO);
return sent;
}
+
/**
* We have been notified that our readset has something to read. We don't
* know which socket needs to be read, so we have to check each one
* @param tc the scheduling context (for rescheduling this function again)
*/
static void
-udp_plugin_select (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+udp_plugin_select (void *cls,
+ const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct Plugin *plugin = cls;
schedule_select (plugin);
}
+
/**
* We have been notified that our readset has something to read. We don't
* know which socket needs to be read, so we have to check each one
* @param tc the scheduling context (for rescheduling this function again)
*/
static void
-udp_plugin_select_v6 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+udp_plugin_select_v6 (void *cls,
+ const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct Plugin *plugin = cls;
schedule_select (plugin);
}
+
/**
+ * Setup the UDP sockets (for IPv4 and IPv6) for the plugin.
*
+ * @param plugin the plugin to initialize
+ * @param bind_v6 IPv6 address to bind to (can be NULL, for 'any')
+ * @param bind_v4 IPv4 address to bind to (can be NULL, for 'any')
* @return number of sockets that were successfully bound
*/
static int
-setup_sockets (struct Plugin *plugin, const struct sockaddr_in6 *bind_v6,
- const struct sockaddr_in *bind_v4)
+setup_sockets (struct Plugin *plugin,
+ const struct sockaddr_in6 *bind_v6,
+ const struct sockaddr_in *bind_v4)
{
int tries;
int sockets_created = 0;
/* Create IPv6 socket */
eno = EINVAL;
- if (plugin->enable_ipv6 == GNUNET_YES)
+ if (GNUNET_YES == plugin->enable_ipv6)
{
plugin->sockv6 = GNUNET_NETWORK_socket_create (PF_INET6, SOCK_DGRAM, 0);
if (NULL == plugin->sockv6)
if (0 == plugin->port)
/* autodetect */
- server_addrv4.sin_port = htons (
- GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_STRONG, 33537)
- + 32000);
+ server_addrv4.sin_port = htons (GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_STRONG,
+ 33537)
+ + 32000);
else
server_addrv4.sin_port = htons (plugin->port);
tries = 0;
while (tries < 10)
{
- LOG(GNUNET_ERROR_TYPE_DEBUG, "Binding to IPv4 `%s'\n",
- GNUNET_a2s (server_addr, addrlen));
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Binding to IPv4 `%s'\n",
+ GNUNET_a2s (server_addr, addrlen));
/* binding */
if (GNUNET_OK
plugin->sockv4 = NULL;
}
- if (plugin->sockv4 != NULL )
+ if (NULL != plugin->sockv4)
{
LOG(GNUNET_ERROR_TYPE_DEBUG, "IPv4 socket created on port %s\n",
GNUNET_a2s (server_addr, addrlen));
schedule_select (plugin);
plugin->nat = GNUNET_NAT_register (plugin->env->cfg, GNUNET_NO, plugin->port,
- sockets_created, (const struct sockaddr **) addrs, addrlens,
- &udp_nat_port_map_callback, NULL, plugin);
+ sockets_created,
+ (const struct sockaddr **) addrs, addrlens,
+ &udp_nat_port_map_callback, NULL, plugin);
return sockets_created;
}
+
/**
* The exported method. Makes the core api available via a global and
* returns the udp transport API.
*
- * @param cls our 'struct GNUNET_TRANSPORT_PluginEnvironment'
- * @return our 'struct GNUNET_TRANSPORT_PluginFunctions'
+ * @param cls our `struct GNUNET_TRANSPORT_PluginEnvironment`
+ * @return our `struct GNUNET_TRANSPORT_PluginFunctions`
*/
void *
libgnunet_plugin_transport_udp_init (void *cls)
unsigned long long enable_v6;
unsigned long long enable_broadcasting;
unsigned long long enable_broadcasting_recv;
- char * bind4_address;
- char * bind6_address;
- char * fancy_interval;
+ char *bind4_address;
+ char *bind6_address;
+ char *fancy_interval;
struct GNUNET_TIME_Relative interval;
struct sockaddr_in server_addrv4;
struct sockaddr_in6 server_addrv6;
return api;
}
- GNUNET_assert(NULL != env->stats);
-
/* 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_OK !=
+ GNUNET_CONFIGURATION_get_value_number (env->cfg, "transport-udp",
+ "PORT", &port))
port = 2086;
- if (GNUNET_OK
- != GNUNET_CONFIGURATION_get_value_number (env->cfg, "transport-udp",
- "ADVERTISED_PORT", &aport))
+ if (GNUNET_OK !=
+ GNUNET_CONFIGURATION_get_value_number (env->cfg, "transport-udp",
+ "ADVERTISED_PORT", &aport))
aport = port;
if (port > 65535)
{
- LOG(GNUNET_ERROR_TYPE_WARNING,
- _("Given `%s' option is out of range: %llu > %u\n"), "PORT", port,
- 65535);
- return NULL ;
+ LOG (GNUNET_ERROR_TYPE_WARNING,
+ _("Given `%s' option is out of range: %llu > %u\n"),
+ "PORT", port,
+ 65535);
+ return NULL;
}
/* Protocols */
- if ((GNUNET_YES
- == GNUNET_CONFIGURATION_get_value_yesno (env->cfg, "nat", "DISABLEV6")))
+ if (GNUNET_YES ==
+ GNUNET_CONFIGURATION_get_value_yesno (env->cfg, "nat", "DISABLEV6"))
enable_v6 = GNUNET_NO;
else
enable_v6 = GNUNET_YES;
/* Addresses */
have_bind4 = GNUNET_NO;
memset (&server_addrv4, 0, sizeof(server_addrv4));
- if (GNUNET_YES
- == GNUNET_CONFIGURATION_get_value_string (env->cfg, "transport-udp",
- "BINDTO", &bind4_address))
+ if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_string (env->cfg, "transport-udp",
+ "BINDTO", &bind4_address))
{
- LOG(GNUNET_ERROR_TYPE_DEBUG,
- "Binding udp plugin to specific address: `%s'\n", bind4_address);
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Binding udp plugin to specific address: `%s'\n",
+ bind4_address);
if (1 != inet_pton (AF_INET, bind4_address, &server_addrv4.sin_addr))
{
- GNUNET_free(bind4_address);
- return NULL ;
+ GNUNET_free (bind4_address);
+ return NULL;
}
have_bind4 = GNUNET_YES;
}
GNUNET_free_non_null(bind4_address);
have_bind6 = GNUNET_NO;
memset (&server_addrv6, 0, sizeof(server_addrv6));
- if (GNUNET_YES
- == GNUNET_CONFIGURATION_get_value_string (env->cfg, "transport-udp",
- "BINDTO6", &bind6_address))
+ if (GNUNET_YES ==
+ GNUNET_CONFIGURATION_get_value_string (env->cfg, "transport-udp",
+ "BINDTO6", &bind6_address))
{
- LOG(GNUNET_ERROR_TYPE_DEBUG,
- "Binding udp plugin to specific address: `%s'\n", bind6_address);
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Binding udp plugin to specific address: `%s'\n", bind6_address);
if (1 != inet_pton (AF_INET6, bind6_address, &server_addrv6.sin6_addr))
{
- LOG(GNUNET_ERROR_TYPE_ERROR, _("Invalid IPv6 address: `%s'\n"),
- bind6_address);
- GNUNET_free(bind6_address);
- return NULL ;
+ LOG (GNUNET_ERROR_TYPE_ERROR,
+ _("Invalid IPv6 address: `%s'\n"),
+ bind6_address);
+ GNUNET_free (bind6_address);
+ return NULL;
}
have_bind6 = GNUNET_YES;
}
- GNUNET_free_non_null(bind6_address);
+ GNUNET_free_non_null (bind6_address);
/* Initialize my flags */
myoptions = 0;
}
/* Maximum datarate */
- if (GNUNET_OK
- != GNUNET_CONFIGURATION_get_value_number (env->cfg, "transport-udp",
- "MAX_BPS", &udp_max_bps))
+ if (GNUNET_OK !=
+ GNUNET_CONFIGURATION_get_value_number (env->cfg, "transport-udp",
+ "MAX_BPS", &udp_max_bps))
{
udp_max_bps = 1024 * 1024 * 50; /* 50 MB/s == infinity for practical purposes */
}
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_tracker_init (&p->tracker, NULL, NULL,
GNUNET_BANDWIDTH_value_init ((uint32_t) udp_max_bps), 30);
plugin = p;
LOG(GNUNET_ERROR_TYPE_DEBUG, "Setting up sockets\n");
- res = setup_sockets (p, (GNUNET_YES == have_bind6) ? &server_addrv6 : NULL,
- (GNUNET_YES == have_bind4) ? &server_addrv4 : NULL );
+ res = setup_sockets (p,
+ (GNUNET_YES == have_bind6) ? &server_addrv6 : NULL,
+ (GNUNET_YES == have_bind4) ? &server_addrv4 : NULL);
if ((res == 0) || ((p->sockv4 == NULL )&& (p->sockv6 == NULL)))
{
LOG (GNUNET_ERROR_TYPE_ERROR,
return api;
}
+
+/**
+ * Function called on each entry in the defragmentation heap to
+ * clean it up.
+ *
+ * @param cls NULL
+ * @param node node in the heap (to be removed)
+ * @param element a `struct DefragContext` to be cleaned up
+ * @param cost unused
+ * @return #GNUNET_YES
+ */
static int
-heap_cleanup_iterator (void *cls, struct GNUNET_CONTAINER_HeapNode *node,
- void *element, GNUNET_CONTAINER_HeapCostType cost)
+heap_cleanup_iterator (void *cls,
+ struct GNUNET_CONTAINER_HeapNode *node,
+ void *element,
+ GNUNET_CONTAINER_HeapCostType cost)
{
- struct DefragContext * d_ctx = element;
+ struct DefragContext *d_ctx = element;
GNUNET_CONTAINER_heap_remove_node (node);
GNUNET_DEFRAGMENT_context_destroy (d_ctx->defrag);
- GNUNET_free(d_ctx);
-
+ GNUNET_free (d_ctx);
return GNUNET_YES;
}
+
/**
* The exported method. Makes the core api available via a global and
* returns the udp transport API.
*
- * @param cls our 'struct GNUNET_TRANSPORT_PluginEnvironment'
+ * @param cls our `struct GNUNET_TRANSPORT_PluginEnvironment`
* @return NULL
*/
void *
struct Plugin *plugin = api->cls;
struct PrettyPrinterContext *cur;
struct PrettyPrinterContext *next;
+ struct UDP_MessageWrapper *udpw;
if (NULL == plugin)
{
GNUNET_free(api);
- return NULL ;
+ return NULL;
}
-
stop_broadcast (plugin);
if (plugin->select_task != GNUNET_SCHEDULER_NO_TASK )
{
{
if (NULL != plugin->sockv4)
{
- GNUNET_break(GNUNET_OK == GNUNET_NETWORK_socket_close (plugin->sockv4));
+ GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (plugin->sockv4));
plugin->sockv4 = NULL;
}
GNUNET_NETWORK_fdset_destroy (plugin->rs_v4);
{
if (NULL != plugin->sockv6)
{
- GNUNET_break(GNUNET_OK == GNUNET_NETWORK_socket_close (plugin->sockv6));
+ GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (plugin->sockv6));
plugin->sockv6 = NULL;
GNUNET_NETWORK_fdset_destroy (plugin->rs_v6);
}
if (NULL != plugin->defrag_ctxs)
{
- GNUNET_CONTAINER_heap_iterate (plugin->defrag_ctxs, heap_cleanup_iterator,
- NULL );
+ GNUNET_CONTAINER_heap_iterate (plugin->defrag_ctxs,
+ &heap_cleanup_iterator, NULL);
GNUNET_CONTAINER_heap_destroy (plugin->defrag_ctxs);
plugin->defrag_ctxs = NULL;
}
- if (plugin->mst != NULL )
+ if (NULL != plugin->mst)
{
GNUNET_SERVER_mst_destroy (plugin->mst);
plugin->mst = NULL;
}
/* Clean up leftover messages */
- struct UDP_MessageWrapper * udpw;
udpw = plugin->ipv4_queue_head;
- while (udpw != NULL )
+ while (NULL != udpw)
{
struct UDP_MessageWrapper *tmp = udpw->next;
dequeue (plugin, udpw);
call_continuation (udpw, GNUNET_SYSERR);
GNUNET_free(udpw);
-
udpw = tmp;
}
udpw = plugin->ipv6_queue_head;
- while (udpw != NULL )
+ while (NULL != udpw)
{
struct UDP_MessageWrapper *tmp = udpw->next;
dequeue (plugin, udpw);
call_continuation (udpw, GNUNET_SYSERR);
GNUNET_free(udpw);
-
udpw = tmp;
}
/* Clean up sessions */
- LOG(GNUNET_ERROR_TYPE_DEBUG, "Cleaning up sessions\n");
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Cleaning up sessions\n");
GNUNET_CONTAINER_multipeermap_iterate (plugin->sessions,
- &disconnect_and_free_it, plugin);
+ &disconnect_and_free_it, plugin);
GNUNET_CONTAINER_multipeermap_destroy (plugin->sessions);
next = ppc_dll_head;
for (cur = next; NULL != cur; cur = next)
{
+ GNUNET_break(0);
next = cur->next;
- GNUNET_CONTAINER_DLL_remove(ppc_dll_head, ppc_dll_tail, cur);
+ 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);
+ GNUNET_free (cur);
}
- struct Allocator *allocator;
- while (NULL != aehead)
- {
- allocator = aehead;
- GNUNET_CONTAINER_DLL_remove (aehead, aetail, allocator);
- GNUNET_free (allocator);
- }
-#endif
- return NULL ;
+ GNUNET_free (plugin);
+ GNUNET_free (api);
+ return NULL;
}
/* end of plugin_transport_udp.c */
projects / oweals / gnunet.git / blobdiff