plugin_transport_tcp.c File Reference

Implementation of the TCP transport service. More...

#include "platform.h"
#include "gnunet_hello_lib.h"
#include "gnunet_constants.h"
#include "gnunet_util_lib.h"
#include "gnunet_nat_service.h"
#include "gnunet_protocols.h"
#include "gnunet_resolver_service.h"
#include "gnunet_signatures.h"
#include "gnunet_statistics_service.h"
#include "gnunet_transport_service.h"
#include "gnunet_transport_plugin.h"
#include "transport.h"
#include "tcp_connection_legacy.c"
#include "tcp_server_mst_legacy.c"
#include "tcp_server_legacy.c"
#include "tcp_service_legacy.c"

Include dependency graph for plugin_transport_tcp.c:

Go to the source code of this file.

Data Structures
struct	GNUNET_CONNECTION_Credentials
	Credentials for UNIX domain sockets. More...
struct	GNUNET_SERVER_MessageHandler
	Message handler. More...
struct	WelcomeMessage
	Initial handshake message for a session. More...
struct	TCP_NAT_ProbeMessage
	Basically a WELCOME message, but with the purpose of giving the waiting peer a client handle to use. More...
struct	TCPProbeContext
	Context for sending a NAT probe via TCP. More...
struct	IPv4TcpAddress
	Network format for IPv4 addresses. More...
struct	IPv6TcpAddress
	Network format for IPv6 addresses. More...
struct	PendingMessage
	List containing all messages that are yet to be send. More...
struct	GNUNET_ATS_Session
	Session handle for connections. More...
struct	PrettyPrinterContext
	Closure for append_port(). More...
struct	Plugin
	Handle for a plugin. More...
struct	GNUNET_ATS_SessionItCtx
	Closure for session_lookup_it(). More...

Macros
#define	LOG(kind, ...)   GNUNET_log_from (kind, "transport-tcp", __VA_ARGS__)
#define	PLUGIN_NAME   "tcp"
#define	NAT_TIMEOUT   GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10)
	How long until we give up on establishing an NAT connection? Must be > 4 RTT. More...
#define	GNUNET_SERVER_client_get_user_context(client, type)    (type *) GNUNET_SERVER_client_get_user_context_ (client, sizeof(type))
	Return user context associated with the given client. More...
#define	GNUNET_SERVER_client_set_user_context(client, value)    GNUNET_SERVER_client_set_user_context_ (client, value, sizeof(*value))
	Set user context to be associated with the given client. More...

Typedefs
typedef size_t(*	GNUNET_CONNECTION_TransmitReadyNotify) (void *cls, size_t size, void *buf)
	Function called to notify a client about the connection begin ready to queue more data. More...
typedef void(*	GNUNET_SERVER_DisconnectCallback) (void *cls, struct GNUNET_SERVER_Client *client)
	Functions with this signature are called whenever a client is disconnected on the network level. More...
typedef void(*	GNUNET_SERVER_ConnectCallback) (void *cls, struct GNUNET_SERVER_Client *client)
	Functions with this signature are called whenever a client is connected on the network level. More...
typedef int(*	GNUNET_CONNECTION_AccessCheck) (void *cls, const struct GNUNET_CONNECTION_Credentials *ucred, const struct sockaddr *addr, socklen_t addrlen)
	Function to call for access control checks. More...
typedef void(*	GNUNET_CONNECTION_Receiver) (void *cls, const void *buf, size_t available, const struct sockaddr *addr, socklen_t addrlen, int errCode)
	Callback function for data received from the network. More...
typedef void *(*	GNUNET_SERVER_MstCreateCallback) (void *cls, struct GNUNET_SERVER_Client *client)
	Signature of a function to create a custom tokenizer. More...
typedef void(*	GNUNET_SERVER_MstDestroyCallback) (void *cls, void *mst)
	Signature of a function to destroy a custom tokenizer. More...
typedef int(*	GNUNET_SERVER_MstReceiveCallback) (void *cls, void *mst, struct GNUNET_SERVER_Client *client, const char *buf, size_t size, int purge, int one_shot)
	Signature of a function to receive data for a custom tokenizer. More...
typedef void(*	GNUNET_SERVER_MessageCallback) (void *cls, struct GNUNET_SERVER_Client *client, const struct GNUNET_MessageHeader *message)
	Functions with this signature are called whenever a message is received. More...
typedef int(*	GNUNET_SERVER_MessageTokenizerCallback) (void *cls, void *client, const struct GNUNET_MessageHeader *message)
	Functions with this signature are called whenever a complete message is received by the tokenizer. More...
typedef void(*	LEGACY_SERVICE_Main) (void *cls, struct GNUNET_SERVER_Handle *server, const struct GNUNET_CONFIGURATION_Handle *cfg)
	Function called by the service's run method to run service-specific setup code. More...

Enumerations
enum	LEGACY_SERVICE_Options { LEGACY_SERVICE_OPTION_NONE = 0 , LEGACY_SERVICE_OPTION_MANUAL_SHUTDOWN = 1 , LEGACY_SERVICE_OPTION_SOFT_SHUTDOWN = 2 }
	Options for the service (bitmask). More...
enum	TcpAddressOptions { TCP_OPTIONS_NONE = 0 , TCP_OPTIONS_RESERVED = 1 , TCP_OPTIONS_TCP_STEALTH = 2 }
	Bits in the options field of TCP addresses. More...

Functions
void	LEGACY_SERVICE_stop (struct LEGACY_SERVICE_Context *srv)
	Stops a service that was started with GNUNET_SERVICE_start(). More...
void	GNUNET_CONNECTION_destroy (struct GNUNET_CONNECTION_Handle *connection)
	Close the connection and free associated resources. More...
void	GNUNET_SERVER_client_disconnect (struct GNUNET_SERVER_Client *client)
	Ask the server to disconnect from the given client. More...
void *	GNUNET_SERVER_client_get_user_context_ (struct GNUNET_SERVER_Client *client, size_t size)
	Return user context associated with the given client. More...
struct GNUNET_SERVER_MessageStreamTokenizer *	GNUNET_SERVER_mst_create (GNUNET_SERVER_MessageTokenizerCallback cb, void *cb_cls)
	Create a message stream tokenizer. More...
int	GNUNET_SERVER_mst_receive (struct GNUNET_SERVER_MessageStreamTokenizer *mst, void *client_identity, const char *buf, size_t size, int purge, int one_shot)
	Add incoming data to the receive buffer and call the callback for all complete messages. More...
void	GNUNET_SERVER_mst_destroy (struct GNUNET_SERVER_MessageStreamTokenizer *mst)
	Destroys a tokenizer. More...
void	GNUNET_SERVER_client_set_user_context_ (struct GNUNET_SERVER_Client *client, void *ptr, size_t size)
	Set user context to be associated with the given client. More...
struct GNUNET_SERVER_TransmitHandle *	GNUNET_SERVER_notify_transmit_ready (struct GNUNET_SERVER_Client *client, size_t size, struct GNUNET_TIME_Relative timeout, GNUNET_CONNECTION_TransmitReadyNotify callback, void *callback_cls)
	Notify us when the server has enough space to transmit a message of the given size to the given client. More...
void	GNUNET_SERVER_notify_transmit_ready_cancel (struct GNUNET_SERVER_TransmitHandle *th)
	Abort transmission request. More...
void	GNUNET_SERVER_client_keep (struct GNUNET_SERVER_Client *client)
	Notify the server that the given client handle should be kept (keeps the connection up if possible, increments the internal reference counter). More...
void	GNUNET_SERVER_client_drop (struct GNUNET_SERVER_Client *client)
	Notify the server that the given client handle is no longer required. More...
void	GNUNET_SERVER_suspend (struct GNUNET_SERVER_Handle *server)
	Suspend accepting connections from the listen socket temporarily. More...
struct GNUNET_SERVER_Client *	GNUNET_SERVER_connect_socket (struct GNUNET_SERVER_Handle *server, struct GNUNET_CONNECTION_Handle *connection)
	Add a TCP socket-based connection to the set of handles managed by this server. More...
void	GNUNET_SERVER_resume (struct GNUNET_SERVER_Handle *server)
	Resume accepting connections from the listen socket. More...
void	GNUNET_SERVER_destroy (struct GNUNET_SERVER_Handle *server)
	Free resources held by this server. More...
static int	get_server_addresses (const char *service_name, const struct GNUNET_CONFIGURATION_Handle *cfg, struct sockaddr ***addrs, socklen_t **addr_lens)
	Get the list of addresses that a server for the given service should bind to. More...
static void	notify_session_monitor (struct Plugin *plugin, struct GNUNET_ATS_Session *session, enum GNUNET_TRANSPORT_SessionState state)
	If a session monitor is attached, notify it about the new session state. More...
static void	tcp_nat_port_map_callback (void *cls, void **app_ctx, int add_remove, enum GNUNET_NAT_AddressClass ac, const struct sockaddr *addr, socklen_t addrlen)
	Our external IP address/port mapping has changed. More...
static const char *	tcp_plugin_address_to_string (void *cls, const void *addr, size_t addrlen)
	Function called for a quick conversion of the binary address to a numeric address. More...
static int	tcp_plugin_string_to_address (void *cls, const char *addr, uint16_t addrlen, void **buf, size_t *added)
	Function called to convert a string address to a binary address. More...
static struct GNUNET_ATS_Session *	lookup_session_by_client (struct Plugin *plugin, struct GNUNET_SERVER_Client *client)
	Find the session handle for the given client. More...
static int	tcp_plugin_disconnect_session (void *cls, struct GNUNET_ATS_Session *session)
	Functions with this signature are called whenever we need to close a session due to a disconnect or failure to establish a connection. More...
static unsigned int	tcp_plugin_query_keepalive_factor (void *cls)
	Function that is called to get the keepalive factor. More...
static void	session_timeout (void *cls)
	Session was idle for too long, so disconnect it. More...
static void	reschedule_session_timeout (struct GNUNET_ATS_Session *s)
	Increment session timeout due to activity. More...
static struct GNUNET_ATS_Session *	create_session (struct Plugin *plugin, const struct GNUNET_HELLO_Address *address, enum GNUNET_NetworkType scope, struct GNUNET_SERVER_Client *client, int is_nat)
	Create a new session. More...
static void	process_pending_messages (struct GNUNET_ATS_Session *session)
	If we have pending messages, ask the server to transmit them (schedule the respective tasks, etc.) More...
static size_t	do_transmit (void *cls, size_t size, void *buf)
	Function called to notify a client about the socket being ready to queue more data. More...
static ssize_t	tcp_plugin_send (void *cls, struct GNUNET_ATS_Session *session, const char *msgbuf, size_t msgbuf_size, unsigned int priority, struct GNUNET_TIME_Relative to, GNUNET_TRANSPORT_TransmitContinuation cont, void *cont_cls)
	Function that can be used by the transport service to transmit a message using the plugin. More...
static int	session_lookup_it (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
	Look for a session by address. More...
static void	nat_connect_timeout (void *cls)
	Task cleaning up a NAT connection attempt after timeout. More...
static void	tcp_plugin_update_session_timeout (void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_ATS_Session *session)
	Function that will be called whenever the transport service wants to notify the plugin that a session is still active and in use and therefore the session timeout for this session has to be updated. More...
static void	delayed_done (void *cls)
	Task to signal the server that we can continue receiving from the TCP client now. More...
static void	tcp_plugin_update_inbound_delay (void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_ATS_Session *session, struct GNUNET_TIME_Relative delay)
	Function that will be called whenever the transport service wants to notify the plugin that the inbound quota changed and that the plugin should update it's delay for the next receive value. More...
static struct GNUNET_ATS_Session *	tcp_plugin_get_session (void *cls, const struct GNUNET_HELLO_Address *address)
	Create a new session to transmit data to the target This session will used to send data to this peer and the plugin will notify us by calling the env->session_end function. More...
static int	session_disconnect_it (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
	We have been asked to destroy all connections to a particular peer. More...
static void	tcp_plugin_disconnect (void *cls, const struct GNUNET_PeerIdentity *target)
	Function that can be called to force a disconnect from the specified neighbour. More...
static void	append_port (void *cls, const char *hostname)
	We are processing an address pretty printing request and finished the IP resolution (if applicable). More...
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)
	Convert the transports address to a nice, human-readable format. More...
static int	tcp_plugin_check_address (void *cls, const void *addr, size_t addrlen)
	Function that will be called to check if a binary address for this plugin is well-formed and corresponds to an address for THIS peer (as per our configuration). More...
static void	handle_tcp_nat_probe (void *cls, struct GNUNET_SERVER_Client *client, const struct GNUNET_MessageHeader *message)
	We've received a nat probe from this peer via TCP. More...
static void	handle_tcp_welcome (void *cls, struct GNUNET_SERVER_Client *client, const struct GNUNET_MessageHeader *message)
	We've received a welcome from this peer via TCP. More...
static void	handle_tcp_data (void *cls, struct GNUNET_SERVER_Client *client, const struct GNUNET_MessageHeader *message)
	We've received data for this peer via TCP. More...
static void	connect_notify (void *cls, struct GNUNET_SERVER_Client *client)
	Function called whenever a peer is connected on the "SERVER" level. More...
static void	disconnect_notify (void *cls, struct GNUNET_SERVER_Client *client)
	Function called whenever a peer is disconnected on the "SERVER" level. More...
static size_t	notify_send_probe (void *cls, size_t size, void *buf)
	We can now send a probe message, copy into buffer to really send. More...
static void	try_connection_reversal (void *cls, const struct sockaddr *addr, socklen_t addrlen)
	Function called by the NAT subsystem suggesting another peer wants to connect to us via connection reversal. More...
static enum GNUNET_NetworkType	tcp_plugin_get_network (void *cls, struct GNUNET_ATS_Session *session)
	Function obtain the network type for a session. More...
static enum GNUNET_NetworkType	tcp_plugin_get_network_for_address (void *cls, const struct GNUNET_HELLO_Address *address)
	Function obtain the network type for an address. More...
static int	send_session_info_iter (void *cls, const struct GNUNET_PeerIdentity *peer, void *value)
	Return information about the given session to the monitor callback. More...
static void	tcp_plugin_setup_monitor (void *cls, GNUNET_TRANSPORT_SessionInfoCallback sic, void *sic_cls)
	Begin monitoring sessions of a plugin. More...
void *	libgnunet_plugin_transport_tcp_init (void *cls)
	Entry point for the plugin. More...
void *	libgnunet_plugin_transport_tcp_done (void *cls)
	Exit point from the plugin. More...

Detailed Description

Implementation of the TCP transport service.

Author

Christian Grothoff

Definition in file plugin_transport_tcp.c.

Macro Definition Documentation

LOG

#define LOG	(		kind,
			...
	)		GNUNET_log_from (kind, "transport-tcp", __VA_ARGS__)

Definition at line 38 of file plugin_transport_tcp.c.

PLUGIN_NAME

#define PLUGIN_NAME   "tcp"

Definition at line 40 of file plugin_transport_tcp.c.

NAT_TIMEOUT

#define NAT_TIMEOUT   GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10)

How long until we give up on establishing an NAT connection? Must be > 4 RTT.

Definition at line 46 of file plugin_transport_tcp.c.

GNUNET_SERVER_client_get_user_context

#define GNUNET_SERVER_client_get_user_context	(		client,
			type
	)		(type *) GNUNET_SERVER_client_get_user_context_ (client, sizeof(type))

Return user context associated with the given client.

Parameters

client	client to query
type	expected return type (i.e. 'struct Foo')

Returns

pointer to user context of type 'type *'.

Definition at line 413 of file plugin_transport_tcp.c.

GNUNET_SERVER_client_set_user_context

#define GNUNET_SERVER_client_set_user_context	(		client,
			value
	)		GNUNET_SERVER_client_set_user_context_ (client, value, sizeof(*value))

Set user context to be associated with the given client.

Parameters

client	client to query
value	pointer to user context

Definition at line 422 of file plugin_transport_tcp.c.

Typedef Documentation

GNUNET_CONNECTION_TransmitReadyNotify

typedef size_t(* GNUNET_CONNECTION_TransmitReadyNotify) (void *cls, size_t size, void *buf)

Function called to notify a client about the connection begin ready to queue more data.

buf will be NULL and size zero if the connection was closed for writing in the meantime.

Parameters

cls	closure
size	number of bytes available in buf
buf	where the callee should write the message

Returns

number of bytes written to buf

Definition at line 99 of file plugin_transport_tcp.c.

GNUNET_SERVER_DisconnectCallback

typedef void(* GNUNET_SERVER_DisconnectCallback) (void *cls, struct GNUNET_SERVER_Client *client)

Functions with this signature are called whenever a client is disconnected on the network level.

Parameters

cls	closure
client	identification of the client; NULL for the last call when the server is destroyed

Definition at line 128 of file plugin_transport_tcp.c.

GNUNET_SERVER_ConnectCallback

typedef void(* GNUNET_SERVER_ConnectCallback) (void *cls, struct GNUNET_SERVER_Client *client)

Functions with this signature are called whenever a client is connected on the network level.

Parameters

cls	closure
client	identification of the client

Definition at line 140 of file plugin_transport_tcp.c.

GNUNET_CONNECTION_AccessCheck

typedef int(* GNUNET_CONNECTION_AccessCheck) (void *cls, const struct GNUNET_CONNECTION_Credentials *ucred, const struct sockaddr *addr, socklen_t addrlen)

Function to call for access control checks.

Parameters

cls	closure
ucred	credentials, if available, otherwise NULL
addr	address
addrlen	length of address

Returns

GNUNET_YES to allow, GNUNET_NO to deny, GNUNET_SYSERR for unknown address family (will be denied).

Definition at line 155 of file plugin_transport_tcp.c.

GNUNET_CONNECTION_Receiver

typedef void(* GNUNET_CONNECTION_Receiver) (void *cls, const void *buf, size_t available, const struct sockaddr *addr, socklen_t addrlen, int errCode)

Callback function for data received from the network.

Note that both "available" and "err" would be 0 if the read simply timed out.

