GNUnet  0.10.x
Data Structures | Macros | Typedefs | Functions
plugin_transport_udp.c File Reference

Implementation of the UDP transport protocol. More...

#include "platform.h"
#include "plugin_transport_udp.h"
#include "gnunet_hello_lib.h"
#include "gnunet_util_lib.h"
#include "gnunet_fragmentation_lib.h"
#include "gnunet_nat_service.h"
#include "gnunet_protocols.h"
#include "gnunet_resolver_service.h"
#include "gnunet_signatures.h"
#include "gnunet_constants.h"
#include "gnunet_statistics_service.h"
#include "gnunet_transport_service.h"
#include "gnunet_transport_plugin.h"
#include "transport.h"
Include dependency graph for plugin_transport_udp.c:

Go to the source code of this file.

Data Structures

struct  UDPMessage
 UDP Message-Packet header (after defragmentation). More...
 
struct  PrettyPrinterContext
 Closure for append_port(). More...
 
struct  GNUNET_ATS_Session
 Information about ongoing sessions of the transport client. More...
 
struct  DefragContext
 Data structure to track defragmentation contexts based on the source of the UDP traffic. More...
 
struct  UDP_FragmentationContext
 Context to send fragmented messages. More...
 
struct  UDP_MessageWrapper
 Information we track for each message in the queue. More...
 
struct  UDP_ACK_Message
 UDP ACK Message-Packet header. More...
 
struct  GNUNET_ATS_SessionCompareContext
 Closure for session_cmp_it(). More...
 
struct  FindReceiveContext
 Closure for find_receive_context(). More...
 

Macros

#define LOG(kind, ...)   GNUNET_log_from(kind, "transport-udp", __VA_ARGS__)
 
#define UDP_SESSION_TIME_OUT   GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 60)
 After how much inactivity should a UDP session time out? More...
 
#define UDP_MAX_MESSAGES_IN_DEFRAG   3
 Number of messages we can defragment in parallel. More...
 
#define UDP_MAX_SENDER_ADDRESSES_WITH_DEFRAG   128
 We keep a defragmentation queue per sender address. More...
 

Typedefs

typedef void(* QueueContinuation) (void *cls, struct UDP_MessageWrapper *udpw, int result)
 Function called when a message is removed from the transmission queue. More...
 

Functions

static GNUNET_NETWORK_STRUCT_END 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 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 udp_plugin_setup_monitor (void *cls, GNUNET_TRANSPORT_SessionInfoCallback sic, void *sic_cls)
 Begin monitoring sessions of a plugin. More...
 
static void free_session (struct GNUNET_ATS_Session *s)
 Function to free last resources associated with a session. More...
 
static unsigned int udp_query_keepalive_factor (void *cls)
 Function that is called to get the keepalive factor. More...
 
static enum GNUNET_NetworkType udp_plugin_get_network (void *cls, struct GNUNET_ATS_Session *session)
 Function obtain the network type for a session. More...
 
static enum GNUNET_NetworkType udp_plugin_get_network_for_address (void *cls, const struct GNUNET_HELLO_Address *address)
 Function obtain the network type for an address. More...
 
static void udp_plugin_select_v4 (void *cls)
 We have been notified that our readset has something to read. More...
 
static void udp_plugin_select_v6 (void *cls)
 We have been notified that our readset has something to read. More...
 
static void schedule_select_v4 (struct Plugin *plugin)
 (re)schedule IPv4-select tasks for this plugin. More...
 
static void schedule_select_v6 (struct Plugin *plugin)
 (re)schedule IPv6-select tasks for this plugin. More...
 
const char * udp_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 udp_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 void append_port (void *cls, const char *hostname)
 Append our port and forward the result. More...
 
static void udp_plugin_address_pretty_printer (void *cls, const char *type, const void *addr, size_t addrlen, int numeric, struct GNUNET_TIME_Relative timeout, GNUNET_TRANSPORT_AddressStringCallback asc, void *asc_cls)
 Convert the transports address to a nice, human-readable format. More...
 
static int check_port (const struct Plugin *plugin, uint16_t in_port)
 Check if the given port is plausible (must be either our listen port or our advertised port). More...
 
