#include "plugin_transport.h"
#include "transport.h"
-#define DEBUG_TCP GNUNET_YES
-#define DEBUG_TCP_NAT GNUNET_YES
+#define DEBUG_TCP GNUNET_NO
+#define DEBUG_TCP_NAT GNUNET_NO
/**
* How long until we give up on transmitting the welcome message?
*/
struct LocalAddrList
{
-
+
/**
* This is a doubly linked list.
*/
*/
int inbound;
+ /**
+ * Was this session created using NAT traversal?
+ */
+ int is_nat;
+
};
* List of our IP addresses.
*/
struct LocalAddrList *lal_head;
-
+
/**
* Tail of our IP address list.
- */
+ */
struct LocalAddrList *lal_tail;
/**
/**
* Function called for a quick conversion of the binary address to
- * a numeric address. Note that the caller must not free the
+ * a numeric address. Note that the caller must not free the
* address and that the next call to this function is allowed
* to override the address again.
*
* @param cls closure ('struct Plugin*')
* @param addr binary address
* @param addrlen length of the address
- * @return string representing the same address
+ * @return string representing the same address
*/
-static const char*
+static const char*
tcp_address_to_string (void *cls,
const void *addr,
size_t addrlen)
GNUNET_assert (client == NULL);
#if DEBUG_TCP
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
"Creating new session for peer `%4s'\n",
GNUNET_i2s (target));
#endif
ret = GNUNET_malloc (sizeof (struct Session));
ret->last_activity = GNUNET_TIME_absolute_get ();
ret->plugin = plugin;
+ ret->is_nat = is_nat;
if (is_nat != GNUNET_YES) /* If not a NAT WAIT conn, add it to global list */
{
ret->next = plugin->sessions;
GNUNET_STATISTICS_update (plugin->env->stats,
gettext_noop ("# bytes currently in TCP buffers"),
pm->message_size,
- GNUNET_NO);
+ GNUNET_NO);
GNUNET_CONTAINER_DLL_insert (ret->pending_messages_head,
ret->pending_messages_tail,
pm);
/* do this call before callbacks (so that if callbacks destroy
session, they have a chance to cancel actions done by this
call) */
- process_pending_messages (session);
+ process_pending_messages (session);
pid = session->target;
/* no do callbacks and do not use session again since
the callbacks may abort the session */
GNUNET_STATISTICS_update (plugin->env->stats,
gettext_noop ("# bytes currently in TCP buffers"),
- (int64_t) ret,
- GNUNET_NO);
+ GNUNET_NO);
GNUNET_STATISTICS_update (plugin->env->stats,
gettext_noop ("# bytes discarded by TCP (timeout)"),
ret,
- GNUNET_NO);
+ GNUNET_NO);
return 0;
}
/* copy all pending messages that would fit */
cbuf = buf;
hd = NULL;
tl = NULL;
- while (NULL != (pos = session->pending_messages_head))
+ while (NULL != (pos = session->pending_messages_head))
{
- if (ret + pos->message_size > size)
+ if (ret + pos->message_size > size)
break;
GNUNET_CONTAINER_DLL_remove (session->pending_messages_head,
session->pending_messages_tail,
/* schedule 'continuation' before callbacks so that callbacks that
cancel everything don't cause us to use a session that no longer
exists... */
- process_pending_messages (session);
+ process_pending_messages (session);
session->last_activity = GNUNET_TIME_absolute_get ();
pid = session->target;
/* we'll now call callbacks that may cancel the session; hence
GNUNET_STATISTICS_update (plugin->env->stats,
gettext_noop ("# bytes currently in TCP buffers"),
- (int64_t) ret,
- GNUNET_NO);
+ GNUNET_NO);
GNUNET_STATISTICS_update (plugin->env->stats,
gettext_noop ("# bytes transmitted via TCP"),
ret,
- GNUNET_NO);
+ GNUNET_NO);
return ret;
}
(session->connect_addr != NULL) ?
tcp_address_to_string (session->plugin,
session->connect_addr,
- session->connect_alen) : "*",
+ session->connect_alen) : "*",
session);
#endif
/* remove from session list */
GNUNET_STATISTICS_update (session->plugin->env->stats,
gettext_noop ("# bytes currently in TCP buffers"),
- (int64_t) pm->message_size,
- GNUNET_NO);
+ GNUNET_NO);
GNUNET_STATISTICS_update (session->plugin->env->stats,
gettext_noop ("# bytes discarded by TCP (disconnect)"),
pm->message_size,
- GNUNET_NO);
+ GNUNET_NO);
GNUNET_CONTAINER_DLL_remove (session->pending_messages_head,
session->pending_messages_tail,
pm);
GNUNET_SCHEDULER_cancel (session->plugin->env->sched,
session->receive_delay_task);
if (session->client != NULL)
- GNUNET_SERVER_receive_done (session->client,
+ GNUNET_SERVER_receive_done (session->client,
GNUNET_SYSERR);
}
- if (session->client != NULL)
+ if (session->client != NULL)
GNUNET_SERVER_client_drop (session->client);
GNUNET_STATISTICS_update (session->plugin->env->stats,
gettext_noop ("# TCP sessions active"),
-1,
- GNUNET_NO);
+ GNUNET_NO);
GNUNET_free_non_null (session->connect_addr);
GNUNET_free (session);
}
/**
* Given two otherwise equivalent sessions, pick the better one.
- *
+ *
* @param s1 one session (also default)
* @param s2 other session
* @return "better" session (more active)
char *port_as_string;
pid_t pid;
const struct sockaddr *sa = (const struct sockaddr *)addr;
+
#if DEBUG_TCP_NAT
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
_("called run_gnunet_nat_client addrlen %d others are %d and %d\n"), addrlen, sizeof (struct sockaddr), sizeof (struct sockaddr_in));
GNUNET_STATISTICS_update (plugin->env->stats,
gettext_noop ("# bytes TCP was asked to transmit"),
msgbuf_size,
- GNUNET_NO);
+ GNUNET_NO);
/* FIXME: we could do this cheaper with a hash table
where we could restrict the iteration to entries that match
the target peer... */
{
cand_session = NULL;
next = plugin->sessions;
- while (NULL != (session = next))
+ while (NULL != (session = next))
{
next = session->next;
GNUNET_assert (session->client != NULL);
if (0 != memcmp (target,
- &session->target,
+ &session->target,
sizeof (struct GNUNET_PeerIdentity)))
continue;
if ( ( (GNUNET_SYSERR == force_address) &&
(session->expecting_welcome == GNUNET_NO) ) ||
- (GNUNET_NO == force_address) )
+ (GNUNET_NO == force_address) )
{
cand_session = select_better_session (cand_session,
session);
GNUNET_break (0);
break;
}
- if (session->inbound == GNUNET_YES)
+ if (session->inbound == GNUNET_YES)
continue;
- if (addrlen != session->connect_alen)
+ if ((addrlen != session->connect_alen) && (session->is_nat == GNUNET_NO))
continue;
- if (0 != memcmp (session->connect_addr,
+ if ((0 != memcmp (session->connect_addr,
addr,
- addrlen))
+ addrlen)) && (session->is_nat == GNUNET_NO))
continue;
cand_session = select_better_session (cand_session,
- session);
+ session);
}
session = cand_session;
}
GNUNET_STATISTICS_update (plugin->env->stats,
gettext_noop ("# bytes discarded by TCP (no address and no connection)"),
msgbuf_size,
- GNUNET_NO);
+ GNUNET_NO);
return -1;
}
if (session == NULL)
is_natd = GNUNET_YES;
memcpy (&a6.sin6_addr,
&t6->ipv6_addr,
- sizeof (struct in6_addr));
+ sizeof (struct in6_addr));
sb = &a6;
sbs = sizeof (a6);
}
return -1; /* NAT client only works with IPv4 addresses */
- if ( (plugin->allow_nat == GNUNET_YES) && (is_natd == GNUNET_YES) &&
+ if ((plugin->allow_nat == GNUNET_YES) && (is_natd == GNUNET_YES) &&
(GNUNET_NO == GNUNET_CONTAINER_multihashmap_contains(plugin->nat_wait_conns, &target->hashPubKey)))
{
#if DEBUG_TCP_NAT
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- _("Found valid IPv4 NAT address!\n"));
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ _("Found valid IPv4 NAT address (creating session)!\n"));
#endif
session = create_session (plugin,
target,
pm = GNUNET_malloc (sizeof (struct PendingMessage) + msgbuf_size);
/* FIXME: the memset of this malloc can be up to 2% of our total runtime */
pm->msg = (const char*) &pm[1];
- memcpy (&pm[1], msg, msgbuf_size);
- /* FIXME: this memcpy can be up to 7% of our total run-time
+ memcpy (&pm[1], msg, msgbuf_size);
+ /* FIXME: this memcpy can be up to 7% of our total run-time
(for transport service) */
pm->message_size = msgbuf_size;
pm->timeout = GNUNET_TIME_relative_to_absolute (timeout);
GNUNET_assert(GNUNET_CONTAINER_multihashmap_put(plugin->nat_wait_conns, &target->hashPubKey, session, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY) == GNUNET_OK);
#if DEBUG_TCP_NAT
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
"Created NAT WAIT connection to `%4s' at `%s'\n",
GNUNET_i2s (target),
GNUNET_a2s (sb, sbs));
#endif
- run_gnunet_nat_client(plugin, sb, sbs);
+ run_gnunet_nat_client (plugin, sb, sbs);
return 0;
}
else if ((plugin->allow_nat == GNUNET_YES) && (is_natd == GNUNET_YES) && (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains(plugin->nat_wait_conns, &target->hashPubKey)))
GNUNET_STATISTICS_update (plugin->env->stats,
gettext_noop ("# bytes discarded by TCP (failed to connect)"),
msgbuf_size,
- GNUNET_NO);
+ GNUNET_NO);
return -1;
}
#if DEBUG_TCP
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
"Asked to transmit to `%4s', creating fresh session using address `%s'.\n",
GNUNET_i2s (target),
GNUNET_a2s (sb, sbs));
GNUNET_STATISTICS_update (plugin->env->stats,
gettext_noop ("# bytes currently in TCP buffers"),
msgbuf_size,
- GNUNET_NO);
+ GNUNET_NO);
/* create new message entry */
pm = GNUNET_malloc (sizeof (struct PendingMessage) + msgbuf_size);
pm->msg = (const char*) &pm[1];
a6.sin6_port = t6->t6_port;
memcpy (&a6.sin6_addr,
&t6->ipv6_addr,
- sizeof (struct in6_addr));
+ sizeof (struct in6_addr));
port = ntohs (t6->t6_port);
sb = &a6;
sbs = sizeof (a6);
}
-/**
+/**
* 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
* (as per our configuration). Naturally, if absolutely necessary,
* and transport, GNUNET_SYSERR if not
*/
static int
-tcp_plugin_check_address (void *cls,
- const void *addr,
+tcp_plugin_check_address (void *cls,
+ const void *addr,
size_t addrlen)
{
struct Plugin *plugin = cls;
GNUNET_break_op (0);
return GNUNET_SYSERR;
}
- if (GNUNET_OK !=
+ if (GNUNET_OK !=
check_port (plugin, ntohs (v6->t6_port)))
return GNUNET_SYSERR;
if (GNUNET_OK !=
GNUNET_SERVER_client_keep (client);
session->client = client;
session->last_activity = GNUNET_TIME_absolute_get ();
+ session->inbound = GNUNET_NO;
if (GNUNET_OK ==
GNUNET_SERVER_client_get_address (client, &vaddr, &alen))
{
#if DEBUG_TCP_NAT
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
"Found address `%s' for incoming connection %p\n",
GNUNET_a2s (vaddr, alen),
client);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Did NOT find session for NAT probe!\n");
#endif
}
+
+ GNUNET_SERVER_receive_done (client, GNUNET_OK);
}
/**
const struct sockaddr_in *s4;
const struct sockaddr_in6 *s6;
-
#if DEBUG_TCP
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Received %s message from a `%4s/%p'.\n",
+ "Received %s message from a `%4s/%p'.\n",
"WELCOME",
GNUNET_i2s (&wm->clientIdentity), client);
#endif
GNUNET_STATISTICS_update (plugin->env->stats,
gettext_noop ("# TCP WELCOME messages received"),
1,
- GNUNET_NO);
+ GNUNET_NO);
session = find_session_by_client (plugin, client);
if (session == NULL)
{
GNUNET_SERVER_client_keep (client);
+#if DEBUG_TCP_NAT
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "Received %s message from a `%4s/%p', creating session\n",
+ "WELCOME",
+ GNUNET_i2s (&wm->clientIdentity), client);
+#endif
session = create_session (plugin,
&wm->clientIdentity, client, GNUNET_NO);
session->inbound = GNUNET_YES;
session->receive_delay_task = GNUNET_SCHEDULER_NO_TASK;
delay = session->plugin->env->receive (session->plugin->env->cls,
&session->target,
- NULL, 0,
+ NULL, 0,
session,
NULL, 0);
if (delay.value == 0)
GNUNET_SERVER_receive_done (session->client, GNUNET_OK);
else
- session->receive_delay_task =
+ session->receive_delay_task =
GNUNET_SCHEDULER_add_delayed (session->plugin->env->sched,
delay, &delayed_done, session);
}
{
/* We don't want to propagate WELCOME and NAT Probe messages up! */
GNUNET_SERVER_receive_done (client, GNUNET_OK);
- return;
- }
+ return;
+ }
session = find_session_by_client (plugin, client);
if ( (NULL == session) || (GNUNET_YES == session->expecting_welcome))
{
#if DEBUG_TCP
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Passing %u bytes of type %u from `%4s' to transport service.\n",
- (unsigned int) ntohs (message->size),
+ (unsigned int) ntohs (message->size),
(unsigned int) ntohs (message->type),
GNUNET_i2s (&session->target));
#endif
GNUNET_STATISTICS_update (plugin->env->stats,
gettext_noop ("# bytes received via TCP"),
ntohs (message->size),
- GNUNET_NO);
+ GNUNET_NO);
delay = plugin->env->receive (plugin->env->cls, &session->target, message, 1,
- session,
+ session,
(GNUNET_YES == session->inbound) ? NULL : session->connect_addr,
(GNUNET_YES == session->inbound) ? 0 : session->connect_alen);
if (delay.value == 0)
GNUNET_SERVER_receive_done (client, GNUNET_OK);
else
- session->receive_delay_task =
+ session->receive_delay_task =
GNUNET_SCHEDULER_add_delayed (session->plugin->env->sched,
delay, &delayed_done, session);
}
* @param client identification of the client
*/
static void
-disconnect_notify (void *cls,
+disconnect_notify (void *cls,
struct GNUNET_SERVER_Client *client)
{
struct Plugin *plugin = cls;
GNUNET_break (0);
return GNUNET_OK;
}
- GNUNET_log (GNUNET_ERROR_TYPE_INFO |
- GNUNET_ERROR_TYPE_BULK,
- _("Found address `%s' (%s)\n"),
- GNUNET_a2s (addr, addrlen), name);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ _("Found address `%s' (%s) len %d\n"),
+ GNUNET_a2s (addr, addrlen), name, args);
plugin->env->notify_address (plugin->env->cls,
"tcp",
if (arg_nat != NULL)
{
- GNUNET_log (GNUNET_ERROR_TYPE_INFO |
- GNUNET_ERROR_TYPE_BULK,
- _("Found address `%s' (%s)\n"),
- GNUNET_a2s (addr, addrlen), name);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ _("Found address `%s' (%s) len %d\n"),
+ GNUNET_a2s (addr, addrlen), name, args);
plugin->env->notify_address (plugin->env->cls,
"tcp",
arg_nat, args, GNUNET_TIME_UNIT_FOREVER_REL);
return;
}
- port = 0;
port_start = NULL;
for (i = 0; i < sizeof(mybuf); i++)
{
*/
sock = GNUNET_CONNECTION_create_from_sockaddr (plugin->env->sched, AF_INET, (struct sockaddr *)&in_addr,
sizeof(in_addr));
+
+
if (sock == NULL)
{
plugin->server_read_task =
}
else
{
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
_("Sending TCP probe message!\n"), &mybuf, port);
- tcp_probe_ctx = GNUNET_malloc(sizeof(struct TCPProbeContext));
+ tcp_probe_ctx = GNUNET_malloc(sizeof(struct TCPProbeContext));
tcp_probe_ctx->message.header.size = htons(sizeof(struct TCP_NAT_ProbeMessage));
tcp_probe_ctx->message.header.type = htons(GNUNET_MESSAGE_TYPE_TRANSPORT_TCP_NAT_PROBE);
memcpy(&tcp_probe_ctx->message.clientIdentity, plugin->env->my_identity, sizeof(struct GNUNET_PeerIdentity));
}
+ /*GNUNET_SERVER_connect_socket(plugin->server, sock);*/
plugin->server_read_task =
GNUNET_SCHEDULER_add_read_file (plugin->env->sched,
GNUNET_TIME_UNIT_FOREVER_REL,
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
_("TCP transport advertises itself as being on port %llu\n"),
aport);
- GNUNET_SERVER_disconnect_notify (plugin->server,
+ GNUNET_SERVER_disconnect_notify (plugin->server,
&disconnect_notify,
plugin);
GNUNET_CONFIGURATION_get_value_string(env->cfg, "transport-tcp", "BINDTO", &plugin->bind_address);
{
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Notifying transport of address %s:0\n", plugin->external_address);
t4.t_port = htons(0);
+ add_to_address_list (plugin, &t4.ipv4_addr, sizeof (uint32_t));
plugin->env->notify_address (plugin->env->cls,
"tcp",
- &t4, sizeof(t4), GNUNET_TIME_UNIT_FOREVER_REL);
+ &t4, sizeof(t4), GNUNET_TIME_UNIT_FOREVER_REL);
}
else if ((plugin->external_address != NULL) && (inet_pton(AF_INET, plugin->external_address, &t4.ipv4_addr) == 1))
{
t4.t_port = htons(plugin->adv_port);
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Notifying transport of address %s:%d\n", plugin->external_address, plugin->adv_port);
+ add_to_address_list (plugin, &t4.ipv4_addr, sizeof (uint32_t));
plugin->env->notify_address (plugin->env->cls,
"tcp",
&t4, sizeof(t4), GNUNET_TIME_UNIT_FOREVER_REL);
projects / oweals / gnunet.git / blobdiff