Parameters

cls	closure
buf	pointer to received data
available	number of bytes available in "buf", possibly 0 (on errors)
addr	address of the sender
addrlen	size of addr
errCode	value of errno (on errors receiving)

Definition at line 173 of file plugin_transport_tcp.c.

GNUNET_SERVER_MstCreateCallback

typedef void*(* GNUNET_SERVER_MstCreateCallback) (void *cls, struct GNUNET_SERVER_Client *client)

Signature of a function to create a custom tokenizer.

Parameters

cls	closure from GNUNET_SERVER_set_callbacks
client	handle to client the tokenzier will be used for

Returns

handle to custom tokenizer ('mst')

Definition at line 199 of file plugin_transport_tcp.c.

GNUNET_SERVER_MstDestroyCallback

typedef void(* GNUNET_SERVER_MstDestroyCallback) (void *cls, void *mst)

Signature of a function to destroy a custom tokenizer.

Parameters

cls	closure from GNUNET_SERVER_set_callbacks
mst	custom tokenizer handle

Definition at line 210 of file plugin_transport_tcp.c.

GNUNET_SERVER_MstReceiveCallback

typedef int(* GNUNET_SERVER_MstReceiveCallback) (void *cls, void *mst, struct GNUNET_SERVER_Client *client, const char *buf, size_t size, int purge, int one_shot)

Signature of a function to receive data for a custom tokenizer.

Parameters

cls	closure from GNUNET_SERVER_set_callbacks
mst	custom tokenizer handle
client_identity	ID of client for which this is a buffer, can be NULL (will be passed back to 'cb')
buf	input data to add
size	number of bytes in buf
purge	should any excess bytes in the buffer be discarded (i.e. for packet-based services like UDP)
one_shot	only call callback once, keep rest of message in buffer

Returns

GNUNET_OK if we are done processing (need more data) GNUNET_NO if one_shot was set and we have another message ready GNUNET_SYSERR if the data stream is corrupt

Definition at line 228 of file plugin_transport_tcp.c.

GNUNET_SERVER_MessageCallback

typedef void(* GNUNET_SERVER_MessageCallback) (void *cls, struct GNUNET_SERVER_Client *client, const struct GNUNET_MessageHeader *message)

Functions with this signature are called whenever a message is received.

Parameters

cls	closure
client	identification of the client
message	the actual message

Definition at line 244 of file plugin_transport_tcp.c.

GNUNET_SERVER_MessageTokenizerCallback

typedef int(* GNUNET_SERVER_MessageTokenizerCallback) (void *cls, void *client, const struct GNUNET_MessageHeader *message)

Functions with this signature are called whenever a complete message is received by the tokenizer.

Do not call GNUNET_SERVER_mst_destroy from within the scope of this callback.

Parameters

cls	closure
client	identification of the client
message	the actual message

Returns

GNUNET_OK on success, GNUNET_SYSERR to stop further processing

Definition at line 342 of file plugin_transport_tcp.c.

LEGACY_SERVICE_Main

typedef void(* LEGACY_SERVICE_Main) (void *cls, struct GNUNET_SERVER_Handle *server, const struct GNUNET_CONFIGURATION_Handle *cfg)

Function called by the service's run method to run service-specific setup code.

Parameters

cls	closure
server	the initialized server
cfg	configuration to use

Definition at line 490 of file plugin_transport_tcp.c.

Enumeration Type Documentation

LEGACY_SERVICE_Options

enum LEGACY_SERVICE_Options

Options for the service (bitmask).

Enumerator
LEGACY_SERVICE_OPTION_NONE	Use defaults. Terminates all client connections and the listen sockets immediately upon receiving the shutdown signal.
LEGACY_SERVICE_OPTION_MANUAL_SHUTDOWN	Do not trigger server shutdown on signal at all; instead, allow for the user to terminate the server explicitly when needed by calling #LEGACY_SERVICE_shutdown().
LEGACY_SERVICE_OPTION_SOFT_SHUTDOWN	Trigger a SOFT server shutdown on signals, allowing active non-monitor clients to complete their transactions.

Definition at line 283 of file plugin_transport_tcp.c.

{
  LEGACY_SERVICE_OPTION_NONE = 0,
 
  LEGACY_SERVICE_OPTION_MANUAL_SHUTDOWN = 1,
 
  LEGACY_SERVICE_OPTION_SOFT_SHUTDOWN = 2
};

TcpAddressOptions

enum TcpAddressOptions

Bits in the options field of TCP addresses.

Enumerator
TCP_OPTIONS_NONE	No bits set.
TCP_OPTIONS_RESERVED	See HTTP_OPTIONS_VERIFY_CERTIFICATE.
TCP_OPTIONS_TCP_STEALTH	Enable TCP Stealth-style port knocking.

Definition at line 642 of file plugin_transport_tcp.c.

{
  TCP_OPTIONS_NONE = 0,
 
  TCP_OPTIONS_RESERVED = 1,
 
  TCP_OPTIONS_TCP_STEALTH = 2
};

Function Documentation

LEGACY_SERVICE_stop()

void LEGACY_SERVICE_stop

(

struct LEGACY_SERVICE_Context *

sctx

)

Stops a service that was started with GNUNET_SERVICE_start().

Parameters

srv	service to stop

Stops a service that was started with GNUNET_SERVICE_start().

Parameters

sctx	the service context returned from the start function

Definition at line 1598 of file tcp_service_legacy.c.

{
  unsigned int i;
 
#if HAVE_MALLINFO2
  {
    char *counter;
 
    if ((GNUNET_YES == GNUNET_CONFIGURATION_have_value (sctx->cfg,
                                                        sctx->service_name,
                                                        "GAUGER_HEAP")) &&
        (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string (sctx->cfg,
                                                             sctx->service_name,
                                                             "GAUGER_HEAP",
                                                             &counter)))
    {
      struct mallinfo2 mi;
 
      mi = mallinfo2 ();
      GAUGER (sctx->service_name, counter, mi.usmblks, "blocks");
      GNUNET_free (counter);
    }
  }
#endif
  if (NULL != sctx->shutdown_task)
  {
    GNUNET_SCHEDULER_cancel (sctx->shutdown_task);
    sctx->shutdown_task = NULL;
  }
  if (NULL != sctx->server)
    GNUNET_SERVER_destroy (sctx->server);
  GNUNET_free (sctx->my_handlers);
  if (NULL != sctx->addrs)
  {
    i = 0;
    while (NULL != sctx->addrs[i])
      GNUNET_free_nz (sctx->addrs[i++]);
    GNUNET_free (sctx->addrs);
  }
  GNUNET_free (sctx->addrlens);
  GNUNET_free (sctx->v4_denied);
  GNUNET_free (sctx->v6_denied);
  GNUNET_free (sctx->v4_allowed);
  GNUNET_free (sctx->v6_allowed);
  GNUNET_free (sctx);
}

References LEGACY_SERVICE_Context::addrlens, LEGACY_SERVICE_Context::addrs, LEGACY_SERVICE_Context::cfg, GAUGER, GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_have_value(), GNUNET_free, GNUNET_free_nz, GNUNET_OK, GNUNET_SCHEDULER_cancel(), GNUNET_SERVER_destroy(), GNUNET_YES, LEGACY_SERVICE_Context::my_handlers, LEGACY_SERVICE_Context::server, LEGACY_SERVICE_Context::service_name, LEGACY_SERVICE_Context::shutdown_task, LEGACY_SERVICE_Context::v4_allowed, LEGACY_SERVICE_Context::v4_denied, LEGACY_SERVICE_Context::v6_allowed, and LEGACY_SERVICE_Context::v6_denied.

Referenced by LEGACY_SERVICE_start(), libgnunet_plugin_transport_tcp_done(), and libgnunet_plugin_transport_tcp_init().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CONNECTION_destroy()

void GNUNET_CONNECTION_destroy

(

struct GNUNET_CONNECTION_Handle *

connection

)

Close the connection and free associated resources.

There must not be any pending requests for reading or writing to the connection at this time.

Parameters

connection

connection to destroy

Definition at line 1023 of file tcp_connection_legacy.c.

{
  struct AddressProbe *pos;
 
  if (0 != connection->destroy_later)
  {
    connection->destroy_later = -1;
    return;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Shutting down connection (%p)\n", connection);
  GNUNET_assert (NULL == connection->nth.notify_ready);
  GNUNET_assert (NULL == connection->receiver);
  if (NULL != connection->write_task)
  {
    GNUNET_SCHEDULER_cancel (connection->write_task);
    connection->write_task = NULL;
    connection->write_buffer_off = 0;
  }
  if (NULL != connection->read_task)
  {
    GNUNET_SCHEDULER_cancel (connection->read_task);
    connection->read_task = NULL;
  }
  if (NULL != connection->nth.timeout_task)
  {
    GNUNET_SCHEDULER_cancel (connection->nth.timeout_task);
    connection->nth.timeout_task = NULL;
  }
  connection->nth.notify_ready = NULL;
  if (NULL != connection->dns_active)
  {
    GNUNET_RESOLVER_request_cancel (connection->dns_active);
    connection->dns_active = NULL;
  }
  if (NULL != connection->proxy_handshake)
  {
    /* GNUNET_CONNECTION_destroy (connection->proxy_handshake); */
    connection->proxy_handshake->destroy_later = -1;
    connection->proxy_handshake = NULL;   /* Not leaked ??? */
  }
  while (NULL != (pos = connection->ap_head))
  {
    GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (pos->sock));
    GNUNET_SCHEDULER_cancel (pos->task);
    GNUNET_CONTAINER_DLL_remove (connection->ap_head, connection->ap_tail, pos);
    GNUNET_free (pos);
  }
  if ((NULL != connection->sock) && (GNUNET_YES != connection->persist))
  {
    if ((GNUNET_OK !=
         GNUNET_NETWORK_socket_shutdown (connection->sock, SHUT_RDWR)) &&
        (ENOTCONN != errno) && (ECONNRESET != errno))
      LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "shutdown");
  }
  if (NULL != connection->sock)
  {
    if (GNUNET_YES != connection->persist)
    {
      GNUNET_break (GNUNET_OK ==
                    GNUNET_NETWORK_socket_close (connection->sock));
    }
    else
    {
      GNUNET_NETWORK_socket_free_memory_only_ (
        connection->sock);     /* at least no memory leak (we deliberately
                                * leak the socket in this special case) ... */
    }
  }
  GNUNET_free (connection->addr);
  GNUNET_free (connection->hostname);
  GNUNET_free (connection->write_buffer);
  GNUNET_free (connection);
}

References GNUNET_CONNECTION_Handle::addr, GNUNET_CONNECTION_Handle::ap_head, GNUNET_CONNECTION_Handle::ap_tail, AddressProbe::connection, GNUNET_CONNECTION_Handle::destroy_later, GNUNET_CONNECTION_Handle::dns_active, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_NETWORK_socket_close(), GNUNET_NETWORK_socket_free_memory_only_(), GNUNET_NETWORK_socket_shutdown(), GNUNET_OK, GNUNET_RESOLVER_request_cancel(), GNUNET_SCHEDULER_cancel(), GNUNET_YES, GNUNET_CONNECTION_Handle::hostname, LOG, LOG_STRERROR, GNUNET_CONNECTION_TransmitHandle::notify_ready, GNUNET_CONNECTION_Handle::nth, GNUNET_CONNECTION_Handle::persist, GNUNET_CONNECTION_Handle::proxy_handshake, GNUNET_CONNECTION_Handle::read_task, GNUNET_CONNECTION_Handle::receiver, AddressProbe::sock, GNUNET_CONNECTION_Handle::sock, AddressProbe::task, GNUNET_CONNECTION_TransmitHandle::timeout_task, GNUNET_CONNECTION_Handle::write_buffer, GNUNET_CONNECTION_Handle::write_buffer_off, and GNUNET_CONNECTION_Handle::write_task.

Referenced by connect_fail_continuation(), GNUNET_CONNECTION_acivate_proxied(), GNUNET_SERVER_client_disconnect(), libgnunet_plugin_transport_tcp_done(), and notify_send_probe().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SERVER_client_disconnect()

void GNUNET_SERVER_client_disconnect

(

struct GNUNET_SERVER_Client *

client

)

Ask the server to disconnect from the given client.

This is the same as passing GNUNET_SYSERR to GNUNET_SERVER_receive_done, except that it allows dropping of a client even when not handling a message from that client.

Parameters

client

the client to disconnect from

This is the same as returning GNUNET_SYSERR from a message handler, except that it allows dropping of a client even when not handling a message from that client.

Parameters

client

the client to disconnect from

Definition at line 1497 of file tcp_server_legacy.c.

{
  struct GNUNET_SERVER_Handle *server = client->server;
  struct NotifyList *n;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Client is being disconnected from the server.\n");
  if (NULL != client->restart_task)
  {
    GNUNET_SCHEDULER_cancel (client->restart_task);
    client->restart_task = NULL;
  }
  if (NULL != client->warn_task)
  {
    GNUNET_SCHEDULER_cancel (client->warn_task);
    client->warn_task = NULL;
  }
  if (GNUNET_YES == client->receive_pending)
  {
    GNUNET_CONNECTION_receive_cancel (client->connection);
    client->receive_pending = GNUNET_NO;
  }
  client->shutdown_now = GNUNET_YES;
  client->reference_count++; /* make sure nobody else clean up client... */
  if ((NULL != client->mst) &&
      (NULL != server))
  {
    GNUNET_CONTAINER_DLL_remove (server->clients_head,
                                 server->clients_tail,
                                 client);
    if (NULL != server->mst_destroy)
      server->mst_destroy (server->mst_cls,
                           client->mst);
    else
      GNUNET_SERVER_mst_destroy (client->mst);
    client->mst = NULL;
    for (n = server->disconnect_notify_list_head; NULL != n; n = n->next)
      n->callback (n->callback_cls,
                   client);
  }
  client->reference_count--;
  if (client->reference_count > 0)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "RC of %p still positive, not destroying everything.\n",
         client);
    client->server = NULL;
    return;
  }
  if (GNUNET_YES == client->in_process_client_buffer)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Still processing inputs of %p, not destroying everything.\n",
         client);
    return;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "RC of %p now zero, destroying everything.\n",
       client);
  if (GNUNET_YES == client->persist)
    GNUNET_CONNECTION_persist_ (client->connection);
  if (NULL != client->th.cth)
    GNUNET_SERVER_notify_transmit_ready_cancel (&client->th);
  GNUNET_CONNECTION_destroy (client->connection);
  /* need to cancel again, as it might have been re-added
     in the meantime (i.e. during callbacks) */
  if (NULL != client->warn_task)
  {
    GNUNET_SCHEDULER_cancel (client->warn_task);
    client->warn_task = NULL;
  }
  if (GNUNET_YES == client->receive_pending)
  {
    GNUNET_CONNECTION_receive_cancel (client->connection);
    client->receive_pending = GNUNET_NO;
  }
  GNUNET_free (client);
  /* we might be in soft-shutdown, test if we're done */
  if (NULL != server)
    test_monitor_clients (server);
}

References NotifyList::callback, NotifyList::callback_cls, GNUNET_SERVER_Handle::clients_head, GNUNET_SERVER_Handle::clients_tail, GNUNET_SERVER_Client::connection, GNUNET_SERVER_TransmitHandle::cth, GNUNET_SERVER_Handle::disconnect_notify_list_head, GNUNET_CONNECTION_destroy(), GNUNET_CONNECTION_persist_(), GNUNET_CONNECTION_receive_cancel(), GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_NO, GNUNET_SCHEDULER_cancel(), GNUNET_SERVER_mst_destroy(), GNUNET_SERVER_notify_transmit_ready_cancel(), GNUNET_YES, GNUNET_SERVER_Client::in_process_client_buffer, LOG, GNUNET_SERVER_Client::mst, GNUNET_SERVER_Handle::mst_cls, GNUNET_SERVER_Handle::mst_destroy, NotifyList::next, GNUNET_SERVER_Client::persist, GNUNET_SERVER_Client::receive_pending, GNUNET_SERVER_Client::reference_count, GNUNET_SERVER_Client::restart_task, GNUNET_SERVER_Client::server, GNUNET_SERVER_Client::shutdown_now, test_monitor_clients(), GNUNET_SERVER_Client::th, and GNUNET_SERVER_Client::warn_task.

Referenced by client_message_tokenizer_callback(), GNUNET_SERVER_client_drop(), GNUNET_SERVER_destroy(), GNUNET_SERVER_receive_done(), process_incoming(), process_mst(), and tcp_plugin_disconnect_session().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SERVER_client_get_user_context_()

void* GNUNET_SERVER_client_get_user_context_	(	struct GNUNET_SERVER_Client *	client,
		size_t	size
	)

Return user context associated with the given client.

Note: you should probably use the macro (call without the underscore).

Parameters

client	client to query
size	number of bytes in user context struct (for verification only)

Returns

pointer to user context

Definition at line 349 of file tcp_server_legacy.c.

{
  if ((0 == client->user_context_size) &&
      (NULL == client->user_context))
    return NULL; /* never set */
  GNUNET_assert (size == client->user_context_size);
  return client->user_context;
}

References GNUNET_assert, size, GNUNET_SERVER_Client::user_context, and GNUNET_SERVER_Client::user_context_size.

GNUNET_SERVER_mst_create()

struct GNUNET_SERVER_MessageStreamTokenizer* GNUNET_SERVER_mst_create	(	GNUNET_SERVER_MessageTokenizerCallback	cb,
		void *	cb_cls
	)

Create a message stream tokenizer.

Parameters

cb	function to call on completed messages
cb_cls	closure for cb

Returns

handle to tokenizer

Definition at line 83 of file tcp_server_mst_legacy.c.

{
  struct GNUNET_SERVER_MessageStreamTokenizer *ret;
 
  ret = GNUNET_new (struct GNUNET_SERVER_MessageStreamTokenizer);
  ret->hdr = GNUNET_malloc (GNUNET_MIN_MESSAGE_SIZE);
  ret->curr_buf = GNUNET_MIN_MESSAGE_SIZE;
  ret->cb = cb;
  ret->cb_cls = cb_cls;
  return ret;
}