static int udp_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 udp_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 int session_cmp_it (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
 Find a session with a matching address. More...
 
static struct GNUNET_ATS_Sessionudp_plugin_lookup_session (void *cls, const struct GNUNET_HELLO_Address *address)
 Locate an existing session the transport service is using to send data to another peer. More...
 
static void reschedule_session_timeout (struct GNUNET_ATS_Session *s)
 Increment session timeout due to activity. More...
 
static void udp_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 dequeue (struct Plugin *plugin, struct UDP_MessageWrapper *udpw)
 Remove the given message from the transmission queue and update all applicable statistics. More...
 
static void enqueue (struct Plugin *plugin, struct UDP_MessageWrapper *udpw)
 Enqueue a message for transmission and update statistics. More...
 
static void fragmented_message_done (struct UDP_FragmentationContext *frag_ctx, int result)
 We have completed our (attempt) to transmit a message that had to be fragmented – either because we got an ACK saying that all fragments were received, or because of timeout / disconnect. More...
 
static void qc_fragment_sent (void *cls, struct UDP_MessageWrapper *udpw, int result)
 We are finished with a fragment in the message queue. More...
 
static void enqueue_fragment (void *cls, const struct GNUNET_MessageHeader *msg)
 Function that is called with messages created by the fragmentation module. More...
 
static void qc_message_sent (void *cls, struct UDP_MessageWrapper *udpw, int result)
 We are finished with a message from the message queue. More...
 
static ssize_t udp_plugin_send (void *cls, struct GNUNET_ATS_Session *s, 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 find_receive_context (void *cls, struct GNUNET_CONTAINER_HeapNode *node, void *element, GNUNET_CONTAINER_HeapCostType cost)
 Scan the heap for a receive context with the given address. More...
 
static int udp_disconnect_session (void *cls, struct GNUNET_ATS_Session *s)
 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 void read_process_ack (struct Plugin *plugin, const struct GNUNET_MessageHeader *msg, const union UdpAddress *udp_addr, socklen_t udp_addr_len)
 Handle a GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_ACK message. More...
 
static int process_inbound_tokenized_messages (void *cls, const struct GNUNET_MessageHeader *hdr)
 Message tokenizer has broken up an incomming message. More...
 
static int disconnect_and_free_it (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
 Destroy a session, plugin is being unloaded. More...
 
static void udp_disconnect (void *cls, const struct GNUNET_PeerIdentity *target)
 Disconnect from a remote node. More...
 
static void session_timeout (void *cls)
 Session was idle, so disconnect it. More...
 
static struct GNUNET_ATS_Sessionudp_plugin_create_session (void *cls, const struct GNUNET_HELLO_Address *address, enum GNUNET_NetworkType network_type)
 Allocate a new session for the given endpoint address. More...
 
static struct GNUNET_ATS_Sessionudp_plugin_get_session (void *cls, const struct GNUNET_HELLO_Address *address)
 Creates a new outbound session the transport service will use to send data to the peer. More...
 
static void process_udp_message (struct Plugin *plugin, const struct UDPMessage *msg, const union UdpAddress *udp_addr, size_t udp_addr_len, enum GNUNET_NetworkType network_type)
 We've received a UDP Message. More...
 
static void fragment_msg_proc (void *cls, const struct GNUNET_MessageHeader *msg)
 Process a defragmented message. More...
 
static void ack_message_sent (void *cls, struct UDP_MessageWrapper *udpw, int result)
 We finished sending an acknowledgement. More...
 
static void ack_proc (void *cls, uint32_t id, const struct GNUNET_MessageHeader *msg)
 Transmit an acknowledgement. More...
 
static void read_process_fragment (struct Plugin *plugin, const struct GNUNET_MessageHeader *msg, const union UdpAddress *udp_addr, size_t udp_addr_len, enum GNUNET_NetworkType network_type)
 We received a fragment, process it. More...
 
static void udp_select_read (struct Plugin *plugin, struct GNUNET_NETWORK_Handle *rsock)
 Read and process a message from the given socket. More...
 
static struct UDP_MessageWrapperremove_timeout_messages_and_select (struct Plugin *plugin, struct GNUNET_NETWORK_Handle *sock)
 Removes messages from the transmission queue that have timed out, and then selects a message that should be transmitted next. More...
 
static void analyze_send_error (struct Plugin *plugin, const struct sockaddr *sa, socklen_t slen, int error)
 We failed to transmit a message via UDP. More...
 
static void udp_select_send (struct Plugin *plugin, struct GNUNET_NETWORK_Handle *sock)
 It is time to try to transmit a UDP message. More...
 
static unsigned int setup_sockets (struct Plugin *plugin, const struct sockaddr_in6 *bind_v6, const struct sockaddr_in *bind_v4)
 Setup the UDP sockets (for IPv4 and IPv6) for the plugin. More...
 
void * libgnunet_plugin_transport_udp_init (void *cls)
 The exported method. More...
 
static int heap_cleanup_iterator (void *cls, struct GNUNET_CONTAINER_HeapNode *node, void *element, GNUNET_CONTAINER_HeapCostType cost)
 Function called on each entry in the defragmentation heap to clean it up. More...
 
void * libgnunet_plugin_transport_udp_done (void *cls)
 The exported method. More...
 

Detailed Description

Implementation of the UDP transport protocol.

Author
Christian Grothoff
Nathan Evans
Matthias Wachs

Definition in file plugin_transport_udp.c.

Macro Definition Documentation

◆ LOG

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

◆ UDP_SESSION_TIME_OUT

#define UDP_SESSION_TIME_OUT   GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 60)

After how much inactivity should a UDP session time out?

Definition at line 48 of file plugin_transport_udp.c.

Referenced by reschedule_session_timeout(), session_timeout(), and udp_plugin_create_session().

◆ UDP_MAX_MESSAGES_IN_DEFRAG

#define UDP_MAX_MESSAGES_IN_DEFRAG   3

Number of messages we can defragment in parallel.

We only really defragment 1 message at a time, but if messages get re-ordered, we may want to keep knowledge about the previous message to avoid discarding the current message in favor of a single fragment of a previous message. 3 should be good since we don't expect massive message reorderings with UDP.

Definition at line 59 of file plugin_transport_udp.c.

Referenced by read_process_fragment().

◆ UDP_MAX_SENDER_ADDRESSES_WITH_DEFRAG

#define UDP_MAX_SENDER_ADDRESSES_WITH_DEFRAG   128

We keep a defragmentation queue per sender address.

How many sender addresses do we support at the same time? Memory consumption is roughly a factor of 32k * UDP_MAX_MESSAGES_IN_DEFRAG times this value. (So 128 corresponds to 12 MB and should suffice for connecting to roughly 128 peers via UDP).

Definition at line 68 of file plugin_transport_udp.c.

Referenced by read_process_fragment().

Typedef Documentation

◆ QueueContinuation

typedef void(* QueueContinuation) (void *cls, struct UDP_MessageWrapper *udpw, int result)

Function called when a message is removed from the transmission queue.

Parameters
clsclosure
udpwmessage wrapper finished
resultGNUNET_OK on success (message was sent) GNUNET_SYSERR if the target disconnected or we had a timeout or other trouble sending

Definition at line 382 of file plugin_transport_udp.c.

Function Documentation

◆ notify_session_monitor()

static GNUNET_NETWORK_STRUCT_END 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
pluginour plugin
sessionsession that changed state
statenew state of the session

Definition at line 508 of file plugin_transport_udp.c.

References GNUNET_ATS_Session::address, GNUNET_TRANSPORT_SessionInfo::address, GNUNET_ATS_Session::bytes_in_queue, GNUNET_SYSERR, GNUNET_YES, GNUNET_ATS_Session::in_destroy, GNUNET_TRANSPORT_SessionInfo::is_inbound, GNUNET_ATS_Session::msgs_in_queue, GNUNET_TRANSPORT_SessionInfo::num_bytes_pending, GNUNET_TRANSPORT_SessionInfo::num_msg_pending, GNUNET_TRANSPORT_SessionInfo::session_timeout, Plugin::sic, Plugin::sic_cls, state, GNUNET_TRANSPORT_SessionInfo::state, and GNUNET_ATS_Session::timeout.

Referenced by ack_proc(), fragmented_message_done(), process_udp_message(), remove_timeout_messages_and_select(), send_session_info_iter(), session_timeout(), udp_disconnect_session(), udp_plugin_create_session(), udp_plugin_send(), and udp_select_send().

511 {
512  struct GNUNET_TRANSPORT_SessionInfo info;
513 
514  if (NULL == plugin->sic)
515  return;
516  if (GNUNET_YES == session->in_destroy)
517  return; /* already destroyed, just RC>0 left-over actions */
518  memset(&info, 0, sizeof(info));
519  info.state = state;
520  info.is_inbound = GNUNET_SYSERR; /* hard to say */
521  info.num_msg_pending = session->msgs_in_queue;
522  info.num_bytes_pending = session->bytes_in_queue;
523  /* info.receive_delay remains zero as this is not supported by UDP
524  (cannot selectively not receive from 'some' peer while continuing
525  to receive from others) */
526  info.session_timeout = session->timeout;
527  info.address = session->address;
528  plugin->sic(plugin->sic_cls, session, &info);
529 }
GNUNET_TRANSPORT_SessionInfoCallback sic
Function to call about session status changes.
unsigned int msgs_in_queue
Number of messages waiting for transmission to this peer.
struct GNUNET_TIME_Absolute timeout
When does this session time out.
struct GNUNET_HELLO_Address * address
Address.
unsigned long long bytes_in_queue
Number of bytes waiting for transmission to this peer.
Information about a plugin's session.
enum State state
current state of profiling
int in_destroy
Is this session about to be destroyed (sometimes we cannot destroy a session immediately as below us ...
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
#define GNUNET_YES
Definition: gnunet_common.h:77
void * sic_cls
Closure for sic.
Here is the caller graph for this function:

◆ send_session_info_iter()

static int send_session_info_iter ( void *  cls,
const struct GNUNET_PeerIdentity peer,
void *  value 
)
static

Return information about the given session to the monitor callback.

Parameters
clsthe struct Plugin with the monitor callback (sic)
peerpeer we send information about
valueour struct GNUNET_ATS_Session to send information about
Returns
GNUNET_OK (continue to iterate)

Definition at line 541 of file plugin_transport_udp.c.

References GNUNET_OK, GNUNET_TRANSPORT_SS_INIT, GNUNET_TRANSPORT_SS_UP, notify_session_monitor(), plugin, and value.

Referenced by udp_plugin_setup_monitor().

544 {
545  struct Plugin *plugin = cls;
546  struct GNUNET_ATS_Session *session = value;
547 
550  return GNUNET_OK;
551 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
static char * value
Value of the record to add/remove.
Information about ongoing sessions of the transport client.
static GNUNET_NETWORK_STRUCT_END 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.
Handle for a plugin.
Definition: block.c:37
The session was created (first call for each session object).
Here is the call graph for this function:
Here is the caller graph for this function:

◆ udp_plugin_setup_monitor()

static void udp_plugin_setup_monitor ( void *  cls,
GNUNET_TRANSPORT_SessionInfoCallback  sic,
void *  sic_cls 
)
static

Begin monitoring sessions of a plugin.

There can only be one active monitor per plugin (i.e. if there are multiple monitors, the transport service needs to multiplex the generated events over all of them).

Parameters
clsclosure of the plugin
siccallback to invoke, NULL to disable monitor; plugin will being by iterating over all active sessions immediately and then enter monitor mode
sic_clsclosure for sic

Definition at line 567 of file plugin_transport_udp.c.

References GNUNET_CONTAINER_multipeermap_iterate(), plugin, send_session_info_iter(), Plugin::sessions, Plugin::sic, and Plugin::sic_cls.

Referenced by libgnunet_plugin_transport_udp_init().

570 {
571  struct Plugin *plugin = cls;
572 
573  plugin->sic = sic;
574  plugin->sic_cls = sic_cls;
575  if (NULL != sic)
576  {
579  plugin);
580  /* signal end of first iteration */
581  sic(sic_cls, NULL, NULL);
582  }
583 }
GNUNET_TRANSPORT_SessionInfoCallback sic
Function to call about session status changes.
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
int GNUNET_CONTAINER_multipeermap_iterate(struct GNUNET_CONTAINER_MultiPeerMap *map, GNUNET_CONTAINER_PeerMapIterator it, void *it_cls)
Iterate over all entries in the map.
Handle for a plugin.
Definition: block.c:37
struct GNUNET_ATS_Session * sessions
List of open sessions (or peer map, or...)
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.
void * sic_cls
Closure for sic.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ free_session()

static void free_session ( struct GNUNET_ATS_Session s)
static

Function to free last resources associated with a session.

Parameters
ssession to free

Definition at line 595 of file plugin_transport_udp.c.

References GNUNET_ATS_Session::address, UDP_FragmentationContext::frag, GNUNET_ATS_Session::frag_ctx, GNUNET_FRAGMENT_context_destroy(), GNUNET_free, GNUNET_HELLO_address_free, GNUNET_MST_destroy(), and GNUNET_ATS_Session::mst.

Referenced by process_udp_message(), and udp_disconnect_session().

596 {
597  if (NULL != s->address)
598  {
600  s->address = NULL;
601  }
602  if (NULL != s->frag_ctx)
603  {
605  GNUNET_free(s->frag_ctx);
606  s->frag_ctx = NULL;
607  }
608  if (NULL != s->mst)
609  {
611  s->mst = NULL;
612  }
613  GNUNET_free(s);
614 }
struct GNUNET_HELLO_Address * address
Address.
void GNUNET_MST_destroy(struct GNUNET_MessageStreamTokenizer *mst)
Destroys a tokenizer.
Definition: mst.c:410
struct GNUNET_MessageStreamTokenizer * mst
Tokenizer for inbound messages.
struct UDP_FragmentationContext * frag_ctx
Context for dealing with fragments.
void GNUNET_FRAGMENT_context_destroy(struct GNUNET_FRAGMENT_Context *fc, struct GNUNET_TIME_Relative *msg_delay, struct GNUNET_TIME_Relative *ack_delay)
Destroy the given fragmentation context (stop calling 'proc', free resources).
struct GNUNET_FRAGMENT_Context * frag
Handle for fragmentation.
#define GNUNET_HELLO_address_free(addr)
Free an address.
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ udp_query_keepalive_factor()

static unsigned int udp_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
clsclosure with the struct Plugin
Returns
keepalive factor

Definition at line 626 of file plugin_transport_udp.c.

Referenced by libgnunet_plugin_transport_udp_init().

627 {
628  return 15;
629 }
Here is the caller graph for this function:

◆ udp_plugin_get_network()

static enum GNUNET_NetworkType udp_plugin_get_network ( void *  cls,
struct GNUNET_ATS_Session session 
)
static

Function obtain the network type for a session.

Parameters
clsclosure (struct Plugin *)
sessionthe session
Returns
the network type

Definition at line 640 of file plugin_transport_udp.c.

References GNUNET_ATS_Session::scope.

Referenced by libgnunet_plugin_transport_udp_init().

641 {
642  return session->scope;
643 }
enum GNUNET_NetworkType scope
ATS network type.
Here is the caller graph for this function:

◆ udp_plugin_get_network_for_address()

static enum GNUNET_NetworkType udp_plugin_get_network_for_address ( void *  cls,
const struct GNUNET_HELLO_Address address 
)
static

Function obtain the network type for an address.

Parameters
clsclosure (struct Plugin *)
addressthe address
Returns
the network type

Definition at line 654 of file plugin_transport_udp.c.

References GNUNET_HELLO_Address::address, GNUNET_HELLO_Address::address_length, GNUNET_DATACACHE_PluginEnvironment::cls, Plugin::env, GNUNET_assert, GNUNET_break, GNUNET_memcpy, GNUNET_NT_UNSPECIFIED, IPv4UdpAddress::ipv4_addr, IPv6UdpAddress::ipv6_addr, plugin, IPv4UdpAddress::u4_port, IPv6UdpAddress::u6_port, udp_plugin_select_v4(), and udp_plugin_select_v6().

Referenced by libgnunet_plugin_transport_udp_init().

656 {
657  struct Plugin *plugin = cls;
658  size_t addrlen;
659  struct sockaddr_in a4;
660  struct sockaddr_in6 a6;
661  const struct IPv4UdpAddress *u4;
662  const struct IPv6UdpAddress *u6;
663  const void *sb;
664  size_t sbs;
665 
666  addrlen = address->address_length;
667  if (addrlen == sizeof(struct IPv6UdpAddress))
668  {
669  GNUNET_assert(NULL != address->address); /* make static analysis happy */
670  u6 = address->address;
671  memset(&a6, 0, sizeof(a6));
672 #if HAVE_SOCKADDR_IN_SIN_LEN
673  a6.sin6_len = sizeof(a6);
674 #endif
675  a6.sin6_family = AF_INET6;
676  a6.sin6_port = u6->u6_port;
677  GNUNET_memcpy(&a6.sin6_addr, &u6->ipv6_addr, sizeof(struct in6_addr));
678  sb = &a6;
679  sbs = sizeof(a6);
680  }
681  else if (addrlen == sizeof(struct IPv4UdpAddress))
682  {
683  GNUNET_assert(NULL != address->address); /* make static analysis happy */
684  u4 = address->address;
685  memset(&a4, 0, sizeof(a4));
686 #if HAVE_SOCKADDR_IN_SIN_LEN
687  a4.sin_len = sizeof(a4);
688 #endif
689  a4.sin_family = AF_INET;
690  a4.sin_port = u4->u4_port;
691  a4.sin_addr.s_addr = u4->ipv4_addr;
692  sb = &a4;
693  sbs = sizeof(a4);
694  }
695  else
696  {
697  GNUNET_break(0);
698  return GNUNET_NT_UNSPECIFIED;
699  }
700  return plugin->env->get_address_type(plugin->env->cls, sb, sbs);
701 }
size_t address_length
Number of bytes in address.
const void * address
Binary representation of the address (plugin-specific).
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
uint16_t u4_port
Port number, in network byte order.
struct in6_addr ipv6_addr
IPv6 address.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
uint16_t u6_port
Port number, in network byte order.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
Network format for IPv4 addresses.
uint32_t ipv4_addr
IPv4 address, in network byte order.
struct GNUNET_DATACACHE_PluginEnvironment * env
Our execution environment.
Network format for IPv6 addresses.
Handle for a plugin.
Definition: block.c:37
void * cls
Closure to use for callbacks.
Category of last resort.
Definition: gnunet_nt_lib.h:39
Here is the call graph for this function:
Here is the caller graph for this function:

◆ udp_plugin_select_v4()

static void udp_plugin_select_v4 ( void *  cls)
static

We have been notified that our readset has something to read.

We don't know which socket needs to be read, so we have to check each one Then reschedule this function to be called again once more is available.

Parameters
clsthe plugin handle

Definition at line 3313 of file plugin_transport_udp.c.

References GNUNET_NETWORK_fdset_isset(), GNUNET_SCHEDULER_get_task_context(), GNUNET_SCHEDULER_REASON_READ_READY, plugin, GNUNET_SCHEDULER_TaskContext::read_ready, GNUNET_SCHEDULER_TaskContext::reason, schedule_select_v4(), Plugin::select_task_v4, Plugin::sockv4, tc, udp_select_read(), and udp_select_send().

Referenced by schedule_select_v4(), and udp_plugin_get_network_for_address().

3314 {
3315  struct Plugin *plugin = cls;
3316  const struct GNUNET_SCHEDULER_TaskContext *tc;
3317 
3318  plugin->select_task_v4 = NULL;
3319  if (NULL == plugin->sockv4)
3320  return;
3322  if ((0 != (tc->reason & GNUNET_SCHEDULER_REASON_READ_READY)) &&
3324  udp_select_read(plugin, plugin->sockv4);
3325  udp_select_send(plugin, plugin->sockv4);
3326  schedule_select_v4(plugin);
3327 }
const struct GNUNET_SCHEDULER_TaskContext * GNUNET_SCHEDULER_get_task_context(void)
Obtain the reasoning why the current task was started.
Definition: scheduler.c:737
The reading socket is ready.
Context information passed to each scheduler task.
static struct GNUNET_SCHEDULER_TaskContext tc
Task context of the current task.
Definition: scheduler.c:410
const struct GNUNET_NETWORK_FDSet * read_ready
Set of file descriptors ready for reading; note that additional bits may be set that were not in the ...
struct GNUNET_NETWORK_Handle * sockv4
The read socket for IPv4.
enum GNUNET_SCHEDULER_Reason reason
Reason why the task is run now.
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
struct GNUNET_SCHEDULER_Task * select_task_v4
ID of select task for IPv4.
static void schedule_select_v4(struct Plugin *plugin)
(re)schedule IPv4-select tasks for this plugin.
Handle for a plugin.
Definition: block.c:37
static void udp_select_send(struct Plugin *plugin, struct GNUNET_NETWORK_Handle *sock)
It is time to try to transmit a UDP message.
static void udp_select_read(struct Plugin *plugin, struct GNUNET_NETWORK_Handle *rsock)
Read and process a message from the given socket.
int GNUNET_NETWORK_fdset_isset(const struct GNUNET_NETWORK_FDSet *fds, const struct GNUNET_NETWORK_Handle *desc)
Check whether a socket is part of the fd set.
Definition: network.c:1017
Here is the call graph for this function:
Here is the caller graph for this function:

◆ udp_plugin_select_v6()

static void udp_plugin_select_v6 ( void *  cls)
static

We have been notified that our readset has something to read.

We don't know which socket needs to be read, so we have to check each one Then reschedule this function to be called again once more is available.

Parameters
clsthe plugin handle

Definition at line 3338 of file plugin_transport_udp.c.

References GNUNET_NETWORK_fdset_isset(), GNUNET_SCHEDULER_get_task_context(), GNUNET_SCHEDULER_REASON_READ_READY, plugin, GNUNET_SCHEDULER_TaskContext::read_ready, GNUNET_SCHEDULER_TaskContext::reason, schedule_select_v6(), Plugin::select_task_v6, Plugin::sockv6, tc, udp_select_read(), and udp_select_send().

Referenced by schedule_select_v6(), and udp_plugin_get_network_for_address().

3339 {
3340  struct Plugin *plugin = cls;
3341  const struct GNUNET_SCHEDULER_TaskContext *tc;
3342 
3343  plugin->select_task_v6 = NULL;
3344  if (NULL == plugin->sockv6)
3345  return;
3347  if ((0 != (tc->reason & GNUNET_SCHEDULER_REASON_READ_READY)) &&
3349  udp_select_read(plugin, plugin->sockv6);
3350 
3351  udp_select_send(plugin, plugin->sockv6);
3352  schedule_select_v6(plugin);
3353 }
const struct GNUNET_SCHEDULER_TaskContext * GNUNET_SCHEDULER_get_task_context(void)
Obtain the reasoning why the current task was started.
Definition: scheduler.c:737
The reading socket is ready.
Context information passed to each scheduler task.
static struct GNUNET_SCHEDULER_TaskContext tc
Task context of the current task.
Definition: scheduler.c:410
const struct GNUNET_NETWORK_FDSet * read_ready
Set of file descriptors ready for reading; note that additional bits may be set that were not in the ...
enum GNUNET_SCHEDULER_Reason reason
Reason why the task is run now.
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
struct GNUNET_SCHEDULER_Task * select_task_v6
ID of select task for IPv6.
static void schedule_select_v6(struct Plugin *plugin)
(re)schedule IPv6-select tasks for this plugin.
Handle for a plugin.
Definition: block.c:37
struct GNUNET_NETWORK_Handle * sockv6
The read socket for IPv6.
static void udp_select_send(struct Plugin *plugin, struct GNUNET_NETWORK_Handle *sock)
It is time to try to transmit a UDP message.
static void udp_select_read(struct Plugin *plugin, struct GNUNET_NETWORK_Handle *rsock)
Read and process a message from the given socket.
int GNUNET_NETWORK_fdset_isset(const struct GNUNET_NETWORK_FDSet *fds, const struct GNUNET_NETWORK_Handle *desc)
Check whether a socket is part of the fd set.
Definition: network.c:1017
Here is the call graph for this function:
Here is the caller graph for this function:

◆ schedule_select_v4()

static void schedule_select_v4 ( struct Plugin plugin)
static

(re)schedule IPv4-select tasks for this plugin.

Parameters
pluginplugin to reschedule

Definition at line 734 of file plugin_transport_udp.c.

References delay, Plugin::enable_ipv4, GNUNET_CONSTANTS_LATENCY_WARN, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_i2s(), GNUNET_log, GNUNET_SCHEDULER_add_read_net(), GNUNET_SCHEDULER_cancel(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, Plugin::ipv4_queue_head, UDP_MessageWrapper::next, GNUNET_TIME_Relative::rel_value_us, Plugin::select_task_v4, UDP_MessageWrapper::session, Plugin::sockv4, GNUNET_ATS_Session::target, UDP_MessageWrapper::transmission_time, and udp_plugin_select_v4().

Referenced by ack_proc(), enqueue_fragment(), setup_sockets(), udp_plugin_select_v4(), and udp_plugin_send().

735 {
736  struct GNUNET_TIME_Relative min_delay;
738  struct UDP_MessageWrapper *udpw;
739  struct UDP_MessageWrapper *min_udpw;
740 
741  if ((GNUNET_YES == plugin->enable_ipv4) && (NULL != plugin->sockv4))
742  {
743  /* Find a message ready to send:
744  * Flow delay from other peer is expired or not set (0) */
745  min_delay = GNUNET_TIME_UNIT_FOREVER_REL;
746  min_udpw = NULL;
747  for (udpw = plugin->ipv4_queue_head; NULL != udpw; udpw = udpw->next)
748  {
750  if (delay.rel_value_us < min_delay.rel_value_us)
751  {
752  min_delay = delay;
753  min_udpw = udpw;
754  }
755  }
756  if (NULL != plugin->select_task_v4)
758  if (NULL != min_udpw)
759  {
760  if (min_delay.rel_value_us > GNUNET_CONSTANTS_LATENCY_WARN.rel_value_us)
761  {
763  "Calculated flow delay for UDPv4 at %s for %s\n",
765  GNUNET_YES),
766  GNUNET_i2s(&min_udpw->session->target));
767  }
768  else
769  {
771  "Calculated flow delay for UDPv4 at %s for %s\n",
773  GNUNET_YES),
774  GNUNET_i2s(&min_udpw->session->target));
775  }
776  }
777  plugin->select_task_v4 =
779  plugin->sockv4,
781  plugin);
782  }
783 }
uint64_t rel_value_us
The actual value.
struct GNUNET_ATS_Session * session
Session this message belongs to.
int enable_ipv4
Is IPv4 enabled: GNUNET_YES or GNUNET_NO.
struct GNUNET_TIME_Absolute transmission_time
Desired transmission time for this message, based on the flow limiting information we got from the ot...
#define GNUNET_CONSTANTS_LATENCY_WARN
After what amount of latency for a message do we print a warning?
struct GNUNET_NETWORK_Handle * sockv4
The read socket for IPv4.
struct UDP_MessageWrapper * next
DLL of messages, next element.
struct GNUNET_SCHEDULER_Task * select_task_v4
ID of select task for IPv4.
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:686
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
Information we track for each message in the queue.
static struct GNUNET_TIME_Relative delay
When should dkg communication start?
static void udp_plugin_select_v4(void *cls)
We have been notified that our readset has something to read.
struct GNUNET_PeerIdentity target
To whom are we talking to.
#define GNUNET_log(kind,...)
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_remaining(struct GNUNET_TIME_Absolute future)
Given a timestamp in the future, how much time remains until then?
Definition: time.c:331
#define GNUNET_YES
Definition: gnunet_common.h:77
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_read_net(struct GNUNET_TIME_Relative delay, struct GNUNET_NETWORK_Handle *rfd, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay or when the specified file descriptor is ready f...
Definition: scheduler.c:1467
struct UDP_MessageWrapper * ipv4_queue_head
Head of messages in IPv4 queue.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
Time for relative time used by GNUnet, in microseconds.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:956
Here is the call graph for this function:
Here is the caller graph for this function:

◆ schedule_select_v6()

static void schedule_select_v6 ( struct Plugin plugin)
static

(re)schedule IPv6-select tasks for this plugin.

Parameters
pluginplugin to reschedule

Definition at line 792 of file plugin_transport_udp.c.

References delay, Plugin::enable_ipv6, GNUNET_CONSTANTS_LATENCY_WARN, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_i2s(), GNUNET_log, GNUNET_SCHEDULER_add_read_net(), GNUNET_SCHEDULER_cancel(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, Plugin::ipv6_queue_head, UDP_MessageWrapper::next, GNUNET_TIME_Relative::rel_value_us, Plugin::select_task_v6, UDP_MessageWrapper::session, Plugin::sockv6, GNUNET_ATS_Session::target, UDP_MessageWrapper::transmission_time, and udp_plugin_select_v6().

Referenced by ack_proc(), enqueue_fragment(), setup_sockets(), udp_plugin_select_v6(), and udp_plugin_send().

793 {
794  struct GNUNET_TIME_Relative min_delay;
796  struct UDP_MessageWrapper *udpw;
797  struct UDP_MessageWrapper *min_udpw;
798 
799  if ((GNUNET_YES == plugin->enable_ipv6) && (NULL != plugin->sockv6))
800  {
801  min_delay = GNUNET_TIME_UNIT_FOREVER_REL;
802  min_udpw = NULL;
803  for (udpw = plugin->ipv6_queue_head; NULL != udpw; udpw = udpw->next)
804  {
806  if (delay.rel_value_us < min_delay.rel_value_us)
807  {
808  min_delay = delay;
809  min_udpw = udpw;
810  }
811  }
812  if (NULL != plugin->select_task_v6)
814  if (NULL != min_udpw)
815  {
816  if (min_delay.rel_value_us > GNUNET_CONSTANTS_LATENCY_WARN.rel_value_us)
817  {
819  "Calculated flow delay for UDPv6 at %s for %s\n",
821  GNUNET_YES),
822  GNUNET_i2s(&min_udpw->session->target));
823  }
824  else
825  {
827  "Calculated flow delay for UDPv6 at %s for %s\n",
829  GNUNET_YES),
830  GNUNET_i2s(&min_udpw->session->target));
831  }
832  }
833  plugin->select_task_v6 =
835  plugin->sockv6,
837  plugin);
838  }
839 }
struct UDP_MessageWrapper * ipv6_queue_head
Head of messages in IPv6 queue.
uint64_t rel_value_us
The actual value.
struct GNUNET_ATS_Session * session
Session this message belongs to.
static void udp_plugin_select_v6(void *cls)
We have been notified that our readset has something to read.
struct GNUNET_TIME_Absolute transmission_time
Desired transmission time for this message, based on the flow limiting information we got from the ot...
#define GNUNET_CONSTANTS_LATENCY_WARN
After what amount of latency for a message do we print a warning?
struct UDP_MessageWrapper * next
DLL of messages, next element.
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:686
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
Information we track for each message in the queue.
struct GNUNET_SCHEDULER_Task * select_task_v6
ID of select task for IPv6.
static struct GNUNET_TIME_Relative delay
When should dkg communication start?
struct GNUNET_PeerIdentity target
To whom are we talking to.
#define GNUNET_log(kind,...)
struct GNUNET_NETWORK_Handle * sockv6
The read socket for IPv6.
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_remaining(struct GNUNET_TIME_Absolute future)
Given a timestamp in the future, how much time remains until then?
Definition: time.c:331
#define GNUNET_YES
Definition: gnunet_common.h:77
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_read_net(struct GNUNET_TIME_Relative delay, struct GNUNET_NETWORK_Handle *rfd, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay or when the specified file descriptor is ready f...
Definition: scheduler.c:1467
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
int enable_ipv6
Is IPv6 enabled: GNUNET_YES or GNUNET_NO.
Time for relative time used by GNUnet, in microseconds.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:956
Here is the call graph for this function:
Here is the caller graph for this function:

◆ udp_address_to_string()

const char* udp_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.

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
clsclosure
addrbinary address (a union UdpAddress)
addrlenlength of the addr
Returns
string representing the same address

Definition at line 857 of file plugin_transport_udp.c.

References buf, GNUNET_break_op, GNUNET_snprintf(), IPv4UdpAddress::ipv4_addr, IPv6UdpAddress::ipv6_addr, options, IPv4UdpAddress::options, IPv6UdpAddress::options, PLUGIN_NAME, port, t4, t6, IPv4UdpAddress::u4_port, and IPv6UdpAddress::u6_port.

Referenced by ack_proc(), broadcast_mst_cb(), libgnunet_plugin_transport_udp_init(), read_process_ack(), read_process_fragment(), udp_disconnect_session(), udp_plugin_create_session(), udp_plugin_lookup_session(), and udp_plugin_send().

858 {
859  static char rbuf[INET6_ADDRSTRLEN + 10];
860  char buf[INET6_ADDRSTRLEN];
861  const void *sb;
862  struct in_addr a4;
863  struct in6_addr a6;
864  const struct IPv4UdpAddress *t4;
865  const struct IPv6UdpAddress *t6;
866  int af;
867  uint16_t port;
868  uint32_t options;
869 
870  if (NULL == addr)
871  {
872  GNUNET_break_op(0);
873  return NULL;
874  }
875 
876  if (addrlen == sizeof(struct IPv6UdpAddress))
877  {
878  t6 = addr;
879  af = AF_INET6;
880  options = ntohl(t6->options);
881  port = ntohs(t6->u6_port);
882  a6 = t6->ipv6_addr;
883  sb = &a6;
884  }
885  else if (addrlen == sizeof(struct IPv4UdpAddress))
886  {
887  t4 = addr;
888  af = AF_INET;
889  options = ntohl(t4->options);
890  port = ntohs(t4->u4_port);
891  a4.s_addr = t4->ipv4_addr;
892  sb = &a4;
893  }
894  else
895  {
896  GNUNET_break_op(0);
897  return NULL;
898  }
899  inet_ntop(af, sb, buf, INET6_ADDRSTRLEN);
900  GNUNET_snprintf(rbuf,
901  sizeof(rbuf),
902  (af == AF_INET6) ? "%s.%u.[%s]:%u" : "%s.%u.%s:%u",
903  PLUGIN_NAME,
904  options,
905  buf,
906  port);
907  return rbuf;
908 }
uint32_t options
Optional options and flags for this address.
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
int GNUNET_snprintf(char *buf, size_t size, const char *format,...)
Like snprintf, just aborts if the buffer is of insufficient size.
uint16_t u4_port
Port number, in network byte order.
struct in6_addr ipv6_addr
IPv6 address.
uint16_t u6_port
Port number, in network byte order.
Network format for IPv4 addresses.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
uint32_t ipv4_addr
IPv4 address, in network byte order.
static struct GNUNET_SCHEDULER_Task * t4
Task for IPv4 socket.
static char buf[2048]
uint32_t options
Optional options and flags for this address.
Network format for IPv6 addresses.
static uint16_t port
Port number.
Definition: gnunet-bcd.c:81
#define PLUGIN_NAME
static struct GNUNET_SCHEDULER_Task * t6
Task for IPv6 socket.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ udp_string_to_address()

static int udp_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
clsclosure (struct Plugin *)
addrstring address
addrlenlength of the address
buflocation to store the buffer
addedlocation 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 923 of file plugin_transport_udp.c.

References address, GNUNET_break, GNUNET_free, GNUNET_new, GNUNET_OK, GNUNET_strdup, GNUNET_STRINGS_to_address_ip(), GNUNET_SYSERR, IPv4UdpAddress::ipv4_addr, IPv6UdpAddress::ipv6_addr, options, IPv4UdpAddress::options, IPv6UdpAddress::options, plugin, IPv4UdpAddress::u4_port, and IPv6UdpAddress::u6_port.

Referenced by libgnunet_plugin_transport_udp_init().

928 {
929  struct sockaddr_storage socket_address;
930  char *address;
931  char *plugin;
932  char *optionstr;
933  uint32_t options;
934 
935  /* Format tcp.options.address:port */
936  address = NULL;
937  plugin = NULL;
938  optionstr = NULL;
939 
940  if ((NULL == addr) || (0 == addrlen))
941  {
942  GNUNET_break(0);
943  return GNUNET_SYSERR;
944  }
945  if ('\0' != addr[addrlen - 1])
946  {
947  GNUNET_break(0);
948  return GNUNET_SYSERR;
949  }
950  if (strlen(addr) != addrlen - 1)
951  {
952  GNUNET_break(0);
953  return GNUNET_SYSERR;
954  }
955  plugin = GNUNET_strdup(addr);
956  optionstr = strchr(plugin, '.');
957  if (NULL == optionstr)
958  {
959  GNUNET_break(0);
960  GNUNET_free(plugin);
961  return GNUNET_SYSERR;
962  }
963  optionstr[0] = '\0';
964  optionstr++;
965  options = atol(optionstr);
966  address = strchr(optionstr, '.');
967  if (NULL == address)
968  {
969  GNUNET_break(0);
970  GNUNET_free(plugin);
971  return GNUNET_SYSERR;
972  }
973  address[0] = '\0';
974  address++;
975 
976  if (GNUNET_OK !=
977  GNUNET_STRINGS_to_address_ip(address, strlen(address), &socket_address))
978  {
979  GNUNET_break(0);
980  GNUNET_free(plugin);
981  return GNUNET_SYSERR;
982  }
983  GNUNET_free(plugin);
984 
985  switch (socket_address.ss_family)
986  {
987  case AF_INET: {
988  struct IPv4UdpAddress *u4;
989  const struct sockaddr_in *in4 =
990  (const struct sockaddr_in *)&socket_address;
991 
992  u4 = GNUNET_new(struct IPv4UdpAddress);
993  u4->options = htonl(options);
994  u4->ipv4_addr = in4->sin_addr.s_addr;
995  u4->u4_port = in4->sin_port;
996  *buf = u4;
997  *added = sizeof(struct IPv4UdpAddress);
998  return GNUNET_OK;
999  }
1000 
1001  case AF_INET6: {
1002  struct IPv6UdpAddress *u6;
1003  const struct sockaddr_in6 *in6 =
1004  (const struct sockaddr_in6 *)&socket_address;
1005 
1006  u6 = GNUNET_new(struct IPv6UdpAddress);
1007  u6->options = htonl(options);
1008  u6->ipv6_addr = in6->sin6_addr;
1009  u6->u6_port = in6->sin6_port;
1010  *buf = u6;
1011  *added = sizeof(struct IPv6UdpAddress);
1012  return GNUNET_OK;
1013  }
1014 
1015  default:
1016  GNUNET_break(0);
1017  return GNUNET_SYSERR;
1018  }
1019 }
uint32_t options
Optional options and flags for this address.
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
uint16_t u4_port
Port number, in network byte order.
struct in6_addr ipv6_addr
IPv6 address.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_new(type)
Allocate a struct or union of the given type.
uint16_t u6_port
Port number, in network byte order.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
Network format for IPv4 addresses.
uint32_t ipv4_addr
IPv4 address, in network byte order.
static char buf[2048]
uint32_t options
Optional options and flags for this address.
Network format for IPv6 addresses.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
static char * address
GNS address for this phone.
int GNUNET_STRINGS_to_address_ip(const char *addr, uint16_t addrlen, struct sockaddr_storage *r_buf)
Tries to convert addr string to an IP (v4 or v6) address.
Definition: strings.c:1327
#define GNUNET_free(ptr)
Wrapper around free.
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

Append our port and forward the result.

Parameters
clsa struct PrettyPrinterContext *
hostnameresult from DNS resolver

Definition at line 1029 of file plugin_transport_udp.c.

References PrettyPrinterContext::asc, PrettyPrinterContext::asc_cls, GNUNET_asprintf(), GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_OK, GNUNET_YES, PrettyPrinterContext::ipv6, PrettyPrinterContext::options, plugin, PrettyPrinterContext::plugin, PLUGIN_NAME, PrettyPrinterContext::port, Plugin::ppc_dll_head, Plugin::ppc_dll_tail, PrettyPrinterContext::resolver_handle, and ret.

Referenced by udp_plugin_address_pretty_printer().

1030 {
1031  struct PrettyPrinterContext *ppc = cls;
1032  struct Plugin *plugin = ppc->plugin;
1033  char *ret;
1034 
1035  if (NULL == hostname)
1036  {
1037  /* Final call, done */
1039  plugin->ppc_dll_tail,
1040  ppc);
1041  ppc->resolver_handle = NULL;
1042  ppc->asc(ppc->asc_cls, NULL, GNUNET_OK);
1043  GNUNET_free(ppc);
1044  return;
1045  }
1046  if (GNUNET_YES == ppc->ipv6)
1047  GNUNET_asprintf(&ret,
1048  "%s.%u.[%s]:%d",
1049  PLUGIN_NAME,
1050  ppc->options,
1051  hostname,
1052  ppc->port);
1053  else
1054  GNUNET_asprintf(&ret,
1055  "%s.%u.%s:%d",
1056  PLUGIN_NAME,
1057  ppc->options,
1058  hostname,
1059  ppc->port);
1060  ppc->asc(ppc->asc_cls, ret, GNUNET_OK);
1061  GNUNET_free(ret);
1062 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
GNUNET_TRANSPORT_AddressStringCallback asc
Function to call with the result.
struct PrettyPrinterContext * ppc_dll_tail
Running pretty printers: tail.
struct GNUNET_RESOLVER_RequestHandle * resolver_handle
Resolver handle.
Closure for append_port().
uint16_t port
Port to add after the IP address.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
void * asc_cls
Clsoure for asc.
static int ret
Final status code.
Definition: gnunet-arm.c:89
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
static char * hostname
Our hostname; we give this to all the peers we start.
Handle for a plugin.
Definition: block.c:37
uint32_t options
Address options.
#define PLUGIN_NAME
#define GNUNET_YES
Definition: gnunet_common.h:77
struct PrettyPrinterContext * ppc_dll_head
Running pretty printers: head.
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ udp_plugin_address_pretty_printer()

static void udp_plugin_address_pretty_printer ( void *  cls,
const char *  type,
const void *  addr,
size_t  addrlen,
int  numeric,
struct GNUNET_TIME_Relative  timeout,
GNUNET_TRANSPORT_AddressStringCallback  asc,
void *  asc_cls 
)
static

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

Parameters
clsclosure with the struct Plugin *
typename of the transport that generated the address
addrone of the addresses of the host, NULL for the last address the specific address format depends on the transport; a union UdpAddress
addrlenlength of the address
numericshould (IP) addresses be displayed in numeric form?
timeoutafter how long should we give up?
ascfunction to call on each string
asc_clsclosure for asc

Definition at line 1080 of file plugin_transport_udp.c.

References append_port(), PrettyPrinterContext::asc, PrettyPrinterContext::asc_cls, GNUNET_break_op, GNUNET_CONTAINER_DLL_insert, GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_RESOLVER_hostname_get(), GNUNET_SYSERR, GNUNET_YES, IPv4UdpAddress::ipv4_addr, PrettyPrinterContext::ipv6, IPv6UdpAddress::ipv6_addr, options, IPv4UdpAddress::options, IPv6UdpAddress::options, PrettyPrinterContext::options, plugin, PrettyPrinterContext::plugin, port, PrettyPrinterContext::port, Plugin::ppc_dll_head, Plugin::ppc_dll_tail, PrettyPrinterContext::resolver_handle, IPv4UdpAddress::u4_port, and IPv6UdpAddress::u6_port.

Referenced by libgnunet_plugin_transport_udp_init().

1088 {
1089  struct Plugin *plugin = cls;
1090  struct PrettyPrinterContext *ppc;
1091  const struct sockaddr *sb;
1092  size_t sbs;
1093  struct sockaddr_in a4;
1094  struct sockaddr_in6 a6;
1095  const struct IPv4UdpAddress *u4;
1096  const struct IPv6UdpAddress *u6;
1097  uint16_t port;
1098  uint32_t options;
1099 
1100  if (addrlen == sizeof(struct IPv6UdpAddress))
1101  {
1102  u6 = addr;
1103  memset(&a6, 0, sizeof(a6));
1104  a6.sin6_family = AF_INET6;
1105 #if HAVE_SOCKADDR_IN_SIN_LEN
1106  a6.sin6_len = sizeof(a6);
1107 #endif
1108  a6.sin6_port = u6->u6_port;
1109  a6.sin6_addr = u6->ipv6_addr;
1110  port = ntohs(u6->u6_port);
1111  options = ntohl(u6->options);
1112  sb = (const struct sockaddr *)&a6;
1113  sbs = sizeof(a6);
1114  }
1115  else if (addrlen == sizeof(struct IPv4UdpAddress))
1116  {
1117  u4 = addr;
1118  memset(&a4, 0, sizeof(a4));
1119  a4.sin_family = AF_INET;
1120 #if HAVE_SOCKADDR_IN_SIN_LEN
1121  a4.sin_len = sizeof(a4);
1122 #endif
1123  a4.sin_port = u4->u4_port;
1124  a4.sin_addr.s_addr = u4->ipv4_addr;
1125  port = ntohs(u4->u4_port);
1126  options = ntohl(u4->options);
1127  sb = (const struct sockaddr *)&a4;
1128  sbs = sizeof(a4);
1129  }
1130  else
1131  {
1132  /* invalid address */
1133  GNUNET_break_op(0);
1134  asc(asc_cls, NULL, GNUNET_SYSERR);
1135  asc(asc_cls, NULL, GNUNET_OK);
1136  return;
1137  }
1138  ppc = GNUNET_new(struct PrettyPrinterContext);
1139  ppc->plugin = plugin;
1140  ppc->asc = asc;
1141  ppc->asc_cls = asc_cls;
1142  ppc->port = port;
1143  ppc->options = options;
1144  if (addrlen == sizeof(struct IPv6UdpAddress))
1145  ppc->ipv6 = GNUNET_YES;
1146  else
1147  ppc->ipv6 = GNUNET_NO;
1148  GNUNET_CONTAINER_DLL_insert(plugin->ppc_dll_head, plugin->ppc_dll_tail, ppc);
1150  sbs,
1151  !numeric,
1152  timeout,
1153  &append_port,
1154  ppc);
1155 }
uint32_t options
Optional options and flags for this address.
GNUNET_TRANSPORT_AddressStringCallback asc
Function to call with the result.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
struct PrettyPrinterContext * ppc_dll_tail
Running pretty printers: tail.
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
struct GNUNET_RESOLVER_RequestHandle * resolver_handle
Resolver handle.
uint16_t u4_port
Port number, in network byte order.
Closure for append_port().
uint16_t port
Port to add after the IP address.
struct in6_addr ipv6_addr
IPv6 address.
#define GNUNET_NO
Definition: gnunet_common.h:78
static int numeric
Option -n.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_RESOLVER_RequestHandle * GNUNET_RESOLVER_hostname_get(const struct sockaddr *sa, socklen_t salen, int do_resolve, struct GNUNET_TIME_Relative timeout, GNUNET_RESOLVER_HostnameCallback callback, void *cls)
Perform a reverse DNS lookup.
void * asc_cls
Clsoure for asc.
uint16_t u6_port
Port number, in network byte order.
static void append_port(void *cls, const char *hostname)
Append our port and forward the result.
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
Network format for IPv4 addresses.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
uint32_t ipv4_addr
IPv4 address, in network byte order.
uint32_t options
Optional options and flags for this address.
Network format for IPv6 addresses.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
static uint16_t port
Port number.
Definition: gnunet-bcd.c:81
Handle for a plugin.
Definition: block.c:37
uint32_t options
Address options.
#define GNUNET_YES
Definition: gnunet_common.h:77
struct PrettyPrinterContext * ppc_dll_head
Running pretty printers: head.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ check_port()

