You should have received a copy of the GNU General Public License
along with GNUnet; see the file COPYING. If not, write to the
- Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA.
+ Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
*/
/**
*/
struct DestinationEntry *destination;
- /**
- * Pre-allocated channel for this destination, or NULL for none.
- */
- struct ChannelState *ts;
-
/**
* Destination port this channel state is used for.
*/
*/
struct ChannelMessageQueueEntry *tmq_tail;
- /**
- * Destination entry that has a pointer to this channel state;
- * NULL if this channel state is in the channel map.
- */
- struct DestinationChannel *destination_container;
-
/**
* Destination to which this channel leads. Note that
* this struct is NOT in the destination_map (but a
*/
int af;
+ /**
+ * Is this channel new (#GNUNET_NO), or did we exchange messages with the
+ * other side already (#GNUNET_YES)?
+ */
+ int is_established;
+
/**
* Length of the doubly linked 'tmq_head/tmq_tail' list.
*/
/**
- * Return value from 'main'.
+ * Return value from #main().
*/
static int global_ret;
*/
static void
get_channel_key_from_ips (int af,
- uint8_t protocol,
- const void *source_ip,
- uint16_t source_port,
- const void *destination_ip,
- uint16_t destination_port,
- struct GNUNET_HashCode *key)
+ uint8_t protocol,
+ const void *source_ip,
+ uint16_t source_port,
+ const void *destination_ip,
+ uint16_t destination_port,
+ struct GNUNET_HashCode *key)
{
char *off;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Cleaning up channel state\n");
+ if (NULL != ts->th)
+ {
+ GNUNET_CADET_notify_transmit_ready_cancel (ts->th);
+ ts->th = NULL;
+ }
+ if (NULL != (channel = ts->channel))
+ {
+ ts->channel = NULL;
+ GNUNET_CADET_channel_destroy (channel);
+ return;
+ }
GNUNET_STATISTICS_update (stats,
gettext_noop ("# Active channels"),
-1, GNUNET_NO);
GNUNET_free (tnq);
}
GNUNET_assert (0 == ts->tmq_length);
- if (NULL != ts->th)
- {
- GNUNET_CADET_notify_transmit_ready_cancel (ts->th);
- ts->th = NULL;
- }
GNUNET_assert (NULL == ts->destination.heap_node);
- if (NULL != (channel = ts->channel))
- {
- ts->channel = NULL;
- GNUNET_CADET_channel_destroy (channel);
- }
if (NULL != ts->search)
{
GNUNET_REGEX_search_cancel (ts->search);
&key,
ts));
}
- if (NULL != ts->destination_container)
- {
- GNUNET_assert (ts == ts->destination_container->ts);
- ts->destination_container->ts = NULL;
- ts->destination_container = NULL;
- }
GNUNET_free (ts);
}
GNUNET_assert (size >= tnq->len);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Sending %u bytes via cadet channel\n",
- tnq->len);
+ (unsigned int) tnq->len);
GNUNET_CONTAINER_DLL_remove (ts->tmq_head,
ts->tmq_tail,
tnq);
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Queueing %u bytes for transmission via cadet channel\n",
- tnq->len);
+ (unsigned int) tnq->len);
GNUNET_assert (NULL != ts->channel);
GNUNET_CONTAINER_DLL_insert_tail (ts->tmq_head,
ts->tmq_tail,
}
+/**
+ * Output destination of a channel for diagnostics.
+ *
+ * @param de destination to process
+ * @return diagnostic string describing destination
+ */
+static const char *
+print_channel_destination (const struct DestinationEntry *de)
+{
+ static char dest[256];
+
+ if (de->is_service)
+ {
+ GNUNET_snprintf (dest,
+ sizeof (dest),
+ "HS: %s-%s",
+ GNUNET_i2s (&de->details.service_destination.target),
+ GNUNET_h2s (&de->details.service_destination.service_descriptor));
+ }
+ else
+ {
+ inet_ntop (de->details.exit_destination.af,
+ &de->details.exit_destination.ip,
+ dest,
+ sizeof (dest));
+ }
+ return dest;
+}
+
+
/**
* Regex has found a potential exit peer for us; consider using it.
*
- * @param cls the 'struct ChannelState'
+ * @param cls the `struct ChannelState`
* @param id Peer providing a regex that matches the string.
* @param get_path Path of the get request.
* @param get_path_length Lenght of @a get_path.
struct ChannelState *ts = cls;
unsigned int apptype;
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ "Exit %s found for destination %s!\n",
+ GNUNET_i2s (id),
+ print_channel_destination (&ts->destination));
GNUNET_REGEX_search_cancel (ts->search);
ts->search = NULL;
switch (ts->af)
GNUNET_break (0);
return;
}
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ "Creating tunnel to %s for destination %s!\n",
+ GNUNET_i2s (id),
+ print_channel_destination (&ts->destination));
ts->channel = GNUNET_CADET_channel_create (cadet_handle,
ts,
id,
*/
static struct ChannelState *
create_channel_to_destination (struct DestinationChannel *dt,
- int client_af)
+ int client_af)
{
struct ChannelState *ts;
unsigned int apptype;
GNUNET_STATISTICS_update (stats,
gettext_noop ("# Cadet channels created"),
1, GNUNET_NO);
- GNUNET_assert (NULL == dt->ts);
switch (client_af)
{
case AF_INET:
ts->af = client_af;
ts->destination = *dt->destination;
ts->destination.heap_node = NULL; /* copy is NOT in destination heap */
- dt->ts = ts;
- ts->destination_container = dt; /* we are referenced from dt */
if (dt->destination->is_service)
{
ts->channel = GNUNET_CADET_channel_create (cadet_handle,
- ts,
- &dt->destination->details.service_destination.target,
- apptype,
- GNUNET_CADET_OPTION_DEFAULT);
+ ts,
+ &dt->destination->details.service_destination.target,
+ apptype,
+ GNUNET_CADET_OPTION_DEFAULT);
if (NULL == ts->channel)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
return NULL;
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Creating channel to peer %s offering service %s\n",
+ "Creating channel %p to peer %s offering service %s\n",
+ ts->channel,
GNUNET_i2s (&dt->destination->details.service_destination.target),
GNUNET_h2s (&dt->destination->details.service_destination.service_descriptor));
}
GNUNET_TUN_ipv4toregexsearch (&dt->destination->details.exit_destination.ip.v4,
dt->destination_port,
address);
- GNUNET_asprintf (&policy, "%s%s",
+ GNUNET_asprintf (&policy,
+ "%s%s",
GNUNET_APPLICATION_TYPE_EXIT_REGEX_PREFIX,
address);
break;
GNUNET_TUN_ipv6toregexsearch (&dt->destination->details.exit_destination.ip.v6,
dt->destination_port,
address);
- GNUNET_asprintf (&policy, "%s%s",
+ GNUNET_asprintf (&policy,
+ "%s%s",
GNUNET_APPLICATION_TYPE_EXIT_REGEX_PREFIX,
address);
break;
GNUNET_assert (NULL != ts);
if (except == ts)
return; /* can't do this */
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Tearing down expired channel to %s\n",
+ print_channel_destination (&except->destination));
free_channel_state (ts);
}
struct ChannelMessageQueueEntry *tnq;
size_t alen;
size_t mlen;
- int is_new;
const struct GNUNET_TUN_UdpHeader *udp;
const struct GNUNET_TUN_TcpHeader *tcp;
const struct GNUNET_TUN_IcmpHeader *icmp;
source_port = ntohs (udp->source_port);
destination_port = ntohs (udp->destination_port);
get_channel_key_from_ips (af,
- IPPROTO_UDP,
- source_ip,
- source_port,
- destination_ip,
- destination_port,
- &key);
+ IPPROTO_UDP,
+ source_ip,
+ source_port,
+ destination_ip,
+ destination_port,
+ &key);
}
break;
case IPPROTO_TCP:
source_port = ntohs (tcp->source_port);
destination_port = ntohs (tcp->destination_port);
get_channel_key_from_ips (af,
- IPPROTO_TCP,
- source_ip,
- source_port,
- destination_ip,
- destination_port,
- &key);
+ IPPROTO_TCP,
+ source_ip,
+ source_port,
+ destination_ip,
+ destination_port,
+ &key);
}
break;
case IPPROTO_ICMP:
source_port = 0;
destination_port = 0;
get_channel_key_from_ips (af,
- protocol,
- source_ip,
- 0,
- destination_ip,
- 0,
- &key);
+ protocol,
+ source_ip,
+ 0,
+ destination_ip,
+ 0,
+ &key);
}
break;
default:
char xbuf[INET6_ADDRSTRLEN];
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Routing %s packet from %s:%u -> %s:%u to destination %s:%u\n",
+ "Routing %s packet from [%s]:%u -> [%s]:%u to destination [%s]:%u\n",
(protocol == IPPROTO_TCP) ? "TCP" : "UDP",
inet_ntop (af, source_ip, sbuf, sizeof (sbuf)),
source_port,
char dbuf[INET6_ADDRSTRLEN];
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Routing %s packet from %s:%u -> %s:%u to service %s at peer %s\n",
+ "Routing %s packet from [%s]:%u -> [%s]:%u to service %s at peer %s\n",
(protocol == IPPROTO_TCP) ? "TCP" : "UDP",
inet_ntop (af, source_ip, sbuf, sizeof (sbuf)),
source_port,
&key);
if (NULL == ts)
{
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Creating new channel for key %s\n",
+ GNUNET_h2s (&key));
/* need to either use the existing channel from the destination (if still
available) or create a fresh one */
- is_new = GNUNET_YES;
- if (NULL == dt->ts)
- ts = create_channel_to_destination (dt, af);
- else
- ts = dt->ts;
+ ts = create_channel_to_destination (dt, af);
if (NULL == ts)
return;
- dt->ts = NULL;
- ts->destination_container = NULL; /* no longer 'contained' */
/* now bind existing "unbound" channel to our IP/port tuple */
ts->protocol = protocol;
ts->af = af;
}
else
{
- is_new = GNUNET_NO;
GNUNET_CONTAINER_heap_update_cost (channel_heap,
ts->heap_node,
GNUNET_TIME_absolute_get ().abs_value_us);
}
if (NULL == ts->channel)
{
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "Packet dropped, channel to %s not yet ready (%s)\n",
+ print_channel_destination (&ts->destination),
+ (NULL == ts->search)
+ ? "EXIT search failed"
+ : "EXIT search active");
GNUNET_STATISTICS_update (stats,
gettext_noop ("# Packets dropped (channel not yet online)"),
1,
}
break;
case IPPROTO_TCP:
- if (is_new)
+ if (GNUNET_NO == ts->is_established)
{
if (destination->is_service)
{
GNUNET_assert (0);
break;
}
+ ts->is_established = GNUNET_YES;
send_to_channel (tnq, ts);
}
GNUNET_CONTAINER_heap_update_cost (channel_heap,
ts->heap_node,
GNUNET_TIME_absolute_get ().abs_value_us);
+ GNUNET_CADET_receive_done (channel);
return GNUNET_OK;
}
char dbuf[INET6_ADDRSTRLEN];
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Received UDP reply from cadet, sending %u bytes from %s:%u -> %s:%u via TUN\n",
+ "Received UDP reply from cadet, sending %u bytes from [%s]:%u -> [%s]:%u via TUN\n",
(unsigned int) mlen,
inet_ntop (ts->af, &ts->destination_ip, sbuf, sizeof (sbuf)),
ts->destination_port,
GNUNET_CONTAINER_heap_update_cost (channel_heap,
ts->heap_node,
GNUNET_TIME_absolute_get ().abs_value_us);
+ GNUNET_CADET_receive_done (channel);
return GNUNET_OK;
}
char dbuf[INET6_ADDRSTRLEN];
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Received TCP reply from cadet, sending %u bytes from %s:%u -> %s:%u via TUN\n",
+ "Received TCP reply from cadet, sending %u bytes from [%s]:%u -> [%s]:%u via TUN\n",
(unsigned int) mlen,
inet_ntop (ts->af, &ts->destination_ip, sbuf, sizeof (sbuf)),
ts->destination_port,
GNUNET_CONTAINER_heap_update_cost (channel_heap,
ts->heap_node,
GNUNET_TIME_absolute_get ().abs_value_us);
+ GNUNET_CADET_receive_done (channel);
return GNUNET_OK;
}
struct DestinationChannel *dt;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Cleaning up destination entry\n");
+ "Cleaning up destination entry `%s'\n",
+ print_channel_destination (de));
GNUNET_STATISTICS_update (stats,
gettext_noop ("# Active destinations"),
-1, GNUNET_NO);
GNUNET_CONTAINER_DLL_remove (de->dt_head,
de->dt_tail,
dt);
- if (NULL != dt->ts)
- {
- free_channel_state (dt->ts);
- GNUNET_assert (NULL == dt->ts);
- }
GNUNET_free (dt);
}
if (NULL != de->heap_node)
void *addr;
struct DestinationEntry *de;
struct GNUNET_HashCode key;
- struct ChannelState *ts;
struct DestinationChannel *dt;
/* parse request */
GNUNET_CONTAINER_DLL_insert (de->dt_head,
de->dt_tail,
dt);
- ts = create_channel_to_destination (dt,
- result_af);
- switch (result_af)
- {
- case AF_INET:
- ts->destination_ip.v4 = v4;
- break;
- case AF_INET6:
- ts->destination_ip.v6 = v6;
- break;
- default:
- GNUNET_assert (0);
- }
/* we're done */
GNUNET_SERVER_receive_done (client, GNUNET_OK);
}
*/
static void
channel_cleaner (void *cls,
- const struct GNUNET_CADET_Channel *channel,
- void *channel_ctx)
+ const struct GNUNET_CADET_Channel *channel,
+ void *channel_ctx)
{
struct ChannelState *ts = channel_ctx;
ts->channel = NULL; /* we must not call GNUNET_CADET_channel_destroy() anymore */
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "CADET notified us about death of channel to `%s'\n",
+ print_channel_destination (&ts->destination));
free_channel_state (ts);
}
*/
static int
cleanup_channel (void *cls,
- const struct GNUNET_HashCode *key,
- void *value)
+ const struct GNUNET_HashCode *key,
+ void *value)
{
struct ChannelState *ts = value;
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Tearing down channel to `%s' during cleanup\n",
+ print_channel_destination (&ts->destination));
free_channel_state (ts);
return GNUNET_OK;
}
* Function scheduled as very last function, cleans up after us
*
* @param cls unused
- * @param tc unused
*/
static void
-cleanup (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+cleanup (void *cls)
{
unsigned int i;
}
if (NULL != helper_handle)
{
- GNUNET_HELPER_stop (helper_handle, GNUNET_NO);
+ GNUNET_HELPER_kill (helper_handle, GNUNET_NO);
+ GNUNET_HELPER_wait (helper_handle);
helper_handle = NULL;
}
if (NULL != nc)
cadet_handle =
GNUNET_CADET_connect (cfg_, NULL,
- NULL,
- &channel_cleaner,
- cadet_handlers,
- NULL);
+ NULL,
+ &channel_cleaner,
+ cadet_handlers,
+ NULL);
helper_handle = GNUNET_HELPER_start (GNUNET_NO,
"gnunet-helper-vpn", vpn_argv,
&message_token, NULL, NULL);
nc = GNUNET_SERVER_notification_context_create (server, 1);
GNUNET_SERVER_add_handlers (server, service_handlers);
- GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &cleanup, cls);
+ GNUNET_SCHEDULER_add_shutdown (&cleanup,
+ NULL);
}
projects / oweals / gnunet.git / blobdiff