References GNUNET_SERVER_MessageStreamTokenizer::cb, GNUNET_SERVER_MessageStreamTokenizer::cb_cls, GNUNET_malloc, GNUNET_MIN_MESSAGE_SIZE, GNUNET_new, and ret.

Referenced by GNUNET_SERVER_connect_socket().

Here is the caller graph for this function:

GNUNET_SERVER_mst_receive()

int GNUNET_SERVER_mst_receive	(	struct GNUNET_SERVER_MessageStreamTokenizer *	mst,
		void *	client_identity,
		const char *	buf,
		size_t	size,
		int	purge,
		int	one_shot
	)

Add incoming data to the receive buffer and call the callback for all complete messages.

Parameters

mst	tokenizer to use
client_identity	ID of client for which this is a buffer, can be NULL (will be passed back to 'cb')
buf	input data to add
size	number of bytes in buf
purge	should any excess bytes in the buffer be discarded (i.e. for packet-based services like UDP)
one_shot	only call callback once, keep rest of message in buffer

Returns

GNUNET_OK if we are done processing (need more data) GNUNET_NO if one_shot was set and we have another message ready GNUNET_SYSERR if the data stream is corrupt

Parameters

mst	tokenizer to use
client_identity	ID of client for which this is a buffer
buf	input data to add
size	number of bytes in buf
purge	should any excess bytes in the buffer be discarded (i.e. for packet-based services like UDP)
one_shot	only call callback once, keep rest of message in buffer

Returns

GNUNET_OK if we are done processing (need more data) GNUNET_NO if one_shot was set and we have another message ready GNUNET_SYSERR if the data stream is corrupt

Definition at line 113 of file tcp_server_mst_legacy.c.

{
  const struct GNUNET_MessageHeader *hdr;
  size_t delta;
  uint16_t want;
  char *ibuf;
  int need_align;
  unsigned long offset;
  int ret;
 
  GNUNET_assert (mst->off <= mst->pos);
  GNUNET_assert (mst->pos <= mst->curr_buf);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Server-mst receives %u bytes with %u bytes already in private buffer\n",
       (unsigned int) size, (unsigned int) (mst->pos - mst->off));
  ret = GNUNET_OK;
  ibuf = (char *) mst->hdr;
  while (mst->pos > 0)
  {
do_align:
    GNUNET_assert (mst->pos >= mst->off);
    if ((mst->curr_buf - mst->off < sizeof(struct GNUNET_MessageHeader)) ||
        (0 != (mst->off % ALIGN_FACTOR)))
    {
      /* need to align or need more space */
      mst->pos -= mst->off;
      memmove (ibuf, &ibuf[mst->off], mst->pos);
      mst->off = 0;
    }
    if (mst->pos - mst->off < sizeof(struct GNUNET_MessageHeader))
    {
      delta =
        GNUNET_MIN (sizeof(struct GNUNET_MessageHeader)
                    - (mst->pos - mst->off), size);
      GNUNET_memcpy (&ibuf[mst->pos], buf, delta);
      mst->pos += delta;
      buf += delta;
      size -= delta;
    }
    if (mst->pos - mst->off < sizeof(struct GNUNET_MessageHeader))
    {
      if (purge)
      {
        mst->off = 0;
        mst->pos = 0;
      }
      return GNUNET_OK;
    }
    hdr = (const struct GNUNET_MessageHeader *) &ibuf[mst->off];
    want = ntohs (hdr->size);
    if (want < sizeof(struct GNUNET_MessageHeader))
    {
      GNUNET_break_op (0);
      return GNUNET_SYSERR;
    }
    if ((mst->curr_buf - mst->off < want) &&
        (mst->off > 0))
    {
      /* can get more space by moving */
      mst->pos -= mst->off;
      memmove (ibuf, &ibuf[mst->off], mst->pos);
      mst->off = 0;
    }
    if (mst->curr_buf < want)
    {
      /* need to get more space by growing buffer */
      GNUNET_assert (0 == mst->off);
      mst->hdr = GNUNET_realloc (mst->hdr, want);
      ibuf = (char *) mst->hdr;
      mst->curr_buf = want;
    }
    hdr = (const struct GNUNET_MessageHeader *) &ibuf[mst->off];
    if (mst->pos - mst->off < want)
    {
      delta = GNUNET_MIN (want - (mst->pos - mst->off), size);
      GNUNET_assert (mst->pos + delta <= mst->curr_buf);
      GNUNET_memcpy (&ibuf[mst->pos], buf, delta);
      mst->pos += delta;
      buf += delta;
      size -= delta;
    }
    if (mst->pos - mst->off < want)
    {
      if (purge)
      {
        mst->off = 0;
        mst->pos = 0;
      }
      return GNUNET_OK;
    }
    if (one_shot == GNUNET_SYSERR)
    {
      /* cannot call callback again, but return value saying that
       * we have another full message in the buffer */
      ret = GNUNET_NO;
      goto copy;
    }
    if (one_shot == GNUNET_YES)
      one_shot = GNUNET_SYSERR;
    mst->off += want;
    if (GNUNET_SYSERR == mst->cb (mst->cb_cls, client_identity, hdr))
      return GNUNET_SYSERR;
    if (mst->off == mst->pos)
    {
      /* reset to beginning of buffer, it's free right now! */
      mst->off = 0;
      mst->pos = 0;
    }
  }
  GNUNET_assert (0 == mst->pos);
  while (size > 0)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Server-mst has %u bytes left in inbound buffer\n",
         (unsigned int) size);
    if (size < sizeof(struct GNUNET_MessageHeader))
      break;
    offset = (unsigned long) buf;
    need_align = (0 != (offset % ALIGN_FACTOR)) ? GNUNET_YES : GNUNET_NO;
    if (GNUNET_NO == need_align)
    {
      /* can try to do zero-copy and process directly from original buffer */
      hdr = (const struct GNUNET_MessageHeader *) buf;
      want = ntohs (hdr->size);
      if (want < sizeof(struct GNUNET_MessageHeader))
      {
        GNUNET_break_op (0);
        mst->off = 0;
        return GNUNET_SYSERR;
      }
      if (size < want)
        break;                  /* or not: buffer incomplete, so copy to private buffer... */
      if (one_shot == GNUNET_SYSERR)
      {
        /* cannot call callback again, but return value saying that
         * we have another full message in the buffer */
        ret = GNUNET_NO;
        goto copy;
      }
      if (one_shot == GNUNET_YES)
        one_shot = GNUNET_SYSERR;
      if (GNUNET_SYSERR == mst->cb (mst->cb_cls, client_identity, hdr))
        return GNUNET_SYSERR;
      buf += want;
      size -= want;
    }
    else
    {
      /* need to copy to private buffer to align;
       * yes, we go a bit more spaghetti than usual here */
      goto do_align;
    }
  }
copy:
  if ((size > 0) && (! purge))
  {
    if (size + mst->pos > mst->curr_buf)
    {
      mst->hdr = GNUNET_realloc (mst->hdr, size + mst->pos);
      ibuf = (char *) mst->hdr;
      mst->curr_buf = size + mst->pos;
    }
    GNUNET_assert (size + mst->pos <= mst->curr_buf);
    GNUNET_memcpy (&ibuf[mst->pos], buf, size);
    mst->pos += size;
  }
  if (purge)
  {
    mst->off = 0;
    mst->pos = 0;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Server-mst leaves %u bytes in private buffer\n",
       (unsigned int) (mst->pos - mst->off));
  return ret;
}

References ALIGN_FACTOR, buf, GNUNET_SERVER_MessageStreamTokenizer::cb, GNUNET_SERVER_MessageStreamTokenizer::cb_cls, GNUNET_SERVER_MessageStreamTokenizer::curr_buf, delta, do_align(), GNUNET_assert, GNUNET_break_op, GNUNET_ERROR_TYPE_DEBUG, GNUNET_memcpy, GNUNET_MIN, GNUNET_NO, GNUNET_OK, GNUNET_realloc, GNUNET_SYSERR, GNUNET_YES, GNUNET_SERVER_MessageStreamTokenizer::hdr, LOG, GNUNET_SERVER_MessageStreamTokenizer::off, GNUNET_SERVER_MessageStreamTokenizer::pos, ret, GNUNET_MessageHeader::size, and size.

Referenced by handle_helper_message(), process_data(), process_incoming(), process_mst(), and wlan_data_message_handler().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SERVER_mst_destroy()

void GNUNET_SERVER_mst_destroy

(

struct GNUNET_SERVER_MessageStreamTokenizer *

mst

)

Destroys a tokenizer.

Parameters

mst	tokenizer to destroy

Definition at line 300 of file tcp_server_mst_legacy.c.

{
  GNUNET_free (mst->hdr);
  GNUNET_free (mst);
}

References GNUNET_free, and GNUNET_SERVER_MessageStreamTokenizer::hdr.

Referenced by GNUNET_SERVER_client_disconnect(), and LIBGNUNET_PLUGIN_TRANSPORT_DONE().

Here is the caller graph for this function:

GNUNET_SERVER_client_set_user_context_()

void GNUNET_SERVER_client_set_user_context_	(	struct GNUNET_SERVER_Client *	client,
		void *	ptr,
		size_t	size
	)

Set user context to be associated with the given client.

Note: you should probably use the macro (call without the underscore).

Parameters

client	client to query
ptr	pointer to user context
size	number of bytes in user context struct (for verification only)

Definition at line 369 of file tcp_server_legacy.c.

{
  if (NULL == ptr)
  {
    client->user_context_size = 0;
    client->user_context = ptr;
    return;
  }
  client->user_context_size = size;
  client->user_context = ptr;
}

References size, GNUNET_SERVER_Client::user_context, and GNUNET_SERVER_Client::user_context_size.

GNUNET_SERVER_notify_transmit_ready()

struct GNUNET_SERVER_TransmitHandle * GNUNET_SERVER_notify_transmit_ready	(	struct GNUNET_SERVER_Client *	client,
		size_t	size,
		struct GNUNET_TIME_Relative	timeout,
		GNUNET_CONNECTION_TransmitReadyNotify	callback,
		void *	callback_cls
	)

Notify us when the server has enough space to transmit a message of the given size to the given client.

Parameters

client	client to transmit message to
size	requested amount of buffer space
timeout	after how long should we give up (and call notify with buf NULL and size 0)?
callback	function to call when space is available
callback_cls	closure for callback

Returns

non-NULL if the notify callback was queued; can be used to cancel the request using GNUNET_SERVER_notify_transmit_ready_cancel. NULL if we are already going to notify someone else (busy)

Definition at line 1619 of file tcp_server_legacy.c.

{
  if (NULL != client->th.callback)
    return NULL;
  client->th.callback_cls = callback_cls;
  client->th.callback = callback;
  client->th.cth = GNUNET_CONNECTION_notify_transmit_ready (client->connection,
                                                            size,
                                                            timeout,
                                                            &
                                                            transmit_ready_callback_wrapper,
                                                            client);
  return &client->th;
}

References GNUNET_SERVER_TransmitHandle::callback, GNUNET_SERVER_TransmitHandle::callback_cls, GNUNET_SERVER_Client::connection, GNUNET_SERVER_TransmitHandle::cth, GNUNET_CONNECTION_notify_transmit_ready(), size, GNUNET_SERVER_Client::th, timeout, and transmit_ready_callback_wrapper().

Referenced by process_pending_messages().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SERVER_notify_transmit_ready_cancel()

void GNUNET_SERVER_notify_transmit_ready_cancel

(

struct GNUNET_SERVER_TransmitHandle *

th

)

Abort transmission request.

Parameters

th	request to abort

Definition at line 1646 of file tcp_server_legacy.c.

{
  GNUNET_CONNECTION_notify_transmit_ready_cancel (th->cth);
  th->cth = NULL;
  th->callback = NULL;
}

References GNUNET_SERVER_TransmitHandle::callback, GNUNET_SERVER_TransmitHandle::cth, and GNUNET_CONNECTION_notify_transmit_ready_cancel().

Referenced by GNUNET_SERVER_client_disconnect(), and tcp_plugin_disconnect_session().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SERVER_client_keep()

void GNUNET_SERVER_client_keep

(

struct GNUNET_SERVER_Client *

client

)

Notify the server that the given client handle should be kept (keeps the connection up if possible, increments the internal reference counter).

Parameters

client

the client to keep

Definition at line 1331 of file tcp_server_legacy.c.

{
  client->reference_count++;
}

References GNUNET_SERVER_Client::reference_count.

Referenced by process_incoming(), and restart_processing().

Here is the caller graph for this function:

GNUNET_SERVER_client_drop()

void GNUNET_SERVER_client_drop

(

struct GNUNET_SERVER_Client *

client

)

Notify the server that the given client handle is no longer required.

Decrements the reference counter. If that counter reaches zero an inactive connection maybe closed.

Parameters

client

the client to drop

Definition at line 1346 of file tcp_server_legacy.c.

{
  GNUNET_assert (client->reference_count > 0);
  client->reference_count--;
  if ((GNUNET_YES == client->shutdown_now) && (0 == client->reference_count))
    GNUNET_SERVER_client_disconnect (client);
}

References GNUNET_assert, GNUNET_SERVER_client_disconnect(), GNUNET_YES, GNUNET_SERVER_Client::reference_count, and GNUNET_SERVER_Client::shutdown_now.

Referenced by process_incoming(), and restart_processing().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SERVER_suspend()

void GNUNET_SERVER_suspend

(

struct GNUNET_SERVER_Handle *

server

)

Suspend accepting connections from the listen socket temporarily.

Resume activity using GNUNET_SERVER_resume.

Parameters

server	server to stop accepting connections.
server	server to stop accepting connections.

Definition at line 692 of file tcp_server_legacy.c.

{
  if (NULL != server->listen_task)
  {
    GNUNET_SCHEDULER_cancel (server->listen_task);
    server->listen_task = NULL;
  }
}

References GNUNET_SCHEDULER_cancel(), GNUNET_SERVER_Handle::listen_task, and GNUNET_SERVER_Client::server.

Referenced by connect_notify().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SERVER_connect_socket()

struct GNUNET_SERVER_Client* GNUNET_SERVER_connect_socket	(	struct GNUNET_SERVER_Handle *	server,
		struct GNUNET_CONNECTION_Handle *	connection
	)

Add a TCP socket-based connection to the set of handles managed by this server.

Use this function for outgoing (P2P) connections that we initiated (and where this server should process incoming messages).

Parameters

server	the server to use
connection	the connection to manage (client must stop using this connection from now on)

Returns

the client handle

Definition at line 1271 of file tcp_server_legacy.c.

{
  struct GNUNET_SERVER_Client *client;
  struct NotifyList *n;
 
  client = GNUNET_new (struct GNUNET_SERVER_Client);
  client->connection = connection;
  client->server = server;
  client->last_activity = GNUNET_TIME_absolute_get ();
  client->idle_timeout = server->idle_timeout;
  GNUNET_CONTAINER_DLL_insert (server->clients_head,
                               server->clients_tail,
                               client);
  if (NULL != server->mst_create)
    client->mst =
      server->mst_create (server->mst_cls, client);
  else
    client->mst =
      GNUNET_SERVER_mst_create (&client_message_tokenizer_callback,
                                server);
  GNUNET_assert (NULL != client->mst);
  for (n = server->connect_notify_list_head; NULL != n; n = n->next)
    n->callback (n->callback_cls, client);
  client->receive_pending = GNUNET_YES;
  if (GNUNET_SYSERR ==
      GNUNET_CONNECTION_receive (client->connection,
                                 GNUNET_MAX_MESSAGE_SIZE - 1,
                                 client->idle_timeout,
                                 &process_incoming,
                                 client))
    return NULL;
  return client;
}

References NotifyList::callback, NotifyList::callback_cls, client_message_tokenizer_callback(), GNUNET_SERVER_Handle::clients_head, GNUNET_SERVER_Handle::clients_tail, GNUNET_SERVER_Handle::connect_notify_list_head, GNUNET_SERVER_Client::connection, GNUNET_assert, GNUNET_CONNECTION_receive(), GNUNET_CONTAINER_DLL_insert, GNUNET_MAX_MESSAGE_SIZE, GNUNET_new, GNUNET_SERVER_mst_create(), GNUNET_SYSERR, GNUNET_TIME_absolute_get(), GNUNET_YES, GNUNET_SERVER_Handle::idle_timeout, GNUNET_SERVER_Client::idle_timeout, GNUNET_SERVER_Client::last_activity, GNUNET_SERVER_Client::mst, GNUNET_SERVER_Handle::mst_cls, GNUNET_SERVER_Handle::mst_create, NotifyList::next, process_incoming(), GNUNET_SERVER_Client::receive_pending, and GNUNET_SERVER_Client::server.

Referenced by notify_send_probe(), process_listen_socket(), and tcp_plugin_get_session().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SERVER_resume()

void GNUNET_SERVER_resume

(

struct GNUNET_SERVER_Handle *

server

)

Resume accepting connections from the listen socket.

Parameters

server

server to resume accepting connections.

Definition at line 703 of file tcp_server_legacy.c.

{
  struct GNUNET_NETWORK_FDSet *r;
  unsigned int i;
 
  if (NULL == server->listen_sockets)
    return;
  if (NULL == server->listen_sockets[0])
    return; /* nothing to do, no listen sockets! */
  if (NULL == server->listen_sockets[1])
  {
    /* simplified method: no fd set needed; this is then much simpler
       and much more efficient */
    server->listen_task =
      GNUNET_SCHEDULER_add_read_net_with_priority (GNUNET_TIME_UNIT_FOREVER_REL,
                                                   GNUNET_SCHEDULER_PRIORITY_HIGH,
                                                   server->listen_sockets[0],
                                                   &process_listen_socket,
                                                   server);
    return;
  }
  r = GNUNET_NETWORK_fdset_create ();
  i = 0;
  while (NULL != server->listen_sockets[i])
    GNUNET_NETWORK_fdset_set (r, server->listen_sockets[i++]);
  server->listen_task =
    GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_HIGH,
                                 GNUNET_TIME_UNIT_FOREVER_REL, r, NULL,
                                 &process_listen_socket, server);
  GNUNET_NETWORK_fdset_destroy (r);
}