static int check_port ( const struct Plugin plugin,
uint16_t  in_port 
)
static

Check if the given port is plausible (must be either our listen port or our advertised port).

If it is neither, we return GNUNET_SYSERR.

Parameters
pluginglobal variables
in_portport number to check
Returns
GNUNET_OK if port is either our open or advertised port

Definition at line 1168 of file plugin_transport_udp.c.

References Plugin::aport, GNUNET_OK, GNUNET_SYSERR, and Plugin::port.

Referenced by udp_plugin_check_address().

1169 {
1170  if ((plugin->port == in_port) || (plugin->aport == in_port))
1171  return GNUNET_OK;
1172  return GNUNET_SYSERR;
1173 }
uint16_t aport
Port we advertise on.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
uint16_t port
Port used.
Here is the caller graph for this function:

◆ udp_plugin_check_address()

static int udp_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
clsclosure, should be our handle to the Plugin
addrpointer to a union UdpAddress
addrlenlength of addr
Returns
GNUNET_OK if this is a plausible address for this peer and transport, GNUNET_SYSERR if not

Definition at line 1192 of file plugin_transport_udp.c.

References check_port(), GNUNET_break_op, GNUNET_NAT_test_address(), GNUNET_OK, GNUNET_SYSERR, Plugin::nat, and plugin.

Referenced by libgnunet_plugin_transport_udp_init().

1193 {
1194  struct Plugin *plugin = cls;
1195  const struct IPv4UdpAddress *v4;
1196  const struct IPv6UdpAddress *v6;
1197 
1198  if (sizeof(struct IPv4UdpAddress) == addrlen)
1199  {
1200  struct sockaddr_in s4;
1201 
1202  v4 = (const struct IPv4UdpAddress *)addr;
1203  if (GNUNET_OK != check_port(plugin, ntohs(v4->u4_port)))
1204  return GNUNET_SYSERR;
1205  memset(&s4, 0, sizeof(s4));
1206  s4.sin_family = AF_INET;
1207 #if HAVE_SOCKADDR_IN_SIN_LEN
1208  s4.sin_len = sizeof(s4);
1209 #endif
1210  s4.sin_port = v4->u4_port;
1211  s4.sin_addr.s_addr = v4->ipv4_addr;
1212 
1213  if (GNUNET_OK !=
1214  GNUNET_NAT_test_address(plugin->nat, &s4, sizeof(struct sockaddr_in)))
1215  return GNUNET_SYSERR;
1216  }
1217  else if (sizeof(struct IPv6UdpAddress) == addrlen)
1218  {
1219  struct sockaddr_in6 s6;
1220 
1221  v6 = (const struct IPv6UdpAddress *)addr;
1222  if (IN6_IS_ADDR_LINKLOCAL(&v6->ipv6_addr))
1223  return GNUNET_OK; /* plausible, if unlikely... */
1224  memset(&s6, 0, sizeof(s6));
1225  s6.sin6_family = AF_INET6;
1226 #if HAVE_SOCKADDR_IN_SIN_LEN
1227  s6.sin6_len = sizeof(s6);
1228 #endif
1229  s6.sin6_port = v6->u6_port;
1230  s6.sin6_addr = v6->ipv6_addr;
1231 
1232  if (GNUNET_OK != GNUNET_NAT_test_address(plugin->nat,
1233  &s6,
1234  sizeof(struct sockaddr_in6)))
1235  return GNUNET_SYSERR;
1236  }
1237  else
1238  {
1239  GNUNET_break_op(0);
1240  return GNUNET_SYSERR;
1241  }
1242  return GNUNET_OK;
1243 }
struct GNUNET_NAT_Handle * nat
NAT handle & address management.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
int GNUNET_NAT_test_address(struct GNUNET_NAT_Handle *nh, const void *addr, socklen_t addrlen)
Test if the given address is (currently) a plausible IP address for this peer.
Definition: nat_api.c:623
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
Network format for IPv4 addresses.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
Network format for IPv6 addresses.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
Handle for a plugin.
Definition: block.c:37
static int check_port(const struct Plugin *plugin, uint16_t in_port)
Check if the given port is plausible (must be either our listen port or our advertised port)...
Here is the call graph for this function:
Here is the caller graph for this function:

◆ udp_nat_port_map_callback()

static void udp_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
clsclosure, the struct Plugin
app_ctx[in,out]location where the app can store stuff on add and retrieve it on remove
add_removeGNUNET_YES to mean the new public IP address, GNUNET_NO to mean the previous (now invalid) one
acaddress class the address belongs to
addreither the previous or the new public IP address
addrlenactual length of the addr

Definition at line 1259 of file plugin_transport_udp.c.

References address, find_typedefs::arg, gnunet-chk::args, GNUNET_DATACACHE_PluginEnvironment::cls, Plugin::env, GNUNET_a2s(), GNUNET_assert, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_HELLO_address_allocate(), GNUNET_HELLO_address_free, GNUNET_HELLO_ADDRESS_INFO_NONE, GNUNET_YES, IPv4UdpAddress::ipv4_addr, IPv6UdpAddress::ipv6_addr, LOG, Plugin::myoptions, IPv4UdpAddress::options, IPv6UdpAddress::options, plugin, PLUGIN_NAME, IPv4UdpAddress::u4_port, and IPv6UdpAddress::u6_port.

Referenced by setup_sockets().

1265 {
1266  struct Plugin *plugin = cls;
1267  struct GNUNET_HELLO_Address *address;
1268  struct IPv4UdpAddress u4;
1269  struct IPv6UdpAddress u6;
1270  void *arg;
1271  size_t args;
1272 
1273  (void)app_ctx;
1275  (GNUNET_YES == add_remove) ? "NAT notification to add address `%s'\n"
1276  : "NAT notification to remove address `%s'\n",
1277  GNUNET_a2s(addr, addrlen));
1278  /* convert 'address' to our internal format */
1279  switch (addr->sa_family)
1280  {
1281  case AF_INET: {
1282  const struct sockaddr_in *i4;
1283 
1284  GNUNET_assert(sizeof(struct sockaddr_in) == addrlen);
1285  i4 = (const struct sockaddr_in *)addr;
1286  if (0 == ntohs(i4->sin_port))
1287  return; /* Port = 0 means unmapped, ignore these for UDP. */
1288  memset(&u4, 0, sizeof(u4));
1289  u4.options = htonl(plugin->myoptions);
1290  u4.ipv4_addr = i4->sin_addr.s_addr;
1291  u4.u4_port = i4->sin_port;
1292  arg = &u4;
1293  args = sizeof(struct IPv4UdpAddress);
1294  break;
1295  }
1296 
1297  case AF_INET6: {
1298  const struct sockaddr_in6 *i6;
1299 
1300  GNUNET_assert(sizeof(struct sockaddr_in6) == addrlen);
1301  i6 = (const struct sockaddr_in6 *)addr;
1302  if (0 == ntohs(i6->sin6_port))
1303  return; /* Port = 0 means unmapped, ignore these for UDP. */
1304  memset(&u6, 0, sizeof(u6));
1305  u6.options = htonl(plugin->myoptions);
1306  u6.ipv6_addr = i6->sin6_addr;
1307  u6.u6_port = i6->sin6_port;
1308  arg = &u6;
1309  args = sizeof(struct IPv6UdpAddress);
1310  break;
1311  }
1312 
1313  default:
1314  GNUNET_break(0);
1315  return;
1316  }
1317  /* modify our published address list */
1318  /* TODO: use 'ac' here in the future... */
1319  address = GNUNET_HELLO_address_allocate(plugin->env->my_identity,
1320  PLUGIN_NAME,
1321  arg,
1322  args,
1324  plugin->env->notify_address(plugin->env->cls, add_remove, address);
1325  GNUNET_HELLO_address_free(address);
1326 }
struct GNUNET_HELLO_Address * GNUNET_HELLO_address_allocate(const struct GNUNET_PeerIdentity *peer, const char *transport_name, const void *address, size_t address_length, enum GNUNET_HELLO_AddressInfo local_info)
Allocate an address struct.
Definition: address.c:73
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
Network format for IPv4 addresses.
struct GNUNET_DATACACHE_PluginEnvironment * env
Our execution environment.
const char * GNUNET_a2s(const struct sockaddr *addr, socklen_t addrlen)
Convert a "struct sockaddr*" (IPv4 or IPv6 address) to a string (for printing debug messages)...
Network format for IPv6 addresses.
No additional information.
Handle for a plugin.
Definition: block.c:37
#define PLUGIN_NAME
An address for communicating with a peer.
void * cls
Closure to use for callbacks.
#define GNUNET_YES
Definition: gnunet_common.h:77
uint32_t myoptions
Address options.
static char * address
GNS address for this phone.
#define LOG(kind,...)
#define GNUNET_HELLO_address_free(addr)
Free an address.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ session_cmp_it()

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

Find a session with a matching address.

Parameters
clsthe struct GNUNET_ATS_SessionCompareContext *
keypeer identity (unused)
valuethe struct GNUNET_ATS_Session *
Returns
GNUNET_NO if we found the session, GNUNET_OK if not

