{
struct Session *res;
const struct GNUNET_HELLO_Address *addr;
+ int inbound;
};
uint16_t port;
uint32_t options;
- 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;
struct sockaddr_in6 *v6;
size_t len;
+ if (NULL == addr)
+ {
+ GNUNET_break (0);
+ return NULL;
+ }
+
switch (addrlen)
{
case sizeof (struct IPv4UdpAddress):
udp_address_to_string (NULL, (void *) address->address,
address->address_length),
GNUNET_a2s (s->sock_addr, s->addrlen));
+ if (s->inbound != cctx->inbound)
+ return GNUNET_YES;
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))
*
* @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,
+ int inbound)
{
struct Plugin * plugin = cls;
struct IPv6UdpAddress * udp_a6;
struct SessionCompareContext cctx;
cctx.addr = address;
cctx.res = NULL;
+ cctx.inbound = inbound;
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Looking for existing session for peer `%s' `%s' \n",
GNUNET_i2s (&address->peer),
static struct Session *
udp_plugin_create_session (void *cls,
- const struct GNUNET_HELLO_Address *address)
+ const struct GNUNET_HELLO_Address *address,
+ int inbound)
{
struct Session *s;
NULL, NULL);
if (NULL == s)
return NULL; /* protocol not supported or address invalid */
+ s->inbound = inbound;
LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Creating new session %p for peer `%s' address `%s'\n",
+ "Creating new %s session %p for peer `%s' address `%s'\n",
+ (GNUNET_YES == s->inbound) ? "inbound" : "outbound",
s,
GNUNET_i2s(&address->peer),
udp_address_to_string(NULL,address->address,address->address_length));
return NULL;
/* otherwise create new */
- if (NULL != (s = udp_plugin_lookup_session (cls, address)))
+ if (NULL != (s = udp_plugin_lookup_session (cls, address, GNUNET_NO)))
return s;
- return udp_plugin_create_session (cls, address);
+ return udp_plugin_create_session (cls, address, GNUNET_NO);
}
GNUNET_a2s (sender_addr, sender_addr_len));
struct GNUNET_HELLO_Address * address = GNUNET_HELLO_address_allocate(&msg->sender, "udp", arg, args);
- if (NULL == (s = udp_plugin_lookup_session (plugin, address)))
+ if (NULL == (s = udp_plugin_lookup_session (plugin, address, GNUNET_YES)))
{
- 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);
+ s = udp_plugin_create_session (plugin, address, 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);
struct LookupContext
{
- const struct sockaddr * addr;
-
struct Session *res;
+ const struct sockaddr * addr;
+
size_t addrlen;
+
+ int must_have_frag_ctx;
};
struct LookupContext *l_ctx = cls;
struct Session * s = value;
+ if ((GNUNET_YES == l_ctx->must_have_frag_ctx) && (NULL == s->frag_ctx))
+ return GNUNET_YES;
+
+ /*
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Comparing session: have %s %s %p<-> want %s\n",
+ GNUNET_a2s(s->sock_addr, s->addrlen),
+ (GNUNET_YES == s->inbound) ? "inbound" : "outbound",
+ s->frag_ctx,
+ GNUNET_a2s(l_ctx->addr, l_ctx->addrlen));
+ */
if ((s->addrlen == l_ctx->addrlen) &&
(0 == memcmp (s->sock_addr, l_ctx->addr, s->addrlen)))
{
l_ctx->res = s;
- return GNUNET_NO;
+ return GNUNET_YES;
}
return GNUNET_YES;
}
l_ctx.addr = rc->src_addr;
l_ctx.addrlen = rc->addr_len;
l_ctx.res = NULL;
+ l_ctx.must_have_frag_ctx = GNUNET_NO;
GNUNET_CONTAINER_multihashmap_iterate (rc->plugin->sessions,
&lookup_session_by_addr_it,
&l_ctx);
l_ctx.addr = (const struct sockaddr *) addr;
l_ctx.addrlen = fromlen;
l_ctx.res = NULL;
+ l_ctx.must_have_frag_ctx = GNUNET_YES;
GNUNET_CONTAINER_multihashmap_iterate (plugin->sessions,
&lookup_session_by_addr_it,
&l_ctx);
s = l_ctx.res;
-
if ((NULL == s) || (NULL == s->frag_ctx))
{
return;
}
+
flow_delay.rel_value_us = (uint64_t) ntohl (udp_ack->delay);
LOG (GNUNET_ERROR_TYPE_DEBUG,
"We received a sending delay of %s\n",