References GNUNET_NETWORK_fdset_create(), GNUNET_NETWORK_fdset_destroy(), GNUNET_NETWORK_fdset_set(), GNUNET_SCHEDULER_add_read_net_with_priority(), GNUNET_SCHEDULER_add_select(), GNUNET_SCHEDULER_PRIORITY_HIGH, GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_SERVER_Handle::listen_sockets, GNUNET_SERVER_Handle::listen_task, and process_listen_socket().

Referenced by disconnect_notify(), GNUNET_SERVER_create_with_sockets(), and process_listen_socket().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SERVER_destroy()

void GNUNET_SERVER_destroy

(

struct GNUNET_SERVER_Handle *

server

)

Free resources held by this server.

Parameters

server

server to destroy

Definition at line 775 of file tcp_server_legacy.c.

{
  struct HandlerList *hpos;
  struct NotifyList *npos;
  unsigned int i;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Server shutting down.\n");
  if (NULL != server->listen_task)
  {
    GNUNET_SCHEDULER_cancel (server->listen_task);
    server->listen_task = NULL;
  }
  if (NULL != server->listen_sockets)
  {
    i = 0;
    while (NULL != server->listen_sockets[i])
      GNUNET_break (GNUNET_OK ==
                    GNUNET_NETWORK_socket_close (server->listen_sockets[i++]));
    GNUNET_free (server->listen_sockets);
    server->listen_sockets = NULL;
  }
  while (NULL != server->clients_head)
    GNUNET_SERVER_client_disconnect (server->clients_head);
  while (NULL != (hpos = server->handlers))
  {
    server->handlers = hpos->next;
    GNUNET_free (hpos);
  }
  while (NULL != (npos = server->disconnect_notify_list_head))
  {
    npos->callback (npos->callback_cls,
                    NULL);
    GNUNET_CONTAINER_DLL_remove (server->disconnect_notify_list_head,
                                 server->disconnect_notify_list_tail,
                                 npos);
    GNUNET_free (npos);
  }
  while (NULL != (npos = server->connect_notify_list_head))
  {
    npos->callback (npos->callback_cls,
                    NULL);
    GNUNET_CONTAINER_DLL_remove (server->connect_notify_list_head,
                                 server->connect_notify_list_tail,
                                 npos);
    GNUNET_free (npos);
  }
  GNUNET_free (server);
}

References NotifyList::callback, NotifyList::callback_cls, GNUNET_SERVER_Handle::clients_head, GNUNET_SERVER_Handle::connect_notify_list_head, GNUNET_SERVER_Handle::connect_notify_list_tail, GNUNET_SERVER_Handle::disconnect_notify_list_head, GNUNET_SERVER_Handle::disconnect_notify_list_tail, GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_NETWORK_socket_close(), GNUNET_OK, GNUNET_SCHEDULER_cancel(), GNUNET_SERVER_client_disconnect(), GNUNET_SERVER_Handle::handlers, GNUNET_SERVER_Handle::listen_sockets, GNUNET_SERVER_Handle::listen_task, LOG, and HandlerList::next.

Referenced by do_destroy(), LEGACY_SERVICE_stop(), libgnunet_plugin_transport_tcp_done(), and shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

get_server_addresses()

static int get_server_addresses ( const char *  service_name, const struct GNUNET_CONFIGURATION_Handle *  cfg, struct sockaddr ***  addrs, socklen_t **  addr_lens  )

static

Get the list of addresses that a server for the given service should bind to.

Parameters

service_name	name of the service
cfg	configuration (which specifies the addresses)
addrs	set (call by reference) to an array of pointers to the addresses the server should bind to and listen on; the array will be NULL-terminated (on success)
addr_lens	set (call by reference) to an array of the lengths of the respective struct sockaddr struct in the addrs array (on success)

Returns

number of addresses found on success, GNUNET_SYSERR if the configuration did not specify reasonable finding information or if it specified a hostname that could not be resolved; GNUNET_NO if the number of addresses configured is zero (in this case, *addrs and *addr_lens will be set to NULL).

Definition at line 1053 of file plugin_transport_tcp.c.

{
  int disablev6;
  struct GNUNET_NETWORK_Handle *desc;
  unsigned long long port;
  char *unixpath;
  struct addrinfo hints;
  struct addrinfo *res;
  struct addrinfo *pos;
  struct addrinfo *next;
  unsigned int i;
  int resi;
  int ret;
  int abstract;
  struct sockaddr **saddrs;
  socklen_t *saddrlens;
  char *hostname;
 
  *addrs = NULL;
  *addr_lens = NULL;
  desc = NULL;
  if (GNUNET_CONFIGURATION_have_value (cfg, service_name, "DISABLEV6"))
  {
    if (GNUNET_SYSERR ==
        (disablev6 = GNUNET_CONFIGURATION_get_value_yesno (cfg,
                                                           service_name,
                                                           "DISABLEV6")))
      return GNUNET_SYSERR;
  }
  else
    disablev6 = GNUNET_NO;
 
  if (! disablev6)
  {
    /* probe IPv6 support */
    desc = GNUNET_NETWORK_socket_create (PF_INET6, SOCK_STREAM, 0);
    if (NULL == desc)
    {
      if ((ENOBUFS == errno) || (ENOMEM == errno) || (ENFILE == errno) ||
          (EACCES == errno))
      {
        GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "socket");
        return GNUNET_SYSERR;
      }
      LOG (GNUNET_ERROR_TYPE_INFO,
           _ (
             "Disabling IPv6 support for service `%s', failed to create IPv6 socket: %s\n"),
           service_name,
           strerror (errno));
      disablev6 = GNUNET_YES;
    }
    else
    {
      GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (desc));
      desc = NULL;
    }
  }
 
  port = 0;
  if (GNUNET_CONFIGURATION_have_value (cfg, service_name, "PORT"))
  {
    if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg,
                                                            service_name,
                                                            "PORT",
                                                            &port))
    {
      LOG (GNUNET_ERROR_TYPE_ERROR,
           _ ("Require valid port number for service `%s' in configuration!\n"),
           service_name);
    }
    if (port > 65535)
    {
      LOG (GNUNET_ERROR_TYPE_ERROR,
           _ ("Require valid port number for service `%s' in configuration!\n"),
           service_name);
      return GNUNET_SYSERR;
    }
  }
 
  if (GNUNET_CONFIGURATION_have_value (cfg, service_name, "BINDTO"))
  {
    GNUNET_break (GNUNET_OK ==
                  GNUNET_CONFIGURATION_get_value_string (cfg,
                                                         service_name,
                                                         "BINDTO",
                                                         &hostname));
  }
  else
    hostname = NULL;
 
  unixpath = NULL;
  abstract = GNUNET_NO;
#ifdef AF_UNIX
  if ((GNUNET_YES ==
       GNUNET_CONFIGURATION_have_value (cfg, service_name, "UNIXPATH")) &&
      (GNUNET_OK == GNUNET_CONFIGURATION_get_value_filename (cfg,
                                                             service_name,
                                                             "UNIXPATH",
                                                             &unixpath)) &&
      (0 < strlen (unixpath)))
  {
    /* probe UNIX support */
    struct sockaddr_un s_un;
 
    if (strlen (unixpath) >= sizeof(s_un.sun_path))
    {
      LOG (GNUNET_ERROR_TYPE_WARNING,
           _ ("UNIXPATH `%s' too long, maximum length is %llu\n"),
           unixpath,
           (unsigned long long) sizeof(s_un.sun_path));
      unixpath = GNUNET_NETWORK_shorten_unixpath (unixpath);
      LOG (GNUNET_ERROR_TYPE_INFO, _ ("Using `%s' instead\n"), unixpath);
    }
#ifdef __linux__
    abstract = GNUNET_CONFIGURATION_get_value_yesno (cfg,
                                                     "TESTING",
                                                     "USE_ABSTRACT_SOCKETS");
    if (GNUNET_SYSERR == abstract)
      abstract = GNUNET_NO;
#endif
    if ((GNUNET_YES != abstract) &&
        (GNUNET_OK != GNUNET_DISK_directory_create_for_file (unixpath)))
      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "mkdir", unixpath);
  }
  if (NULL != unixpath)
  {
    desc = GNUNET_NETWORK_socket_create (AF_UNIX, SOCK_STREAM, 0);
    if (NULL == desc)
    {
      if ((ENOBUFS == errno) || (ENOMEM == errno) || (ENFILE == errno) ||
          (EACCES == errno))
      {
        GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "socket");
        GNUNET_free (hostname);
        GNUNET_free (unixpath);
        return GNUNET_SYSERR;
      }
      LOG (GNUNET_ERROR_TYPE_INFO,
           _ (
             "Disabling UNIX domain socket support for service `%s', failed to create UNIX domain socket: %s\n"),
           service_name,
           strerror (errno));
      GNUNET_free (unixpath);
      unixpath = NULL;
    }
    else
    {
      GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (desc));
      desc = NULL;
    }
  }
#endif
 
  if ((0 == port) && (NULL == unixpath))
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         _ (
           "Have neither PORT nor UNIXPATH for service `%s', but one is required\n"),
         service_name);
    GNUNET_free (hostname);
    return GNUNET_SYSERR;
  }
  if (0 == port)
  {
    saddrs = GNUNET_malloc (2 * sizeof(struct sockaddr *));
    saddrlens = GNUNET_malloc (2 * sizeof(socklen_t));
    add_unixpath (saddrs, saddrlens, unixpath, abstract);
    GNUNET_free (unixpath);
    GNUNET_free (hostname);
    *addrs = saddrs;
    *addr_lens = saddrlens;
    return 1;
  }
 
  if (NULL != hostname)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Resolving `%s' since that is where `%s' will bind to.\n",
         hostname,
         service_name);
    memset (&hints, 0, sizeof(struct addrinfo));
    if (disablev6)
      hints.ai_family = AF_INET;
    hints.ai_protocol = IPPROTO_TCP;
    if ((0 != (ret = getaddrinfo (hostname, NULL, &hints, &res))) ||
        (NULL == res))
    {
      LOG (GNUNET_ERROR_TYPE_ERROR,
           _ ("Failed to resolve `%s': %s\n"),
           hostname,
           gai_strerror (ret));
      GNUNET_free (hostname);
      GNUNET_free (unixpath);
      return GNUNET_SYSERR;
    }
    next = res;
    i = 0;
    while (NULL != (pos = next))
    {
      next = pos->ai_next;
      if ((disablev6) && (pos->ai_family == AF_INET6))
        continue;
      i++;
    }
    if (0 == i)
    {
      LOG (GNUNET_ERROR_TYPE_ERROR,
           _ ("Failed to find %saddress for `%s'.\n"),
           disablev6 ? "IPv4 " : "",
           hostname);
      freeaddrinfo (res);
      GNUNET_free (hostname);
      GNUNET_free (unixpath);
      return GNUNET_SYSERR;
    }
    resi = i;
    if (NULL != unixpath)
      resi++;
    saddrs = GNUNET_malloc ((resi + 1) * sizeof(struct sockaddr *));
    saddrlens = GNUNET_malloc ((resi + 1) * sizeof(socklen_t));
    i = 0;
    if (NULL != unixpath)
    {
      add_unixpath (saddrs, saddrlens, unixpath, abstract);
      i++;
    }
    next = res;
    while (NULL != (pos = next))
    {
      next = pos->ai_next;
      if ((disablev6) && (AF_INET6 == pos->ai_family))
        continue;
      if ((IPPROTO_TCP != pos->ai_protocol) && (0 != pos->ai_protocol))
        continue;     /* not TCP */
      if ((SOCK_STREAM != pos->ai_socktype) && (0 != pos->ai_socktype))
        continue;     /* huh? */
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Service `%s' will bind to `%s'\n",
           service_name,
           GNUNET_a2s (pos->ai_addr, pos->ai_addrlen));
      if (AF_INET == pos->ai_family)
      {
        GNUNET_assert (sizeof(struct sockaddr_in) == pos->ai_addrlen);
        saddrlens[i] = pos->ai_addrlen;
        saddrs[i] = GNUNET_malloc (saddrlens[i]);
        GNUNET_memcpy (saddrs[i], pos->ai_addr, saddrlens[i]);
        ((struct sockaddr_in *) saddrs[i])->sin_port = htons (port);
      }
      else
      {
        GNUNET_assert (AF_INET6 == pos->ai_family);
        GNUNET_assert (sizeof(struct sockaddr_in6) == pos->ai_addrlen);
        saddrlens[i] = pos->ai_addrlen;
        saddrs[i] = GNUNET_malloc (saddrlens[i]);
        GNUNET_memcpy (saddrs[i], pos->ai_addr, saddrlens[i]);
        ((struct sockaddr_in6 *) saddrs[i])->sin6_port = htons (port);
      }
      i++;
    }
    GNUNET_free (hostname);
    freeaddrinfo (res);
    resi = i;
  }
  else
  {
    /* will bind against everything, just set port */
    if (disablev6)
    {
      /* V4-only */
      resi = 1;
      if (NULL != unixpath)
        resi++;
      i = 0;
      saddrs = GNUNET_malloc ((resi + 1) * sizeof(struct sockaddr *));
      saddrlens = GNUNET_malloc ((resi + 1) * sizeof(socklen_t));
      if (NULL != unixpath)
      {
        add_unixpath (saddrs, saddrlens, unixpath, abstract);
        i++;
      }
      saddrlens[i] = sizeof(struct sockaddr_in);
      saddrs[i] = GNUNET_malloc (saddrlens[i]);
#if HAVE_SOCKADDR_IN_SIN_LEN
      ((struct sockaddr_in *) saddrs[i])->sin_len = saddrlens[i];
#endif
      ((struct sockaddr_in *) saddrs[i])->sin_family = AF_INET;
      ((struct sockaddr_in *) saddrs[i])->sin_port = htons (port);
    }
    else
    {
      /* dual stack */
      resi = 2;
      if (NULL != unixpath)
        resi++;
      saddrs = GNUNET_malloc ((resi + 1) * sizeof(struct sockaddr *));
      saddrlens = GNUNET_malloc ((resi + 1) * sizeof(socklen_t));
      i = 0;
      if (NULL != unixpath)
      {
        add_unixpath (saddrs, saddrlens, unixpath, abstract);
        i++;
      }
      saddrlens[i] = sizeof(struct sockaddr_in6);
      saddrs[i] = GNUNET_malloc (saddrlens[i]);
#if HAVE_SOCKADDR_IN_SIN_LEN
      ((struct sockaddr_in6 *) saddrs[i])->sin6_len = saddrlens[0];
#endif
      ((struct sockaddr_in6 *) saddrs[i])->sin6_family = AF_INET6;
      ((struct sockaddr_in6 *) saddrs[i])->sin6_port = htons (port);
      i++;
      saddrlens[i] = sizeof(struct sockaddr_in);
      saddrs[i] = GNUNET_malloc (saddrlens[i]);
#if HAVE_SOCKADDR_IN_SIN_LEN
      ((struct sockaddr_in *) saddrs[i])->sin_len = saddrlens[1];
#endif
      ((struct sockaddr_in *) saddrs[i])->sin_family = AF_INET;
      ((struct sockaddr_in *) saddrs[i])->sin_port = htons (port);
    }
  }
  GNUNET_free (unixpath);
  *addrs = saddrs;
  *addr_lens = saddrlens;
  return resi;
}

References _, add_unixpath(), cfg, GNUNET_a2s(), GNUNET_assert, GNUNET_break, GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_get_value_yesno(), GNUNET_CONFIGURATION_have_value(), GNUNET_DISK_directory_create_for_file(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log_strerror, GNUNET_log_strerror_file, GNUNET_malloc, GNUNET_memcpy, GNUNET_NETWORK_shorten_unixpath(), GNUNET_NETWORK_socket_close(), GNUNET_NETWORK_socket_create(), GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, hostname, LOG, port, res, ret, and service_name.

Referenced by libgnunet_plugin_transport_tcp_init().

Here is the call graph for this function:

Here is the caller graph for this function:

notify_session_monitor()

static void notify_session_monitor ( struct Plugin *  plugin, struct GNUNET_ATS_Session *  session, enum GNUNET_TRANSPORT_SessionState  state  )

static

If a session monitor is attached, notify it about the new session state.

Parameters

plugin	our plugin
session	session that changed state
state	new state of the session

Definition at line 1394 of file plugin_transport_tcp.c.

{
  struct GNUNET_TRANSPORT_SessionInfo info;
 
  if (NULL == plugin->sic)
    return;
  memset (&info, 0, sizeof(info));
  info.state = state;
  info.is_inbound =
    GNUNET_HELLO_address_check_option (session->address,
                                       GNUNET_HELLO_ADDRESS_INFO_INBOUND);
  info.num_msg_pending = session->msgs_in_queue;
  info.num_bytes_pending = session->bytes_in_queue;
  if (NULL != session->receive_delay_task)
    info.receive_delay = session->receive_delay;
  info.session_timeout = session->timeout;
  info.address = session->address;
  plugin->sic (plugin->sic_cls, session, &info);
}

References GNUNET_ATS_Session::address, GNUNET_ATS_Session::bytes_in_queue, GNUNET_HELLO_address_check_option(), GNUNET_HELLO_ADDRESS_INFO_INBOUND, info, GNUNET_ATS_Session::msgs_in_queue, plugin, GNUNET_ATS_Session::receive_delay, GNUNET_ATS_Session::receive_delay_task, state, and GNUNET_ATS_Session::timeout.

Referenced by create_session(), do_transmit(), send_session_info_iter(), session_timeout(), tcp_plugin_disconnect_session(), and tcp_plugin_send().

Here is the call graph for this function:

Here is the caller graph for this function:

tcp_nat_port_map_callback()

static void tcp_nat_port_map_callback ( void *  cls, void **  app_ctx, int  add_remove, enum GNUNET_NAT_AddressClass  ac, const struct sockaddr *  addr, socklen_t  addrlen  )

static

Our external IP address/port mapping has changed.

Parameters

	cls	closure, the struct Plugin
[in,out]	app_ctx	location where the app can store stuff on add and retrieve it on remove
	add_remove	GNUNET_YES to mean the new public IP address, GNUNET_NO to mean the previous (now invalid) one
	ac	address class the address belongs to
	addr	either the previous or the new public IP address
	addrlen	actual length of addr

Definition at line 1430 of file plugin_transport_tcp.c.

{
  struct Plugin *plugin = cls;
  struct GNUNET_HELLO_Address *address;
  struct IPv4TcpAddress t4;
  struct IPv6TcpAddress t6;
  void *arg;
  size_t args;
 
  (void) app_ctx;
  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));
    t4.options = htonl (plugin->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);
    break;
 
  case AF_INET6:
    if (IN6_IS_ADDR_LINKLOCAL (&((struct sockaddr_in6 *) addr)->sin6_addr))
    {
      /* skip link local, we don't allow them in
       #tcp_plugin_check_address() */
      return;
    }
    GNUNET_assert (addrlen == sizeof(struct sockaddr_in6));
    memset (&t6, 0, sizeof(t6));
    GNUNET_memcpy (&t6.ipv6_addr,
                   &((struct sockaddr_in6 *) addr)->sin6_addr,
                   sizeof(struct in6_addr));
    t6.options = htonl (plugin->myoptions);
    t6.t6_port = ((struct sockaddr_in6 *) addr)->sin6_port;
    arg = &t6;
    args = sizeof(t6);
    break;
 
  default:
    GNUNET_break (0);
    return;
  }
  /* modify our published address list */
  GNUNET_assert ((args == sizeof(struct IPv4TcpAddress)) ||
                 (args == sizeof(struct IPv6TcpAddress)));
  /* TODO: use 'ac' here in the future... */
  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);
}