Definition at line 1357 of file plugin_transport_udp.c.

References GNUNET_ATS_Session::address, GNUNET_ATS_SessionCompareContext::address, GNUNET_assert, GNUNET_HELLO_address_cmp(), GNUNET_NO, GNUNET_OK, GNUNET_ATS_Session::in_destroy, GNUNET_ATS_SessionCompareContext::res, and value.

Referenced by udp_plugin_lookup_session().

1358 {
1359  struct GNUNET_ATS_SessionCompareContext *cctx = cls;
1360  struct GNUNET_ATS_Session *s = value;
1361 
1362  if (0 == GNUNET_HELLO_address_cmp(s->address, cctx->address))
1363  {
1365  cctx->res = s;
1366  return GNUNET_NO;
1367  }
1368  return GNUNET_OK;
1369 }
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
struct GNUNET_HELLO_Address * address
Address.
int GNUNET_HELLO_address_cmp(const struct GNUNET_HELLO_Address *a1, const struct GNUNET_HELLO_Address *a2)
Compare two addresses.
Definition: address.c:130
static char * value
Value of the record to add/remove.
Information about ongoing sessions of the transport client.
Closure for session_cmp_it().
int in_destroy
Is this session about to be destroyed (sometimes we cannot destroy a session immediately as below us ...
const struct GNUNET_HELLO_Address * address
Address we are looking for.
struct GNUNET_ATS_Session * res
Set to session matching the address.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ udp_plugin_lookup_session()

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

Locate an existing session the transport service is using to send data to another peer.

Performs some basic sanity checks on the address and then tries to locate a matching session.

Parameters
clsthe plugin
addressthe address we should locate the session by
Returns
the session if it exists, or NULL if it is not found

Definition at line 1382 of file plugin_transport_udp.c.

References GNUNET_HELLO_Address::address, address, GNUNET_ATS_SessionCompareContext::address, GNUNET_HELLO_Address::address_length, GNUNET_break, GNUNET_CONTAINER_multipeermap_get_multiple(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), LOG, GNUNET_HELLO_Address::peer, plugin, GNUNET_ATS_SessionCompareContext::res, session_cmp_it(), Plugin::sessions, Plugin::sockv4, Plugin::sockv6, IPv4UdpAddress::u4_port, IPv6UdpAddress::u6_port, and udp_address_to_string().

Referenced by ack_proc(), process_udp_message(), read_process_ack(), and udp_plugin_get_session().

1384 {
1385  struct Plugin *plugin = cls;
1386  const struct IPv6UdpAddress *udp_a6;
1387  const struct IPv4UdpAddress *udp_a4;
1389 
1390  if (NULL == address->address)
1391  {
1392  GNUNET_break(0);
1393  return NULL;
1394  }
1395  if (sizeof(struct IPv4UdpAddress) == address->address_length)
1396  {
1397  if (NULL == plugin->sockv4)
1398  return NULL;
1399  udp_a4 = (const struct IPv4UdpAddress *)address->address;
1400  if (0 == udp_a4->u4_port)
1401  {
1402  GNUNET_break(0);
1403  return NULL;
1404  }
1405  }
1406  else if (sizeof(struct IPv6UdpAddress) == address->address_length)
1407  {
1408  if (NULL == plugin->sockv6)
1409  return NULL;
1410  udp_a6 = (const struct IPv6UdpAddress *)address->address;
1411  if (0 == udp_a6->u6_port)
1412  {
1413  GNUNET_break(0);
1414  return NULL;
1415  }
1416  }
1417  else
1418  {
1419  GNUNET_break(0);
1420  return NULL;
1421  }
1422 
1423  /* check if session already exists */
1424  cctx.address = address;
1425  cctx.res = NULL;
1427  "Looking for existing session for peer `%s' with address `%s'\n",
1428  GNUNET_i2s(&address->peer),
1429  udp_address_to_string(plugin,
1430  address->address,
1431  address->address_length));
1433  &address->peer,
1434  &session_cmp_it,
1435  &cctx);
1436  if (NULL == cctx.res)
1437  return NULL;
1438  LOG(GNUNET_ERROR_TYPE_DEBUG, "Found existing session %p\n", cctx.res);
1439  return cctx.res;
1440 }
size_t address_length
Number of bytes in address.
const void * address
Binary representation of the address (plugin-specific).
uint16_t u4_port
Port number, in network byte order.
struct GNUNET_NETWORK_Handle * sockv4
The read socket for IPv4.
uint16_t u6_port
Port number, in network byte order.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
Network format for IPv4 addresses.
Closure for session_cmp_it().
static int session_cmp_it(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
Find a session with a matching address.
Network format for IPv6 addresses.
struct GNUNET_PeerIdentity peer
For which peer is this an address?
Handle for a plugin.
Definition: block.c:37
const char * udp_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.
struct GNUNET_ATS_Session * sessions
List of open sessions (or peer map, or...)
struct GNUNET_NETWORK_Handle * sockv6
The read socket for IPv6.
static char * address
GNS address for this phone.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define LOG(kind,...)
int GNUNET_CONTAINER_multipeermap_get_multiple(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, GNUNET_CONTAINER_PeerMapIterator it, void *it_cls)
Iterate over all entries in the map that match a particular key.
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
ssession to reschedule timeout activity for

Definition at line 1452 of file plugin_transport_udp.c.

References GNUNET_assert, GNUNET_TIME_relative_to_absolute(), GNUNET_YES, GNUNET_ATS_Session::in_destroy, GNUNET_ATS_Session::timeout, GNUNET_ATS_Session::timeout_task, and UDP_SESSION_TIME_OUT.

Referenced by process_inbound_tokenized_messages(), and udp_plugin_update_session_timeout().

1453 {
1454  if (GNUNET_YES == s->in_destroy)
1455  return;
1456  GNUNET_assert(NULL != s->timeout_task);
1458 }
struct GNUNET_SCHEDULER_Task * timeout_task
Session timeout task.
struct GNUNET_TIME_Absolute GNUNET_TIME_relative_to_absolute(struct GNUNET_TIME_Relative rel)
Convert relative time to an absolute time in the future.
Definition: time.c:246
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_TIME_Absolute timeout
When does this session time out.
#define UDP_SESSION_TIME_OUT
After how much inactivity should a UDP session time out?
int in_destroy
Is this session about to be destroyed (sometimes we cannot destroy a session immediately as below us ...
#define GNUNET_YES
Definition: gnunet_common.h:77
Here is the call graph for this function:
Here is the caller graph for this function:

◆ udp_plugin_update_session_timeout()

static void udp_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
clsclosure with the struct Plugin
peerwhich peer was the session for
sessionwhich session is being updated

Definition at line 1471 of file plugin_transport_udp.c.

References GNUNET_break, GNUNET_CONTAINER_multipeermap_contains_value(), GNUNET_YES, plugin, reschedule_session_timeout(), and Plugin::sessions.

Referenced by libgnunet_plugin_transport_udp_init().

1474 {
1475  struct Plugin *plugin = cls;
1476 
1477  if (GNUNET_YES !=
1479  peer,
1480  session))
1481  {
1482  GNUNET_break(0);
1483  return;
1484  }
1485  /* Reschedule session timeout */
1486  reschedule_session_timeout(session);
1487 }
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
int GNUNET_CONTAINER_multipeermap_contains_value(const struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, const void *value)
Check if the map contains the given value under the given key.
Handle for a plugin.
Definition: block.c:37
struct GNUNET_ATS_Session * sessions
List of open sessions (or peer map, or...)
#define GNUNET_YES
Definition: gnunet_common.h:77
static void reschedule_session_timeout(struct GNUNET_ATS_Session *s)
Increment session timeout due to activity.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ dequeue()

static void dequeue ( struct Plugin plugin,
struct UDP_MessageWrapper udpw 
)
static

Remove the given message from the transmission queue and update all applicable statistics.

Parameters
pluginthe UDP plugin
udpwmessage wrapper to dequeue

Definition at line 1501 of file plugin_transport_udp.c.

References GNUNET_ATS_Session::address, GNUNET_HELLO_Address::address_length, Plugin::bytes_in_buffer, GNUNET_ATS_Session::bytes_in_queue, Plugin::env, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_NO, GNUNET_STATISTICS_update(), Plugin::ipv4_queue_head, Plugin::ipv4_queue_tail, Plugin::ipv6_queue_head, Plugin::ipv6_queue_tail, UDP_MessageWrapper::msg_size, GNUNET_ATS_Session::msgs_in_queue, and UDP_MessageWrapper::session.

Referenced by fragmented_message_done(), libgnunet_plugin_transport_udp_done(), remove_timeout_messages_and_select(), udp_disconnect_session(), and udp_select_send().

1502 {
1503  struct GNUNET_ATS_Session *session = udpw->session;
1504 
1505  if (plugin->bytes_in_buffer < udpw->msg_size)
1506  {
1507  GNUNET_break(0);
1508  }
1509  else
1510  {
1511  GNUNET_STATISTICS_update(plugin->env->stats,
1512  "# UDP, total bytes in send buffers",
1513  -(long long)udpw->msg_size,
1514  GNUNET_NO);
1515  plugin->bytes_in_buffer -= udpw->msg_size;
1516  }
1517  GNUNET_STATISTICS_update(plugin->env->stats,
1518  "# UDP, total messages in send buffers",
1519  -1,
1520  GNUNET_NO);
1521  if (sizeof(struct IPv4UdpAddress) == udpw->session->address->address_length)
1522  {
1524  plugin->ipv4_queue_tail,
1525  udpw);
1526  }
1527  else if (sizeof(struct IPv6UdpAddress) ==
1528  udpw->session->address->address_length)
1529  {
1531  plugin->ipv6_queue_tail,
1532  udpw);
1533  }
1534  else
1535  {
1536  GNUNET_break(0);
1537  return;
1538  }
1539  GNUNET_assert(session->msgs_in_queue > 0);
1540  session->msgs_in_queue--;
1541  GNUNET_assert(session->bytes_in_queue >= udpw->msg_size);
1542  session->bytes_in_queue -= udpw->msg_size;
1543 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
size_t address_length
Number of bytes in address.
struct UDP_MessageWrapper * ipv6_queue_head
Head of messages in IPv6 queue.
struct GNUNET_ATS_Session * session
Session this message belongs to.
unsigned int msgs_in_queue
Number of messages waiting for transmission to this peer.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_NO
Definition: gnunet_common.h:78
int64_t bytes_in_buffer
Bytes currently in buffer.
struct GNUNET_HELLO_Address * address
Address.
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
unsigned long long bytes_in_queue
Number of bytes waiting for transmission to this peer.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
Network format for IPv4 addresses.
Information about ongoing sessions of the transport client.
struct GNUNET_DATACACHE_PluginEnvironment * env
Our execution environment.
Network format for IPv6 addresses.
struct UDP_MessageWrapper * ipv4_queue_tail
Tail of messages in IPv4 queue.
struct UDP_MessageWrapper * ipv6_queue_tail
Tail of messages in IPv6 queue.
struct UDP_MessageWrapper * ipv4_queue_head
Head of messages in IPv4 queue.
size_t msg_size
Size of UDP message to send, including UDP-specific overhead.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ enqueue()

static void enqueue ( struct Plugin plugin,
struct UDP_MessageWrapper udpw 
)
static

Enqueue a message for transmission and update statistics.

Parameters
pluginthe UDP plugin
udpwmessage wrapper to queue

Definition at line 1553 of file plugin_transport_udp.c.

References GNUNET_ATS_Session::address, GNUNET_HELLO_Address::address_length, Plugin::bytes_in_buffer, GNUNET_ATS_Session::bytes_in_queue, UDP_MessageWrapper::cont, UDP_MessageWrapper::cont_cls, Plugin::env, GNUNET_break, GNUNET_CONTAINER_DLL_insert, GNUNET_free, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_SYSERR, GNUNET_YES, GNUNET_ATS_Session::in_destroy, Plugin::ipv4_queue_head, Plugin::ipv4_queue_tail, Plugin::ipv6_queue_head, Plugin::ipv6_queue_tail, UDP_MessageWrapper::msg_size, GNUNET_ATS_Session::msgs_in_queue, UDP_MessageWrapper::session, and GNUNET_ATS_Session::target.

Referenced by ack_proc(), enqueue_fragment(), and udp_plugin_send().

1554 {
1555  struct GNUNET_ATS_Session *session = udpw->session;
1556 
1557  if (GNUNET_YES == session->in_destroy)
1558  {
1559  GNUNET_break(0);
1560  GNUNET_free(udpw);
1561  return;
1562  }
1563  if (plugin->bytes_in_buffer > INT64_MAX - udpw->msg_size)
1564  {
1565  GNUNET_break(0);
1566  }
1567  else
1568  {
1569  GNUNET_STATISTICS_update(plugin->env->stats,
1570  "# UDP, total bytes in send buffers",
1571  udpw->msg_size,
1572  GNUNET_NO);
1573  plugin->bytes_in_buffer += udpw->msg_size;
1574  }
1575  GNUNET_STATISTICS_update(plugin->env->stats,
1576  "# UDP, total messages in send buffers",
1577  1,
1578  GNUNET_NO);
1579  if (sizeof(struct IPv4UdpAddress) == udpw->session->address->address_length)
1580  {
1582  plugin->ipv4_queue_tail,
1583  udpw);
1584  }
1585  else if (sizeof(struct IPv6UdpAddress) ==
1586  udpw->session->address->address_length)
1587  {
1589  plugin->ipv6_queue_tail,
1590  udpw);
1591  }
1592  else
1593  {
1594  GNUNET_break(0);
1595  udpw->cont(udpw->cont_cls,
1596  &session->target,
1597  GNUNET_SYSERR,
1598  udpw->msg_size,
1599  0);
1600  GNUNET_free(udpw);
1601  return;
1602  }
1603  session->msgs_in_queue++;
1604  session->bytes_in_queue += udpw->msg_size;
1605 }
size_t address_length
Number of bytes in address.
struct UDP_MessageWrapper * ipv6_queue_head
Head of messages in IPv6 queue.
struct GNUNET_ATS_Session * session
Session this message belongs to.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
unsigned int msgs_in_queue
Number of messages waiting for transmission to this peer.
#define GNUNET_NO
Definition: gnunet_common.h:78
int64_t bytes_in_buffer
Bytes currently in buffer.
struct GNUNET_HELLO_Address * address
Address.
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
unsigned long long bytes_in_queue
Number of bytes waiting for transmission to this peer.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
Network format for IPv4 addresses.
Information about ongoing sessions of the transport client.
struct GNUNET_DATACACHE_PluginEnvironment * env
Our execution environment.
int in_destroy
Is this session about to be destroyed (sometimes we cannot destroy a session immediately as below us ...
GNUNET_TRANSPORT_TransmitContinuation cont
External continuation to call upon completion of the transmission, NULL if this queue entry is not fo...
Network format for IPv6 addresses.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
struct UDP_MessageWrapper * ipv4_queue_tail
Tail of messages in IPv4 queue.
struct UDP_MessageWrapper * ipv6_queue_tail
Tail of messages in IPv6 queue.
void * cont_cls
Closure for cont.
struct GNUNET_PeerIdentity target
To whom are we talking to.
#define GNUNET_YES
Definition: gnunet_common.h:77
struct UDP_MessageWrapper * ipv4_queue_head
Head of messages in IPv4 queue.
size_t msg_size
Size of UDP message to send, including UDP-specific overhead.
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ fragmented_message_done()

static void fragmented_message_done ( struct UDP_FragmentationContext frag_ctx,
int  result 
)
static

We have completed our (attempt) to transmit a message that had to be fragmented – either because we got an ACK saying that all fragments were received, or because of timeout / disconnect.

Clean up our state.

Parameters
frag_ctxfragmentation context to clean up
resultGNUNET_OK if we succeeded (got ACK), GNUNET_SYSERR if the transmission failed

Definition at line 1619 of file plugin_transport_udp.c.

References GNUNET_ATS_Session::address, GNUNET_HELLO_Address::address_length, UDP_FragmentationContext::cont, UDP_FragmentationContext::cont_cls, dequeue(), Plugin::env, UDP_FragmentationContext::frag, GNUNET_ATS_Session::frag_ctx, UDP_MessageWrapper::frag_ctx, GNUNET_CONSTANTS_LATENCY_WARN, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_FRAGMENT_context_destroy(), GNUNET_free, GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_update(), GNUNET_STRINGS_absolute_time_to_string(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_SYSERR, GNUNET_TIME_absolute_get_duration(), GNUNET_TRANSPORT_SS_UPDATE, GNUNET_YES, Plugin::ipv4_queue_head, Plugin::ipv6_queue_head, GNUNET_ATS_Session::last_expected_ack_delay, GNUNET_ATS_Session::last_expected_msg_delay, LOG, UDP_MessageWrapper::next, UDP_FragmentationContext::next_frag_time, notify_session_monitor(), UDP_FragmentationContext::on_wire_size, UDP_FragmentationContext::payload_size, plugin, UDP_FragmentationContext::plugin, GNUNET_ATS_Session::plugin, GNUNET_TIME_Relative::rel_value_us, UDP_FragmentationContext::session, UDP_FragmentationContext::start_time, and GNUNET_ATS_Session::target.

Referenced by qc_fragment_sent(), read_process_ack(), and udp_disconnect_session().

1620 {
1621  struct Plugin *plugin = frag_ctx->plugin;
1622  struct GNUNET_ATS_Session *s = frag_ctx->session;
1623  struct UDP_MessageWrapper *udpw;
1624  struct UDP_MessageWrapper *tmp;
1625  size_t overhead;
1626  struct GNUNET_TIME_Relative delay;
1627 
1629  "%p: Fragmented message removed with result %s\n",
1630  frag_ctx,
1631  (result == GNUNET_SYSERR) ? "FAIL" : "SUCCESS");
1632  /* Call continuation for fragmented message */
1633  if (frag_ctx->on_wire_size >= frag_ctx->payload_size)
1634  overhead = frag_ctx->on_wire_size - frag_ctx->payload_size;
1635  else
1636  overhead = frag_ctx->on_wire_size;
1639  {
1641  "Fragmented message acknowledged after %s (expected at %s)\n",
1644  }
1645  else
1646  {
1648  "Fragmented message acknowledged after %s (expected at %s)\n",
1651  }
1652 
1653  if (NULL != frag_ctx->cont)
1654  frag_ctx->cont(frag_ctx->cont_cls,
1655  &s->target,
1656  result,
1657  s->frag_ctx->payload_size,
1658  frag_ctx->on_wire_size);
1659  GNUNET_STATISTICS_update(plugin->env->stats,
1660  "# UDP, fragmented messages active",
1661  -1,
1662  GNUNET_NO);
1663 
1664  if (GNUNET_OK == result)
1665  {
1666  GNUNET_STATISTICS_update(plugin->env->stats,
1667  "# UDP, fragmented msgs, messages, sent, success",
1668  1,
1669  GNUNET_NO);
1670  GNUNET_STATISTICS_update(plugin->env->stats,
1671  "# UDP, fragmented msgs, bytes payload, sent, success",
1672  s->frag_ctx->payload_size,
1673  GNUNET_NO);
1675  plugin->env->stats,
1676  "# UDP, fragmented msgs, bytes overhead, sent, success",
1677  overhead,
1678  GNUNET_NO);
1679  GNUNET_STATISTICS_update(plugin->env->stats,
1680  "# UDP, total, bytes overhead, sent",
1681  overhead,
1682  GNUNET_NO);
1683  GNUNET_STATISTICS_update(plugin->env->stats,
1684  "# UDP, total, bytes payload, sent",
1685  s->frag_ctx->payload_size,
1686  GNUNET_NO);
1687  }
1688  else
1689  {
1690  GNUNET_STATISTICS_update(plugin->env->stats,
1691  "# UDP, fragmented msgs, messages, sent, failure",
1692  1,
1693  GNUNET_NO);
1694  GNUNET_STATISTICS_update(plugin->env->stats,
1695  "# UDP, fragmented msgs, bytes payload, sent, failure",
1696  s->frag_ctx->payload_size,
1697  GNUNET_NO);
1698  GNUNET_STATISTICS_update(plugin->env->stats,
1699  "# UDP, fragmented msgs, bytes payload, sent, failure",
1700  overhead,
1701  GNUNET_NO);
1702  GNUNET_STATISTICS_update(plugin->env->stats,
1703  "# UDP, fragmented msgs, bytes payload, sent, failure",
1704  overhead,
1705  GNUNET_NO);
1706  }
1707 
1708  /* Remove remaining fragments from queue, no need to transmit those
1709  any longer. */
1710  if (s->address->address_length == sizeof(struct IPv6UdpAddress))
1711  {
1712  udpw = plugin->ipv6_queue_head;
1713  while (NULL != udpw)
1714  {
1715  tmp = udpw->next;
1716  if ((udpw->frag_ctx != NULL) && (udpw->frag_ctx == frag_ctx))
1717  {
1718  dequeue(plugin, udpw);
1719  GNUNET_free(udpw);
1720  }
1721  udpw = tmp;
1722  }
1723  }
1724  if (s->address->address_length == sizeof(struct IPv4UdpAddress))
1725  {
1726  udpw = plugin->ipv4_queue_head;
1727  while (NULL != udpw)
1728  {
1729  tmp = udpw->next;
1730  if ((NULL != udpw->frag_ctx) && (udpw->frag_ctx == frag_ctx))
1731  {
1732  dequeue(plugin, udpw);
1733  GNUNET_free(udpw);
1734  }
1735  udpw = tmp;
1736  }
1737  }
1742  s->frag_ctx = NULL;
1743  GNUNET_free(frag_ctx);
1744 }
size_t address_length
Number of bytes in address.
size_t payload_size
Payload size of original unfragmented message.
struct UDP_MessageWrapper * ipv6_queue_head
Head of messages in IPv6 queue.
uint64_t rel_value_us
The actual value.
struct Plugin * plugin
Pointer to the global plugin struct.
struct Plugin * plugin
The plugin.
#define GNUNET_CONSTANTS_LATENCY_WARN
After what amount of latency for a message do we print a warning?
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
struct GNUNET_HELLO_Address * address
Address.
struct GNUNET_TIME_Relative last_expected_ack_delay
expected delay for ACKs
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
struct UDP_FragmentationContext * frag_ctx
Fragmentation context.
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
struct UDP_MessageWrapper * next
DLL of messages, next element.
size_t on_wire_size
Bytes used to send all fragments on wire including UDP overhead.
Network format for IPv4 addresses.
Information about ongoing sessions of the transport client.
struct GNUNET_DATACACHE_PluginEnvironment * env
Our execution environment.
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:686
static int result
Global testing status.
static GNUNET_NETWORK_STRUCT_END 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.
void * cont_cls
Closure for cont.
struct GNUNET_ATS_Session * session
The session this fragmentation context belongs to.
Information we track for each message in the queue.
Network format for IPv6 addresses.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
static struct GNUNET_TIME_Relative delay
When should dkg communication start?
static void dequeue(struct Plugin *plugin, struct UDP_MessageWrapper *udpw)
Remove the given message from the transmission queue and update all applicable statistics.
struct GNUNET_TIME_Absolute start_time
Start time.
This is just an update about the session, the state did not change.
Handle for a plugin.
Definition: block.c:37
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_duration(struct GNUNET_TIME_Absolute whence)
Get the duration of an operation as the difference of the current time and the given start time "henc...
Definition: time.c:373
struct GNUNET_PeerIdentity target
To whom are we talking to.
#define GNUNET_YES
Definition: gnunet_common.h:77
struct GNUNET_TIME_Relative last_expected_msg_delay
desired delay between UDP messages
const char * GNUNET_STRINGS_absolute_time_to_string(struct GNUNET_TIME_Absolute t)
Like asctime, except for GNUnet time.
Definition: strings.c:741
struct UDP_MessageWrapper * ipv4_queue_head
Head of messages in IPv4 queue.
GNUNET_TRANSPORT_TransmitContinuation cont
Function to call upon completion of the transmission.
struct UDP_FragmentationContext * frag_ctx
Context for dealing with fragments.
void GNUNET_FRAGMENT_context_destroy(struct GNUNET_FRAGMENT_Context *fc, struct GNUNET_TIME_Relative *msg_delay, struct GNUNET_TIME_Relative *ack_delay)
Destroy the given fragmentation context (stop calling &#39;proc&#39;, free resources).
#define LOG(kind,...)
struct GNUNET_FRAGMENT_Context * frag
Handle for fragmentation.
#define GNUNET_free(ptr)
Wrapper around free.
Time for relative time used by GNUnet, in microseconds.
struct GNUNET_TIME_Absolute next_frag_time
Transmission time for the next fragment.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ qc_fragment_sent()

static void qc_fragment_sent ( void *  cls,
struct UDP_MessageWrapper udpw,
int  result 
)
static

We are finished with a fragment in the message queue.

Notify the continuation and update statistics.

Parameters
clsthe struct Plugin *
udpwthe queue entry
resultGNUNET_OK on success, GNUNET_SYSERR on failure

Definition at line 1756 of file plugin_transport_udp.c.

References Plugin::env, UDP_FragmentationContext::frag, UDP_MessageWrapper::frag_ctx, fragmented_message_done(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_FRAGMENT_context_transmission_done(), GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_update(), GNUNET_SYSERR, UDP_MessageWrapper::msg_size, UDP_MessageWrapper::payload_size, plugin, UDP_MessageWrapper::session, and GNUNET_ATS_Session::target.

Referenced by enqueue_fragment().

1757 {
1758  struct Plugin *plugin = cls;
1759 
1760  GNUNET_assert(NULL != udpw->frag_ctx);
1761  if (GNUNET_OK == result)
1762  {
1764  "Fragment of message with %u bytes transmitted to %s\n",
1765  (unsigned int)udpw->payload_size,
1766  GNUNET_i2s(&udpw->session->target));
1768  GNUNET_STATISTICS_update(plugin->env->stats,
1769  "# UDP, fragmented msgs, fragments, sent, success",
1770  1,
1771  GNUNET_NO);
1773  plugin->env->stats,
1774  "# UDP, fragmented msgs, fragments bytes, sent, success",
1775  udpw->msg_size,
1776  GNUNET_NO);
1777  }
1778  else
1779  {
1781  "Failed to transmit fragment of message with %u bytes to %s\n",
1782  (unsigned int)udpw->payload_size,
1783  GNUNET_i2s(&udpw->session->target));
1785  GNUNET_STATISTICS_update(plugin->env->stats,
1786  "# UDP, fragmented msgs, fragments, sent, failure",
1787  1,
1788  GNUNET_NO);
1790  plugin->env->stats,
1791  "# UDP, fragmented msgs, fragments bytes, sent, failure",
1792  udpw->msg_size,
1793  GNUNET_NO);
1794  }
1795 }
size_t payload_size
Payload size of original message.
struct GNUNET_ATS_Session * session
Session this message belongs to.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static void fragmented_message_done(struct UDP_FragmentationContext *frag_ctx, int result)
We have completed our (attempt) to transmit a message that had to be fragmented – either because we ...
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
struct UDP_FragmentationContext * frag_ctx
Fragmentation context.
void GNUNET_FRAGMENT_context_transmission_done(struct GNUNET_FRAGMENT_Context *fc)
Continuation to call from the &#39;proc&#39; function after the fragment has been transmitted (and hence the ...
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
struct GNUNET_DATACACHE_PluginEnvironment * env
Our execution environment.
static int result
Global testing status.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
Handle for a plugin.
Definition: block.c:37
struct GNUNET_PeerIdentity target
To whom are we talking to.
#define GNUNET_log(kind,...)
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
struct GNUNET_FRAGMENT_Context * frag
Handle for fragmentation.
size_t msg_size
Size of UDP message to send, including UDP-specific overhead.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ enqueue_fragment()

