[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[GNUnet-SVN] r31886 - gnunet/src/transport
|
From: |
gnunet |
|
Subject: |
[GNUnet-SVN] r31886 - gnunet/src/transport |
|
Date: |
Mon, 13 Jan 2014 17:59:57 +0100 |
Author: wachs
Date: 2014-01-13 17:59:57 +0100 (Mon, 13 Jan 2014)
New Revision: 31886
Modified:
gnunet/src/transport/gnunet-service-transport.c
gnunet/src/transport/gnunet-service-transport.h
gnunet/src/transport/gnunet-service-transport_clients.c
gnunet/src/transport/gnunet-service-transport_manipulation.c
gnunet/src/transport/gnunet-service-transport_manipulation.h
gnunet/src/transport/gnunet-service-transport_neighbours.c
gnunet/src/transport/gnunet-service-transport_validation.c
gnunet/src/transport/plugin_transport_bluetooth.c
gnunet/src/transport/plugin_transport_http_client.c
gnunet/src/transport/plugin_transport_http_common.h
gnunet/src/transport/plugin_transport_http_server.c
gnunet/src/transport/plugin_transport_tcp.c
gnunet/src/transport/plugin_transport_udp.c
gnunet/src/transport/plugin_transport_udp.h
gnunet/src/transport/plugin_transport_udp_broadcasting.c
gnunet/src/transport/plugin_transport_unix.c
gnunet/src/transport/plugin_transport_wlan.c
gnunet/src/transport/test_plugin_transport.c
gnunet/src/transport/transport.h
gnunet/src/transport/transport_api_monitoring.c
Log:
implementing 0003268 to inbound information in HELLO addresses
All transport plugin functions are modified to use HELLO addresses instead of
peer,address,address_length
All plugins are modified to use HELLO addresses internally
This commit can break transport functionality: core tests on my system still
pass,
but transport tests may still fail, errors messages may occurs or crashs
Will be fixed asap
Modified: gnunet/src/transport/gnunet-service-transport.c
===================================================================
--- gnunet/src/transport/gnunet-service-transport.c 2014-01-13 16:56:41 UTC
(rev 31885)
+++ gnunet/src/transport/gnunet-service-transport.c 2014-01-13 16:59:57 UTC
(rev 31886)
@@ -1,22 +1,22 @@
/*
- This file is part of GNUnet.
- (C) 2010,2011 Christian Grothoff (and other contributing authors)
+ This file is part of GNUnet.
+ (C) 2010,2011 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
- by the Free Software Foundation; either version 3, or (at your
- option) any later version.
+ GNUnet is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published
+ by the Free Software Foundation; either version 3, or (at your
+ option) any later version.
- GNUnet is distributed in the hope that it will be useful, but
- WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- General Public License for more details.
+ GNUnet is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
- 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.
-*/
+ 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.
+ */
/**
* @file transport/gnunet-service-transport.c
@@ -40,7 +40,6 @@
#include "gnunet-service-transport_manipulation.h"
#include "transport.h"
-
/**
* Information we need for an asynchronous session kill.
*/
@@ -72,7 +71,6 @@
GNUNET_SCHEDULER_TaskIdentifier task;
};
-
/* globals */
/**
@@ -130,7 +128,6 @@
*/
static struct SessionKiller *sk_tail;
-
/**
* Transmit our HELLO message to the given (connected) neighbour.
*
@@ -144,24 +141,21 @@
*/
static void
transmit_our_hello (void *cls, const struct GNUNET_PeerIdentity *target,
- const struct GNUNET_HELLO_Address *address,
- enum GNUNET_TRANSPORT_PeerState state,
- struct GNUNET_TIME_Absolute state_timeout,
- struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
- struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out)
+ const struct GNUNET_HELLO_Address *address,
+ enum GNUNET_TRANSPORT_PeerState state,
+ struct GNUNET_TIME_Absolute state_timeout,
+ struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
+ struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out)
{
const struct GNUNET_MessageHeader *hello = cls;
- if ( GNUNET_NO == GST_neighbours_test_connected(target) )
+ if (GNUNET_NO == GST_neighbours_test_connected (target))
return;
- GST_neighbours_send (target,
- hello,
- ntohs (hello->size),
- hello_expiration, NULL, NULL);
+ GST_neighbours_send (target, hello, ntohs (hello->size), hello_expiration,
+ NULL, NULL );
}
-
/**
* My HELLO has changed. Tell everyone who should know.
*
@@ -169,14 +163,12 @@
* @param hello new HELLO
*/
static void
-process_hello_update (void *cls,
- const struct GNUNET_MessageHeader *hello)
+process_hello_update (void *cls, const struct GNUNET_MessageHeader *hello)
{
GST_clients_broadcast (hello, GNUNET_NO);
GST_neighbours_iterate (&transmit_our_hello, (void *) hello);
}
-
/**
* We received some payload. Prepare to pass it on to our clients.
*
@@ -188,30 +180,26 @@
*/
static struct GNUNET_TIME_Relative
process_payload (const struct GNUNET_PeerIdentity *peer,
- const struct GNUNET_HELLO_Address *address,
- struct Session *session,
- const struct GNUNET_MessageHeader *message)
+ const struct GNUNET_HELLO_Address *address, struct Session *session,
+ const struct GNUNET_MessageHeader *message)
{
struct GNUNET_TIME_Relative ret;
int do_forward;
struct InboundMessage *im;
size_t msg_size = ntohs (message->size);
- size_t size =
- sizeof (struct InboundMessage) + msg_size;
+ size_t size = sizeof(struct InboundMessage) + msg_size;
char buf[size] GNUNET_ALIGN;
do_forward = GNUNET_SYSERR;
ret = GST_neighbours_calculate_receive_delay (peer, msg_size, &do_forward);
- if (! GST_neighbours_test_connected (peer))
+ if (!GST_neighbours_test_connected (peer))
{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Discarded %u bytes type %u payload from peer `%s'\n",
- msg_size,
- ntohs (message->type), GNUNET_i2s (peer));
- GNUNET_STATISTICS_update (GST_stats,
- gettext_noop
- ("# bytes payload discarded due to not connected
peer"),
- msg_size, GNUNET_NO);
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+ "Discarded %u bytes type %u payload from peer `%s'\n", msg_size,
+ ntohs (message->type), GNUNET_i2s (peer));
+ GNUNET_STATISTICS_update (GST_stats, gettext_noop
+ ("# bytes payload discarded due to not connected peer"), msg_size,
+ GNUNET_NO);
return ret;
}
@@ -228,7 +216,6 @@
return ret;
}
-
/**
* Task to asynchronously terminate a session.
*
@@ -236,19 +223,16 @@
* @param tc scheduler context
*/
static void
-kill_session_task (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+kill_session_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct SessionKiller *sk = cls;
sk->task = GNUNET_SCHEDULER_NO_TASK;
- GNUNET_CONTAINER_DLL_remove (sk_head, sk_tail, sk);
- sk->plugin->disconnect_session (sk->plugin->cls,
- sk->session);
- GNUNET_free (sk);
+ GNUNET_CONTAINER_DLL_remove(sk_head, sk_tail, sk);
+ sk->plugin->disconnect_session (sk->plugin->cls, sk->session);
+ GNUNET_free(sk);
}
-
/**
* Force plugin to terminate session due to communication
* issue.
@@ -257,8 +241,7 @@
* @param session session to termiante
*/
static void
-kill_session (const char *plugin_name,
- struct Session *session)
+kill_session (const char *plugin_name, struct Session *session)
{
struct GNUNET_TRANSPORT_PluginFunctions *plugin;
struct SessionKiller *sk;
@@ -269,19 +252,17 @@
plugin = GST_plugins_find (plugin_name);
if (NULL == plugin)
{
- GNUNET_break (0);
+ GNUNET_break(0);
return;
}
/* need to issue disconnect asynchronously */
sk = GNUNET_new (struct SessionKiller);
sk->session = session;
sk->plugin = plugin;
- sk->task = GNUNET_SCHEDULER_add_now (&kill_session_task,
- sk);
- GNUNET_CONTAINER_DLL_insert (sk_head, sk_tail, sk);
+ sk->task = GNUNET_SCHEDULER_add_now (&kill_session_task, sk);
+ GNUNET_CONTAINER_DLL_insert(sk_head, sk_tail, sk);
}
-
/**
* Function called by the transport for each received message.
*
@@ -303,35 +284,25 @@
*/
struct GNUNET_TIME_Relative
GST_receive_callback (void *cls,
- const struct GNUNET_PeerIdentity *peer,
- const struct GNUNET_MessageHeader *message,
+ const struct GNUNET_HELLO_Address *address,
struct Session *session,
- const char *sender_address,
- uint16_t sender_address_len)
+ const struct GNUNET_MessageHeader *message)
{
const char *plugin_name = cls;
struct GNUNET_TIME_Relative ret;
- struct GNUNET_HELLO_Address address;
uint16_t type;
- address.peer = *peer;
- address.address = sender_address;
- address.address_length = sender_address_len;
- address.transport_name = plugin_name;
ret = GNUNET_TIME_UNIT_ZERO;
if (NULL == message)
goto end;
type = ntohs (message->type);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Received Message with type %u from peer `%s'\n",
- type,
- GNUNET_i2s (peer));
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+ "Received Message with type %u from peer `%s'\n", type,
+ GNUNET_i2s (&address->peer));
- GNUNET_STATISTICS_update (GST_stats,
- gettext_noop
- ("# bytes total received"),
- ntohs (message->size), GNUNET_NO);
- GST_neighbours_notify_data_recv (peer, &address, session, message);
+ GNUNET_STATISTICS_update (GST_stats, gettext_noop
+ ("# bytes total received"), ntohs (message->size), GNUNET_NO);
+ GST_neighbours_notify_data_recv (&address->peer, address, session, message);
switch (type)
{
@@ -339,85 +310,76 @@
/* Legacy HELLO message, discard */
return ret;
case GNUNET_MESSAGE_TYPE_HELLO:
- if (GNUNET_OK !=
- GST_validation_handle_hello (message))
+ if (GNUNET_OK != GST_validation_handle_hello (message))
{
- GNUNET_break_op (0);
+ GNUNET_break_op(0);
kill_session (plugin_name, session);
}
return ret;
case GNUNET_MESSAGE_TYPE_TRANSPORT_PING:
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
- "Processing `%s' from `%s'\n", "PING",
- (sender_address !=
- NULL) ? GST_plugins_a2s (&address) :
TRANSPORT_SESSION_INBOUND_STRING);
- if (GNUNET_OK !=
- GST_validation_handle_ping (peer, message, &address, session))
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
+ "Processing `%s' from `%s'\n", "PING", GST_plugins_a2s (address));
+ if (GNUNET_OK
+ != GST_validation_handle_ping (&address->peer, message, address,
session))
kill_session (plugin_name, session);
break;
case GNUNET_MESSAGE_TYPE_TRANSPORT_PONG:
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
- "Processing `%s' from `%s'\n", "PONG",
- (sender_address !=
- NULL) ? GST_plugins_a2s (&address) :
TRANSPORT_SESSION_INBOUND_STRING);
- if (GNUNET_OK !=
- GST_validation_handle_pong (peer, message))
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
+ "Processing `%s' from `%s'\n", "PONG",
+ GST_plugins_a2s (address));
+ if (GNUNET_OK != GST_validation_handle_pong (&address->peer, message))
{
- GNUNET_break_op (0);
+ GNUNET_break_op(0);
kill_session (plugin_name, session);
}
break;
case GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_CONNECT:
- if (GNUNET_OK !=
- GST_neighbours_handle_connect (message, peer, &address, session))
+ if (GNUNET_OK
+ != GST_neighbours_handle_connect (message, &address->peer, address,
session))
{
- GNUNET_break_op (0);
+ GNUNET_break_op(0);
kill_session (plugin_name, session);
}
break;
case GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_CONNECT_ACK:
- if (GNUNET_OK !=
- GST_neighbours_handle_connect_ack (message, peer, &address, session))
+ if (GNUNET_OK
+ != GST_neighbours_handle_connect_ack (message, &address->peer,
address, session))
{
kill_session (plugin_name, session);
}
break;
case GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_ACK:
- if (GNUNET_OK !=
- GST_neighbours_handle_session_ack (message, peer, &address, session))
+ if (GNUNET_OK
+ != GST_neighbours_handle_session_ack (message, &address->peer,
address, session))
{
- GNUNET_break_op (0);
+ GNUNET_break_op(0);
kill_session (plugin_name, session);
}
break;
case GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_DISCONNECT:
- GST_neighbours_handle_disconnect_message (peer, message);
+ GST_neighbours_handle_disconnect_message (&address->peer, message);
break;
case GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_KEEPALIVE:
- GST_neighbours_keepalive (peer, message);
+ GST_neighbours_keepalive (&address->peer, message);
break;
case GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_KEEPALIVE_RESPONSE:
- GST_neighbours_keepalive_response (peer, message);
+ GST_neighbours_keepalive_response (&address->peer, message);
break;
default:
/* should be payload */
- GNUNET_STATISTICS_update (GST_stats,
- gettext_noop
- ("# bytes payload received"),
- ntohs (message->size), GNUNET_NO);
- GST_neighbours_notify_payload_recv (peer, &address, session, message);
- ret = process_payload (peer, &address, session, message);
+ GNUNET_STATISTICS_update (GST_stats, gettext_noop
+ ("# bytes payload received"), ntohs (message->size), GNUNET_NO);
+ GST_neighbours_notify_payload_recv (&address->peer, address, session,
message);
+ ret = process_payload (&address->peer, address, session, message);
break;
}
-end:
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Allowing receive from peer %s to continue in %s\n",
- GNUNET_i2s (peer),
- GNUNET_STRINGS_relative_time_to_string (ret, GNUNET_YES));
+ end:
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+ "Allowing receive from peer %s to continue in %s\n", GNUNET_i2s
(&address->peer),
+ GNUNET_STRINGS_relative_time_to_string (ret, GNUNET_YES));
return ret;
}
-
/**
* Function that will be called for each address the transport
* is aware that it might be reachable under. Update our HELLO.
@@ -425,26 +387,15 @@
* @param cls name of the plugin (const char*)
* @param add_remove should the address added (YES) or removed (NO) from the
* set of valid addresses?
- * @param addr one of the addresses of the host
- * the specific address format depends on the transport
- * @param addrlen length of the @a addr
- * @param dest_plugin destination plugin to use this address with
+ * @param address the address to add or remove
*/
static void
plugin_env_address_change_notification (void *cls, int add_remove,
- const void *addr, size_t addrlen,
- const char *dest_plugin)
+ const struct GNUNET_HELLO_Address *address)
{
- struct GNUNET_HELLO_Address address;
-
- address.peer = GST_my_identity;
- address.transport_name = dest_plugin;
- address.address = addr;
- address.address_length = addrlen;
- GST_hello_modify_addresses (add_remove, &address);
+ GST_hello_modify_addresses (add_remove, address);
}
-
/**
* Function that will be called whenever the plugin internally
* cleans up a session pointer and hence the service needs to
@@ -460,22 +411,21 @@
*/
static void
plugin_env_session_end (void *cls, const struct GNUNET_PeerIdentity *peer,
- struct Session *session)
+ struct Session *session)
{
const char *transport_name = cls;
struct GNUNET_HELLO_Address address;
struct SessionKiller *sk;
- GNUNET_assert (strlen (transport_name) > 0);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Session %p to peer `%s' ended \n",
- session,
- GNUNET_i2s (peer));
+ GNUNET_assert(strlen (transport_name) > 0);
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Session %p to peer `%s' ended \n",
+ session, GNUNET_i2s (peer));
if (NULL != session)
- GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
- "transport-ats",
- "Telling ATS to destroy session %p from peer %s\n",
- session, GNUNET_i2s (peer));
+ GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
+ "transport-ats", "Telling ATS to destroy session %p from peer %s\n",
+ session, GNUNET_i2s (peer));
+
+ memset (&address, '\0', sizeof (address));
address.peer = *peer;
address.address = NULL;
address.address_length = 0;
@@ -488,15 +438,14 @@
{
if (sk->session == session)
{
- GNUNET_CONTAINER_DLL_remove (sk_head, sk_tail, sk);
+ GNUNET_CONTAINER_DLL_remove(sk_head, sk_tail, sk);
GNUNET_SCHEDULER_cancel (sk->task);
- GNUNET_free (sk);
+ GNUNET_free(sk);
break;
}
}
}
-
/**
* Function that will be called to figure if an address is an loopback,
* LAN, WAN etc. address
@@ -507,9 +456,8 @@
* @return ATS Information containing the network type
*/
static struct GNUNET_ATS_Information
-plugin_env_address_to_type (void *cls,
- const struct sockaddr *addr,
- size_t addrlen)
+plugin_env_address_to_type (void *cls, const struct sockaddr *addr,
+ size_t addrlen)
{
struct GNUNET_ATS_Information ats;
@@ -517,24 +465,23 @@
ats.value = htonl (GNUNET_ATS_NET_UNSPECIFIED);
if (NULL == GST_ats)
{
- GNUNET_break (0);
+ GNUNET_break(0);
return ats;
}
- if (((addr->sa_family != AF_INET) && (addrlen != sizeof (struct
sockaddr_in))) &&
- ((addr->sa_family != AF_INET6) && (addrlen != sizeof (struct
sockaddr_in6))) &&
- (addr->sa_family != AF_UNIX))
+ if (((addr->sa_family != AF_INET) && (addrlen != sizeof(struct sockaddr_in)))
+ && ((addr->sa_family != AF_INET6)
+ && (addrlen != sizeof(struct sockaddr_in6)))
+ && (addr->sa_family != AF_UNIX))
{
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Malformed address with length %u `%s'\n",
- addrlen,
- GNUNET_a2s (addr, addrlen));
- GNUNET_break (0);
+ GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+ "Malformed address with length %u `%s'\n", addrlen,
+ GNUNET_a2s (addr, addrlen));
+ GNUNET_break(0);
return ats;
}
return GNUNET_ATS_address_get_type (GST_ats, addr, addrlen);
}
-
/**
* Notify ATS about the new address including the network this address is
* located in.
@@ -546,9 +493,8 @@
*/
void
GST_ats_add_address (const struct GNUNET_HELLO_Address *address,
- struct Session *session,
- const struct GNUNET_ATS_Information *ats,
- uint32_t ats_count)
+ struct Session *session, const struct GNUNET_ATS_Information *ats,
+ uint32_t ats_count)
{
struct GNUNET_TRANSPORT_PluginFunctions *papi;
struct GNUNET_ATS_Information ats2[ats_count + 1];
@@ -557,48 +503,43 @@
/* valid new address, let ATS know! */
if (NULL == address->transport_name)
{
- GNUNET_break (0);
+ GNUNET_break(0);
return;
}
if (NULL == (papi = GST_plugins_find (address->transport_name)))
{
/* we don't have the plugin for this address */
- GNUNET_break (0);
+ GNUNET_break(0);
return;
}
if (GNUNET_YES == GNUNET_ATS_session_known (GST_ats, address, session))
{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "ATS already knows the address, not passing it on again\n");
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+ "ATS already knows the address, not passing it on again\n");
return;
}
net = papi->get_network (NULL, session);
if (GNUNET_ATS_NET_UNSPECIFIED == net)
{
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- _("Could not obtain a valid network for `%s' %s (%s)\n"),
- GNUNET_i2s (&address->peer),
- GST_plugins_a2s (address),
- address->transport_name);
- GNUNET_break (0);
+ GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+ _("Could not obtain a valid network for `%s' %s (%s)\n"),
+ GNUNET_i2s (&address->peer), GST_plugins_a2s (address),
+ address->transport_name);
+ GNUNET_break(0);
}
ats2[0].type = htonl (GNUNET_ATS_NETWORK_TYPE);
- ats2[0].value = htonl(net);
- memcpy (&ats2[1], ats, sizeof (struct GNUNET_ATS_Information) * ats_count);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Notifying ATS about peer `%s''s new address `%s' session %p in
network %s\n",
- GNUNET_i2s (&address->peer),
- (0 == address->address_length) ? "<inbound>" : GST_plugins_a2s
(address),
- session,
- GNUNET_ATS_print_network_type(net));
- GNUNET_ATS_address_add (GST_ats,
- address, session,
- ats2, ats_count + 1);
+ ats2[0].value = htonl (net);
+ memcpy (&ats2[1], ats, sizeof(struct GNUNET_ATS_Information) * ats_count);
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+ "Notifying ATS about peer `%s''s new address `%s' session %p in network
%s\n",
+ GNUNET_i2s (&address->peer),
+ (0 == address->address_length) ? "<inbound>" : GST_plugins_a2s (address),
+ session, GNUNET_ATS_print_network_type (net));
+ GNUNET_ATS_address_add (GST_ats, address, session, ats2, ats_count + 1);
}
-
/**
* Notify ATS about property changes to an address
*
@@ -610,10 +551,8 @@
*/
void
GST_ats_update_metrics (const struct GNUNET_PeerIdentity *peer,
- const struct GNUNET_HELLO_Address *address,
- struct Session *session,
- const struct GNUNET_ATS_Information *ats,
- uint32_t ats_count)
+ const struct GNUNET_HELLO_Address *address, struct Session *session,
+ const struct GNUNET_ATS_Information *ats, uint32_t ats_count)
{
struct GNUNET_ATS_Information *ats_new;
@@ -622,26 +561,23 @@
/* Call to manipulation to manipulate ATS information */
ats_new = GST_manipulation_manipulate_metrics (peer, address, session, ats,
- ats_count);
+ ats_count);
if (NULL == ats_new)
{
GNUNET_break(0);
return;
}
- if (GNUNET_NO == GNUNET_ATS_address_update (GST_ats,
- address, session, ats_new, ats_count))
+ if (GNUNET_NO == GNUNET_ATS_address_update (GST_ats, address, session,
+ ats_new, ats_count))
{
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- _("Address or session unknown: failed to update properties for
peer `%s' plugin `%s' address `%s' session %p\n"),
- GNUNET_i2s (peer),
- address->transport_name,
- GST_plugins_a2s (address),
- session);
+ GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+ _("Address or session unknown: failed to update properties for peer
`%s' plugin `%s' address `%s' session %p\n"),
+ GNUNET_i2s (peer), address->transport_name, GST_plugins_a2s (address),
+ session);
}
- GNUNET_free (ats_new);
+ GNUNET_free(ats_new);
}
-
/**
* Function that will be called to figure if an address is an loopback,
* LAN, WAN etc. address
@@ -656,85 +592,60 @@
*/
static void
plugin_env_update_metrics (void *cls,
- const struct GNUNET_PeerIdentity *peer,
- const void *address,
- uint16_t address_len,
- struct Session *session,
- const struct GNUNET_ATS_Information *ats,
- uint32_t ats_count)
+ const struct GNUNET_HELLO_Address *address,
+ struct Session *session,
+ const struct GNUNET_ATS_Information *ats,
+ uint32_t ats_count)
{
- const char *plugin_name = cls;
- struct GNUNET_HELLO_Address haddress;
-
if ((NULL == ats) || (0 == ats_count))
return;
- GNUNET_assert (NULL != GST_ats);
+ GNUNET_assert(NULL != GST_ats);
- haddress.peer = *peer;
- haddress.address = address;
- haddress.address_length = address_len;
- haddress.transport_name = plugin_name;
-
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Updating metrics for peer `%s' address %s session %p\n",
- GNUNET_i2s (peer),
- GST_plugins_a2s (&haddress),
- session);
- GST_ats_update_metrics (peer, &haddress, session, ats, ats_count);
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+ "Updating metrics for peer `%s' address %s session %p\n",
+ GNUNET_i2s (&address->peer), GST_plugins_a2s (address), session);
+ GST_ats_update_metrics (&address->peer, address, session, ats, ats_count);
}
-
/**
- * Plugin tells transport service about a new (inbound) session
+ * Plugin tells transport service about a new inbound session
*
* @param cls unused
- * @param peer the peer
- * @param plugin plugin name
- * @param address address
- * @param address_len @a address length
+ * @param address the address
* @param session the new session
* @param ats ats information
* @param ats_count number of @a ats information
*/
static void
-plugin_env_session_start (void *cls,
- const struct GNUNET_PeerIdentity *peer,
- const char *plugin,
- const void *address, uint16_t address_len,
- struct Session *session,
- const struct GNUNET_ATS_Information *ats,
- uint32_t ats_count)
+plugin_env_session_start (void *cls, struct GNUNET_HELLO_Address *address,
+ struct Session *session, const struct GNUNET_ATS_Information *ats,
+ uint32_t ats_count)
{
- struct GNUNET_HELLO_Address *addr;
-
- if (NULL == peer)
+ int inbound;
+ if (NULL == address)
{
GNUNET_break(0);
return;
}
- if (NULL == plugin)
- {
- GNUNET_break(0);
- return;
- }
if (NULL == session)
{
GNUNET_break(0);
return;
}
- addr = GNUNET_HELLO_address_allocate (peer, plugin, address, address_len);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Notification from plugin `%s' about new session %p from peer
`%s' address `%s'\n",
- plugin,
- session,
- GNUNET_i2s (peer),
- GST_plugins_a2s (addr));
- GST_ats_add_address (addr, session, ats, ats_count);
- GNUNET_free(addr);
+ if (GNUNET_HELLO_ADDRESS_INFO_INBOUND
+ == (address->local_info & GNUNET_HELLO_ADDRESS_INFO_INBOUND))
+ inbound = GNUNET_YES;
+ else
+ inbound = GNUNET_NO;
+
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+ "Notification from plugin `%s' about new %s session %p from peer `%s'
address `%s'\n",
+ address->transport_name, (GNUNET_YES == inbound) ? "inbound" :
"outbound",
+ session, GNUNET_i2s (&address->peer), GST_plugins_a2s (address));
+ GST_ats_add_address (address, session, ats, ats_count);
}
-
/**
* Function called by ATS to notify the callee that the
* assigned bandwidth or address for a given peer was changed. If the
@@ -753,14 +664,11 @@
* @param ats_count number of @a ats elements
*/
static void
-ats_request_address_change (void *cls,
- const struct GNUNET_PeerIdentity *peer,
- const struct GNUNET_HELLO_Address *address,
- struct Session *session,
- struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
- struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
- const struct GNUNET_ATS_Information *ats,
- uint32_t ats_count)
+ats_request_address_change (void *cls, const struct GNUNET_PeerIdentity *peer,
+ const struct GNUNET_HELLO_Address *address, struct Session *session,
+ struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
+ struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
+ const struct GNUNET_ATS_Information *ats, uint32_t ats_count)
{
uint32_t bw_in = ntohl (bandwidth_in.value__);
uint32_t bw_out = ntohl (bandwidth_out.value__);
@@ -768,19 +676,17 @@
/* ATS tells me to disconnect from peer */
if ((0 == bw_in) && (0 == bw_out))
{
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "ATS tells me to disconnect from peer `%s'\n",
- GNUNET_i2s (&address->peer));
+ GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+ "ATS tells me to disconnect from peer `%s'\n",
+ GNUNET_i2s (&address->peer));
GST_neighbours_force_disconnect (&address->peer);
return;
}
GST_neighbours_switch_to_address (&address->peer, address, session, ats,
- ats_count, bandwidth_in,
- bandwidth_out);
+ ats_count, bandwidth_in, bandwidth_out);
}
-
/**
* Function called to notify transport users that another
* peer connected to us.
@@ -792,19 +698,19 @@
*/
static void
neighbours_connect_notification (void *cls,
- const struct GNUNET_PeerIdentity *peer,
- struct GNUNET_BANDWIDTH_Value32NBO
bandwidth_in,
- struct GNUNET_BANDWIDTH_Value32NBO
bandwidth_out)
+ const struct GNUNET_PeerIdentity *peer,
+ struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
+ struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out)
{
- size_t len = sizeof (struct ConnectInfoMessage);
+ size_t len = sizeof(struct ConnectInfoMessage);
char buf[len] GNUNET_ALIGN;
struct ConnectInfoMessage *connect_msg = (struct ConnectInfoMessage *) buf;
connections++;
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "We are now connected to peer `%s' and %u peers in total\n",
- GNUNET_i2s (peer), connections);
- connect_msg->header.size = htons (sizeof (buf));
+ GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+ "We are now connected to peer `%s' and %u peers in total\n",
+ GNUNET_i2s (peer), connections);
+ connect_msg->header.size = htons (sizeof(buf));
connect_msg->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT);
connect_msg->id = *peer;
connect_msg->quota_in = bandwidth_in;
@@ -812,7 +718,6 @@
GST_clients_broadcast (&connect_msg->header, GNUNET_NO);
}
-
/**
* Function called to notify transport users that another
* peer disconnected from us.
@@ -822,24 +727,23 @@
*/
static void
neighbours_disconnect_notification (void *cls,
- const struct GNUNET_PeerIdentity *peer)
+ const struct GNUNET_PeerIdentity *peer)
{
struct DisconnectInfoMessage disconnect_msg;
connections--;
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "Peer `%s' disconnected and we are connected to %u peers\n",
- GNUNET_i2s (peer), connections);
+ GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+ "Peer `%s' disconnected and we are connected to %u peers\n",
+ GNUNET_i2s (peer), connections);
GST_manipulation_peer_disconnect (peer);
- disconnect_msg.header.size = htons (sizeof (struct DisconnectInfoMessage));
+ disconnect_msg.header.size = htons (sizeof(struct DisconnectInfoMessage));
disconnect_msg.header.type = htons
(GNUNET_MESSAGE_TYPE_TRANSPORT_DISCONNECT);
disconnect_msg.reserved = htonl (0);
disconnect_msg.peer = *peer;
GST_clients_broadcast (&disconnect_msg.header, GNUNET_NO);
}
-
/**
* Function called to notify transport users that a neighbour peer changed its
* active address.
@@ -854,24 +758,23 @@
*/
static void
neighbours_changed_notification (void *cls,
- const struct GNUNET_PeerIdentity *peer,
- const struct GNUNET_HELLO_Address *address,
- enum GNUNET_TRANSPORT_PeerState state,
- struct GNUNET_TIME_Absolute state_timeout,
- struct GNUNET_BANDWIDTH_Value32NBO
bandwidth_in,
- struct GNUNET_BANDWIDTH_Value32NBO
bandwidth_out)
+ const struct GNUNET_PeerIdentity *peer,
+ const struct GNUNET_HELLO_Address *address,
+ enum GNUNET_TRANSPORT_PeerState state,
+ struct GNUNET_TIME_Absolute state_timeout,
+ struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
+ struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out)
{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"Notifying about change for peer `%s' with address `%s' in state `%s'
timing out at %s\n",
GNUNET_i2s (peer),
(NULL != address) ? GST_plugins_a2s (address) : "<none>",
- GNUNET_TRANSPORT_p2s(state),
- GNUNET_STRINGS_absolute_time_to_string(state_timeout));
+ GNUNET_TRANSPORT_p2s (state),
+ GNUNET_STRINGS_absolute_time_to_string (state_timeout));
GST_clients_broadcast_peer_notification (peer, address, state,
state_timeout);
}
-
/**
* Function called when the service shuts down. Unloads our plugins
* and cancels pending validations.
@@ -905,13 +808,12 @@
}
if (NULL != GST_my_private_key)
{
- GNUNET_free (GST_my_private_key);
+ GNUNET_free(GST_my_private_key);
GST_my_private_key = NULL;
}
GST_server = NULL;
}
-
/**
* Initiate transport service.
*
@@ -921,7 +823,7 @@
*/
static void
run (void *cls, struct GNUNET_SERVER_Handle *server,
- const struct GNUNET_CONFIGURATION_Handle *c)
+ const struct GNUNET_CONFIGURATION_Handle *c)
{
char *keyfile;
struct GNUNET_CRYPTO_EddsaPrivateKey *pk;
@@ -932,42 +834,42 @@
/* setup globals */
GST_cfg = c;
- if (GNUNET_OK !=
- GNUNET_CONFIGURATION_get_value_filename (c, "PEER", "PRIVATE_KEY",
- &keyfile))
+ if (GNUNET_OK
+ != GNUNET_CONFIGURATION_get_value_filename (c, "PEER", "PRIVATE_KEY",
+ &keyfile))
{
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- _("Transport service is lacking key configuration settings.
Exiting.\n"));
+ GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+ _("Transport service is lacking key configuration settings.
Exiting.\n"));
GNUNET_SCHEDULER_shutdown ();
return;
}
- if (GNUNET_OK !=
- GNUNET_CONFIGURATION_get_value_time (c, "transport", "HELLO_EXPIRATION",
- &hello_expiration))
+ if (GNUNET_OK
+ != GNUNET_CONFIGURATION_get_value_time (c, "transport",
+ "HELLO_EXPIRATION", &hello_expiration))
{
hello_expiration = GNUNET_CONSTANTS_HELLO_ADDRESS_EXPIRATION;
}
GST_server = server;
pk = GNUNET_CRYPTO_eddsa_key_create_from_file (keyfile);
- GNUNET_free (keyfile);
- GNUNET_assert (NULL != pk);
+ GNUNET_free(keyfile);
+ GNUNET_assert(NULL != pk);
GST_my_private_key = pk;
GST_stats = GNUNET_STATISTICS_create ("transport", GST_cfg);
GST_peerinfo = GNUNET_PEERINFO_connect (GST_cfg);
GNUNET_CRYPTO_eddsa_key_get_public (GST_my_private_key,
- &GST_my_identity.public_key);
- GNUNET_assert (NULL != GST_my_private_key);
+ &GST_my_identity.public_key);
+ GNUNET_assert(NULL != GST_my_private_key);
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "My identity is `%4s'\n", GNUNET_i2s (&GST_my_identity));
+ GNUNET_log(GNUNET_ERROR_TYPE_INFO, "My identity is `%4s'\n",
+ GNUNET_i2s (&GST_my_identity));
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &shutdown_task,
- NULL);
+ NULL );
if (NULL == GST_peerinfo)
{
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- _("Could not access PEERINFO service. Exiting.\n"));
+ GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+ _("Could not access PEERINFO service. Exiting.\n"));
GNUNET_SCHEDULER_shutdown ();
return;
}
@@ -980,51 +882,50 @@
{
max_fd_rlimit = r_file.rlim_cur;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Maximum number of open files was: %u/%u\n",
- r_file.rlim_cur,
- r_file.rlim_max);
+ "Maximum number of open files was: %u/%u\n",
+ r_file.rlim_cur,
+ r_file.rlim_max);
}
max_fd_rlimit = (9 * max_fd_rlimit) / 10; /* Keep 10% for rest of transport
*/
#endif
- GNUNET_CONFIGURATION_get_value_number (GST_cfg, "transport", "MAX_FD",
&max_fd_cfg);
+ GNUNET_CONFIGURATION_get_value_number (GST_cfg, "transport", "MAX_FD",
+ &max_fd_cfg);
if (max_fd_cfg > max_fd_rlimit)
- max_fd = max_fd_cfg;
+ max_fd = max_fd_cfg;
else
- max_fd = max_fd_rlimit;
+ max_fd = max_fd_rlimit;
if (max_fd < DEFAULT_MAX_FDS)
- max_fd = DEFAULT_MAX_FDS;
+ max_fd = DEFAULT_MAX_FDS;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Limiting number of sockets to %u: validation %u, neighbors:
%u\n",
- max_fd, (max_fd / 3) , (max_fd / 3) * 2);
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+ "Limiting number of sockets to %u: validation %u, neighbors: %u\n",
+ max_fd, (max_fd / 3), (max_fd / 3) * 2);
- friend_only = GNUNET_CONFIGURATION_get_value_yesno(GST_cfg,
"topology","FRIENDS-ONLY");
+ friend_only = GNUNET_CONFIGURATION_get_value_yesno (GST_cfg, "topology",
+ "FRIENDS-ONLY");
if (GNUNET_SYSERR == friend_only)
- friend_only = GNUNET_NO; /* According to topology defaults */
+ friend_only = GNUNET_NO; /* According to topology defaults */
/* start subsystems */
- GST_hello_start (friend_only, &process_hello_update, NULL);
- GNUNET_assert (NULL != GST_hello_get());
+ GST_hello_start (friend_only, &process_hello_update, NULL );
+ GNUNET_assert(NULL != GST_hello_get());
GST_blacklist_start (GST_server, GST_cfg, &GST_my_identity);
- GST_ats =
- GNUNET_ATS_scheduling_init (GST_cfg, &ats_request_address_change, NULL);
+ GST_ats = GNUNET_ATS_scheduling_init (GST_cfg, &ats_request_address_change,
+ NULL );
GST_manipulation_init (GST_cfg);
GST_plugins_load (&GST_manipulation_recv,
- &plugin_env_address_change_notification,
- &plugin_env_session_start,
- &plugin_env_session_end,
- &plugin_env_address_to_type,
- &plugin_env_update_metrics);
- GST_neighbours_start (NULL,
- &neighbours_connect_notification,
- &neighbours_disconnect_notification,
- &neighbours_changed_notification,
- (max_fd / 3) * 2);
+ &plugin_env_address_change_notification,
+ &plugin_env_session_start,
+ &plugin_env_session_end,
+ &plugin_env_address_to_type,
+ &plugin_env_update_metrics);
+ GST_neighbours_start (NULL, &neighbours_connect_notification,
+ &neighbours_disconnect_notification, &neighbours_changed_notification,
+ (max_fd / 3) * 2);
GST_clients_start (GST_server);
GST_validation_start ((max_fd / 3));
}
-
/**
* The main function for the transport service.
*
@@ -1033,11 +934,12 @@
* @return 0 ok, 1 on error
*/
int
-main (int argc, char *const *argv)
+main (int argc, char * const *argv)
{
- return (GNUNET_OK ==
- GNUNET_SERVICE_run (argc, argv, "transport",
- GNUNET_SERVICE_OPTION_NONE, &run, NULL)) ? 0 : 1;
+ return
+ (GNUNET_OK
+ == GNUNET_SERVICE_run (argc, argv, "transport",
+ GNUNET_SERVICE_OPTION_NONE, &run, NULL )) ? 0 : 1;
}
/* end of file gnunet-service-transport.c */
Modified: gnunet/src/transport/gnunet-service-transport.h
===================================================================
--- gnunet/src/transport/gnunet-service-transport.h 2014-01-13 16:56:41 UTC
(rev 31885)
+++ gnunet/src/transport/gnunet-service-transport.h 2014-01-13 16:59:57 UTC
(rev 31886)
@@ -72,12 +72,12 @@
*/
typedef void
(*GNUNET_TRANSPORT_NeighbourChangeCallback) (void *cls,
- const struct GNUNET_PeerIdentity *peer,
- const struct GNUNET_HELLO_Address *address,
- enum GNUNET_TRANSPORT_PeerState state,
- struct GNUNET_TIME_Absolute state_timeout,
- struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
- struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out);
+ const struct GNUNET_PeerIdentity *peer,
+ const struct GNUNET_HELLO_Address *address,
+ enum GNUNET_TRANSPORT_PeerState state,
+ struct GNUNET_TIME_Absolute state_timeout,
+ struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
+ struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out);
/**
@@ -103,11 +103,9 @@
*/
struct GNUNET_TIME_Relative
GST_receive_callback (void *cls,
- const struct GNUNET_PeerIdentity *peer,
- const struct GNUNET_MessageHeader *message,
- struct Session *session,
- const char *sender_address,
- uint16_t sender_address_len);
+ const struct GNUNET_HELLO_Address *address,
+ struct Session *session,
+ const struct GNUNET_MessageHeader *message);
/**
Modified: gnunet/src/transport/gnunet-service-transport_clients.c
===================================================================
--- gnunet/src/transport/gnunet-service-transport_clients.c 2014-01-13
16:56:41 UTC (rev 31885)
+++ gnunet/src/transport/gnunet-service-transport_clients.c 2014-01-13
16:59:57 UTC (rev 31886)
@@ -885,8 +885,10 @@
msg->peer = *peer;
msg->addrlen = htonl (alen);
msg->pluginlen = htonl (tlen);
+
if (NULL != address)
{
+ msg->local_address_info = htonl((uint32_t) address->local_info);
addr = (char *) &msg[1];
memcpy (addr, address->address, alen);
memcpy (&addr[alen], address->transport_name, tlen);
Modified: gnunet/src/transport/gnunet-service-transport_manipulation.c
===================================================================
--- gnunet/src/transport/gnunet-service-transport_manipulation.c
2014-01-13 16:56:41 UTC (rev 31885)
+++ gnunet/src/transport/gnunet-service-transport_manipulation.c
2014-01-13 16:59:57 UTC (rev 31886)
@@ -529,9 +529,10 @@
* @return manipulated delay for next receive
*/
struct GNUNET_TIME_Relative
-GST_manipulation_recv(void *cls, const struct GNUNET_PeerIdentity *peer,
- const struct GNUNET_MessageHeader *message, struct Session *session,
- const char *sender_address, uint16_t sender_address_len)
+GST_manipulation_recv (void *cls,
+ const struct GNUNET_HELLO_Address *address,
+ struct Session *session,
+ const struct GNUNET_MessageHeader *message)
{
struct TM_Peer *tmp;
uint32_t p_recv_delay;
@@ -547,7 +548,7 @@
else
m_delay = GNUNET_TIME_UNIT_ZERO;
- if (NULL != (tmp = GNUNET_CONTAINER_multipeermap_get(man_handle.peers,
peer)))
+ if (NULL != (tmp = GNUNET_CONTAINER_multipeermap_get(man_handle.peers,
&address->peer)))
{
/* Manipulate receive delay */
p_recv_delay = find_metric(tmp, GNUNET_ATS_QUALITY_NET_DELAY,
TM_RECEIVE);
@@ -555,14 +556,15 @@
m_delay.rel_value_us = p_recv_delay; /* Peer specific delay */
}
- quota_delay = GST_receive_callback(cls, peer, message, session,
- sender_address, sender_address_len);
+ quota_delay = GST_receive_callback(cls, address, session, message);
if (quota_delay.rel_value_us > m_delay.rel_value_us)
m_delay = quota_delay;
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "Delaying next receive for peer `%s' for %s\n", GNUNET_i2s (peer),
GNUNET_STRINGS_relative_time_to_string (m_delay, GNUNET_YES));
+ "Delaying next receive for peer `%s' for %s\n",
+ GNUNET_i2s (&address->peer),
+ GNUNET_STRINGS_relative_time_to_string (m_delay, GNUNET_YES));
return m_delay;
}
Modified: gnunet/src/transport/gnunet-service-transport_manipulation.h
===================================================================
--- gnunet/src/transport/gnunet-service-transport_manipulation.h
2014-01-13 16:56:41 UTC (rev 31885)
+++ gnunet/src/transport/gnunet-service-transport_manipulation.h
2014-01-13 16:59:57 UTC (rev 31886)
@@ -79,11 +79,9 @@
*/
struct GNUNET_TIME_Relative
GST_manipulation_recv (void *cls,
-
const struct GNUNET_PeerIdentity *peer,
-
const struct GNUNET_MessageHeader *message,
-
struct Session *session,
-
const char *sender_address,
-
uint16_t sender_address_len);
+ const struct GNUNET_HELLO_Address *address,
+ struct Session *session,
+ const struct GNUNET_MessageHeader *message);
/**
* Function that will be called to manipulate ATS information according to
Modified: gnunet/src/transport/gnunet-service-transport_neighbours.c
===================================================================
--- gnunet/src/transport/gnunet-service-transport_neighbours.c 2014-01-13
16:56:41 UTC (rev 31885)
+++ gnunet/src/transport/gnunet-service-transport_neighbours.c 2014-01-13
16:59:57 UTC (rev 31886)
@@ -2300,11 +2300,11 @@
return;
}
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "ATS tells us to switch to address '%s/%s' session %p for "
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ "ATS tells us to switch to %s address '%s' session %p for "
"peer `%s' in state %s/%d (quota in/out %u %u )\n",
- (address->address_length != 0) ? GST_plugins_a2s (address):
"<inbound>",
- address->transport_name,
+ (GNUNET_HELLO_ADDRESS_INFO_INBOUND ==
(GNUNET_HELLO_ADDRESS_INFO_INBOUND & address->local_info)) ? "inbound" : "",
+ GST_plugins_a2s (address),
session,
GNUNET_i2s (peer),
GNUNET_TRANSPORT_p2s (n->state),
Modified: gnunet/src/transport/gnunet-service-transport_validation.c
===================================================================
--- gnunet/src/transport/gnunet-service-transport_validation.c 2014-01-13
16:56:41 UTC (rev 31885)
+++ gnunet/src/transport/gnunet-service-transport_validation.c 2014-01-13
16:59:57 UTC (rev 31886)
@@ -986,6 +986,7 @@
addrend++;
slen = strlen (addr) + 1;
alen -= slen;
+ address.local_info = GNUNET_HELLO_ADDRESS_INFO_NONE;
address.address = addrend;
address.address_length = alen;
address.transport_name = addr;
@@ -1298,6 +1299,7 @@
address.address = addr;
address.address_length = addrlen;
address.transport_name = tname;
+ address.local_info = GNUNET_HELLO_ADDRESS_INFO_NONE;
ve = find_validation_entry (NULL, &address);
if ((NULL == ve) || (GNUNET_NO == ve->expecting_pong))
{
Modified: gnunet/src/transport/plugin_transport_bluetooth.c
===================================================================
--- gnunet/src/transport/plugin_transport_bluetooth.c 2014-01-13 16:56:41 UTC
(rev 31885)
+++ gnunet/src/transport/plugin_transport_bluetooth.c 2014-01-13 16:59:57 UTC
(rev 31886)
@@ -355,8 +355,10 @@
/**
* peer mac address
*/
- struct WlanAddress addr;
+ //struct WlanAddress addr;
+ struct GNUNET_HELLO_Address *address;
+
/**
* Message delay for fragmentation context
*/
@@ -605,8 +607,8 @@
get_radiotap_header (endpoint, radio_header, size);
get_wlan_header (endpoint->plugin,
&radio_header->frame,
- &endpoint->addr.mac,
- size);
+ endpoint->address->address,
+ endpoint->address->address_length);
memcpy (&radio_header[1], hdr, msize);
if (NULL !=
GNUNET_HELPER_send (endpoint->plugin->suid_helper,
@@ -742,7 +744,7 @@
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Created new session for peer `%s' with endpoint %s\n",
GNUNET_i2s (peer),
- mac_to_string (&endpoint->addr.mac));
+ mac_to_string (endpoint->address->address));
return session;
}
@@ -793,8 +795,8 @@
get_radiotap_header (endpoint, radio_header, size);
get_wlan_header (endpoint->plugin,
&radio_header->frame,
- &endpoint->addr.mac,
- size);
+ endpoint->address->address,
+ endpoint->address->address_length);
memcpy (&radio_header[1], hdr, msize);
GNUNET_assert (NULL == fm->sh);
fm->sh = GNUNET_HELPER_send (endpoint->plugin->suid_helper,
@@ -999,10 +1001,11 @@
struct MacEndpoint *pos;
for (pos = plugin->mac_head; NULL != pos; pos = pos->next)
- if (0 == memcmp (addr, &pos->addr, sizeof (struct WlanAddress)))
+ if (0 == memcmp (addr, &pos->address->address, sizeof (struct
WlanAddress)))
return pos;
pos = GNUNET_new (struct MacEndpoint);
- pos->addr = *addr;
+ pos->address = GNUNET_HELLO_address_allocate (NULL, PLUGIN_NAME, addr,
+ sizeof (struct WlanAddress), GNUNET_HELLO_ADDRESS_INFO_NONE);
pos->plugin = plugin;
pos->defrag =
GNUNET_DEFRAGMENT_context_create (plugin->env->stats, WLAN_MTU,
@@ -1244,23 +1247,20 @@
"Processing %u bytes of HELLO from peer `%s' at MAC %s\n",
(unsigned int) msize,
GNUNET_i2s (&tmpsource),
- bluetooth_plugin_address_to_string (NULL, &mas->endpoint->addr, sizeof
(struct WlanAddress)));
+ bluetooth_plugin_address_to_string (NULL, mas->endpoint->address,
+ mas->endpoint->address->address_length));
GNUNET_STATISTICS_update (plugin->env->stats,
_("# HELLO messages received via Bluetooth"), 1,
GNUNET_NO);
plugin->env->receive (plugin->env->cls,
- &tmpsource,
- hdr,
- mas->session,
- (mas->endpoint == NULL) ? NULL : (const char *)
&mas->endpoint->addr,
- (mas->endpoint == NULL) ? 0 : sizeof (struct
GNUNET_TRANSPORT_WLAN_MacAddress));
+ mas->endpoint->address,
+ mas->session,
+ hdr);
plugin->env->update_address_metrics (plugin->env->cls,
- &tmpsource,
- (mas->endpoint == NULL) ? NULL :
(const char *) &mas->endpoint->addr,
- (mas->endpoint == NULL) ? 0 : sizeof
(struct GNUNET_TRANSPORT_WLAN_MacAddress),
- mas->session,
- &ats, 1);
+ mas->endpoint->address,
+ mas->session,
+ &ats, 1);
break;
case GNUNET_MESSAGE_TYPE_FRAGMENT:
if (NULL == mas->endpoint)
@@ -1271,7 +1271,8 @@
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Processing %u bytes of FRAGMENT from MAC %s\n",
(unsigned int) msize,
- bluetooth_plugin_address_to_string (NULL, &mas->endpoint->addr, sizeof
(struct WlanAddress)));
+ bluetooth_plugin_address_to_string (NULL,
mas->endpoint->address->address,
+ mas->endpoint->address->address_length));
GNUNET_STATISTICS_update (plugin->env->stats,
_("# fragments received via Bluetooth"), 1,
GNUNET_NO);
(void) GNUNET_DEFRAGMENT_process_fragment (mas->endpoint->defrag,
@@ -1292,7 +1293,8 @@
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Got last ACK, finished message transmission to `%s' (%p)\n",
- bluetooth_plugin_address_to_string (NULL,
&mas->endpoint->addr, sizeof (struct WlanAddress)),
+ bluetooth_plugin_address_to_string (NULL,
mas->endpoint->address->address,
+ mas->endpoint->address->address_length),
fm);
mas->endpoint->timeout = GNUNET_TIME_relative_to_absolute
(MACENDPOINT_TIMEOUT);
if (NULL != fm->cont)
@@ -1307,13 +1309,15 @@
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Got an ACK, message transmission to `%s' not yet finished\n",
- bluetooth_plugin_address_to_string (NULL,
&mas->endpoint->addr, sizeof (struct WlanAddress)));
+ bluetooth_plugin_address_to_string (NULL,
mas->endpoint->address->address,
+ mas->endpoint->address->address_length));
break;
}
}
LOG (GNUNET_ERROR_TYPE_DEBUG,
"ACK not matched against any active fragmentation with MAC `%s'\n",
- bluetooth_plugin_address_to_string (NULL, &mas->endpoint->addr, sizeof
(struct WlanAddress)));
+ bluetooth_plugin_address_to_string (NULL,
mas->endpoint->address->address,
+ mas->endpoint->address->address_length));
break;
case GNUNET_MESSAGE_TYPE_WLAN_DATA:
if (NULL == mas->endpoint)
@@ -1373,17 +1377,13 @@
(unsigned int) ntohs (hdr->type),
GNUNET_i2s (&mas->session->target));
plugin->env->receive (plugin->env->cls,
- &mas->session->target,
- hdr,
+ mas->endpoint->address,
mas->session,
- (mas->endpoint == NULL) ? NULL : (const char *)
&mas->endpoint->addr,
- (mas->endpoint == NULL) ? 0 : sizeof (struct
WlanAddress));
+ hdr);
plugin->env->update_address_metrics (plugin->env->cls,
- &mas->session->target,
- (mas->endpoint == NULL) ? NULL :
(const char *) &mas->endpoint->addr,
- (mas->endpoint == NULL) ? 0 : sizeof
(struct WlanAddress),
- mas->session,
- &ats, 1);
+ mas->endpoint->address,
+ mas->session,
+ &ats, 1);
break;
}
return GNUNET_OK;
@@ -1402,6 +1402,7 @@
const struct GNUNET_MessageHeader *hdr)
{
struct Plugin *plugin = cls;
+ struct GNUNET_HELLO_Address *address;
const struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *rxinfo;
const struct GNUNET_TRANSPORT_WLAN_HelperControlMessage *cm;
struct WlanAddress wa;
@@ -1428,24 +1429,26 @@
memset (&wa, 0, sizeof (struct WlanAddress));
wa.mac = plugin->mac_address;
wa.options = htonl(plugin->options);
- plugin->env->notify_address (plugin->env->cls, GNUNET_NO,
- &wa,
- sizeof (wa),
- "bluetooth");
+ address = GNUNET_HELLO_address_allocate (plugin->env->my_identity,
+ PLUGIN_NAME, &wa, sizeof (wa), GNUNET_HELLO_ADDRESS_INFO_NONE);
+ plugin->env->notify_address (plugin->env->cls, GNUNET_NO, address);
+ GNUNET_HELLO_address_free (address);
}
plugin->mac_address = cm->mac;
plugin->have_mac = GNUNET_YES;
memset (&wa, 0, sizeof (struct WlanAddress));
wa.mac = plugin->mac_address;
wa.options = htonl(plugin->options);
+ address = GNUNET_HELLO_address_allocate (plugin->env->my_identity,
+ PLUGIN_NAME, &wa, sizeof (wa), GNUNET_HELLO_ADDRESS_INFO_NONE);
+
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Received BT_HELPER_CONTROL message with MAC address `%s' for peer
`%s'\n",
mac_to_string (&cm->mac),
GNUNET_i2s (plugin->env->my_identity));
- plugin->env->notify_address (plugin->env->cls, GNUNET_YES,
- &wa,
- sizeof (struct WlanAddress),
- "bluetooth");
+ plugin->env->notify_address (plugin->env->cls, GNUNET_YES, address);
+ GNUNET_HELLO_address_free (address);
+
break;
case GNUNET_MESSAGE_TYPE_WLAN_DATA_FROM_HELPER:
LOG (GNUNET_ERROR_TYPE_DEBUG,
@@ -1682,7 +1685,8 @@
void *
libgnunet_plugin_transport_bluetooth_done (void *cls)
{
- struct WlanAddress wa;
+ struct WlanAddress wa;
+ struct GNUNET_HELLO_Address *address;
struct GNUNET_TRANSPORT_PluginFunctions *api = cls;
struct Plugin *plugin = api->cls;
struct MacEndpoint *endpoint;
@@ -1696,14 +1700,17 @@
if (GNUNET_YES == plugin->have_mac)
{
- memset (&wa, 0, sizeof (wa));
- wa.options = htonl (plugin->options);
- wa.mac = plugin->mac_address;
- plugin->env->notify_address (plugin->env->cls, GNUNET_NO,
- &wa,
- sizeof (struct WlanAddress),
- "bluetooth");
- plugin->have_mac = GNUNET_NO;
+ memset (&wa, 0, sizeof(wa));
+ wa.options = htonl (plugin->options);
+ wa.mac = plugin->mac_address;
+ address = GNUNET_HELLO_address_allocate (plugin->env->my_identity,
+ PLUGIN_NAME, &wa, sizeof (struct WlanAddress),
+ GNUNET_HELLO_ADDRESS_INFO_NONE);
+
+ plugin->env->notify_address (plugin->env->cls, GNUNET_NO, address);
+ plugin->have_mac = GNUNET_NO;
+
+ GNUNET_HELLO_address_free (address);
}
if (GNUNET_SCHEDULER_NO_TASK != plugin->beacon_task)
Modified: gnunet/src/transport/plugin_transport_http_client.c
===================================================================
--- gnunet/src/transport/plugin_transport_http_client.c 2014-01-13 16:56:41 UTC
(rev 31885)
+++ gnunet/src/transport/plugin_transport_http_client.c 2014-01-13 16:59:57 UTC
(rev 31886)
@@ -155,14 +155,9 @@
/**
* Address
*/
- struct HttpAddress *addr;
+ struct GNUNET_HELLO_Address *address;
/**
- * Address length
- */
- size_t addrlen;
-
- /**
* ATS network type in NBO
*/
uint32_t ats_address_network_type;
@@ -587,7 +582,7 @@
GNUNET_SERVER_mst_destroy (s->msg_tk);
s->msg_tk = NULL;
}
- GNUNET_free (s->addr);
+ GNUNET_HELLO_address_free (s->address);
GNUNET_free (s->url);
GNUNET_free (s);
}
@@ -761,10 +756,11 @@
struct Session *pos;
for (pos = plugin->head; NULL != pos; pos = pos->next)
+ {
if ((0 == memcmp (&address->peer, &pos->target, sizeof (struct
GNUNET_PeerIdentity))) &&
- (address->address_length == pos->addrlen) &&
- (0 == memcmp (address->address, pos->addr, pos->addrlen)))
+ (0 == GNUNET_HELLO_address_cmp(address, pos->address)))
return pos;
+ }
return NULL;
}
@@ -923,14 +919,10 @@
atsi.type = htonl (GNUNET_ATS_NETWORK_TYPE);
atsi.value = s->ats_address_network_type;
GNUNET_break (s->ats_address_network_type != ntohl
(GNUNET_ATS_NET_UNSPECIFIED));
- delay = s->plugin->env->receive (plugin->env->cls, &s->target, message,
- s, (const char *) s->addr, s->addrlen);
+ delay = s->plugin->env->receive (plugin->env->cls, s->address, s, message);
plugin->env->update_address_metrics (plugin->env->cls,
- &s->target,
- s->addr,
- s->addrlen,
- s,
+ s->address, s,
&atsi, 1);
GNUNET_asprintf (&stat_txt,
@@ -949,8 +941,8 @@
"Client: peer `%s' address `%s' next read delayed for
%s\n",
GNUNET_i2s (&s->target),
http_common_plugin_address_to_string (NULL,
- s->plugin->protocol,
- s->addr, s->addrlen),
+ s->plugin->protocol, s->address->address,
+ s->address->address_length),
GNUNET_STRINGS_relative_time_to_string (delay,
GNUNET_YES));
}
@@ -1241,8 +1233,8 @@
static int
client_connect_get (struct Session *s)
{
+ CURLMcode mret;
- CURLMcode mret;
/* create get connection */
s->client_get = curl_easy_init ();
s->get.s = s;
@@ -1254,17 +1246,22 @@
#endif
#if BUILD_HTTPS
curl_easy_setopt (s->client_get, CURLOPT_SSLVERSION, CURL_SSLVERSION_TLSv1);
- if (HTTP_OPTIONS_VERIFY_CERTIFICATE ==
- (ntohl (s->addr->options) & HTTP_OPTIONS_VERIFY_CERTIFICATE))
{
- curl_easy_setopt (s->client_get, CURLOPT_SSL_VERIFYPEER, 1L);
- curl_easy_setopt (s->client_get, CURLOPT_SSL_VERIFYHOST, 2L);
+ struct HttpAddress *ha;
+ ha = (struct HttpAddress *) s->address->address;
+
+ if (HTTP_OPTIONS_VERIFY_CERTIFICATE ==
+ (ntohl (ha->options) & HTTP_OPTIONS_VERIFY_CERTIFICATE))
+ {
+ curl_easy_setopt (s->client_get, CURLOPT_SSL_VERIFYPEER, 1L);
+ curl_easy_setopt (s->client_get, CURLOPT_SSL_VERIFYHOST, 2L);
+ }
+ else
+ {
+ curl_easy_setopt (s->client_get, CURLOPT_SSL_VERIFYPEER, 0);
+ curl_easy_setopt (s->client_get, CURLOPT_SSL_VERIFYHOST, 0);
+ }
}
- else
- {
- curl_easy_setopt (s->client_get, CURLOPT_SSL_VERIFYPEER, 0);
- curl_easy_setopt (s->client_get, CURLOPT_SSL_VERIFYHOST, 0);
- }
curl_easy_setopt (s->client_get, CURLOPT_PROTOCOLS, CURLPROTO_HTTPS);
curl_easy_setopt (s->client_get, CURLOPT_REDIR_PROTOCOLS, CURLPROTO_HTTPS);
#else
@@ -1334,17 +1331,22 @@
#endif
#if BUILD_HTTPS
curl_easy_setopt (s->client_put, CURLOPT_SSLVERSION, CURL_SSLVERSION_TLSv1);
- if (HTTP_OPTIONS_VERIFY_CERTIFICATE ==
- (ntohl (s->addr->options) & HTTP_OPTIONS_VERIFY_CERTIFICATE))
{
- curl_easy_setopt (s->client_put, CURLOPT_SSL_VERIFYPEER, 1L);
- curl_easy_setopt (s->client_put, CURLOPT_SSL_VERIFYHOST, 2L);
+ struct HttpAddress *ha;
+ ha = (struct HttpAddress *) s->address->address;
+
+ if (HTTP_OPTIONS_VERIFY_CERTIFICATE ==
+ (ntohl (ha->options) & HTTP_OPTIONS_VERIFY_CERTIFICATE))
+ {
+ curl_easy_setopt (s->client_put, CURLOPT_SSL_VERIFYPEER, 1L);
+ curl_easy_setopt (s->client_put, CURLOPT_SSL_VERIFYHOST, 2L);
+ }
+ else
+ {
+ curl_easy_setopt (s->client_put, CURLOPT_SSL_VERIFYPEER, 0);
+ curl_easy_setopt (s->client_put, CURLOPT_SSL_VERIFYHOST, 0);
+ }
}
- else
- {
- curl_easy_setopt (s->client_put, CURLOPT_SSL_VERIFYPEER, 0);
- curl_easy_setopt (s->client_put, CURLOPT_SSL_VERIFYHOST, 0);
- }
curl_easy_setopt (s->client_get, CURLOPT_PROTOCOLS, CURLPROTO_HTTPS);
curl_easy_setopt (s->client_get, CURLOPT_REDIR_PROTOCOLS, CURLPROTO_HTTPS);
#else
@@ -1403,8 +1405,7 @@
/* create url */
if (NULL == http_common_plugin_address_to_string (NULL,
- plugin->protocol,
- s->addr, s->addrlen))
+ plugin->protocol, s->address->address, s->address->address_length))
{
GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
plugin->name,
@@ -1414,7 +1415,8 @@
}
GNUNET_asprintf (&s->url, "%s/%s;%u",
- http_common_plugin_address_to_url (NULL, s->addr,
s->addrlen),
+ http_common_plugin_address_to_url (NULL, s->address->address,
+ s->address->address_length),
GNUNET_i2s_full (plugin->env->my_identity),
plugin->last_tag);
@@ -1567,9 +1569,7 @@
s = GNUNET_new (struct Session);
s->target = address->peer;
s->plugin = plugin;
- s->addr = GNUNET_malloc (address->address_length);
- memcpy (s->addr, address->address, address->address_length);
- s->addrlen = address->address_length;
+ s->address = GNUNET_HELLO_address_copy (address);
s->ats_address_network_type = ats.value;
s->put_paused = GNUNET_NO;
s->put_tmp_disconnecting = GNUNET_NO;
@@ -1579,8 +1579,9 @@
s);
GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
"Created new session %p for `%s' address `%s''\n",
- s,
- http_common_plugin_address_to_string (NULL,
plugin->protocol, s->addr, s->addrlen),
+ s, http_common_plugin_address_to_string (NULL,
+ plugin->protocol, s->address->address,
+ s->address->address_length),
GNUNET_i2s (&s->target));
/* add new session */
@@ -1591,7 +1592,9 @@
{
GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, plugin->name,
"Cannot connect to peer `%s' address `%s''\n",
- http_common_plugin_address_to_string (NULL,
plugin->protocol, s->addr, s->addrlen),
+ http_common_plugin_address_to_string (NULL,
+ plugin->protocol,
s->address->address,
+ s->address->address_length),
GNUNET_i2s (&s->target));
client_delete_session (s);
return NULL;
Modified: gnunet/src/transport/plugin_transport_http_common.h
===================================================================
--- gnunet/src/transport/plugin_transport_http_common.h 2014-01-13 16:56:41 UTC
(rev 31885)
+++ gnunet/src/transport/plugin_transport_http_common.h 2014-01-13 16:59:57 UTC
(rev 31886)
@@ -59,7 +59,7 @@
#define HTTP_DEFAULT_PORT 80
#define HTTPS_DEFAULT_PORT 443
-enum HTTP_OPTIONS
+enum HTTP_ADDRESS_OPTIONS
{
HTTP_OPTIONS_NONE = 0,
HTTP_OPTIONS_VERIFY_CERTIFICATE = 1
Modified: gnunet/src/transport/plugin_transport_http_server.c
===================================================================
--- gnunet/src/transport/plugin_transport_http_server.c 2014-01-13 16:56:41 UTC
(rev 31885)
+++ gnunet/src/transport/plugin_transport_http_server.c 2014-01-13 16:59:57 UTC
(rev 31886)
@@ -113,14 +113,9 @@
/**
* Address
*/
- void *addr;
+ struct GNUNET_HELLO_Address *address;
/**
- * Address length
- */
- size_t addrlen;
-
- /**
* Unique HTTP/S connection tag for this connection
*/
uint32_t tag;
@@ -263,7 +258,7 @@
* External hostname the plugin can be connected to, can be different to
* the host's FQDN, used e.g. for reverse proxying
*/
- struct HttpAddress *ext_addr;
+ struct GNUNET_HELLO_Address *ext_addr;
/**
* Notify transport only about external address
@@ -271,11 +266,6 @@
unsigned int external_only;
/**
- * External address length
- */
- size_t ext_addr_len;
-
- /**
* use IPv6
*/
uint16_t use_ipv6;
@@ -668,8 +658,8 @@
if ((NULL != plugin->ext_addr) &&
GNUNET_YES == (http_common_cmp_addresses (addr, addrlen,
- plugin->ext_addr,
- plugin->ext_addr_len)))
+ plugin->ext_addr->address,
+
plugin->ext_addr->address_length)))
{
/* Checking HTTP_OPTIONS_VERIFY_CERTIFICATE option for external hostname */
if ((ntohl (haddr->options) & HTTP_OPTIONS_VERIFY_CERTIFICATE) !=
@@ -743,7 +733,7 @@
GNUNET_SERVER_mst_destroy (s->msg_tk);
s->msg_tk = NULL;
}
- GNUNET_free (s->addr);
+ GNUNET_HELLO_address_free (s->address);
GNUNET_free_non_null (s->server_recv);
GNUNET_free_non_null (s->server_send);
GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
@@ -1082,10 +1072,11 @@
struct Session *s = NULL;
struct ServerConnection *sc = NULL;
const union MHD_ConnectionInfo *conn_info;
+ struct HttpAddress *addr;
+
struct GNUNET_ATS_Information ats;
- struct HttpAddress *addr;
+ struct GNUNET_PeerIdentity target;
size_t addr_len;
- struct GNUNET_PeerIdentity target;
uint32_t tag = 0;
int direction = GNUNET_SYSERR;
unsigned int to;
@@ -1175,8 +1166,8 @@
s = GNUNET_new (struct Session);
memcpy (&s->target, &target, sizeof (struct GNUNET_PeerIdentity));
s->plugin = plugin;
- s->addr = addr;
- s->addrlen = addr_len;
+ s->address = GNUNET_HELLO_address_allocate (&s->target, PLUGIN_NAME,
+ addr, addr_len, GNUNET_HELLO_ADDRESS_INFO_INBOUND);
s->ats_address_network_type = ats.value;
s->next_receive = GNUNET_TIME_UNIT_ZERO_ABS;
s->tag = tag;
@@ -1212,7 +1203,7 @@
if ((NULL != s->server_send) && (NULL != s->server_recv))
{
s->connect_in_progress = GNUNET_NO; /* PUT and GET are connected */
- plugin->env->session_start (NULL, &s->target, PLUGIN_NAME, NULL, 0 ,s,
NULL, 0);
+ plugin->env->session_start (NULL, s->address ,s, NULL, 0);
}
if ((NULL == s->server_recv) || (NULL == s->server_send))
@@ -1353,16 +1344,9 @@
atsi.value = s->ats_address_network_type;
GNUNET_break (s->ats_address_network_type != ntohl
(GNUNET_ATS_NET_UNSPECIFIED));
+ delay = plugin->env->receive (plugin->env->cls, s->address, s, message);
+ plugin->env->update_address_metrics (plugin->env->cls, s->address, s, &atsi,
1);
- delay = plugin->env->receive (plugin->env->cls,
- &s->target,
- message,
- s, NULL, 0);
-
- plugin->env->update_address_metrics (plugin->env->cls,
- &s->target,
- NULL, 0, s, &atsi, 1);
-
GNUNET_asprintf (&stat_txt, "# bytes received via %s_server",
plugin->protocol);
GNUNET_STATISTICS_update (plugin->env->stats,
stat_txt, ntohs (message->size), GNUNET_NO);
@@ -1376,8 +1360,8 @@
"Peer `%s' address `%s' next read delayed for %s\n",
GNUNET_i2s (&s->target),
http_common_plugin_address_to_string (NULL,
- plugin->protocol,
- s->addr,
s->addrlen),
+ plugin->protocol, s->address->address,
+ s->address->address_length),
GNUNET_STRINGS_relative_time_to_string (delay,
GNUNET_YES));
}
@@ -1485,9 +1469,8 @@
s, sc,
GNUNET_i2s (&s->target),
http_common_plugin_address_to_string (NULL,
- plugin->protocol,
- s->addr,
- s->addrlen));
+ plugin->protocol, s->address->address,
+ s->address->address_length));
sc->connected = GNUNET_YES;
return MHD_YES;
}
@@ -1499,9 +1482,8 @@
s, sc,
GNUNET_i2s (&s->target),
http_common_plugin_address_to_string (NULL,
- plugin->protocol,
- s->addr,
- s->addrlen));
+ plugin->protocol, s->address->address,
+ s->address->address_length));
sc->connected = GNUNET_NO;
/* Sent HTTP/1.1: 200 OK as PUT Response\ */
response = MHD_create_response_from_data (strlen ("Thank you!"),
@@ -1519,9 +1501,8 @@
s, sc,
GNUNET_i2s (&s->target),
http_common_plugin_address_to_string (NULL,
- plugin->protocol,
- s->addr,
- s->addrlen),
+ plugin->protocol, s->address->address,
+ s->address->address_length),
*upload_data_size);
struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get ();
@@ -1597,8 +1578,8 @@
"Peer `%s' connection %p, GET on address `%s'
disconnected\n",
GNUNET_i2s (&s->target), s->server_send,
http_common_plugin_address_to_string (NULL,
- plugin->protocol,
- s->addr,
s->addrlen));
+ plugin->protocol, s->address->address,
+ s->address->address_length));
s->server_send = NULL;
if (NULL != (s->server_recv))
{
@@ -1617,8 +1598,8 @@
"Peer `%s' connection %p PUT on address `%s'
disconnected\n",
GNUNET_i2s (&s->target), s->server_recv,
http_common_plugin_address_to_string (NULL,
- plugin->protocol,
- s->addr,
s->addrlen));
+ plugin->protocol, s->address->address,
+ s->address->address_length));
s->server_recv = NULL;
/* Do not terminate session when PUT disconnects
if (NULL != (s->server_send))
@@ -1647,8 +1628,8 @@
"Peer `%s' on address `%s' disconnected\n",
GNUNET_i2s (&s->target),
http_common_plugin_address_to_string (NULL,
- plugin->protocol,
- s->addr,
s->addrlen));
+ plugin->protocol, s->address->address,
+ s->address->address_length));
if ((GNUNET_YES == s->session_passed) && (GNUNET_NO == s->session_ended))
{
@@ -2217,6 +2198,7 @@
socklen_t addrlen)
{
struct HTTP_Server_Plugin *plugin = cls;
+ struct GNUNET_HELLO_Address *address;
struct HttpAddressWrapper *w = NULL;
w = GNUNET_new (struct HttpAddressWrapper);
@@ -2234,11 +2216,17 @@
http_common_plugin_address_to_string (NULL,
plugin->protocol,
w->address,
w->addrlen));
+ /* modify our published address list */
#if BUILD_HTTPS
- plugin->env->notify_address (plugin->env->cls, add_remove, w->address,
w->addrlen, "https_client");
+ address = GNUNET_HELLO_address_allocate (plugin->env->my_identity,
+ "https_client", w->address, w->addrlen, GNUNET_HELLO_ADDRESS_INFO_NONE);
#else
- plugin->env->notify_address (plugin->env->cls, add_remove, w->address,
w->addrlen, "http_client");
+ address = GNUNET_HELLO_address_allocate (plugin->env->my_identity,
+ "http_client", w->address, w->addrlen, GNUNET_HELLO_ADDRESS_INFO_NONE);
#endif
+
+ plugin->env->notify_address (plugin->env->cls, add_remove, address);
+ GNUNET_HELLO_address_free (address);
}
@@ -2255,6 +2243,7 @@
socklen_t addrlen)
{
struct HTTP_Server_Plugin *plugin = cls;
+ struct GNUNET_HELLO_Address *address;
struct HttpAddressWrapper *w = plugin->addr_head;
size_t saddr_len;
void * saddr = http_common_address_from_socket (plugin->protocol, addr,
addrlen);
@@ -2278,12 +2267,20 @@
http_common_plugin_address_to_string (NULL,
plugin->protocol,
w->address,
w->addrlen));
+
+
GNUNET_CONTAINER_DLL_remove (plugin->addr_head, plugin->addr_tail, w);
+
+ /* modify our published address list */
#if BUILD_HTTPS
- plugin->env->notify_address (plugin->env->cls, add_remove, w->address,
w->addrlen, "https_client");
+ address = GNUNET_HELLO_address_allocate (plugin->env->my_identity,
+ "https_client", w->address, w->addrlen, GNUNET_HELLO_ADDRESS_INFO_NONE);
#else
- plugin->env->notify_address (plugin->env->cls, add_remove, w->address,
w->addrlen, "http_client");
+ address = GNUNET_HELLO_address_allocate (plugin->env->my_identity,
+ "http_client", w->address, w->addrlen, GNUNET_HELLO_ADDRESS_INFO_NONE);
#endif
+ plugin->env->notify_address (plugin->env->cls, add_remove, address);
+ GNUNET_HELLO_address_free (address);
GNUNET_free (w->address);
GNUNET_free (w);
}
@@ -2660,6 +2657,8 @@
server_notify_external_hostname (void *cls, const struct
GNUNET_SCHEDULER_TaskContext *tc)
{
struct HTTP_Server_Plugin *plugin = cls;
+ struct HttpAddress *ext_addr;
+ size_t ext_addr_len;
unsigned int urlen;
char *url;
@@ -2670,26 +2669,30 @@
GNUNET_asprintf(&url, "%s://%s", plugin->protocol,
plugin->external_hostname);
urlen = strlen (url) + 1;
- plugin->ext_addr = GNUNET_malloc (sizeof (struct HttpAddress) + urlen);
- plugin->ext_addr->options = htonl(plugin->options);
- plugin->ext_addr->urlen = htonl (urlen);
- plugin->ext_addr_len = sizeof (struct HttpAddress) + urlen;
- memcpy (&plugin->ext_addr[1], url, urlen);
+ ext_addr = GNUNET_malloc (sizeof (struct HttpAddress) + urlen);
+ ext_addr->options = htonl(plugin->options);
+ ext_addr->urlen = htonl (urlen);
+ ext_addr_len = sizeof (struct HttpAddress) + urlen;
+ memcpy (&ext_addr[1], url, urlen);
GNUNET_free (url);
+
GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
"Notifying transport about external hostname address
`%s'\n", plugin->external_hostname);
#if BUILD_HTTPS
if (GNUNET_YES == plugin->verify_external_hostname)
- GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, plugin->name,
- "Enabling SSL verification for external hostname address
`%s'\n", plugin->external_hostname);
- plugin->env->notify_address (plugin->env->cls, GNUNET_YES,
- plugin->ext_addr, plugin->ext_addr_len,
- "https_client");
+ GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, plugin->name,
+ "Enabling SSL verification for external hostname address `%s'\n",
+ plugin->external_hostname);
+ plugin->ext_addr = GNUNET_HELLO_address_allocate (plugin->env->my_identity,
+ "https_client", ext_addr, ext_addr_len, GNUNET_HELLO_ADDRESS_INFO_NONE );
+ plugin->env->notify_address (plugin->env->cls, GNUNET_YES, plugin->ext_addr);
+ GNUNET_free (ext_addr);
#else
- plugin->env->notify_address (plugin->env->cls, GNUNET_YES,
- plugin->ext_addr, plugin->ext_addr_len,
- "http_client");
+ plugin->ext_addr = GNUNET_HELLO_address_allocate (plugin->env->my_identity,
+ "http_client", ext_addr, ext_addr_len, GNUNET_HELLO_ADDRESS_INFO_NONE );
+ plugin->env->notify_address (plugin->env->cls, GNUNET_YES, plugin->ext_addr);
+ GNUNET_free (ext_addr);
#endif
}
@@ -3013,21 +3016,19 @@
"Notifying transport to remove address `%s'\n",
http_common_plugin_address_to_string (NULL,
plugin->protocol,
- plugin->ext_addr,
-
plugin->ext_addr_len));
+
plugin->ext_addr->address,
+
plugin->ext_addr->address_length));
#if BUILD_HTTPS
plugin->env->notify_address (plugin->env->cls,
GNUNET_NO,
- plugin->ext_addr,
- plugin->ext_addr_len,
- "https_client");
+ plugin->ext_addr);
#else
plugin->env->notify_address (plugin->env->cls,
GNUNET_NO,
- plugin->ext_addr,
- plugin->ext_addr_len,
- "http_client");
+ plugin->ext_addr);
#endif
+ GNUNET_HELLO_address_free (plugin->ext_addr);
+ plugin->ext_addr = NULL;
}
/* Stop to report addresses to transport service */
Modified: gnunet/src/transport/plugin_transport_tcp.c
===================================================================
--- gnunet/src/transport/plugin_transport_tcp.c 2014-01-13 16:56:41 UTC (rev
31885)
+++ gnunet/src/transport/plugin_transport_tcp.c 2014-01-13 16:59:57 UTC (rev
31886)
@@ -1,22 +1,22 @@
/*
- This file is part of GNUnet
- (C) 2002--2013 Christian Grothoff (and other contributing authors)
+ This file is part of GNUnet
+ (C) 2002--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
- by the Free Software Foundation; either version 3, or (at your
- option) any later version.
+ GNUnet is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published
+ by the Free Software Foundation; either version 3, or (at your
+ option) any later version.
- GNUnet is distributed in the hope that it will be useful, but
- WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- General Public License for more details.
+ GNUnet is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
- 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.
-*/
+ 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.
+ */
/**
* @file transport/plugin_transport_tcp.c
* @brief Implementation of the TCP transport service
@@ -47,7 +47,6 @@
*/
#define NAT_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
10)
-
GNUNET_NETWORK_STRUCT_BEGIN
/**
@@ -72,7 +71,6 @@
};
-
/**
* Basically a WELCOME message, but with the purpose
* of giving the waiting peer a client handle to use
@@ -129,7 +127,6 @@
struct Plugin *plugin;
};
-
GNUNET_NETWORK_STRUCT_BEGIN
/**
@@ -154,7 +151,6 @@
};
-
/**
* Network format for IPv6 addresses.
*/
@@ -183,7 +179,6 @@
*/
struct Plugin;
-
/**
* Information kept for each message that is yet to
* be transmitted.
@@ -232,7 +227,6 @@
};
-
/**
* Session handle for TCP connections.
*/
@@ -291,19 +285,19 @@
*/
GNUNET_SCHEDULER_TaskIdentifier timeout_task;
+ struct GNUNET_HELLO_Address *address;
+
/**
* Address of the other peer (either based on our 'connect'
* call or on our 'accept' call).
*
* struct IPv4TcpAddress or struct IPv6TcpAddress
*/
- void *addr;
-
+ //void *addr;
/**
* Length of @e addr.
*/
- size_t addrlen;
-
+ //size_t addrlen;
/**
* Last activity on this connection. Used to select preferred
* connection.
@@ -316,11 +310,6 @@
int expecting_welcome;
/**
- * Was this a connection that was inbound (we accepted)?
(#GNUNET_YES/#GNUNET_NO)
- */
- int inbound;
-
- /**
* Was this session created using NAT traversal?
*/
int is_nat;
@@ -331,7 +320,6 @@
enum GNUNET_ATS_Network_Type ats_address_network_type;
};
-
/**
* Encapsulation of all of the state of the plugin.
*/
@@ -421,7 +409,6 @@
};
-
/**
* Function called for a quick conversion of the binary address to
* a numeric address. Note that the caller must not free the
@@ -434,11 +421,8 @@
* @return string representing the same address
*/
static const char *
-tcp_address_to_string (void *cls,
- const void *addr,
- size_t addrlen);
+tcp_address_to_string (void *cls, const void *addr, size_t addrlen);
-
/**
* Function to check if an inbound connection is acceptable.
* Mostly used to limit the total number of open connections
@@ -453,20 +437,19 @@
*/
static int
plugin_tcp_access_check (void *cls,
- const struct GNUNET_CONNECTION_Credentials *ucred,
- const struct sockaddr *addr, socklen_t addrlen)
+ const struct GNUNET_CONNECTION_Credentials *ucred,
+ const struct sockaddr *addr, socklen_t addrlen)
{
struct Plugin *plugin = cls;
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Accepting new incoming TCP connection from `%s'\n",
- GNUNET_a2s (addr, addrlen));
+ LOG(GNUNET_ERROR_TYPE_DEBUG,
+ "Accepting new incoming TCP connection from `%s'\n",
+ GNUNET_a2s (addr, addrlen));
if (plugin->cur_connections >= plugin->max_connections)
return GNUNET_NO;
- plugin->cur_connections ++;
+ plugin->cur_connections++;
return GNUNET_YES;
}
-
/**
* Our external IP address/port mapping has changed.
*
@@ -478,50 +461,51 @@
*/
static void
tcp_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;
struct IPv4TcpAddress t4;
struct IPv6TcpAddress t6;
void *arg;
size_t args;
- LOG (GNUNET_ERROR_TYPE_INFO,
- "NAT notification to %s address `%s'\n",
- (GNUNET_YES == add_remove) ? "add" : "remove",
- GNUNET_a2s (addr, addrlen));
+ LOG(GNUNET_ERROR_TYPE_INFO, "NAT notification to %s address `%s'\n",
+ (GNUNET_YES == add_remove) ? "add" : "remove",
+ GNUNET_a2s (addr, addrlen));
/* convert 'addr' to our internal format */
switch (addr->sa_family)
{
case AF_INET:
- GNUNET_assert (addrlen == sizeof (struct sockaddr_in));
- memset (&t4,0, sizeof (t4));
+ GNUNET_assert(addrlen == sizeof(struct sockaddr_in));
+ memset (&t4, 0, sizeof(t4));
t4.options = htonl (myoptions);
t4.ipv4_addr = ((struct sockaddr_in *) addr)->sin_addr.s_addr;
t4.t4_port = ((struct sockaddr_in *) addr)->sin_port;
arg = &t4;
- args = sizeof (t4);
+ args = sizeof(t4);
break;
case AF_INET6:
- GNUNET_assert (addrlen == sizeof (struct sockaddr_in6));
- memset (&t6, 0, sizeof (t6));
+ GNUNET_assert(addrlen == sizeof(struct sockaddr_in6));
+ memset (&t6, 0, sizeof(t6));
memcpy (&t6.ipv6_addr, &((struct sockaddr_in6 *) addr)->sin6_addr,
- sizeof (struct in6_addr));
+ sizeof(struct in6_addr));
t6.options = htonl (myoptions);
t6.t6_port = ((struct sockaddr_in6 *) addr)->sin6_port;
arg = &t6;
- args = sizeof (t6);
+ args = sizeof(t6);
break;
default:
- GNUNET_break (0);
+ GNUNET_break(0);
return;
}
/* modify our published address list */
- plugin->env->notify_address (plugin->env->cls, add_remove, arg, args, "tcp");
+ address = GNUNET_HELLO_address_allocate (plugin->env->my_identity,
+ PLUGIN_NAME, arg, args, GNUNET_HELLO_ADDRESS_INFO_NONE);
+ plugin->env->notify_address (plugin->env->cls, add_remove, address);
+ GNUNET_HELLO_address_free(address);
}
-
/**
* Function called for a quick conversion of the binary address to
* a numeric address. Note that the caller must not free the
@@ -549,52 +533,44 @@
switch (addrlen)
{
- case sizeof (struct IPv6TcpAddress):
+ case sizeof(struct IPv6TcpAddress):
t6 = addr;
af = AF_INET6;
port = ntohs (t6->t6_port);
options = ntohl (t6->options);
- memcpy (&a6, &t6->ipv6_addr, sizeof (a6));
+ memcpy (&a6, &t6->ipv6_addr, sizeof(a6));
sb = &a6;
break;
- case sizeof (struct IPv4TcpAddress):
+ case sizeof(struct IPv4TcpAddress):
t4 = addr;
af = AF_INET;
port = ntohs (t4->t4_port);
options = ntohl (t4->options);
- memcpy (&a4, &t4->ipv4_addr, sizeof (a4));
+ memcpy (&a4, &t4->ipv4_addr, sizeof(a4));
sb = &a4;
break;
case 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;
+ }
default:
- LOG (GNUNET_ERROR_TYPE_WARNING,
- _("Unexpected address length: %u bytes\n"),
- (unsigned int) addrlen);
- return NULL;
+ LOG(GNUNET_ERROR_TYPE_WARNING, _("Unexpected address length: %u bytes\n"),
+ (unsigned int ) addrlen);
+ return NULL ;
}
if (NULL == inet_ntop (af, sb, buf, INET6_ADDRSTRLEN))
{
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "inet_ntop");
- return NULL;
+ GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "inet_ntop");
+ return NULL ;
}
- GNUNET_snprintf (rbuf,
- sizeof (rbuf),
- (af == AF_INET6)
- ? "%s.%u.[%s]:%u"
- : "%s.%u.%s:%u",
- PLUGIN_NAME,
- options,
- buf,
- port);
+ GNUNET_snprintf (rbuf, sizeof(rbuf),
+ (af == AF_INET6) ? "%s.%u.[%s]:%u" : "%s.%u.%s:%u", PLUGIN_NAME, options,
+ buf, port);
return rbuf;
}
-
/**
* Function called to convert a string address to
* a binary address.
@@ -608,10 +584,8 @@
* @return #GNUNET_OK on success, #GNUNET_SYSERR on failure
*/
static int
-tcp_string_to_address (void *cls,
- const char *addr,
- uint16_t addrlen,
- void **buf, size_t *added)
+tcp_string_to_address (void *cls, const char *addr, uint16_t addrlen,
+ void **buf, size_t *added)
{
struct sockaddr_storage socket_address;
char *address;
@@ -625,82 +599,81 @@
optionstr = NULL;
if ((NULL == addr) || (addrlen == 0))
{
- GNUNET_break (0);
+ GNUNET_break(0);
return GNUNET_SYSERR;
}
if ('\0' != addr[addrlen - 1])
{
- GNUNET_break (0);
+ GNUNET_break(0);
return GNUNET_SYSERR;
}
if (strlen (addr) != addrlen - 1)
{
- GNUNET_break (0);
+ GNUNET_break(0);
return GNUNET_SYSERR;
}
plugin = GNUNET_strdup (addr);
optionstr = strchr (plugin, '.');
if (NULL == optionstr)
{
- GNUNET_break (0);
- GNUNET_free (plugin);
+ GNUNET_break(0);
+ GNUNET_free(plugin);
return GNUNET_SYSERR;
}
optionstr[0] = '\0';
- optionstr ++;
+ optionstr++;
options = atol (optionstr);
address = strchr (optionstr, '.');
if (NULL == address)
{
- GNUNET_break (0);
- GNUNET_free (plugin);
+ GNUNET_break(0);
+ GNUNET_free(plugin);
return GNUNET_SYSERR;
}
address[0] = '\0';
- address ++;
+ 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);
+ GNUNET_break(0);
+ GNUNET_free(plugin);
return GNUNET_SYSERR;
}
- GNUNET_free (plugin);
+ GNUNET_free(plugin);
switch (socket_address.ss_family)
{
case AF_INET:
- {
- struct IPv4TcpAddress *t4;
- struct sockaddr_in *in4 = (struct sockaddr_in *) &socket_address;
- t4 = GNUNET_new (struct IPv4TcpAddress);
- t4->options = htonl (options);
- t4->ipv4_addr = in4->sin_addr.s_addr;
- t4->t4_port = in4->sin_port;
- *buf = t4;
- *added = sizeof (struct IPv4TcpAddress);
- return GNUNET_OK;
- }
+ {
+ struct IPv4TcpAddress *t4;
+ struct sockaddr_in *in4 = (struct sockaddr_in *) &socket_address;
+ t4 = GNUNET_new (struct IPv4TcpAddress);
+ t4->options = htonl (options);
+ t4->ipv4_addr = in4->sin_addr.s_addr;
+ t4->t4_port = in4->sin_port;
+ *buf = t4;
+ *added = sizeof(struct IPv4TcpAddress);
+ return GNUNET_OK;
+ }
case AF_INET6:
- {
- struct IPv6TcpAddress *t6;
- struct sockaddr_in6 *in6 = (struct sockaddr_in6 *) &socket_address;
- t6 = GNUNET_new (struct IPv6TcpAddress);
- t6->options = htonl (options);
- t6->ipv6_addr = in6->sin6_addr;
- t6->t6_port = in6->sin6_port;
- *buf = t6;
- *added = sizeof (struct IPv6TcpAddress);
- return GNUNET_OK;
- }
+ {
+ struct IPv6TcpAddress *t6;
+ struct sockaddr_in6 *in6 = (struct sockaddr_in6 *) &socket_address;
+ t6 = GNUNET_new (struct IPv6TcpAddress);
+ t6->options = htonl (options);
+ t6->ipv6_addr = in6->sin6_addr;
+ t6->t6_port = in6->sin6_port;
+ *buf = t6;
+ *added = sizeof(struct IPv6TcpAddress);
+ return GNUNET_OK;
+ }
default:
return GNUNET_SYSERR;
}
}
-
/**
* Closure for #session_lookup_by_client_it().
*/
@@ -717,11 +690,9 @@
struct Session *ret;
};
-
static int
-session_lookup_by_client_it (void *cls,
- const struct GNUNET_PeerIdentity *key,
- void *value)
+session_lookup_by_client_it (void *cls, const struct GNUNET_PeerIdentity *key,
+ void *value)
{
struct SessionClientCtx *sc_ctx = cls;
struct Session *s = value;
@@ -734,7 +705,6 @@
return GNUNET_YES;
}
-
/**
* Find the session handle for the given client.
* Currently uses both the hashmap and the client
@@ -747,7 +717,7 @@
*/
static struct Session *
lookup_session_by_client (struct Plugin *plugin,
- struct GNUNET_SERVER_Client *client)
+ struct GNUNET_SERVER_Client *client)
{
struct Session *ret;
struct SessionClientCtx sc_ctx;
@@ -756,13 +726,12 @@
sc_ctx.client = client;
sc_ctx.ret = NULL;
GNUNET_CONTAINER_multipeermap_iterate (plugin->sessionmap,
- &session_lookup_by_client_it,
&sc_ctx);
+ &session_lookup_by_client_it, &sc_ctx);
/* check both methods yield the same result */
- GNUNET_break (ret == sc_ctx.ret);
+ GNUNET_break(ret == sc_ctx.ret);
return sc_ctx.ret;
}
-
/**
* Functions with this signature are called whenever we need
* to close a session due to a disconnect or failure to
@@ -773,16 +742,15 @@
* @return #GNUNET_OK on success
*/
static int
-tcp_disconnect_session (void *cls,
- struct Session *session)
+tcp_disconnect_session (void *cls, struct Session *session)
{
struct Plugin *plugin = cls;
struct PendingMessage *pm;
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Disconnecting session of peer `%s' address `%s'\n",
- GNUNET_i2s (&session->target),
- tcp_address_to_string (NULL, session->addr, session->addrlen));
+ LOG(GNUNET_ERROR_TYPE_DEBUG,
+ "Disconnecting session of peer `%s' address `%s'\n",
+ GNUNET_i2s (&session->target),
+ tcp_address_to_string (NULL, session->address->address,
session->address->address_length));
if (GNUNET_SCHEDULER_NO_TASK != session->timeout_task)
{
@@ -790,25 +758,20 @@
session->timeout_task = GNUNET_SCHEDULER_NO_TASK;
}
- if (GNUNET_YES ==
- GNUNET_CONTAINER_multipeermap_remove (plugin->sessionmap,
- &session->target,
- session))
+ if (GNUNET_YES
+ == GNUNET_CONTAINER_multipeermap_remove (plugin->sessionmap,
+ &session->target, session))
{
GNUNET_STATISTICS_update (session->plugin->env->stats,
- gettext_noop ("# TCP sessions active"), -1,
- GNUNET_NO);
+ gettext_noop ("# TCP sessions active"), -1, GNUNET_NO);
}
else
{
- GNUNET_assert (GNUNET_YES ==
- GNUNET_CONTAINER_multipeermap_remove
(plugin->nat_wait_conns,
- &session->target,
- session));
+ GNUNET_assert(
+ GNUNET_YES == GNUNET_CONTAINER_multipeermap_remove
(plugin->nat_wait_conns, &session->target, session));
}
if (NULL != session->client)
- GNUNET_SERVER_client_set_user_context (session->client,
- (void *) NULL);
+ GNUNET_SERVER_client_set_user_context(session->client, (void *) NULL);
/* clean up state */
if (NULL != session->transmit_handle)
@@ -817,7 +780,7 @@
session->transmit_handle = NULL;
}
session->plugin->env->session_end (session->plugin->env->cls,
- &session->target, session);
+ &session->target, session);
if (GNUNET_SCHEDULER_NO_TASK != session->nat_connection_timeout)
{
@@ -827,26 +790,22 @@
while (NULL != (pm = session->pending_messages_head))
{
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- pm->transmit_cont !=
- NULL ? "Could not deliver message to `%4s'.\n" :
- "Could not deliver message to `%4s', notifying.\n",
- GNUNET_i2s (&session->target));
+ LOG(GNUNET_ERROR_TYPE_DEBUG,
+ pm->transmit_cont != NULL ? "Could not deliver message to `%4s'.\n" :
"Could not deliver message to `%4s', notifying.\n",
+ GNUNET_i2s (&session->target));
GNUNET_STATISTICS_update (session->plugin->env->stats,
- gettext_noop ("# bytes currently in TCP
buffers"),
- -(int64_t) pm->message_size, GNUNET_NO);
- GNUNET_STATISTICS_update (session->plugin->env->stats,
- gettext_noop
- ("# bytes discarded by TCP (disconnect)"),
- pm->message_size, GNUNET_NO);
- GNUNET_CONTAINER_DLL_remove (session->pending_messages_head,
- session->pending_messages_tail, pm);
+ gettext_noop ("# bytes currently in TCP buffers"),
+ -(int64_t) pm->message_size, GNUNET_NO);
+ GNUNET_STATISTICS_update (session->plugin->env->stats, gettext_noop
+ ("# bytes discarded by TCP (disconnect)"), pm->message_size, GNUNET_NO);
+ GNUNET_CONTAINER_DLL_remove(session->pending_messages_head,
+ session->pending_messages_tail, pm);
if (NULL != pm->transmit_cont)
- pm->transmit_cont (pm->transmit_cont_cls, &session->target,
- GNUNET_SYSERR, pm->message_size, 0);
- GNUNET_free (pm);
+ pm->transmit_cont (pm->transmit_cont_cls, &session->target,
GNUNET_SYSERR,
+ pm->message_size, 0);
+ GNUNET_free(pm);
}
- if (session->receive_delay_task != GNUNET_SCHEDULER_NO_TASK)
+ if (session->receive_delay_task != GNUNET_SCHEDULER_NO_TASK )
{
GNUNET_SCHEDULER_cancel (session->receive_delay_task);
if (NULL != session->client)
@@ -858,13 +817,12 @@
GNUNET_SERVER_client_drop (session->client);
session->client = NULL;
}
- GNUNET_free_non_null (session->addr);
- GNUNET_assert (NULL == session->transmit_handle);
- GNUNET_free (session);
+ GNUNET_HELLO_address_free(session->address);
+ GNUNET_assert(NULL == session->transmit_handle);
+ GNUNET_free(session);
return GNUNET_OK;
}
-
/**
* Function that is called to get the keepalive factor.
* GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT is divided by this number to
@@ -879,7 +837,6 @@
return 3;
}
-
/**
* Session was idle, so disconnect it
*
@@ -887,22 +844,18 @@
* @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
(GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
- GNUNET_YES));
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+ "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 */
tcp_disconnect_session (s->plugin, s);
}
-
/**
* Increment session timeout due to activity
*
@@ -911,19 +864,15 @@
static void
reschedule_session_timeout (struct Session *s)
{
- GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != s->timeout_task);
+ GNUNET_assert(GNUNET_SCHEDULER_NO_TASK != s->timeout_task);
GNUNET_SCHEDULER_cancel (s->timeout_task);
- s->timeout_task = GNUNET_SCHEDULER_add_delayed
(GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
- &session_timeout,
- s);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Timeout rescheduled for session %p set to %s\n",
- s,
- GNUNET_STRINGS_relative_time_to_string
(GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
- GNUNET_YES));
+ s->timeout_task = GNUNET_SCHEDULER_add_delayed (
+ GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, &session_timeout, s);
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+ "Timeout rescheduled for session %p set to %s\n", s,
+ GNUNET_STRINGS_relative_time_to_string
(GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, GNUNET_YES));
}
-
/**
* Create a new session. Also queues a welcome message.
*
@@ -936,22 +885,20 @@
* @return new session object
*/
static struct Session *
-create_session (struct Plugin *plugin,
- const struct GNUNET_PeerIdentity *target,
- struct GNUNET_SERVER_Client *client, int is_nat)
+create_session (struct Plugin *plugin, const struct GNUNET_PeerIdentity
*target,
+ struct GNUNET_SERVER_Client *client, int is_nat)
{
struct Session *session;
struct PendingMessage *pm;
struct WelcomeMessage welcome;
if (GNUNET_YES != is_nat)
- GNUNET_assert (NULL != client);
+ GNUNET_assert(NULL != client);
else
- GNUNET_assert (NULL == client);
+ GNUNET_assert(NULL == client);
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Creating new session for peer `%4s'\n",
- GNUNET_i2s (target));
+ LOG(GNUNET_ERROR_TYPE_DEBUG, "Creating new session for peer `%4s'\n",
+ GNUNET_i2s (target));
session = GNUNET_new (struct Session);
session->last_activity = GNUNET_TIME_absolute_get ();
session->plugin = plugin;
@@ -961,32 +908,29 @@
session->expecting_welcome = GNUNET_YES;
session->ats_address_network_type = GNUNET_ATS_NET_UNSPECIFIED;
pm = GNUNET_malloc (sizeof (struct PendingMessage) +
- sizeof (struct WelcomeMessage));
+ sizeof (struct WelcomeMessage));
pm->msg = (const char *) &pm[1];
- pm->message_size = sizeof (struct WelcomeMessage);
- welcome.header.size = htons (sizeof (struct WelcomeMessage));
+ pm->message_size = sizeof(struct WelcomeMessage);
+ welcome.header.size = htons (sizeof(struct WelcomeMessage));
welcome.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_TCP_WELCOME);
welcome.clientIdentity = *plugin->env->my_identity;
- memcpy (&pm[1], &welcome, sizeof (welcome));
+ memcpy (&pm[1], &welcome, sizeof(welcome));
pm->timeout = GNUNET_TIME_UNIT_FOREVER_ABS;
GNUNET_STATISTICS_update (plugin->env->stats,
- gettext_noop ("# bytes currently in TCP buffers"),
- pm->message_size, GNUNET_NO);
- GNUNET_CONTAINER_DLL_insert (session->pending_messages_head,
- session->pending_messages_tail, pm);
+ gettext_noop ("# bytes currently in TCP buffers"), pm->message_size,
+ GNUNET_NO);
+ GNUNET_CONTAINER_DLL_insert(session->pending_messages_head,
+ session->pending_messages_tail, pm);
if (GNUNET_YES != is_nat)
{
GNUNET_STATISTICS_update (plugin->env->stats,
- gettext_noop ("# TCP sessions active"), 1,
- GNUNET_NO);
+ gettext_noop ("# TCP sessions active"), 1, GNUNET_NO);
}
- session->timeout_task = GNUNET_SCHEDULER_add_delayed
(GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
- &session_timeout,
- session);
+ session->timeout_task = GNUNET_SCHEDULER_add_delayed (
+ GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, &session_timeout, session);
return session;
}
-
/**
* If we have pending messages, ask the server to
* transmit them (schedule the respective tasks, etc.)
@@ -996,7 +940,6 @@
static void
process_pending_messages (struct Session *session);
-
/**
* Function called to notify a client about the socket
* being ready to queue more data. "buf" will be
@@ -1025,24 +968,24 @@
plugin = session->plugin;
if (NULL == buf)
{
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Timeout trying to transmit to peer `%4s', discarding message
queue.\n",
- GNUNET_i2s (&session->target));
+ LOG(GNUNET_ERROR_TYPE_DEBUG,
+ "Timeout trying to transmit to peer `%4s', discarding message
queue.\n",
+ GNUNET_i2s (&session->target));
/* timeout; cancel all messages that have already expired */
hd = NULL;
tl = NULL;
ret = 0;
now = GNUNET_TIME_absolute_get ();
- while ((NULL != (pos = session->pending_messages_head)) &&
- (pos->timeout.abs_value_us <= now.abs_value_us))
+ while ((NULL != (pos = session->pending_messages_head))
+ && (pos->timeout.abs_value_us <= now.abs_value_us))
{
- GNUNET_CONTAINER_DLL_remove (session->pending_messages_head,
- session->pending_messages_tail, pos);
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Failed to transmit %u byte message to `%4s'.\n",
- pos->message_size, GNUNET_i2s (&session->target));
+ GNUNET_CONTAINER_DLL_remove(session->pending_messages_head,
+ session->pending_messages_tail, pos);
+ LOG(GNUNET_ERROR_TYPE_DEBUG,
+ "Failed to transmit %u byte message to `%4s'.\n", pos->message_size,
+ GNUNET_i2s (&session->target));
ret += pos->message_size;
- GNUNET_CONTAINER_DLL_insert_after (hd, tl, tl, pos);
+ GNUNET_CONTAINER_DLL_insert_after(hd, tl, tl, pos);
}
/* do this call before callbacks (so that if callbacks destroy
* session, they have a chance to cancel actions done by this
@@ -1053,18 +996,17 @@
* the callbacks may abort the session */
while (NULL != (pos = hd))
{
- GNUNET_CONTAINER_DLL_remove (hd, tl, pos);
- if (pos->transmit_cont != NULL)
- pos->transmit_cont (pos->transmit_cont_cls, &pid, GNUNET_SYSERR,
pos->message_size, 0);
- GNUNET_free (pos);
+ GNUNET_CONTAINER_DLL_remove(hd, tl, pos);
+ if (pos->transmit_cont != NULL )
+ pos->transmit_cont (pos->transmit_cont_cls, &pid, GNUNET_SYSERR,
+ pos->message_size, 0);
+ GNUNET_free(pos);
}
GNUNET_STATISTICS_update (plugin->env->stats,
- gettext_noop ("# bytes currently in TCP
buffers"),
- -(int64_t) ret, GNUNET_NO);
- GNUNET_STATISTICS_update (plugin->env->stats,
- gettext_noop
- ("# bytes discarded by TCP (timeout)"), ret,
- GNUNET_NO);
+ gettext_noop ("# bytes currently in TCP buffers"), -(int64_t) ret,
+ GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats, gettext_noop
+ ("# bytes discarded by TCP (timeout)"), ret, GNUNET_NO);
return 0;
}
/* copy all pending messages that would fit */
@@ -1076,18 +1018,17 @@
{
if (ret + pos->message_size > size)
break;
- GNUNET_CONTAINER_DLL_remove (session->pending_messages_head,
- session->pending_messages_tail, pos);
- GNUNET_assert (size >= pos->message_size);
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Transmitting message of type %u\n",
- ntohs (((struct GNUNET_MessageHeader *) pos->msg)->type));
+ GNUNET_CONTAINER_DLL_remove(session->pending_messages_head,
+ session->pending_messages_tail, pos);
+ GNUNET_assert(size >= pos->message_size);
+ LOG(GNUNET_ERROR_TYPE_DEBUG, "Transmitting message of type %u\n",
+ ntohs (((struct GNUNET_MessageHeader * ) pos->msg)->type));
/* FIXME: this memcpy can be up to 7% of our total runtime */
memcpy (cbuf, pos->msg, pos->message_size);
cbuf += pos->message_size;
ret += pos->message_size;
size -= pos->message_size;
- GNUNET_CONTAINER_DLL_insert_tail (hd, tl, pos);
+ GNUNET_CONTAINER_DLL_insert_tail(hd, tl, pos);
}
/* schedule 'continuation' before callbacks so that callbacks that
* cancel everything don't cause us to use a session that no longer
@@ -1099,25 +1040,23 @@
* we should not use 'session' after this point */
while (NULL != (pos = hd))
{
- GNUNET_CONTAINER_DLL_remove (hd, tl, pos);
- if (pos->transmit_cont != NULL)
- pos->transmit_cont (pos->transmit_cont_cls, &pid, GNUNET_OK,
pos->message_size, pos->message_size); /* FIXME: include TCP overhead */
- GNUNET_free (pos);
+ GNUNET_CONTAINER_DLL_remove(hd, tl, pos);
+ if (pos->transmit_cont != NULL )
+ pos->transmit_cont (pos->transmit_cont_cls, &pid, GNUNET_OK,
+ pos->message_size, pos->message_size); /* FIXME: include TCP
overhead */
+ GNUNET_free(pos);
}
- GNUNET_assert (hd == NULL);
- GNUNET_assert (tl == NULL);
- LOG (GNUNET_ERROR_TYPE_DEBUG, "Transmitting %u bytes\n",
- ret);
+ GNUNET_assert(hd == NULL);
+ GNUNET_assert(tl == NULL);
+ LOG(GNUNET_ERROR_TYPE_DEBUG, "Transmitting %u bytes\n", ret);
GNUNET_STATISTICS_update (plugin->env->stats,
- gettext_noop ("# bytes currently in TCP buffers"),
- -(int64_t) ret, GNUNET_NO);
+ gettext_noop ("# bytes currently in TCP buffers"), -(int64_t) ret,
+ GNUNET_NO);
GNUNET_STATISTICS_update (plugin->env->stats,
- gettext_noop ("# bytes transmitted via TCP"), ret,
- GNUNET_NO);
+ gettext_noop ("# bytes transmitted via TCP"), ret, GNUNET_NO);
return ret;
}
-
/**
* If we have pending messages, ask the server to
* transmit them (schedule the respective tasks, etc.)
@@ -1129,20 +1068,17 @@
{
struct PendingMessage *pm;
- GNUNET_assert (NULL != session->client);
+ GNUNET_assert(NULL != session->client);
if (NULL != session->transmit_handle)
return;
if (NULL == (pm = session->pending_messages_head))
return;
- session->transmit_handle =
- GNUNET_SERVER_notify_transmit_ready (session->client, pm->message_size,
- GNUNET_TIME_absolute_get_remaining
- (pm->timeout), &do_transmit,
- session);
+ session->transmit_handle = GNUNET_SERVER_notify_transmit_ready (
+ session->client, pm->message_size,
+ GNUNET_TIME_absolute_get_remaining (pm->timeout), &do_transmit, session);
}
-
#if EXTRA_CHECKS
/**
* Closure for #session_it().
@@ -1160,7 +1096,6 @@
int res;
};
-
/**
* Function called to check if a session is in our maps.
*
@@ -1170,9 +1105,7 @@
* @return #GNUNET_YES to continue looking, #GNUNET_NO if we found the session
*/
static int
-session_it (void *cls,
- const struct GNUNET_PeerIdentity *key,
- void *value)
+session_it (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
{
struct FindSessionContext *res = cls;
struct Session *session = value;
@@ -1185,7 +1118,6 @@
return GNUNET_YES;
}
-
/**
* Check that the given session is known to the plugin and
* is in one of our maps.
@@ -1195,30 +1127,28 @@
* @return #GNUNET_OK if all is well, #GNUNET_SYSERR if the session is invalid
*/
static int
-find_session (struct Plugin *plugin,
- struct Session *session)
+find_session (struct Plugin *plugin, struct Session *session)
{
struct FindSessionContext session_map_res;
struct FindSessionContext nat_map_res;
session_map_res.s = session;
session_map_res.res = GNUNET_SYSERR;
- GNUNET_CONTAINER_multipeermap_iterate (plugin->sessionmap,
- &session_it, &session_map_res);
+ GNUNET_CONTAINER_multipeermap_iterate (plugin->sessionmap, &session_it,
+ &session_map_res);
if (GNUNET_SYSERR != session_map_res.res)
return GNUNET_OK;
nat_map_res.s = session;
nat_map_res.res = GNUNET_SYSERR;
- GNUNET_CONTAINER_multipeermap_iterate (plugin->nat_wait_conns,
- &session_it, &nat_map_res);
+ GNUNET_CONTAINER_multipeermap_iterate (plugin->nat_wait_conns, &session_it,
+ &nat_map_res);
if (GNUNET_SYSERR != nat_map_res.res)
return GNUNET_OK;
- GNUNET_break (0);
+ GNUNET_break(0);
return GNUNET_SYSERR;
}
#endif
-
/**
* Function that can be used by the transport service to transmit
* a message using the plugin. Note that in the case of a
@@ -1247,12 +1177,9 @@
* and does NOT mean that the message was not transmitted (DV)
*/
static ssize_t
-tcp_plugin_send (void *cls,
- struct Session *session,
- const char *msgbuf, size_t msgbuf_size,
- unsigned int priority,
- struct GNUNET_TIME_Relative to,
- GNUNET_TRANSPORT_TransmitContinuation cont, void *cont_cls)
+tcp_plugin_send (void *cls, struct Session *session, 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;
struct PendingMessage *pm;
@@ -1260,9 +1187,8 @@
#if EXTRA_CHECKS
if (GNUNET_SYSERR == find_session (plugin, session))
{
- LOG (GNUNET_ERROR_TYPE_ERROR,
- _("Trying to send with invalid session %p\n"));
- GNUNET_assert (0);
+ LOG(GNUNET_ERROR_TYPE_ERROR, _("Trying to send with invalid session
%p\n"));
+ GNUNET_assert(0);
return GNUNET_SYSERR;
}
#endif
@@ -1275,63 +1201,55 @@
pm->transmit_cont = cont;
pm->transmit_cont_cls = cont_cls;
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Asked to transmit %u bytes to `%s', added message to list.\n",
- msgbuf_size, GNUNET_i2s (&session->target));
+ LOG(GNUNET_ERROR_TYPE_DEBUG,
+ "Asked to transmit %u bytes to `%s', added message to list.\n",
+ msgbuf_size, GNUNET_i2s (&session->target));
- if (GNUNET_YES ==
- GNUNET_CONTAINER_multipeermap_contains_value (plugin->sessionmap,
- &session->target,
- session))
+ if (GNUNET_YES
+ == GNUNET_CONTAINER_multipeermap_contains_value (plugin->sessionmap,
+ &session->target, session))
{
- GNUNET_assert (NULL != session->client);
+ GNUNET_assert(NULL != session->client);
GNUNET_SERVER_client_set_timeout (session->client,
-
GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
+ GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
GNUNET_STATISTICS_update (plugin->env->stats,
- gettext_noop ("# bytes currently in TCP
buffers"),
- msgbuf_size, GNUNET_NO);
+ gettext_noop ("# bytes currently in TCP buffers"), msgbuf_size,
+ GNUNET_NO);
/* append pm to pending_messages list */
- GNUNET_CONTAINER_DLL_insert_tail (session->pending_messages_head,
- session->pending_messages_tail, pm);
+ GNUNET_CONTAINER_DLL_insert_tail(session->pending_messages_head,
+ session->pending_messages_tail, pm);
process_pending_messages (session);
return msgbuf_size;
}
- else if (GNUNET_YES ==
- GNUNET_CONTAINER_multipeermap_contains_value(plugin->nat_wait_conns,
- &session->target,
- session))
+ else if (GNUNET_YES
+ == GNUNET_CONTAINER_multipeermap_contains_value (plugin->nat_wait_conns,
+ &session->target, session))
{
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "This NAT WAIT session for peer `%s' is not yet ready!\n",
- GNUNET_i2s (&session->target));
+ LOG(GNUNET_ERROR_TYPE_DEBUG,
+ "This NAT WAIT session for peer `%s' is not yet ready!\n",
+ GNUNET_i2s (&session->target));
GNUNET_STATISTICS_update (plugin->env->stats,
- gettext_noop ("# bytes currently in TCP
buffers"),
- msgbuf_size, GNUNET_NO);
+ gettext_noop ("# bytes currently in TCP buffers"), msgbuf_size,
+ GNUNET_NO);
/* append pm to pending_messages list */
- GNUNET_CONTAINER_DLL_insert_tail (session->pending_messages_head,
- session->pending_messages_tail, pm);
+ GNUNET_CONTAINER_DLL_insert_tail(session->pending_messages_head,
+ session->pending_messages_tail, pm);
return msgbuf_size;
}
else
{
- LOG (GNUNET_ERROR_TYPE_ERROR,
- "Invalid session %p\n", session);
+ LOG(GNUNET_ERROR_TYPE_ERROR, "Invalid session %p\n", session);
if (NULL != cont)
- cont (cont_cls,
- &session->target,
- GNUNET_SYSERR,
- pm->message_size,
- 0);
- GNUNET_break (0);
- GNUNET_free (pm);
+ cont (cont_cls, &session->target, GNUNET_SYSERR, pm->message_size, 0);
+ GNUNET_break(0);
+ GNUNET_free(pm);
return GNUNET_SYSERR; /* session does not exist here */
}
}
-
/**
* Closure for #session_lookup_it().
*/
@@ -1340,20 +1258,15 @@
/**
* Address we are looking for.
*/
- void *addr;
+ const struct GNUNET_HELLO_Address *address;
/**
- * Number of bytes in @e addr.
- */
- size_t addrlen;
-
- /**
* Where to store the session (if we found it).
*/
struct Session *result;
+
};
-
/**
* Look for a session by address.
*
@@ -1363,23 +1276,19 @@
* @return #GNUNET_YES to continue looking, #GNUNET_NO if we found the session
*/
static int
-session_lookup_it (void *cls,
- const struct GNUNET_PeerIdentity *key,
- void *value)
+session_lookup_it (void *cls, const struct GNUNET_PeerIdentity *key,
+ void *value)
{
struct SessionItCtx * si_ctx = cls;
struct Session * session = value;
- if (session->addrlen != si_ctx->addrlen)
+ if (0 != GNUNET_HELLO_address_cmp (si_ctx->address, session->address))
return GNUNET_YES;
- if (0 != memcmp (session->addr, si_ctx->addr, si_ctx->addrlen))
- return GNUNET_YES;
/* Found existing session */
si_ctx->result = session;
return GNUNET_NO;
}
-
/**
* Task cleaning up a NAT connection attempt after timeout
*
@@ -1387,26 +1296,21 @@
* @param tc scheduler context (unused)
*/
static void
-nat_connect_timeout (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+nat_connect_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct Session *session = cls;
session->nat_connection_timeout = GNUNET_SCHEDULER_NO_TASK;
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "NAT WAIT connection to `%4s' at `%s' could not be established,
removing session\n",
- GNUNET_i2s (&session->target),
- tcp_address_to_string (NULL,
- session->addr, session->addrlen));
- tcp_disconnect_session (session->plugin,
- session);
+ LOG(GNUNET_ERROR_TYPE_DEBUG,
+ "NAT WAIT connection to `%4s' at `%s' could not be established, removing
session\n",
+ GNUNET_i2s (&session->target),
+ tcp_address_to_string (NULL, session->address->address,
session->address->address_length));
+ tcp_disconnect_session (session->plugin, session);
}
-
static void
tcp_plugin_update_session_timeout (void *cls,
- const struct GNUNET_PeerIdentity *peer,
- struct Session *session)
+ const struct GNUNET_PeerIdentity *peer, struct Session *session)
{
struct Plugin *plugin = cls;
@@ -1415,7 +1319,6 @@
reschedule_session_timeout (session);
}
-
/**
* Create a new session to transmit data to the target
* This session will used to send data to this peer and the plugin will
@@ -1426,8 +1329,7 @@
* @return the session if the address is valid, NULL otherwise
*/
static struct Session *
-tcp_plugin_get_session (void *cls,
- const struct GNUNET_HELLO_Address *address)
+tcp_plugin_get_session (void *cls, const struct GNUNET_HELLO_Address *address)
{
struct Plugin *plugin = cls;
struct Session *session = NULL;
@@ -1444,48 +1346,44 @@
size_t addrlen;
addrlen = address->address_length;
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Trying to get session for `%s' address of peer `%s'\n",
- tcp_address_to_string(NULL, address->address, address->address_length),
- GNUNET_i2s (&address->peer));
+ LOG(GNUNET_ERROR_TYPE_DEBUG,
+ "Trying to get session for `%s' address of peer `%s'\n",
+ tcp_address_to_string(NULL, address->address, address->address_length),
+ GNUNET_i2s (&address->peer));
/* look for existing session */
- if (GNUNET_YES ==
- GNUNET_CONTAINER_multipeermap_contains (plugin->sessionmap,
- &address->peer))
+ if (GNUNET_YES == GNUNET_CONTAINER_multipeermap_contains (plugin->sessionmap,
+ &address->peer))
{
struct SessionItCtx si_ctx;
- si_ctx.addr = (void *) address->address;
- si_ctx.addrlen = address->address_length;
-
+ si_ctx.address = address;
si_ctx.result = NULL;
GNUNET_CONTAINER_multipeermap_get_multiple (plugin->sessionmap,
- &address->peer,
- &session_lookup_it, &si_ctx);
- if (si_ctx.result != NULL)
+ &address->peer, &session_lookup_it, &si_ctx);
+ if (si_ctx.result != NULL )
{
session = si_ctx.result;
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Found existing session for `%s' address `%s' session %p\n",
- GNUNET_i2s (&address->peer),
- tcp_address_to_string(NULL, address->address,
address->address_length),
- session);
+ LOG(GNUNET_ERROR_TYPE_DEBUG,
+ "Found existing session for `%s' address `%s' session %p\n",
+ GNUNET_i2s (&address->peer),
+ tcp_address_to_string(NULL, address->address,
address->address_length),
+ session);
return session;
}
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Existing sessions did not match address `%s' or peer `%s'\n",
- tcp_address_to_string(NULL, address->address, address->address_length),
- GNUNET_i2s (&address->peer));
+ LOG(GNUNET_ERROR_TYPE_DEBUG,
+ "Existing sessions did not match address `%s' or peer `%s'\n",
+ tcp_address_to_string(NULL, address->address, address->address_length),
+ GNUNET_i2s (&address->peer));
}
- if (addrlen == sizeof (struct IPv6TcpAddress))
+ if (addrlen == sizeof(struct IPv6TcpAddress))
{
- GNUNET_assert (NULL != address->address); /* make static analysis
happy */
+ GNUNET_assert(NULL != address->address); /* make static analysis happy */
t6 = address->address;
af = AF_INET6;
- memset (&a6, 0, sizeof (a6));
+ memset (&a6, 0, sizeof(a6));
#if HAVE_SOCKADDR_IN_SIN_LEN
a6.sin6_len = sizeof (a6);
#endif
@@ -1493,16 +1391,16 @@
a6.sin6_port = t6->t6_port;
if (t6->t6_port == 0)
is_natd = GNUNET_YES;
- memcpy (&a6.sin6_addr, &t6->ipv6_addr, sizeof (struct in6_addr));
+ memcpy (&a6.sin6_addr, &t6->ipv6_addr, sizeof(struct in6_addr));
sb = &a6;
- sbs = sizeof (a6);
+ sbs = sizeof(a6);
}
- else if (addrlen == sizeof (struct IPv4TcpAddress))
+ else if (addrlen == sizeof(struct IPv4TcpAddress))
{
- GNUNET_assert (NULL != address->address); /* make static analysis
happy */
+ GNUNET_assert(NULL != address->address); /* make static analysis happy */
t4 = address->address;
af = AF_INET;
- memset (&a4, 0, sizeof (a4));
+ memset (&a4, 0, sizeof(a4));
#if HAVE_SOCKADDR_IN_SIN_LEN
a4.sin_len = sizeof (a4);
#endif
@@ -1512,144 +1410,123 @@
is_natd = GNUNET_YES;
a4.sin_addr.s_addr = t4->ipv4_addr;
sb = &a4;
- sbs = sizeof (a4);
+ sbs = sizeof(a4);
}
else
{
- GNUNET_STATISTICS_update (plugin->env->stats,
- gettext_noop
- ("# requests to create session with invalid
address"),
- 1, GNUNET_NO);
- return NULL;
+ GNUNET_STATISTICS_update (plugin->env->stats, gettext_noop
+ ("# requests to create session with invalid address"), 1, GNUNET_NO);
+ return NULL ;
}
ats = plugin->env->get_address_type (plugin->env->cls, sb, sbs);
- if ((is_natd == GNUNET_YES) && (addrlen == sizeof (struct IPv6TcpAddress)))
+ if ((is_natd == GNUNET_YES) && (addrlen == sizeof(struct IPv6TcpAddress)))
{
/* NAT client only works with IPv4 addresses */
- return NULL;
+ return NULL ;
}
if (plugin->cur_connections >= plugin->max_connections)
{
/* saturated */
- return NULL;
+ return NULL ;
}
- if ((is_natd == GNUNET_YES) &&
- (GNUNET_YES ==
- GNUNET_CONTAINER_multipeermap_contains (plugin->nat_wait_conns,
- &address->peer)))
+ if ((is_natd == GNUNET_YES)
+ && (GNUNET_YES
+ == GNUNET_CONTAINER_multipeermap_contains (plugin->nat_wait_conns,
+ &address->peer)))
{
/* Only do one NAT punch attempt per peer identity */
- return NULL;
+ return NULL ;
}
if ((is_natd == GNUNET_YES) && (NULL != plugin->nat) &&
- (GNUNET_NO ==
- GNUNET_CONTAINER_multipeermap_contains (plugin->nat_wait_conns,
- &address->peer)))
+ (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains
(plugin->nat_wait_conns,
+ &address->peer)))
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Found valid IPv4 NAT address (creating session)!\n") ;
- session = create_session (plugin,
- &address->peer,
- NULL,
- GNUNET_YES);
- session->addrlen = 0;
- session->addr = NULL;
- session->ats_address_network_type = (enum GNUNET_ATS_Network_Type) ntohl
(ats.value);
- GNUNET_break (session->ats_address_network_type !=
GNUNET_ATS_NET_UNSPECIFIED);
+ "Found valid IPv4 NAT address (creating session)!\n");
+ session = create_session (plugin, &address->peer, NULL, GNUNET_YES);
+ session->address = GNUNET_HELLO_address_copy (address);
+ session->ats_address_network_type = (enum GNUNET_ATS_Network_Type) ntohl (
+ ats.value);
+ GNUNET_break(
+ session->ats_address_network_type != GNUNET_ATS_NET_UNSPECIFIED);
session->nat_connection_timeout = GNUNET_SCHEDULER_add_delayed
(NAT_TIMEOUT,
-
&nat_connect_timeout,
- session);
- GNUNET_assert (session != NULL);
- GNUNET_assert (GNUNET_OK ==
- GNUNET_CONTAINER_multipeermap_put (plugin->nat_wait_conns,
- &session->target,
- session,
-
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+ &nat_connect_timeout, session);
+ GNUNET_assert(session != NULL);
+ GNUNET_assert(
+ GNUNET_OK == GNUNET_CONTAINER_multipeermap_put
(plugin->nat_wait_conns, &session->target, session,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Created NAT WAIT connection to `%4s' at `%s'\n",
- GNUNET_i2s (&session->target), GNUNET_a2s (sb, sbs));
+ LOG(GNUNET_ERROR_TYPE_DEBUG,
+ "Created NAT WAIT connection to `%4s' at `%s'\n",
+ GNUNET_i2s (&session->target), GNUNET_a2s (sb, sbs));
if (GNUNET_OK == GNUNET_NAT_run_client (plugin->nat, &a4))
return session;
else
{
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Running NAT client for `%4s' at `%s' failed\n",
- GNUNET_i2s (&session->target), GNUNET_a2s (sb, sbs));
+ LOG(GNUNET_ERROR_TYPE_DEBUG,
+ "Running NAT client for `%4s' at `%s' failed\n",
+ GNUNET_i2s (&session->target), GNUNET_a2s (sb, sbs));
tcp_disconnect_session (plugin, session);
- return NULL;
+ return NULL ;
}
}
/* create new outbound session */
- GNUNET_assert (plugin->cur_connections <= plugin->max_connections);
+ GNUNET_assert(plugin->cur_connections <= plugin->max_connections);
sa = GNUNET_CONNECTION_create_from_sockaddr (af, sb, sbs);
if (NULL == sa)
{
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Failed to create connection to `%4s' at `%s'\n",
- GNUNET_i2s (&address->peer), GNUNET_a2s (sb, sbs));
- return NULL;
+ LOG(GNUNET_ERROR_TYPE_DEBUG,
+ "Failed to create connection to `%4s' at `%s'\n",
+ GNUNET_i2s (&address->peer), GNUNET_a2s (sb, sbs));
+ return NULL ;
}
plugin->cur_connections++;
if (plugin->cur_connections == plugin->max_connections)
GNUNET_SERVER_suspend (plugin->server); /* Maximum number of connections
rechead */
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Asked to transmit to `%4s', creating fresh session using address
`%s'.\n",
- GNUNET_i2s (&address->peer),
- GNUNET_a2s (sb, sbs));
+ LOG(GNUNET_ERROR_TYPE_DEBUG,
+ "Asked to transmit to `%4s', creating fresh session using address
`%s'.\n",
+ GNUNET_i2s (&address->peer), GNUNET_a2s (sb, sbs));
- session = create_session (plugin,
- &address->peer,
- GNUNET_SERVER_connect_socket (plugin->server, sa),
- GNUNET_NO);
- session->addr = GNUNET_malloc (addrlen);
- memcpy (session->addr, address->address, addrlen);
- session->addrlen = addrlen;
- session->ats_address_network_type = (enum GNUNET_ATS_Network_Type) ntohl
(ats.value);
- GNUNET_break (session->ats_address_network_type !=
GNUNET_ATS_NET_UNSPECIFIED);
- GNUNET_SERVER_client_set_user_context (session->client, session);
- GNUNET_CONTAINER_multipeermap_put (plugin->sessionmap,
- &session->target,
- session,
-
GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Creating new session for `%s' address `%s' session %p\n",
- GNUNET_i2s (&address->peer),
- tcp_address_to_string(NULL, address->address, address->address_length),
- session);
+ session = create_session (plugin, &address->peer,
+ GNUNET_SERVER_connect_socket (plugin->server, sa), GNUNET_NO);
+ session->address = GNUNET_HELLO_address_copy (address);
+ session->ats_address_network_type = (enum GNUNET_ATS_Network_Type) ntohl (
+ ats.value);
+ GNUNET_break(session->ats_address_network_type !=
GNUNET_ATS_NET_UNSPECIFIED);
+ GNUNET_SERVER_client_set_user_context(session->client, session);
+ GNUNET_CONTAINER_multipeermap_put (plugin->sessionmap, &session->target,
+ session, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+ LOG(GNUNET_ERROR_TYPE_DEBUG,
+ "Creating new session for `%s' address `%s' session %p\n",
+ GNUNET_i2s (&address->peer),
+ tcp_address_to_string(NULL, address->address, address->address_length),
+ session);
/* Send TCP Welcome */
process_pending_messages (session);
return session;
}
-
static int
-session_disconnect_it (void *cls,
- const struct GNUNET_PeerIdentity *key,
- void *value)
+session_disconnect_it (void *cls, const struct GNUNET_PeerIdentity *key,
+ void *value)
{
struct Plugin *plugin = cls;
struct Session *session = value;
- GNUNET_STATISTICS_update (session->plugin->env->stats,
- gettext_noop
- ("# transport-service disconnect requests for
TCP"),
- 1, GNUNET_NO);
- tcp_disconnect_session (plugin,
- session);
+ GNUNET_STATISTICS_update (session->plugin->env->stats, gettext_noop
+ ("# transport-service disconnect requests for TCP"), 1, GNUNET_NO);
+ tcp_disconnect_session (plugin, session);
return GNUNET_YES;
}
-
/**
* Function that can be called to force a disconnect from the
* specified neighbour. This should also cancel all previously
@@ -1667,21 +1544,18 @@
* to be cancelled
*/
static void
-tcp_plugin_disconnect (void *cls,
- const struct GNUNET_PeerIdentity *target)
+tcp_plugin_disconnect (void *cls, const struct GNUNET_PeerIdentity *target)
{
struct Plugin *plugin = cls;
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Disconnecting peer `%4s'\n",
- GNUNET_i2s (target));
+ LOG(GNUNET_ERROR_TYPE_DEBUG, "Disconnecting peer `%4s'\n",
+ GNUNET_i2s (target));
GNUNET_CONTAINER_multipeermap_get_multiple (plugin->sessionmap, target,
- &session_disconnect_it, plugin);
+ &session_disconnect_it, plugin);
GNUNET_CONTAINER_multipeermap_get_multiple (plugin->nat_wait_conns, target,
- &session_disconnect_it, plugin);
+ &session_disconnect_it, plugin);
}
-
/**
* Running pretty printers: head
*/
@@ -1743,10 +1617,8 @@
uint32_t options;
};
-
static void
-ppc_cancel_task (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+ppc_cancel_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct PrettyPrinterContext *ppc = cls;
@@ -1756,11 +1628,10 @@
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);
+ GNUNET_CONTAINER_DLL_remove(ppc_dll_head, ppc_dll_tail, ppc);
+ GNUNET_free(ppc);
}
-
/**
* Append our port and forward the result.
*
@@ -1776,12 +1647,12 @@
if (NULL == hostname)
{
- ppc->asc (ppc->asc_cls, NULL);
- GNUNET_CONTAINER_DLL_remove (ppc_dll_head, ppc_dll_tail, ppc);
+ 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;
ppc->resolver_handle = NULL;
- GNUNET_free (ppc);
+ GNUNET_free(ppc);
return;
}
for (cur = ppc_dll_head; (NULL != cur); cur = cur->next)
@@ -1789,29 +1660,20 @@
break;
if (NULL == cur)
{
- GNUNET_break (0);
+ GNUNET_break(0);
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);
+ GNUNET_asprintf (&ret, "%s.%u.%s:%d", PLUGIN_NAME, ppc->options, hostname,
+ ppc->port);
ppc->asc (ppc->asc_cls, ret);
- GNUNET_free (ret);
+ GNUNET_free(ret);
}
-
/**
* Convert the transports address to a nice, human-readable
* format.
@@ -1828,11 +1690,9 @@
*/
static void
tcp_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)
+ 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;
@@ -1844,45 +1704,45 @@
uint16_t port;
uint32_t options;
- if (addrlen == sizeof (struct IPv6TcpAddress))
+ if (addrlen == sizeof(struct IPv6TcpAddress))
{
t6 = addr;
- memset (&a6, 0, sizeof (a6));
+ memset (&a6, 0, sizeof(a6));
a6.sin6_family = AF_INET6;
a6.sin6_port = t6->t6_port;
- memcpy (&a6.sin6_addr, &t6->ipv6_addr, sizeof (struct in6_addr));
+ memcpy (&a6.sin6_addr, &t6->ipv6_addr, sizeof(struct in6_addr));
port = ntohs (t6->t6_port);
options = ntohl (t6->options);
sb = &a6;
- sbs = sizeof (a6);
+ sbs = sizeof(a6);
}
- else if (addrlen == sizeof (struct IPv4TcpAddress))
+ else if (addrlen == sizeof(struct IPv4TcpAddress))
{
t4 = addr;
- memset (&a4, 0, sizeof (a4));
+ memset (&a4, 0, sizeof(a4));
a4.sin_family = AF_INET;
a4.sin_port = t4->t4_port;
a4.sin_addr.s_addr = t4->ipv4_addr;
port = ntohs (t4->t4_port);
options = ntohl (t4->options);
sb = &a4;
- sbs = sizeof (a4);
+ sbs = sizeof(a4);
}
else if (0 == addrlen)
{
asc (asc_cls, TRANSPORT_SESSION_INBOUND_STRING);
- asc (asc_cls, NULL);
+ asc (asc_cls, NULL );
return;
}
else
{
/* invalid address */
- GNUNET_break_op (0);
- asc (asc_cls, NULL);
+ GNUNET_break_op(0);
+ asc (asc_cls, NULL );
return;
}
ppc = GNUNET_new (struct PrettyPrinterContext);
- if (addrlen == sizeof (struct IPv6TcpAddress))
+ if (addrlen == sizeof(struct IPv6TcpAddress))
ppc->ipv6 = GNUNET_YES;
else
ppc->ipv6 = GNUNET_NO;
@@ -1890,24 +1750,22 @@
ppc->asc_cls = asc_cls;
ppc->port = port;
ppc->options = options;
- ppc->timeout_task = GNUNET_SCHEDULER_add_delayed
(GNUNET_TIME_relative_multiply(timeout, 2),
- &ppc_cancel_task, ppc);
+ ppc->timeout_task = GNUNET_SCHEDULER_add_delayed (
+ GNUNET_TIME_relative_multiply (timeout, 2), &ppc_cancel_task, ppc);
ppc->resolver_handle = GNUNET_RESOLVER_hostname_get (sb, sbs, !numeric,
- timeout,
- &append_port, ppc);
+ timeout, &append_port, ppc);
if (NULL != ppc->resolver_handle)
{
//GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Adding request %p\n", ppc);
- GNUNET_CONTAINER_DLL_insert (ppc_dll_head, ppc_dll_tail, ppc);
+ GNUNET_CONTAINER_DLL_insert(ppc_dll_head, ppc_dll_tail, ppc);
}
else
{
- GNUNET_break (0);
- GNUNET_free (ppc);
+ GNUNET_break(0);
+ GNUNET_free(ppc);
}
}
-
/**
* Check if the given port is plausible (must be either our listen
* port or our advertised port), or any port if we are behind NAT
@@ -1926,7 +1784,6 @@
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
@@ -1949,26 +1806,26 @@
struct IPv4TcpAddress *v4;
struct IPv6TcpAddress *v6;
- if ((addrlen != sizeof (struct IPv4TcpAddress)) &&
- (addrlen != sizeof (struct IPv6TcpAddress)))
+ if ((addrlen != sizeof(struct IPv4TcpAddress))
+ && (addrlen != sizeof(struct IPv6TcpAddress)))
{
- GNUNET_break_op (0);
+ GNUNET_break_op(0);
return GNUNET_SYSERR;
}
- if (addrlen == sizeof (struct IPv4TcpAddress))
+ if (addrlen == sizeof(struct IPv4TcpAddress))
{
v4 = (struct IPv4TcpAddress *) addr;
- if (0 != memcmp (&v4->options, &myoptions, sizeof (myoptions)))
+ if (0 != memcmp (&v4->options, &myoptions, sizeof(myoptions)))
{
- GNUNET_break (0);
+ GNUNET_break(0);
return GNUNET_SYSERR;
}
if (GNUNET_OK != check_port (plugin, ntohs (v4->t4_port)))
return GNUNET_SYSERR;
- if (GNUNET_OK !=
- GNUNET_NAT_test_address (plugin->nat, &v4->ipv4_addr,
- sizeof (struct in_addr)))
+ if (GNUNET_OK
+ != GNUNET_NAT_test_address (plugin->nat, &v4->ipv4_addr,
+ sizeof(struct in_addr)))
return GNUNET_SYSERR;
}
else
@@ -1976,25 +1833,24 @@
v6 = (struct IPv6TcpAddress *) addr;
if (IN6_IS_ADDR_LINKLOCAL (&v6->ipv6_addr))
{
- GNUNET_break_op (0);
+ GNUNET_break_op(0);
return GNUNET_SYSERR;
}
- if (0 != memcmp (&v6->options, &myoptions, sizeof (myoptions)))
+ if (0 != memcmp (&v6->options, &myoptions, sizeof(myoptions)))
{
- GNUNET_break (0);
- return GNUNET_SYSERR;
+ GNUNET_break(0);
+ return GNUNET_SYSERR;
}
if (GNUNET_OK != check_port (plugin, ntohs (v6->t6_port)))
return GNUNET_SYSERR;
- if (GNUNET_OK !=
- GNUNET_NAT_test_address (plugin->nat, &v6->ipv6_addr,
- sizeof (struct in6_addr)))
+ if (GNUNET_OK
+ != GNUNET_NAT_test_address (plugin->nat, &v6->ipv6_addr,
+ sizeof(struct in6_addr)))
return GNUNET_SYSERR;
}
return GNUNET_OK;
}
-
/**
* We've received a nat probe from this peer via TCP. Finish
* creating the client session and resume sending of queued
@@ -2005,9 +1861,8 @@
* @param message the actual message
*/
static void
-handle_tcp_nat_probe (void *cls,
- struct GNUNET_SERVER_Client *client,
- const struct GNUNET_MessageHeader *message)
+handle_tcp_nat_probe (void *cls, struct GNUNET_SERVER_Client *client,
+ const struct GNUNET_MessageHeader *message)
{
struct Plugin *plugin = cls;
struct Session *session;
@@ -2019,45 +1874,40 @@
const struct sockaddr_in *s4;
const struct sockaddr_in6 *s6;
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Received NAT probe\n");
+ LOG(GNUNET_ERROR_TYPE_DEBUG, "Received NAT probe\n");
/* We have received a TCP NAT probe, meaning we (hopefully) initiated
* a connection to this peer by running gnunet-nat-client. This peer
* received the punch message and now wants us to use the new connection
* as the default for that peer. Do so and then send a WELCOME message
* so we can really be connected!
*/
- if (ntohs (message->size) != sizeof (struct TCP_NAT_ProbeMessage))
+ if (ntohs (message->size) != sizeof(struct TCP_NAT_ProbeMessage))
{
- GNUNET_break_op (0);
+ GNUNET_break_op(0);
GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
return;
}
tcp_nat_probe = (const struct TCP_NAT_ProbeMessage *) message;
- if (0 ==
- memcmp (&tcp_nat_probe->clientIdentity, plugin->env->my_identity,
- sizeof (struct GNUNET_PeerIdentity)))
+ if (0 == memcmp (&tcp_nat_probe->clientIdentity, plugin->env->my_identity,
+ sizeof(struct GNUNET_PeerIdentity)))
{
/* refuse connections from ourselves */
GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
return;
}
- session =
- GNUNET_CONTAINER_multipeermap_get (plugin->nat_wait_conns,
- &tcp_nat_probe->clientIdentity);
- if (session == NULL)
+ session = GNUNET_CONTAINER_multipeermap_get (plugin->nat_wait_conns,
+ &tcp_nat_probe->clientIdentity);
+ if (session == NULL )
{
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Did NOT find session for NAT probe!\n");
+ LOG(GNUNET_ERROR_TYPE_DEBUG, "Did NOT find session for NAT probe!\n");
GNUNET_SERVER_receive_done (client, GNUNET_OK);
return;
}
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Found session for NAT probe!\n");
+ LOG(GNUNET_ERROR_TYPE_DEBUG, "Found session for NAT probe!\n");
- if (session->nat_connection_timeout != GNUNET_SCHEDULER_NO_TASK)
+ if (session->nat_connection_timeout != GNUNET_SCHEDULER_NO_TASK )
{
GNUNET_SCHEDULER_cancel (session->nat_connection_timeout);
session->nat_connection_timeout = GNUNET_SCHEDULER_NO_TASK;
@@ -2065,24 +1915,19 @@
if (GNUNET_OK != GNUNET_SERVER_client_get_address (client, &vaddr, &alen))
{
- GNUNET_break (0);
+ GNUNET_break(0);
GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
tcp_disconnect_session (plugin, session);
return;
}
- GNUNET_assert (GNUNET_CONTAINER_multipeermap_remove
- (plugin->nat_wait_conns,
- &tcp_nat_probe->clientIdentity,
- session) == GNUNET_YES);
- GNUNET_SERVER_client_set_user_context (client, session);
- GNUNET_CONTAINER_multipeermap_put (plugin->sessionmap,
- &session->target, session,
-
GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+ GNUNET_assert(
+ GNUNET_CONTAINER_multipeermap_remove (plugin->nat_wait_conns,
&tcp_nat_probe->clientIdentity, session) == GNUNET_YES);
+ GNUNET_SERVER_client_set_user_context(client, session);
+ GNUNET_CONTAINER_multipeermap_put (plugin->sessionmap, &session->target,
+ session, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
session->last_activity = GNUNET_TIME_absolute_get ();
- session->inbound = GNUNET_NO;
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Found address `%s' for incoming connection\n",
- GNUNET_a2s (vaddr, alen));
+ LOG(GNUNET_ERROR_TYPE_DEBUG, "Found address `%s' for incoming connection\n",
+ GNUNET_a2s (vaddr, alen));
switch (((const struct sockaddr *) vaddr)->sa_family)
{
case AF_INET:
@@ -2091,39 +1936,38 @@
t4->options = 0;
t4->t4_port = s4->sin_port;
t4->ipv4_addr = s4->sin_addr.s_addr;
- session->addr = t4;
- session->addrlen = sizeof (struct IPv4TcpAddress);
+ session->address = GNUNET_HELLO_address_allocate (
+ &tcp_nat_probe->clientIdentity, PLUGIN_NAME, &t4,
+ sizeof(struct IPv4TcpAddress), GNUNET_HELLO_ADDRESS_INFO_NONE);
break;
case AF_INET6:
s6 = vaddr;
t6 = GNUNET_new (struct IPv6TcpAddress);
t6->options = 0;
t6->t6_port = s6->sin6_port;
- memcpy (&t6->ipv6_addr, &s6->sin6_addr, sizeof (struct in6_addr));
- session->addr = t6;
- session->addrlen = sizeof (struct IPv6TcpAddress);
+ memcpy (&t6->ipv6_addr, &s6->sin6_addr, sizeof(struct in6_addr));
+ session->address = GNUNET_HELLO_address_allocate (
+ &tcp_nat_probe->clientIdentity, PLUGIN_NAME, &t6,
+ sizeof(struct IPv6TcpAddress), GNUNET_HELLO_ADDRESS_INFO_NONE);
break;
default:
- GNUNET_break_op (0);
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Bad address for incoming connection!\n");
- GNUNET_free (vaddr);
+ GNUNET_break_op(0);
+ LOG(GNUNET_ERROR_TYPE_DEBUG, "Bad address for incoming connection!\n");
+ GNUNET_free(vaddr);
GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
tcp_disconnect_session (plugin, session);
return;
}
- GNUNET_free (vaddr);
- GNUNET_break (NULL == session->client);
+ GNUNET_free(vaddr);
+ GNUNET_break(NULL == session->client);
GNUNET_SERVER_client_keep (client);
session->client = client;
GNUNET_STATISTICS_update (plugin->env->stats,
- gettext_noop ("# TCP sessions active"), 1,
- GNUNET_NO);
+ gettext_noop ("# TCP sessions active"), 1, GNUNET_NO);
process_pending_messages (session);
GNUNET_SERVER_receive_done (client, GNUNET_OK);
}
-
/**
* We've received a welcome from this peer via TCP. Possibly create a
* fresh client record and send back our welcome.
@@ -2134,135 +1978,120 @@
*/
static void
handle_tcp_welcome (void *cls, struct GNUNET_SERVER_Client *client,
- const struct GNUNET_MessageHeader *message)
+ const struct GNUNET_MessageHeader *message)
{
struct Plugin *plugin = cls;
const struct WelcomeMessage *wm = (const struct WelcomeMessage *) message;
struct Session *session;
size_t alen;
void *vaddr;
- struct IPv4TcpAddress *t4;
- struct IPv6TcpAddress *t6;
+ struct IPv4TcpAddress t4;
+ struct IPv6TcpAddress t6;
const struct sockaddr_in *s4;
const struct sockaddr_in6 *s6;
struct GNUNET_ATS_Information ats;
- if (0 ==
- memcmp (&wm->clientIdentity, plugin->env->my_identity,
- sizeof (struct GNUNET_PeerIdentity)))
+ if (0 == memcmp (&wm->clientIdentity, plugin->env->my_identity,
+ sizeof(struct GNUNET_PeerIdentity)))
{
/* refuse connections from ourselves */
GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
if (GNUNET_OK == GNUNET_SERVER_client_get_address (client, &vaddr, &alen))
{
- LOG (GNUNET_ERROR_TYPE_WARNING,
- "Received %s message from my own identity `%4s' on address `%s'\n",
- "WELCOME", GNUNET_i2s (&wm->clientIdentity), GNUNET_a2s (vaddr,
alen));
- GNUNET_free (vaddr);
+ LOG(GNUNET_ERROR_TYPE_WARNING,
+ "Received %s message from my own identity `%4s' on address `%s'\n",
+ "WELCOME", GNUNET_i2s (&wm->clientIdentity),
+ GNUNET_a2s (vaddr, alen));
+ GNUNET_free(vaddr);
}
- GNUNET_break_op (0);
+ GNUNET_break_op(0);
return;
}
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Received %s message from `%4s' %p\n", "WELCOME",
- GNUNET_i2s (&wm->clientIdentity), client);
+ LOG(GNUNET_ERROR_TYPE_DEBUG, "Received %s message from `%4s' %p\n",
"WELCOME",
+ GNUNET_i2s (&wm->clientIdentity), client);
GNUNET_STATISTICS_update (plugin->env->stats,
- gettext_noop ("# TCP WELCOME messages received"),
1,
- GNUNET_NO);
+ gettext_noop ("# TCP WELCOME messages received"), 1, GNUNET_NO);
session = lookup_session_by_client (plugin, client);
if (NULL != session)
{
- if (GNUNET_OK ==
- GNUNET_SERVER_client_get_address (client, &vaddr, &alen))
+ if (GNUNET_OK == GNUNET_SERVER_client_get_address (client, &vaddr, &alen))
{
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Found existing session %p for peer `%s'\n",
- session,
- GNUNET_a2s (vaddr, alen));
- GNUNET_free (vaddr);
+ LOG(GNUNET_ERROR_TYPE_DEBUG, "Found existing session %p for peer `%s'\n",
+ session, GNUNET_a2s (vaddr, alen));
+ GNUNET_free(vaddr);
}
}
else
{
GNUNET_SERVER_client_keep (client);
if (NULL != plugin->service) /* Otherwise value is incremented in
tcp_access_check */
- plugin->cur_connections++;
+ plugin->cur_connections++;
if (plugin->cur_connections == plugin->max_connections)
- GNUNET_SERVER_suspend (plugin->server); /* Maximum number of
connections rechead */
+ GNUNET_SERVER_suspend (plugin->server); /* Maximum number of connections
rechead */
session = create_session (plugin, &wm->clientIdentity, client, GNUNET_NO);
- session->inbound = GNUNET_YES;
if (GNUNET_OK == GNUNET_SERVER_client_get_address (client, &vaddr, &alen))
{
- if (alen == sizeof (struct sockaddr_in))
+ if (alen == sizeof(struct sockaddr_in))
{
s4 = vaddr;
- t4 = GNUNET_new (struct IPv4TcpAddress);
- t4->options = htonl (0);
- t4->t4_port = s4->sin_port;
- t4->ipv4_addr = s4->sin_addr.s_addr;
- session->addr = t4;
- session->addrlen = sizeof (struct IPv4TcpAddress);
+ memset (&t4, '\0', sizeof (t4));
+ t4.options = htonl (0);
+ t4.t4_port = s4->sin_port;
+ t4.ipv4_addr = s4->sin_addr.s_addr;
+ session->address = GNUNET_HELLO_address_allocate (&wm->clientIdentity,
+ PLUGIN_NAME, &t4, sizeof(struct IPv4TcpAddress),
+ GNUNET_HELLO_ADDRESS_INFO_INBOUND);
}
- else if (alen == sizeof (struct sockaddr_in6))
+ else if (alen == sizeof(struct sockaddr_in6))
{
s6 = vaddr;
- t6 = GNUNET_new (struct IPv6TcpAddress);
- t6->options = htonl (0);
- t6->t6_port = s6->sin6_port;
- memcpy (&t6->ipv6_addr, &s6->sin6_addr, sizeof (struct in6_addr));
- session->addr = t6;
- session->addrlen = sizeof (struct IPv6TcpAddress);
+ memset (&t6, '\0', sizeof (t6));
+ t6.options = htonl (0);
+ t6.t6_port = s6->sin6_port;
+ memcpy (&t6.ipv6_addr, &s6->sin6_addr, sizeof(struct in6_addr));
+ session->address = GNUNET_HELLO_address_allocate (&wm->clientIdentity,
+ PLUGIN_NAME, &t6, sizeof(struct IPv6TcpAddress),
+ GNUNET_HELLO_ADDRESS_INFO_INBOUND);
}
- ats = plugin->env->get_address_type (plugin->env->cls, vaddr ,alen);
- session->ats_address_network_type = (enum GNUNET_ATS_Network_Type) ntohl
(ats.value);
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Creating new session %p for peer `%s'\n",
- session,
- GNUNET_a2s (vaddr, alen));
- GNUNET_free (vaddr);
- GNUNET_SERVER_client_set_user_context (session->client, session);
- GNUNET_CONTAINER_multipeermap_put (plugin->sessionmap,
- &session->target,
- session,
-
GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+ ats = plugin->env->get_address_type (plugin->env->cls, vaddr, alen);
+ session->ats_address_network_type = (enum GNUNET_ATS_Network_Type) ntohl
(
+ ats.value);
+ LOG(GNUNET_ERROR_TYPE_DEBUG, "Creating new session %p for peer `%s'\n",
+ session, GNUNET_a2s (vaddr, alen));
+ GNUNET_free(vaddr);
+ GNUNET_SERVER_client_set_user_context(session->client, session);
+ GNUNET_CONTAINER_multipeermap_put (plugin->sessionmap, &session->target,
+ session, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
}
else
{
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Did not obtain TCP socket address for incoming connection\n");
- GNUNET_break (0);
+ LOG(GNUNET_ERROR_TYPE_DEBUG,
+ "Did not obtain TCP socket address for incoming connection\n");
+ GNUNET_break(0);
}
}
if (session->expecting_welcome != GNUNET_YES)
{
- GNUNET_break_op (0);
+ GNUNET_break_op(0);
GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
- GNUNET_break (0);
+ GNUNET_break(0);
return;
}
session->last_activity = GNUNET_TIME_absolute_get ();
session->expecting_welcome = GNUNET_NO;
/* Notify transport and ATS about new session */
- if (GNUNET_YES == session->inbound)
- {
- plugin->env->session_start (NULL,
- &wm->clientIdentity,
- PLUGIN_NAME,
- (GNUNET_YES == session->inbound) ? NULL :
session->addr,
- (GNUNET_YES == session->inbound) ? 0 :
session->addrlen,
- session, &ats, 1);
- }
+ plugin->env->session_start (NULL, session->address, session, &ats, 1);
+
process_pending_messages (session);
GNUNET_SERVER_client_set_timeout (client,
- GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
+ GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
GNUNET_SERVER_receive_done (client, GNUNET_OK);
}
-
/**
* Task to signal the server that we can continue
* receiving from the TCP client now.
@@ -2271,8 +2100,7 @@
* @param tc task context (unused)
*/
static void
-delayed_done (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+delayed_done (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct Session *session = cls;
@@ -2282,7 +2110,6 @@
GNUNET_SERVER_receive_done (session->client, GNUNET_OK);
}
-
/**
* We've received data for this peer via TCP. Unbox,
* compute latency and forward.
@@ -2293,7 +2120,7 @@
*/
static void
handle_tcp_data (void *cls, struct GNUNET_SERVER_Client *client,
- const struct GNUNET_MessageHeader *message)
+ const struct GNUNET_MessageHeader *message)
{
struct Plugin *plugin = cls;
struct Session *session;
@@ -2301,8 +2128,8 @@
uint16_t type;
type = ntohs (message->type);
- if ((GNUNET_MESSAGE_TYPE_TRANSPORT_TCP_WELCOME == type) ||
- (GNUNET_MESSAGE_TYPE_TRANSPORT_TCP_NAT_PROBE == type))
+ if ((GNUNET_MESSAGE_TYPE_TRANSPORT_TCP_WELCOME == type)
+ || (GNUNET_MESSAGE_TYPE_TRANSPORT_TCP_NAT_PROBE == type))
{
/* We don't want to propagate WELCOME and NAT Probe messages up! */
GNUNET_SERVER_receive_done (client, GNUNET_OK);
@@ -2316,12 +2143,11 @@
size_t alen;
GNUNET_SERVER_client_get_address (client, &vaddr, &alen);
- LOG (GNUNET_ERROR_TYPE_ERROR,
- "Received unexpected %u bytes of type %u from `%s'\n",
- (unsigned int) ntohs (message->size),
- (unsigned int) ntohs (message->type),
- GNUNET_a2s(vaddr, alen));
- GNUNET_break_op (0);
+ LOG(GNUNET_ERROR_TYPE_ERROR,
+ "Received unexpected %u bytes of type %u from `%s'\n",
+ (unsigned int ) ntohs (message->size),
+ (unsigned int ) ntohs (message->type), GNUNET_a2s (vaddr, alen));
+ GNUNET_break_op(0);
GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
GNUNET_free_non_null(vaddr);
return;
@@ -2333,48 +2159,38 @@
size_t alen;
GNUNET_SERVER_client_get_address (client, &vaddr, &alen);
- LOG (GNUNET_ERROR_TYPE_ERROR,
- "Received unexpected %u bytes of type %u from `%s'\n",
- (unsigned int) ntohs (message->size),
- (unsigned int) ntohs (message->type),
- GNUNET_a2s(vaddr, alen));
- GNUNET_break_op (0);
+ LOG(GNUNET_ERROR_TYPE_ERROR,
+ "Received unexpected %u bytes of type %u from `%s'\n",
+ (unsigned int ) ntohs (message->size),
+ (unsigned int ) ntohs (message->type), GNUNET_a2s (vaddr, alen));
+ GNUNET_break_op(0);
GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
GNUNET_free_non_null(vaddr);
return;
}
session->last_activity = GNUNET_TIME_absolute_get ();
- 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->type),
- GNUNET_i2s (&session->target));
+ 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->type), GNUNET_i2s (&session->target));
GNUNET_STATISTICS_update (plugin->env->stats,
- gettext_noop ("# bytes received via TCP"),
- ntohs (message->size), GNUNET_NO);
+ gettext_noop ("# bytes received via TCP"), ntohs (message->size),
+ GNUNET_NO);
struct GNUNET_ATS_Information distance;
distance.type = htonl (GNUNET_ATS_NETWORK_TYPE);
distance.value = htonl ((uint32_t) session->ats_address_network_type);
- GNUNET_break (session->ats_address_network_type !=
GNUNET_ATS_NET_UNSPECIFIED);
+ GNUNET_break(session->ats_address_network_type !=
GNUNET_ATS_NET_UNSPECIFIED);
- GNUNET_assert (GNUNET_CONTAINER_multipeermap_contains_value
(plugin->sessionmap,
- &session->target,
- session));
+ GNUNET_assert(
+ GNUNET_CONTAINER_multipeermap_contains_value (plugin->sessionmap,
+ &session->target, session));
- delay = plugin->env->receive (plugin->env->cls,
- &session->target,
- message,
- session,
- (GNUNET_YES == session->inbound) ? NULL :
session->addr,
- (GNUNET_YES == session->inbound) ? 0 :
session->addrlen);
- plugin->env->update_address_metrics (plugin->env->cls,
- &session->target,
- (GNUNET_YES == session->inbound) ? NULL
: session->addr,
- (GNUNET_YES == session->inbound) ? 0 :
session->addrlen,
- session, &distance, 1);
+ delay = plugin->env->receive (plugin->env->cls, session->address, session,
message);
+ plugin->env->update_address_metrics (plugin->env->cls, session->address,
+ session, &distance, 1);
reschedule_session_timeout (session);
if (0 == delay.rel_value_us)
{
@@ -2382,17 +2198,15 @@
}
else
{
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Throttling receiving from `%s' for %s\n",
- GNUNET_i2s (&session->target),
- GNUNET_STRINGS_relative_time_to_string (delay, GNUNET_YES));
+ LOG(GNUNET_ERROR_TYPE_DEBUG, "Throttling receiving from `%s' for %s\n",
+ GNUNET_i2s (&session->target),
+ GNUNET_STRINGS_relative_time_to_string (delay, GNUNET_YES));
GNUNET_SERVER_disable_receive_done_warning (client);
- session->receive_delay_task =
- GNUNET_SCHEDULER_add_delayed (delay, &delayed_done, session);
+ session->receive_delay_task = GNUNET_SCHEDULER_add_delayed (delay,
+ &delayed_done, session);
}
}
-
/**
* Functions with this signature are called whenever a peer
* is disconnected on the network level.
@@ -2406,36 +2220,30 @@
struct Plugin *plugin = cls;
struct Session *session;
- if (client == NULL)
+ if (client == NULL )
return;
session = lookup_session_by_client (plugin, client);
- if (session == NULL)
- return; /* unknown, nothing to do */
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Destroying session of `%4s' with %s due to network-level
disconnect.\n",
- GNUNET_i2s (&session->target),
- (session->addr !=
- NULL) ? tcp_address_to_string (session->plugin,
- session->addr,
- session->addrlen) :
- "*");
+ if (session == NULL )
+ return; /* unknown, nothing to do */
+ LOG(GNUNET_ERROR_TYPE_DEBUG,
+ "Destroying session of `%4s' with %s due to network-level disconnect.\n",
+ GNUNET_i2s (&session->target),
+ tcp_address_to_string (session->plugin, session->address->address,
+ session->address->address_length));
if (plugin->cur_connections == plugin->max_connections)
GNUNET_SERVER_resume (plugin->server); /* Resume server */
if (plugin->cur_connections < 1)
- GNUNET_break (0);
+ GNUNET_break(0);
else
plugin->cur_connections--;
- GNUNET_STATISTICS_update (session->plugin->env->stats,
- gettext_noop
- ("# network-level TCP disconnect events"), 1,
- GNUNET_NO);
+ GNUNET_STATISTICS_update (session->plugin->env->stats, gettext_noop
+ ("# network-level TCP disconnect events"), 1, GNUNET_NO);
tcp_disconnect_session (plugin, session);
}
-
/**
* We can now send a probe message, copy into buffer to really send.
*
@@ -2452,24 +2260,23 @@
size_t ret;
tcp_probe_ctx->transmit_handle = NULL;
- GNUNET_CONTAINER_DLL_remove (plugin->probe_head, plugin->probe_tail,
- tcp_probe_ctx);
- if (buf == NULL)
+ GNUNET_CONTAINER_DLL_remove(plugin->probe_head, plugin->probe_tail,
+ tcp_probe_ctx);
+ if (buf == NULL )
{
GNUNET_CONNECTION_destroy (tcp_probe_ctx->sock);
- GNUNET_free (tcp_probe_ctx);
+ GNUNET_free(tcp_probe_ctx);
return 0;
}
- GNUNET_assert (size >= sizeof (tcp_probe_ctx->message));
- memcpy (buf, &tcp_probe_ctx->message, sizeof (tcp_probe_ctx->message));
+ GNUNET_assert(size >= sizeof(tcp_probe_ctx->message));
+ memcpy (buf, &tcp_probe_ctx->message, sizeof(tcp_probe_ctx->message));
GNUNET_SERVER_connect_socket (tcp_probe_ctx->plugin->server,
- tcp_probe_ctx->sock);
- ret = sizeof (tcp_probe_ctx->message);
- GNUNET_free (tcp_probe_ctx);
+ tcp_probe_ctx->sock);
+ ret = sizeof(tcp_probe_ctx->message);
+ GNUNET_free(tcp_probe_ctx);
return ret;
}
-
/**
* Function called by the NAT subsystem suggesting another peer wants
* to connect to us via connection reversal. Try to connect back to the
@@ -2481,7 +2288,7 @@
*/
static void
try_connection_reversal (void *cls, const struct sockaddr *addr,
- socklen_t addrlen)
+ socklen_t addrlen)
{
struct Plugin *plugin = cls;
struct GNUNET_CONNECTION_Handle *sock;
@@ -2492,7 +2299,7 @@
* that wants to connect to us! Send a message to establish a connection.
*/
sock = GNUNET_CONNECTION_create_from_sockaddr (AF_INET, addr, addrlen);
- if (sock == NULL)
+ if (sock == NULL )
{
/* failed for some odd reason (out of sockets?); ignore attempt */
return;
@@ -2501,27 +2308,22 @@
/* FIXME: do we need to track these probe context objects so that
* we can clean them up on plugin unload? */
tcp_probe_ctx = GNUNET_new (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);
+ 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));
+ sizeof(struct GNUNET_PeerIdentity));
tcp_probe_ctx->plugin = plugin;
tcp_probe_ctx->sock = sock;
- GNUNET_CONTAINER_DLL_insert (plugin->probe_head, plugin->probe_tail,
- tcp_probe_ctx);
- tcp_probe_ctx->transmit_handle =
- GNUNET_CONNECTION_notify_transmit_ready (sock,
- ntohs (tcp_probe_ctx->
- message.header.size),
- GNUNET_TIME_UNIT_FOREVER_REL,
- ¬ify_send_probe,
- tcp_probe_ctx);
+ GNUNET_CONTAINER_DLL_insert(plugin->probe_head, plugin->probe_tail,
+ tcp_probe_ctx);
+ tcp_probe_ctx->transmit_handle = GNUNET_CONNECTION_notify_transmit_ready (
+ sock, ntohs (tcp_probe_ctx->message.header.size),
+ GNUNET_TIME_UNIT_FOREVER_REL, ¬ify_send_probe, tcp_probe_ctx);
}
-
/**
* Function obtain the network type for a session
*
@@ -2530,14 +2332,12 @@
* @return the network type in HBO or #GNUNET_SYSERR
*/
static enum GNUNET_ATS_Network_Type
-tcp_get_network (void *cls,
- struct Session *session)
+tcp_get_network (void *cls, struct Session *session)
{
- GNUNET_assert (NULL != session);
+ GNUNET_assert(NULL != session);
return session->ats_address_network_type;
}
-
/**
* Entry point for the plugin.
*
@@ -2547,14 +2347,12 @@
void *
libgnunet_plugin_transport_tcp_init (void *cls)
{
- static const struct GNUNET_SERVER_MessageHandler my_handlers[] = {
- {&handle_tcp_welcome, NULL, GNUNET_MESSAGE_TYPE_TRANSPORT_TCP_WELCOME,
- sizeof (struct WelcomeMessage)},
- {&handle_tcp_nat_probe, NULL, GNUNET_MESSAGE_TYPE_TRANSPORT_TCP_NAT_PROBE,
- sizeof (struct TCP_NAT_ProbeMessage)},
- {&handle_tcp_data, NULL, GNUNET_MESSAGE_TYPE_ALL, 0},
- {NULL, NULL, 0, 0}
- };
+ static const struct GNUNET_SERVER_MessageHandler my_handlers[] = { {
+ &handle_tcp_welcome, NULL, GNUNET_MESSAGE_TYPE_TRANSPORT_TCP_WELCOME,
+ sizeof(struct WelcomeMessage) }, { &handle_tcp_nat_probe, NULL,
+ GNUNET_MESSAGE_TYPE_TRANSPORT_TCP_NAT_PROBE,
+ sizeof(struct TCP_NAT_ProbeMessage) }, { &handle_tcp_data, NULL,
+ GNUNET_MESSAGE_TYPE_ALL, 0 }, { NULL, NULL, 0, 0 } };
struct GNUNET_TRANSPORT_PluginEnvironment *env = cls;
struct GNUNET_TRANSPORT_PluginFunctions *api;
struct Plugin *plugin;
@@ -2569,11 +2367,10 @@
struct sockaddr **addrs;
socklen_t *addrlens;
-
if (NULL == env->receive)
{
/* run in 'stub' mode (i.e. as part of gnunet-peerinfo), don't fully
- initialze the plugin or the API */
+ initialze the plugin or the API */
api = GNUNET_new (struct GNUNET_TRANSPORT_PluginFunctions);
api->cls = NULL;
api->address_pretty_printer = &tcp_plugin_address_pretty_printer;
@@ -2582,26 +2379,24 @@
return api;
}
- GNUNET_assert (NULL != env->cfg);
- if (GNUNET_OK !=
- GNUNET_CONFIGURATION_get_value_number (env->cfg, "transport-tcp",
- "MAX_CONNECTIONS",
- &max_connections))
+ GNUNET_assert(NULL != env->cfg);
+ if (GNUNET_OK
+ != GNUNET_CONFIGURATION_get_value_number (env->cfg, "transport-tcp",
+ "MAX_CONNECTIONS", &max_connections))
max_connections = 128;
aport = 0;
- if ((GNUNET_OK !=
- GNUNET_CONFIGURATION_get_value_number (env->cfg, "transport-tcp",
"PORT",
- &bport)) || (bport > 65535) ||
- ((GNUNET_OK ==
- GNUNET_CONFIGURATION_get_value_number (env->cfg, "transport-tcp",
- "ADVERTISED-PORT", &aport)) &&
- (aport > 65535)))
+ if ((GNUNET_OK
+ != GNUNET_CONFIGURATION_get_value_number (env->cfg, "transport-tcp",
+ "PORT", &bport)) || (bport > 65535)
+ || ((GNUNET_OK
+ == GNUNET_CONFIGURATION_get_value_number (env->cfg, "transport-tcp",
+ "ADVERTISED-PORT", &aport)) && (aport > 65535)))
{
- LOG (GNUNET_ERROR_TYPE_ERROR,
- _("Require valid port number for service `%s' in configuration!\n"),
- "transport-tcp");
- return NULL;
+ LOG(GNUNET_ERROR_TYPE_ERROR,
+ _("Require valid port number for service `%s' in configuration!\n"),
+ "transport-tcp");
+ return NULL ;
}
if (aport == 0)
aport = bport;
@@ -2609,12 +2404,12 @@
aport = 0;
if (bport != 0)
{
- service = GNUNET_SERVICE_start ("transport-tcp", env->cfg,
GNUNET_SERVICE_OPTION_NONE);
- if (service == NULL)
+ service = GNUNET_SERVICE_start ("transport-tcp", env->cfg,
+ GNUNET_SERVICE_OPTION_NONE);
+ if (service == NULL )
{
- LOG (GNUNET_ERROR_TYPE_WARNING,
- _("Failed to start service.\n"));
- return NULL;
+ LOG(GNUNET_ERROR_TYPE_WARNING, _("Failed to start service.\n"));
+ return NULL ;
}
}
else
@@ -2624,42 +2419,42 @@
myoptions = 0;
plugin = GNUNET_new (struct Plugin);
- plugin->sessionmap = GNUNET_CONTAINER_multipeermap_create (max_connections,
GNUNET_YES);
+ plugin->sessionmap = GNUNET_CONTAINER_multipeermap_create (max_connections,
+ GNUNET_YES);
plugin->max_connections = max_connections;
plugin->cur_connections = 0;
plugin->open_port = bport;
plugin->adv_port = aport;
plugin->env = env;
plugin->lsock = NULL;
- if ((service != NULL) &&
- (GNUNET_SYSERR !=
- (ret_s =
- GNUNET_SERVICE_get_server_addresses ("transport-tcp", env->cfg, &addrs,
- &addrlens))))
+ if ((service != NULL )&&
+ (GNUNET_SYSERR !=
+ (ret_s =
+ GNUNET_SERVICE_get_server_addresses ("transport-tcp", env->cfg,
&addrs,
+ &addrlens)))){
+ for (ret = ret_s-1; ret >= 0; ret--)
+ LOG (GNUNET_ERROR_TYPE_INFO,
+ "Binding to address `%s'\n",
+ GNUNET_a2s (addrs[ret], addrlens[ret]));
+ plugin->nat =
+ GNUNET_NAT_register (env->cfg, GNUNET_YES, aport, (unsigned int) ret_s,
+ (const struct sockaddr **) addrs, addrlens,
+ &tcp_nat_port_map_callback,
+ &try_connection_reversal, plugin);
+ for (ret = ret_s -1; ret >= 0; ret--)
{
- for (ret = ret_s-1; ret >= 0; ret--)
- LOG (GNUNET_ERROR_TYPE_INFO,
- "Binding to address `%s'\n",
- GNUNET_a2s (addrs[ret], addrlens[ret]));
- plugin->nat =
- GNUNET_NAT_register (env->cfg, GNUNET_YES, aport, (unsigned int) ret_s,
- (const struct sockaddr **) addrs, addrlens,
- &tcp_nat_port_map_callback,
- &try_connection_reversal, plugin);
- for (ret = ret_s -1; ret >= 0; ret--)
- {
- GNUNET_assert (addrs[ret] != NULL);
- GNUNET_free (addrs[ret]);
- }
- GNUNET_free_non_null (addrs);
- GNUNET_free_non_null (addrlens);
+ GNUNET_assert (addrs[ret] != NULL);
+ GNUNET_free (addrs[ret]);
}
- else
- {
- plugin->nat = GNUNET_NAT_register (plugin->env->cfg,
- GNUNET_YES, 0, 0, NULL, NULL, NULL,
- &try_connection_reversal, plugin);
- }
+ GNUNET_free_non_null (addrs);
+ GNUNET_free_non_null (addrlens);
+}
+else
+{
+ plugin->nat = GNUNET_NAT_register (plugin->env->cfg,
+ GNUNET_YES, 0, 0, NULL, NULL, NULL,
+ &try_connection_reversal, plugin);
+}
api = GNUNET_new (struct GNUNET_TRANSPORT_PluginFunctions);
api->cls = plugin;
api->send = &tcp_plugin_send;
@@ -2681,51 +2476,48 @@
}
else
{
- if (GNUNET_OK !=
- GNUNET_CONFIGURATION_get_value_time (env->cfg, "transport-tcp",
- "TIMEOUT", &idle_timeout))
+ if (GNUNET_OK
+ != GNUNET_CONFIGURATION_get_value_time (env->cfg, "transport-tcp",
+ "TIMEOUT", &idle_timeout))
{
- GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
- "transport-tcp", "TIMEOUT");
- if (plugin->nat != NULL)
+ GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "transport-tcp",
+ "TIMEOUT");
+ if (plugin->nat != NULL )
GNUNET_NAT_unregister (plugin->nat);
- GNUNET_free (plugin);
- GNUNET_free (api);
- return NULL;
+ GNUNET_free(plugin);
+ GNUNET_free(api);
+ return NULL ;
}
- plugin->server =
- GNUNET_SERVER_create_with_sockets (&plugin_tcp_access_check, plugin,
- NULL, idle_timeout, GNUNET_YES);
+ plugin->server = GNUNET_SERVER_create_with_sockets (
+ &plugin_tcp_access_check, plugin, NULL, idle_timeout, GNUNET_YES);
}
plugin->handlers = GNUNET_malloc (sizeof (my_handlers));
- memcpy (plugin->handlers, my_handlers, sizeof (my_handlers));
+ memcpy (plugin->handlers, my_handlers, sizeof(my_handlers));
for (i = 0;
- i < sizeof (my_handlers) / sizeof (struct GNUNET_SERVER_MessageHandler);
- i++)
+ i < sizeof(my_handlers) / sizeof(struct GNUNET_SERVER_MessageHandler);
+ i++)
plugin->handlers[i].callback_cls = plugin;
GNUNET_SERVER_add_handlers (plugin->server, plugin->handlers);
GNUNET_SERVER_disconnect_notify (plugin->server, &disconnect_notify, plugin);
- plugin->nat_wait_conns = GNUNET_CONTAINER_multipeermap_create (16,
GNUNET_YES);
+ plugin->nat_wait_conns = GNUNET_CONTAINER_multipeermap_create (16,
+ GNUNET_YES);
if (bport != 0)
- LOG (GNUNET_ERROR_TYPE_INFO,
- _("TCP transport listening on port %llu\n"), bport);
+ LOG(GNUNET_ERROR_TYPE_INFO, _("TCP transport listening on port %llu\n"),
+ bport);
else
- LOG (GNUNET_ERROR_TYPE_INFO,
- _("TCP transport not listening on any port (client only)\n"));
+ LOG(GNUNET_ERROR_TYPE_INFO,
+ _("TCP transport not listening on any port (client only)\n"));
if (aport != bport)
- LOG (GNUNET_ERROR_TYPE_INFO,
- _("TCP transport advertises itself as being on port %llu\n"),
- aport);
+ LOG(GNUNET_ERROR_TYPE_INFO,
+ _("TCP transport advertises itself as being on port %llu\n"), aport);
/* Initially set connections to 0 */
- GNUNET_assert (NULL != plugin->env->stats);
+ GNUNET_assert(NULL != plugin->env->stats);
GNUNET_STATISTICS_set (plugin->env->stats,
- gettext_noop ("# TCP sessions active"), 0,
- GNUNET_NO);
+ gettext_noop ("# TCP sessions active"), 0, GNUNET_NO);
return api;
}
-
/**
* Exit point from the plugin.
*
@@ -2743,50 +2535,49 @@
if (NULL == plugin)
{
- GNUNET_free (api);
- return NULL;
+ GNUNET_free(api);
+ return NULL ;
}
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Shutting down TCP plugin\n");
+ LOG(GNUNET_ERROR_TYPE_DEBUG, "Shutting down TCP plugin\n");
/* Removing leftover sessions */
GNUNET_CONTAINER_multipeermap_iterate (plugin->sessionmap,
- &session_disconnect_it, plugin);
+ &session_disconnect_it, plugin);
/* Removing leftover NAT sessions */
GNUNET_CONTAINER_multipeermap_iterate (plugin->nat_wait_conns,
- &session_disconnect_it, plugin);
+ &session_disconnect_it, plugin);
next = ppc_dll_head;
for (cur = next; NULL != cur; cur = next)
{
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);
if (NULL != cur->resolver_handle)
GNUNET_RESOLVER_request_cancel (cur->resolver_handle);
GNUNET_SCHEDULER_cancel (cur->timeout_task);
- GNUNET_free (cur);
- GNUNET_break (0);
+ GNUNET_free(cur);
+ GNUNET_break(0);
}
- if (plugin->service != NULL)
+ if (plugin->service != NULL )
GNUNET_SERVICE_stop (plugin->service);
else
GNUNET_SERVER_destroy (plugin->server);
- GNUNET_free (plugin->handlers);
- if (plugin->nat != NULL)
+ GNUNET_free(plugin->handlers);
+ if (plugin->nat != NULL )
GNUNET_NAT_unregister (plugin->nat);
while (NULL != (tcp_probe = plugin->probe_head))
{
- GNUNET_CONTAINER_DLL_remove (plugin->probe_head, plugin->probe_tail,
- tcp_probe);
+ GNUNET_CONTAINER_DLL_remove(plugin->probe_head, plugin->probe_tail,
+ tcp_probe);
GNUNET_CONNECTION_destroy (tcp_probe->sock);
- GNUNET_free (tcp_probe);
+ GNUNET_free(tcp_probe);
}
GNUNET_CONTAINER_multipeermap_destroy (plugin->nat_wait_conns);
GNUNET_CONTAINER_multipeermap_destroy (plugin->sessionmap);
- GNUNET_free (plugin);
- GNUNET_free (api);
- return NULL;
+ GNUNET_free(plugin);
+ GNUNET_free(api);
+ return NULL ;
}
/* end of plugin_transport_tcp.c */
Modified: gnunet/src/transport/plugin_transport_udp.c
===================================================================
--- gnunet/src/transport/plugin_transport_udp.c 2014-01-13 16:56:41 UTC (rev
31885)
+++ gnunet/src/transport/plugin_transport_udp.c 2014-01-13 16:59:57 UTC (rev
31886)
@@ -1,22 +1,22 @@
/*
- This file is part of GNUnet
- (C) 2010-2013 Christian Grothoff (and other contributing authors)
+ This file is part of GNUnet
+ (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
- by the Free Software Foundation; either version 3, or (at your
- option) any later version.
+ GNUnet is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published
+ by the Free Software Foundation; either version 3, or (at your
+ option) any later version.
- GNUnet is distributed in the hope that it will be useful, but
- WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- General Public License for more details.
+ GNUnet is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
- 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.
-*/
+ 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.
+ */
/**
* @file transport/plugin_transport_udp.c
@@ -44,8 +44,6 @@
#define UDP_SESSION_TIME_OUT GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_SECONDS, 60)
-#define PLUGIN_NAME "udp"
-
/**
* Number of messages we can defragment in parallel. We only really
* defragment 1 message at a time, but if messages get re-ordered, we
@@ -127,7 +125,6 @@
uint32_t options;
};
-
enum UDP_MessageType
{
UNDEFINED = 0,
@@ -138,7 +135,6 @@
MSG_BEACON = 5
};
-
struct Session
{
/**
@@ -157,11 +153,6 @@
struct UDP_FragmentationContext *frag_ctx;
/**
- * Address of the other peer
- */
- const struct sockaddr *sock_addr;
-
- /**
* Desired delay for next sending we send to other peer
*/
struct GNUNET_TIME_Relative flow_delay_for_other_peer;
@@ -188,10 +179,7 @@
struct GNUNET_ATS_Information ats;
- /**
- * Number of bytes in @e sock_addr.
- */
- size_t addrlen;
+ struct GNUNET_HELLO_Address *address;
/**
* Reference counter to indicate that this session is
@@ -208,22 +196,17 @@
* @e rc is non-zero).
*/
int in_destroy;
-
- int inbound;
};
-
/**
* Closure for #session_cmp_it().
*/
struct SessionCompareContext
{
struct Session *res;
- const struct GNUNET_HELLO_Address *addr;
- int inbound;
+ const struct GNUNET_HELLO_Address *address;
};
-
/**
* Closure for #process_inbound_tokenized_messages().
*/
@@ -251,7 +234,6 @@
};
-
/**
* Closure for #find_receive_context().
*/
@@ -276,8 +258,6 @@
};
-
-
/**
* Data structure to track defragmentation contexts based
* on the source of the UDP traffic.
@@ -312,8 +292,6 @@
size_t addr_len;
};
-
-
/**
* Context to send fragmented messages
*/
@@ -373,7 +351,6 @@
};
-
struct UDP_MessageWrapper
{
/**
@@ -437,7 +414,6 @@
struct UDP_FragmentationContext *frag_ctx;
};
-
/**
* UDP ACK Message-Packet header (after defragmentation).
*/
@@ -465,13 +441,11 @@
*/
static uint32_t myoptions;
-
/**
* Encapsulation of all of the state of the plugin.
*/
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
@@ -483,7 +457,6 @@
static void
udp_plugin_select (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
-
/**
* 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
@@ -495,7 +468,6 @@
static void
udp_plugin_select_v6 (void *cls, const struct GNUNET_SCHEDULER_TaskContext
*tc);
-
/**
* (re)schedule select tasks for this plugin.
*
@@ -514,40 +486,41 @@
min_delay = GNUNET_TIME_UNIT_FOREVER_REL;
for (udpw = plugin->ipv4_queue_head; NULL != udpw; udpw = udpw->next)
min_delay = GNUNET_TIME_relative_min (min_delay,
- GNUNET_TIME_absolute_get_remaining
(udpw->session->flow_delay_from_other_peer));
+ GNUNET_TIME_absolute_get_remaining (
+ udpw->session->flow_delay_from_other_peer));
- if (plugin->select_task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel(plugin->select_task);
+ if (plugin->select_task != GNUNET_SCHEDULER_NO_TASK )
+ GNUNET_SCHEDULER_cancel (plugin->select_task);
/* Schedule with:
* - write active set if message is ready
* - timeout minimum delay */
- plugin->select_task =
- GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
- (0 == min_delay.rel_value_us) ?
GNUNET_TIME_UNIT_FOREVER_REL : min_delay,
- plugin->rs_v4,
- (0 == min_delay.rel_value_us) ?
plugin->ws_v4 : NULL,
- &udp_plugin_select, plugin);
+ plugin->select_task = GNUNET_SCHEDULER_add_select (
+ GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+ (0 == min_delay.rel_value_us) ?
+ GNUNET_TIME_UNIT_FOREVER_REL : min_delay, plugin->rs_v4,
+ (0 == min_delay.rel_value_us) ? plugin->ws_v4 : NULL,
+ &udp_plugin_select, plugin);
}
if ((GNUNET_YES == plugin->enable_ipv6) && (NULL != plugin->sockv6))
{
min_delay = GNUNET_TIME_UNIT_FOREVER_REL;
for (udpw = plugin->ipv6_queue_head; NULL != udpw; udpw = udpw->next)
min_delay = GNUNET_TIME_relative_min (min_delay,
- GNUNET_TIME_absolute_get_remaining
(udpw->session->flow_delay_from_other_peer));
+ GNUNET_TIME_absolute_get_remaining (
+ udpw->session->flow_delay_from_other_peer));
if (GNUNET_SCHEDULER_NO_TASK != plugin->select_task_v6)
- GNUNET_SCHEDULER_cancel(plugin->select_task_v6);
- plugin->select_task_v6 =
- GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
- (0 == min_delay.rel_value_us) ?
GNUNET_TIME_UNIT_FOREVER_REL : min_delay,
- plugin->rs_v6,
- (0 == min_delay.rel_value_us) ?
plugin->ws_v6 : NULL,
- &udp_plugin_select_v6, plugin);
+ GNUNET_SCHEDULER_cancel (plugin->select_task_v6);
+ plugin->select_task_v6 = GNUNET_SCHEDULER_add_select (
+ GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+ (0 == min_delay.rel_value_us) ?
+ GNUNET_TIME_UNIT_FOREVER_REL : min_delay, plugin->rs_v6,
+ (0 == min_delay.rel_value_us) ? plugin->ws_v6 : NULL,
+ &udp_plugin_select_v6, plugin);
}
}
-
/**
* Function called for a quick conversion of the binary address to
* a numeric address. Note that the caller must not free the
@@ -573,37 +546,36 @@
uint16_t port;
uint32_t options;
- if ((NULL != addr) && (addrlen == sizeof (struct IPv6UdpAddress)))
+ if ((NULL != addr) && (addrlen == sizeof(struct IPv6UdpAddress)))
{
t6 = addr;
af = AF_INET6;
options = ntohl (t6->options);
port = ntohs (t6->u6_port);
- memcpy (&a6, &t6->ipv6_addr, sizeof (a6));
+ memcpy (&a6, &t6->ipv6_addr, sizeof(a6));
sb = &a6;
}
- else if ((NULL != addr) && (addrlen == sizeof (struct IPv4UdpAddress)))
+ else if ((NULL != addr) && (addrlen == sizeof(struct IPv4UdpAddress)))
{
t4 = addr;
af = AF_INET;
options = ntohl (t4->options);
port = ntohs (t4->u4_port);
- memcpy (&a4, &t4->ipv4_addr, sizeof (a4));
+ memcpy (&a4, &t4->ipv4_addr, sizeof(a4));
sb = &a4;
}
else
{
- return NULL;
+ 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",
- PLUGIN_NAME, options, buf, port);
+ GNUNET_snprintf (rbuf, sizeof(rbuf),
+ (af == AF_INET6) ? "%s.%u.[%s]:%u" : "%s.%u.%s:%u", PLUGIN_NAME, options,
+ buf, port);
return rbuf;
}
-
/**
* Function called to convert a string address to
* a binary address.
@@ -633,87 +605,85 @@
if ((NULL == addr) || (addrlen == 0))
{
- GNUNET_break (0);
+ GNUNET_break(0);
return GNUNET_SYSERR;
}
if ('\0' != addr[addrlen - 1])
{
- GNUNET_break (0);
+ GNUNET_break(0);
return GNUNET_SYSERR;
}
if (strlen (addr) != addrlen - 1)
{
- GNUNET_break (0);
+ GNUNET_break(0);
return GNUNET_SYSERR;
}
plugin = GNUNET_strdup (addr);
optionstr = strchr (plugin, '.');
if (NULL == optionstr)
{
- GNUNET_break (0);
- GNUNET_free (plugin);
+ GNUNET_break(0);
+ GNUNET_free(plugin);
return GNUNET_SYSERR;
}
optionstr[0] = '\0';
- optionstr ++;
+ optionstr++;
options = atol (optionstr);
address = strchr (optionstr, '.');
if (NULL == address)
{
- GNUNET_break (0);
- GNUNET_free (plugin);
+ GNUNET_break(0);
+ GNUNET_free(plugin);
return GNUNET_SYSERR;
}
address[0] = '\0';
- address ++;
+ 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);
+ GNUNET_break(0);
+ GNUNET_free(plugin);
return GNUNET_SYSERR;
}
- GNUNET_free (plugin);
+ GNUNET_free(plugin);
switch (socket_address.ss_family)
{
case AF_INET:
- {
- struct IPv4UdpAddress *u4;
- struct sockaddr_in *in4 = (struct sockaddr_in *) &socket_address;
- u4 = GNUNET_new (struct IPv4UdpAddress);
- u4->options = htonl (options);
- u4->ipv4_addr = in4->sin_addr.s_addr;
- u4->u4_port = in4->sin_port;
- *buf = u4;
- *added = sizeof (struct IPv4UdpAddress);
- return GNUNET_OK;
- }
+ {
+ struct IPv4UdpAddress *u4;
+ struct sockaddr_in *in4 = (struct sockaddr_in *) &socket_address;
+ u4 = GNUNET_new (struct IPv4UdpAddress);
+ u4->options = htonl (options);
+ u4->ipv4_addr = in4->sin_addr.s_addr;
+ u4->u4_port = in4->sin_port;
+ *buf = u4;
+ *added = sizeof(struct IPv4UdpAddress);
+ return GNUNET_OK;
+ }
case AF_INET6:
- {
- struct IPv6UdpAddress *u6;
- struct sockaddr_in6 *in6 = (struct sockaddr_in6 *) &socket_address;
- u6 = GNUNET_new (struct IPv6UdpAddress);
- u6->options = htonl (options);
- u6->ipv6_addr = in6->sin6_addr;
- u6->u6_port = in6->sin6_port;
- *buf = u6;
- *added = sizeof (struct IPv6UdpAddress);
- return GNUNET_OK;
- }
+ {
+ struct IPv6UdpAddress *u6;
+ struct sockaddr_in6 *in6 = (struct sockaddr_in6 *) &socket_address;
+ u6 = GNUNET_new (struct IPv6UdpAddress);
+ u6->options = htonl (options);
+ u6->ipv6_addr = in6->sin6_addr;
+ u6->u6_port = in6->sin6_port;
+ *buf = u6;
+ *added = sizeof(struct IPv6UdpAddress);
+ return GNUNET_OK;
+ }
default:
- GNUNET_break (0);
+ GNUNET_break(0);
return GNUNET_SYSERR;
}
}
-
static void
-ppc_cancel_task (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+ppc_cancel_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct PrettyPrinterContext *ppc = cls;
@@ -723,11 +693,10 @@
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);
+ GNUNET_CONTAINER_DLL_remove(ppc_dll_head, ppc_dll_tail, ppc);
+ GNUNET_free(ppc);
}
-
/**
* Append our port and forward the result.
*
@@ -741,14 +710,14 @@
struct PrettyPrinterContext *cur;
char *ret;
- if (hostname == NULL)
+ if (hostname == NULL )
{
- ppc->asc (ppc->asc_cls, NULL);
- GNUNET_CONTAINER_DLL_remove (ppc_dll_head, ppc_dll_tail, ppc);
+ 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;
ppc->resolver_handle = NULL;
- GNUNET_free (ppc);
+ GNUNET_free(ppc);
return;
}
for (cur = ppc_dll_head; (NULL != cur); cur = cur->next)
@@ -758,30 +727,20 @@
}
if (NULL == cur)
{
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Invalid callback for PPC %p \n", ppc);
+ GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Invalid callback for PPC %p \n", 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);
+ GNUNET_asprintf (&ret, "%s.%u.%s:%d", PLUGIN_NAME, ppc->options, hostname,
+ ppc->port);
ppc->asc (ppc->asc_cls, ret);
- GNUNET_free (ret);
+ GNUNET_free(ret);
}
-
/**
* Convert the transports address to a nice, human-readable
* format.
@@ -798,11 +757,9 @@
*/
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)
+ 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;
@@ -814,25 +771,25 @@
uint16_t port;
uint32_t options;
- if (addrlen == sizeof (struct IPv6UdpAddress))
+ if (addrlen == sizeof(struct IPv6UdpAddress))
{
u6 = addr;
- memset (&a6, 0, sizeof (a6));
+ 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));
+ memcpy (&a6.sin6_addr, &u6->ipv6_addr, sizeof(struct in6_addr));
port = ntohs (u6->u6_port);
options = ntohl (u6->options);
sb = &a6;
- sbs = sizeof (a6);
+ sbs = sizeof(a6);
}
- else if (addrlen == sizeof (struct IPv4UdpAddress))
+ else if (addrlen == sizeof(struct IPv4UdpAddress))
{
u4 = addr;
- memset (&a4, 0, sizeof (a4));
+ memset (&a4, 0, sizeof(a4));
a4.sin_family = AF_INET;
#if HAVE_SOCKADDR_IN_SIN_LEN
a4.sin_len = sizeof (a4);
@@ -842,13 +799,13 @@
port = ntohs (u4->u4_port);
options = ntohl (u4->options);
sb = &a4;
- sbs = sizeof (a4);
+ sbs = sizeof(a4);
}
else
{
/* invalid address */
- GNUNET_break_op (0);
- asc (asc_cls, NULL);
+ GNUNET_break_op(0);
+ asc (asc_cls, NULL );
return;
}
ppc = GNUNET_new (struct PrettyPrinterContext);
@@ -856,26 +813,23 @@
ppc->asc_cls = asc_cls;
ppc->port = port;
ppc->options = options;
- if (addrlen == sizeof (struct IPv6UdpAddress))
+ if (addrlen == sizeof(struct IPv6UdpAddress))
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);
+ 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);
}
-
static void
call_continuation (struct UDP_MessageWrapper *udpw, int result)
{
size_t overhead;
- LOG (GNUNET_ERROR_TYPE_DEBUG,
+ 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");
@@ -885,160 +839,148 @@
else
overhead = udpw->msg_size;
- switch (result) {
- case GNUNET_OK:
- switch (udpw->msg_type) {
- case MSG_UNFRAGMENTED:
- if (NULL != udpw->cont)
- {
- /* Transport continuation */
- udpw->cont (udpw->cont_cls, &udpw->session->target, result,
- udpw->payload_size, udpw->msg_size);
- }
- GNUNET_STATISTICS_update (plugin->env->stats,
- "# UDP, unfragmented msgs, messages, sent,
success",
- 1, GNUNET_NO);
- GNUNET_STATISTICS_update (plugin->env->stats,
- "# UDP, unfragmented msgs, bytes payload,
sent, success",
- udpw->payload_size, GNUNET_NO);
- GNUNET_STATISTICS_update (plugin->env->stats,
- "# UDP, unfragmented msgs, bytes overhead,
sent, success",
- overhead, GNUNET_NO);
- GNUNET_STATISTICS_update (plugin->env->stats,
- "# UDP, total, bytes overhead, sent",
- overhead, GNUNET_NO);
- GNUNET_STATISTICS_update (plugin->env->stats,
- "# UDP, total, bytes payload, sent",
- udpw->payload_size, GNUNET_NO);
- break;
- case 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_OK,
- udpw->frag_ctx->payload_size,
udpw->frag_ctx->on_wire_size);
- GNUNET_STATISTICS_update (plugin->env->stats,
- "# UDP, fragmented msgs, messages, sent,
success",
- 1, GNUNET_NO);
- GNUNET_STATISTICS_update (plugin->env->stats,
- "# UDP, fragmented msgs, bytes payload,
sent, success",
- udpw->payload_size, GNUNET_NO);
- GNUNET_STATISTICS_update (plugin->env->stats,
- "# UDP, fragmented msgs, bytes overhead,
sent, success",
- overhead, GNUNET_NO);
- GNUNET_STATISTICS_update (plugin->env->stats,
- "# UDP, total, bytes overhead, sent",
- overhead, GNUNET_NO);
- GNUNET_STATISTICS_update (plugin->env->stats,
- "# UDP, total, bytes payload, sent",
- udpw->payload_size, GNUNET_NO);
- GNUNET_STATISTICS_update (plugin->env->stats,
- "# UDP, fragmented msgs, messages,
pending",
- -1, GNUNET_NO);
- break;
- case MSG_FRAGMENTED:
- /* Fragmented message: enqueue next fragment */
- if (NULL != udpw->cont)
- udpw->cont (udpw->cont_cls, &udpw->session->target, result,
- udpw->payload_size, udpw->msg_size);
- GNUNET_STATISTICS_update (plugin->env->stats,
- "# UDP, fragmented msgs, fragments, sent,
success",
- 1, GNUNET_NO);
- GNUNET_STATISTICS_update (plugin->env->stats,
- "# UDP, fragmented msgs, fragments bytes,
sent, success",
- udpw->msg_size, GNUNET_NO);
- break;
- case 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, ACK msgs, bytes overhead, sent,
success",
- overhead, 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;
+ switch (result)
+ {
+ case GNUNET_OK:
+ switch (udpw->msg_type)
+ {
+ case MSG_UNFRAGMENTED:
+ if (NULL != udpw->cont)
+ {
+ /* Transport continuation */
+ udpw->cont (udpw->cont_cls, &udpw->session->target, result,
+ udpw->payload_size, udpw->msg_size);
}
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, unfragmented msgs, messages, sent, success", 1, GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, unfragmented msgs, bytes payload, sent, success",
+ udpw->payload_size, GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, unfragmented msgs, bytes overhead, sent, success", overhead,
+ GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, total, bytes overhead, sent", overhead, GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, total, bytes payload, sent", udpw->payload_size, GNUNET_NO);
break;
- case GNUNET_SYSERR:
- switch (udpw->msg_type) {
- case MSG_UNFRAGMENTED:
- /* Unfragmented message: failed to send */
- if (NULL != udpw->cont)
- udpw->cont (udpw->cont_cls, &udpw->session->target, result,
- udpw->payload_size, overhead);
- GNUNET_STATISTICS_update (plugin->env->stats,
- "# UDP, unfragmented msgs, messages, sent,
failure",
- 1, GNUNET_NO);
- GNUNET_STATISTICS_update (plugin->env->stats,
- "# UDP, unfragmented msgs, bytes payload,
sent, failure",
- udpw->payload_size, GNUNET_NO);
- GNUNET_STATISTICS_update (plugin->env->stats,
- "# UDP, unfragmented msgs, bytes overhead,
sent, failure",
- overhead, GNUNET_NO);
- break;
- case 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_SYSERR,
- udpw->frag_ctx->payload_size,
udpw->frag_ctx->on_wire_size);
- GNUNET_STATISTICS_update (plugin->env->stats,
- "# UDP, fragmented msgs, messages, sent,
failure",
- 1, GNUNET_NO);
- GNUNET_STATISTICS_update (plugin->env->stats,
- "# UDP, fragmented msgs, bytes payload,
sent, failure",
- udpw->payload_size, GNUNET_NO);
- GNUNET_STATISTICS_update (plugin->env->stats,
- "# UDP, fragmented msgs, bytes payload,
sent, failure",
- overhead, GNUNET_NO);
- GNUNET_STATISTICS_update (plugin->env->stats,
- "# UDP, fragmented msgs, bytes payload,
sent, failure",
- overhead, GNUNET_NO);
- GNUNET_STATISTICS_update (plugin->env->stats,
- "# UDP, fragmented msgs, messages,
pending",
- -1, GNUNET_NO);
- break;
- case MSG_FRAGMENTED:
- GNUNET_assert (NULL != udpw->frag_ctx);
- /* Fragmented message: failed to send */
- GNUNET_STATISTICS_update (plugin->env->stats,
- "# UDP, fragmented msgs, fragments, sent,
failure",
- 1, GNUNET_NO);
- GNUNET_STATISTICS_update (plugin->env->stats,
- "# UDP, fragmented msgs, fragments bytes,
sent, failure",
- udpw->msg_size, GNUNET_NO);
- break;
- case 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;
- }
+ case 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_OK, udpw->frag_ctx->payload_size,
+ udpw->frag_ctx->on_wire_size);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, fragmented msgs, messages, sent, success", 1, GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, fragmented msgs, bytes payload, sent, success",
+ udpw->payload_size, GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, fragmented msgs, bytes overhead, sent, success", overhead,
+ GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, total, bytes overhead, sent", overhead, GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, total, bytes payload, sent", udpw->payload_size, GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, fragmented msgs, messages, pending", -1, GNUNET_NO);
break;
+ case MSG_FRAGMENTED:
+ /* Fragmented message: enqueue next fragment */
+ if (NULL != udpw->cont)
+ udpw->cont (udpw->cont_cls, &udpw->session->target, result,
+ udpw->payload_size, udpw->msg_size);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, fragmented msgs, fragments, sent, success", 1, GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, fragmented msgs, fragments bytes, sent, success",
+ udpw->msg_size, GNUNET_NO);
+ break;
+ case 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, ACK msgs, bytes overhead, sent, success", overhead,
+ 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:
- GNUNET_break (0);
+ LOG(GNUNET_ERROR_TYPE_ERROR, "ERROR: %u\n", udpw->msg_type);
+ GNUNET_break(0);
break;
+ }
+ break;
+ case GNUNET_SYSERR:
+ switch (udpw->msg_type)
+ {
+ case MSG_UNFRAGMENTED:
+ /* Unfragmented message: failed to send */
+ if (NULL != udpw->cont)
+ udpw->cont (udpw->cont_cls, &udpw->session->target, result,
+ udpw->payload_size, overhead);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, unfragmented msgs, messages, sent, failure", 1, GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, unfragmented msgs, bytes payload, sent, failure",
+ udpw->payload_size, GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, unfragmented msgs, bytes overhead, sent, failure", overhead,
+ GNUNET_NO);
+ break;
+ case 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_SYSERR, udpw->frag_ctx->payload_size,
+ udpw->frag_ctx->on_wire_size);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, fragmented msgs, messages, sent, failure", 1, GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, fragmented msgs, bytes payload, sent, failure",
+ udpw->payload_size, GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, fragmented msgs, bytes payload, sent, failure", overhead,
+ GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, fragmented msgs, bytes payload, sent, failure", overhead,
+ GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, fragmented msgs, messages, pending", -1, GNUNET_NO);
+ break;
+ case MSG_FRAGMENTED:
+ GNUNET_assert(NULL != udpw->frag_ctx);
+ /* Fragmented message: failed to send */
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, fragmented msgs, fragments, sent, failure", 1, GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, fragmented msgs, fragments bytes, sent, failure",
+ udpw->msg_size, GNUNET_NO);
+ break;
+ case 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;
+ }
+ 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
@@ -1056,7 +998,6 @@
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
@@ -1074,28 +1015,26 @@
*
*/
static int
-udp_plugin_check_address (void *cls,
- const void *addr,
- size_t addrlen)
+udp_plugin_check_address (void *cls, const void *addr, size_t addrlen)
{
struct Plugin *plugin = cls;
struct IPv4UdpAddress *v4;
struct IPv6UdpAddress *v6;
- if ((addrlen != sizeof (struct IPv4UdpAddress)) &&
- (addrlen != sizeof (struct IPv6UdpAddress)))
+ if ((addrlen != sizeof(struct IPv4UdpAddress))
+ && (addrlen != sizeof(struct IPv6UdpAddress)))
{
- GNUNET_break_op (0);
+ GNUNET_break_op(0);
return GNUNET_SYSERR;
}
- if (addrlen == sizeof (struct IPv4UdpAddress))
+ if (addrlen == sizeof(struct IPv4UdpAddress))
{
v4 = (struct IPv4UdpAddress *) addr;
if (GNUNET_OK != check_port (plugin, ntohs (v4->u4_port)))
return GNUNET_SYSERR;
- if (GNUNET_OK !=
- GNUNET_NAT_test_address (plugin->nat, &v4->ipv4_addr,
- sizeof (struct in_addr)))
+ if (GNUNET_OK
+ != GNUNET_NAT_test_address (plugin->nat, &v4->ipv4_addr,
+ sizeof(struct in_addr)))
return GNUNET_SYSERR;
}
else
@@ -1103,20 +1042,19 @@
v6 = (struct IPv6UdpAddress *) addr;
if (IN6_IS_ADDR_LINKLOCAL (&v6->ipv6_addr))
{
- GNUNET_break_op (0);
+ GNUNET_break_op(0);
return GNUNET_SYSERR;
}
if (GNUNET_OK != check_port (plugin, ntohs (v6->u6_port)))
return GNUNET_SYSERR;
- if (GNUNET_OK !=
- GNUNET_NAT_test_address (plugin->nat, &v6->ipv6_addr,
- sizeof (struct in6_addr)))
+ if (GNUNET_OK
+ != GNUNET_NAT_test_address (plugin->nat, &v6->ipv6_addr,
+ sizeof(struct in6_addr)))
return GNUNET_SYSERR;
}
return GNUNET_OK;
}
-
/**
* Function to free last resources associated with a session.
*
@@ -1127,39 +1065,35 @@
{
if (NULL != s->frag_ctx)
{
- GNUNET_FRAGMENT_context_destroy (s->frag_ctx->frag, NULL, NULL);
- GNUNET_free (s->frag_ctx);
+ GNUNET_FRAGMENT_context_destroy (s->frag_ctx->frag, NULL, NULL );
+ GNUNET_free(s->frag_ctx);
s->frag_ctx = NULL;
}
- GNUNET_free (s);
+ 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_break(0);
else
{
GNUNET_STATISTICS_update (plugin->env->stats,
- "# UDP, total, bytes in buffers",
- - (long long) udpw->msg_size, GNUNET_NO);
+ "# UDP, total, bytes in buffers", -(long long) udpw->msg_size,
+ GNUNET_NO);
plugin->bytes_in_buffer -= udpw->msg_size;
}
- GNUNET_STATISTICS_update (plugin->env->stats,
- "# UDP, total, msgs in buffers",
- -1, GNUNET_NO);
- if (udpw->session->addrlen == sizeof (struct sockaddr_in))
- GNUNET_CONTAINER_DLL_remove (plugin->ipv4_queue_head,
- plugin->ipv4_queue_tail, udpw);
- if (udpw->session->addrlen == sizeof (struct sockaddr_in6))
- GNUNET_CONTAINER_DLL_remove (plugin->ipv6_queue_head,
- plugin->ipv6_queue_tail, udpw);
+ GNUNET_STATISTICS_update (plugin->env->stats, "# UDP, total, msgs in
buffers",
+ -1, GNUNET_NO);
+ if (udpw->session->address->address_length == sizeof(struct sockaddr_in))
+ GNUNET_CONTAINER_DLL_remove(plugin->ipv4_queue_head,
+ plugin->ipv4_queue_tail, udpw);
+ if (udpw->session->address->address_length == sizeof(struct sockaddr_in6))
+ GNUNET_CONTAINER_DLL_remove(plugin->ipv6_queue_head,
+ plugin->ipv6_queue_tail, udpw);
}
-
static void
fragmented_message_done (struct UDP_FragmentationContext *fc, int result)
{
@@ -1168,13 +1102,12 @@
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));
+ memset (&dummy, 0, sizeof(dummy));
dummy.msg_type = MSG_FRAGMENTED_COMPLETE;
dummy.msg_size = s->frag_ctx->on_wire_size;
dummy.payload_size = s->frag_ctx->payload_size;
@@ -1186,46 +1119,43 @@
call_continuation (&dummy, result);
/* Remove leftover fragments from queue */
- if (s->addrlen == sizeof (struct sockaddr_in6))
+ if (s->address->address_length == sizeof(struct sockaddr_in6))
{
udpw = plugin->ipv6_queue_head;
while (NULL != udpw)
{
tmp = udpw->next;
- if ((udpw->frag_ctx != NULL) && (udpw->frag_ctx == s->frag_ctx))
- {
- dequeue (plugin, udpw);
- call_continuation (udpw, GNUNET_SYSERR);
- GNUNET_free (udpw);
- }
+ if ((udpw->frag_ctx != NULL )&& (udpw->frag_ctx == s->frag_ctx)){
+ dequeue (plugin, udpw);
+ call_continuation (udpw, GNUNET_SYSERR);
+ GNUNET_free (udpw);
+ }
udpw = tmp;
}
}
- if (s->addrlen == sizeof (struct sockaddr_in))
+ if (s->address->address_length == sizeof(struct sockaddr_in))
{
udpw = plugin->ipv4_queue_head;
- while (udpw!= NULL)
+ while (udpw != NULL )
{
tmp = udpw->next;
if ((NULL != udpw->frag_ctx) && (udpw->frag_ctx == s->frag_ctx))
{
dequeue (plugin, udpw);
call_continuation (udpw, GNUNET_SYSERR);
- GNUNET_free (udpw);
+ GNUNET_free(udpw);
}
udpw = tmp;
}
}
/* Destroy fragmentation context */
- GNUNET_FRAGMENT_context_destroy (fc->frag,
- &s->last_expected_msg_delay,
- &s->last_expected_ack_delay);
+ GNUNET_FRAGMENT_context_destroy (fc->frag, &s->last_expected_msg_delay,
+ &s->last_expected_ack_delay);
s->frag_ctx = NULL;
- GNUNET_free (fc);
+ GNUNET_free(fc);
}
-
/**
* Functions with this signature are called whenever we need
* to close a session due to a disconnect or failure to
@@ -1236,19 +1166,16 @@
* @return #GNUNET_OK on success
*/
static int
-udp_disconnect_session (void *cls,
- struct Session *s)
+udp_disconnect_session (void *cls, struct Session *s)
{
struct Plugin *plugin = cls;
struct UDP_MessageWrapper *udpw;
struct UDP_MessageWrapper *next;
- GNUNET_assert (GNUNET_YES != s->in_destroy);
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Session %p to peer `%s' address ended\n",
- s,
- GNUNET_i2s (&s->target),
- GNUNET_a2s (s->sock_addr, s->addrlen));
+ GNUNET_assert(GNUNET_YES != s->in_destroy);
+ LOG(GNUNET_ERROR_TYPE_DEBUG, "Session %p to peer `%s' address ended\n", s,
+ GNUNET_i2s (&s->target),
+ GNUNET_a2s (s->address->address, s->address->address_length));
/* stop timeout task */
if (GNUNET_SCHEDULER_NO_TASK != s->timeout_task)
{
@@ -1269,7 +1196,7 @@
{
dequeue (plugin, udpw);
call_continuation (udpw, GNUNET_SYSERR);
- GNUNET_free (udpw);
+ GNUNET_free(udpw);
}
}
next = plugin->ipv6_queue_head;
@@ -1280,7 +1207,7 @@
{
dequeue (plugin, udpw);
call_continuation (udpw, GNUNET_SYSERR);
- GNUNET_free (udpw);
+ GNUNET_free(udpw);
}
}
plugin->env->session_end (plugin->env->cls, &s->target, s);
@@ -1290,29 +1217,27 @@
if (NULL != s->frag_ctx->cont)
{
s->frag_ctx->cont (s->frag_ctx->cont_cls, &s->target, GNUNET_SYSERR,
- s->frag_ctx->payload_size, s->frag_ctx->on_wire_size);
- LOG (GNUNET_ERROR_TYPE_DEBUG,
+ s->frag_ctx->payload_size, s->frag_ctx->on_wire_size);
+ LOG(GNUNET_ERROR_TYPE_DEBUG,
"Calling continuation for fragemented message to `%s' with result
SYSERR\n",
GNUNET_i2s (&s->target));
}
}
- GNUNET_assert (GNUNET_YES ==
- GNUNET_CONTAINER_multipeermap_remove (plugin->sessions,
- &s->target,
- s));
- GNUNET_STATISTICS_set (plugin->env->stats,
- "# UDP, sessions active",
- GNUNET_CONTAINER_multipeermap_size(plugin->sessions),
- GNUNET_NO);
+ GNUNET_assert(
+ GNUNET_YES == GNUNET_CONTAINER_multipeermap_remove (plugin->sessions,
&s->target, s));
+ 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;
else
+ {
+ GNUNET_HELLO_address_free (s->address);
free_session (s);
+ }
return GNUNET_OK;
}
-
/**
* Function that is called to get the keepalive factor.
* GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT is divided by this number to
@@ -1327,7 +1252,6 @@
return 15;
}
-
/**
* Destroy a session, plugin is being unloaded.
*
@@ -1337,9 +1261,8 @@
* @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;
@@ -1347,7 +1270,6 @@
return GNUNET_OK;
}
-
/**
* Disconnect from a remote node. Clean up session if we have one for
* this peer.
@@ -1357,20 +1279,17 @@
* @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
*
@@ -1378,23 +1297,18 @@
* @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 (s->plugin, s);
}
-
/**
* Increment session timeout due to activity
*
@@ -1405,155 +1319,51 @@
{
if (GNUNET_YES == s->in_destroy)
return;
- GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != s->timeout_task);
+ GNUNET_assert(GNUNET_SCHEDULER_NO_TASK != s->timeout_task);
GNUNET_SCHEDULER_cancel (s->timeout_task);
s->timeout_task = GNUNET_SCHEDULER_add_delayed (UDP_SESSION_TIME_OUT,
- &session_timeout,
- s);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Timeout restarted for session %p\n",
- s);
+ &session_timeout, s);
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Timeout restarted for session %p\n", s);
}
-
static struct Session *
create_session (struct Plugin *plugin,
- const struct GNUNET_PeerIdentity *target,
- const void *addr, size_t addrlen,
- GNUNET_TRANSPORT_TransmitContinuation cont, void *cont_cls)
+ const struct GNUNET_HELLO_Address *address)
{
struct Session *s;
- const struct IPv4UdpAddress *t4;
- const struct IPv6UdpAddress *t6;
- struct sockaddr_in *v4;
- struct sockaddr_in6 *v6;
- size_t len;
- if (NULL == addr)
- {
- GNUNET_break (0);
- return NULL;
- }
-
- switch (addrlen)
- {
- case sizeof (struct IPv4UdpAddress):
- if (NULL == plugin->sockv4)
- {
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Could not create session for peer `%s' address `%s': IPv4 is not
enabled\n",
- GNUNET_i2s(target),
- udp_address_to_string (NULL, addr, addrlen));
- return NULL;
- }
- t4 = addr;
- s = GNUNET_malloc (sizeof (struct Session) + sizeof (struct sockaddr_in));
- s->plugin = plugin;
- len = sizeof (struct sockaddr_in);
- v4 = (struct sockaddr_in *) &s[1];
- v4->sin_family = AF_INET;
-#if HAVE_SOCKADDR_IN_SIN_LEN
- v4->sin_len = sizeof (struct sockaddr_in);
-#endif
- v4->sin_port = t4->u4_port;
- v4->sin_addr.s_addr = t4->ipv4_addr;
- s->ats = plugin->env->get_address_type (plugin->env->cls, (const struct
sockaddr *) v4, sizeof (struct sockaddr_in));
- break;
- case sizeof (struct IPv6UdpAddress):
- if (NULL == plugin->sockv6)
- {
- LOG (GNUNET_ERROR_TYPE_INFO,
- "Could not create session for peer `%s' address `%s': IPv6 is not
enabled\n",
- GNUNET_i2s(target),
- udp_address_to_string(NULL, addr, addrlen));
- return NULL;
- }
- t6 = addr;
- s = GNUNET_malloc (sizeof (struct Session) + sizeof (struct sockaddr_in6));
- s->plugin = plugin;
- len = sizeof (struct sockaddr_in6);
- v6 = (struct sockaddr_in6 *) &s[1];
- v6->sin6_family = AF_INET6;
-#if HAVE_SOCKADDR_IN_SIN_LEN
- v6->sin6_len = sizeof (struct sockaddr_in6);
-#endif
- v6->sin6_port = t6->u6_port;
- v6->sin6_addr = t6->ipv6_addr;
- s->ats = plugin->env->get_address_type (plugin->env->cls, (const struct
sockaddr *) v6, sizeof (struct sockaddr_in6));
- break;
- default:
- /* Must have a valid address to send to */
- GNUNET_STATISTICS_update (plugin->env->stats,
- gettext_noop
- ("# requests to create session with invalid
address"),
- 1, GNUNET_NO);
- return NULL;
- }
- s->addrlen = len;
- s->target = *target;
- s->sock_addr = (const struct sockaddr *) &s[1];
- s->last_expected_ack_delay = GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_MILLISECONDS, 250);
+ s = GNUNET_new (struct Session);
+ s->address = GNUNET_HELLO_address_copy (address);
+ s->target = address->peer;
+ s->last_expected_ack_delay = GNUNET_TIME_relative_multiply (
+ GNUNET_TIME_UNIT_MILLISECONDS, 250);
s->last_expected_msg_delay = GNUNET_TIME_UNIT_MILLISECONDS;
s->flow_delay_from_other_peer = GNUNET_TIME_UNIT_ZERO_ABS;
s->flow_delay_for_other_peer = GNUNET_TIME_UNIT_ZERO;
- s->inbound = GNUNET_NO;
- s->timeout_task = GNUNET_SCHEDULER_add_delayed (UDP_SESSION_TIME_OUT,
- &session_timeout,
- s);
+ s->timeout_task = GNUNET_SCHEDULER_add_delayed (UDP_SESSION_TIME_OUT,
+ &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;
- const struct GNUNET_HELLO_Address *address = cctx->addr;
+ const struct GNUNET_HELLO_Address *address = cctx->address;
struct Session *s = value;
- 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));
- 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))
- {
- cctx->res = s;
- return GNUNET_NO;
- }
+ 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));
- }
- if ((address->address_length == sizeof (struct IPv6UdpAddress)) &&
- (s_addrlen == sizeof (struct sockaddr_in6)))
+ if (0 == GNUNET_HELLO_address_cmp(s->address, cctx->address))
{
- 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))
- {
- cctx->res = s;
- return GNUNET_NO;
- }
+ cctx->res = s;
+ return GNUNET_NO;
}
return GNUNET_YES;
}
-
/**
* Function obtain the network type for a session
*
@@ -1562,13 +1372,11 @@
* @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
@@ -1580,107 +1388,130 @@
*/
static struct Session *
udp_plugin_lookup_session (void *cls,
- const struct GNUNET_HELLO_Address *address,
- int inbound)
+ const struct GNUNET_HELLO_Address *address)
{
struct Plugin * plugin = cls;
struct IPv6UdpAddress * udp_a6;
struct IPv4UdpAddress * udp_a4;
- GNUNET_assert (plugin != NULL);
- GNUNET_assert (address != NULL);
+ 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))))
+ if (address->address_length == sizeof(struct IPv4UdpAddress))
{
- 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 (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.addr = address;
+ cctx.address = 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),
- udp_address_to_string(NULL, address->address, address->address_length));
- GNUNET_CONTAINER_multipeermap_get_multiple(plugin->sessions, &address->peer,
session_cmp_it, &cctx);
- if (cctx.res != NULL)
+ LOG(GNUNET_ERROR_TYPE_ERROR,
+ "Looking for existing session for peer `%s' `%s' \n",
+ GNUNET_i2s (&address->peer),
+ udp_address_to_string(NULL, address->address, address->address_length));
+ GNUNET_CONTAINER_multipeermap_get_multiple (plugin->sessions, &address->peer,
+ session_cmp_it, &cctx);
+ if (cctx.res != NULL )
{
- LOG (GNUNET_ERROR_TYPE_DEBUG, "Found existing session %p\n", cctx.res);
+ LOG(GNUNET_ERROR_TYPE_ERROR, "Found existing session %p\n", cctx.res);
return cctx.res;
}
- return NULL;
+ return NULL ;
}
+static int
+udp_address_is_inbound (const struct GNUNET_HELLO_Address *address)
+{
+ if (GNUNET_HELLO_ADDRESS_INFO_INBOUND == (address->local_info &
GNUNET_HELLO_ADDRESS_INFO_INBOUND))
+ return GNUNET_YES;
+ else
+ return GNUNET_NO;
+}
static struct Session *
udp_plugin_create_session (void *cls,
- const struct GNUNET_HELLO_Address *address,
- int inbound)
+ const struct GNUNET_HELLO_Address *address)
{
struct Session *s;
+ struct IPv4UdpAddress *udp_v4;
+ struct IPv6UdpAddress *udp_v6;
- s = create_session (plugin,
- &address->peer,
- address->address,
- address->address_length,
- NULL, NULL);
+ s = create_session (plugin, address);
+ if (sizeof (struct IPv4UdpAddress) == address->address_length)
+ {
+ struct sockaddr_in v4;
+ udp_v4 = (struct IPv4UdpAddress *) address->address;
+ memset (&v4, '\0', sizeof (v4));
+ v4.sin_family = AF_INET;
+#if HAVE_SOCKADDR_IN_SIN_LEN
+ v4->sin_len = sizeof (struct sockaddr_in);
+#endif
+ v4.sin_port = udp_v4->u4_port;
+ v4.sin_addr.s_addr = udp_v4->ipv4_addr;
+ s->ats = plugin->env->get_address_type (plugin->env->cls,
+ (const struct sockaddr *) &v4, sizeof (v4));
+ }
+ else if (sizeof (struct IPv6UdpAddress) == address->address_length)
+ {
+ struct sockaddr_in6 v6;
+ udp_v6 = (struct IPv6UdpAddress *) address->address;
+ memset (&v6, '\0', sizeof (v6));
+ v6.sin6_family = AF_INET6;
+#if HAVE_SOCKADDR_IN_SIN_LEN
+ v6->sin_len = sizeof (struct sockaddr_in6);
+#endif
+ v6.sin6_port = udp_v6->u6_port;
+ v6.sin6_addr = udp_v6->ipv6_addr;
+ s->ats = plugin->env->get_address_type (plugin->env->cls,
+ (const struct sockaddr *) &v6, sizeof (v6));
+ }
+
if (NULL == s)
- return NULL; /* protocol not supported or address invalid */
- s->inbound = inbound;
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "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));
- 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_CONTAINER_multipeermap_size(plugin->sessions),
- GNUNET_NO);
+ return NULL ; /* protocol not supported or address invalid */
+ LOG(GNUNET_ERROR_TYPE_ERROR,
+ "Creating new %s session %p for peer `%s' address `%s'\n",
+ (GNUNET_YES == udp_address_is_inbound(address)) ? "inbound" : "outbound",
+ s, GNUNET_i2s (&address->peer),
+ 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_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))
+ != GNUNET_CONTAINER_multipeermap_contains_value (plugin->sessions, peer,
+ session))
{
GNUNET_break(0);
return;
@@ -1699,52 +1530,46 @@
* @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;
+ GNUNET_break(0);
+ 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, GNUNET_NO)))
+ if (NULL != (s = udp_plugin_lookup_session (cls, address)))
return s;
- return udp_plugin_create_session (cls, address, GNUNET_NO);
+ return udp_plugin_create_session (cls, address);
}
-
static void
enqueue (struct Plugin *plugin, struct UDP_MessageWrapper * udpw)
{
if (plugin->bytes_in_buffer + udpw->msg_size > INT64_MAX)
- GNUNET_break (0);
+ GNUNET_break(0);
else
{
GNUNET_STATISTICS_update (plugin->env->stats,
- "# UDP, total, bytes in buffers",
- udpw->msg_size, GNUNET_NO);
+ "# UDP, total, bytes in buffers", udpw->msg_size, GNUNET_NO);
plugin->bytes_in_buffer += udpw->msg_size;
}
- GNUNET_STATISTICS_update (plugin->env->stats,
- "# UDP, total, msgs in buffers",
- 1, GNUNET_NO);
- if (udpw->session->addrlen == sizeof (struct sockaddr_in))
- GNUNET_CONTAINER_DLL_insert (plugin->ipv4_queue_head,
- plugin->ipv4_queue_tail, udpw);
- if (udpw->session->addrlen == sizeof (struct sockaddr_in6))
- GNUNET_CONTAINER_DLL_insert (plugin->ipv6_queue_head,
- plugin->ipv6_queue_tail, udpw);
+ GNUNET_STATISTICS_update (plugin->env->stats, "# UDP, total, msgs in
buffers",
+ 1, GNUNET_NO);
+ if (udpw->session->address->address_length == sizeof(struct sockaddr_in))
+ GNUNET_CONTAINER_DLL_insert(plugin->ipv4_queue_head,
+ plugin->ipv4_queue_tail, udpw);
+ if (udpw->session->address->address_length == sizeof(struct sockaddr_in6))
+ GNUNET_CONTAINER_DLL_insert(plugin->ipv6_queue_head,
+ plugin->ipv6_queue_tail, udpw);
}
-
-
/**
* Fragment message was transmitted via UDP, let fragmentation know
* to send the next fragment now.
@@ -1756,16 +1581,14 @@
* @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
@@ -1783,9 +1606,8 @@
struct UDP_MessageWrapper * udpw;
size_t msg_len = ntohs (msg->size);
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Enqueuing fragment with %u bytes\n", msg_len);
- frag_ctx->fragments_used ++;
+ LOG(GNUNET_ERROR_TYPE_DEBUG, "Enqueuing fragment with %u bytes\n", msg_len);
+ frag_ctx->fragments_used++;
udpw = GNUNET_malloc (sizeof (struct UDP_MessageWrapper) + msg_len);
udpw->session = frag_ctx->session;
udpw->msg_buf = (char *) &udpw[1];
@@ -1801,7 +1623,6 @@
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
@@ -1830,43 +1651,39 @@
* 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);
+ size_t udpmlen = msgbuf_size + sizeof(struct UDPMessage);
struct UDP_FragmentationContext * frag_ctx;
struct UDP_MessageWrapper * udpw;
struct UDPMessage *udp;
char mbuf[udpmlen];
- GNUNET_assert (plugin != NULL);
- GNUNET_assert (s != NULL);
+ GNUNET_assert(plugin != NULL);
+ GNUNET_assert(s != NULL);
- if ((s->addrlen == sizeof (struct sockaddr_in6)) && (plugin->sockv6 == NULL))
+ if ((s->address->address_length == sizeof(struct sockaddr_in6)) &&
(plugin->sockv6 == NULL ))
return GNUNET_SYSERR;
- if ((s->addrlen == sizeof (struct sockaddr_in)) && (plugin->sockv4 == NULL))
+ if ((s->address->address_length == sizeof(struct sockaddr_in)) &&
(plugin->sockv4 == NULL ))
return GNUNET_SYSERR;
if (udpmlen >= GNUNET_SERVER_MAX_MESSAGE_SIZE)
{
- GNUNET_break (0);
+ GNUNET_break(0);
return GNUNET_SYSERR;
}
- if (GNUNET_YES !=
GNUNET_CONTAINER_multipeermap_contains_value(plugin->sessions, &s->target, s))
+ if (GNUNET_YES
+ != GNUNET_CONTAINER_multipeermap_contains_value (plugin->sessions,
+ &s->target, s))
{
- GNUNET_break (0);
+ 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),
- GNUNET_a2s(s->sock_addr, s->addrlen));
+ 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;
udp->header.size = htons (udpmlen);
@@ -1889,26 +1706,25 @@
udpw->msg_buf = (char *) &udpw[1];
udpw->msg_size = udpmlen; /* message size with UDP overhead */
udpw->payload_size = msgbuf_size; /* message size without UDP overhead */
- udpw->timeout = GNUNET_TIME_absolute_add(GNUNET_TIME_absolute_get(), to);
+ udpw->timeout = GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get (), to);
udpw->cont = cont;
udpw->cont_cls = cont_cls;
udpw->frag_ctx = NULL;
udpw->msg_type = MSG_UNFRAGMENTED;
- memcpy (udpw->msg_buf, udp, sizeof (struct UDPMessage));
- memcpy (&udpw->msg_buf[sizeof (struct UDPMessage)], msgbuf, msgbuf_size);
+ memcpy (udpw->msg_buf, udp, sizeof(struct UDPMessage));
+ memcpy (&udpw->msg_buf[sizeof(struct UDPMessage)], msgbuf, msgbuf_size);
enqueue (plugin, udpw);
GNUNET_STATISTICS_update (plugin->env->stats,
- "# UDP, unfragmented msgs, messages, attempt",
- 1, GNUNET_NO);
+ "# UDP, unfragmented msgs, messages, attempt", 1, GNUNET_NO);
GNUNET_STATISTICS_update (plugin->env->stats,
- "# UDP, unfragmented msgs, bytes payload,
attempt",
- udpw->payload_size, GNUNET_NO);
+ "# UDP, unfragmented msgs, bytes payload, attempt", udpw->payload_size,
+ GNUNET_NO);
}
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);
@@ -1916,93 +1732,87 @@
frag_ctx->session = s;
frag_ctx->cont = cont;
frag_ctx->cont_cls = cont_cls;
- frag_ctx->timeout = GNUNET_TIME_absolute_add(GNUNET_TIME_absolute_get(),
to);
+ frag_ctx->timeout = GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get (),
+ to);
frag_ctx->payload_size = msgbuf_size; /* unfragmented message size without
UDP overhead */
frag_ctx->on_wire_size = 0; /* bytes with UDP and fragmentation overhead */
frag_ctx->frag = GNUNET_FRAGMENT_context_create (plugin->env->stats,
- UDP_MTU,
- &plugin->tracker,
- s->last_expected_msg_delay,
- s->last_expected_ack_delay,
- &udp->header,
- &enqueue_fragment,
- frag_ctx);
+ UDP_MTU, &plugin->tracker, s->last_expected_msg_delay,
+ s->last_expected_ack_delay, &udp->header, &enqueue_fragment, frag_ctx);
s->frag_ctx = frag_ctx;
GNUNET_STATISTICS_update (plugin->env->stats,
- "# UDP, fragmented msgs, messages, pending",
- 1, GNUNET_NO);
+ "# UDP, fragmented msgs, messages, pending", 1, GNUNET_NO);
GNUNET_STATISTICS_update (plugin->env->stats,
- "# UDP, fragmented msgs, messages, attempt",
- 1, GNUNET_NO);
+ "# UDP, fragmented msgs, messages, attempt", 1, GNUNET_NO);
GNUNET_STATISTICS_update (plugin->env->stats,
- "# UDP, fragmented msgs, bytes payload, attempt",
- frag_ctx->payload_size, GNUNET_NO);
+ "# UDP, fragmented msgs, bytes payload, attempt",
+ frag_ctx->payload_size, GNUNET_NO);
}
schedule_select (plugin);
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
* the previous (now invalid) one
- * @param addr either the previous or the new public IP address
+ * @param address 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;
struct IPv4UdpAddress u4;
struct IPv6UdpAddress u6;
void *arg;
size_t args;
- LOG (GNUNET_ERROR_TYPE_INFO,
- "NAT notification to %s address `%s'\n",
- (GNUNET_YES == add_remove) ? "add" : "remove",
- GNUNET_a2s (addr, addrlen));
+ LOG(GNUNET_ERROR_TYPE_INFO, "NAT notification to %s address `%s'\n",
+ (GNUNET_YES == add_remove) ? "add" : "remove",
+ GNUNET_a2s (addr, addrlen));
- /* convert 'addr' to our internal format */
+ /* convert 'address' to our internal format */
switch (addr->sa_family)
{
case AF_INET:
- GNUNET_assert (addrlen == sizeof (struct sockaddr_in));
- memset (&u4, 0, sizeof (u4));
- u4.options = htonl(myoptions);
+ GNUNET_assert(addrlen == sizeof(struct sockaddr_in));
+ memset (&u4, 0, sizeof(u4));
+ u4.options = htonl (myoptions);
u4.ipv4_addr = ((struct sockaddr_in *) addr)->sin_addr.s_addr;
u4.u4_port = ((struct sockaddr_in *) addr)->sin_port;
if (0 == ((struct sockaddr_in *) addr)->sin_port)
- return;
+ return;
arg = &u4;
- args = sizeof (struct IPv4UdpAddress);
+ args = sizeof(struct IPv4UdpAddress);
break;
case AF_INET6:
- GNUNET_assert (addrlen == sizeof (struct sockaddr_in6));
- memset (&u4, 0, sizeof (u4));
- u6.options = htonl(myoptions);
+ GNUNET_assert(addrlen == sizeof(struct sockaddr_in6));
+ memset (&u4, 0, sizeof(u4));
+ u6.options = htonl (myoptions);
if (0 == ((struct sockaddr_in6 *) addr)->sin6_port)
- return;
+ return;
memcpy (&u6.ipv6_addr, &((struct sockaddr_in6 *) addr)->sin6_addr,
- sizeof (struct in6_addr));
+ sizeof(struct in6_addr));
u6.u6_port = ((struct sockaddr_in6 *) addr)->sin6_port;
arg = &u6;
- args = sizeof (struct IPv6UdpAddress);
+ args = sizeof(struct IPv6UdpAddress);
break;
default:
- GNUNET_break (0);
+ GNUNET_break(0);
return;
}
/* modify our published address list */
- plugin->env->notify_address (plugin->env->cls, add_remove, arg, args, "udp");
+ address = GNUNET_HELLO_address_allocate (plugin->env->my_identity,
+ PLUGIN_NAME, arg, args, GNUNET_HELLO_ADDRESS_INFO_NONE);
+ plugin->env->notify_address (plugin->env->cls, add_remove, address);
+ GNUNET_HELLO_address_free (address);
}
-
-
/**
* Message tokenizer has broken up an incomming message. Pass it on
* to the service.
@@ -2014,37 +1824,26 @@
*/
static int
process_inbound_tokenized_messages (void *cls, void *client,
- const struct GNUNET_MessageHeader *hdr)
+ const struct GNUNET_MessageHeader *hdr)
{
struct Plugin *plugin = cls;
struct SourceInformation *si = client;
struct GNUNET_TIME_Relative delay;
- GNUNET_assert (si->session != NULL);
+ GNUNET_assert(si->session != NULL);
if (GNUNET_YES == si->session->in_destroy)
return GNUNET_OK;
/* setup ATS */
- GNUNET_break (ntohl(si->session->ats.value) != GNUNET_ATS_NET_UNSPECIFIED);
+ GNUNET_break(ntohl (si->session->ats.value) != GNUNET_ATS_NET_UNSPECIFIED);
reschedule_session_timeout (si->session);
- delay = plugin->env->receive (plugin->env->cls,
- &si->sender,
- hdr,
- si->session,
- (GNUNET_YES == si->session->inbound)
- ? NULL : si->arg,
- (GNUNET_YES == si->session->inbound)
- ? 0 : si->args);
+ delay = plugin->env->receive (plugin->env->cls, si->session->address,
si->session, hdr);
plugin->env->update_address_metrics (plugin->env->cls,
- &si->sender,
- (GNUNET_YES == si->session->inbound) ?
NULL : si->arg,
- (GNUNET_YES == si->session->inbound) ?
0 : si->args,
- si->session,
- &si->session->ats, 1);
+ si->session->address, si->session,
+ &si->session->ats, 1);
si->session->flow_delay_for_other_peer = delay;
return GNUNET_OK;
}
-
/**
* We've received a UDP Message. Process it (pass contents to main service).
*
@@ -2055,11 +1854,11 @@
*/
static void
process_udp_message (struct Plugin *plugin, const struct UDPMessage *msg,
- const struct sockaddr *sender_addr,
- socklen_t sender_addr_len)
+ const struct sockaddr *sender_addr, socklen_t sender_addr_len)
{
struct SourceInformation si;
struct Session * s;
+ struct GNUNET_HELLO_Address *address;
struct IPv4UdpAddress u4;
struct IPv6UdpAddress u6;
const void *arg;
@@ -2067,13 +1866,13 @@
if (0 != ntohl (msg->reserved))
{
- GNUNET_break_op (0);
+ GNUNET_break_op(0);
return;
}
- if (ntohs (msg->header.size) <
- sizeof (struct GNUNET_MessageHeader) + sizeof (struct UDPMessage))
+ if (ntohs (msg->header.size)
+ < sizeof(struct GNUNET_MessageHeader) + sizeof(struct UDPMessage))
{
- GNUNET_break_op (0);
+ GNUNET_break_op(0);
return;
}
@@ -2081,40 +1880,40 @@
switch (sender_addr->sa_family)
{
case AF_INET:
- GNUNET_assert (sender_addr_len == sizeof (struct sockaddr_in));
- memset (&u4, 0, sizeof (u4));
+ GNUNET_assert(sender_addr_len == sizeof(struct sockaddr_in));
+ memset (&u4, 0, sizeof(u4));
u6.options = htonl (0);
u4.ipv4_addr = ((struct sockaddr_in *) sender_addr)->sin_addr.s_addr;
u4.u4_port = ((struct sockaddr_in *) sender_addr)->sin_port;
arg = &u4;
- args = sizeof (u4);
+ args = sizeof(u4);
break;
case AF_INET6:
- GNUNET_assert (sender_addr_len == sizeof (struct sockaddr_in6));
- memset (&u6, 0, sizeof (u6));
+ GNUNET_assert(sender_addr_len == sizeof(struct sockaddr_in6));
+ memset (&u6, 0, sizeof(u6));
u6.options = htonl (0);
u6.ipv6_addr = ((struct sockaddr_in6 *) sender_addr)->sin6_addr;
u6.u6_port = ((struct sockaddr_in6 *) sender_addr)->sin6_port;
arg = &u6;
- args = sizeof (u6);
+ args = sizeof(u6);
break;
default:
- GNUNET_break (0);
+ GNUNET_break(0);
return;
}
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Received message with %u bytes from peer `%s' at `%s'\n",
- (unsigned int) ntohs (msg->header.size), GNUNET_i2s (&msg->sender),
- GNUNET_a2s (sender_addr, sender_addr_len));
+ LOG(GNUNET_ERROR_TYPE_DEBUG,
+ "Received message with %u bytes from peer `%s' at `%s'\n",
+ (unsigned int ) ntohs (msg->header.size), GNUNET_i2s (&msg->sender),
+ 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, GNUNET_YES)))
+ address = GNUNET_HELLO_address_allocate ( &msg->sender, PLUGIN_NAME,
+ arg, args, GNUNET_HELLO_ADDRESS_INFO_INBOUND);
+ if (NULL == (s = udp_plugin_lookup_session (plugin, address)))
{
- s = udp_plugin_create_session (plugin, address, GNUNET_YES);
- plugin->env->session_start (NULL, &address->peer, PLUGIN_NAME,
- address->address, address->address_length, s, NULL, 0);
+ s = udp_plugin_create_session (plugin, address);
+ plugin->env->session_start (NULL, address, s, NULL, 0);
}
- GNUNET_free (address);
+ GNUNET_free(address);
/* iterate over all embedded messages */
si.session = s;
@@ -2122,18 +1921,14 @@
si.arg = arg;
si.args = args;
s->rc++;
- GNUNET_SERVER_mst_receive (plugin->mst,
- &si,
- (const char *) &msg[1],
- ntohs (msg->header.size) - sizeof (struct
UDPMessage),
- GNUNET_YES,
- GNUNET_NO);
+ GNUNET_SERVER_mst_receive (plugin->mst, &si, (const char *) &msg[1],
+ ntohs (msg->header.size) - sizeof(struct UDPMessage), GNUNET_YES,
+ GNUNET_NO);
s->rc--;
- if ( (0 == s->rc) && (GNUNET_YES == s->in_destroy))
+ if ((0 == s->rc) && (GNUNET_YES == s->in_destroy))
free_session (s);
}
-
/**
* Scan the heap for a receive context with the given address.
*
@@ -2146,13 +1941,13 @@
*/
static int
find_receive_context (void *cls, struct GNUNET_CONTAINER_HeapNode *node,
- void *element, GNUNET_CONTAINER_HeapCostType cost)
+ 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)))
+ if ((frc->addr_len == e->addr_len)
+ && (0 == memcmp (frc->addr, e->src_addr, frc->addr_len)))
{
frc->rc = e;
return GNUNET_NO;
@@ -2160,7 +1955,6 @@
return GNUNET_YES;
}
-
/**
* Process a defragmented message.
*
@@ -2174,35 +1968,30 @@
if (ntohs (msg->type) != GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_MESSAGE)
{
- GNUNET_break (0);
+ GNUNET_break(0);
return;
}
- if (ntohs (msg->size) < sizeof (struct UDPMessage))
+ if (ntohs (msg->size) < sizeof(struct UDPMessage))
{
- GNUNET_break (0);
+ GNUNET_break(0);
return;
}
process_udp_message (rc->plugin, (const struct UDPMessage *) msg,
- rc->src_addr, rc->addr_len);
+ rc->src_addr, rc->addr_len);
}
-
struct LookupContext
{
struct Session *res;
- const struct sockaddr * addr;
+ const struct GNUNET_HELLO_Address *address;
- size_t addrlen;
-
int must_have_frag_ctx;
};
-
static int
-lookup_session_by_addr_it (void *cls,
- const struct GNUNET_PeerIdentity *key,
- void *value)
+lookup_session_by_addr_it (void *cls, const struct GNUNET_PeerIdentity *key,
+ void *value)
{
struct LookupContext *l_ctx = cls;
struct Session * s = value;
@@ -2210,15 +1999,7 @@
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)))
+ if (0 == GNUNET_HELLO_address_cmp (s->address, l_ctx->address))
{
l_ctx->res = s;
return GNUNET_YES;
@@ -2226,7 +2007,6 @@
return GNUNET_YES;
}
-
/**
* Transmit an acknowledgement.
*
@@ -2238,20 +2018,19 @@
ack_proc (void *cls, uint32_t id, const struct GNUNET_MessageHeader *msg)
{
struct DefragContext *rc = cls;
- size_t msize = sizeof (struct UDP_ACK_Message) + ntohs (msg->size);
+ size_t msize = sizeof(struct UDP_ACK_Message) + ntohs (msg->size);
struct UDP_ACK_Message *udp_ack;
uint32_t delay = 0;
struct UDP_MessageWrapper *udpw;
struct Session *s;
struct LookupContext l_ctx;
- l_ctx.addr = rc->src_addr;
- l_ctx.addrlen = rc->addr_len;
+ 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.must_have_frag_ctx = GNUNET_NO;
GNUNET_CONTAINER_multipeermap_iterate (rc->plugin->sessions,
- &lookup_session_by_addr_it,
- &l_ctx);
+ &lookup_session_by_addr_it, &l_ctx);
s = l_ctx.res;
if (NULL == s)
@@ -2260,20 +2039,15 @@
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 %s\n",
- GNUNET_a2s (rc->src_addr,
- (rc->src_addr->sa_family ==
- AF_INET) ? sizeof (struct sockaddr_in) : sizeof (struct
-
sockaddr_in6)),
- GNUNET_STRINGS_relative_time_to_string (s->flow_delay_for_other_peer,
- GNUNET_YES));
+ LOG(GNUNET_ERROR_TYPE_DEBUG, "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)),
+ 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;
udpw->session = s;
udpw->timeout = GNUNET_TIME_UNIT_FOREVER_ABS;
- udpw->msg_buf = (char *)&udpw[1];
+ udpw->msg_buf = (char *) &udpw[1];
udpw->msg_type = MSG_ACK;
udp_ack = (struct UDP_ACK_Message *) udpw->msg_buf;
udp_ack->header.size = htons ((uint16_t) msize);
@@ -2284,28 +2058,21 @@
enqueue (rc->plugin, udpw);
}
-
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))
+ if (ntohs (msg->size) < sizeof(struct UDPMessage))
{
- GNUNET_break_op (0);
+ GNUNET_break_op(0);
return;
}
- process_udp_message (plugin, (const struct UDPMessage *) msg,
- addr, fromlen);
+ 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;
@@ -2313,70 +2080,64 @@
struct Session *s;
struct GNUNET_TIME_Relative flow_delay;
- if (ntohs (msg->size) <
- sizeof (struct UDP_ACK_Message) + sizeof (struct GNUNET_MessageHeader))
+ if (ntohs (msg->size)
+ < sizeof(struct UDP_ACK_Message) + sizeof(struct GNUNET_MessageHeader))
{
- GNUNET_break_op (0);
+ GNUNET_break_op(0);
return;
}
udp_ack = (const struct UDP_ACK_Message *) msg;
- l_ctx.addr = (const struct sockaddr *) addr;
- l_ctx.addrlen = fromlen;
+
+ l_ctx.address = GNUNET_HELLO_address_allocate (NULL, PLUGIN_NAME,
+ (const struct sockaddr *) addr, fromlen, GNUNET_HELLO_ADDRESS_INFO_NONE);
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_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",
- GNUNET_STRINGS_relative_time_to_string (flow_delay,
- GNUNET_YES));
- s->flow_delay_from_other_peer =
- GNUNET_TIME_relative_to_absolute (flow_delay);
+ LOG(GNUNET_ERROR_TYPE_DEBUG, "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);
ack = (const struct GNUNET_MessageHeader *) &udp_ack[1];
- if (ntohs (ack->size) !=
- ntohs (msg->size) - sizeof (struct UDP_ACK_Message))
+ if (ntohs (ack->size) != ntohs (msg->size) - sizeof(struct UDP_ACK_Message))
{
- GNUNET_break_op (0);
+ GNUNET_break_op(0);
return;
}
- if (0 != memcmp (&l_ctx.res->target, &udp_ack->sender, sizeof (struct
GNUNET_PeerIdentity)))
- GNUNET_break (0);
+ if (0
+ != memcmp (&l_ctx.res->target, &udp_ack->sender,
+ sizeof(struct GNUNET_PeerIdentity)))
+ GNUNET_break(0);
if (GNUNET_OK != GNUNET_FRAGMENT_process_ack (s->frag_ctx->frag, ack))
{
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "UDP processes %u-byte acknowledgement from `%s' at `%s'\n",
- (unsigned int) ntohs (msg->size), GNUNET_i2s (&udp_ack->sender),
- GNUNET_a2s (addr, fromlen));
+ LOG(GNUNET_ERROR_TYPE_DEBUG,
+ "UDP processes %u-byte acknowledgement from `%s' at `%s'\n",
+ (unsigned int ) ntohs (msg->size), GNUNET_i2s (&udp_ack->sender),
+ GNUNET_a2s (addr, fromlen));
/* Expect more ACKs to arrive */
return;
}
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Message full ACK'ed\n",
- (unsigned int) ntohs (msg->size), GNUNET_i2s (&udp_ack->sender),
- GNUNET_a2s (addr, fromlen));
+ LOG(GNUNET_ERROR_TYPE_DEBUG, "Message full ACK'ed\n",
+ (unsigned int ) ntohs (msg->size), GNUNET_i2s (&udp_ack->sender),
+ GNUNET_a2s (addr, fromlen));
/* Remove fragmented message after successful sending */
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;
@@ -2386,17 +2147,15 @@
frc.addr = addr;
frc.addr_len = fromlen;
- LOG (GNUNET_ERROR_TYPE_DEBUG, "UDP processes %u-byte fragment from `%s'\n",
- (unsigned int) ntohs (msg->size),
- GNUNET_a2s (addr, fromlen));
+ 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;
- if (d_ctx == NULL)
+ if (d_ctx == NULL )
{
/* Create a new defragmentation context */
d_ctx = GNUNET_malloc (sizeof (struct DefragContext) + fromlen);
@@ -2404,46 +2163,39 @@
d_ctx->src_addr = (const struct sockaddr *) &d_ctx[1];
d_ctx->addr_len = fromlen;
d_ctx->plugin = plugin;
- d_ctx->defrag =
- GNUNET_DEFRAGMENT_context_create (plugin->env->stats, UDP_MTU,
- UDP_MAX_MESSAGES_IN_DEFRAG, d_ctx,
- &fragment_msg_proc, &ack_proc);
- d_ctx->hnode =
- GNUNET_CONTAINER_heap_insert (plugin->defrag_ctxs, d_ctx,
- (GNUNET_CONTAINER_HeapCostType)
- 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),
- GNUNET_a2s (addr, fromlen));
+ d_ctx->defrag = GNUNET_DEFRAGMENT_context_create (plugin->env->stats,
+ UDP_MTU, UDP_MAX_MESSAGES_IN_DEFRAG, d_ctx, &fragment_msg_proc,
+ &ack_proc);
+ d_ctx->hnode = GNUNET_CONTAINER_heap_insert (plugin->defrag_ctxs, d_ctx,
+ (GNUNET_CONTAINER_HeapCostType) 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), GNUNET_a2s (addr, fromlen));
}
else
{
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Found existing defragmentation context for %u-byte fragment from
`%s'\n",
- (unsigned int) ntohs (msg->size),
- GNUNET_a2s (addr, fromlen));
+ LOG(GNUNET_ERROR_TYPE_DEBUG,
+ "Found existing defragmentation context for %u-byte fragment from
`%s'\n",
+ (unsigned int ) ntohs (msg->size), GNUNET_a2s (addr, fromlen));
}
if (GNUNET_OK == GNUNET_DEFRAGMENT_process_fragment (d_ctx->defrag, msg))
{
/* keep this 'rc' from expiring */
GNUNET_CONTAINER_heap_update_cost (plugin->defrag_ctxs, d_ctx->hnode,
- (GNUNET_CONTAINER_HeapCostType)
- now.abs_value_us);
+ (GNUNET_CONTAINER_HeapCostType) now.abs_value_us);
}
if (GNUNET_CONTAINER_heap_get_size (plugin->defrag_ctxs) >
- UDP_MAX_SENDER_ADDRESSES_WITH_DEFRAG)
+ UDP_MAX_SENDER_ADDRESSES_WITH_DEFRAG)
{
/* remove 'rc' that was inactive the longest */
d_ctx = GNUNET_CONTAINER_heap_remove_root (plugin->defrag_ctxs);
- GNUNET_assert (NULL != d_ctx);
+ GNUNET_assert(NULL != d_ctx);
GNUNET_DEFRAGMENT_context_destroy (d_ctx->defrag);
- GNUNET_free (d_ctx);
+ GNUNET_free(d_ctx);
}
}
-
/**
* Read and process a message from the given socket.
*
@@ -2459,10 +2211,10 @@
ssize_t size;
const struct GNUNET_MessageHeader *msg;
- fromlen = sizeof (addr);
- memset (&addr, 0, sizeof (addr));
- size = GNUNET_NETWORK_socket_recvfrom (rsock, buf, sizeof (buf),
- (struct sockaddr *) &addr, &fromlen);
+ fromlen = sizeof(addr);
+ memset (&addr, 0, sizeof(addr));
+ size = GNUNET_NETWORK_socket_recvfrom (rsock, buf, sizeof(buf),
+ (struct sockaddr *) &addr, &fromlen);
#if MINGW
/* On SOCK_DGRAM UDP sockets recvfrom might fail with a
* WSAECONNRESET error to indicate that previous sendto() (yes, sendto!)
@@ -2475,146 +2227,134 @@
* Unreachable message.
*/
if ( (-1 == size) && (ECONNRESET == errno) )
- return;
+ return;
#endif
if (-1 == size)
{
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "UDP failed to receive data: %s\n", STRERROR (errno));
+ LOG(GNUNET_ERROR_TYPE_DEBUG, "UDP failed to receive data: %s\n",
+ STRERROR (errno));
/* Connection failure or something. Not a protocol violation. */
return;
}
- if (size < sizeof (struct GNUNET_MessageHeader))
+ if (size < sizeof(struct GNUNET_MessageHeader))
{
- LOG (GNUNET_ERROR_TYPE_WARNING,
+ LOG(GNUNET_ERROR_TYPE_WARNING,
"UDP got %u bytes, which is not enough for a GNUnet message header\n",
- (unsigned int) size);
+ (unsigned int ) size);
/* _MAY_ be a connection failure (got partial message) */
/* But it _MAY_ also be that the other side uses non-GNUnet protocol. */
- GNUNET_break_op (0);
+ GNUNET_break_op(0);
return;
}
msg = (const struct GNUNET_MessageHeader *) buf;
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "UDP received %u-byte message from `%s' type %u\n",
- (unsigned int) size,
- GNUNET_a2s ((const struct sockaddr *) &addr, fromlen),
- ntohs (msg->type));
+ LOG(GNUNET_ERROR_TYPE_DEBUG,
+ "UDP received %u-byte message from `%s' type %u\n", (unsigned int ) size,
+ GNUNET_a2s ((const struct sockaddr * ) &addr, fromlen),
+ ntohs (msg->type));
if (size != ntohs (msg->size))
{
- GNUNET_break_op (0);
+ GNUNET_break_op(0);
return;
}
- GNUNET_STATISTICS_update (plugin->env->stats,
- "# UDP, total, bytes, received",
- size, GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats, "# UDP, total, bytes,
received",
+ size, GNUNET_NO);
switch (ntohs (msg->type))
{
case GNUNET_MESSAGE_TYPE_TRANSPORT_BROADCAST_BEACON:
if (GNUNET_YES == plugin->enable_broadcasting_receiving)
- udp_broadcast_receive (plugin, buf, size,
- (const struct sockaddr *) &addr, fromlen);
+ udp_broadcast_receive (plugin, buf, size, (const struct sockaddr *)
&addr,
+ fromlen);
return;
case GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_MESSAGE:
- read_process_msg (plugin, msg,
- (const struct sockaddr *) &addr, fromlen);
+ read_process_msg (plugin, msg, (const struct sockaddr *) &addr, fromlen);
return;
case GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_ACK:
- read_process_ack (plugin, msg,
- (const struct sockaddr *) &addr, fromlen);
+ read_process_ack (plugin, msg, (const struct sockaddr *) &addr, fromlen);
return;
case GNUNET_MESSAGE_TYPE_FRAGMENT:
- read_process_fragment (plugin, msg,
- (const struct sockaddr *) &addr, fromlen);
+ read_process_fragment (plugin, msg, (const struct sockaddr *) &addr,
+ fromlen);
return;
default:
- GNUNET_break_op (0);
+ GNUNET_break_op(0);
return;
}
}
-
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;
udpw = head;
- while (udpw != NULL)
+ while (udpw != NULL )
{
/* Find messages with timeout */
remaining = GNUNET_TIME_absolute_get_remaining (udpw->timeout);
if (GNUNET_TIME_UNIT_ZERO.rel_value_us == remaining.rel_value_us)
{
/* Message timed out */
- switch (udpw->msg_type) {
- case MSG_UNFRAGMENTED:
- GNUNET_STATISTICS_update (plugin->env->stats,
- "# UDP, total, bytes, sent, timeout",
- udpw->msg_size, GNUNET_NO);
- GNUNET_STATISTICS_update (plugin->env->stats,
- "# UDP, total, messages, sent, timeout",
- 1, GNUNET_NO);
- GNUNET_STATISTICS_update (plugin->env->stats,
- "# UDP, unfragmented msgs, messages, sent,
timeout",
- 1, GNUNET_NO);
- GNUNET_STATISTICS_update (plugin->env->stats,
- "# UDP, unfragmented msgs, bytes, sent,
timeout",
- udpw->payload_size, GNUNET_NO);
- /* Not fragmented message */
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Message for peer `%s' with size %u timed out\n",
- GNUNET_i2s(&udpw->session->target), udpw->payload_size);
- call_continuation (udpw, GNUNET_SYSERR);
- /* Remove message */
- dequeue (plugin, udpw);
- GNUNET_free (udpw);
- break;
- case MSG_FRAGMENTED:
- /* Fragmented message */
- GNUNET_STATISTICS_update (plugin->env->stats,
- "# UDP, total, bytes, sent, timeout",
- udpw->frag_ctx->on_wire_size, GNUNET_NO);
- GNUNET_STATISTICS_update (plugin->env->stats,
- "# UDP, total, messages, sent, timeout",
- 1, GNUNET_NO);
- call_continuation (udpw, GNUNET_SYSERR);
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Fragment for message for peer `%s' with size %u timed out\n",
- GNUNET_i2s(&udpw->session->target),
udpw->frag_ctx->payload_size);
+ switch (udpw->msg_type)
+ {
+ case MSG_UNFRAGMENTED:
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, total, bytes, sent, timeout", udpw->msg_size, GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, total, messages, sent, timeout", 1, GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, unfragmented msgs, messages, sent, timeout", 1, GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, unfragmented msgs, bytes, sent, timeout",
+ udpw->payload_size, GNUNET_NO);
+ /* Not fragmented message */
+ LOG(GNUNET_ERROR_TYPE_DEBUG,
+ "Message for peer `%s' with size %u timed out\n",
+ GNUNET_i2s (&udpw->session->target), udpw->payload_size);
+ call_continuation (udpw, GNUNET_SYSERR);
+ /* Remove message */
+ dequeue (plugin, udpw);
+ GNUNET_free(udpw);
+ break;
+ case MSG_FRAGMENTED:
+ /* Fragmented message */
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, total, bytes, sent, timeout", udpw->frag_ctx->on_wire_size,
+ GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, total, messages, sent, timeout", 1, GNUNET_NO);
+ call_continuation (udpw, GNUNET_SYSERR);
+ LOG(GNUNET_ERROR_TYPE_DEBUG,
+ "Fragment for message for peer `%s' with size %u timed out\n",
+ GNUNET_i2s (&udpw->session->target), udpw->frag_ctx->payload_size);
-
- GNUNET_STATISTICS_update (plugin->env->stats,
- "# UDP, fragmented msgs, messages, sent,
timeout",
- 1, GNUNET_NO);
- GNUNET_STATISTICS_update (plugin->env->stats,
- "# UDP, fragmented msgs, bytes, sent,
timeout",
- udpw->frag_ctx->payload_size, GNUNET_NO);
- /* Remove fragmented message due to timeout */
- fragmented_message_done (udpw->frag_ctx, GNUNET_SYSERR);
- break;
- case MSG_ACK:
- GNUNET_STATISTICS_update (plugin->env->stats,
- "# UDP, total, bytes, sent, timeout",
- udpw->msg_size, GNUNET_NO);
- GNUNET_STATISTICS_update (plugin->env->stats,
- "# UDP, total, messages, sent, timeout",
- 1, GNUNET_NO);
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "ACK Message for peer `%s' with size %u timed out\n",
- GNUNET_i2s(&udpw->session->target), udpw->payload_size);
- call_continuation (udpw, GNUNET_SYSERR);
- dequeue (plugin, udpw);
- GNUNET_free (udpw);
- break;
- default:
- break;
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, fragmented msgs, messages, sent, timeout", 1, GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, fragmented msgs, bytes, sent, timeout",
+ udpw->frag_ctx->payload_size, GNUNET_NO);
+ /* Remove fragmented message due to timeout */
+ fragmented_message_done (udpw->frag_ctx, GNUNET_SYSERR);
+ break;
+ case MSG_ACK:
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, total, bytes, sent, timeout", udpw->msg_size, GNUNET_NO);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# UDP, total, messages, sent, timeout", 1, GNUNET_NO);
+ LOG(GNUNET_ERROR_TYPE_DEBUG,
+ "ACK Message for peer `%s' with size %u timed out\n",
+ GNUNET_i2s (&udpw->session->target), udpw->payload_size);
+ call_continuation (udpw, GNUNET_SYSERR);
+ dequeue (plugin, udpw);
+ GNUNET_free(udpw);
+ break;
+ default:
+ break;
}
if (sock == plugin->sockv4)
udpw = plugin->ipv4_queue_head;
@@ -2622,33 +2362,32 @@
udpw = plugin->ipv6_queue_head;
else
{
- GNUNET_break (0); /* should never happen */
+ GNUNET_break(0); /* should never happen */
udpw = NULL;
}
GNUNET_STATISTICS_update (plugin->env->stats,
- "# messages dismissed due to timeout",
- 1, GNUNET_NO);
+ "# messages dismissed due to timeout", 1, GNUNET_NO);
}
else
{
/* Message did not time out, check flow delay */
- remaining = GNUNET_TIME_absolute_get_remaining
(udpw->session->flow_delay_from_other_peer);
+ remaining = GNUNET_TIME_absolute_get_remaining (
+ udpw->session->flow_delay_from_other_peer);
if (GNUNET_TIME_UNIT_ZERO.rel_value_us == remaining.rel_value_us)
{
/* this message is not delayed */
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Message for peer `%s' (%u bytes) is not delayed \n",
- GNUNET_i2s(&udpw->session->target), udpw->payload_size);
+ LOG(GNUNET_ERROR_TYPE_DEBUG,
+ "Message for peer `%s' (%u bytes) is not delayed \n",
+ GNUNET_i2s (&udpw->session->target), udpw->payload_size);
break; /* Found message to send, break */
}
else
{
/* Message is delayed, try next */
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "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));
+ LOG(GNUNET_ERROR_TYPE_DEBUG,
+ "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;
}
}
@@ -2656,55 +2395,52 @@
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;
- type = plugin->env->get_address_type (plugin->env->cls,sa, slen);
- 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
- */
+ type = plugin->env->get_address_type (plugin->env->cls, sa, slen);
+ 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));
- }
-}
+ 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)
{
@@ -2715,53 +2451,51 @@
struct UDP_MessageWrapper *udpw = NULL;
/* 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->sock_addr;
- slen = udpw->session->addrlen;
+ sa = udpw->session->address->address;
+ slen = udpw->session->address->address_length;
- sent = GNUNET_NETWORK_socket_sendto (sock, udpw->msg_buf, udpw->msg_size,
sa, slen);
+ sent = GNUNET_NETWORK_socket_sendto (sock, udpw->msg_buf, udpw->msg_size, sa,
+ slen);
if (GNUNET_SYSERR == sent)
{
/* Failure */
analyze_send_error (plugin, sa, slen, errno);
- call_continuation(udpw, GNUNET_SYSERR);
+ call_continuation (udpw, GNUNET_SYSERR);
GNUNET_STATISTICS_update (plugin->env->stats,
- "# UDP, total, bytes, sent, failure",
- sent, GNUNET_NO);
+ "# UDP, total, bytes, sent, failure", sent, GNUNET_NO);
GNUNET_STATISTICS_update (plugin->env->stats,
- "# UDP, total, messages, sent, failure",
- 1, GNUNET_NO);
+ "# UDP, total, messages, sent, failure", 1, GNUNET_NO);
}
else
{
/* Success */
- 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,
- (sent < 0) ? STRERROR (errno) : "ok");
+ 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,
+ (sent < 0) ? STRERROR (errno) : "ok");
GNUNET_STATISTICS_update (plugin->env->stats,
- "# UDP, total, bytes, sent, success",
- sent, GNUNET_NO);
+ "# UDP, total, bytes, sent, success", sent, GNUNET_NO);
GNUNET_STATISTICS_update (plugin->env->stats,
- "# UDP, total, messages, sent, success",
- 1, GNUNET_NO);
+ "# UDP, total, messages, sent, success", 1, GNUNET_NO);
if (NULL != udpw->frag_ctx)
- udpw->frag_ctx->on_wire_size += udpw->msg_size;
+ udpw->frag_ctx->on_wire_size += udpw->msg_size;
call_continuation (udpw, GNUNET_OK);
}
dequeue (plugin, udpw);
- GNUNET_free (udpw);
+ GNUNET_free(udpw);
udpw = NULL;
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
@@ -2778,19 +2512,17 @@
plugin->select_task = GNUNET_SCHEDULER_NO_TASK;
if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
return;
- if ( (0 != (tc->reason & GNUNET_SCHEDULER_REASON_READ_READY)) &&
- (NULL != plugin->sockv4) &&
- (GNUNET_NETWORK_fdset_isset (tc->read_ready, plugin->sockv4)) )
+ if ((0 != (tc->reason & GNUNET_SCHEDULER_REASON_READ_READY))
+ && (NULL != plugin->sockv4)
+ && (GNUNET_NETWORK_fdset_isset (tc->read_ready, plugin->sockv4)))
udp_select_read (plugin, plugin->sockv4);
- if ( (0 != (tc->reason & GNUNET_SCHEDULER_REASON_WRITE_READY)) &&
- (NULL != plugin->sockv4) &&
- (NULL != plugin->ipv4_queue_head) &&
- (GNUNET_NETWORK_fdset_isset (tc->write_ready, plugin->sockv4)) )
+ if ((0 != (tc->reason & GNUNET_SCHEDULER_REASON_WRITE_READY))
+ && (NULL != plugin->sockv4) && (NULL != plugin->ipv4_queue_head)
+ && (GNUNET_NETWORK_fdset_isset (tc->write_ready, plugin->sockv4)))
udp_select_send (plugin, plugin->sockv4);
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
@@ -2807,26 +2539,23 @@
plugin->select_task_v6 = GNUNET_SCHEDULER_NO_TASK;
if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
return;
- if ( ((tc->reason & GNUNET_SCHEDULER_REASON_READ_READY) != 0) &&
- (NULL != plugin->sockv6) &&
- (GNUNET_NETWORK_fdset_isset (tc->read_ready, plugin->sockv6)) )
+ if (((tc->reason & GNUNET_SCHEDULER_REASON_READ_READY) != 0)
+ && (NULL != plugin->sockv6)
+ && (GNUNET_NETWORK_fdset_isset (tc->read_ready, plugin->sockv6)))
udp_select_read (plugin, plugin->sockv6);
- if ( (0 != (tc->reason & GNUNET_SCHEDULER_REASON_WRITE_READY)) &&
- (NULL != plugin->sockv6) && (plugin->ipv6_queue_head != NULL) &&
- (GNUNET_NETWORK_fdset_isset (tc->write_ready, plugin->sockv6)) )
- udp_select_send (plugin, plugin->sockv6);
+ if ((0 != (tc->reason & GNUNET_SCHEDULER_REASON_WRITE_READY))
+ && (NULL != plugin->sockv6) && (plugin->ipv6_queue_head != NULL )&&
+ (GNUNET_NETWORK_fdset_isset (tc->write_ready, plugin->sockv6))
)udp_select_send (plugin, plugin->sockv6);
schedule_select (plugin);
}
-
/**
*
* @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;
@@ -2845,46 +2574,52 @@
plugin->sockv6 = GNUNET_NETWORK_socket_create (PF_INET6, SOCK_DGRAM, 0);
if (NULL == plugin->sockv6)
{
- LOG (GNUNET_ERROR_TYPE_WARNING, "Disabling IPv6 since it is not
supported on this system!\n");
+ LOG(GNUNET_ERROR_TYPE_WARNING,
+ "Disabling IPv6 since it is not supported on this system!\n");
plugin->enable_ipv6 = GNUNET_NO;
}
else
{
- memset (&server_addrv6, '\0', sizeof (struct sockaddr_in6));
+ memset (&server_addrv6, '\0', sizeof(struct sockaddr_in6));
#if HAVE_SOCKADDR_IN_SIN_LEN
server_addrv6.sin6_len = sizeof (struct sockaddr_in6);
#endif
server_addrv6.sin6_family = AF_INET6;
if (NULL != bind_v6)
- server_addrv6.sin6_addr = bind_v6->sin6_addr;
+ server_addrv6.sin6_addr = bind_v6->sin6_addr;
else
- server_addrv6.sin6_addr = in6addr_any;
+ server_addrv6.sin6_addr = in6addr_any;
if (0 == plugin->port) /* autodetect */
- server_addrv6.sin6_port = htons (GNUNET_CRYPTO_random_u32
(GNUNET_CRYPTO_QUALITY_STRONG, 33537) + 32000);
+ server_addrv6.sin6_port = htons (
+ GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_STRONG, 33537)
+ + 32000);
else
- server_addrv6.sin6_port = htons (plugin->port);
- addrlen = sizeof (struct sockaddr_in6);
+ server_addrv6.sin6_port = htons (plugin->port);
+ addrlen = sizeof(struct sockaddr_in6);
server_addr = (struct sockaddr *) &server_addrv6;
tries = 0;
while (tries < 10)
{
- LOG (GNUNET_ERROR_TYPE_DEBUG, "Binding to IPv6 `%s'\n",
- GNUNET_a2s (server_addr, addrlen));
- /* binding */
- if (GNUNET_OK == GNUNET_NETWORK_socket_bind (plugin->sockv6,
- server_addr,
addrlen))
- break;
- eno = errno;
- if (0 != plugin->port)
- {
- tries = 10; /* fail */
- break; /* bind failed on specific port */
- }
- /* autodetect */
- server_addrv6.sin6_port = htons (GNUNET_CRYPTO_random_u32
(GNUNET_CRYPTO_QUALITY_STRONG, 33537) + 32000);
- tries ++;
+ LOG(GNUNET_ERROR_TYPE_DEBUG, "Binding to IPv6 `%s'\n",
+ GNUNET_a2s (server_addr, addrlen));
+ /* binding */
+ if (GNUNET_OK
+ == GNUNET_NETWORK_socket_bind (plugin->sockv6, server_addr,
+ addrlen))
+ break;
+ eno = errno;
+ if (0 != plugin->port)
+ {
+ tries = 10; /* fail */
+ break; /* bind failed on specific port */
+ }
+ /* autodetect */
+ server_addrv6.sin6_port = htons (
+ GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_STRONG, 33537)
+ + 32000);
+ tries++;
}
if (tries >= 10)
{
@@ -2893,21 +2628,18 @@
plugin->sockv6 = NULL;
}
- if (plugin->sockv6 != NULL)
+ if (plugin->sockv6 != NULL )
{
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "IPv6 socket created on port %s\n",
- GNUNET_a2s (server_addr, addrlen));
+ LOG(GNUNET_ERROR_TYPE_DEBUG, "IPv6 socket created on port %s\n",
+ GNUNET_a2s (server_addr, addrlen));
addrs[sockets_created] = (struct sockaddr *) &server_addrv6;
- addrlens[sockets_created] = sizeof (struct sockaddr_in6);
+ addrlens[sockets_created] = sizeof(struct sockaddr_in6);
sockets_created++;
}
else
{
- LOG (GNUNET_ERROR_TYPE_ERROR,
- "Failed to bind UDP socket to %s: %s\n",
- GNUNET_a2s (server_addr, addrlen),
- STRERROR (eno));
+ LOG(GNUNET_ERROR_TYPE_ERROR, "Failed to bind UDP socket to %s: %s\n",
+ GNUNET_a2s (server_addr, addrlen), STRERROR (eno));
}
}
}
@@ -2917,13 +2649,14 @@
plugin->sockv4 = GNUNET_NETWORK_socket_create (PF_INET, SOCK_DGRAM, 0);
if (NULL == plugin->sockv4)
{
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "socket");
- LOG (GNUNET_ERROR_TYPE_WARNING, "Disabling IPv4 since it is not supported
on this system!\n");
+ GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "socket");
+ LOG(GNUNET_ERROR_TYPE_WARNING,
+ "Disabling IPv4 since it is not supported on this system!\n");
plugin->enable_ipv4 = GNUNET_NO;
}
else
{
- memset (&server_addrv4, '\0', sizeof (struct sockaddr_in));
+ memset (&server_addrv4, '\0', sizeof(struct sockaddr_in));
#if HAVE_SOCKADDR_IN_SIN_LEN
server_addrv4.sin_len = sizeof (struct sockaddr_in);
#endif
@@ -2935,34 +2668,37 @@
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);
-
- addrlen = sizeof (struct sockaddr_in);
+ addrlen = sizeof(struct sockaddr_in);
server_addr = (struct sockaddr *) &server_addrv4;
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 == GNUNET_NETWORK_socket_bind (plugin->sockv4,
- server_addr, addrlen))
- break;
+ if (GNUNET_OK
+ == GNUNET_NETWORK_socket_bind (plugin->sockv4, server_addr, addrlen))
+ break;
eno = errno;
if (0 != plugin->port)
{
- tries = 10; /* fail */
- break; /* bind failed on specific port */
+ tries = 10; /* fail */
+ break; /* bind failed on specific port */
}
/* autodetect */
- server_addrv4.sin_port = htons (GNUNET_CRYPTO_random_u32
(GNUNET_CRYPTO_QUALITY_STRONG, 33537) + 32000);
- tries ++;
+ server_addrv4.sin_port = htons (
+ GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_STRONG, 33537)
+ + 32000);
+ tries++;
}
if (tries >= 10)
@@ -2972,40 +2708,39 @@
plugin->sockv4 = NULL;
}
- if (plugin->sockv4 != NULL)
+ if (plugin->sockv4 != NULL )
{
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "IPv4 socket created on port %s\n", GNUNET_a2s (server_addr,
addrlen));
+ LOG(GNUNET_ERROR_TYPE_DEBUG, "IPv4 socket created on port %s\n",
+ GNUNET_a2s (server_addr, addrlen));
addrs[sockets_created] = (struct sockaddr *) &server_addrv4;
- addrlens[sockets_created] = sizeof (struct sockaddr_in);
+ addrlens[sockets_created] = sizeof(struct sockaddr_in);
sockets_created++;
}
else
{
- LOG (GNUNET_ERROR_TYPE_ERROR,
- "Failed to bind UDP socket to %s: %s\n",
- GNUNET_a2s (server_addr, addrlen), STRERROR (eno));
+ LOG(GNUNET_ERROR_TYPE_ERROR, "Failed to bind UDP socket to %s: %s\n",
+ GNUNET_a2s (server_addr, addrlen), STRERROR (eno));
}
}
if (0 == sockets_created)
{
- LOG (GNUNET_ERROR_TYPE_WARNING, _("Failed to open UDP
sockets\n"));
- return 0; /* No sockets created, return */
+ LOG(GNUNET_ERROR_TYPE_WARNING, _("Failed to open UDP sockets\n"));
+ return 0; /* No sockets created, return */
}
/* Create file descriptors */
if (plugin->enable_ipv4 == GNUNET_YES)
{
- plugin->rs_v4 = GNUNET_NETWORK_fdset_create ();
- plugin->ws_v4 = GNUNET_NETWORK_fdset_create ();
- GNUNET_NETWORK_fdset_zero (plugin->rs_v4);
- GNUNET_NETWORK_fdset_zero (plugin->ws_v4);
- if (NULL != plugin->sockv4)
- {
- GNUNET_NETWORK_fdset_set (plugin->rs_v4,
plugin->sockv4);
- GNUNET_NETWORK_fdset_set (plugin->ws_v4,
plugin->sockv4);
- }
+ plugin->rs_v4 = GNUNET_NETWORK_fdset_create ();
+ plugin->ws_v4 = GNUNET_NETWORK_fdset_create ();
+ GNUNET_NETWORK_fdset_zero (plugin->rs_v4);
+ GNUNET_NETWORK_fdset_zero (plugin->ws_v4);
+ if (NULL != plugin->sockv4)
+ {
+ GNUNET_NETWORK_fdset_set (plugin->rs_v4, plugin->sockv4);
+ GNUNET_NETWORK_fdset_set (plugin->ws_v4, plugin->sockv4);
+ }
}
if (plugin->enable_ipv6 == GNUNET_YES)
@@ -3022,16 +2757,13 @@
}
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);
+ 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);
return sockets_created;
}
-
/**
* The exported method. Makes the core api available via a global and
* returns the udp transport API.
@@ -3064,7 +2796,7 @@
if (NULL == env->receive)
{
/* run in 'stub' mode (i.e. as part of gnunet-peerinfo), don't fully
- initialze the plugin or the API */
+ initialze the plugin or the API */
api = GNUNET_new (struct GNUNET_TRANSPORT_PluginFunctions);
api->cls = NULL;
api->address_pretty_printer = &udp_plugin_address_pretty_printer;
@@ -3073,106 +2805,105 @@
return api;
}
- GNUNET_assert (NULL != env->stats);
+ 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))
+ memset (&server_addrv4, 0, sizeof(server_addrv4));
+ 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);
+ 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))
+ memset (&server_addrv6, 0, sizeof(server_addrv6));
+ 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);
- if (1 !=
- inet_pton (AF_INET6, bind6_address, &server_addrv6.sin6_addr))
+ 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;
/* Enable neighbour discovery */
- enable_broadcasting = GNUNET_CONFIGURATION_get_value_yesno (env->cfg,
"transport-udp",
- "BROADCAST");
+ enable_broadcasting = GNUNET_CONFIGURATION_get_value_yesno (env->cfg,
+ "transport-udp", "BROADCAST");
if (enable_broadcasting == GNUNET_SYSERR)
enable_broadcasting = GNUNET_NO;
- enable_broadcasting_recv = GNUNET_CONFIGURATION_get_value_yesno (env->cfg,
"transport-udp",
- "BROADCAST_RECEIVE");
+ enable_broadcasting_recv = GNUNET_CONFIGURATION_get_value_yesno (env->cfg,
+ "transport-udp", "BROADCAST_RECEIVE");
if (enable_broadcasting_recv == GNUNET_SYSERR)
enable_broadcasting_recv = GNUNET_YES;
- if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string (env->cfg,
"transport-udp",
- "BROADCAST_INTERVAL",
&fancy_interval))
+ if (GNUNET_SYSERR
+ == GNUNET_CONFIGURATION_get_value_string (env->cfg, "transport-udp",
+ "BROADCAST_INTERVAL", &fancy_interval))
{
interval = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10);
}
else
{
- if (GNUNET_SYSERR ==
GNUNET_STRINGS_fancy_time_to_relative(fancy_interval, &interval))
- {
- interval = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30);
- }
- GNUNET_free (fancy_interval);
+ if (GNUNET_SYSERR
+ == GNUNET_STRINGS_fancy_time_to_relative (fancy_interval, &interval))
+ {
+ interval = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30);
+ }
+ GNUNET_free(fancy_interval);
}
/* 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 */
+ udp_max_bps = 1024 * 1024 * 50; /* 50 MB/s == infinity for practical
purposes */
}
p = GNUNET_new (struct Plugin);
@@ -3185,7 +2916,8 @@
p->enable_broadcasting_receiving = enable_broadcasting_recv;
p->env = env;
p->sessions = GNUNET_CONTAINER_multipeermap_create (10, GNUNET_NO);
- p->defrag_ctxs = GNUNET_CONTAINER_heap_create
(GNUNET_CONTAINER_HEAP_ORDER_MIN);
+ 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_value_init ((uint32_t) udp_max_bps), 30);
@@ -3197,7 +2929,7 @@
if ((res == 0) || ((p->sockv4 == NULL )&& (p->sockv6 == NULL)))
{
LOG (GNUNET_ERROR_TYPE_ERROR,
- _("Failed to create network sockets, plugin failed\n"));
+ _("Failed to create network sockets, plugin failed\n"));
GNUNET_CONTAINER_multipeermap_destroy (p->sessions);
GNUNET_CONTAINER_heap_destroy (p->defrag_ctxs);
GNUNET_SERVER_mst_destroy (p->mst);
@@ -3225,23 +2957,19 @@
return api;
}
-
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;
GNUNET_CONTAINER_heap_remove_node (node);
- GNUNET_DEFRAGMENT_context_destroy(d_ctx->defrag);
- GNUNET_free (d_ctx);
+ GNUNET_DEFRAGMENT_context_destroy (d_ctx->defrag);
+ GNUNET_free(d_ctx);
return GNUNET_YES;
}
-
/**
* The exported method. Makes the core api available via a global and
* returns the udp transport API.
@@ -3259,17 +2987,17 @@
if (NULL == plugin)
{
- GNUNET_free (api);
- return NULL;
+ GNUNET_free(api);
+ return NULL ;
}
stop_broadcast (plugin);
- if (plugin->select_task != GNUNET_SCHEDULER_NO_TASK)
+ if (plugin->select_task != GNUNET_SCHEDULER_NO_TASK )
{
GNUNET_SCHEDULER_cancel (plugin->select_task);
plugin->select_task = GNUNET_SCHEDULER_NO_TASK;
}
- if (plugin->select_task_v6 != GNUNET_SCHEDULER_NO_TASK)
+ if (plugin->select_task_v6 != GNUNET_SCHEDULER_NO_TASK )
{
GNUNET_SCHEDULER_cancel (plugin->select_task_v6);
plugin->select_task_v6 = GNUNET_SCHEDULER_NO_TASK;
@@ -3280,7 +3008,7 @@
{
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);
@@ -3290,7 +3018,7 @@
{
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);
@@ -3304,60 +3032,60 @@
}
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 (plugin->mst != NULL )
{
- GNUNET_SERVER_mst_destroy(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 (udpw != NULL )
{
struct UDP_MessageWrapper *tmp = udpw->next;
dequeue (plugin, udpw);
- call_continuation(udpw, GNUNET_SYSERR);
- GNUNET_free (udpw);
+ call_continuation (udpw, GNUNET_SYSERR);
+ GNUNET_free(udpw);
udpw = tmp;
}
udpw = plugin->ipv6_queue_head;
- while (udpw != NULL)
+ while (udpw != NULL )
{
struct UDP_MessageWrapper *tmp = udpw->next;
dequeue (plugin, udpw);
- call_continuation(udpw, GNUNET_SYSERR);
- GNUNET_free (udpw);
+ call_continuation (udpw, GNUNET_SYSERR);
+ GNUNET_free(udpw);
udpw = tmp;
}
/* Clean up sessions */
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Cleaning up sessions\n");
- GNUNET_CONTAINER_multipeermap_iterate (plugin->sessions,
&disconnect_and_free_it, plugin);
+ LOG(GNUNET_ERROR_TYPE_DEBUG, "Cleaning up sessions\n");
+ GNUNET_CONTAINER_multipeermap_iterate (plugin->sessions,
+ &disconnect_and_free_it, plugin);
GNUNET_CONTAINER_multipeermap_destroy (plugin->sessions);
next = ppc_dll_head;
for (cur = next; NULL != cur; cur = next)
{
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);
+ GNUNET_free(cur);
+ GNUNET_break(0);
}
plugin->nat = NULL;
- GNUNET_free (plugin);
- GNUNET_free (api);
+ GNUNET_free(plugin);
+ GNUNET_free(api);
#if DEBUG_MALLOC
struct Allocation *allocation;
while (NULL != ahead)
@@ -3374,8 +3102,7 @@
GNUNET_free (allocator);
}
#endif
- return NULL;
+ return NULL ;
}
-
/* end of plugin_transport_udp.c */
Modified: gnunet/src/transport/plugin_transport_udp.h
===================================================================
--- gnunet/src/transport/plugin_transport_udp.h 2014-01-13 16:56:41 UTC (rev
31885)
+++ gnunet/src/transport/plugin_transport_udp.h 2014-01-13 16:59:57 UTC (rev
31886)
@@ -41,6 +41,8 @@
#define LOG(kind,...) GNUNET_log_from (kind, "transport-udp", __VA_ARGS__)
+#define PLUGIN_NAME "udp"
+
#define DEBUG_UDP GNUNET_NO
#define DEBUG_UDP_BROADCASTING GNUNET_NO
Modified: gnunet/src/transport/plugin_transport_udp_broadcasting.c
===================================================================
--- gnunet/src/transport/plugin_transport_udp_broadcasting.c 2014-01-13
16:56:41 UTC (rev 31885)
+++ gnunet/src/transport/plugin_transport_udp_broadcasting.c 2014-01-13
16:59:57 UTC (rev 31886)
@@ -135,6 +135,7 @@
{
struct Plugin *plugin = cls;
struct Mstv6Context *mc = client;
+ struct GNUNET_HELLO_Address *address;
const struct GNUNET_MessageHeader *hello;
const struct UDP_Beacon_Message *msg;
struct GNUNET_ATS_Information atsi;
@@ -155,19 +156,12 @@
GNUNET_break (ntohl(mc->ats_address_network_type) !=
GNUNET_ATS_NET_UNSPECIFIED);
hello = (struct GNUNET_MessageHeader *) &msg[1];
- plugin->env->receive (plugin->env->cls,
- &msg->sender,
- hello,
- NULL,
- (const char *) &mc->addr,
- sizeof (mc->addr));
- plugin->env->update_address_metrics (plugin->env->cls,
- &msg->sender,
- (const char *) &mc->addr,
- sizeof (mc->addr),
- NULL,
- &atsi, 1);
-
+ address = GNUNET_HELLO_address_allocate (&msg->sender, PLUGIN_NAME,
+ (const char *) &mc->addr, sizeof (mc->addr),
GNUNET_HELLO_ADDRESS_INFO_INBOUND);
+ plugin->env->receive (plugin->env->cls, address, NULL, hello);
+ plugin->env->update_address_metrics (plugin->env->cls, address,
+ NULL, &atsi, 1);
+ GNUNET_HELLO_address_free (address);
GNUNET_STATISTICS_update (plugin->env->stats,
_
("# IPv6 multicast HELLO beacons received via
udp"),
@@ -183,6 +177,7 @@
{
struct Plugin *plugin = cls;
struct Mstv4Context *mc = client;
+ struct GNUNET_HELLO_Address *address;
const struct GNUNET_MessageHeader *hello;
const struct UDP_Beacon_Message *msg;
struct GNUNET_ATS_Information atsi;
@@ -204,20 +199,13 @@
GNUNET_break (ntohl(mc->ats_address_network_type) !=
GNUNET_ATS_NET_UNSPECIFIED);
hello = (struct GNUNET_MessageHeader *) &msg[1];
- plugin->env->receive (plugin->env->cls,
- &msg->sender,
- hello,
- NULL,
- (const char *) &mc->addr,
- sizeof (mc->addr));
+ address = GNUNET_HELLO_address_allocate (&msg->sender, PLUGIN_NAME,
+ (const char *) &mc->addr, sizeof (mc->addr),
GNUNET_HELLO_ADDRESS_INFO_INBOUND);
+ plugin->env->receive (plugin->env->cls, address, NULL, hello);
+ plugin->env->update_address_metrics (plugin->env->cls, address,
+ NULL, &atsi, 1);
+ GNUNET_HELLO_address_free (address);
- plugin->env->update_address_metrics (plugin->env->cls,
- &msg->sender,
- (const char *) &mc->addr,
- sizeof (mc->addr),
- NULL,
- &atsi, 1);
-
GNUNET_STATISTICS_update (plugin->env->stats,
_("# IPv4 broadcast HELLO beacons received via
udp"),
1, GNUNET_NO);
Modified: gnunet/src/transport/plugin_transport_unix.c
===================================================================
--- gnunet/src/transport/plugin_transport_unix.c 2014-01-13 16:56:41 UTC
(rev 31885)
+++ gnunet/src/transport/plugin_transport_unix.c 2014-01-13 16:59:57 UTC
(rev 31886)
@@ -103,12 +103,8 @@
struct Plugin * plugin;
- struct UnixAddress *addr;
+ struct GNUNET_HELLO_Address *address;
- size_t addrlen;
-
- int inbound;
-
/**
* Session timeout task
*/
@@ -468,17 +464,9 @@
/**
* Location to store the session, if found.
*/
- struct Session *s;
+ struct Session *res;
- /**
- * Address we are looking for.
- */
- const struct UnixAddress *ua;
-
- /**
- * Number of bytes in @e ua
- */
- size_t ua_len;
+ struct GNUNET_HELLO_Address *address;
};
@@ -496,20 +484,13 @@
void *value)
{
struct LookupCtx *lctx = cls;
- struct Session *t = value;
+ struct Session *s = value;
- if (t->addrlen != lctx->ua_len)
+ if (0 == GNUNET_HELLO_address_cmp (lctx->address, s->address))
{
- GNUNET_break (0);
- return GNUNET_YES;
- }
-
- if (0 == memcmp (t->addr, lctx->ua, lctx->ua_len))
- {
- lctx->s = t;
+ lctx->res = s;
return GNUNET_NO;
}
- GNUNET_break (0);
return GNUNET_YES;
}
@@ -525,18 +506,16 @@
*/
static struct Session *
lookup_session (struct Plugin *plugin,
- const struct GNUNET_PeerIdentity *sender,
- const struct UnixAddress *ua, size_t ua_len)
+ struct GNUNET_HELLO_Address *address)
{
struct LookupCtx lctx;
- lctx.s = NULL;
- lctx.ua = ua;
- lctx.ua_len = ua_len;
+ lctx.address = address;
+ lctx.res = NULL;
GNUNET_CONTAINER_multipeermap_get_multiple (plugin->session_map,
- sender,
+ &address->peer,
&lookup_session_it, &lctx);
- return lctx.s;
+ return lctx.res;
}
@@ -561,7 +540,7 @@
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Disconnecting session for peer `%s' `%s'\n",
GNUNET_i2s (&s->target),
- s->addr);
+ unix_address_to_string (NULL, s->address->address,
s->address->address_length) );
plugin->env->session_end (plugin->env->cls, &s->target, s);
removed = GNUNET_NO;
next = plugin->msg_head;
@@ -594,6 +573,7 @@
GNUNET_SCHEDULER_cancel (s->timeout_task);
s->timeout_task = GNUNET_SCHEDULER_NO_TASK;
}
+ GNUNET_HELLO_address_free (s->address);
GNUNET_free (s);
return GNUNET_OK;
}
@@ -746,12 +726,7 @@
/**
* Address information.
*/
- const char *address;
-
- /**
- * Number of bytes in @e address
- */
- size_t addrlen;
+ const struct GNUNET_HELLO_Address *address;
};
@@ -771,8 +746,7 @@
struct GetSessionIteratorContext *gsi = cls;
struct Session *s = value;
- if ((GNUNET_NO == s->inbound) && (gsi->addrlen == s->addrlen) &&
- (0 == memcmp (gsi->address, s->addr, s->addrlen)) )
+ if (0 == GNUNET_HELLO_address_cmp(s->address, gsi->address))
{
gsi->res = s;
return GNUNET_NO;
@@ -868,27 +842,23 @@
}
/* Check if already existing */
- gsi.address = (const char *) address->address;
- gsi.addrlen = address->address_length;
+ gsi.address = address;
gsi.res = NULL;
GNUNET_CONTAINER_multipeermap_get_multiple (plugin->session_map,
&address->peer,
&get_session_it, &gsi);
if (NULL != gsi.res)
{
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Found existing session\n");
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Found existing session %p for address
`%s'\n",
+ gsi.res,
+ unix_address_to_string (NULL, address->address,
address->address_length));
return gsi.res;
}
/* create a new session */
- s = GNUNET_malloc (sizeof (struct Session) + address->address_length);
- s->addr = (struct UnixAddress *) &s[1];
- s->addrlen = address->address_length;
- s->plugin = plugin;
- s->inbound = GNUNET_NO;
- memcpy (s->addr, address->address, address->address_length);
- memcpy (&s->target, &address->peer, sizeof (struct GNUNET_PeerIdentity));
+ s = GNUNET_new (struct Session);
+ s->target = address->peer;
+ s->address = GNUNET_HELLO_address_copy (address);
GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == s->timeout_task);
s->timeout_task = GNUNET_SCHEDULER_add_delayed
(GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
&session_timeout,
@@ -918,7 +888,6 @@
&session->target,
session))
return;
-
reschedule_session_timeout (session);
}
@@ -970,7 +939,8 @@
LOG (GNUNET_ERROR_TYPE_ERROR,
"Invalid session for peer `%s' `%s'\n",
GNUNET_i2s (&session->target),
- (const char *) session->addr);
+ unix_address_to_string(NULL, session->address->address,
+ session->address->address_length));
GNUNET_break (0);
return GNUNET_SYSERR;
}
@@ -978,7 +948,8 @@
"Sending %u bytes with session for peer `%s' `%s'\n",
msgbuf_size,
GNUNET_i2s (&session->target),
- (const char *) session->addr);
+ unix_address_to_string(NULL, session->address->address,
+ session->address->address_length));
ssize = sizeof (struct UNIXMessage) + msgbuf_size;
message = GNUNET_malloc (sizeof (struct UNIXMessage) + msgbuf_size);
message->header.size = htons (ssize);
@@ -1025,7 +996,7 @@
const struct UnixAddress *ua, size_t ua_len)
{
struct Session *s = NULL;
- struct GNUNET_HELLO_Address * addr;
+ struct GNUNET_HELLO_Address *address;
GNUNET_break (ntohl(plugin->ats_network.value) !=
GNUNET_ATS_NET_UNSPECIFIED);
GNUNET_assert (ua_len >= sizeof (struct UnixAddress));
@@ -1037,31 +1008,23 @@
ntohs (currhdr->size),
GNUNET_NO);
- addr = GNUNET_HELLO_address_allocate (sender,
- "unix",
- ua,
- ua_len);
- s = lookup_session (plugin, sender, ua, ua_len);
+ /* Look for existing session */
+ address = GNUNET_HELLO_address_allocate (sender, PLUGIN_NAME, ua, ua_len,
+ GNUNET_HELLO_ADDRESS_INFO_NONE); /* UNIX does not have "inbound"
sessions */
+ s = lookup_session (plugin, address);
+
if (NULL == s)
{
- s = unix_plugin_get_session (plugin, addr);
- s->inbound = GNUNET_YES;
+ s = unix_plugin_get_session (plugin, address);
/* Notify transport and ATS about new inbound session */
- plugin->env->session_start (NULL, sender,
- PLUGIN_NAME, ua, ua_len, s, &plugin->ats_network, 1);
+ plugin->env->session_start (NULL, s->address, s, &plugin->ats_network, 1);
}
+ GNUNET_HELLO_address_free (address);
reschedule_session_timeout (s);
- plugin->env->receive (plugin->env->cls, sender, currhdr, s,
- (GNUNET_YES == s->inbound) ? NULL : (const char *) ua,
- (GNUNET_YES == s->inbound) ? 0 :
ua_len);
-
- plugin->env->update_address_metrics (plugin->env->cls, sender,
- (GNUNET_YES == s->inbound) ? NULL :
(const char *) ua,
- (GNUNET_YES == s->inbound) ? 0 : ua_len,
- s, &plugin->ats_network, 1);
-
- GNUNET_free (addr);
+ plugin->env->receive (plugin->env->cls, s->address, s, currhdr);
+ plugin->env->update_address_metrics (plugin->env->cls, s->address, s,
+ &plugin->ats_network, 1);
}
@@ -1193,8 +1156,8 @@
msgw->msgsize,
msgw->priority,
msgw->timeout,
- msgw->session->addr,
- msgw->session->addrlen,
+ msgw->session->address->address,
+ msgw->session->address->address_length,
msgw->payload,
msgw->cont, msgw->cont_cls);
@@ -1517,6 +1480,7 @@
const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct Plugin *plugin = cls;
+ struct GNUNET_HELLO_Address *address;
size_t len;
struct UnixAddress *ua;
@@ -1527,16 +1491,19 @@
memcpy (&ua[1], plugin->unix_socket_path, strlen (plugin->unix_socket_path)
+ 1);
plugin->address_update_task = GNUNET_SCHEDULER_NO_TASK;
- plugin->env->notify_address (plugin->env->cls, GNUNET_YES,
- ua, len, "unix");
+ address = GNUNET_HELLO_address_allocate (plugin->env->my_identity,
+ PLUGIN_NAME, ua, len, GNUNET_HELLO_ADDRESS_INFO_NONE);
+
+ plugin->env->notify_address (plugin->env->cls, GNUNET_YES, address);
GNUNET_free (ua);
+ GNUNET_free (address);
}
/**
* Increment session timeout due to activity
*
- * @param s session for which the timeout should be moved
+ * @param res session for which the timeout should be moved
*/
static void
reschedule_session_timeout (struct Session *s)
@@ -1672,6 +1639,7 @@
{
struct GNUNET_TRANSPORT_PluginFunctions *api = cls;
struct Plugin *plugin = api->cls;
+ struct GNUNET_HELLO_Address *address;
struct UNIXMessageWrapper * msgw;
struct UnixAddress *ua;
size_t len;
@@ -1687,10 +1655,13 @@
ua->options = htonl (myoptions);
ua->addrlen = htonl(strlen (plugin->unix_socket_path) + 1);
memcpy (&ua[1], plugin->unix_socket_path, strlen (plugin->unix_socket_path)
+ 1);
+ address = GNUNET_HELLO_address_allocate (plugin->env->my_identity,
+ PLUGIN_NAME, ua, len, GNUNET_HELLO_ADDRESS_INFO_NONE);
+ plugin->env->notify_address (plugin->env->cls, GNUNET_NO, address);
- plugin->env->notify_address (plugin->env->cls, GNUNET_NO,
-
ua, len, "unix");
+ GNUNET_free (address);
GNUNET_free (ua);
+
while (NULL != (msgw = plugin->msg_head))
{
GNUNET_CONTAINER_DLL_remove (plugin->msg_head, plugin->msg_tail, msgw);
Modified: gnunet/src/transport/plugin_transport_wlan.c
===================================================================
--- gnunet/src/transport/plugin_transport_wlan.c 2014-01-13 16:56:41 UTC
(rev 31885)
+++ gnunet/src/transport/plugin_transport_wlan.c 2014-01-13 16:59:57 UTC
(rev 31886)
@@ -351,8 +351,10 @@
/**
* peer mac address
*/
- struct WlanAddress addr;
+ //struct WlanAddress addr;
+ struct GNUNET_HELLO_Address *address;
+
/**
* Inbound or outbound session
*/
@@ -612,8 +614,8 @@
get_radiotap_header (endpoint, radio_header, size);
get_wlan_header (endpoint->plugin,
&radio_header->frame,
- &endpoint->addr.mac,
- size);
+ endpoint->address->address,
+ endpoint->address->address_length);
memcpy (&radio_header[1], hdr, msize);
if (NULL !=
GNUNET_HELPER_send (endpoint->plugin->suid_helper,
@@ -789,10 +791,11 @@
GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
&session_timeout, session);
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Created new %s session %p for peer `%s' with endpoint %s\n",
+
(GNUNET_YES == inbound) ? "inbound" : "outbound",
session,
GNUNET_i2s (peer),
- mac_to_string (&endpoint->addr.mac));
+ mac_to_string (endpoint->address->address));
return session;
}
@@ -870,8 +873,8 @@
get_radiotap_header (endpoint, radio_header, size);
get_wlan_header (endpoint->plugin,
&radio_header->frame,
- &endpoint->addr.mac,
- size);
+ endpoint->address->address,
+ endpoint->address->address_length);
memcpy (&radio_header[1], hdr, msize);
GNUNET_assert (NULL == fm->sh);
fm->sh = GNUNET_HELPER_send (endpoint->plugin->suid_helper,
@@ -1072,15 +1075,16 @@
*/
static struct MacEndpoint *
create_macendpoint (struct Plugin *plugin,
- const struct WlanAddress *addr)
+ const struct GNUNET_HELLO_Address *address)
{
struct MacEndpoint *pos;
for (pos = plugin->mac_head; NULL != pos; pos = pos->next)
- if (0 == memcmp (addr, &pos->addr, sizeof (struct WlanAddress)))
+ if (0 == memcmp (address->address, pos->address->address,
+ pos->address->address_length))
return pos;
pos = GNUNET_new (struct MacEndpoint);
- pos->addr = *addr;
+ pos->address = GNUNET_HELLO_address_copy (address);
pos->plugin = plugin;
pos->defrag =
GNUNET_DEFRAGMENT_context_create (plugin->env->stats, WLAN_MTU,
@@ -1090,8 +1094,7 @@
&send_ack);
pos->msg_delay = GNUNET_TIME_UNIT_MILLISECONDS;
- pos->ack_delay = GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_MILLISECONDS,
-
100);
+ pos->ack_delay = GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_MILLISECONDS, 100);
pos->timeout = GNUNET_TIME_relative_to_absolute (MACENDPOINT_TIMEOUT);
pos->timeout_task =
GNUNET_SCHEDULER_add_delayed (MACENDPOINT_TIMEOUT, &macendpoint_timeout,
@@ -1100,9 +1103,8 @@
plugin->mac_count++;
GNUNET_STATISTICS_update (plugin->env->stats, _("# WLAN MAC endpoints
allocated"),
1, GNUNET_NO);
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "New MAC endpoint `%s'\n",
- wlan_plugin_address_to_string(NULL, addr, sizeof (struct WlanAddress)));
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "New MAC endpoint `%s'\n",
+ wlan_plugin_address_to_string(NULL, address->address,
address->address_length));
return pos;
}
@@ -1149,7 +1151,7 @@
"Service asked to create session for peer `%s' with MAC `%s'\n",
GNUNET_i2s (&address->peer),
wlan_plugin_address_to_string(NULL, address->address,
address->address_length));
- endpoint = create_macendpoint (plugin, address->address);
+ endpoint = create_macendpoint (plugin, address);
return get_session (endpoint, &address->peer, GNUNET_NO);
}
@@ -1261,6 +1263,7 @@
process_data (void *cls, void *client, const struct GNUNET_MessageHeader *hdr)
{
struct Plugin *plugin = cls;
+ struct GNUNET_HELLO_Address *address;
struct MacAndSession *mas = client;
struct MacAndSession xmas;
struct GNUNET_ATS_Information ats;
@@ -1291,21 +1294,18 @@
"Processing %u bytes of HELLO from peer `%s' at MAC %s\n",
(unsigned int) msize,
GNUNET_i2s (&tmpsource),
- wlan_plugin_address_to_string (NULL, &mas->endpoint->addr, sizeof
(struct WlanAddress)));
+ wlan_plugin_address_to_string (NULL, mas->endpoint->address->address,
mas->endpoint->address->address_length));
GNUNET_STATISTICS_update (plugin->env->stats,
_("# HELLO messages received via WLAN"), 1,
GNUNET_NO);
+
plugin->env->receive (plugin->env->cls,
- &tmpsource,
- hdr,
- mas->session,
- (mas->endpoint == NULL) ? NULL : (const char *)
&mas->endpoint->addr,
- (mas->endpoint == NULL) ? 0 : sizeof (struct
WlanAddress));
+ mas->endpoint->address,
+ mas->session,
+ hdr);
plugin->env->update_address_metrics (plugin->env->cls,
- &tmpsource,
- (mas->endpoint == NULL) ? NULL :
(const char *) &mas->endpoint->addr,
- (mas->endpoint == NULL) ? 0 : sizeof
(struct WlanAddress),
+ mas->endpoint->address,
mas->session,
&ats, 1);
break;
@@ -1318,7 +1318,8 @@
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Processing %u bytes of FRAGMENT from MAC %s\n",
(unsigned int) msize,
- wlan_plugin_address_to_string (NULL, &mas->endpoint->addr, sizeof
(struct WlanAddress)));
+ wlan_plugin_address_to_string (NULL, mas->endpoint->address->address,
+ mas->endpoint->address->address_length));
GNUNET_STATISTICS_update (plugin->env->stats,
_("# fragments received via WLAN"), 1,
GNUNET_NO);
(void) GNUNET_DEFRAGMENT_process_fragment (mas->endpoint->defrag,
@@ -1339,7 +1340,8 @@
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Got last ACK, finished message transmission to `%s' (%p)\n",
- wlan_plugin_address_to_string (NULL, &mas->endpoint->addr,
sizeof (struct WlanAddress)),
+ wlan_plugin_address_to_string (NULL,
mas->endpoint->address->address,
+ mas->endpoint->address->address_length),
fm);
mas->endpoint->timeout = GNUNET_TIME_relative_to_absolute
(MACENDPOINT_TIMEOUT);
if (NULL != fm->cont)
@@ -1354,13 +1356,15 @@
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Got an ACK, message transmission to `%s' not yet finished\n",
- wlan_plugin_address_to_string (NULL, &mas->endpoint->addr,
sizeof (struct WlanAddress)));
+ wlan_plugin_address_to_string (NULL,
mas->endpoint->address->address,
+ mas->endpoint->address->address_length));
break;
}
}
LOG (GNUNET_ERROR_TYPE_DEBUG,
"ACK not matched against any active fragmentation with MAC `%s'\n",
- wlan_plugin_address_to_string (NULL, &mas->endpoint->addr, sizeof
(struct WlanAddress)));
+ wlan_plugin_address_to_string (NULL, mas->endpoint->address->address,
+ mas->endpoint->address->address_length));
break;
case GNUNET_MESSAGE_TYPE_WLAN_DATA:
if (NULL == mas->endpoint)
@@ -1395,12 +1399,14 @@
if (NULL == (xmas.session = lookup_session (mas->endpoint,
&wlanheader->sender, GNUNET_YES)))
{
xmas.session = create_session (mas->endpoint, &wlanheader->sender,
GNUNET_YES);
- plugin->env->session_start (NULL, &wlanheader->sender,
- PLUGIN_NAME, &mas->endpoint->addr,
- sizeof (struct WlanAddress), xmas.session, NULL, 0);
+ address = GNUNET_HELLO_address_allocate (&wlanheader->sender,
PLUGIN_NAME,
+ &mas->endpoint->address, sizeof (struct WlanAddress),
+ GNUNET_HELLO_ADDRESS_INFO_NONE);
+ plugin->env->session_start (NULL, address, xmas.session, NULL, 0);
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Notifying transport about peer `%s''s new inbound session %p \n",
GNUNET_i2s (&wlanheader->sender), xmas.session);
+ GNUNET_HELLO_address_free (address);
}
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Processing %u bytes of WLAN DATA from peer `%s'\n",
@@ -1429,17 +1435,13 @@
(unsigned int) ntohs (hdr->type),
GNUNET_i2s (&mas->session->target));
plugin->env->receive (plugin->env->cls,
- &mas->session->target,
- hdr,
- mas->session,
- (mas->endpoint == NULL) ? NULL : (const char *)
&mas->endpoint->addr,
- (mas->endpoint == NULL) ? 0 : sizeof (struct
WlanAddress));
+ mas->session->mac->address,
+ mas->session,
+ hdr);
plugin->env->update_address_metrics (plugin->env->cls,
- &mas->session->target,
- (mas->endpoint == NULL) ? NULL :
(const char *) &mas->endpoint->addr,
- (mas->endpoint == NULL) ? 0 : sizeof
(struct WlanAddress),
- mas->session,
- &ats, 1);
+ mas->session->mac->address,
+ mas->session,
+ &ats, 1);
break;
}
return GNUNET_OK;
@@ -1458,6 +1460,7 @@
const struct GNUNET_MessageHeader *hdr)
{
struct Plugin *plugin = cls;
+ struct GNUNET_HELLO_Address *address;
const struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *rxinfo;
const struct GNUNET_TRANSPORT_WLAN_HelperControlMessage *cm;
struct WlanAddress wa;
@@ -1484,24 +1487,26 @@
memset (&wa, 0, sizeof (struct WlanAddress));
wa.mac = plugin->mac_address;
wa.options = htonl(plugin->options);
- plugin->env->notify_address (plugin->env->cls, GNUNET_NO,
- &wa,
- sizeof (wa),
- "wlan");
+ address = GNUNET_HELLO_address_allocate (plugin->env->my_identity,
+ PLUGIN_NAME, &wa, sizeof (wa), GNUNET_HELLO_ADDRESS_INFO_NONE);
+ plugin->env->notify_address (plugin->env->cls, GNUNET_NO, address);
+ GNUNET_HELLO_address_free (address);
}
plugin->mac_address = cm->mac;
plugin->have_mac = GNUNET_YES;
+
memset (&wa, 0, sizeof (struct WlanAddress));
wa.mac = plugin->mac_address;
wa.options = htonl(plugin->options);
+ address = GNUNET_HELLO_address_allocate (plugin->env->my_identity,
+ PLUGIN_NAME, &wa, sizeof (wa), GNUNET_HELLO_ADDRESS_INFO_NONE);
+
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Received WLAN_HELPER_CONTROL message with MAC address `%s' for peer
`%s'\n",
mac_to_string (&cm->mac),
GNUNET_i2s (plugin->env->my_identity));
- plugin->env->notify_address (plugin->env->cls, GNUNET_YES,
- &wa,
- sizeof (struct WlanAddress),
- "wlan");
+ plugin->env->notify_address (plugin->env->cls, GNUNET_YES, address);
+ GNUNET_HELLO_address_free (address);
break;
case GNUNET_MESSAGE_TYPE_WLAN_DATA_FROM_HELPER:
LOG (GNUNET_ERROR_TYPE_DEBUG,
@@ -1551,7 +1556,10 @@
mac_to_string (&rxinfo->frame.addr2));
wa.mac = rxinfo->frame.addr2;
wa.options = htonl (0);
- mas.endpoint = create_macendpoint (plugin, &wa);
+ address = GNUNET_HELLO_address_allocate (NULL, PLUGIN_NAME, &wa,
+ sizeof (struct WlanAddress), GNUNET_HELLO_ADDRESS_INFO_NONE);
+ mas.endpoint = create_macendpoint (plugin, address);
+ GNUNET_HELLO_address_free (address);
mas.session = NULL;
(void) GNUNET_SERVER_mst_receive (plugin->helper_payload_tokenizer,
&mas,
@@ -1738,7 +1746,8 @@
void *
libgnunet_plugin_transport_wlan_done (void *cls)
{
- struct WlanAddress wa;
+ struct WlanAddress wa;
+ struct GNUNET_HELLO_Address *address;
struct GNUNET_TRANSPORT_PluginFunctions *api = cls;
struct Plugin *plugin = api->cls;
struct MacEndpoint *endpoint;
@@ -1752,14 +1761,17 @@
if (GNUNET_YES == plugin->have_mac)
{
- memset (&wa, 0, sizeof (wa));
- wa.options = htonl (plugin->options);
- wa.mac = plugin->mac_address;
- plugin->env->notify_address (plugin->env->cls, GNUNET_NO,
- &wa,
- sizeof (struct WlanAddress),
- "wlan");
- plugin->have_mac = GNUNET_NO;
+ memset (&wa, 0, sizeof(wa));
+ wa.options = htonl (plugin->options);
+ wa.mac = plugin->mac_address;
+ address = GNUNET_HELLO_address_allocate (plugin->env->my_identity,
+ PLUGIN_NAME, &wa, sizeof (struct WlanAddress),
+ GNUNET_HELLO_ADDRESS_INFO_NONE);
+
+ plugin->env->notify_address (plugin->env->cls, GNUNET_NO, address);
+ plugin->have_mac = GNUNET_NO;
+
+ GNUNET_HELLO_address_free (address);
}
if (GNUNET_SCHEDULER_NO_TASK != plugin->beacon_task)
Modified: gnunet/src/transport/test_plugin_transport.c
===================================================================
--- gnunet/src/transport/test_plugin_transport.c 2014-01-13 16:56:41 UTC
(rev 31885)
+++ gnunet/src/transport/test_plugin_transport.c 2014-01-13 16:59:57 UTC
(rev 31886)
@@ -1,22 +1,22 @@
/*
- This file is part of GNUnet.
- (C) 2009 Christian Grothoff (and other contributing authors)
+ This file is part of GNUnet.
+ (C) 2009 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
- by the Free Software Foundation; either version 3, or (at your
- option) any later version.
+ GNUnet is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published
+ by the Free Software Foundation; either version 3, or (at your
+ option) any later version.
- GNUnet is distributed in the hope that it will be useful, but
- WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- General Public License for more details.
+ GNUnet is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
- 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.
-*/
+ 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.
+ */
/**
* @file transport/test_plugin_transport.c
* @brief testcase for transport_api.c
@@ -120,21 +120,17 @@
*/
static int ok;
-
struct AddressWrapper
{
struct AddressWrapper *next;
struct AddressWrapper *prev;
- void *addr;
+ struct GNUNET_HELLO_Address *address;
- size_t addrlen;
-
char *addrstring;
};
-
static void
end ()
{
@@ -144,33 +140,32 @@
if (GNUNET_SCHEDULER_NO_TASK != timeout_endbadly)
{
- GNUNET_SCHEDULER_cancel (timeout_endbadly);
- timeout_endbadly = GNUNET_SCHEDULER_NO_TASK;
+ GNUNET_SCHEDULER_cancel (timeout_endbadly);
+ timeout_endbadly = GNUNET_SCHEDULER_NO_TASK;
}
if (NULL != api)
- GNUNET_PLUGIN_unload (libname, api);
+ GNUNET_PLUGIN_unload (libname, api);
while (NULL != head)
{
- w = head;
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Plugin did not remove address `%s'\n", w->addrstring);
- GNUNET_CONTAINER_DLL_remove (head, tail, w);
- c ++;
- GNUNET_free (w->addr);
- GNUNET_free (w->addrstring);
- GNUNET_free (w);
+ w = head;
+ GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Plugin did not remove address `%s'\n",
+ w->addrstring);
+ GNUNET_CONTAINER_DLL_remove(head, tail, w);
+ c++;
+ GNUNET_HELLO_address_free(w->address);
+ GNUNET_free(w->addrstring);
+ GNUNET_free(w);
}
if (c > 0)
{
- GNUNET_break (0);
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Plugin did not remove %u addresses \n", c);
+ GNUNET_break(0);
+ GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Plugin did not remove %u addresses
\n",
+ c);
ok = 1;
}
-
- GNUNET_free (libname);
+ GNUNET_free(libname);
libname = NULL;
GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
stats = NULL;
@@ -182,7 +177,6 @@
}
}
-
static void
end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
@@ -192,48 +186,49 @@
timeout_endbadly = GNUNET_SCHEDULER_NO_TASK;
if (GNUNET_SCHEDULER_NO_TASK != timeout_wait)
{
- GNUNET_SCHEDULER_cancel (timeout_wait);
- timeout_wait = GNUNET_SCHEDULER_NO_TASK;
+ GNUNET_SCHEDULER_cancel (timeout_wait);
+ timeout_wait = GNUNET_SCHEDULER_NO_TASK;
}
if (pretty_printers_running > 0)
{
- timeout_endbadly =
GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_SECONDS, &end_badly, &ok);
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "Have pending calls to pretty_printer ... deferring
shutdown\n");
- return;
+ timeout_endbadly = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
+ &end_badly, &ok);
+ GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+ "Have pending calls to pretty_printer ... deferring shutdown\n");
+ return;
}
if (NULL != cls)
{
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Test took too long to execute, timeout .... \n");
+ GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+ "Test took too long to execute, timeout .... \n");
}
if (NULL != libname)
{
if (NULL != api)
GNUNET_PLUGIN_unload (libname, api);
- GNUNET_free (libname);
+ GNUNET_free(libname);
libname = NULL;
}
while (NULL != head)
{
- w = head;
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Plugin did not remove address `%s'\n", w->addrstring);
- GNUNET_CONTAINER_DLL_remove (head, tail, w);
- c ++;
- GNUNET_free (w->addr);
- GNUNET_free (w->addrstring);
- GNUNET_free (w);
+ w = head;
+ GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Plugin did not remove address `%s'\n",
+ w->addrstring);
+ GNUNET_CONTAINER_DLL_remove(head, tail, w);
+ c++;
+ GNUNET_HELLO_address_free(w->address);
+ GNUNET_free(w->addrstring);
+ GNUNET_free(w);
}
if (c > 0)
{
- GNUNET_break (0);
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Plugin did not remove %u addresses\n", c);
+ GNUNET_break(0);
+ GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Plugin did not remove %u addresses\n",
+ c);
}
if (NULL != stats)
@@ -251,51 +246,44 @@
ok = 1;
}
-
static void
wait_end (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
timeout_wait = GNUNET_SCHEDULER_NO_TASK;
if (0 == addresses_reported)
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- "Plugin did not report any addresses, could not check address
conversion functions\n");
+ GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+ "Plugin did not report any addresses, could not check address
conversion functions\n");
end ();
}
-
static void
end_badly_now ()
{
if (GNUNET_SCHEDULER_NO_TASK != timeout_wait)
{
- GNUNET_SCHEDULER_cancel (timeout_wait);
- timeout_wait = GNUNET_SCHEDULER_NO_TASK;
+ GNUNET_SCHEDULER_cancel (timeout_wait);
+ timeout_wait = GNUNET_SCHEDULER_NO_TASK;
}
if (GNUNET_SCHEDULER_NO_TASK != timeout_endbadly)
{
- GNUNET_SCHEDULER_cancel (timeout_endbadly);
- timeout_endbadly = GNUNET_SCHEDULER_NO_TASK;
+ GNUNET_SCHEDULER_cancel (timeout_endbadly);
+ timeout_endbadly = GNUNET_SCHEDULER_NO_TASK;
}
- timeout_endbadly = GNUNET_SCHEDULER_add_now (&end_badly, NULL);
+ timeout_endbadly = GNUNET_SCHEDULER_add_now (&end_badly, NULL );
}
-
static struct GNUNET_TIME_Relative
env_receive (void *cls,
- const struct GNUNET_PeerIdentity *peer,
- const struct GNUNET_MessageHeader *message,
- struct Session * session,
- const char *sender_address,
- uint16_t sender_address_len)
+ const struct GNUNET_HELLO_Address *address,
+ struct Session *session,
+ const struct GNUNET_MessageHeader *message)
{
/* do nothing */
- return GNUNET_TIME_relative_get_zero_();
+ return GNUNET_TIME_relative_get_zero_ ();
}
-
static int got_reply;
-
/**
* Take the given address and append it to the set of results sent back to
* the client.
@@ -309,28 +297,23 @@
if (NULL != buf)
{
got_reply = GNUNET_YES;
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "Pretty address : `%s'\n", buf);
- pretty_printers_running --;
+ GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Pretty address : `%s'\n", buf);
+ pretty_printers_running--;
}
else
{
- if (GNUNET_NO == got_reply)
- {
- pretty_printers_running --;
- GNUNET_break (0);
- end_badly_now ();
- }
+ if (GNUNET_NO == got_reply)
+ {
+ pretty_printers_running--;
+ GNUNET_break(0);
+ end_badly_now ();
+ }
}
}
-
static void
-env_notify_address (void *cls,
- int add_remove,
- const void *addr,
- size_t addrlen,
- const char *plugin)
+env_notify_address (void *cls, int add_remove,
+ const struct GNUNET_HELLO_Address *address)
{
struct AddressWrapper *w;
struct AddressWrapper *wtmp;
@@ -339,150 +322,145 @@
if (GNUNET_YES == add_remove)
{
- addresses_reported ++;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Adding address of length %u\n", addrlen);
+ addresses_reported++;
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Adding address of length %u\n",
+ address->address_length);
- for (wtmp = head; NULL != wtmp; wtmp = wtmp->next)
+ for (wtmp = head; NULL != wtmp; wtmp = wtmp->next)
+ {
+ if ((address->address_length == wtmp->address->address_length) &&
+ (0 == memcmp (address->address, wtmp->address->address,
address->address_length)))
{
- if ((addrlen == wtmp->addrlen) && (0 == memcmp (addr, wtmp->addr,
addrlen)))
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Duplicate address notification .... \n");
- return;
- }
+ GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+ "Duplicate address notification .... \n");
+ return;
}
+ }
- w = GNUNET_new (struct AddressWrapper);
- w->addr = GNUNET_malloc (addrlen);
- w->addrlen = addrlen;
- memcpy (w->addr, addr, addrlen);
- GNUNET_CONTAINER_DLL_insert(head, tail, w);
- got_reply = GNUNET_NO;
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "Testing: address_to_string \n");
- w->addrstring = strdup (api->address_to_string (api, w->addr,
w->addrlen));
- if (NULL == w->addrstring)
- {
- GNUNET_break (0);
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Plugin cannot convert address to string!\n");
- end_badly_now();
- return;
- }
- else
- {
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "Plugin added address `%s'\n", w->addrstring);
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "Testing address_to_string: OK\n");
- }
+ w = GNUNET_new (struct AddressWrapper);
+ w->address = GNUNET_HELLO_address_copy (address);
+ GNUNET_CONTAINER_DLL_insert(head, tail, w);
+ got_reply = GNUNET_NO;
+ GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Testing: address_to_string \n");
+ w->addrstring = strdup (
+ api->address_to_string (api, w->address->address,
+ w->address->address_length));
+ if (NULL == w->addrstring)
+ {
+ GNUNET_break(0);
+ GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+ "Plugin cannot convert address to string!\n");
+ end_badly_now ();
+ return;
+ }
+ else
+ {
+ GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Plugin added address `%s'\n",
+ w->addrstring);
+ GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Testing address_to_string: OK\n");
+ }
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "Testing: string_to_address \n");
- s2a = NULL;
- s2a_len = 0;
- if ((GNUNET_OK != api->string_to_address (api, w->addrstring, strlen
(w->addrstring)+1, &s2a, &s2a_len)) || (NULL == s2a))
- {
- GNUNET_break (0);
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Plugin cannot convert string to address!\n");
- end_badly_now();
- return;
- }
+ GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Testing: string_to_address \n");
+ s2a = NULL;
+ s2a_len = 0;
+ if ((GNUNET_OK
+ != api->string_to_address (api, w->addrstring,
+ strlen (w->addrstring) + 1, &s2a, &s2a_len)) || (NULL == s2a))
+ {
+ GNUNET_break(0);
+ GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+ "Plugin cannot convert string to address!\n");
+ end_badly_now ();
+ return;
+ }
- /*
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "Plugin creates `%s'
%u\n",api->address_to_string (api, s2a, s2a_len), s2a_len);
+ /*
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ "Plugin creates `%s' %u\n",api->address_to_string (api, s2a, s2a_len),
s2a_len);
- int c1;
- for (c1 = 0; c1 < s2a_len; c1++ )
- fprintf (stderr, "%u == %u\n", ((char *) s2a)[c1], ((char *)
w->addr)[c1]);
- */
- if (s2a_len != w->addrlen)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Plugin creates different address length when converting
address->string->address: %u != %u\n", w->addrlen, s2a_len);
- }
- else if (0 != memcmp (s2a, w->addr, s2a_len))
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Plugin creates different address length when
converting back and forth %i!\n", memcmp (s2a, w->addr, s2a_len));
- }
- else
- {
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "Testing string_to_address: OK\n");
- }
- GNUNET_free (s2a);
+ int c1;
+ for (c1 = 0; c1 < s2a_len; c1++ )
+ fprintf (stderr, "%u == %u\n", ((char *) s2a)[c1], ((char *)
w->addr)[c1]);
+ */
+ if (s2a_len != w->address->address_length)
+ {
+ GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+ "Plugin creates different address length when converting
address->string->address: %u != %u\n",
+ w->address->address_length, s2a_len);
+ }
+ else if (0 != memcmp (s2a, w->address->address, s2a_len))
+ {
+ GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+ "Plugin creates different address length when converting back and
forth %i!\n",
+ memcmp (s2a, w->address->address, s2a_len));
+ }
+ else
+ {
+ GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Testing string_to_address: OK\n");
+ }
+ GNUNET_free(s2a);
- pretty_printers_running ++;
- api->address_pretty_printer (api->cls, plugin, addr, addrlen,
- GNUNET_YES, GNUNET_TIME_UNIT_MINUTES,
- &address_pretty_printer_cb,
- w);
+ pretty_printers_running++;
+ api->address_pretty_printer (api->cls, address->transport_name,
address->address, address->address_length, GNUNET_YES,
+ GNUNET_TIME_UNIT_MINUTES, &address_pretty_printer_cb, w);
- if (GNUNET_OK != api->check_address (api->cls, w->addr, w->addrlen))
- {
- GNUNET_break (0);
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Plugin refuses added address!\n");
- end_badly_now();
- return;
- }
- if (GNUNET_SCHEDULER_NO_TASK != timeout_wait)
- {
- GNUNET_SCHEDULER_cancel (timeout_wait);
- timeout_wait = GNUNET_SCHEDULER_NO_TASK;
- }
+ if (GNUNET_OK != api->check_address (api->cls, w->address->address,
w->address->address_length))
+ {
+ GNUNET_break(0);
+ GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Plugin refuses added address!\n");
+ end_badly_now ();
+ return;
+ }
+ if (GNUNET_SCHEDULER_NO_TASK != timeout_wait)
+ {
+ GNUNET_SCHEDULER_cancel (timeout_wait);
+ timeout_wait = GNUNET_SCHEDULER_NO_TASK;
+ }
- timeout_wait = GNUNET_SCHEDULER_add_delayed (WAIT, &wait_end, NULL);
+ timeout_wait = GNUNET_SCHEDULER_add_delayed (WAIT, &wait_end, NULL );
}
else if (GNUNET_NO == add_remove)
{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Removing address of length %u\n", addrlen);
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Removing address of length %u\n",
+ address->address_length);
- w = head;
- while (NULL != w)
+ w = head;
+ while (NULL != w)
+ {
+ if ((address->address_length == w->address->address_length) &&
+ (0 == memcmp (w->address->address, address->address,
address->address_length)))
{
- if ((addrlen == w->addrlen) && (0 == memcmp (w->addr, addr,
addrlen)))
- {
- break;
- }
- w = w->next;
+ break;
}
+ w = w->next;
+ }
- if (w == NULL)
- {
- GNUNET_break (0);
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Plugin removes address never added!\n");
- end_badly_now();
- return;
- }
+ if (w == NULL )
+ {
+ GNUNET_break(0);
+ GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+ "Plugin removes address never added!\n");
+ end_badly_now ();
+ return;
+ }
- GNUNET_CONTAINER_DLL_remove (head, tail, w);
- GNUNET_free (w->addr);
- GNUNET_free (w->addrstring);
- GNUNET_free (w);
+ GNUNET_CONTAINER_DLL_remove(head, tail, w);
+ GNUNET_HELLO_address_free (w->address);
+ GNUNET_free(w->addrstring);
+ GNUNET_free(w);
}
else
{
- GNUNET_break (0);
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Invalid operation: %u\n", add_remove);
- end_badly_now ();
- return;
+ GNUNET_break(0);
+ GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Invalid operation: %u\n", add_remove);
+ end_badly_now ();
+ return;
}
}
-
static struct GNUNET_ATS_Information
-env_get_address_type (void *cls,
- const struct sockaddr *addr,
- size_t addrlen)
+env_get_address_type (void *cls, const struct sockaddr *addr, size_t addrlen)
{
struct GNUNET_ATS_Information ats;
ats.type = htonl (GNUNET_ATS_NETWORK_TYPE);
@@ -490,34 +468,27 @@
return ats;
}
-
static const struct GNUNET_MessageHeader *
env_get_our_hello ()
{
return (const struct GNUNET_MessageHeader *) hello;
}
-
static void
-env_session_end (void *cls,
- const struct GNUNET_PeerIdentity *peer,
- struct Session * session)
+env_session_end (void *cls, const struct GNUNET_PeerIdentity *peer,
+ struct Session * session)
{
}
-
static void
env_update_metrics (void *cls,
- const struct GNUNET_PeerIdentity *peer,
- const void *address,
- uint16_t address_len,
- struct Session *session,
- const struct GNUNET_ATS_Information *ats,
- uint32_t ats_count)
+ const struct GNUNET_HELLO_Address *address,
+ struct Session *session,
+ const struct GNUNET_ATS_Information *ats,
+ uint32_t ats_count)
{
}
-
static void
setup_plugin_environment ()
{
@@ -534,15 +505,13 @@
env.session_end = &env_session_end;
}
-
static int
handle_helper_message (void *cls, void *client,
- const struct GNUNET_MessageHeader *hdr)
+ const struct GNUNET_MessageHeader *hdr)
{
return GNUNET_OK;
}
-
/**
* Runs the test.
*
@@ -550,10 +519,10 @@
* @param c configuration to use
*/
static void
-run (void *cls, char *const *args, const char *cfgfile,
- const struct GNUNET_CONFIGURATION_Handle *c)
+run (void *cls, char * const *args, const char *cfgfile,
+ const struct GNUNET_CONFIGURATION_Handle *c)
{
- char *const *argv = cls;
+ char * const *argv = cls;
unsigned long long tneigh;
char *keyfile;
char *plugin;
@@ -563,66 +532,62 @@
cfg = c;
/* parse configuration */
- if ( (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (c,
- "TRANSPORT",
- "NEIGHBOUR_LIMIT",
- &tneigh)) ||
- (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (c,
- "PEER",
"PRIVATE_KEY",
- &keyfile)))
+ if ((GNUNET_OK
+ != GNUNET_CONFIGURATION_get_value_number (c, "TRANSPORT",
+ "NEIGHBOUR_LIMIT", &tneigh))
+ || (GNUNET_OK
+ != GNUNET_CONFIGURATION_get_value_filename (c, "PEER", "PRIVATE_KEY",
+ &keyfile)))
{
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Transport service is lacking key configuration settings.
Exiting.\n");
+ GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+ "Transport service is lacking key configuration settings.
Exiting.\n");
return;
}
if (NULL == (stats = GNUNET_STATISTICS_create ("transport", cfg)))
{
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Could not create statistics. Exiting.\n");
- GNUNET_free (keyfile);
+ GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+ "Could not create statistics. Exiting.\n");
+ GNUNET_free(keyfile);
end_badly_now ();
return;
}
if (GNUNET_OK != GNUNET_DISK_file_test (HOSTKEY_FILE))
{
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Hostkey `%s' missing. Exiting.\n",
- HOSTKEY_FILE);
- GNUNET_free (keyfile);
- end_badly_now ();
- return;
+ GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Hostkey `%s' missing. Exiting.\n",
+ HOSTKEY_FILE);
+ GNUNET_free(keyfile);
+ end_badly_now ();
+ return;
}
if (GNUNET_OK != GNUNET_DISK_directory_create_for_file (keyfile))
{
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Could not create a directory for hostkey `%s'. Exiting.\n",
- keyfile);
- GNUNET_free (keyfile);
- end_badly_now ();
- return;
+ GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+ "Could not create a directory for hostkey `%s'. Exiting.\n", keyfile);
+ GNUNET_free(keyfile);
+ end_badly_now ();
+ return;
}
- if (GNUNET_OK != GNUNET_DISK_file_copy (HOSTKEY_FILE, keyfile))
+ if (GNUNET_OK != GNUNET_DISK_file_copy (HOSTKEY_FILE, keyfile))
{
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Could not copy hostkey `%s' to destination `%s'.
Exiting.\n",
- HOSTKEY_FILE, keyfile);
- GNUNET_free (keyfile);
- end_badly_now ();
- return;
+ GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+ "Could not copy hostkey `%s' to destination `%s'. Exiting.\n",
+ HOSTKEY_FILE, keyfile);
+ GNUNET_free(keyfile);
+ end_badly_now ();
+ return;
}
-
max_connect_per_transport = (uint32_t) tneigh;
my_private_key = GNUNET_CRYPTO_eddsa_key_create_from_file (keyfile);
- GNUNET_free (keyfile);
+ GNUNET_free(keyfile);
if (NULL == my_private_key)
{
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Could not access hostkey. Exiting.\n");
+ GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+ "Could not access hostkey. Exiting.\n");
end_badly_now ();
return;
}
@@ -633,18 +598,18 @@
/* load plugins... */
setup_plugin_environment ();
- GNUNET_assert (strlen (argv[0]) > strlen ("test_plugin_"));
- plugin = strstr(argv[0],"test_plugin_");
- sep = strrchr(argv[0],'.');
+ GNUNET_assert(strlen (argv[0]) > strlen ("test_plugin_"));
+ plugin = strstr (argv[0], "test_plugin_");
+ sep = strrchr (argv[0], '.');
if (NULL == plugin)
{
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Not a valid test name\n");
- end_badly_now ();
- return;
+ GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Not a valid test name\n");
+ end_badly_now ();
+ return;
}
plugin += strlen ("test_plugin_");
if (NULL != sep)
- sep[0] = '\0';
+ sep[0] = '\0';
/* Hack for WLAN: start a second helper */
if (0 == strcmp (plugin, "wlan"))
@@ -654,77 +619,73 @@
helper_argv[1] = (char *) "2";
helper_argv[2] = NULL;
suid_helper = GNUNET_HELPER_start (GNUNET_NO,
- "gnunet-helper-transport-wlan-dummy",
- helper_argv,
- &handle_helper_message,
- NULL,
- NULL);
+ "gnunet-helper-transport-wlan-dummy", helper_argv,
+ &handle_helper_message, NULL, NULL );
}
/* Loading plugin */
- GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Loading transport plugin %s\n", plugin);
+ GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Loading transport plugin %s\n", plugin);
GNUNET_asprintf (&libname, "libgnunet_plugin_transport_%s", plugin);
api = GNUNET_PLUGIN_load (libname, &env);
- if (api == NULL)
+ if (api == NULL )
{
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Failed to load transport plugin for %s\n", plugin);
+ GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+ "Failed to load transport plugin for %s\n", plugin);
end_badly_now ();
return;
}
- timeout_wait = GNUNET_SCHEDULER_add_delayed (WAIT, &wait_end, NULL);
+ timeout_wait = GNUNET_SCHEDULER_add_delayed (WAIT, &wait_end, NULL );
/* Check if all functions are implemented */
if (NULL == api->address_pretty_printer)
{
- GNUNET_break (0);
- end_badly_now ();
- return;
+ GNUNET_break(0);
+ end_badly_now ();
+ return;
}
if (NULL == api->address_to_string)
{
- GNUNET_break (0);
- end_badly_now ();
- return;
+ GNUNET_break(0);
+ end_badly_now ();
+ return;
}
- GNUNET_assert (NULL != api->check_address);
+ GNUNET_assert(NULL != api->check_address);
if (NULL == api->check_address)
{
- GNUNET_break (0);
- end_badly_now ();
- return;
+ GNUNET_break(0);
+ end_badly_now ();
+ return;
}
- GNUNET_assert (NULL != api->disconnect_peer);
+ GNUNET_assert(NULL != api->disconnect_peer);
if (NULL == api->disconnect_peer)
{
- GNUNET_break (0);
- end_badly_now ();
- return;
+ GNUNET_break(0);
+ end_badly_now ();
+ return;
}
- GNUNET_assert (NULL != api->get_session);
+ GNUNET_assert(NULL != api->get_session);
if (NULL == api->get_session)
{
- GNUNET_break (0);
- end_badly_now ();
- return;
+ GNUNET_break(0);
+ end_badly_now ();
+ return;
}
if (NULL == api->address_pretty_printer)
{
- GNUNET_break (0);
- end_badly_now ();
- return;
+ GNUNET_break(0);
+ end_badly_now ();
+ return;
}
if (NULL == api->string_to_address)
{
- GNUNET_break (0);
- end_badly_now ();
- return;
+ GNUNET_break(0);
+ end_badly_now ();
+ return;
}
}
-
/**
* The main function for the test
*
@@ -733,32 +694,22 @@
* @return 0 ok, 1 on error
*/
int
-main (int argc, char *const *argv)
+main (int argc, char * const *argv)
{
static struct GNUNET_GETOPT_CommandLineOption options[] = {
- GNUNET_GETOPT_OPTION_END
- };
+ GNUNET_GETOPT_OPTION_END };
int ret;
GNUNET_DISK_directory_remove ("/tmp/test-gnunetd-plugin-transport");
- char *const argv_prog[] = {
- "test_plugin_transport",
- "-c",
- "test_plugin_transport_data.conf",
- NULL
- };
- GNUNET_log_setup ("test-plugin-transport",
- "WARNING",
- NULL);
- ok = 1; /* set to fail */
- ret = (GNUNET_OK == GNUNET_PROGRAM_run (3,
- argv_prog,
- "test-plugin-transport",
- "testcase",
- options,
- &run,
- (void *) argv)) ? ok : 1;
+ char * const argv_prog[] = { "test_plugin_transport", "-c",
+ "test_plugin_transport_data.conf", NULL };
+ GNUNET_log_setup ("test-plugin-transport", "WARNING", NULL );
+ ok = 1; /* set to fail */
+ ret =
+ (GNUNET_OK
+ == GNUNET_PROGRAM_run (3, argv_prog, "test-plugin-transport",
+ "testcase", options, &run, (void *) argv)) ? ok : 1;
GNUNET_DISK_directory_remove ("/tmp/test-gnunetd-plugin-transport");
return ret;
}
Modified: gnunet/src/transport/transport.h
===================================================================
--- gnunet/src/transport/transport.h 2014-01-13 16:56:41 UTC (rev 31885)
+++ gnunet/src/transport/transport.h 2014-01-13 16:59:57 UTC (rev 31886)
@@ -461,6 +461,11 @@
struct GNUNET_TIME_AbsoluteNBO state_timeout;
/**
+ * Local info about the address
+ */
+ uint32_t local_address_info GNUNET_PACKED;
+
+ /**
* State this peer is in as #GNUNET_TRANSPORT_PeerState enumeration element
*/
uint32_t state GNUNET_PACKED;
Modified: gnunet/src/transport/transport_api_monitoring.c
===================================================================
--- gnunet/src/transport/transport_api_monitoring.c 2014-01-13 16:56:41 UTC
(rev 31885)
+++ gnunet/src/transport/transport_api_monitoring.c 2014-01-13 16:59:57 UTC
(rev 31886)
@@ -311,8 +311,7 @@
* message with the human-readable address
*/
static void
-peer_response_processor (void *cls,
- const struct GNUNET_MessageHeader *msg)
+peer_response_processor (void *cls, const struct GNUNET_MessageHeader *msg)
{
struct GNUNET_TRANSPORT_PeerMonitoringContext *pal_ctx = cls;
struct PeerIterateResponseMessage *pir_msg;
@@ -432,7 +431,7 @@
/* notify client */
address = GNUNET_HELLO_address_allocate (&pir_msg->peer,
- transport_name, addr, alen);
+ transport_name, addr, alen, ntohl(pir_msg->local_address_info));
pal_ctx->cb (pal_ctx->cb_cls, &pir_msg->peer, address,
ntohl(pir_msg->state),
GNUNET_TIME_absolute_ntoh (pir_msg->state_timeout));
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- [GNUnet-SVN] r31886 - gnunet/src/transport,
gnunet <=