References address, find_typedefs::arg, consensus-simulation::args, GNUNET_a2s(), GNUNET_assert, GNUNET_break, GNUNET_ERROR_TYPE_INFO, GNUNET_HELLO_address_allocate(), GNUNET_HELLO_address_free, GNUNET_HELLO_ADDRESS_INFO_NONE, GNUNET_memcpy, GNUNET_YES, LOG, plugin, PLUGIN_NAME, t4, and t6.

Referenced by libgnunet_plugin_transport_tcp_init().

Here is the call graph for this function:

Here is the caller graph for this function:

tcp_plugin_address_to_string()

static const char* tcp_plugin_address_to_string ( void *  cls, const void *  addr, size_t  addrlen  )

static

Function called for a quick conversion of the binary address to a numeric address.

Note that the caller must not free the address and that the next call to this function is allowed to override the address again.

Parameters

cls	closure (struct Plugin*)
addr	binary address
addrlen	length of addr

Returns

string representing the same address

Definition at line 1510 of file plugin_transport_tcp.c.

{
  static char rbuf[INET6_ADDRSTRLEN + 12];
  char buf[INET6_ADDRSTRLEN];
  const void *sb;
  struct in_addr a4;
  struct in6_addr a6;
  const struct IPv4TcpAddress *t4;
  const struct IPv6TcpAddress *t6;
  int af;
  uint16_t port;
  uint32_t options;
 
  switch (addrlen)
  {
  case sizeof(struct IPv6TcpAddress):
    t6 = addr;
    af = AF_INET6;
    port = ntohs (t6->t6_port);
    options = ntohl (t6->options);
    GNUNET_memcpy (&a6, &t6->ipv6_addr, sizeof(a6));
    sb = &a6;
    break;
 
  case sizeof(struct IPv4TcpAddress):
    t4 = addr;
    af = AF_INET;
    port = ntohs (t4->t4_port);
    options = ntohl (t4->options);
    GNUNET_memcpy (&a4, &t4->ipv4_addr, sizeof(a4));
    sb = &a4;
    break;
 
  default:
    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_snprintf (rbuf,
                   sizeof(rbuf),
                   (af == AF_INET6) ? "%s.%u.[%s]:%u" : "%s.%u.%s:%u",
                   PLUGIN_NAME,
                   options,
                   buf,
                   port);
  return rbuf;
}

References buf, GNUNET_ERROR_TYPE_WARNING, GNUNET_log_strerror, GNUNET_memcpy, GNUNET_snprintf(), IPv6TcpAddress::ipv6_addr, LOG, options, PLUGIN_NAME, port, t4, t6, and IPv6TcpAddress::t6_port.

Referenced by create_session(), disconnect_notify(), do_transmit(), handle_tcp_welcome(), libgnunet_plugin_transport_tcp_init(), nat_connect_timeout(), tcp_plugin_disconnect_session(), and tcp_plugin_get_session().

Here is the call graph for this function:

Here is the caller graph for this function:

tcp_plugin_string_to_address()

static int tcp_plugin_string_to_address ( void *  cls, const char *  addr, uint16_t  addrlen, void **  buf, size_t *  added  )

static

Function called to convert a string address to a binary address.

Parameters

cls	closure (struct Plugin*)
addr	string address
addrlen	length of the address
buf	location to store the buffer
added	location to store the number of bytes in the buffer. If the function returns GNUNET_SYSERR, its contents are undefined.

Returns

GNUNET_OK on success, GNUNET_SYSERR on failure

Definition at line 1578 of file plugin_transport_tcp.c.

{
  struct sockaddr_storage socket_address;
  char *address;
  char *plugin;
  char *optionstr;
  uint32_t options;
 
  /* Format tcp.options.address:port */
  address = NULL;
  plugin = NULL;
  optionstr = NULL;
  if ((NULL == addr) || (0 == addrlen))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  if ('\0' != addr[addrlen - 1])
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  if (strlen (addr) != addrlen - 1)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  plugin = GNUNET_strdup (addr);
  optionstr = strchr (plugin, '.');
  if (NULL == optionstr)
  {
    GNUNET_break (0);
    GNUNET_free (plugin);
    return GNUNET_SYSERR;
  }
  optionstr[0] = '\0';
  optionstr++;
  options = atol (optionstr);
  address = strchr (optionstr, '.');
  if (NULL == address)
  {
    GNUNET_break (0);
    GNUNET_free (plugin);
    return GNUNET_SYSERR;
  }
  address[0] = '\0';
  address++;
 
  if (GNUNET_OK !=
      GNUNET_STRINGS_to_address_ip (address, strlen (address), &socket_address))
  {
    GNUNET_break (0);
    GNUNET_free (plugin);
    return GNUNET_SYSERR;
  }
 
  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;
    }
 
  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;
    }
 
  default:
    return GNUNET_SYSERR;
  }
}

References address, buf, GNUNET_break, GNUNET_free, GNUNET_new, GNUNET_OK, GNUNET_strdup, GNUNET_STRINGS_to_address_ip(), GNUNET_SYSERR, options, plugin, t4, and t6.

Referenced by libgnunet_plugin_transport_tcp_init().

Here is the call graph for this function:

Here is the caller graph for this function:

lookup_session_by_client()

static struct GNUNET_ATS_Session* lookup_session_by_client ( struct Plugin *  plugin, struct GNUNET_SERVER_Client *  client  )

static

Find the session handle for the given client.

Currently uses both the hashmap and the client context, as the client context is new and the logic still needs to be tested.

Parameters

plugin	the plugin
client	which client to find the session handle for

Returns

NULL if no matching session exists

Definition at line 1682 of file plugin_transport_tcp.c.

{
  return GNUNET_SERVER_client_get_user_context (client,
                                                struct GNUNET_ATS_Session);
}

References GNUNET_ATS_Session::client, and GNUNET_SERVER_client_get_user_context.

Referenced by disconnect_notify(), handle_tcp_data(), and handle_tcp_welcome().

Here is the caller graph for this function:

tcp_plugin_disconnect_session()

static int tcp_plugin_disconnect_session ( void *  cls, struct GNUNET_ATS_Session *  session  )

static

Functions with this signature are called whenever we need to close a session due to a disconnect or failure to establish a connection.

Parameters

cls	the struct Plugin
session	session to close down

Returns

GNUNET_OK on success

Definition at line 1700 of file plugin_transport_tcp.c.

{
  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_plugin_address_to_string (session->plugin,
                                     session->address->address,
                                     session->address->address_length));
 
  if (NULL != session->timeout_task)
  {
    GNUNET_SCHEDULER_cancel (session->timeout_task);
    session->timeout_task = NULL;
    session->timeout = GNUNET_TIME_UNIT_ZERO_ABS;
  }
 
  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);
  }
  else
  {
    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, NULL);
 
  /* clean up state */
  if (NULL != session->transmit_handle)
  {
    GNUNET_SERVER_notify_transmit_ready_cancel (session->transmit_handle);
    session->transmit_handle = NULL;
  }
  session->plugin->env->session_end (session->plugin->env->cls,
                                     session->address,
                                     session);
 
  if (NULL != session->nat_connection_timeout)
  {
    GNUNET_SCHEDULER_cancel (session->nat_connection_timeout);
    session->nat_connection_timeout = NULL;
  }
 
  while (NULL != (pm = session->pending_messages_head))
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         (NULL != pm->transmit_cont)
         ? "Could not deliver message to `%s' at %s.\n"
         : "Could not deliver message to `%s' at %s, notifying.\n",
         GNUNET_i2s (&session->target),
         tcp_plugin_address_to_string (session->plugin,
                                       session->address->address,
                                       session->address->address_length));
    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);
    GNUNET_assert (0 < session->msgs_in_queue);
    session->msgs_in_queue--;
    GNUNET_assert (pm->message_size <= session->bytes_in_queue);
    session->bytes_in_queue -= pm->message_size;
    if (NULL != pm->transmit_cont)
      pm->transmit_cont (pm->transmit_cont_cls,
                         &session->target,
                         GNUNET_SYSERR,
                         pm->message_size,
                         0);
    GNUNET_free (pm);
  }
  GNUNET_assert (0 == session->msgs_in_queue);
  GNUNET_assert (0 == session->bytes_in_queue);
  notify_session_monitor (session->plugin, session, GNUNET_TRANSPORT_SS_DONE);
 
  if (NULL != session->receive_delay_task)
  {
    GNUNET_SCHEDULER_cancel (session->receive_delay_task);
    session->receive_delay_task = NULL;
  }
  if (NULL != session->client)
  {
    GNUNET_SERVER_client_disconnect (session->client);
    session->client = NULL;
  }
  GNUNET_HELLO_address_free (session->address);
  GNUNET_assert (NULL == session->transmit_handle);
  GNUNET_free (session);
  return GNUNET_OK;
}