static void enqueue_fragment ( void *  cls,
const struct GNUNET_MessageHeader msg 
)
static

Function that is called with messages created by the fragmentation module.

In the case of the proc callback of the GNUNET_FRAGMENT_context_create() function, this function must eventually call GNUNET_FRAGMENT_context_transmission_done().

Parameters
clsclosure, the struct UDP_FragmentationContext
msgthe message that was created

Definition at line 1808 of file plugin_transport_udp.c.

References GNUNET_ATS_Session::address, GNUNET_HELLO_Address::address_length, enqueue(), UDP_FragmentationContext::flow_delay_from_other_peer, GNUNET_ATS_Session::frag_ctx, UDP_MessageWrapper::frag_ctx, GNUNET_ERROR_TYPE_DEBUG, GNUNET_malloc, GNUNET_memcpy, GNUNET_TIME_absolute_add(), LOG, UDP_MessageWrapper::msg_buf, UDP_MessageWrapper::msg_size, UDP_FragmentationContext::next_frag_time, UDP_MessageWrapper::payload_size, plugin, UDP_FragmentationContext::plugin, UDP_MessageWrapper::qc, UDP_MessageWrapper::qc_cls, qc_fragment_sent(), schedule_select_v4(), schedule_select_v6(), UDP_FragmentationContext::session, UDP_MessageWrapper::session, GNUNET_MessageHeader::size, UDP_FragmentationContext::start_time, UDP_MessageWrapper::start_time, UDP_FragmentationContext::timeout, UDP_MessageWrapper::timeout, and UDP_MessageWrapper::transmission_time.

Referenced by udp_plugin_send().

1809 {
1810  struct UDP_FragmentationContext *frag_ctx = cls;
1811  struct Plugin *plugin = frag_ctx->plugin;
1812  struct UDP_MessageWrapper *udpw;
1813  struct GNUNET_ATS_Session *session = frag_ctx->session;
1814  size_t msg_len = ntohs(msg->size);
1815 
1816  LOG(GNUNET_ERROR_TYPE_DEBUG, "Enqueuing fragment with %u bytes\n", msg_len);
1817  udpw = GNUNET_malloc(sizeof(struct UDP_MessageWrapper) + msg_len);
1818  udpw->session = session;
1819  udpw->msg_buf = (char *)&udpw[1];
1820  udpw->msg_size = msg_len;
1821  udpw->payload_size = msg_len; /* FIXME: minus fragment overhead */
1822  udpw->timeout = frag_ctx->timeout;
1823  udpw->start_time = frag_ctx->start_time;
1824  udpw->transmission_time = frag_ctx->next_frag_time;
1825  frag_ctx->next_frag_time =
1827  frag_ctx->flow_delay_from_other_peer);
1828  udpw->frag_ctx = frag_ctx;
1829  udpw->qc = &qc_fragment_sent;
1830  udpw->qc_cls = plugin;
1831  GNUNET_memcpy(udpw->msg_buf, msg, msg_len);
1832  enqueue(plugin, udpw);
1833  if (session->address->address_length == sizeof(struct IPv4UdpAddress))
1834  schedule_select_v4(plugin);
1835  else
1836  schedule_select_v6(plugin);
1837 }
size_t address_length
Number of bytes in address.
size_t payload_size
Payload size of original message.
struct GNUNET_ATS_Session * session
Session this message belongs to.
static void enqueue(struct Plugin *plugin, struct UDP_MessageWrapper *udpw)
Enqueue a message for transmission and update statistics.
struct GNUNET_TIME_Absolute timeout
Message timeout.
struct Plugin * plugin
The plugin.
struct GNUNET_TIME_Absolute transmission_time
Desired transmission time for this message, based on the flow limiting information we got from the ot...
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
struct GNUNET_TIME_Relative flow_delay_from_other_peer
Desired delay for transmissions we received from other peer.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_add(struct GNUNET_TIME_Absolute start, struct GNUNET_TIME_Relative duration)
Add a given relative duration to the given start time.
Definition: time.c:393
struct GNUNET_HELLO_Address * address
Address.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
struct UDP_FragmentationContext * frag_ctx
Fragmentation context.
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
Context to send fragmented messages.
Network format for IPv4 addresses.
Information about ongoing sessions of the transport client.
struct GNUNET_ATS_Session * session
The session this fragmentation context belongs to.
Information we track for each message in the queue.
static void schedule_select_v6(struct Plugin *plugin)
(re)schedule IPv6-select tasks for this plugin.
static void schedule_select_v4(struct Plugin *plugin)
(re)schedule IPv4-select tasks for this plugin.
struct GNUNET_TIME_Absolute start_time
Message enqueue time.
struct GNUNET_TIME_Absolute start_time
Start time.
char * msg_buf
Message with msg_size bytes including UDP-specific overhead.
Handle for a plugin.
Definition: block.c:37
void * qc_cls
Closure for qc.
QueueContinuation qc
Function to call once the message wrapper is being removed from the queue (with success or failure)...
static void qc_fragment_sent(void *cls, struct UDP_MessageWrapper *udpw, int result)
We are finished with a fragment in the message queue.
struct UDP_FragmentationContext * frag_ctx
Context for dealing with fragments.
#define LOG(kind,...)
size_t msg_size
Size of UDP message to send, including UDP-specific overhead.
#define GNUNET_malloc(size)
Wrapper around malloc.
struct GNUNET_TIME_Absolute timeout
Message timeout.
struct GNUNET_TIME_Absolute next_frag_time
Transmission time for the next fragment.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ qc_message_sent()

static void qc_message_sent ( void *  cls,
struct UDP_MessageWrapper udpw,
int  result 
)
static

We are finished with a message from the message queue.

Notify the continuation and update statistics.

Parameters
clsthe struct Plugin *
udpwthe queue entry
resultGNUNET_OK on success, GNUNET_SYSERR on failure

Definition at line 1849 of file plugin_transport_udp.c.

References UDP_MessageWrapper::cont, UDP_MessageWrapper::cont_cls, Plugin::env, GNUNET_CONSTANTS_LATENCY_WARN, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_update(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get_duration(), GNUNET_YES, LOG, UDP_MessageWrapper::msg_size, UDP_MessageWrapper::payload_size, plugin, GNUNET_TIME_Relative::rel_value_us, UDP_MessageWrapper::session, UDP_MessageWrapper::start_time, and GNUNET_ATS_Session::target.

Referenced by udp_plugin_send().

1850 {
1851  struct Plugin *plugin = cls;
1852  size_t overhead;
1853  struct GNUNET_TIME_Relative delay;
1854 
1855  if (udpw->msg_size >= udpw->payload_size)
1856  overhead = udpw->msg_size - udpw->payload_size;
1857  else
1858  overhead = udpw->msg_size;
1859 
1860  if (NULL != udpw->cont)
1861  {
1864  {
1866  "Message sent via UDP with delay of %s\n",
1868  }
1869  else
1870  {
1872  "Message sent via UDP with delay of %s\n",
1874  }
1875  udpw->cont(udpw->cont_cls,
1876  &udpw->session->target,
1877  result,
1878  udpw->payload_size,
1879  overhead);
1880  }
1881  if (GNUNET_OK == result)
1882  {
1883  GNUNET_STATISTICS_update(plugin->env->stats,
1884  "# UDP, unfragmented msgs, messages, sent, success",
1885  1,
1886  GNUNET_NO);
1888  plugin->env->stats,
1889  "# UDP, unfragmented msgs, bytes payload, sent, success",
1890  udpw->payload_size,
1891  GNUNET_NO);
1893  plugin->env->stats,
1894  "# UDP, unfragmented msgs, bytes overhead, sent, success",
1895  overhead,
1896  GNUNET_NO);
1897  GNUNET_STATISTICS_update(plugin->env->stats,
1898  "# UDP, total, bytes overhead, sent",
1899  overhead,
1900  GNUNET_NO);
1901  GNUNET_STATISTICS_update(plugin->env->stats,
1902  "# UDP, total, bytes payload, sent",
1903  udpw->payload_size,
1904  GNUNET_NO);
1905  }
1906  else
1907  {
1908  GNUNET_STATISTICS_update(plugin->env->stats,
1909  "# UDP, unfragmented msgs, messages, sent, failure",
1910  1,
1911  GNUNET_NO);
1913  plugin->env->stats,
1914  "# UDP, unfragmented msgs, bytes payload, sent, failure",
1915  udpw->payload_size,
1916  GNUNET_NO);
1918  plugin->env->stats,
1919  "# UDP, unfragmented msgs, bytes overhead, sent, failure",
1920  overhead,
1921  GNUNET_NO);
1922  }
1923 }
size_t payload_size
Payload size of original message.
uint64_t rel_value_us
The actual value.
struct GNUNET_ATS_Session * session
Session this message belongs to.
#define GNUNET_CONSTANTS_LATENCY_WARN
After what amount of latency for a message do we print a warning?
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
struct GNUNET_DATACACHE_PluginEnvironment * env
Our execution environment.
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:686
static int result
Global testing status.
GNUNET_TRANSPORT_TransmitContinuation cont
External continuation to call upon completion of the transmission, NULL if this queue entry is not fo...
static struct GNUNET_TIME_Relative delay
When should dkg communication start?
struct GNUNET_TIME_Absolute start_time
Message enqueue time.
Handle for a plugin.
Definition: block.c:37
void * cont_cls
Closure for cont.
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_duration(struct GNUNET_TIME_Absolute whence)
Get the duration of an operation as the difference of the current time and the given start time "henc...
Definition: time.c:373
struct GNUNET_PeerIdentity target
To whom are we talking to.
#define GNUNET_YES
Definition: gnunet_common.h:77
#define LOG(kind,...)
size_t msg_size
Size of UDP message to send, including UDP-specific overhead.
Time for relative time used by GNUnet, in microseconds.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ udp_plugin_send()

static ssize_t udp_plugin_send ( void *  cls,
struct GNUNET_ATS_Session s,
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
clsclosure
swhich session must be used
msgbufthe message to transmit
msgbuf_sizenumber of bytes in msgbuf
priorityhow important is the message (most plugins will ignore message priority and just FIFO)
tohow 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)
contcontinuation 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_clsclosure 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 1954 of file plugin_transport_udp.c.