References GNUNET_HELLO_Address::address, GNUNET_ATS_Session::address, GNUNET_HELLO_Address::address_length, GNUNET_ATS_Session::bytes_in_queue, GNUNET_ATS_Session::client, GNUNET_DATACACHE_PluginEnvironment::cls, Plugin::env, gettext_noop, GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multipeermap_remove(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_HELLO_address_free, GNUNET_i2s(), GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_cancel(), GNUNET_SERVER_client_disconnect(), GNUNET_SERVER_client_set_user_context, GNUNET_SERVER_notify_transmit_ready_cancel(), GNUNET_STATISTICS_update(), GNUNET_SYSERR, GNUNET_TIME_UNIT_ZERO_ABS, GNUNET_TRANSPORT_SS_DONE, GNUNET_YES, LOG, GNUNET_ATS_Session::msgs_in_queue, GNUNET_ATS_Session::nat_connection_timeout, notify_session_monitor(), GNUNET_ATS_Session::pending_messages_head, GNUNET_ATS_Session::pending_messages_tail, plugin, GNUNET_ATS_Session::plugin, pm, GNUNET_ATS_Session::receive_delay_task, GNUNET_ATS_Session::target, tcp_plugin_address_to_string(), GNUNET_ATS_Session::timeout, GNUNET_ATS_Session::timeout_task, and GNUNET_ATS_Session::transmit_handle.

Referenced by disconnect_notify(), handle_tcp_nat_probe(), libgnunet_plugin_transport_tcp_init(), nat_connect_timeout(), session_disconnect_it(), session_timeout(), and tcp_plugin_get_session().

Here is the call graph for this function:

Here is the caller graph for this function:

tcp_plugin_query_keepalive_factor()

static unsigned int tcp_plugin_query_keepalive_factor ( void *  cls )

static

Function that is called to get the keepalive factor.

GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT is divided by this number to calculate the interval between keepalive packets.

Parameters

cls	closure with the struct Plugin

Returns

keepalive factor

Definition at line 1818 of file plugin_transport_tcp.c.

{
  return 3;
}

Referenced by libgnunet_plugin_transport_tcp_init().

Here is the caller graph for this function:

session_timeout()

static void session_timeout ( void *  cls )

static

Session was idle for too long, so disconnect it.

Parameters

cls	the struct GNUNET_ATS_Session of the idle session

Definition at line 1830 of file plugin_transport_tcp.c.

{
  struct GNUNET_ATS_Session *s = cls;
  struct GNUNET_TIME_Relative left;
 
  s->timeout_task = NULL;
  left = GNUNET_TIME_absolute_get_remaining (s->timeout);
  if (0 != left.rel_value_us)
  {
    /* not actually our turn yet, but let's at least update
       the monitor, it may think we're about to die ... */
    notify_session_monitor (s->plugin, s, GNUNET_TRANSPORT_SS_UPDATE);
    s->timeout_task = GNUNET_SCHEDULER_add_delayed (left, &session_timeout, s);
    return;
  }
  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_plugin_disconnect_session (s->plugin, s);
}

References GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, GNUNET_ERROR_TYPE_DEBUG, GNUNET_SCHEDULER_add_delayed(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get_remaining(), GNUNET_TRANSPORT_SS_UPDATE, GNUNET_YES, LOG, notify_session_monitor(), GNUNET_ATS_Session::plugin, GNUNET_TIME_Relative::rel_value_us, tcp_plugin_disconnect_session(), GNUNET_ATS_Session::timeout, and GNUNET_ATS_Session::timeout_task.

Referenced by create_session().

Here is the call graph for this function:

Here is the caller graph for this function:

reschedule_session_timeout()

static void reschedule_session_timeout ( struct GNUNET_ATS_Session *  s )

static

Increment session timeout due to activity.

Parameters

s	session to increment timeout for

Definition at line 1862 of file plugin_transport_tcp.c.

{
  GNUNET_assert (NULL != s->timeout_task);
  s->timeout =
    GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
}

References GNUNET_assert, GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, GNUNET_TIME_relative_to_absolute(), GNUNET_ATS_Session::timeout, and GNUNET_ATS_Session::timeout_task.

Referenced by delayed_done(), handle_tcp_data(), and tcp_plugin_update_session_timeout().

Here is the call graph for this function:

Here is the caller graph for this function:

create_session()

static struct GNUNET_ATS_Session* create_session ( struct Plugin *  plugin, const struct GNUNET_HELLO_Address *  address, enum GNUNET_NetworkType  scope, struct GNUNET_SERVER_Client *  client, int  is_nat  )

static

Create a new session.

Also queues a welcome message.

Parameters

plugin	the plugin
address	the address to create the session for
scope	network scope the address is from
client	client to use, reference counter must have already been increased
is_nat	this a NAT session, we should wait for a client to connect to us from an address, then assign that to the session

Returns

new session object

Definition at line 1883 of file plugin_transport_tcp.c.

{
  struct GNUNET_ATS_Session *session;
  struct PendingMessage *pm;
 
  if (GNUNET_YES != is_nat)
    GNUNET_assert (NULL != client);
  else
    GNUNET_assert (NULL == client);
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Creating new session for peer `%s' at address %s\n",
       GNUNET_i2s (&address->peer),
       tcp_plugin_address_to_string (plugin,
                                     address->address,
                                     address->address_length));
  session = GNUNET_new (struct GNUNET_ATS_Session);
  session->last_activity = GNUNET_TIME_absolute_get ();
  session->plugin = plugin;
  session->is_nat = is_nat;
  if (NULL != client)
  {
    session->client = client;
    GNUNET_SERVER_client_set_user_context (client, session);
  }
  session->address = GNUNET_HELLO_address_copy (address);
  session->target = address->peer;
  session->expecting_welcome = GNUNET_YES;
  session->scope = scope;
  pm = GNUNET_malloc (sizeof(struct PendingMessage)
                      + sizeof(struct WelcomeMessage));
  pm->msg = (const char *) &pm[1];
  pm->message_size = sizeof(struct WelcomeMessage);
  GNUNET_memcpy (&pm[1], &plugin->my_welcome, sizeof(struct WelcomeMessage));
  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);
  session->msgs_in_queue++;
  session->bytes_in_queue += pm->message_size;
  session->timeout =
    GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
  session->timeout_task =
    GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
                                  &session_timeout,
                                  session);
  notify_session_monitor (session->plugin, session, GNUNET_TRANSPORT_SS_INIT);
  if (GNUNET_YES != is_nat)
  {
    GNUNET_STATISTICS_update (plugin->env->stats,
                              gettext_noop ("# TCP sessions active"),
                              1,
                              GNUNET_NO);
    notify_session_monitor (session->plugin, session, GNUNET_TRANSPORT_SS_UP);
  }
  else
  {
    notify_session_monitor (session->plugin,
                            session,
                            GNUNET_TRANSPORT_SS_HANDSHAKE);
  }
  return session;
}

References address, GNUNET_ATS_Session::address, GNUNET_ATS_Session::bytes_in_queue, PendingMessage::client, GNUNET_ATS_Session::client, GNUNET_ATS_Session::expecting_welcome, gettext_noop, GNUNET_assert, GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_HELLO_address_copy(), GNUNET_i2s(), GNUNET_malloc, GNUNET_memcpy, GNUNET_new, GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_SERVER_client_set_user_context, GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_get(), GNUNET_TIME_relative_to_absolute(), GNUNET_TIME_UNIT_FOREVER_ABS, GNUNET_TRANSPORT_SS_HANDSHAKE, GNUNET_TRANSPORT_SS_INIT, GNUNET_TRANSPORT_SS_UP, GNUNET_YES, GNUNET_ATS_Session::is_nat, GNUNET_ATS_Session::last_activity, LOG, GNUNET_ATS_Session::msgs_in_queue, notify_session_monitor(), GNUNET_ATS_Session::pending_messages_head, GNUNET_ATS_Session::pending_messages_tail, plugin, GNUNET_ATS_Session::plugin, pm, GNUNET_ATS_Session::scope, scope, session_timeout(), GNUNET_ATS_Session::target, tcp_plugin_address_to_string(), GNUNET_ATS_Session::timeout, and GNUNET_ATS_Session::timeout_task.

Referenced by handle_tcp_welcome(), and tcp_plugin_get_session().

Here is the call graph for this function:

Here is the caller graph for this function:

process_pending_messages()

static void process_pending_messages ( struct GNUNET_ATS_Session *  session )

static

If we have pending messages, ask the server to transmit them (schedule the respective tasks, etc.)

Parameters

session

for which session should we do this

Definition at line 2125 of file plugin_transport_tcp.c.

{
  struct PendingMessage *pm;
 
  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);
}

References GNUNET_ATS_Session::client, do_transmit(), GNUNET_assert, GNUNET_SERVER_notify_transmit_ready(), GNUNET_TIME_absolute_get_remaining(), GNUNET_ATS_Session::pending_messages_head, pm, and GNUNET_ATS_Session::transmit_handle.

Referenced by do_transmit(), handle_tcp_nat_probe(), handle_tcp_welcome(), tcp_plugin_get_session(), and tcp_plugin_send().

Here is the call graph for this function:

Here is the caller graph for this function:

do_transmit()

static size_t do_transmit ( void *  cls, size_t  size, void *  buf  )

static

Function called to notify a client about the socket being ready to queue more data.

"buf" will be NULL and "size" zero if the socket was closed for writing in the meantime.

Parameters

cls	closure
size	number of bytes available in buf
buf	where the callee should write the message

Returns

number of bytes written to buf

Definition at line 1978 of file plugin_transport_tcp.c.

{
  struct GNUNET_ATS_Session *session = cls;
  struct GNUNET_PeerIdentity pid;
  struct Plugin *plugin;
  struct PendingMessage *pos;
  struct PendingMessage *hd;
  struct PendingMessage *tl;
  struct GNUNET_TIME_Absolute now;
  char *cbuf;
  size_t ret;
 
  session->transmit_handle = NULL;
  plugin = session->plugin;
  if (NULL == buf)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Timeout trying to transmit to peer `%s', 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))
    {
      GNUNET_CONTAINER_DLL_remove (session->pending_messages_head,
                                   session->pending_messages_tail,
                                   pos);
      GNUNET_assert (0 < session->msgs_in_queue);
      session->msgs_in_queue--;
      GNUNET_assert (pos->message_size <= session->bytes_in_queue);
      session->bytes_in_queue -= pos->message_size;
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Failed to transmit %lu byte message to `%s'.\n",
           (unsigned long) pos->message_size,
           GNUNET_i2s (&session->target));
      ret += pos->message_size;
      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
     * call) */
    process_pending_messages (session);
    pid = session->target;
    /* no do callbacks and do not use session again since
     * the callbacks may abort the session */
    while (NULL != (pos = hd))
    {
      GNUNET_CONTAINER_DLL_remove (hd, tl, pos);
      if (NULL != pos->transmit_cont)
        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);
    if (0 < ret)
      notify_session_monitor (session->plugin,
                              session,
                              GNUNET_TRANSPORT_SS_UPDATE);
    return 0;
  }
  /* copy all pending messages that would fit */
  ret = 0;
  cbuf = buf;
  hd = NULL;
  tl = NULL;
  while (NULL != (pos = session->pending_messages_head))
  {
    if (ret + pos->message_size > size)
      break;
    GNUNET_CONTAINER_DLL_remove (session->pending_messages_head,
                                 session->pending_messages_tail,
                                 pos);
    GNUNET_assert (0 < session->msgs_in_queue);
    session->msgs_in_queue--;
    GNUNET_assert (pos->message_size <= session->bytes_in_queue);
    session->bytes_in_queue -= pos->message_size;
    GNUNET_assert (size >= pos->message_size);
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Transmitting message of type %u size %lu to peer %s at %s\n",
         ntohs (((struct GNUNET_MessageHeader *) pos->msg)->type),
         (unsigned long) pos->message_size,
         GNUNET_i2s (&session->target),
         tcp_plugin_address_to_string (session->plugin,
                                       session->address->address,
                                       session->address->address_length));
    /* FIXME: this GNUNET_memcpy can be up to 7% of our total runtime */
    GNUNET_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);
  }
  notify_session_monitor (session->plugin, session, GNUNET_TRANSPORT_SS_UPDATE);
  /* schedule 'continuation' before callbacks so that callbacks that
   * cancel everything don't cause us to use a session that no longer
   * exists... */
  process_pending_messages (session);
  session->last_activity = GNUNET_TIME_absolute_get ();
  pid = session->target;
  /* we'll now call callbacks that may cancel the session; hence
   * we should not use 'session' after this point */
  while (NULL != (pos = hd))
  {
    GNUNET_CONTAINER_DLL_remove (hd, tl, pos);
    if (NULL != pos->transmit_cont)
      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 (NULL == hd);
  GNUNET_assert (NULL == tl);
  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 transmitted via TCP"),
                            ret,
                            GNUNET_NO);
  return ret;
}

References GNUNET_TIME_Absolute::abs_value_us, GNUNET_HELLO_Address::address, GNUNET_ATS_Session::address, GNUNET_HELLO_Address::address_length, buf, GNUNET_ATS_Session::bytes_in_queue, gettext_noop, GNUNET_assert, GNUNET_CONTAINER_DLL_insert_after, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_memcpy, GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_update(), GNUNET_SYSERR, GNUNET_TIME_absolute_get(), GNUNET_TRANSPORT_SS_UPDATE, GNUNET_ATS_Session::last_activity, LOG, PendingMessage::message_size, PendingMessage::msg, GNUNET_ATS_Session::msgs_in_queue, notify_session_monitor(), GNUNET_ATS_Session::pending_messages_head, GNUNET_ATS_Session::pending_messages_tail, pid, plugin, GNUNET_ATS_Session::plugin, process_pending_messages(), ret, size, GNUNET_ATS_Session::target, tcp_plugin_address_to_string(), PendingMessage::timeout, PendingMessage::transmit_cont, PendingMessage::transmit_cont_cls, and GNUNET_ATS_Session::transmit_handle.

Referenced by process_pending_messages().

Here is the call graph for this function:

Here is the caller graph for this function:

tcp_plugin_send()

static ssize_t tcp_plugin_send ( void *  cls, struct GNUNET_ATS_Session *  session, const char *  msgbuf, size_t  msgbuf_size, unsigned int  priority, struct GNUNET_TIME_Relative  to, GNUNET_TRANSPORT_TransmitContinuation  cont, void *  cont_cls  )

static

Function that can be used by the transport service to transmit a message using the plugin.

Note that in the case of a peer disconnecting, the continuation MUST be called prior to the disconnect notification itself. This function will be called with this peer's HELLO message to initiate a fresh connection to another peer.

Parameters

cls	closure
session	which session must be used
msgbuf	the message to transmit
msgbuf_size	number of bytes in msgbuf
priority	how important is the message (most plugins will ignore message priority and just FIFO)
to	how long to wait at most for the transmission (does not require plugins to discard the message after the timeout, just advisory for the desired delay; most plugins will ignore this as well)
cont	continuation to call once the message has been transmitted (or if the transport is ready for the next transmission call; or if the peer disconnected...); can be NULL
cont_cls	closure for cont

Returns

number of bytes used (on the physical network, with overheads); -1 on hard errors (i.e. address invalid); 0 is a legal value and does NOT mean that the message was not transmitted (DV)

Definition at line 2173 of file plugin_transport_tcp.c.

{
  struct Plugin *plugin = cls;
  struct PendingMessage *pm;
 
  /* create new message entry */
  pm = GNUNET_malloc (sizeof(struct PendingMessage) + msgbuf_size);
  pm->msg = (const char *) &pm[1];
  GNUNET_memcpy (&pm[1], msgbuf, msgbuf_size);
  pm->message_size = msgbuf_size;
  pm->timeout = GNUNET_TIME_relative_to_absolute (to);
  pm->transmit_cont = cont;
  pm->transmit_cont_cls = cont_cls;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Asked to transmit %lu bytes to `%s', added message to list.\n",
       (unsigned long) msgbuf_size,
       GNUNET_i2s (&session->target));
 
  if (GNUNET_YES ==
      GNUNET_CONTAINER_multipeermap_contains_value (plugin->sessionmap,
                                                    &session->target,
                                                    session))
  {
    GNUNET_assert (NULL != session->client);
    GNUNET_SERVER_client_set_timeout (session->client,
                                      GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
    GNUNET_STATISTICS_update (plugin->env->stats,
                              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);
    notify_session_monitor (session->plugin,
                            session,
                            GNUNET_TRANSPORT_SS_UPDATE);
    session->msgs_in_queue++;
    session->bytes_in_queue += pm->message_size;
    process_pending_messages (session);
    return msgbuf_size;
  }
  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));
    GNUNET_STATISTICS_update (plugin->env->stats,
                              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);
    session->msgs_in_queue++;
    session->bytes_in_queue += pm->message_size;
    notify_session_monitor (session->plugin,
                            session,
                            GNUNET_TRANSPORT_SS_HANDSHAKE);
    return msgbuf_size;
  }
  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);
  return GNUNET_SYSERR; /* session does not exist here */
}

References GNUNET_ATS_Session::bytes_in_queue, GNUNET_ATS_Session::client, gettext_noop, GNUNET_assert, GNUNET_break, GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_CONTAINER_multipeermap_contains_value(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_i2s(), GNUNET_malloc, GNUNET_memcpy, GNUNET_NO, GNUNET_SERVER_client_set_timeout(), GNUNET_STATISTICS_update(), GNUNET_SYSERR, GNUNET_TIME_relative_to_absolute(), GNUNET_TRANSPORT_SS_HANDSHAKE, GNUNET_TRANSPORT_SS_UPDATE, GNUNET_YES, LOG, GNUNET_ATS_Session::msgs_in_queue, notify_session_monitor(), GNUNET_ATS_Session::pending_messages_head, GNUNET_ATS_Session::pending_messages_tail, plugin, GNUNET_ATS_Session::plugin, pm, process_pending_messages(), and GNUNET_ATS_Session::target.

Referenced by libgnunet_plugin_transport_tcp_init().

Here is the call graph for this function:

Here is the caller graph for this function:

session_lookup_it()

static int session_lookup_it ( void *  cls, const struct GNUNET_PeerIdentity *  key, void *  value  )

static

Look for a session by address.

Parameters

cls	the struct GNUNET_ATS_SessionItCtx
key	unused
value	a struct GNUNET_ATS_Session

Returns

GNUNET_YES to continue looking, GNUNET_NO if we found the session

Definition at line 2282 of file plugin_transport_tcp.c.

{
  struct GNUNET_ATS_SessionItCtx *si_ctx = cls;
  struct GNUNET_ATS_Session *session = value;
 
  if (0 != GNUNET_HELLO_address_cmp (si_ctx->address, session->address))
    return GNUNET_YES;
  si_ctx->result = session;
  return GNUNET_NO;
}

References GNUNET_ATS_Session::address, GNUNET_ATS_SessionItCtx::address, GNUNET_HELLO_address_cmp(), GNUNET_NO, GNUNET_YES, GNUNET_ATS_SessionItCtx::result, and value.

Referenced by tcp_plugin_get_session().

Here is the call graph for this function:

Here is the caller graph for this function:

nat_connect_timeout()

static void nat_connect_timeout ( void *  cls )

static

Task cleaning up a NAT connection attempt after timeout.

Parameters

cls	the struct GNUNET_ATS_Session

Definition at line 2302 of file plugin_transport_tcp.c.

{
  struct GNUNET_ATS_Session *session = cls;
 
  session->nat_connection_timeout = NULL;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "NAT WAIT connection to `%4s' at `%s' could not be established, removing session\n",
       GNUNET_i2s (&session->target),
       tcp_plugin_address_to_string (session->plugin,
                                     session->address->address,
                                     session->address->address_length));
  tcp_plugin_disconnect_session (session->plugin, session);
}

References GNUNET_HELLO_Address::address, GNUNET_ATS_Session::address, GNUNET_HELLO_Address::address_length, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), LOG, GNUNET_ATS_Session::nat_connection_timeout, GNUNET_ATS_Session::plugin, GNUNET_ATS_Session::target, tcp_plugin_address_to_string(), and tcp_plugin_disconnect_session().

Referenced by tcp_plugin_get_session().

Here is the call graph for this function:

Here is the caller graph for this function:

tcp_plugin_update_session_timeout()

static void tcp_plugin_update_session_timeout ( void *  cls, const struct GNUNET_PeerIdentity *  peer, struct GNUNET_ATS_Session *  session  )

static

Function that will be called whenever the transport service wants to notify the plugin that a session is still active and in use and therefore the session timeout for this session has to be updated.

Parameters

cls	closure
peer	which peer was the session for
session	which session is being updated

Definition at line 2327 of file plugin_transport_tcp.c.

{
  reschedule_session_timeout (session);
}

References reschedule_session_timeout().

Referenced by libgnunet_plugin_transport_tcp_init().

Here is the call graph for this function:

Here is the caller graph for this function:

delayed_done()

static void delayed_done ( void *  cls )

static

Task to signal the server that we can continue receiving from the TCP client now.

Parameters

cls	the struct GNUNET_ATS_Session *

Definition at line 2342 of file plugin_transport_tcp.c.

{
  struct GNUNET_ATS_Session *session = cls;
 
  session->receive_delay_task = NULL;
  reschedule_session_timeout (session);
  GNUNET_SERVER_receive_done (session->client, GNUNET_OK);
}

References GNUNET_ATS_Session::client, GNUNET_OK, GNUNET_SERVER_receive_done(), GNUNET_ATS_Session::receive_delay_task, and reschedule_session_timeout().

Referenced by handle_tcp_data(), and tcp_plugin_update_inbound_delay().

Here is the call graph for this function:

Here is the caller graph for this function:

tcp_plugin_update_inbound_delay()

static void tcp_plugin_update_inbound_delay ( void *  cls, const struct GNUNET_PeerIdentity *  peer, struct GNUNET_ATS_Session *  session, struct GNUNET_TIME_Relative  delay  )

static

Function that will be called whenever the transport service wants to notify the plugin that the inbound quota changed and that the plugin should update it's delay for the next receive value.

Parameters

cls	closure
peer	which peer was the session for
session	which session is being updated
delay	new delay to use for receiving

Definition at line 2363 of file plugin_transport_tcp.c.

{
  if (NULL == session->receive_delay_task)
    return;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "New inbound delay %s\n",
       GNUNET_STRINGS_relative_time_to_string (delay, GNUNET_NO));
  session->receive_delay = GNUNET_TIME_relative_to_absolute (delay);
  GNUNET_SCHEDULER_cancel (session->receive_delay_task);
  session->receive_delay_task =
    GNUNET_SCHEDULER_add_delayed (delay, &delayed_done, session);
}