References GNUNET_HELLO_Address::address, GNUNET_ATS_Session::address, GNUNET_HELLO_Address::address_length, UDP_FragmentationContext::cont, UDP_MessageWrapper::cont, UDP_FragmentationContext::cont_cls, UDP_MessageWrapper::cont_cls, enqueue(), enqueue_fragment(), Plugin::env, GNUNET_ATS_Session::flow_delay_from_other_peer, UDP_FragmentationContext::flow_delay_from_other_peer, UDP_FragmentationContext::frag, GNUNET_ATS_Session::frag_ctx, UDP_MessageWrapper::frag_ctx, GNUNET_ALIGN, GNUNET_break, GNUNET_CONSTANTS_LATENCY_WARN, GNUNET_CONTAINER_multipeermap_contains_value(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_FRAGMENT_context_create(), GNUNET_i2s(), GNUNET_malloc, GNUNET_MAX_MESSAGE_SIZE, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_MESSAGE, GNUNET_new, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_SYSERR, GNUNET_TIME_absolute_add(), GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_relative_divide(), GNUNET_TIME_relative_to_absolute(), GNUNET_TRANSPORT_SS_UPDATE, GNUNET_YES, UDPMessage::header, GNUNET_ATS_Session::last_expected_ack_delay, GNUNET_ATS_Session::last_expected_msg_delay, GNUNET_ATS_Session::last_transmit_time, LOG, UDP_MessageWrapper::msg_buf, UDP_MessageWrapper::msg_size, GNUNET_ATS_Session::msgs_in_queue, UDP_FragmentationContext::next_frag_time, notify_session_monitor(), UDP_FragmentationContext::on_wire_size, UDP_FragmentationContext::payload_size, UDP_MessageWrapper::payload_size, plugin, UDP_FragmentationContext::plugin, GNUNET_ATS_Session::plugin, UDP_MessageWrapper::qc, UDP_MessageWrapper::qc_cls, qc_message_sent(), GNUNET_TIME_Relative::rel_value_us, UDPMessage::reserved, schedule_select_v4(), schedule_select_v6(), UDPMessage::sender, UDP_FragmentationContext::session, UDP_MessageWrapper::session, Plugin::sessions, GNUNET_MessageHeader::size, Plugin::sockv4, Plugin::sockv6, UDP_FragmentationContext::start_time, UDP_MessageWrapper::start_time, GNUNET_ATS_Session::target, UDP_FragmentationContext::timeout, UDP_MessageWrapper::timeout, Plugin::tracker, UDP_MessageWrapper::transmission_time, GNUNET_MessageHeader::type, udp, udp_address_to_string(), and UDP_MTU.

Referenced by libgnunet_plugin_transport_udp_init().

1962 {
1963  struct Plugin *plugin = cls;
1964  size_t udpmlen = msgbuf_size + sizeof(struct UDPMessage);
1965  struct UDP_FragmentationContext *frag_ctx;
1966  struct UDP_MessageWrapper *udpw;
1967  struct UDPMessage *udp;
1968  char mbuf[udpmlen] GNUNET_ALIGN;
1969  struct GNUNET_TIME_Relative latency;
1970 
1971  if ((sizeof(struct IPv6UdpAddress) == s->address->address_length) &&
1972  (NULL == plugin->sockv6))
1973  return GNUNET_SYSERR;
1974  if ((sizeof(struct IPv4UdpAddress) == s->address->address_length) &&
1975  (NULL == plugin->sockv4))
1976  return GNUNET_SYSERR;
1977  if (udpmlen >= GNUNET_MAX_MESSAGE_SIZE)
1978  {
1979  GNUNET_break(0);
1980  return GNUNET_SYSERR;
1981  }
1982  if (GNUNET_YES !=
1984  &s->target,
1985  s))
1986  {
1987  GNUNET_break(0);
1988  return GNUNET_SYSERR;
1989  }
1991  "UDP transmits %u-byte message to `%s' using address `%s'\n",
1992  udpmlen,
1993  GNUNET_i2s(&s->target),
1994  udp_address_to_string(plugin,
1995  s->address->address,
1996  s->address->address_length));
1997 
1998  udp = (struct UDPMessage *)mbuf;
1999  udp->header.size = htons(udpmlen);
2001  udp->reserved = htonl(0);
2002  udp->sender = *plugin->env->my_identity;
2003 
2004  /* We do not update the session time out here! Otherwise this
2005  * session will not timeout since we send keep alive before session
2006  * can timeout.
2007  *
2008  * For UDP we update session timeout only on receive, this will
2009  * cover keep alives, since remote peer will reply with keep alive
2010  * responses!
2011  */
2012  if (udpmlen <= UDP_MTU)
2013  {
2014  /* unfragmented message */
2015  udpw = GNUNET_malloc(sizeof(struct UDP_MessageWrapper) + udpmlen);
2016  udpw->session = s;
2017  udpw->msg_buf = (char *)&udpw[1];
2018  udpw->msg_size = udpmlen; /* message size with UDP overhead */
2019  udpw->payload_size = msgbuf_size; /* message size without UDP overhead */
2023  s->last_transmit_time =
2026  udpw->cont = cont;
2027  udpw->cont_cls = cont_cls;
2028  udpw->frag_ctx = NULL;
2029  udpw->qc = &qc_message_sent;
2030  udpw->qc_cls = plugin;
2031  GNUNET_memcpy(udpw->msg_buf, udp, sizeof(struct UDPMessage));
2032  GNUNET_memcpy(&udpw->msg_buf[sizeof(struct UDPMessage)],
2033  msgbuf,
2034  msgbuf_size);
2035  enqueue(plugin, udpw);
2036  GNUNET_STATISTICS_update(plugin->env->stats,
2037  "# UDP, unfragmented messages queued total",
2038  1,
2039  GNUNET_NO);
2040  GNUNET_STATISTICS_update(plugin->env->stats,
2041  "# UDP, unfragmented bytes payload queued total",
2042  msgbuf_size,
2043  GNUNET_NO);
2044  if (s->address->address_length == sizeof(struct IPv4UdpAddress))
2045  schedule_select_v4(plugin);
2046  else
2047  schedule_select_v6(plugin);
2048  }
2049  else
2050  {
2051  /* fragmented message */
2052  if (NULL != s->frag_ctx)
2053  return GNUNET_SYSERR;
2054  GNUNET_memcpy(&udp[1], msgbuf, msgbuf_size);
2055  frag_ctx = GNUNET_new(struct UDP_FragmentationContext);
2056  frag_ctx->plugin = plugin;
2057  frag_ctx->session = s;
2058  frag_ctx->cont = cont;
2059  frag_ctx->cont_cls = cont_cls;
2060  frag_ctx->start_time = GNUNET_TIME_absolute_get();
2061  frag_ctx->next_frag_time = s->last_transmit_time;
2062  frag_ctx->flow_delay_from_other_peer =
2064  1 + (msgbuf_size / UDP_MTU));
2065  frag_ctx->timeout = GNUNET_TIME_relative_to_absolute(to);
2066  frag_ctx->payload_size =
2067  msgbuf_size; /* unfragmented message size without UDP overhead */
2068  frag_ctx->on_wire_size = 0; /* bytes with UDP and fragmentation overhead */
2069  frag_ctx->frag = GNUNET_FRAGMENT_context_create(plugin->env->stats,
2070  UDP_MTU,
2071  &plugin->tracker,
2074  &udp->header,
2076  frag_ctx);
2077  s->frag_ctx = frag_ctx;
2078  s->last_transmit_time = frag_ctx->next_frag_time;
2080  if (latency.rel_value_us > GNUNET_CONSTANTS_LATENCY_WARN.rel_value_us)
2082  "Enqueued fragments will take %s for transmission to %s (queue size: %u)\n",
2084  GNUNET_i2s(&s->target),
2085  (unsigned int)s->msgs_in_queue);
2086  else
2088  "Enqueued fragments will take %s for transmission to %s (queue size: %u)\n",
2090  GNUNET_i2s(&s->target),
2091  (unsigned int)s->msgs_in_queue);
2092 
2093  GNUNET_STATISTICS_update(plugin->env->stats,
2094  "# UDP, fragmented messages active",
2095  1,
2096  GNUNET_NO);
2097  GNUNET_STATISTICS_update(plugin->env->stats,
2098  "# UDP, fragmented messages, total",
2099  1,
2100  GNUNET_NO);
2101  GNUNET_STATISTICS_update(plugin->env->stats,
2102  "# UDP, fragmented bytes (payload)",
2103  frag_ctx->payload_size,
2104  GNUNET_NO);
2105  }
2107  return udpmlen;
2108 }
size_t address_length
Number of bytes in address.
struct GNUNET_TIME_Absolute last_transmit_time
What time did we last transmit?
size_t payload_size
Payload size of original message.
static int udp
Option -u: UDP requested.
Definition: gnunet-vpn.c:76
size_t payload_size
Payload size of original unfragmented message.
const void * address
Binary representation of the address (plugin-specific).
struct GNUNET_ATS_Session * session
Session this message belongs to.
static void enqueue(struct Plugin *plugin, struct UDP_MessageWrapper *udpw)
Enqueue a message for transmission and update statistics.
unsigned int msgs_in_queue
Number of messages waiting for transmission to this peer.
struct Plugin * plugin
Pointer to the global plugin struct.
struct GNUNET_TIME_Absolute timeout
Message timeout.
struct Plugin * plugin
The plugin.
struct GNUNET_TIME_Absolute GNUNET_TIME_relative_to_absolute(struct GNUNET_TIME_Relative rel)
Convert relative time to an absolute time in the future.
Definition: time.c:246
struct GNUNET_MessageHeader header
Message header.
UDP Message-Packet header (after defragmentation).
struct GNUNET_TIME_Absolute transmission_time
Desired transmission time for this message, based on the flow limiting information we got from the ot...
uint32_t reserved
Always zero for now.
static void qc_message_sent(void *cls, struct UDP_MessageWrapper *udpw, int result)
We are finished with a message from the message queue.
struct GNUNET_FRAGMENT_Context * GNUNET_FRAGMENT_context_create(struct GNUNET_STATISTICS_Handle *stats, uint16_t mtu, struct GNUNET_BANDWIDTH_Tracker *tracker, struct GNUNET_TIME_Relative msg_delay, struct GNUNET_TIME_Relative ack_delay, const struct GNUNET_MessageHeader *msg, GNUNET_FRAGMENT_MessageProcessor proc, void *proc_cls)
Create a fragmentation context for the given message.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_CONSTANTS_LATENCY_WARN
After what amount of latency for a message do we print a warning?
static void enqueue_fragment(void *cls, const struct GNUNET_MessageHeader *msg)
Function that is called with messages created by the fragmentation module.
#define GNUNET_NO
Definition: gnunet_common.h:78
struct GNUNET_TIME_Relative flow_delay_from_other_peer
Desired delay for transmissions we received from other peer.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_add(struct GNUNET_TIME_Absolute start, struct GNUNET_TIME_Relative duration)
Add a given relative duration to the given start time.
Definition: time.c:393
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_HELLO_Address * address
Address.
struct GNUNET_TIME_Relative last_expected_ack_delay
expected delay for ACKs
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
struct GNUNET_NETWORK_Handle * sockv4
The read socket for IPv4.
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
#define UDP_MTU
MTU for fragmentation subsystem.
struct UDP_FragmentationContext * frag_ctx
Fragmentation context.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
Context to send fragmented messages.
struct GNUNET_TIME_Relative flow_delay_from_other_peer
Desired delay for transmissions we received from other peer.
size_t on_wire_size
Bytes used to send all fragments on wire including UDP overhead.
Network format for IPv4 addresses.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_MESSAGE
Normal UDP message type.
struct GNUNET_DATACACHE_PluginEnvironment * env
Our execution environment.
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:686
static GNUNET_NETWORK_STRUCT_END 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.
GNUNET_TRANSPORT_TransmitContinuation cont
External continuation to call upon completion of the transmission, NULL if this queue entry is not fo...
void * cont_cls
Closure for cont.
struct GNUNET_ATS_Session * session
The session this fragmentation context belongs to.
Information we track for each message in the queue.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
static void schedule_select_v6(struct Plugin *plugin)
(re)schedule IPv6-select tasks for this plugin.
Network format for IPv6 addresses.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
#define GNUNET_MAX_MESSAGE_SIZE
Largest supported message (to be precise, one byte more than the largest possible message...
static void schedule_select_v4(struct Plugin *plugin)
(re)schedule IPv4-select tasks for this plugin.
struct GNUNET_TIME_Absolute start_time
Message enqueue time.
struct GNUNET_TIME_Absolute start_time
Start time.
This is just an update about the session, the state did not change.
char * msg_buf
Message with msg_size bytes including UDP-specific overhead.
int GNUNET_CONTAINER_multipeermap_contains_value(const struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, const void *value)
Check if the map contains the given value under the given key.
#define GNUNET_ALIGN
gcc-ism to force alignment; we use this to align char-arrays that may then be cast to &#39;struct&#39;s...
Handle for a plugin.
Definition: block.c:37
void * cont_cls
Closure for cont.
void * qc_cls
Closure for qc.
struct GNUNET_PeerIdentity target
To whom are we talking to.
const char * udp_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.
struct GNUNET_ATS_Session * sessions
List of open sessions (or peer map, or...)
struct GNUNET_NETWORK_Handle * sockv6
The read socket for IPv6.
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_remaining(struct GNUNET_TIME_Absolute future)
Given a timestamp in the future, how much time remains until then?
Definition: time.c:331
struct GNUNET_TIME_Relative GNUNET_TIME_relative_divide(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Divide relative time by a given factor.
Definition: time.c:525
#define GNUNET_YES
Definition: gnunet_common.h:77
struct GNUNET_TIME_Relative last_expected_msg_delay
desired delay between UDP messages
QueueContinuation qc
Function to call once the message wrapper is being removed from the queue (with success or failure)...
struct GNUNET_BANDWIDTH_Tracker tracker
Bandwidth tracker to limit global UDP traffic.
GNUNET_TRANSPORT_TransmitContinuation cont
Function to call upon completion of the transmission.
struct UDP_FragmentationContext * frag_ctx
Context for dealing with fragments.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define LOG(kind,...)
struct GNUNET_FRAGMENT_Context * frag
Handle for fragmentation.
size_t msg_size
Size of UDP message to send, including UDP-specific overhead.
#define GNUNET_malloc(size)
Wrapper around malloc.
Time for relative time used by GNUnet, in microseconds.
struct GNUNET_TIME_Absolute timeout
Message timeout.
struct GNUNET_TIME_Absolute next_frag_time
Transmission time for the next fragment.
struct GNUNET_PeerIdentity sender
What is the identity of the sender.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ find_receive_context()

static int find_receive_context ( void *  cls,
struct GNUNET_CONTAINER_HeapNode node,
void *  element,
GNUNET_CONTAINER_HeapCostType  cost 
)
static

Scan the heap for a receive context with the given address.

Parameters
clsthe struct FindReceiveContext
nodeinternal node of the heap
elementvalue stored at the node (a struct ReceiveContext)
costcost associated with the node
Returns
GNUNET_YES if we should continue to iterate, GNUNET_NO if not.

Definition at line 2151 of file plugin_transport_udp.c.

References e, GNUNET_NO, GNUNET_YES, FindReceiveContext::rc, DefragContext::udp_addr, FindReceiveContext::udp_addr, DefragContext::udp_addr_len, and FindReceiveContext::udp_addr_len.

Referenced by read_process_fragment(), and udp_disconnect_session().

2155 {
2156  struct FindReceiveContext *frc = cls;
2157  struct DefragContext *e = element;
2158 
2159  if ((frc->udp_addr_len == e->udp_addr_len) &&
2160  (0 == memcmp(frc->udp_addr, e->udp_addr, frc->udp_addr_len)))
2161  {
2162  frc->rc = e;
2163  return GNUNET_NO;
2164  }
2165  return GNUNET_YES;
2166 }
const union UdpAddress * udp_addr
Address to find.
static struct Experiment * e
#define GNUNET_NO
Definition: gnunet_common.h:78
const union UdpAddress * udp_addr
Source address this receive context is for (allocated at the end of the struct).
size_t udp_addr_len
Length of udp_addr.
Closure for find_receive_context().
struct DefragContext * rc
Where to store the result.
Data structure to track defragmentation contexts based on the source of the UDP traffic.
size_t udp_addr_len
Number of bytes in udp_addr.
#define GNUNET_YES
Definition: gnunet_common.h:77
Here is the caller graph for this function:

◆ udp_disconnect_session()

static int udp_disconnect_session ( void *  cls,
struct GNUNET_ATS_Session s 
)
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
clsclosure with the struct Plugin
ssession to close down
Returns
GNUNET_OK on success

Definition at line 2178 of file plugin_transport_udp.c.

References GNUNET_HELLO_Address::address, GNUNET_ATS_Session::address, GNUNET_HELLO_Address::address_length, GNUNET_DATACACHE_PluginEnvironment::cls, UDP_FragmentationContext::cont, UDP_FragmentationContext::cont_cls, DefragContext::defrag, Plugin::defrag_ctxs, dequeue(), Plugin::env, find_receive_context(), GNUNET_ATS_Session::frag_ctx, fragmented_message_done(), free_session(), GNUNET_assert, GNUNET_CONTAINER_heap_iterate(), GNUNET_CONTAINER_heap_remove_node(), GNUNET_CONTAINER_multipeermap_remove(), GNUNET_CONTAINER_multipeermap_size(), GNUNET_DEFRAGMENT_context_destroy(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_set(), GNUNET_SYSERR, GNUNET_TRANSPORT_SS_DONE, GNUNET_YES, DefragContext::hnode, GNUNET_ATS_Session::in_destroy, Plugin::ipv4_queue_head, Plugin::ipv6_queue_head, LOG, UDP_MessageWrapper::next, notify_session_monitor(), UDP_FragmentationContext::on_wire_size, UDP_FragmentationContext::payload_size, plugin, GNUNET_ATS_Session::plugin, UDP_MessageWrapper::qc, UDP_MessageWrapper::qc_cls, GNUNET_ATS_Session::rc, FindReceiveContext::rc, UDP_MessageWrapper::session, Plugin::sessions, GNUNET_ATS_Session::target, GNUNET_ATS_Session::timeout_task, FindReceiveContext::udp_addr, FindReceiveContext::udp_addr_len, and udp_address_to_string().

Referenced by disconnect_and_free_it(), libgnunet_plugin_transport_udp_init(), read_process_ack(), and session_timeout().

2179 {
2180  struct Plugin *plugin = cls;
2181  struct UDP_MessageWrapper *udpw;
2182  struct UDP_MessageWrapper *next;
2183  struct FindReceiveContext frc;
2184 
2187  "Session %p to peer `%s' at address %s ended\n",
2188  s,
2189  GNUNET_i2s(&s->target),
2190  udp_address_to_string(plugin,
2191  s->address->address,
2192  s->address->address_length));
2193  if (NULL != s->timeout_task)
2194  {
2196  s->timeout_task = NULL;
2197  }
2198  if (NULL != s->frag_ctx)
2199  {
2200  /* Remove fragmented message due to disconnect */
2202  }
2203  GNUNET_assert(
2204  GNUNET_YES ==
2206  frc.rc = NULL;
2207  frc.udp_addr = s->address->address;
2208  frc.udp_addr_len = s->address->address_length;
2209  /* Lookup existing receive context for this address */
2210  if (NULL != plugin->defrag_ctxs)
2211  {
2214  &frc);
2215  if (NULL != frc.rc)
2216  {
2217  struct DefragContext *d_ctx = frc.rc;
2218 
2221  GNUNET_free(d_ctx);
2222  }
2223  }
2224  s->in_destroy = GNUNET_YES;
2225  next = plugin->ipv4_queue_head;
2226  while (NULL != (udpw = next))
2227  {
2228  next = udpw->next;
2229  if (udpw->session == s)
2230  {
2231  dequeue(plugin, udpw);
2232  udpw->qc(udpw->qc_cls, udpw, GNUNET_SYSERR);
2233  GNUNET_free(udpw);
2234  }
2235  }
2236  next = plugin->ipv6_queue_head;
2237  while (NULL != (udpw = next))
2238  {
2239  next = udpw->next;
2240  if (udpw->session == s)
2241  {
2242  dequeue(plugin, udpw);
2243  udpw->qc(udpw->qc_cls, udpw, GNUNET_SYSERR);
2244  GNUNET_free(udpw);
2245  }
2246  }
2247  if ((NULL != s->frag_ctx) && (NULL != s->frag_ctx->cont))
2248  {
2249  /* The 'frag_ctx' itself will be freed in #free_session() a bit
2250  later, as it might be in use right now */
2252  "Calling continuation for fragemented message to `%s' with result SYSERR\n",
2253  GNUNET_i2s(&s->target));
2254  s->frag_ctx->cont(s->frag_ctx->cont_cls,
2255  &s->target,
2256  GNUNET_SYSERR,
2257  s->frag_ctx->payload_size,
2258  s->frag_ctx->on_wire_size);
2259  }
2261  plugin->env->session_end(plugin->env->cls, s->address, s);
2262  GNUNET_STATISTICS_set(plugin->env->stats,
2263  "# UDP sessions active",
2265  GNUNET_NO);
2266  if (0 == s->rc)
2267  free_session(s);
2268  return GNUNET_OK;
2269 }
size_t address_length
Number of bytes in address.
Session is being torn down and about to disappear.
size_t payload_size
Payload size of original unfragmented message.
struct UDP_MessageWrapper * ipv6_queue_head
Head of messages in IPv6 queue.
unsigned int rc
Reference counter to indicate that this session is currently being used and must not be destroyed; se...
const void * address
Binary representation of the address (plugin-specific).
struct GNUNET_ATS_Session * session
Session this message belongs to.
struct GNUNET_SCHEDULER_Task * timeout_task
Session timeout task.
static void free_session(struct GNUNET_ATS_Session *s)
Function to free last resources associated with a session.
struct Plugin * plugin
Pointer to the global plugin struct.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static void fragmented_message_done(struct UDP_FragmentationContext *frag_ctx, int result)
We have completed our (attempt) to transmit a message that had to be fragmented – either because we ...
int GNUNET_CONTAINER_multipeermap_remove(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, const void *value)
Remove the given key-value pair from the map.
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
struct GNUNET_HELLO_Address * address
Address.
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
struct UDP_MessageWrapper * next
DLL of messages, next element.
void GNUNET_DEFRAGMENT_context_destroy(struct GNUNET_DEFRAGMENT_Context *dc)
Destroy the given defragmentation context.
size_t on_wire_size
Bytes used to send all fragments on wire including UDP overhead.
struct GNUNET_DATACACHE_PluginEnvironment * env
Our execution environment.
struct GNUNET_DEFRAGMENT_Context * defrag
Defragmentation context.
int in_destroy
Is this session about to be destroyed (sometimes we cannot destroy a session immediately as below us ...
static GNUNET_NETWORK_STRUCT_END 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.
void * cont_cls
Closure for cont.
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
Information we track for each message in the queue.
Closure for find_receive_context().
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
Data structure to track defragmentation contexts based on the source of the UDP traffic.
static void dequeue(struct Plugin *plugin, struct UDP_MessageWrapper *udpw)
Remove the given message from the transmission queue and update all applicable statistics.
struct GNUNET_CONTAINER_HeapNode * hnode
Node in the defrag heap.
static int find_receive_context(void *cls, struct GNUNET_CONTAINER_HeapNode *node, void *element, GNUNET_CONTAINER_HeapCostType cost)
Scan the heap for a receive context with the given address.
Handle for a plugin.
Definition: block.c:37
void * qc_cls
Closure for qc.
struct GNUNET_PeerIdentity target
To whom are we talking to.
const char * udp_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.
struct GNUNET_ATS_Session * sessions
List of open sessions (or peer map, or...)
void * cls
Closure to use for callbacks.
struct GNUNET_CONTAINER_Heap * defrag_ctxs
Heap with all of our defragmentation activities.
#define GNUNET_YES
Definition: gnunet_common.h:77
QueueContinuation qc
Function to call once the message wrapper is being removed from the queue (with success or failure)...
unsigned int GNUNET_CONTAINER_multipeermap_size(const struct GNUNET_CONTAINER_MultiPeerMap *map)
Get the number of key-value pairs in the map.
struct UDP_MessageWrapper * ipv4_queue_head
Head of messages in IPv4 queue.
void GNUNET_CONTAINER_heap_iterate(const struct GNUNET_CONTAINER_Heap *heap, GNUNET_CONTAINER_HeapIterator iterator, void *iterator_cls)
Iterate over all entries in the heap.
GNUNET_TRANSPORT_TransmitContinuation cont
Function to call upon completion of the transmission.
struct UDP_FragmentationContext * frag_ctx
Context for dealing with fragments.
void * GNUNET_CONTAINER_heap_remove_node(struct GNUNET_CONTAINER_HeapNode *node)
Removes a node from the heap.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define LOG(kind,...)
#define GNUNET_free(ptr)
Wrapper around free.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:956
Here is the call graph for this function:
Here is the caller graph for this function:

◆ read_process_ack()

static void read_process_ack ( struct Plugin plugin,
const struct GNUNET_MessageHeader msg,
const union UdpAddress udp_addr,
socklen_t  udp_addr_len 
)
static

Handle a GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_ACK message.

Parameters
pluginthe UDP plugin
msgthe (presumed) UDP ACK message
udp_addrsender address
udp_addr_lennumber of bytes in udp_addr

Definition at line 2281 of file plugin_transport_udp.c.

References GNUNET_HELLO_Address::address, address, GNUNET_HELLO_Address::address_length, UDP_ACK_Message::delay, GNUNET_ATS_Session::flow_delay_from_other_peer, UDP_FragmentationContext::frag, GNUNET_ATS_Session::frag_ctx, fragmented_message_done(), GNUNET_break_op, GNUNET_CONSTANTS_LATENCY_WARN, GNUNET_ERROR_TYPE_BULK, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_FRAGMENT_print_ack(), GNUNET_FRAGMENT_process_ack(), GNUNET_HELLO_address_allocate(), GNUNET_HELLO_address_free, GNUNET_HELLO_ADDRESS_INFO_NONE, GNUNET_i2s(), GNUNET_OK, GNUNET_STRINGS_relative_time_to_string(), GNUNET_YES, LOG, PLUGIN_NAME, GNUNET_TIME_Relative::rel_value_us, UDP_ACK_Message::sender, GNUNET_MessageHeader::size, udp_address_to_string(), udp_disconnect_session(), and udp_plugin_lookup_session().

Referenced by udp_select_read().

2285 {
2286  const struct GNUNET_MessageHeader *ack;
2287  const struct UDP_ACK_Message *udp_ack;
2288  struct GNUNET_HELLO_Address *address;
2289  struct GNUNET_ATS_Session *s;
2290  struct GNUNET_TIME_Relative flow_delay;
2291 
2292  /* check message format */
2293  if (ntohs(msg->size) <
2294  sizeof(struct UDP_ACK_Message) + sizeof(struct GNUNET_MessageHeader))
2295  {
2296  GNUNET_break_op(0);
2297  return;
2298  }
2299  udp_ack = (const struct UDP_ACK_Message *)msg;
2300  ack = (const struct GNUNET_MessageHeader *)&udp_ack[1];
2301  if (ntohs(ack->size) != ntohs(msg->size) - sizeof(struct UDP_ACK_Message))
2302  {
2303  GNUNET_break_op(0);
2304  return;
2305  }
2306 
2307  /* Locate session */
2308  address = GNUNET_HELLO_address_allocate(&udp_ack->sender,
2309  PLUGIN_NAME,
2310  udp_addr,
2311  udp_addr_len,
2313  s = udp_plugin_lookup_session(plugin, address);
2314  if (NULL == s)
2315  {
2317  "UDP session of address %s for ACK not found\n",
2318  udp_address_to_string(plugin,
2319  address->address,
2320  address->address_length));
2321  GNUNET_HELLO_address_free(address);
2322  return;
2323  }
2324  if (NULL == s->frag_ctx)
2325  {
2327  "Fragmentation context of address %s for ACK (%s) not found\n",
2328  udp_address_to_string(plugin,
2329  address->address,
2330  address->address_length),
2332  GNUNET_HELLO_address_free(address);
2333  return;
2334  }
2335  GNUNET_HELLO_address_free(address);
2336 
2337  /* evaluate flow delay: how long should we wait between messages? */
2338  if (UINT32_MAX == ntohl(udp_ack->delay))
2339  {
2340  /* Other peer asked for us to terminate the session */
2342  "Asked to disconnect UDP session of %s\n",
2343  GNUNET_i2s(&udp_ack->sender));
2344  udp_disconnect_session(plugin, s);
2345  return;
2346  }
2347  flow_delay.rel_value_us = (uint64_t)ntohl(udp_ack->delay);
2348  if (flow_delay.rel_value_us > GNUNET_CONSTANTS_LATENCY_WARN.rel_value_us)
2350  "We received a sending delay of %s for %s\n",
2352  GNUNET_i2s(&udp_ack->sender));
2353  else
2355  "We received a sending delay of %s for %s\n",
2357  GNUNET_i2s(&udp_ack->sender));
2358  /* Flow delay is for the reassembled packet, however, our delay
2359  is per packet, so we need to adjust: */
2360  s->flow_delay_from_other_peer = flow_delay;
2361 
2362  /* Handle ACK */
2364  {
2366  "UDP processes %u-byte acknowledgement from `%s' at `%s'\n",
2367  (unsigned int)ntohs(msg->size),
2368  GNUNET_i2s(&udp_ack->sender),
2369  udp_address_to_string(plugin, udp_addr, udp_addr_len));
2370  /* Expect more ACKs to arrive */
2371  return;
2372  }
2373 
2374  /* Remove fragmented message after successful sending */
2376  "Message from %s at %s full ACK'ed\n",
2377  GNUNET_i2s(&udp_ack->sender),
2378  udp_address_to_string(plugin, udp_addr, udp_addr_len));
2380 }
size_t address_length
Number of bytes in address.
struct GNUNET_HELLO_Address * GNUNET_HELLO_address_allocate(const struct GNUNET_PeerIdentity *peer, const char *transport_name, const void *address, size_t address_length, enum GNUNET_HELLO_AddressInfo local_info)
Allocate an address struct.
Definition: address.c:73
const void * address
Binary representation of the address (plugin-specific).
static struct GNUNET_ATS_Session * udp_plugin_lookup_session(void *cls, const struct GNUNET_HELLO_Address *address)
Locate an existing session the transport service is using to send data to another peer...
#define GNUNET_CONSTANTS_LATENCY_WARN
After what amount of latency for a message do we print a warning?
static void fragmented_message_done(struct UDP_FragmentationContext *frag_ctx, int result)
We have completed our (attempt) to transmit a message that had to be fragmented – either because we ...
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
const char * GNUNET_FRAGMENT_print_ack(const struct GNUNET_MessageHeader *ack)
Convert an ACK message to a printable format suitable for logging.
struct GNUNET_TIME_Relative flow_delay_from_other_peer
Desired delay for transmissions we received from other peer.
Information about ongoing sessions of the transport client.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:686
struct GNUNET_PeerIdentity sender
What is the identity of the sender.
static int udp_disconnect_session(void *cls, struct GNUNET_ATS_Session *s)
Functions with this signature are called whenever we need to close a session due to a disconnect or f...
int GNUNET_FRAGMENT_process_ack(struct GNUNET_FRAGMENT_Context *fc, const struct GNUNET_MessageHeader *msg)
Process an acknowledgement message we got from the other side (to control re-transmits).
uint32_t delay
Desired delay for flow control, in us (in NBO).
No additional information.
#define PLUGIN_NAME
An address for communicating with a peer.
const char * udp_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.
Header for all communications.
#define GNUNET_YES
Definition: gnunet_common.h:77
UDP ACK Message-Packet header.
struct UDP_FragmentationContext * frag_ctx
Context for dealing with fragments.
static char * address
GNS address for this phone.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define LOG(kind,...)
struct GNUNET_FRAGMENT_Context * frag
Handle for fragmentation.
#define GNUNET_HELLO_address_free(addr)
Free an address.
Time for relative time used by GNUnet, in microseconds.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ process_inbound_tokenized_messages()

static int process_inbound_tokenized_messages ( void *  cls,
const struct GNUNET_MessageHeader hdr 
)
static

Message tokenizer has broken up an incomming message.

Pass it on to the service.

Parameters
clsthe struct GNUNET_ATS_Session *
hdrthe actual message
Returns
GNUNET_OK (always)

Definition at line 2392 of file plugin_transport_udp.c.

References GNUNET_ATS_Session::address, GNUNET_DATACACHE_PluginEnvironment::cls, Plugin::env, GNUNET_ATS_Session::flow_delay_for_other_peer, GNUNET_OK, GNUNET_YES, GNUNET_ATS_Session::in_destroy, plugin, GNUNET_ATS_Session::plugin, and reschedule_session_timeout().

Referenced by udp_plugin_create_session().

2394 {
2395  struct GNUNET_ATS_Session *session = cls;
2396  struct Plugin *plugin = session->plugin;
2397 
2398  if (GNUNET_YES == session->in_destroy)
2399  return GNUNET_OK;
2400  reschedule_session_timeout(session);
2401  session->flow_delay_for_other_peer =
2402  plugin->env->receive(plugin->env->cls, session->address, session, hdr);
2403  return GNUNET_OK;
2404 }
struct GNUNET_TIME_Relative flow_delay_for_other_peer
Desired delay for next sending we send to other peer.
struct Plugin * plugin
Pointer to the global plugin struct.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
struct GNUNET_HELLO_Address * address
Address.
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
Information about ongoing sessions of the transport client.
struct GNUNET_DATACACHE_PluginEnvironment * env
Our execution environment.
int in_destroy
Is this session about to be destroyed (sometimes we cannot destroy a session immediately as below us ...
Handle for a plugin.
Definition: block.c:37
void * cls
Closure to use for callbacks.
#define GNUNET_YES
Definition: gnunet_common.h:77
static void reschedule_session_timeout(struct GNUNET_ATS_Session *s)
Increment session timeout due to activity.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ disconnect_and_free_it()

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

Destroy a session, plugin is being unloaded.

Parameters
clsthe struct Plugin
keyhash of public key of target peer
valuea struct PeerSession * to clean up
Returns
GNUNET_OK (continue to iterate)

Definition at line 2416 of file plugin_transport_udp.c.

References GNUNET_OK, plugin, and udp_disconnect_session().

Referenced by libgnunet_plugin_transport_udp_done(), and udp_disconnect().

2419 {
2420  struct Plugin *plugin = cls;
2421 
2422  udp_disconnect_session(plugin, value);
2423  return GNUNET_OK;
2424 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
static char * value
Value of the record to add/remove.
static int udp_disconnect_session(void *cls, struct GNUNET_ATS_Session *s)
Functions with this signature are called whenever we need to close a session due to a disconnect or f...
Handle for a plugin.
Definition: block.c:37
Here is the call graph for this function:
Here is the caller graph for this function:

◆ udp_disconnect()

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

Disconnect from a remote node.

Clean up session if we have one for this peer.

Parameters
clsclosure for this call (should be handle to Plugin)
targetthe peeridentity of the peer to disconnect
Returns
GNUNET_OK on success, GNUNET_SYSERR if the operation failed

Definition at line 2436 of file plugin_transport_udp.c.

References disconnect_and_free_it(), GNUNET_CONTAINER_multipeermap_get_multiple(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), LOG, plugin, and Plugin::sessions.

Referenced by libgnunet_plugin_transport_udp_init().

2437 {
2438  struct Plugin *plugin = cls;
2439 
2441  "Disconnecting from peer `%s'\n",
2442  GNUNET_i2s(target));
2444  target,
2446  plugin);
2447 }
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
static int disconnect_and_free_it(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
Destroy a session, plugin is being unloaded.
Handle for a plugin.
Definition: block.c:37
struct GNUNET_ATS_Session * sessions
List of open sessions (or peer map, or...)
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define LOG(kind,...)
int GNUNET_CONTAINER_multipeermap_get_multiple(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, GNUNET_CONTAINER_PeerMapIterator it, void *it_cls)
Iterate over all entries in the map that match a particular key.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ session_timeout()

static void session_timeout ( void *  cls)
static

Session was idle, so disconnect it.

Parameters
clsthe struct GNUNET_ATS_Session to time out

Definition at line 2456 of file plugin_transport_udp.c.

References 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(), plugin, GNUNET_ATS_Session::plugin, GNUNET_TIME_Relative::rel_value_us, GNUNET_ATS_Session::timeout, GNUNET_ATS_Session::timeout_task, udp_disconnect_session(), and UDP_SESSION_TIME_OUT.

Referenced by udp_plugin_create_session().

2457 {
2458  struct GNUNET_ATS_Session *s = cls;
2459  struct Plugin *plugin = s->plugin;
2460  struct GNUNET_TIME_Relative left;
2461 
2462  s->timeout_task = NULL;
2464  if (left.rel_value_us > 0)
2465  {
2466  /* not actually our turn yet, but let's at least update
2467  the monitor, it may think we're about to die ... */
2470  return;
2471  }
2473  "Session %p was idle for %s, disconnecting\n",
2474  s,
2476  GNUNET_YES));
2477  /* call session destroy function */
2478  udp_disconnect_session(plugin, s);
2479 }
struct GNUNET_SCHEDULER_Task * timeout_task
Session timeout task.
struct Plugin * plugin
Pointer to the global plugin struct.
struct GNUNET_TIME_Absolute timeout
When does this session time out.
#define UDP_SESSION_TIME_OUT
After how much inactivity should a UDP session time out?
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1237
Information about ongoing sessions of the transport client.
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:686
static GNUNET_NETWORK_STRUCT_END 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.
static int udp_disconnect_session(void *cls, struct GNUNET_ATS_Session *s)
Functions with this signature are called whenever we need to close a session due to a disconnect or f...
This is just an update about the session, the state did not change.
static void session_timeout(void *cls)
Session was idle, so disconnect it.
Handle for a plugin.
Definition: block.c:37
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_remaining(struct GNUNET_TIME_Absolute future)
Given a timestamp in the future, how much time remains until then?
Definition: time.c:331
#define GNUNET_YES
Definition: gnunet_common.h:77
#define LOG(kind,...)
Time for relative time used by GNUnet, in microseconds.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ udp_plugin_create_session()

static struct GNUNET_ATS_Session* udp_plugin_create_session ( void *  cls,
const struct GNUNET_HELLO_Address address,
enum GNUNET_NetworkType  network_type 
)
static

Allocate a new session for the given endpoint address.

Note that this function does not inform the service of the new session, this is the responsibility of the caller (if needed).

Parameters
clsthe struct Plugin
addressaddress of the other peer to use
network_typenetwork type the address belongs to
Returns
NULL on error, otherwise session handle

Definition at line 2494 of file plugin_transport_udp.c.