References delay, delayed_done(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_cancel(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_relative_to_absolute(), LOG, GNUNET_ATS_Session::receive_delay, and GNUNET_ATS_Session::receive_delay_task.

Referenced by libgnunet_plugin_transport_tcp_init().

Here is the call graph for this function:

Here is the caller graph for this function:

tcp_plugin_get_session()

static struct GNUNET_ATS_Session* tcp_plugin_get_session ( void *  cls, const struct GNUNET_HELLO_Address *  address  )

static

Create a new session to transmit data to the target This session will used to send data to this peer and the plugin will notify us by calling the env->session_end function.

Parameters

cls	closure
address	the address to use

Returns

the session if the address is valid, NULL otherwise

Definition at line 2390 of file plugin_transport_tcp.c.

{
  struct Plugin *plugin = cls;
  struct GNUNET_ATS_Session *session = NULL;
  int af;
  const void *sb;
  size_t sbs;
  struct GNUNET_CONNECTION_Handle *sa;
  struct sockaddr_in a4;
  struct sockaddr_in6 a6;
  const struct IPv4TcpAddress *t4;
  const struct IPv6TcpAddress *t6;
  unsigned int options;
  enum GNUNET_NetworkType net_type;
  unsigned int is_natd = GNUNET_NO;
  size_t addrlen;
 
#ifdef TCP_STEALTH
  struct GNUNET_NETWORK_Handle *s;
#endif
 
  addrlen = address->address_length;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Trying to get session for `%s' address of peer `%s'\n",
       tcp_plugin_address_to_string (plugin,
                                     address->address,
                                     address->address_length),
       GNUNET_i2s (&address->peer));
 
  if (GNUNET_HELLO_address_check_option (address,
                                         GNUNET_HELLO_ADDRESS_INFO_INBOUND))
  {
    GNUNET_break (0);
    return NULL;
  }
 
  /* look for existing session */
  if (GNUNET_YES == GNUNET_CONTAINER_multipeermap_contains (plugin->sessionmap,
                                                            &address->peer))
  {
    struct GNUNET_ATS_SessionItCtx si_ctx;
 
    si_ctx.address = address;
    si_ctx.result = NULL;
    GNUNET_CONTAINER_multipeermap_get_multiple (plugin->sessionmap,
                                                &address->peer,
                                                &session_lookup_it,
                                                &si_ctx);
    if (NULL != si_ctx.result)
    {
      session = si_ctx.result;
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Found existing session for `%s' address `%s'\n",
           GNUNET_i2s (&address->peer),
           tcp_plugin_address_to_string (plugin,
                                         address->address,
                                         address->address_length));
      return session;
    }
    /* This is a bit of a hack, limiting TCP to never allow more than
       one TCP connection to any given peer at the same time.
       Without this, peers sometimes disagree about which of the TCP
       connections they should use, causing one side to believe that
       they transmit successfully, while the other receives nothing. */return NULL; /* Refuse to have more than one TCP connection per
                      peer pair at the same time. */
  }
 
  if (addrlen == sizeof(struct IPv6TcpAddress))
  {
    GNUNET_assert (NULL != address->address);  /* make static analysis happy */
    t6 = address->address;
    options = t6->options;
    af = AF_INET6;
    memset (&a6, 0, sizeof(a6));
#if HAVE_SOCKADDR_IN_SIN_LEN
    a6.sin6_len = sizeof(a6);
#endif
    a6.sin6_family = AF_INET6;
    a6.sin6_port = t6->t6_port;
    if (t6->t6_port == 0)
      is_natd = GNUNET_YES;
    GNUNET_memcpy (&a6.sin6_addr, &t6->ipv6_addr, sizeof(struct in6_addr));
    sb = &a6;
    sbs = sizeof(a6);
  }
  else if (addrlen == sizeof(struct IPv4TcpAddress))
  {
    GNUNET_assert (NULL != address->address);  /* make static analysis happy */
    t4 = address->address;
    options = t4->options;
    af = AF_INET;
    memset (&a4, 0, sizeof(a4));
#if HAVE_SOCKADDR_IN_SIN_LEN
    a4.sin_len = sizeof(a4);
#endif
    a4.sin_family = AF_INET;
    a4.sin_port = t4->t4_port;
    if (t4->t4_port == 0)
      is_natd = GNUNET_YES;
    a4.sin_addr.s_addr = t4->ipv4_addr;
    sb = &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;
  }
 
  net_type = plugin->env->get_address_type (plugin->env->cls, sb, sbs);
  GNUNET_break (net_type != GNUNET_NT_UNSPECIFIED);
 
  if ((is_natd == GNUNET_YES) && (addrlen == sizeof(struct IPv6TcpAddress)))
  {
    /* NAT client only works with IPv4 addresses */
    return NULL;
  }
 
  if (plugin->cur_connections >= plugin->max_connections)
  {
    /* saturated */
    return NULL;
  }
 
  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;
  }
 
  if ((is_natd == GNUNET_YES) && (NULL != plugin->nat) &&
      (GNUNET_NO ==
       GNUNET_CONTAINER_multipeermap_contains (plugin->nat_wait_conns,
                                               &address->peer)))
  {
    struct sockaddr_in local_sa;
 
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Found valid IPv4 NAT address (creating session)!\n");
    session = create_session (plugin, address, net_type, NULL, GNUNET_YES);
    session->nat_connection_timeout =
      GNUNET_SCHEDULER_add_delayed (NAT_TIMEOUT, &nat_connect_timeout, session);
    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 `%s' at `%s'\n",
         GNUNET_i2s (&session->target),
         GNUNET_a2s (sb, sbs));
    memset (&local_sa, 0, sizeof(local_sa));
    local_sa.sin_family = AF_INET;
    local_sa.sin_port = htons (plugin->open_port);
    /* We leave sin_address at 0, let the kernel figure it out,
       even if our bind() is more specific.  (May want to reconsider
       later.) */
    if (GNUNET_OK == GNUNET_NAT_request_reversal (plugin->nat, &local_sa, &a4))
      return session;
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Running NAT client for `%s' at `%s' failed\n",
         GNUNET_i2s (&session->target),
         GNUNET_a2s (sb, sbs));
    tcp_plugin_disconnect_session (plugin, session);
    return NULL;
  }
 
  /* create new outbound session */
  if (0 != (options & TCP_OPTIONS_TCP_STEALTH))
  {
#ifdef TCP_STEALTH
    s = GNUNET_NETWORK_socket_create (af, SOCK_STREAM, 0);
    if (NULL == s)
    {
      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING | GNUNET_ERROR_TYPE_BULK,
                           "socket");
      sa = NULL;
    }
    else
    {
      if ((GNUNET_OK !=
           GNUNET_NETWORK_socket_setsockopt (s,
                                             IPPROTO_TCP,
                                             TCP_STEALTH,
                                             &session->target,
                                             sizeof(
                                               struct GNUNET_PeerIdentity))) ||
          (GNUNET_OK !=
           GNUNET_NETWORK_socket_setsockopt (s,
                                             IPPROTO_TCP,
                                             TCP_STEALTH_INTEGRITY,
                                             &plugin->my_welcome,
                                             sizeof(struct WelcomeMessage))))
      {
        /* TCP STEALTH not supported by kernel */
        GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (s));
        sa = NULL;
      }
      else
      {
        sa = GNUNET_CONNECTION_connect_socket (s, sb, sbs);
      }
    }
#else
    sa = NULL;
#endif
  }
  else
  {
    sa = GNUNET_CONNECTION_create_from_sockaddr (af, sb, sbs);
  }
  if (NULL == sa)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Failed to create connection to `%s' at `%s'\n",
         GNUNET_i2s (&address->peer),
         GNUNET_a2s (sb, sbs));
    return NULL;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Asked to transmit to `%s', creating fresh session using address `%s'.\n",
       GNUNET_i2s (&address->peer),
       GNUNET_a2s (sb, sbs));
 
  session = create_session (plugin,
                            address,
                            net_type,
                            GNUNET_SERVER_connect_socket (plugin->server, sa),
                            GNUNET_NO);
  (void) GNUNET_CONTAINER_multipeermap_put (
    plugin->sessionmap,
    &session->target,
    session,
    GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
  /* Send TCP Welcome */
  process_pending_messages (session);
 
  return session;
}

References address, GNUNET_ATS_SessionItCtx::address, GNUNET_NETWORK_Handle::addrlen, create_session(), gettext_noop, GNUNET_a2s(), GNUNET_assert, GNUNET_break, GNUNET_CONNECTION_connect_socket(), GNUNET_CONNECTION_create_from_sockaddr(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CONTAINER_multipeermap_contains(), GNUNET_CONTAINER_multipeermap_get_multiple(), GNUNET_CONTAINER_multipeermap_put(), GNUNET_ERROR_TYPE_BULK, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_HELLO_address_check_option(), GNUNET_HELLO_ADDRESS_INFO_INBOUND, GNUNET_i2s(), GNUNET_log_strerror, GNUNET_memcpy, GNUNET_NAT_request_reversal(), GNUNET_NETWORK_socket_close(), GNUNET_NETWORK_socket_create(), GNUNET_NETWORK_socket_setsockopt(), GNUNET_NO, GNUNET_NT_UNSPECIFIED, GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_SERVER_connect_socket(), GNUNET_STATISTICS_update(), GNUNET_YES, LOG, nat_connect_timeout(), GNUNET_ATS_Session::nat_connection_timeout, NAT_TIMEOUT, options, plugin, process_pending_messages(), GNUNET_ATS_SessionItCtx::result, session_lookup_it(), t4, t6, GNUNET_ATS_Session::target, TCP_OPTIONS_TCP_STEALTH, tcp_plugin_address_to_string(), and tcp_plugin_disconnect_session().

Referenced by libgnunet_plugin_transport_tcp_init().

Here is the call graph for this function:

Here is the caller graph for this function:

session_disconnect_it()

static int session_disconnect_it ( void *  cls, const struct GNUNET_PeerIdentity *  key, void *  value  )

static

We have been asked to destroy all connections to a particular peer.

This function is called on each applicable session and must tear it down.

Parameters

cls	the struct Plugin *
key	the peer which the session belongs to (unused)
value	the struct GNUNET_ATS_Session

Returns

GNUNET_YES (continue to iterate)

Definition at line 2651 of file plugin_transport_tcp.c.

{
  struct Plugin *plugin = cls;
  struct GNUNET_ATS_Session *session = value;
 
  GNUNET_STATISTICS_update (session->plugin->env->stats,
                            gettext_noop (
                              "# transport-service disconnect requests for TCP"),
                            1,
                            GNUNET_NO);
  tcp_plugin_disconnect_session (plugin, session);
  return GNUNET_YES;
}

References Plugin::env, gettext_noop, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_YES, plugin, GNUNET_ATS_Session::plugin, tcp_plugin_disconnect_session(), and value.

Referenced by libgnunet_plugin_transport_tcp_done(), and tcp_plugin_disconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

tcp_plugin_disconnect()

static void tcp_plugin_disconnect ( void *  cls, const struct GNUNET_PeerIdentity *  target  )

static

Function that can be called to force a disconnect from the specified neighbour.

This should also cancel all previously scheduled transmissions. Obviously the transmission may have been partially completed already, which is OK. The plugin is supposed to close the connection (if applicable) and no longer call the transmit continuation(s).

Finally, plugin MUST NOT call the services's receive function to notify the service that the connection to the specified target was closed after a getting this call.

Parameters

cls	closure
target	peer for which the last transmission is to be cancelled

Definition at line 2685 of file plugin_transport_tcp.c.

{
  struct Plugin *plugin = cls;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Disconnecting peer `%s'\n",
       GNUNET_i2s (target));
  GNUNET_CONTAINER_multipeermap_get_multiple (plugin->sessionmap,
                                              target,
                                              &session_disconnect_it,
                                              plugin);
  GNUNET_CONTAINER_multipeermap_get_multiple (plugin->nat_wait_conns,
                                              target,
                                              &session_disconnect_it,
                                              plugin);
}

References GNUNET_CONTAINER_multipeermap_get_multiple(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), LOG, plugin, and session_disconnect_it().

Referenced by libgnunet_plugin_transport_tcp_init().

Here is the call graph for this function:

Here is the caller graph for this function:

append_port()

static void append_port ( void *  cls, const char *  hostname  )

static

We are processing an address pretty printing request and finished the IP resolution (if applicable).

Append our port and forward the result. If called with hostname NULL, we are done and should clean up the pretty printer (otherwise, there might be multiple hostnames for the IP address and we might receive more).

Parameters

cls	the struct PrettyPrinterContext *
hostname	hostname part of the address

Definition at line 2714 of file plugin_transport_tcp.c.

{
  struct PrettyPrinterContext *ppc = cls;
  struct Plugin *plugin = ppc->plugin;
  char *ret;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "append_port called with hostname `%s'\n",
              hostname);
  if (NULL == hostname)
  {
    /* Final call, done */
    ppc->resolver_handle = NULL;
    GNUNET_CONTAINER_DLL_remove (plugin->ppc_dll_head,
                                 plugin->ppc_dll_tail,
                                 ppc);
    ppc->asc (ppc->asc_cls, NULL, GNUNET_OK);
    GNUNET_free (ppc);
    return;
  }
  if (GNUNET_YES == ppc->ipv6)
    GNUNET_asprintf (&ret,
                     "%s.%u.[%s]:%d",
                     PLUGIN_NAME,
                     ppc->options,
                     hostname,
                     ppc->port);
  else
    GNUNET_asprintf (&ret,
                     "%s.%u.%s:%d",
                     PLUGIN_NAME,
                     ppc->options,
                     hostname,
                     ppc->port);
  ppc->asc (ppc->asc_cls, ret, GNUNET_OK);
  GNUNET_free (ret);
}

References PrettyPrinterContext::asc, PrettyPrinterContext::asc_cls, GNUNET_asprintf(), GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_OK, GNUNET_YES, hostname, PrettyPrinterContext::ipv6, PrettyPrinterContext::options, plugin, PrettyPrinterContext::plugin, PLUGIN_NAME, PrettyPrinterContext::port, PrettyPrinterContext::resolver_handle, and ret.

Referenced by tcp_plugin_address_pretty_printer().

Here is the call graph for this function:

Here is the caller graph for this function:

tcp_plugin_address_pretty_printer()

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  )

static

Convert the transports address to a nice, human-readable format.

Parameters

cls	closure with the struct Plugin
type	name of the transport that generated the address
addr	one of the addresses of the host, NULL for the last address the specific address format depends on the transport
addrlen	length of the addr
numeric	should (IP) addresses be displayed in numeric form?
timeout	after how long should we give up?
asc	function to call on each string
asc_cls	closure for asc

Definition at line 2767 of file plugin_transport_tcp.c.

{
  struct Plugin *plugin = cls;
  struct PrettyPrinterContext *ppc;
  const void *sb;
  size_t sbs;
  struct sockaddr_in a4;
  struct sockaddr_in6 a6;
  const struct IPv4TcpAddress *t4;
  const struct IPv6TcpAddress *t6;
  uint16_t port;
  uint32_t options;
 
  if (sizeof(struct IPv6TcpAddress) == addrlen)
  {
    t6 = addr;
    memset (&a6, 0, sizeof(a6));
    a6.sin6_family = AF_INET6;
    a6.sin6_port = t6->t6_port;
    GNUNET_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);
  }
  else if (sizeof(struct IPv4TcpAddress) == addrlen)
  {
    t4 = addr;
    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);
  }
  else
  {
    /* invalid address */
    LOG (GNUNET_ERROR_TYPE_WARNING,
         _ ("Unexpected address length: %u bytes\n"),
         (unsigned int) addrlen);
    asc (asc_cls, NULL, GNUNET_SYSERR);
    asc (asc_cls, NULL, GNUNET_OK);
    return;
  }
  ppc = GNUNET_new (struct PrettyPrinterContext);
  ppc->plugin = plugin;
  if (addrlen == sizeof(struct IPv6TcpAddress))
    ppc->ipv6 = GNUNET_YES;
  else
    ppc->ipv6 = GNUNET_NO;
  ppc->asc = asc;
  ppc->asc_cls = asc_cls;
  ppc->port = port;
  ppc->options = options;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting DNS reverse lookup\n");
  ppc->resolver_handle = GNUNET_RESOLVER_hostname_get (sb,
                                                       sbs,
                                                       ! numeric,
                                                       timeout,
                                                       &append_port,
                                                       ppc);
  if (NULL == ppc->resolver_handle)
  {
    GNUNET_break (0);
    GNUNET_free (ppc);
    return;
  }
  GNUNET_CONTAINER_DLL_insert (plugin->ppc_dll_head, plugin->ppc_dll_tail, ppc);
}

References _, append_port(), PrettyPrinterContext::asc, PrettyPrinterContext::asc_cls, GNUNET_break, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_memcpy, GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_RESOLVER_hostname_get(), GNUNET_SYSERR, GNUNET_YES, PrettyPrinterContext::ipv6, LOG, numeric, options, PrettyPrinterContext::options, plugin, PrettyPrinterContext::plugin, port, PrettyPrinterContext::port, PrettyPrinterContext::resolver_handle, t4, t6, and timeout.

Referenced by libgnunet_plugin_transport_tcp_init().

Here is the call graph for this function:

Here is the caller graph for this function:

tcp_plugin_check_address()

static int tcp_plugin_check_address ( void *  cls, const void *  addr, size_t  addrlen  )

static

Function that will be called to check if a binary address for this plugin is well-formed and corresponds to an address for THIS peer (as per our configuration).

Naturally, if absolutely necessary, plugins can be a bit conservative in their answer, but in general plugins should make sure that the address does not redirect traffic to a 3rd party that might try to man-in-the-middle our traffic.

Parameters

cls	closure, our struct Plugin *
addr	pointer to the address
addrlen	length of addr

Returns

GNUNET_OK if this is a plausible address for this peer and transport, GNUNET_SYSERR if not

Definition at line 2864 of file plugin_transport_tcp.c.

{
  struct Plugin *plugin = cls;
  const struct IPv4TcpAddress *v4;
  const struct IPv6TcpAddress *v6;
 
  if ((addrlen != sizeof(struct IPv4TcpAddress)) &&
      (addrlen != sizeof(struct IPv6TcpAddress)))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
 
  if (addrlen == sizeof(struct IPv4TcpAddress))
  {
    struct sockaddr_in s4;
 
    v4 = (const struct IPv4TcpAddress *) addr;
    if (0 != memcmp (&v4->options, &plugin->myoptions, sizeof(uint32_t)))
    {
      GNUNET_break (0);
      return GNUNET_SYSERR;
    }
    memset (&s4, 0, sizeof(s4));
    s4.sin_family = AF_INET;
#if HAVE_SOCKADDR_IN_SIN_LEN
    s4.sin_len = sizeof(s4);
#endif
    s4.sin_port = v4->t4_port;
    s4.sin_addr.s_addr = v4->ipv4_addr;
 
    if (GNUNET_OK !=
        GNUNET_NAT_test_address (plugin->nat, &s4, sizeof(struct sockaddr_in)))
      return GNUNET_SYSERR;
  }
  else
  {
    struct sockaddr_in6 s6;
 
    v6 = (const struct IPv6TcpAddress *) addr;
    if (IN6_IS_ADDR_LINKLOCAL (&v6->ipv6_addr))
    {
      GNUNET_break_op (0);
      return GNUNET_SYSERR;
    }
    if (0 != memcmp (&v6->options, &plugin->myoptions, sizeof(uint32_t)))
    {
      GNUNET_break (0);
      return GNUNET_SYSERR;
    }
    memset (&s6, 0, sizeof(s6));
    s6.sin6_family = AF_INET6;
#if HAVE_SOCKADDR_IN_SIN_LEN
    s6.sin6_len = sizeof(s6);
#endif
    s6.sin6_port = v6->t6_port;
    s6.sin6_addr = v6->ipv6_addr;
 
    if (GNUNET_OK != GNUNET_NAT_test_address (plugin->nat,
                                              &s6,
                                              sizeof(struct sockaddr_in6)))
      return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break, GNUNET_break_op, GNUNET_NAT_test_address(), GNUNET_OK, GNUNET_SYSERR, and plugin.

Referenced by libgnunet_plugin_transport_tcp_init().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_tcp_nat_probe()

static void handle_tcp_nat_probe ( void *  cls, struct GNUNET_SERVER_Client *  client, const struct GNUNET_MessageHeader *  message  )

static

We've received a nat probe from this peer via TCP.

Finish creating the client session and resume sending of queued messages.

Parameters

cls	closure
client	identification of the client
message	the actual message

Definition at line 2941 of file plugin_transport_tcp.c.

{
  struct Plugin *plugin = cls;
  struct GNUNET_ATS_Session *session;
  const struct TCP_NAT_ProbeMessage *tcp_nat_probe;
  size_t alen;
  void *vaddr;
  struct IPv4TcpAddress *t4;
  struct IPv6TcpAddress *t6;
  const struct sockaddr_in *s4;
  const struct sockaddr_in6 *s6;
 
  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))
  {
    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)))
  {
    /* 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 (NULL == session)
  {
    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");
 
  if (NULL != session->nat_connection_timeout)
  {
    GNUNET_SCHEDULER_cancel (session->nat_connection_timeout);
    session->nat_connection_timeout = NULL;
  }
 
  if (GNUNET_OK != GNUNET_SERVER_client_get_address (client, &vaddr, &alen))
  {
    GNUNET_break (0);
    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
    tcp_plugin_disconnect_session (plugin, session);
    return;
  }
  GNUNET_assert (
    GNUNET_YES ==
    GNUNET_CONTAINER_multipeermap_remove (plugin->nat_wait_conns,
                                          &tcp_nat_probe->clientIdentity,
                                          session));
  GNUNET_SERVER_client_set_user_context (client, session);
  (void) GNUNET_CONTAINER_multipeermap_put (
    plugin->sessionmap,
    &session->target,
    session,
    GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
  session->last_activity = GNUNET_TIME_absolute_get ();
  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:
    s4 = vaddr;
    t4 = GNUNET_new (struct IPv4TcpAddress);
    t4->options = htonl (TCP_OPTIONS_NONE);
    t4->t4_port = s4->sin_port;
    t4->ipv4_addr = s4->sin_addr.s_addr;
    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 = htonl (TCP_OPTIONS_NONE);
    t6->t6_port = s6->sin6_port;
    GNUNET_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_SERVER_receive_done (client, GNUNET_SYSERR);
    tcp_plugin_disconnect_session (plugin, session);
    return;
  }
  GNUNET_free (vaddr);
  GNUNET_break (NULL == session->client);
  session->client = client;
  GNUNET_STATISTICS_update (plugin->env->stats,
                            gettext_noop ("# TCP sessions active"),
                            1,
                            GNUNET_NO);
  process_pending_messages (session);
  GNUNET_SERVER_receive_done (client, GNUNET_OK);
}

References GNUNET_ATS_Session::address, GNUNET_ATS_Session::client, TCP_NAT_ProbeMessage::clientIdentity, gettext_noop, GNUNET_a2s(), GNUNET_assert, GNUNET_break, GNUNET_break_op, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CONTAINER_multipeermap_get(), GNUNET_CONTAINER_multipeermap_put(), GNUNET_CONTAINER_multipeermap_remove(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_HELLO_address_allocate(), GNUNET_HELLO_ADDRESS_INFO_NONE, GNUNET_memcpy, GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_cancel(), GNUNET_SERVER_client_get_address(), GNUNET_SERVER_client_set_user_context, GNUNET_SERVER_receive_done(), GNUNET_STATISTICS_update(), GNUNET_SYSERR, GNUNET_TIME_absolute_get(), GNUNET_YES, GNUNET_ATS_Session::last_activity, LOG, GNUNET_ATS_Session::nat_connection_timeout, plugin, PLUGIN_NAME, process_pending_messages(), GNUNET_MessageHeader::size, t4, t6, GNUNET_ATS_Session::target, TCP_OPTIONS_NONE, and tcp_plugin_disconnect_session().

Referenced by libgnunet_plugin_transport_tcp_init().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_tcp_welcome()

static void handle_tcp_welcome ( void *  cls, struct GNUNET_SERVER_Client *  client, const struct GNUNET_MessageHeader *  message  )

static

We've received a welcome from this peer via TCP.

Possibly create a fresh client record and send back our welcome.

Parameters

cls	closure
client	identification of the client
message	the actual message

Definition at line 3075 of file plugin_transport_tcp.c.

{
  struct Plugin *plugin = cls;
  const struct WelcomeMessage *wm = (const struct WelcomeMessage *) message;
  struct GNUNET_HELLO_Address *address;
  struct GNUNET_ATS_Session *session;
  size_t alen;
  void *vaddr;
  struct IPv4TcpAddress t4;
  struct IPv6TcpAddress t6;
  const struct sockaddr_in *s4;
  const struct sockaddr_in6 *s6;
 
  if (0 == memcmp (&wm->clientIdentity,
                   plugin->env->my_identity,
                   sizeof(struct GNUNET_PeerIdentity)))
  {
    /* refuse connections from ourselves */
    if (GNUNET_OK == GNUNET_SERVER_client_get_address (client, &vaddr, &alen))
    {
      LOG (GNUNET_ERROR_TYPE_INFO,
           "Received WELCOME message from my own identity `%s' on address `%s'\n",
           GNUNET_i2s (&wm->clientIdentity),
           GNUNET_a2s (vaddr, alen));
      GNUNET_free (vaddr);
    }
    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
    return;
  }
 
  if (GNUNET_OK == GNUNET_SERVER_client_get_address (client, &vaddr, &alen))
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Received WELCOME message from `%s' on address `%s'\n",
         GNUNET_i2s (&wm->clientIdentity),
         GNUNET_a2s (vaddr, alen));
    GNUNET_free (vaddr);
  }
  GNUNET_STATISTICS_update (plugin->env->stats,
                            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))
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Found existing session %p for peer `%s'\n",
           session,
           GNUNET_a2s (vaddr, alen));
      GNUNET_free (vaddr);
    }
  }
  else
  {
    if (GNUNET_OK == GNUNET_SERVER_client_get_address (client, &vaddr, &alen))
    {
      if (alen == sizeof(struct sockaddr_in))
      {
        s4 = vaddr;
        memset (&t4, '\0', sizeof(t4));
        t4.options = htonl (TCP_OPTIONS_NONE);
        t4.t4_port = s4->sin_port;
        t4.ipv4_addr = s4->sin_addr.s_addr;
        address =
          GNUNET_HELLO_address_allocate (&wm->clientIdentity,
                                         PLUGIN_NAME,
                                         &t4,
                                         sizeof(t4),
                                         GNUNET_HELLO_ADDRESS_INFO_INBOUND);
      }
      else if (alen == sizeof(struct sockaddr_in6))
      {
        s6 = vaddr;
        memset (&t6, '\0', sizeof(t6));
        t6.options = htonl (TCP_OPTIONS_NONE);
        t6.t6_port = s6->sin6_port;
        GNUNET_memcpy (&t6.ipv6_addr, &s6->sin6_addr, sizeof(struct in6_addr));
        address =
          GNUNET_HELLO_address_allocate (&wm->clientIdentity,
                                         PLUGIN_NAME,
                                         &t6,
                                         sizeof(t6),
                                         GNUNET_HELLO_ADDRESS_INFO_INBOUND);
      }
      else
      {
        GNUNET_break (0);
        GNUNET_free (vaddr);
        GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
        return;
      }
      session = create_session (plugin,
                                address,
                                plugin->env->get_address_type (plugin->env->cls,
                                                               vaddr,
                                                               alen),
                                client,
                                GNUNET_NO);
      GNUNET_break (GNUNET_NT_UNSPECIFIED != session->scope);
      GNUNET_HELLO_address_free (address);
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Creating new%s session %p for peer `%s' client %p\n",
           GNUNET_HELLO_address_check_option (session->address,
                                              GNUNET_HELLO_ADDRESS_INFO_INBOUND)
           ? " inbound"
           : "",
           session,
           tcp_plugin_address_to_string (plugin,
                                         session->address->address,
                                         session->address->address_length),
           client);
      GNUNET_free (vaddr);
      (void) GNUNET_CONTAINER_multipeermap_put (
        plugin->sessionmap,
        &session->target,
        session,
        GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
      /* Notify transport and ATS about new session */
      plugin->env->session_start (plugin->env->cls,
                                  session->address,
                                  session,
                                  session->scope);
    }
    else
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Did not obtain TCP socket address for incoming connection\n");
      GNUNET_break (0);
      GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
      return;
    }
  }
 
  if (GNUNET_YES != session->expecting_welcome)
  {
    GNUNET_break_op (0);
    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
    return;
  }
  session->last_activity = GNUNET_TIME_absolute_get ();
  session->expecting_welcome = GNUNET_NO;
 
  process_pending_messages (session);
  GNUNET_SERVER_client_set_timeout (client,
                                    GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
  GNUNET_SERVER_receive_done (client, GNUNET_OK);
}

References address, GNUNET_HELLO_Address::address, GNUNET_ATS_Session::address, GNUNET_HELLO_Address::address_length, WelcomeMessage::clientIdentity, create_session(), GNUNET_ATS_Session::expecting_welcome, gettext_noop, GNUNET_a2s(), GNUNET_break, GNUNET_break_op, GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CONTAINER_multipeermap_put(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_HELLO_address_allocate(), GNUNET_HELLO_address_check_option(), GNUNET_HELLO_address_free, GNUNET_HELLO_ADDRESS_INFO_INBOUND, GNUNET_i2s(), GNUNET_memcpy, GNUNET_NO, GNUNET_NT_UNSPECIFIED, GNUNET_OK, GNUNET_SERVER_client_get_address(), GNUNET_SERVER_client_set_timeout(), GNUNET_SERVER_receive_done(), GNUNET_STATISTICS_update(), GNUNET_SYSERR, GNUNET_TIME_absolute_get(), GNUNET_YES, GNUNET_ATS_Session::last_activity, LOG, lookup_session_by_client(), plugin, PLUGIN_NAME, process_pending_messages(), GNUNET_ATS_Session::scope, t4, t6, GNUNET_ATS_Session::target, TCP_OPTIONS_NONE, and tcp_plugin_address_to_string().

Referenced by libgnunet_plugin_transport_tcp_init().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_tcp_data()

static void handle_tcp_data ( void *  cls, struct GNUNET_SERVER_Client *  client, const struct GNUNET_MessageHeader *  message  )

static

We've received data for this peer via TCP.

Unbox, compute latency and forward.

Parameters

cls	closure
client	identification of the client
message	the actual message

Definition at line 3237 of file plugin_transport_tcp.c.

{
  struct Plugin *plugin = cls;
  struct GNUNET_ATS_Session *session;
  struct GNUNET_TIME_Relative delay;
  uint16_t type;
 
  type = ntohs (message->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);
    return;
  }
  session = lookup_session_by_client (plugin, client);
  if (NULL == session)
  {
    /* No inbound session found */
    void *vaddr = NULL;
    size_t alen;
 
    GNUNET_assert (GNUNET_OK ==
                   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);
    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
    GNUNET_free (vaddr);
    return;
  }
  if (GNUNET_YES == session->expecting_welcome)
  {
    /* Session is expecting WELCOME message */
    void *vaddr = NULL;
    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);
    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
    GNUNET_free (vaddr);
    return;
  }
 
  session->last_activity = GNUNET_TIME_absolute_get ();
  {
    void *vaddr = NULL;
    size_t alen;
 
    GNUNET_SERVER_client_get_address (client, &vaddr, &alen);
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Passing %u bytes of type %u from `%s' at %s to transport service.\n",
         (unsigned int) ntohs (message->size),
         (unsigned int) ntohs (message->type),
         GNUNET_i2s (&session->target),
         GNUNET_a2s (vaddr, alen));
    GNUNET_free (vaddr);
  }
 
  GNUNET_STATISTICS_update (plugin->env->stats,
                            gettext_noop ("# bytes received via TCP"),
                            ntohs (message->size),
                            GNUNET_NO);
 
  GNUNET_assert (
    GNUNET_CONTAINER_multipeermap_contains_value (plugin->sessionmap,
                                                  &session->target,
                                                  session));
  delay =
    plugin->env->receive (plugin->env->cls, session->address, session, message);
  reschedule_session_timeout (session);
  if (0 == delay.rel_value_us)
  {
    GNUNET_SERVER_receive_done (client, GNUNET_OK);
  }
  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));
    GNUNET_SERVER_disable_receive_done_warning (client);
    GNUNET_assert (NULL == session->receive_delay_task);
    session->receive_delay_task =
      GNUNET_SCHEDULER_add_delayed (delay, &delayed_done, session);
  }
}

References GNUNET_ATS_Session::address, delay, delayed_done(), GNUNET_ATS_Session::expecting_welcome, gettext_noop, GNUNET_a2s(), GNUNET_assert, GNUNET_break_op, GNUNET_CONTAINER_multipeermap_contains_value(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_i2s(), GNUNET_MESSAGE_TYPE_TRANSPORT_TCP_NAT_PROBE, GNUNET_MESSAGE_TYPE_TRANSPORT_TCP_WELCOME, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_SERVER_client_get_address(), GNUNET_SERVER_disable_receive_done_warning(), GNUNET_SERVER_receive_done(), GNUNET_STATISTICS_update(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_SYSERR, GNUNET_TIME_absolute_get(), GNUNET_YES, GNUNET_ATS_Session::last_activity, LOG, lookup_session_by_client(), plugin, GNUNET_ATS_Session::receive_delay_task, GNUNET_TIME_Relative::rel_value_us, reschedule_session_timeout(), GNUNET_MessageHeader::size, GNUNET_ATS_Session::target, GNUNET_MessageHeader::type, and type.

Referenced by libgnunet_plugin_transport_tcp_init().

Here is the call graph for this function:

Here is the caller graph for this function:

connect_notify()

static void connect_notify ( void *  cls, struct GNUNET_SERVER_Client *  client  )

static

Function called whenever a peer is connected on the "SERVER" level.

Increments number of active connections and suspends server if we have reached the limit.

Parameters

cls	closure
client	identification of the client

Definition at line 3345 of file plugin_transport_tcp.c.

{
  struct Plugin *plugin = cls;
 
  if (NULL == client)
    return;
  plugin->cur_connections++;
  GNUNET_STATISTICS_set (plugin->env->stats,
                         gettext_noop ("# TCP server connections active"),
                         plugin->cur_connections,
                         GNUNET_NO);
  GNUNET_STATISTICS_update (plugin->env->stats,
                            gettext_noop ("# TCP server connect events"),
                            1,
                            GNUNET_NO);
  if (plugin->cur_connections != plugin->max_connections)
    return;
  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
              _ ("TCP connection limit reached, suspending server\n"));
  GNUNET_STATISTICS_update (plugin->env->stats,
                            gettext_noop ("# TCP service suspended"),
                            1,
                            GNUNET_NO);
  GNUNET_SERVER_suspend (
    plugin->server); /* Maximum number of connections rechead */
}

References _, gettext_noop, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_NO, GNUNET_SERVER_suspend(), GNUNET_STATISTICS_set(), GNUNET_STATISTICS_update(), and plugin.

Referenced by libgnunet_plugin_transport_tcp_init().

Here is the call graph for this function:

Here is the caller graph for this function:

disconnect_notify()

static void disconnect_notify ( void *  cls, struct GNUNET_SERVER_Client *  client  )

static

Function called whenever a peer is disconnected on the "SERVER" level.

Cleans up the connection, decrements number of active connections and if applicable resumes listening.

Parameters

cls	closure
client	identification of the client

Definition at line 3382 of file plugin_transport_tcp.c.

{
  struct Plugin *plugin = cls;
  struct GNUNET_ATS_Session *session;
 
  if (NULL == client)
    return;
  GNUNET_assert (plugin->cur_connections >= 1);
  plugin->cur_connections--;
  session = lookup_session_by_client (plugin, client);
  if (NULL == session)
    return; /* unknown, nothing to do */
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Destroying session of `%s' with %s due to network-level disconnect.\n",
       GNUNET_i2s (&session->target),
       tcp_plugin_address_to_string (session->plugin,
                                     session->address->address,
                                     session->address->address_length));
 
  if (plugin->cur_connections == plugin->max_connections)
  {
    GNUNET_STATISTICS_update (session->plugin->env->stats,
                              gettext_noop ("# TCP service resumed"),
                              1,
                              GNUNET_NO);
    GNUNET_SERVER_resume (plugin->server);  /* Resume server  */
  }
  GNUNET_STATISTICS_set (plugin->env->stats,
                         gettext_noop ("# TCP server connections active"),
                         plugin->cur_connections,
                         GNUNET_NO);
  GNUNET_STATISTICS_update (session->plugin->env->stats,
                            gettext_noop (
                              "# network-level TCP disconnect events"),
                            1,
                            GNUNET_NO);
  tcp_plugin_disconnect_session (plugin, session);
}

References GNUNET_HELLO_Address::address, GNUNET_ATS_Session::address, GNUNET_HELLO_Address::address_length, GNUNET_ATS_Session::client, Plugin::env, gettext_noop, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_NO, GNUNET_SERVER_resume(), GNUNET_STATISTICS_set(), GNUNET_STATISTICS_update(), LOG, lookup_session_by_client(), plugin, GNUNET_ATS_Session::plugin, GNUNET_ATS_Session::target, tcp_plugin_address_to_string(), and tcp_plugin_disconnect_session().

Referenced by libgnunet_plugin_transport_tcp_init().

Here is the call graph for this function:

Here is the caller graph for this function:

notify_send_probe()

static size_t notify_send_probe ( void *  cls, size_t  size, void *  buf  )

static

We can now send a probe message, copy into buffer to really send.

Parameters

cls	closure, a struct TCPProbeContext
size	max size to copy
buf	buffer to copy message to

Returns

number of bytes copied into buf

Definition at line 3431 of file plugin_transport_tcp.c.

{
  struct TCPProbeContext *tcp_probe_ctx = cls;
  struct Plugin *plugin = tcp_probe_ctx->plugin;
  size_t ret;
 
  tcp_probe_ctx->transmit_handle = NULL;
  GNUNET_CONTAINER_DLL_remove (plugin->probe_head,
                               plugin->probe_tail,
                               tcp_probe_ctx);
  if (NULL == buf)
  {
    GNUNET_CONNECTION_destroy (tcp_probe_ctx->sock);
    GNUNET_free (tcp_probe_ctx);
    return 0;
  }