References GNUNET_HELLO_Address::address, GNUNET_ATS_Session::address, GNUNET_HELLO_Address::address_length, Plugin::env, GNUNET_ATS_Session::flow_delay_for_other_peer, GNUNET_ATS_Session::flow_delay_from_other_peer, GNUNET_assert, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CONTAINER_multipeermap_put(), GNUNET_CONTAINER_multipeermap_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_HELLO_address_copy(), GNUNET_i2s(), GNUNET_MST_create(), GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_STATISTICS_set(), GNUNET_TIME_absolute_get(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_relative_to_absolute(), GNUNET_TIME_UNIT_MILLISECONDS, GNUNET_TIME_UNIT_ZERO, GNUNET_TRANSPORT_SS_INIT, GNUNET_ATS_Session::last_expected_ack_delay, GNUNET_ATS_Session::last_expected_msg_delay, GNUNET_ATS_Session::last_transmit_time, LOG, GNUNET_ATS_Session::mst, notify_session_monitor(), GNUNET_HELLO_Address::peer, plugin, GNUNET_ATS_Session::plugin, process_inbound_tokenized_messages(), GNUNET_ATS_Session::scope, session_timeout(), Plugin::sessions, GNUNET_ATS_Session::target, GNUNET_ATS_Session::timeout, GNUNET_ATS_Session::timeout_task, udp_address_to_string(), and UDP_SESSION_TIME_OUT.

Referenced by process_udp_message(), and udp_plugin_get_session().

2497 {
2498  struct Plugin *plugin = cls;
2499  struct GNUNET_ATS_Session *s;
2500 
2501  s = GNUNET_new(struct GNUNET_ATS_Session);
2503  s->plugin = plugin;
2504  s->address = GNUNET_HELLO_address_copy(address);
2505  s->target = address->peer;
2513  s->timeout_task =
2515  s->scope = network_type;
2516 
2518  "Creating new session %p for peer `%s' address `%s'\n",
2519  s,
2520  GNUNET_i2s(&address->peer),
2521  udp_address_to_string(plugin,
2522  address->address,
2523  address->address_length));
2525  plugin->sessions,
2526  &s->target,
2527  s,
2529  GNUNET_STATISTICS_set(plugin->env->stats,
2530  "# UDP sessions active",
2532  GNUNET_NO);
2534  return s;
2535 }
size_t address_length
Number of bytes in address.
struct GNUNET_TIME_Absolute last_transmit_time
What time did we last transmit?
const void * address
Binary representation of the address (plugin-specific).
struct GNUNET_SCHEDULER_Task * timeout_task
Session timeout task.
struct GNUNET_TIME_Relative flow_delay_for_other_peer
Desired delay for next sending we send to other peer.
struct Plugin * plugin
Pointer to the global plugin struct.
struct GNUNET_TIME_Absolute GNUNET_TIME_relative_to_absolute(struct GNUNET_TIME_Relative rel)
Convert relative time to an absolute time in the future.
Definition: time.c:246
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_TIME_Absolute timeout
When does this session time out.
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_HELLO_Address * address
Address.
static int process_inbound_tokenized_messages(void *cls, const struct GNUNET_MessageHeader *hdr)
Message tokenizer has broken up an incomming message.
struct GNUNET_TIME_Relative last_expected_ack_delay
expected delay for ACKs
#define UDP_SESSION_TIME_OUT
After how much inactivity should a UDP session time out?
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1237
struct GNUNET_TIME_Relative flow_delay_from_other_peer
Desired delay for transmissions we received from other peer.
Information about ongoing sessions of the transport client.
struct GNUNET_DATACACHE_PluginEnvironment * env
Our execution environment.
struct GNUNET_MessageStreamTokenizer * GNUNET_MST_create(GNUNET_MessageTokenizerCallback cb, void *cb_cls)
Create a message stream tokenizer.
Definition: mst.c:84
struct GNUNET_TIME_Relative GNUNET_TIME_relative_multiply(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Multiply relative time by a given factor.
Definition: time.c:440
static GNUNET_NETWORK_STRUCT_END 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.
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
#define GNUNET_TIME_UNIT_MILLISECONDS
One millisecond.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
struct GNUNET_MessageStreamTokenizer * mst
Tokenizer for inbound messages.
enum GNUNET_NetworkType scope
ATS network type.
struct GNUNET_PeerIdentity peer
For which peer is this an address?
#define GNUNET_TIME_UNIT_ZERO
Relative time zero.
Allow multiple values with the same key.
int GNUNET_CONTAINER_multipeermap_put(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
static void session_timeout(void *cls)
Session was idle, so disconnect it.
Handle for a plugin.
Definition: block.c:37
struct GNUNET_PeerIdentity target
To whom are we talking to.
struct GNUNET_HELLO_Address * GNUNET_HELLO_address_copy(const struct GNUNET_HELLO_Address *address)
Copy an address struct.
Definition: address.c:109
const char * udp_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.
The session was created (first call for each session object).
struct GNUNET_ATS_Session * sessions
List of open sessions (or peer map, or...)
struct GNUNET_TIME_Relative last_expected_msg_delay
desired delay between UDP messages
unsigned int GNUNET_CONTAINER_multipeermap_size(const struct GNUNET_CONTAINER_MultiPeerMap *map)
Get the number of key-value pairs in the map.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define LOG(kind,...)
Here is the call graph for this function:
Here is the caller graph for this function:

◆ udp_plugin_get_session()

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

Creates a new outbound session the transport service will use to send data to the peer.

Parameters
clsthe struct Plugin *
addressthe address
Returns
the session or NULL of max connections exceeded

Definition at line 2547 of file plugin_transport_udp.c.

References GNUNET_HELLO_Address::address, GNUNET_HELLO_Address::address_length, GNUNET_DATACACHE_PluginEnvironment::cls, Plugin::env, GNUNET_break, GNUNET_break_op, GNUNET_NT_UNSPECIFIED, plugin, udp_plugin_create_session(), and udp_plugin_lookup_session().

Referenced by libgnunet_plugin_transport_udp_init().

2548 {
2549  struct Plugin *plugin = cls;
2550  struct GNUNET_ATS_Session *s;
2551  enum GNUNET_NetworkType network_type = GNUNET_NT_UNSPECIFIED;
2552  const struct IPv4UdpAddress *udp_v4;
2553  const struct IPv6UdpAddress *udp_v6;
2554 
2555  if (NULL == address)
2556  {
2557  GNUNET_break(0);
2558  return NULL;
2559  }
2560  if ((address->address_length != sizeof(struct IPv4UdpAddress)) &&
2561  (address->address_length != sizeof(struct IPv6UdpAddress)))
2562  {
2563  GNUNET_break_op(0);
2564  return NULL;
2565  }
2566  if (NULL != (s = udp_plugin_lookup_session(cls, address)))
2567  return s;
2568 
2569  /* need to create new session */
2570  if (sizeof(struct IPv4UdpAddress) == address->address_length)
2571  {
2572  struct sockaddr_in v4;
2573 
2574  udp_v4 = (const struct IPv4UdpAddress *)address->address;
2575  memset(&v4, '\0', sizeof(v4));
2576  v4.sin_family = AF_INET;
2577 #if HAVE_SOCKADDR_IN_SIN_LEN
2578  v4.sin_len = sizeof(struct sockaddr_in);
2579 #endif
2580  v4.sin_port = udp_v4->u4_port;
2581  v4.sin_addr.s_addr = udp_v4->ipv4_addr;
2582  network_type = plugin->env->get_address_type(plugin->env->cls,
2583  (const struct sockaddr *)&v4,
2584  sizeof(v4));
2585  }
2586  if (sizeof(struct IPv6UdpAddress) == address->address_length)
2587  {
2588  struct sockaddr_in6 v6;
2589 
2590  udp_v6 = (const struct IPv6UdpAddress *)address->address;
2591  memset(&v6, '\0', sizeof(v6));
2592  v6.sin6_family = AF_INET6;
2593 #if HAVE_SOCKADDR_IN_SIN_LEN
2594  v6.sin6_len = sizeof(struct sockaddr_in6);
2595 #endif
2596  v6.sin6_port = udp_v6->u6_port;
2597  v6.sin6_addr = udp_v6->ipv6_addr;
2598  network_type = plugin->env->get_address_type(plugin->env->cls,
2599  (const struct sockaddr *)&v6,
2600  sizeof(v6));
2601  }
2602  GNUNET_break(GNUNET_NT_UNSPECIFIED != network_type);
2603  return udp_plugin_create_session(cls, address, network_type);
2604 }
size_t address_length
Number of bytes in address.
const void * address
Binary representation of the address (plugin-specific).
static struct GNUNET_ATS_Session * udp_plugin_lookup_session(void *cls, const struct GNUNET_HELLO_Address *address)
Locate an existing session the transport service is using to send data to another peer...
GNUNET_NetworkType
Types of networks (with separate quotas) we support.
Definition: gnunet_nt_lib.h:35
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
Network format for IPv4 addresses.
Information about ongoing sessions of the transport client.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
struct GNUNET_DATACACHE_PluginEnvironment * env
Our execution environment.
Network format for IPv6 addresses.
static struct GNUNET_ATS_Session * udp_plugin_create_session(void *cls, const struct GNUNET_HELLO_Address *address, enum GNUNET_NetworkType network_type)
Allocate a new session for the given endpoint address.
Handle for a plugin.
Definition: block.c:37
void * cls
Closure to use for callbacks.
Category of last resort.
Definition: gnunet_nt_lib.h:39
Here is the call graph for this function:
Here is the caller graph for this function:

◆ process_udp_message()

static void process_udp_message ( struct Plugin plugin,
const struct UDPMessage msg,
const union UdpAddress udp_addr,
size_t  udp_addr_len,
enum GNUNET_NetworkType  network_type 
)
static

We've received a UDP Message.

Process it (pass contents to main service).

Parameters
pluginplugin context
msgthe message
udp_addrsender address
udp_addr_lennumber of bytes in udp_addr
network_typenetwork type the address belongs to

Definition at line 2617 of file plugin_transport_udp.c.

References address, GNUNET_DATACACHE_PluginEnvironment::cls, Plugin::env, free_session(), GNUNET_break, GNUNET_break_op, GNUNET_free, GNUNET_HELLO_address_allocate(), GNUNET_HELLO_ADDRESS_INFO_NONE, GNUNET_MST_from_buffer(), GNUNET_NO, GNUNET_NT_UNSPECIFIED, GNUNET_TRANSPORT_SS_UP, GNUNET_YES, UDPMessage::header, GNUNET_ATS_Session::in_destroy, GNUNET_ATS_Session::mst, notify_session_monitor(), PLUGIN_NAME, GNUNET_ATS_Session::rc, UDPMessage::reserved, GNUNET_ATS_Session::scope, UDPMessage::sender, GNUNET_MessageHeader::size, udp_plugin_create_session(), and udp_plugin_lookup_session().

Referenced by fragment_msg_proc(), and udp_select_read().

2622 {
2623  struct GNUNET_ATS_Session *s;
2624  struct GNUNET_HELLO_Address *address;
2625 
2626  GNUNET_break(GNUNET_NT_UNSPECIFIED != network_type);
2627  if (0 != ntohl(msg->reserved))
2628  {
2629  GNUNET_break_op(0);
2630  return;
2631  }
2632  if (ntohs(msg->header.size) <
2633  sizeof(struct GNUNET_MessageHeader) + sizeof(struct UDPMessage))
2634  {
2635  GNUNET_break_op(0);
2636  return;
2637  }
2638 
2639  address = GNUNET_HELLO_address_allocate(&msg->sender,
2640  PLUGIN_NAME,
2641  udp_addr,
2642  udp_addr_len,
2644  if (NULL == (s = udp_plugin_lookup_session(plugin, address)))
2645  {
2646  s = udp_plugin_create_session(plugin, address, network_type);
2647  plugin->env->session_start(plugin->env->cls, address, s, s->scope);
2649  }
2650  GNUNET_free(address);
2651 
2652  s->rc++;
2654  (const char *)&msg[1],
2655  ntohs(msg->header.size) - sizeof(struct UDPMessage),
2656  GNUNET_YES,
2657  GNUNET_NO);
2658  s->rc--;
2659  if ((0 == s->rc) && (GNUNET_YES == s->in_destroy))
2660  free_session(s);
2661 }
unsigned int rc
Reference counter to indicate that this session is currently being used and must not be destroyed; se...
struct GNUNET_HELLO_Address * GNUNET_HELLO_address_allocate(const struct GNUNET_PeerIdentity *peer, const char *transport_name, const void *address, size_t address_length, enum GNUNET_HELLO_AddressInfo local_info)
Allocate an address struct.
Definition: address.c:73
static void free_session(struct GNUNET_ATS_Session *s)
Function to free last resources associated with a session.
static struct GNUNET_ATS_Session * udp_plugin_lookup_session(void *cls, const struct GNUNET_HELLO_Address *address)
Locate an existing session the transport service is using to send data to another peer...
struct GNUNET_MessageHeader header
Message header.
UDP Message-Packet header (after defragmentation).
uint32_t reserved
Always zero for now.
#define GNUNET_NO
Definition: gnunet_common.h:78
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
Information about ongoing sessions of the transport client.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
struct GNUNET_DATACACHE_PluginEnvironment * env
Our execution environment.
int GNUNET_MST_from_buffer(struct GNUNET_MessageStreamTokenizer *mst, 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.
Definition: mst.c:113
int in_destroy
Is this session about to be destroyed (sometimes we cannot destroy a session immediately as below us ...
static GNUNET_NETWORK_STRUCT_END 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.
struct GNUNET_MessageStreamTokenizer * mst
Tokenizer for inbound messages.
enum GNUNET_NetworkType scope
ATS network type.
static struct GNUNET_ATS_Session * udp_plugin_create_session(void *cls, const struct GNUNET_HELLO_Address *address, enum GNUNET_NetworkType network_type)
Allocate a new session for the given endpoint address.
No additional information.
#define PLUGIN_NAME
An address for communicating with a peer.
void * cls
Closure to use for callbacks.
Header for all communications.
#define GNUNET_YES
Definition: gnunet_common.h:77
static char * address
GNS address for this phone.
#define GNUNET_free(ptr)
Wrapper around free.
Category of last resort.
Definition: gnunet_nt_lib.h:39
struct GNUNET_PeerIdentity sender
What is the identity of the sender.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ fragment_msg_proc()

static void fragment_msg_proc ( void *  cls,
const struct GNUNET_MessageHeader msg 
)
static

Process a defragmented message.

Parameters
clsthe struct DefragContext *
msgthe message

Definition at line 2671 of file plugin_transport_udp.c.

References dc, GNUNET_break_op, GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_MESSAGE, GNUNET_YES, DefragContext::have_sender, DefragContext::network_type, DefragContext::plugin, process_udp_message(), UDPMessage::sender, DefragContext::sender, GNUNET_MessageHeader::size, GNUNET_MessageHeader::type, DefragContext::udp_addr, and DefragContext::udp_addr_len.

Referenced by read_process_fragment().

2672 {
2673  struct DefragContext *dc = cls;
2674  const struct UDPMessage *um;
2675 
2677  {
2678  GNUNET_break_op(0);
2679  return;
2680  }
2681  if (ntohs(msg->size) < sizeof(struct UDPMessage))
2682  {
2683  GNUNET_break_op(0);
2684  return;
2685  }
2686  um = (const struct UDPMessage *)msg;
2687  dc->sender = um->sender;
2688  dc->have_sender = GNUNET_YES;
2690  um,
2691  dc->udp_addr,
2692  dc->udp_addr_len,
2693  dc->network_type);
2694 }
UDP Message-Packet header (after defragmentation).
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
const union UdpAddress * udp_addr
Source address this receive context is for (allocated at the end of the struct).
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
enum GNUNET_NetworkType network_type
Network type the address belongs to.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_MESSAGE
Normal UDP message type.
int have_sender
Has the sender field been initialized yet?
size_t udp_addr_len
Length of udp_addr.
Data structure to track defragmentation contexts based on the source of the UDP traffic.
static void process_udp_message(struct Plugin *plugin, const struct UDPMessage *msg, const union UdpAddress *udp_addr, size_t udp_addr_len, enum GNUNET_NetworkType network_type)
We&#39;ve received a UDP Message.
#define GNUNET_YES
Definition: gnunet_common.h:77
struct Plugin * plugin
Reference to master plugin struct.
static struct GNUNET_FS_DownloadContext * dc
struct GNUNET_PeerIdentity sender
Who&#39;s message(s) are we defragmenting here? Only initialized once we succeeded and have_sender is set...
struct GNUNET_PeerIdentity sender
What is the identity of the sender.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ ack_message_sent()

static void ack_message_sent ( void *  cls,
struct UDP_MessageWrapper udpw,
int  result 
)
static

We finished sending an acknowledgement.

Update statistics.

Parameters
clsthe struct Plugin
udpwmessage queue entry of the ACK
resultGNUNET_OK if the transmission worked, GNUNET_SYSERR if we failed to send the ACK

Definition at line 2707 of file plugin_transport_udp.c.

References Plugin::env, GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_update(), and plugin.

Referenced by ack_proc().

2708 {
2709  struct Plugin *plugin = cls;
2710 
2711  if (GNUNET_OK == result)
2712  {
2713  GNUNET_STATISTICS_update(plugin->env->stats,
2714  "# UDP, ACK messages sent",
2715  1,
2716  GNUNET_NO);
2717  }
2718  else
2719  {
2720  GNUNET_STATISTICS_update(plugin->env->stats,
2721  "# UDP, ACK transmissions failed",
2722  1,
2723  GNUNET_NO);
2724  }
2725 }
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
struct GNUNET_DATACACHE_PluginEnvironment * env
Our execution environment.
static int result
Global testing status.
Handle for a plugin.
Definition: block.c:37
Here is the call graph for this function:
Here is the caller graph for this function:

◆ ack_proc()

static void ack_proc ( void *  cls,
uint32_t  id,
const struct GNUNET_MessageHeader msg 
)
static

Transmit an acknowledgement.

Parameters
clsthe struct DefragContext *
idmessage ID (unused)
msgack to transmit

Definition at line 2736 of file plugin_transport_udp.c.

References ack_message_sent(), GNUNET_ATS_Session::address, address, GNUNET_HELLO_Address::address_length, DefragContext::defrag, delay, UDP_ACK_Message::delay, enqueue(), Plugin::env, GNUNET_ATS_Session::flow_delay_for_other_peer, GNUNET_CONTAINER_heap_remove_node(), GNUNET_DEFRAGMENT_context_destroy(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_HELLO_address_allocate(), GNUNET_HELLO_address_free, GNUNET_HELLO_ADDRESS_INFO_NONE, GNUNET_malloc, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_ACK, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get(), GNUNET_TIME_UNIT_FOREVER_ABS, GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_TRANSPORT_SS_UPDATE, GNUNET_YES, DefragContext::have_sender, UDP_ACK_Message::header, DefragContext::hnode, LOG, UDP_MessageWrapper::msg_buf, UDP_MessageWrapper::msg_size, notify_session_monitor(), UDP_MessageWrapper::payload_size, plugin, DefragContext::plugin, PLUGIN_NAME, UDP_MessageWrapper::qc, UDP_MessageWrapper::qc_cls, GNUNET_TIME_Relative::rel_value_us, schedule_select_v4(), schedule_select_v6(), DefragContext::sender, UDP_ACK_Message::sender, UDP_MessageWrapper::session, GNUNET_MessageHeader::size, UDP_MessageWrapper::start_time, UDP_MessageWrapper::timeout, GNUNET_MessageHeader::type, DefragContext::udp_addr, DefragContext::udp_addr_len, udp_address_to_string(), and udp_plugin_lookup_session().

Referenced by read_process_fragment().

2737 {
2738  struct DefragContext *rc = cls;
2739  struct Plugin *plugin = rc->plugin;
2740  size_t msize = sizeof(struct UDP_ACK_Message) + ntohs(msg->size);
2741  struct UDP_ACK_Message *udp_ack;
2742  uint32_t delay;
2743  struct UDP_MessageWrapper *udpw;
2744  struct GNUNET_ATS_Session *s;
2745  struct GNUNET_HELLO_Address *address;
2746 
2747  if (GNUNET_NO == rc->have_sender)
2748  {
2749  /* tried to defragment but never succeeded, hence will not ACK */
2750  /* This can happen if we just lost msgs */
2751  GNUNET_STATISTICS_update(plugin->env->stats,
2752  "# UDP, fragments discarded without ACK",
2753  1,
2754  GNUNET_NO);
2755  return;
2756  }
2757  address = GNUNET_HELLO_address_allocate(&rc->sender,
2758  PLUGIN_NAME,
2759  rc->udp_addr,
2760  rc->udp_addr_len,
2762  s = udp_plugin_lookup_session(plugin, address);
2763  GNUNET_HELLO_address_free(address);
2764  if (NULL == s)
2765  {
2767  "Trying to transmit ACK to peer `%s' but no session found!\n",
2768  udp_address_to_string(plugin, rc->udp_addr, rc->udp_addr_len));
2771  GNUNET_free(rc);
2772  GNUNET_STATISTICS_update(plugin->env->stats,
2773  "# UDP, ACK transmissions failed",
2774  1,
2775  GNUNET_NO);
2776  return;
2777  }
2778  if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us ==
2780  delay = UINT32_MAX;
2781  else if (s->flow_delay_for_other_peer.rel_value_us < UINT32_MAX)
2783  else
2784  delay = UINT32_MAX - 1; /* largest value we can communicate */
2786  "Sending ACK to `%s' including delay of %s\n",
2787  udp_address_to_string(plugin, rc->udp_addr, rc->udp_addr_len),
2789  GNUNET_YES));
2790  udpw = GNUNET_malloc(sizeof(struct UDP_MessageWrapper) + msize);
2791  udpw->msg_size = msize;
2792  udpw->payload_size = 0;
2793  udpw->session = s;
2796  udpw->msg_buf = (char *)&udpw[1];
2797  udpw->qc = &ack_message_sent;
2798  udpw->qc_cls = plugin;
2799  udp_ack = (struct UDP_ACK_Message *)udpw->msg_buf;
2800  udp_ack->header.size = htons((uint16_t)msize);
2802  udp_ack->delay = htonl(delay);
2803  udp_ack->sender = *plugin->env->my_identity;
2804  GNUNET_memcpy(&udp_ack[1], msg, ntohs(msg->size));
2805  enqueue(plugin, udpw);
2807  if (s->address->address_length == sizeof(struct IPv4UdpAddress))
2808  schedule_select_v4(plugin);
2809  else
2810  schedule_select_v6(plugin);
2811 }
size_t address_length
Number of bytes in address.
size_t payload_size
Payload size of original message.
struct GNUNET_HELLO_Address * GNUNET_HELLO_address_allocate(const struct GNUNET_PeerIdentity *peer, const char *transport_name, const void *address, size_t address_length, enum GNUNET_HELLO_AddressInfo local_info)
Allocate an address struct.
Definition: address.c:73
uint64_t rel_value_us
The actual value.
struct GNUNET_ATS_Session * session
Session this message belongs to.
static void enqueue(struct Plugin *plugin, struct UDP_MessageWrapper *udpw)
Enqueue a message for transmission and update statistics.
struct GNUNET_TIME_Relative flow_delay_for_other_peer
Desired delay for next sending we send to other peer.
static struct GNUNET_ATS_Session * udp_plugin_lookup_session(void *cls, const struct GNUNET_HELLO_Address *address)
Locate an existing session the transport service is using to send data to another peer...
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_NO
Definition: gnunet_common.h:78
static void ack_message_sent(void *cls, struct UDP_MessageWrapper *udpw, int result)
We finished sending an acknowledgement.
struct GNUNET_HELLO_Address * address
Address.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
#define GNUNET_TIME_UNIT_FOREVER_ABS
Constant used to specify "forever".
const union UdpAddress * udp_addr
Source address this receive context is for (allocated at the end of the struct).
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
void GNUNET_DEFRAGMENT_context_destroy(struct GNUNET_DEFRAGMENT_Context *dc)
Destroy the given defragmentation context.
Network format for IPv4 addresses.
Information about ongoing sessions of the transport client.
struct GNUNET_DATACACHE_PluginEnvironment * env
Our execution environment.
int have_sender
Has the sender field been initialized yet?
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:686
struct GNUNET_DEFRAGMENT_Context * defrag
Defragmentation context.
struct GNUNET_MessageHeader header
Message header.
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
size_t udp_addr_len
Length of udp_addr.
struct GNUNET_PeerIdentity sender
What is the identity of the sender.