GNUnet  0.16.x
Data Structures | Macros | Typedefs | Enumerations | Functions | Variables
gnunet-service-tng.c File Reference

main for gnunet-service-tng More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_statistics_service.h"
#include "gnunet_transport_monitor_service.h"
#include "gnunet_peerstore_service.h"
#include "gnunet_hello_lib.h"
#include "gnunet_signatures.h"
#include "transport.h"
Include dependency graph for gnunet-service-tng.c:

Go to the source code of this file.

Data Structures

struct  MessageUUIDP
 Unique identifier we attach to a message. More...
 
struct  AcknowledgementUUIDP
 Unique identifier to map an acknowledgement to a transmission. More...
 
struct  TransportBackchannelEncapsulationMessage
 Outer layer of an encapsulated backchannel message. More...
 
struct  EphemeralConfirmationPS
 Body by which a peer confirms that it is using an ephemeral key. More...
 
struct  TransportDVBoxPayloadP
 Plaintext of the variable-size payload that is encrypted within a struct TransportBackchannelEncapsulationMessage More...
 
struct  TransportReliabilityBoxMessage
 Outer layer of an encapsulated unfragmented application message sent over an unreliable channel. More...
 
struct  TransportCummulativeAckPayloadP
 Acknowledgement payload. More...
 
struct  TransportReliabilityAckMessage
 Confirmation that the receiver got a GNUNET_MESSAGE_TYPE_TRANSPORT_RELIABILITY_BOX. More...
 
struct  TransportFragmentBoxMessage
 Outer layer of an encapsulated fragmented application message. More...
 
struct  DvInitPS
 Content signed by the initator during DV learning. More...
 
struct  DvHopPS
 Content signed by each peer during DV learning. More...
 
struct  DVPathEntryP
 An entry describing a peer on a path in a struct TransportDVLearnMessage message. More...
 
struct  TransportDVLearnMessage
 Internal message used by transport for distance vector learning. More...
 
struct  TransportDVBoxMessage
 Outer layer of an encapsulated message send over multiple hops. More...
 
struct  TransportValidationChallengeMessage
 Message send to another peer to validate that it can indeed receive messages at a particular address. More...
 
struct  TransportValidationPS
 Message signed by a peer to confirm that it can indeed receive messages at a particular address. More...
 
struct  TransportValidationResponseMessage
 Message send to a peer to respond to a #GNUNET_MESSAGE_TYPE_ADDRESS_VALIDATION_CHALLENGE. More...
 
struct  TransportFlowControlMessage
 Message for Transport-to-Transport Flow control. More...
 
struct  LearnLaunchEntry
 When did we launch this DV learning activity? More...
 
struct  TransmissionHistoryEntry
 Information we keep per GOODPUT_AGING_SLOTS about historic (or current) transmission performance. More...
 
struct  PerformanceData
 Performance data for a transmission possibility. More...
 
struct  CommunicatorMessageContext
 Context from handle_incoming_msg(). More...
 
struct  CoreSentContext
 Closure for core_env_sent_cb. More...
 
struct  ReassemblyContext
 Information we keep for a message that we are reassembling. More...
 
struct  VirtualLink
 A virtual link is another reachable peer that is known to CORE. More...
 
struct  PendingAcknowledgement
 Data structure kept when we are waiting for an acknowledgement. More...
 
struct  DistanceVectorHop
 One possible hop towards a DV target. More...
 
struct  DistanceVector
 Entry in our dv_routes table, representing a (set of) distance vector routes to a particular peer. More...
 
struct  QueueEntry
 An entry in the operation queue. More...
 
struct  Queue
 Handle for a queue. More...
 
struct  Neighbour
 A connected controller which is not our child. More...
 
struct  IncomingRequest
 Another peer attempted to talk to us, we should try to establish a connection in the other direction. More...
 
struct  PeerRequest
 Information per peer and request. More...
 
struct  PendingMessage
 List containing all messages that are yet to be send. More...
 
struct  TransportCummulativeAckPayload
 Acknowledgement payload. More...
 
struct  AcknowledgementCummulator
 Data structure in which we track acknowledgements still to be sent to the. More...
 
struct  AddressListEntry
 One of the addresses of this peer. More...
 
struct  TransportClient
 Client connected to the transport service. More...
 
struct  ValidationState
 State we keep for validation activities. More...
 
struct  Backtalker
 A Backtalker is a peer sending us backchannel messages. More...
 
struct  MonitorEvent
 Details about what to notify monitors about. More...
 
struct  DVKeyState
 Structure of the key material used to encrypt backchannel messages. More...
 
struct  FindByMessageUuidContext
 Closure for find_by_message_uuid. More...
 
struct  NeighbourSelectionContext
 Closure for dv_neighbour_selection and dv_neighbour_transmission. More...
 
struct  CheckKnownAddressContext
 Closure for check_known_address. More...
 
struct  CheckKnownChallengeContext
 Closure for check_known_challenge. More...
 
struct  PendingMessageScoreContext
 Context for select_best_pending_from_link(). More...
 
struct  QueueQualityContext
 Closure for check_connection_quality. More...
 

Macros

#define MAX_FC_RETRANSMIT_COUNT   1000
 Maximum number of FC retransmissions for a runing retransmission task. More...
 
#define MAX_CUMMULATIVE_ACKS   64
 Maximum number of messages we acknowledge together in one cumulative ACK. More...
 
#define FC_NO_CHANGE_REPLY_PROBABILITY   8
 What is the 1:n chance that we send a Flow control response when receiving a flow control message that did not change anything for us? Basically, this is used in the case where both peers are stuck on flow control (no window changes), but one might continue sending flow control messages to the other peer as the first FC message when things stalled got lost, and then subsequently the other peer does usually not respond as nothing changed. More...
 
#define IN_PACKET_SIZE_WITHOUT_MTU   128
 What is the size we assume for a read operation in the absence of an MTU for the purpose of flow control? More...
 
#define GOODPUT_AGING_SLOTS   4
 Number of slots we keep of historic data for computation of goodput / message loss ratio. More...
 
#define DEFAULT_WINDOW_SIZE   (128 * 1024)
 How big is the flow control window size by default; limits per-neighbour RAM utilization. More...
 
#define MAX_INCOMING_REQUEST   16
 For how many incoming connections do we try to create a virtual link for (at the same time!). More...
 
#define MAX_DV_DISCOVERY_SELECTION   16
 Maximum number of peers we select for forwarding DVInit messages at the same time (excluding initiator). More...
 
#define RECV_WINDOW_SIZE   4
 Window size. More...
 
#define MIN_DV_PATH_LENGTH_FOR_INITIATOR   3
 Minimum number of hops we should forward DV learn messages even if they are NOT useful for us in hope of looping back to the initiator? More...
 
#define MAX_DV_HOPS_ALLOWED   16
 Maximum DV distance allowed ever. More...
 
#define MAX_DV_LEARN_PENDING   64
 Maximum number of DV learning activities we may have pending at the same time. More...
 
#define MAX_DV_PATHS_TO_TARGET   3
 Maximum number of DV paths we keep simultaneously to the same target. More...
 
#define DELAY_WARN_THRESHOLD    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)
 If a queue delays the next message by more than this number of seconds we log a warning. More...
 
#define DV_FORWARD_TIMEOUT    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 60)
 If a DVBox could not be forwarded after this number of seconds we drop it. More...
 
#define DEFAULT_ACK_WAIT_DURATION    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1)
 Default value for how long we wait for reliability ack. More...
 
#define DV_QUALITY_RTT_THRESHOLD    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1)
 We only consider queues as "quality" connections when suppressing the generation of DV initiation messages if the latency of the queue is below this threshold. More...
 
#define DV_PATH_VALIDITY_TIMEOUT    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5)
 How long do we consider a DV path valid if we see no further updates on it? Note: the value chosen here might be too low! More...
 
#define BACKCHANNEL_INACTIVITY_TIMEOUT    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5)
 How long do we cache backchannel (struct Backtalker) information after a backchannel goes inactive? More...
 
#define DV_PATH_DISCOVERY_FREQUENCY    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 4)
 How long before paths expire would we like to (re)discover DV paths? Should be below DV_PATH_VALIDITY_TIMEOUT. More...
 
#define EPHEMERAL_VALIDITY    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 4)
 How long are ephemeral keys valid? More...
 
#define REASSEMBLY_EXPIRATION    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 4)
 How long do we keep partially reassembled messages around before giving up? More...
 
#define FAST_VALIDATION_CHALLENGE_FREQ    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 1)
 What is the fastest rate at which we send challenges if we keep learning an address (gossip, DHT, etc.)? More...
 
#define MAX_VALIDATION_CHALLENGE_FREQ    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_DAYS, 1)
 What is the slowest rate at which we send challenges? More...
 
#define ACK_CUMMULATOR_TIMEOUT    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 4)
 How long until we forget about historic accumulators and thus reset the ACK counter? Should exceed the maximum time an active connection experiences without an ACK. More...
 
#define DV_LEARN_BASE_FREQUENCY   GNUNET_TIME_UNIT_MINUTES
 What is the non-randomized base frequency at which we would initiate DV learn messages? More...
 
#define DV_LEARN_QUALITY_THRESHOLD   100
 How many good connections (confirmed, bi-directional, not DV) do we need to have to suppress initiating DV learn messages? More...
 
#define MAX_ADDRESS_VALID_UNTIL    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MONTHS, 1)
 When do we forget an invalid address for sure? More...
 
#define ADDRESS_VALIDATION_LIFETIME    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 4)
 How long do we consider an address valid if we just checked? More...
 
#define MIN_DELAY_ADDRESS_VALIDATION   GNUNET_TIME_UNIT_MILLISECONDS
 What is the maximum frequency at which we do address validation? A random value between 0 and this value is added when scheduling the validation_task (both to ensure we do not validate too often, and to randomize a bit). More...
 
#define VALIDATION_RTT_BUFFER_FACTOR   3
 How many network RTTs before an address validation expires should we begin trying to revalidate? (Note that the RTT used here is the one that we experienced during the last validation, not necessarily the latest RTT observed). More...
 
#define COMMUNICATOR_TOTAL_QUEUE_LIMIT   512
 How many messages can we have pending for a given communicator process before we start to throttle that communicator? More...
 
#define QUEUE_LENGTH_LIMIT   32
 How many messages can we have pending for a given queue (queue to a particular peer via a communicator) process before we start to throttle that queue? More...
 

Typedefs

typedef void(* DVMessageHandler) (void *cls, struct Neighbour *next_hop, const struct GNUNET_MessageHeader *hdr, enum RouteMessageOptions options)
 Function to call to further operate on the now DV encapsulated message hdr, forwarding it via next_hop under respect of options. More...
 

Enumerations

enum  ClientType {
  CT_NONE = 0 , CT_CORE = 1 , CT_MONITOR = 2 , CT_COMMUNICATOR = 3 ,
  CT_APPLICATION = 4 , CT_NONE = 0 , CT_CORE = 1 , CT_MONITOR = 2 ,
  CT_BLACKLIST = 3 , CT_CORE_NO_HANDLERS = 4
}
 What type of client is the struct TransportClient about? More...
 
enum  RouteMessageOptions {
  RMO_NONE = 0 , RMO_DV_ALLOWED = 1 , RMO_UNCONFIRMED_ALLOWED = 2 , RMO_ANYTHING_GOES = (RMO_DV_ALLOWED | RMO_UNCONFIRMED_ALLOWED) ,
  RMO_REDUNDANT = 4
}
 Which transmission options are allowable for transmission? Interpreted bit-wise! More...
 
enum  PendingMessageType { PMT_CORE = 0 , PMT_FRAGMENT_BOX = 1 , PMT_RELIABILITY_BOX = 2 , PMT_DV_BOX = 3 }
 Types of different pending messages. More...
 

Functions

static unsigned int get_age ()
 Get an offset into the transmission history buffer for struct PerformanceData. More...
 
static void free_incoming_request (struct IncomingRequest *ir)
 Release ir data structure. More...
 
static void free_pending_acknowledgement (struct PendingAcknowledgement *pa)
 Release pa data structure. More...
 
static void free_fragment_tree (struct PendingMessage *root)
 Free fragment tree below root, excluding root itself. More...
 
static void free_pending_message (struct PendingMessage *pm)
 Release memory associated with pm and remove pm from associated data structures. More...
 
static void free_reassembly_context (struct ReassemblyContext *rc)
 Free rc. More...
 
static void reassembly_cleanup_task (void *cls)
 Task run to clean up reassembly context of a neighbour that have expired. More...
 
static int free_reassembly_cb (void *cls, uint32_t key, void *value)
 function called to free_reassembly_context(). More...
 
static void free_virtual_link (struct VirtualLink *vl)
 Free virtual link. More...
 
static void free_validation_state (struct ValidationState *vs)
 Free validation state. More...
 
static struct Neighbourlookup_neighbour (const struct GNUNET_PeerIdentity *pid)
 Lookup neighbour for peer pid. More...
 
static struct VirtualLinklookup_virtual_link (const struct GNUNET_PeerIdentity *pid)
 Lookup virtual link for peer pid. More...
 
static void free_distance_vector_hop (struct DistanceVectorHop *dvh)
 Free a @dvh. More...
 
static void check_link_down (void *cls)
 Task run to check whether the hops of the cls still are validated, or if we need to core about disconnection. More...
 
static void cores_send_disconnect_info (const struct GNUNET_PeerIdentity *pid)
 Send message to CORE clients that we lost a connection. More...
 
static void free_dv_route (struct DistanceVector *dv)
 Free entry in dv_routes. More...
 
static void notify_monitor (struct TransportClient *tc, const struct GNUNET_PeerIdentity *peer, const char *address, enum GNUNET_NetworkType nt, const struct MonitorEvent *me)
 Notify monitor tc about an event. More...
 
static void notify_monitors (const struct GNUNET_PeerIdentity *peer, const char *address, enum GNUNET_NetworkType nt, const struct MonitorEvent *me)
 Send information in me about a peer's status with respect to some address to all monitors that care. More...
 
static void * client_connect_cb (void *cls, struct GNUNET_SERVICE_Client *client, struct GNUNET_MQ_Handle *mq)
 Called whenever a client connects. More...
 
static void free_neighbour (struct Neighbour *neighbour)
 Release memory used by neighbour. More...
 
static void core_send_connect_info (struct TransportClient *tc, const struct GNUNET_PeerIdentity *pid)
 Send message to CORE clients that we lost a connection. More...
 
static void cores_send_connect_info (const struct GNUNET_PeerIdentity *pid)
 Send message to CORE clients that we gained a connection. More...
 
static void transmit_on_queue (void *cls)
 We believe we are ready to transmit a message on a queue. More...
 
static unsigned int check_for_queue_with_higher_prio (struct Queue *queue, struct Queue *queue_head)
 Check if the communicator has another queue with higher prio ready for sending. More...
 
static void schedule_transmit_on_queue (struct GNUNET_TIME_Relative delay, struct Queue *queue, enum GNUNET_SCHEDULER_Priority p)
 Called whenever something changed that might effect when we try to do the next transmission on queue using transmit_on_queue(). More...
 
static void free_queue (struct Queue *queue)
 Free queue. More...
 
static void free_address_list_entry (struct AddressListEntry *ale)
 Free ale. More...
 
static int stop_peer_request (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
 Stop the peer request in value. More...
 
static void do_shutdown (void *cls)
 Function called when the service shuts down. More...
 
static void client_disconnect_cb (void *cls, struct GNUNET_SERVICE_Client *client, void *app_ctx)
 Called whenever a client is disconnected. More...
 
static int notify_client_connect_info (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
 Iterator telling new CORE client about all existing connections to peers. More...
 
static void handle_client_start (void *cls, const struct StartMessage *start)
 Initialize a "CORE" client. More...
 
static int check_client_send (void *cls, const struct OutboundMessage *obm)
 Client asked for transmission to a peer. More...
 
static void client_send_response (struct PendingMessage *pm)
 Send a response to the pm that we have processed a "send" request. More...
 
static unsigned int pick_random_dv_hops (const struct DistanceVector *dv, enum RouteMessageOptions options, struct DistanceVectorHop **hops_array, unsigned int hops_array_length)
 Pick hops_array_length random DV paths satisfying options. More...
 
static int check_communicator_available (void *cls, const struct GNUNET_TRANSPORT_CommunicatorAvailableMessage *cam)
 Communicator started. More...
 
static void finish_cmc_handling (struct CommunicatorMessageContext *cmc)
 Send ACK to communicator (if requested) and free cmc. More...
 
static void handle_client_recv_ok (void *cls, const struct RecvOkMessage *rom)
 Client confirms that it is done handling message(s) to a particular peer. More...
 
static void handle_communicator_available (void *cls, const struct GNUNET_TRANSPORT_CommunicatorAvailableMessage *cam)
 Communicator started. More...
 
static int check_communicator_backchannel (void *cls, const struct GNUNET_TRANSPORT_CommunicatorBackchannel *cb)
 Communicator requests backchannel transmission. More...
 
static void update_ephemeral (struct DistanceVector *dv)
 Ensure ephemeral keys in our dv are current. More...
 
static void queue_send_msg (struct Queue *queue, struct PendingMessage *pm, const void *payload, size_t payload_size)
 Send the message payload on queue. More...
 
static struct GNUNET_TIME_Relative route_via_neighbour (const struct Neighbour *n, const struct GNUNET_MessageHeader *hdr, enum RouteMessageOptions options)
 Pick a queue of n under constraints options and schedule transmission of hdr. More...
 
static void dv_setup_key_state_from_km (const struct GNUNET_HashCode *km, const struct GNUNET_ShortHashCode *iv, struct DVKeyState *key)
 Given the key material in km and the initialization vector iv, setup the key material for the backchannel in key. More...
 
static void dh_key_derive_eph_pid (const struct GNUNET_CRYPTO_EcdhePrivateKey *priv_ephemeral, const struct GNUNET_PeerIdentity *target, const struct GNUNET_ShortHashCode *iv, struct DVKeyState *key)
 Derive backchannel encryption key material from priv_ephemeral and target and iv. More...
 
static void dh_key_derive_eph_pub (const struct GNUNET_CRYPTO_EcdhePublicKey *pub_ephemeral, const struct GNUNET_ShortHashCode *iv, struct DVKeyState *key)
 Derive backchannel encryption key material from GST_my_private_key and pub_ephemeral and iv. More...
 
static void dv_hmac (const struct DVKeyState *key, struct GNUNET_HashCode *hmac, const void *data, size_t data_size)
 Do HMAC calculation for backchannel messages over data using key material from key. More...
 
static void dv_encrypt (struct DVKeyState *key, const void *in, void *dst, size_t in_size)
 Perform backchannel encryption using symmetric secret in key to encrypt data from in to dst. More...
 
static void dv_decrypt (struct DVKeyState *key, void *out, const void *ciph, size_t out_size)
 Perform backchannel encryption using symmetric secret in key to encrypt data from in to dst. More...
 
static void dv_key_clean (struct DVKeyState *key)
 Clean up key material in key. More...
 
static struct GNUNET_TIME_Relative encapsulate_for_dv (struct DistanceVector *dv, unsigned int num_dvhs, struct DistanceVectorHop **dvhs, const struct GNUNET_MessageHeader *hdr, DVMessageHandler use, void *use_cls, enum RouteMessageOptions options, enum GNUNET_GenericReturnValue without_fc)
 Pick a path of dv under constraints options and schedule transmission of hdr. More...
 
static void send_dv_to_neighbour (void *cls, struct Neighbour *next_hop, const struct GNUNET_MessageHeader *hdr, enum RouteMessageOptions options)
 Wrapper around route_via_neighbour() that matches the DVMessageHandler structure. More...
 
static struct GNUNET_TIME_Relative route_control_message_without_fc (struct VirtualLink *vl, const struct GNUNET_MessageHeader *hdr, enum RouteMessageOptions options)
 We need to transmit hdr to target. More...
 
static void consider_sending_fc (void *cls)
 Something changed on the virtual link with respect to flow control. More...
 
static void task_consider_sending_fc (void *cls)
 Something changed on the virtual link with respect to flow control. More...
 
static void check_vl_transmission (struct VirtualLink *vl)
 There is a message at the head of the pending messages for vl which may be ready for transmission. More...
 
static void handle_client_send (void *cls, const struct OutboundMessage *obm)
 Client asked for transmission to a peer. More...
 
static void handle_communicator_backchannel (void *cls, const struct GNUNET_TRANSPORT_CommunicatorBackchannel *cb)
 Communicator requests backchannel transmission. More...
 
static int check_add_address (void *cls, const struct GNUNET_TRANSPORT_AddAddressMessage *aam)
 Address of our peer added. More...
 
static void store_pi (void *cls)
 Ask peerstore to store our address. More...
 
static void peerstore_store_own_cb (void *cls, int success)
 Function called when peerstore is done storing our address. More...
 
static void handle_add_address (void *cls, const struct GNUNET_TRANSPORT_AddAddressMessage *aam)
 Address of our peer added. More...
 
static void handle_del_address (void *cls, const struct GNUNET_TRANSPORT_DelAddressMessage *dam)
 Address of our peer deleted. More...
 
static void demultiplex_with_cmc (struct CommunicatorMessageContext *cmc, const struct GNUNET_MessageHeader *msg)
 Given an inbound message msg from a communicator cmc, demultiplex it based on the type calling the right handler. More...
 
static void core_env_sent_cb (void *cls)
 Function called when we are done giving a message of a certain size to CORE and should thus decrement the number of bytes of RAM reserved for that peer's MQ. More...
 
static void handle_raw_message (void *cls, const struct GNUNET_MessageHeader *mh)
 Communicator gave us an unencapsulated message to pass as-is to CORE. More...
 
static int check_fragment_box (void *cls, const struct TransportFragmentBoxMessage *fb)
 Communicator gave us a fragment box. More...
 
static void destroy_ack_cummulator (void *cls)
 Clean up an idle cumulative acknowledgement data structure. More...
 
static void transmit_cummulative_ack_cb (void *cls)
 Do the transmission of a cumulative acknowledgement now. More...
 
static void cummulative_ack (const struct GNUNET_PeerIdentity *pid, const struct AcknowledgementUUIDP *ack_uuid, struct GNUNET_TIME_Absolute max_delay)
 Transmit an acknowledgement for ack_uuid to pid delaying transmission by at most ack_delay. More...
 
static int find_by_message_uuid (void *cls, uint32_t key, void *value)
 Iterator called to find a reassembly context by the message UUID in the multihashmap32. More...
 
static void handle_fragment_box (void *cls, const struct TransportFragmentBoxMessage *fb)
 Communicator gave us a fragment. More...
 
static int check_reliability_box (void *cls, const struct TransportReliabilityBoxMessage *rb)
 Communicator gave us a reliability box. More...
 
static void handle_reliability_box (void *cls, const struct TransportReliabilityBoxMessage *rb)
 Communicator gave us a reliability box. More...
 
static void update_pd_age (struct PerformanceData *pd, unsigned int age)
 Check if we have advanced to another age since the last time. More...
 
static void update_performance_data (struct PerformanceData *pd, struct GNUNET_TIME_Relative rtt, uint16_t bytes_transmitted_ok)
 Update pd based on the latest rtt and the number of bytes that were confirmed to be successfully transmitted. More...
 
static void update_queue_performance (struct Queue *q, struct GNUNET_TIME_Relative rtt, uint16_t bytes_transmitted_ok)
 We have successfully transmitted data via q, update metrics. More...
 
static void update_dvh_performance (struct DistanceVectorHop *dvh, struct GNUNET_TIME_Relative rtt, uint16_t bytes_transmitted_ok)
 We have successfully transmitted data via dvh, update metrics. More...
 
static void completed_pending_message (struct PendingMessage *pm)
 We have completed transmission of pm, remove it from the transmission queues (and if it is a fragment, continue up the tree as necessary). More...
 
static void handle_acknowledged (struct PendingAcknowledgement *pa, struct GNUNET_TIME_Relative ack_delay)
 The pa was acknowledged, process the acknowledgement. More...
 
static int check_reliability_ack (void *cls, const struct TransportReliabilityAckMessage *ra)
 Communicator gave us a reliability ack. More...
 
static void handle_reliability_ack (void *cls, const struct TransportReliabilityAckMessage *ra)
 Communicator gave us a reliability ack. More...
 
static int check_backchannel_encapsulation (void *cls, const struct TransportBackchannelEncapsulationMessage *be)
 Communicator gave us a backchannel encapsulation. More...
 
static void handle_backchannel_encapsulation (void *cls, const struct TransportBackchannelEncapsulationMessage *be)
 Communicator gave us a backchannel encapsulation. More...
 
static void path_cleanup_cb (void *cls)
 Task called when we should check if any of the DV paths we have learned to a target are due for garbage collection. More...
 
static void activate_core_visible_dv_path (struct DistanceVectorHop *hop)
 The hop is a validated path to the respective target peer and we should tell core about it – and schedule a job to revoke the state. More...
 
static int learn_dv_path (const struct GNUNET_PeerIdentity *path, unsigned int path_len, struct GNUNET_TIME_Relative network_latency, struct GNUNET_TIME_Absolute path_valid_until)
 We have learned a path through the network to some other peer, add it to our DV data structure (returning GNUNET_YES on success). More...
 
static int check_dv_learn (void *cls, const struct TransportDVLearnMessage *dvl)
 Communicator gave us a DV learn message. More...
 
static void forward_dv_learn (const struct GNUNET_PeerIdentity *next_hop, const struct TransportDVLearnMessage *msg, uint16_t bi_history, uint16_t nhops, const struct DVPathEntryP *hops, struct GNUNET_TIME_Absolute in_time)
 Build and forward a DV learn message to next_hop. More...
 
static int validate_dv_initiator_signature (struct GNUNET_TIME_AbsoluteNBO sender_monotonic_time, const struct GNUNET_PeerIdentity *init, const struct GNUNET_CRYPTO_ChallengeNonceP *challenge, const struct GNUNET_CRYPTO_EddsaSignature *init_sig)
 Check signature of type GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_INITIATOR. More...
 
static int dv_neighbour_selection (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
 Function called for each neighbour during handle_dv_learn. More...
 
static int dv_neighbour_transmission (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
 Function called for each neighbour during handle_dv_learn. More...
 
static unsigned int calculate_fork_degree (unsigned int hops_taken, unsigned int neighbour_count, unsigned int eligible_count)
 Computes the number of neighbours we should forward a DVInit message to given that it has so far taken hops_taken hops though the network and that the number of neighbours we have in total is neighbour_count, out of which eligible_count are not yet on the path. More...
 
static void neighbour_store_dvmono_cb (void *cls, int success)
 Function called when peerstore is done storing a DV monotonic time. More...
 
static void handle_dv_learn (void *cls, const struct TransportDVLearnMessage *dvl)
 Communicator gave us a DV learn message. More...
 
static int check_dv_box (void *cls, const struct TransportDVBoxMessage *dvb)
 Communicator gave us a DV box. More...
 
static void forward_dv_box (struct Neighbour *next_hop, struct TransportDVBoxMessage *hdr, uint16_t total_hops, uint16_t num_hops, const struct GNUNET_PeerIdentity *hops, const void *enc_payload, uint16_t enc_payload_size)
 Create a DV Box message and queue it for transmission to @ea next_hop. More...
 
static void free_backtalker (struct Backtalker *b)
 Free data structures associated with b. More...
 
static int free_backtalker_cb (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
 Callback to free backtalker records. More...
 
static void backtalker_timeout_cb (void *cls)
 Function called when it is time to clean up a backtalker. More...
 
static void backtalker_monotime_cb (void *cls, const struct GNUNET_PEERSTORE_Record *record, const char *emsg)
 Function called with the monotonic time of a backtalker by PEERSTORE. More...
 
static void backtalker_monotime_store_cb (void *cls, int success)
 Function called by PEERSTORE when the store operation of a backtalker's monotonic time is complete. More...
 
static void update_backtalker_monotime (struct Backtalker *b)
 The backtalker b monotonic time changed. More...
 
static void handle_dv_box (void *cls, const struct TransportDVBoxMessage *dvb)
 Communicator gave us a DV box. More...
 
static int check_incoming_msg (void *cls, const struct GNUNET_TRANSPORT_IncomingMessage *im)
 Client notified us about transmission from a peer. More...
 
static int check_known_address (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
 Test if the validation state in value matches the address from cls. More...
 
static void validation_start_cb (void *cls)
 Task run periodically to validate some address based on validation_heap. More...
 
static void update_next_challenge_time (struct ValidationState *vs, struct GNUNET_TIME_Absolute new_time)
 Set the time for next_challenge of vs to new_time. More...
 
static void start_address_validation (const struct GNUNET_PeerIdentity *pid, const char *address)
 Start address validation. More...
 
static void handle_hello_for_incoming (void *cls, const struct GNUNET_PEERSTORE_Record *record, const char *emsg)
 Function called by PEERSTORE for each matching record. More...
 
static void handle_validation_challenge (void *cls, const struct TransportValidationChallengeMessage *tvc)
 Communicator gave us a transport address validation challenge. More...
 
static int check_known_challenge (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
 Test if the validation state in value matches the challenge from cls. More...
 
static void peerstore_store_validation_cb (void *cls, int success)
 Function called when peerstore is done storing a validated address. More...
 
static struct Queuefind_queue (const struct GNUNET_PeerIdentity *pid, const char *address)
 Find the queue matching pid and address. More...
 
static void handle_validation_response (void *cls, const struct TransportValidationResponseMessage *tvr)
 Communicator gave us a transport address validation response. More...
 
static void handle_incoming_msg (void *cls, const struct GNUNET_TRANSPORT_IncomingMessage *im)
 Incoming meessage. More...
 
static void handle_flow_control (void *cls, const struct TransportFlowControlMessage *fc)
 Communicator gave us a transport address validation response. More...
 
static int check_add_queue_message (void *cls, const struct GNUNET_TRANSPORT_AddQueueMessage *aqm)
 New queue became available. More...
 
static void set_pending_message_uuid (struct PendingMessage *pm)
 If necessary, generates the UUID for a pm. More...
 
static struct PendingAcknowledgementprepare_pending_acknowledgement (struct Queue *queue, struct DistanceVectorHop *dvh, struct PendingMessage *pm)
 Setup data structure waiting for acknowledgements. More...
 
static struct PendingMessagefragment_message (struct Queue *queue, struct DistanceVectorHop *dvh, struct PendingMessage *pm)
 Fragment the given pm to the given mtu. More...
 
static struct PendingMessagereliability_box_message (struct Queue *queue, struct DistanceVectorHop *dvh, struct PendingMessage *pm)
 Reliability-box the given pm. More...
 
static void reorder_root_pm (struct PendingMessage *pm, struct GNUNET_TIME_Absolute next_attempt)
 
static void update_pm_next_attempt (struct PendingMessage *pm, struct GNUNET_TIME_Absolute next_attempt)
 Change the value of the next_attempt field of pm to next_attempt and re-order pm in the transmission list as required by the new timestamp. More...
 
static void select_best_pending_from_link (struct PendingMessageScoreContext *sc, struct Queue *queue, struct VirtualLink *vl, struct DistanceVectorHop *dvh, size_t overhead)
 Select the best pending message from vl for transmission via queue. More...
 
static void extract_box_cb (void *cls, struct Neighbour *next_hop, const struct GNUNET_MessageHeader *hdr, enum RouteMessageOptions options)
 Function to call to further operate on the now DV encapsulated message hdr, forwarding it via next_hop under respect of options. More...
 
static void handle_del_queue_message (void *cls, const struct GNUNET_TRANSPORT_DelQueueMessage *dqm)
 Queue to a peer went down. More...
 
static void handle_send_message_ack (void *cls, const struct GNUNET_TRANSPORT_SendMessageToAck *sma)
 Message was transmitted. More...
 
static int notify_client_queues (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
 Iterator telling new MONITOR client about all existing queues to peers. More...
 
static void handle_monitor_start (void *cls, const struct GNUNET_TRANSPORT_MonitorStart *start)
 Initialize a monitor client. More...
 
static struct TransportClientlookup_communicator (const char *prefix)
 Find transport client providing communication service for the protocol prefix. More...
 
static void suggest_to_connect (const struct GNUNET_PeerIdentity *pid, const char *address)
 Signature of a function called with a communicator address of a peer pid that an application wants us to connect to. More...
 
static void validation_transmit_on_queue (struct Queue *q, struct ValidationState *vs)
 The queue q (which matches the peer and address in vs) is ready for queueing. More...
 
static int check_connection_quality (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
 Check whether any queue to the given neighbour is of a good "quality" and if so, increment the counter. More...
 
static void start_dv_learn (void *cls)
 Task run when we CONSIDER initiating a DV learn process. More...
 
static int check_validation_request_pending (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
 A new queue has been created, check if any address validation requests have been waiting for it. More...
 
static void neighbour_dv_monotime_cb (void *cls, const struct GNUNET_PEERSTORE_Record *record, const char *emsg)
 Function called with the monotonic time of a DV initiator by PEERSTORE. More...
 
static void handle_add_queue_message (void *cls, const struct GNUNET_TRANSPORT_AddQueueMessage *aqm)
 New queue became available. More...
 
static void handle_update_queue_message (void *cls, const struct GNUNET_TRANSPORT_UpdateQueueMessage *msg)
 Handle updates to queues. More...
 
static void handle_queue_create_ok (void *cls, const struct GNUNET_TRANSPORT_CreateQueueResponse *cqr)
 Communicator tells us that our request to create a queue "worked", that is setting up the queue is now in process. More...
 
static void handle_queue_create_fail (void *cls, const struct GNUNET_TRANSPORT_CreateQueueResponse *cqr)
 Communicator tells us that our request to create a queue failed. More...
 
static void handle_suggest_cancel (void *cls, const struct ExpressPreferenceMessage *msg)
 We have received a struct ExpressPreferenceMessage from an application client. More...
 
static void handle_hello_for_client (void *cls, const struct GNUNET_PEERSTORE_Record *record, const char *emsg)
 Function called by PEERSTORE for each matching record. More...
 
static void handle_suggest (void *cls, const struct ExpressPreferenceMessage *msg)
 We have received a struct ExpressPreferenceMessage from an application client. More...
 
static int check_request_hello_validation (void *cls, const struct RequestHelloValidationMessage *m)
 Check GNUNET_MESSAGE_TYPE_TRANSPORT_REQUEST_HELLO_VALIDATION messages. More...
 
static void handle_request_hello_validation (void *cls, const struct RequestHelloValidationMessage *m)
 A client encountered an address of another peer. More...
 
static int free_neighbour_cb (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
 Free neighbour entry. More...
 
static int free_dv_routes_cb (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
 Free DV route entry. More...
 
static int free_validation_state_cb (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
 Free validation state. More...
 
static int free_pending_ack_cb (void *cls, const struct GNUNET_Uuid *key, void *value)
 Free pending acknowledgement. More...
 
static int free_ack_cummulator_cb (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
 Free acknowledgement cummulator. More...
 
static void shutdown_task (void *cls)
 
static void run (void *cls, const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_SERVICE_Handle *service)
 Initiate transport service. More...
 
 GNUNET_SERVICE_MAIN ("transport", GNUNET_SERVICE_OPTION_SOFT_SHUTDOWN, &run, &client_connect_cb, &client_disconnect_cb, NULL, GNUNET_MQ_hd_fixed_size(suggest, GNUNET_MESSAGE_TYPE_TRANSPORT_SUGGEST, struct ExpressPreferenceMessage, NULL), GNUNET_MQ_hd_fixed_size(suggest_cancel, GNUNET_MESSAGE_TYPE_TRANSPORT_SUGGEST_CANCEL, struct ExpressPreferenceMessage, NULL), GNUNET_MQ_hd_var_size(request_hello_validation, GNUNET_MESSAGE_TYPE_TRANSPORT_REQUEST_HELLO_VALIDATION, struct RequestHelloValidationMessage, NULL), GNUNET_MQ_hd_fixed_size(client_start, GNUNET_MESSAGE_TYPE_TRANSPORT_START, struct StartMessage, NULL), GNUNET_MQ_hd_var_size(client_send, GNUNET_MESSAGE_TYPE_TRANSPORT_SEND, struct OutboundMessage, NULL), GNUNET_MQ_hd_fixed_size(client_recv_ok, GNUNET_MESSAGE_TYPE_TRANSPORT_RECV_OK, struct RecvOkMessage, NULL), GNUNET_MQ_hd_var_size(communicator_available, GNUNET_MESSAGE_TYPE_TRANSPORT_NEW_COMMUNICATOR, struct GNUNET_TRANSPORT_CommunicatorAvailableMessage, NULL), GNUNET_MQ_hd_var_size(communicator_backchannel, GNUNET_MESSAGE_TYPE_TRANSPORT_COMMUNICATOR_BACKCHANNEL, struct GNUNET_TRANSPORT_CommunicatorBackchannel, NULL), GNUNET_MQ_hd_var_size(add_address, GNUNET_MESSAGE_TYPE_TRANSPORT_ADD_ADDRESS, struct GNUNET_TRANSPORT_AddAddressMessage, NULL), GNUNET_MQ_hd_fixed_size(del_address, GNUNET_MESSAGE_TYPE_TRANSPORT_DEL_ADDRESS, struct GNUNET_TRANSPORT_DelAddressMessage, NULL), GNUNET_MQ_hd_var_size(incoming_msg, GNUNET_MESSAGE_TYPE_TRANSPORT_INCOMING_MSG, struct GNUNET_TRANSPORT_IncomingMessage, NULL), GNUNET_MQ_hd_fixed_size(queue_create_ok, GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_CREATE_OK, struct GNUNET_TRANSPORT_CreateQueueResponse, NULL), GNUNET_MQ_hd_fixed_size(queue_create_fail, GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_CREATE_FAIL, struct GNUNET_TRANSPORT_CreateQueueResponse, NULL), GNUNET_MQ_hd_var_size(add_queue_message, GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_SETUP, struct GNUNET_TRANSPORT_AddQueueMessage, NULL), GNUNET_MQ_hd_fixed_size(update_queue_message, GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_UPDATE, struct GNUNET_TRANSPORT_UpdateQueueMessage, NULL), GNUNET_MQ_hd_fixed_size(del_queue_message, GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_TEARDOWN, struct GNUNET_TRANSPORT_DelQueueMessage, NULL), GNUNET_MQ_hd_fixed_size(send_message_ack, GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_MSG_ACK, struct GNUNET_TRANSPORT_SendMessageToAck, NULL), GNUNET_MQ_hd_fixed_size(monitor_start, GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_START, struct GNUNET_TRANSPORT_MonitorStart, NULL), GNUNET_MQ_handler_end())
 Define "main" method using service macro. More...
 

Variables

static struct TransportClientclients_head
 Head of linked list of all clients to this service. More...
 
static struct TransportClientclients_tail
 Tail of linked list of all clients to this service. More...
 
static struct GNUNET_STATISTICS_HandleGST_stats
 Statistics handle. More...
 
static const struct GNUNET_CONFIGURATION_HandleGST_cfg
 Configuration handle. More...
 
static struct GNUNET_PeerIdentity GST_my_identity
 Our public key. More...
 
static struct GNUNET_CRYPTO_EddsaPrivateKeyGST_my_private_key
 Our private key. More...
 
static struct GNUNET_CONTAINER_MultiPeerMapneighbours
 Map from PIDs to struct Neighbour entries. More...
 
static struct GNUNET_CONTAINER_MultiPeerMapbacktalkers
 Map from PIDs to struct Backtalker entries. More...
 
static struct GNUNET_CONTAINER_MultiPeerMapack_cummulators
 Map from PIDs to struct AcknowledgementCummulators. More...
 
static struct GNUNET_CONTAINER_MultiUuidmappending_acks
 Map of pending acknowledgements, mapping struct AcknowledgementUUID to a struct PendingAcknowledgement. More...
 
static struct GNUNET_CONTAINER_MultiPeerMapdv_routes
 Map from PIDs to struct DistanceVector entries describing known paths to the peer. More...
 
static struct GNUNET_CONTAINER_MultiPeerMapvalidation_map
 Map from PIDs to struct ValidationState entries describing addresses we are aware of and their validity state. More...
 
static struct GNUNET_CONTAINER_MultiPeerMaplinks
 Map from PIDs to struct VirtualLink entries describing links CORE knows to exist. More...
 
static struct GNUNET_CONTAINER_MultiShortmapdvlearn_map
 Map from challenges to struct LearnLaunchEntry values. More...
 
static struct LearnLaunchEntrylle_head = NULL
 Head of a DLL sorted by launch time. More...
 
static struct LearnLaunchEntrylle_tail = NULL
 Tail of a DLL sorted by launch time. More...
 
static struct GNUNET_CONTAINER_Heapvalidation_heap
 MIN Heap sorted by "next_challenge" to struct ValidationState entries sorting addresses we are aware of by when we should next try to (re)validate (or expire) them. More...
 
static struct GNUNET_PEERSTORE_Handlepeerstore
 Database for peer's HELLOs. More...
 
static struct GNUNET_SCHEDULER_Taskdvlearn_task
 Task run to initiate DV learning. More...
 
static struct GNUNET_SCHEDULER_Taskvalidation_task
 Task to run address validation. More...
 
static struct PendingAcknowledgementpa_head
 The most recent PA we have created, head of DLL. More...
 
static struct PendingAcknowledgementpa_tail
 The oldest PA we have created, tail of DLL. More...
 
static struct IncomingRequestir_head
 List of incoming connections where we are trying to get a connection back established. More...
 
static struct IncomingRequestir_tail
 Tail of DLL starting at ir_head. More...
 
static unsigned int ir_total
 Length of the DLL starting at ir_head. More...
 
static unsigned long long logging_uuid_gen
 Generator of logging_uuid in struct PendingMessage. More...
 
static unsigned int pa_count
 Number of entries in the pa_head/pa_tail DLL. More...
 
static struct GNUNET_TIME_Absolute hello_mono_time
 Monotonic time we use for HELLOs generated at this time. More...
 
static int in_shutdown
 Indication if we have received a shutdown signal and are in the process of cleaning up. More...
 

Detailed Description

main for gnunet-service-tng

Author
Christian Grothoff

TODO: Implement next:

Optimizations-Statistics:

Optimizations-DV:

Optimizations-Fragmentation:

Optimizations-internals:

Definition in file gnunet-service-tng.c.

Macro Definition Documentation

◆ MAX_FC_RETRANSMIT_COUNT

#define MAX_FC_RETRANSMIT_COUNT   1000

Maximum number of FC retransmissions for a runing retransmission task.

Definition at line 87 of file gnunet-service-tng.c.

◆ MAX_CUMMULATIVE_ACKS

#define MAX_CUMMULATIVE_ACKS   64

Maximum number of messages we acknowledge together in one cumulative ACK.

Larger values may save a bit of bandwidth.

Definition at line 93 of file gnunet-service-tng.c.

◆ FC_NO_CHANGE_REPLY_PROBABILITY

#define FC_NO_CHANGE_REPLY_PROBABILITY   8

What is the 1:n chance that we send a Flow control response when receiving a flow control message that did not change anything for us? Basically, this is used in the case where both peers are stuck on flow control (no window changes), but one might continue sending flow control messages to the other peer as the first FC message when things stalled got lost, and then subsequently the other peer does usually not respond as nothing changed.

So to ensure that eventually the FC messages stop, we do send with 1/8th probability an FC message even if nothing changed. That prevents one peer being stuck in sending (useless) FC messages "forever".

Definition at line 107 of file gnunet-service-tng.c.

◆ IN_PACKET_SIZE_WITHOUT_MTU

#define IN_PACKET_SIZE_WITHOUT_MTU   128

What is the size we assume for a read operation in the absence of an MTU for the purpose of flow control?

Definition at line 113 of file gnunet-service-tng.c.

◆ GOODPUT_AGING_SLOTS

#define GOODPUT_AGING_SLOTS   4

Number of slots we keep of historic data for computation of goodput / message loss ratio.

Definition at line 119 of file gnunet-service-tng.c.

◆ DEFAULT_WINDOW_SIZE

#define DEFAULT_WINDOW_SIZE   (128 * 1024)

How big is the flow control window size by default; limits per-neighbour RAM utilization.

Definition at line 125 of file gnunet-service-tng.c.

◆ MAX_INCOMING_REQUEST

#define MAX_INCOMING_REQUEST   16

For how many incoming connections do we try to create a virtual link for (at the same time!).

This does NOT limit the number of incoming connections, just the number for which we are actively trying to find working addresses in the absence (!) of our own applications wanting the link to go up.

Definition at line 135 of file gnunet-service-tng.c.

◆ MAX_DV_DISCOVERY_SELECTION

#define MAX_DV_DISCOVERY_SELECTION   16

Maximum number of peers we select for forwarding DVInit messages at the same time (excluding initiator).

Definition at line 141 of file gnunet-service-tng.c.

◆ RECV_WINDOW_SIZE

#define RECV_WINDOW_SIZE   4

Window size.

How many messages to the same target do we pass to CORE without a RECV_OK in between? Small values limit thoughput, large values will increase latency.

FIXME-OPTIMIZE: find out what good values are experimentally, maybe set adaptively (i.e. to observed available bandwidth).

Definition at line 151 of file gnunet-service-tng.c.

◆ MIN_DV_PATH_LENGTH_FOR_INITIATOR

#define MIN_DV_PATH_LENGTH_FOR_INITIATOR   3

Minimum number of hops we should forward DV learn messages even if they are NOT useful for us in hope of looping back to the initiator?

FIXME: allow initiator some control here instead?

Definition at line 160 of file gnunet-service-tng.c.

◆ MAX_DV_HOPS_ALLOWED

#define MAX_DV_HOPS_ALLOWED   16

Maximum DV distance allowed ever.

Definition at line 165 of file gnunet-service-tng.c.

◆ MAX_DV_LEARN_PENDING

#define MAX_DV_LEARN_PENDING   64

Maximum number of DV learning activities we may have pending at the same time.

Definition at line 171 of file gnunet-service-tng.c.

◆ MAX_DV_PATHS_TO_TARGET

#define MAX_DV_PATHS_TO_TARGET   3

Maximum number of DV paths we keep simultaneously to the same target.

Definition at line 176 of file gnunet-service-tng.c.

◆ DELAY_WARN_THRESHOLD

#define DELAY_WARN_THRESHOLD    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)

If a queue delays the next message by more than this number of seconds we log a warning.

Note: this is for testing, the value chosen here might be too aggressively low!

Definition at line 183 of file gnunet-service-tng.c.

◆ DV_FORWARD_TIMEOUT

#define DV_FORWARD_TIMEOUT    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 60)

If a DVBox could not be forwarded after this number of seconds we drop it.

Definition at line 190 of file gnunet-service-tng.c.

◆ DEFAULT_ACK_WAIT_DURATION

#define DEFAULT_ACK_WAIT_DURATION    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1)

Default value for how long we wait for reliability ack.

Definition at line 196 of file gnunet-service-tng.c.

◆ DV_QUALITY_RTT_THRESHOLD

#define DV_QUALITY_RTT_THRESHOLD    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1)

We only consider queues as "quality" connections when suppressing the generation of DV initiation messages if the latency of the queue is below this threshold.

Definition at line 204 of file gnunet-service-tng.c.

◆ DV_PATH_VALIDITY_TIMEOUT

#define DV_PATH_VALIDITY_TIMEOUT    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5)

How long do we consider a DV path valid if we see no further updates on it? Note: the value chosen here might be too low!

Definition at line 211 of file gnunet-service-tng.c.

◆ BACKCHANNEL_INACTIVITY_TIMEOUT

#define BACKCHANNEL_INACTIVITY_TIMEOUT    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5)

How long do we cache backchannel (struct Backtalker) information after a backchannel goes inactive?

Definition at line 218 of file gnunet-service-tng.c.

◆ DV_PATH_DISCOVERY_FREQUENCY

#define DV_PATH_DISCOVERY_FREQUENCY    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 4)

How long before paths expire would we like to (re)discover DV paths? Should be below DV_PATH_VALIDITY_TIMEOUT.

Definition at line 225 of file gnunet-service-tng.c.

◆ EPHEMERAL_VALIDITY

#define EPHEMERAL_VALIDITY    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 4)

How long are ephemeral keys valid?

Definition at line 231 of file gnunet-service-tng.c.

◆ REASSEMBLY_EXPIRATION

#define REASSEMBLY_EXPIRATION    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 4)

How long do we keep partially reassembled messages around before giving up?

Definition at line 237 of file gnunet-service-tng.c.

◆ FAST_VALIDATION_CHALLENGE_FREQ

#define FAST_VALIDATION_CHALLENGE_FREQ    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 1)

What is the fastest rate at which we send challenges if we keep learning an address (gossip, DHT, etc.)?

Definition at line 244 of file gnunet-service-tng.c.

◆ MAX_VALIDATION_CHALLENGE_FREQ

#define MAX_VALIDATION_CHALLENGE_FREQ    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_DAYS, 1)

What is the slowest rate at which we send challenges?

Definition at line 250 of file gnunet-service-tng.c.

◆ ACK_CUMMULATOR_TIMEOUT

#define ACK_CUMMULATOR_TIMEOUT    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 4)

How long until we forget about historic accumulators and thus reset the ACK counter? Should exceed the maximum time an active connection experiences without an ACK.

Definition at line 258 of file gnunet-service-tng.c.

◆ DV_LEARN_BASE_FREQUENCY

#define DV_LEARN_BASE_FREQUENCY   GNUNET_TIME_UNIT_MINUTES

What is the non-randomized base frequency at which we would initiate DV learn messages?

Definition at line 265 of file gnunet-service-tng.c.

◆ DV_LEARN_QUALITY_THRESHOLD

#define DV_LEARN_QUALITY_THRESHOLD   100

How many good connections (confirmed, bi-directional, not DV) do we need to have to suppress initiating DV learn messages?

Definition at line 271 of file gnunet-service-tng.c.

◆ MAX_ADDRESS_VALID_UNTIL

#define MAX_ADDRESS_VALID_UNTIL    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MONTHS, 1)

When do we forget an invalid address for sure?

Definition at line 276 of file gnunet-service-tng.c.

◆ ADDRESS_VALIDATION_LIFETIME

#define ADDRESS_VALIDATION_LIFETIME    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 4)

How long do we consider an address valid if we just checked?

Definition at line 282 of file gnunet-service-tng.c.

◆ MIN_DELAY_ADDRESS_VALIDATION

#define MIN_DELAY_ADDRESS_VALIDATION   GNUNET_TIME_UNIT_MILLISECONDS

What is the maximum frequency at which we do address validation? A random value between 0 and this value is added when scheduling the validation_task (both to ensure we do not validate too often, and to randomize a bit).

Definition at line 291 of file gnunet-service-tng.c.

◆ VALIDATION_RTT_BUFFER_FACTOR

#define VALIDATION_RTT_BUFFER_FACTOR   3

How many network RTTs before an address validation expires should we begin trying to revalidate? (Note that the RTT used here is the one that we experienced during the last validation, not necessarily the latest RTT observed).

Definition at line 299 of file gnunet-service-tng.c.

◆ COMMUNICATOR_TOTAL_QUEUE_LIMIT

#define COMMUNICATOR_TOTAL_QUEUE_LIMIT   512

How many messages can we have pending for a given communicator process before we start to throttle that communicator?

Used if a communicator might be CPU-bound and cannot handle the traffic.

Definition at line 307 of file gnunet-service-tng.c.

◆ QUEUE_LENGTH_LIMIT

#define QUEUE_LENGTH_LIMIT   32

How many messages can we have pending for a given queue (queue to a particular peer via a communicator) process before we start to throttle that queue?

Definition at line 314 of file gnunet-service-tng.c.

Typedef Documentation

◆ DVMessageHandler

typedef void(* DVMessageHandler) (void *cls, struct Neighbour *next_hop, const struct GNUNET_MessageHeader *hdr, enum RouteMessageOptions options)

Function to call to further operate on the now DV encapsulated message hdr, forwarding it via next_hop under respect of options.

Parameters
clsclosure
next_hopnext hop of the DV path
hdrencapsulated message, technically a struct TransportDFBoxMessage
optionsoptions of the original message

Definition at line 4730 of file gnunet-service-tng.c.

Enumeration Type Documentation

◆ ClientType

enum ClientType

What type of client is the struct TransportClient about?

Enumerator
CT_NONE 

We do not know yet (client is fresh).

CT_CORE 

Is the CORE service, we need to forward traffic to it.

CT_MONITOR 

It is a monitor, forward monitor data.

CT_COMMUNICATOR 

It is a communicator, use for communication.

CT_APPLICATION 

"Application" telling us where to connect (i.e.

TOPOLOGY, DHT or CADET).

CT_NONE 

We do not know yet (client is fresh).

CT_CORE 

Is the CORE service, we need to forward traffic to it.

CT_MONITOR 

It is a monitor, forward monitor data.

CT_BLACKLIST 

It is a blacklist, query about allowed connections.

CT_CORE_NO_HANDLERS 

CORE client without any handlers.

Definition at line 977 of file gnunet-service-tng.c.

978 {
982  CT_NONE = 0,
983 
987  CT_CORE = 1,
988 
992  CT_MONITOR = 2,
993 
997  CT_COMMUNICATOR = 3,
998 
1002  CT_APPLICATION = 4
1003 };
@ CT_APPLICATION
"Application" telling us where to connect (i.e.
@ CT_MONITOR
It is a monitor, forward monitor data.
@ CT_NONE
We do not know yet (client is fresh).
@ CT_CORE
Is the CORE service, we need to forward traffic to it.
@ CT_COMMUNICATOR
It is a communicator, use for communication.

◆ RouteMessageOptions

Which transmission options are allowable for transmission? Interpreted bit-wise!

Enumerator
RMO_NONE 

Only confirmed, non-DV direct neighbours.

RMO_DV_ALLOWED 

We are allowed to use DV routing for this hdr.

RMO_UNCONFIRMED_ALLOWED 

We are allowed to use unconfirmed queues or DV routes for this message.

RMO_ANYTHING_GOES 

Reliable and unreliable, DV and non-DV are all acceptable.

RMO_REDUNDANT 

If we have multiple choices, it is OK to send this message over multiple channels at the same time to improve loss tolerance.

(We do at most 2 transmissions.)

Definition at line 1010 of file gnunet-service-tng.c.

1011 {
1015  RMO_NONE = 0,
1016 
1020  RMO_DV_ALLOWED = 1,
1021 
1026 
1031 
1037  RMO_REDUNDANT = 4
1038 };
@ RMO_UNCONFIRMED_ALLOWED
We are allowed to use unconfirmed queues or DV routes for this message.
@ RMO_DV_ALLOWED
We are allowed to use DV routing for this hdr.
@ RMO_REDUNDANT
If we have multiple choices, it is OK to send this message over multiple channels at the same time to...
@ RMO_NONE
Only confirmed, non-DV direct neighbours.
@ RMO_ANYTHING_GOES
Reliable and unreliable, DV and non-DV are all acceptable.

◆ PendingMessageType

Types of different pending messages.

Enumerator
PMT_CORE 

Ordinary message received from the CORE service.

PMT_FRAGMENT_BOX 

Fragment box.

PMT_RELIABILITY_BOX 

Reliability box.

PMT_DV_BOX 

Pending message created during forward_dv_box().

Definition at line 2069 of file gnunet-service-tng.c.

2070 {
2074  PMT_CORE = 0,
2075 
2079  PMT_FRAGMENT_BOX = 1,
2080 
2084  PMT_RELIABILITY_BOX = 2,
2085 
2089  PMT_DV_BOX = 3
2090 };
@ PMT_FRAGMENT_BOX
Fragment box.
@ PMT_DV_BOX
Pending message created during forward_dv_box().
@ PMT_CORE
Ordinary message received from the CORE service.
@ PMT_RELIABILITY_BOX
Reliability box.

Function Documentation

◆ get_age()

static unsigned int get_age ( )
static

Get an offset into the transmission history buffer for struct PerformanceData.

Note that the caller must perform the required modulo GOODPUT_AGING_SLOTS operation before indexing into the array!

An 'age' lasts 15 minute slots.

Returns
current age of the world

Definition at line 2847 of file gnunet-service-tng.c.

2848 {
2849  struct GNUNET_TIME_Absolute now;
2850 
2851  now = GNUNET_TIME_absolute_get ();
2852  return now.abs_value_us / GNUNET_TIME_UNIT_MINUTES.rel_value_us / 15;
2853 }
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:110
#define GNUNET_TIME_UNIT_MINUTES
One minute.
Time for absolute times used by GNUnet, in microseconds.

References GNUNET_TIME_Absolute::abs_value_us, GNUNET_TIME_absolute_get(), and GNUNET_TIME_UNIT_MINUTES.

Referenced by update_performance_data().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ free_incoming_request()

static void free_incoming_request ( struct IncomingRequest ir)
static

Release ir data structure.

Parameters
irdata structure to release

Definition at line 2862 of file gnunet-service-tng.c.

2863 {
2865  GNUNET_assert (ir_total > 0);
2866  ir_total--;
2868  ir->wc = NULL;
2869  GNUNET_free (ir);
2870 }
static struct IncomingRequest * ir_tail
Tail of DLL starting at ir_head.
static unsigned int ir_total
Length of the DLL starting at ir_head.
static struct IncomingRequest * ir_head
List of incoming connections where we are trying to get a connection back established.
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_free(ptr)
Wrapper around free.
void GNUNET_PEERSTORE_watch_cancel(struct GNUNET_PEERSTORE_WatchContext *wc)
Cancel a watch request.
struct GNUNET_PEERSTORE_WatchContext * wc
Handle for watching the peerstore for HELLOs for this peer.

References GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_PEERSTORE_watch_cancel(), ir_head, ir_tail, ir_total, and IncomingRequest::wc.

Referenced by do_shutdown(), and handle_validation_challenge().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ free_pending_acknowledgement()

static void free_pending_acknowledgement ( struct PendingAcknowledgement pa)
static

Release pa data structure.

Parameters
padata structure to release

Definition at line 2879 of file gnunet-service-tng.c.

2880 {
2881  struct Queue *q = pa->queue;
2882  struct PendingMessage *pm = pa->pm;
2883  struct DistanceVectorHop *dvh = pa->dvh;
2884 
2886  "free_pending_acknowledgement\n");
2887  if (NULL != q)
2888  {
2889  GNUNET_CONTAINER_MDLL_remove (queue, q->pa_head, q->pa_tail, pa);
2890  pa->queue = NULL;
2891  }
2892  if (NULL != pm)
2893  {
2895  "remove pa from message\n");
2897  "remove pa from message %llu\n",
2898  pm->logging_uuid);
2900  "remove pa from message %u\n",
2901  pm->pmt);
2903  "remove pa from message %s\n",
2904  GNUNET_uuid2s (&pa->ack_uuid.value));
2905  GNUNET_CONTAINER_MDLL_remove (pm, pm->pa_head, pm->pa_tail, pa);
2906  pa->pm = NULL;
2907  }
2908  if (NULL != dvh)
2909  {
2910  GNUNET_CONTAINER_MDLL_remove (dvh, dvh->pa_head, dvh->pa_tail, pa);
2911  pa->queue = NULL;
2912  }
2915  &pa->ack_uuid.value,
2916  pa));
2917  GNUNET_free (pa);
2918 }
static struct GNUNET_REVOCATION_Query * q
Handle for revocation query.
static struct GNUNET_CONTAINER_MultiUuidmap * pending_acks
Map of pending acknowledgements, mapping struct AcknowledgementUUID to a struct PendingAcknowledgemen...
static struct GNUNET_TRANSPORT_PluginMonitor * pm
Handle if we are monitoring plugin session activity.
static void queue(const char *hostname)
Add hostname to the list of requests to be made.
#define GNUNET_log(kind,...)
@ GNUNET_YES
Definition: gnunet_common.h:97
#define GNUNET_CONTAINER_MDLL_remove(mdll, head, tail, element)
Remove an element from a MDLL.
int GNUNET_CONTAINER_multiuuidmap_remove(struct GNUNET_CONTAINER_MultiUuidmap *map, const struct GNUNET_Uuid *key, const void *value)
Remove the given key-value pair from the map.
const char * GNUNET_uuid2s(const struct GNUNET_Uuid *uuid)
Convert a UUID to a string (for printing debug messages).
@ GNUNET_ERROR_TYPE_DEBUG
struct GNUNET_Uuid value
The UUID value.
One possible hop towards a DV target.
struct PendingAcknowledgement * pa_head
Head of DLL of PAs that used our path.
struct PendingAcknowledgement * pa_tail
Tail of DLL of PAs that used our path.
struct AcknowledgementUUIDP ack_uuid
Unique identifier for this transmission operation.
struct PendingMessage * pm
Message that was transmitted, may be NULL if the message was ACKed via another channel.
struct Queue * queue
Queue used for transmission, NULL if the queue has been destroyed (which may happen before we get an ...
struct DistanceVectorHop * dvh
Distance vector path chosen for this transmission, NULL if transmission was to a direct neighbour OR ...
List containing all messages that are yet to be send.
Handle for a queue.

References PendingAcknowledgement::ack_uuid, PendingAcknowledgement::dvh, GNUNET_assert, GNUNET_CONTAINER_MDLL_remove, GNUNET_CONTAINER_multiuuidmap_remove(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_uuid2s(), GNUNET_YES, DistanceVectorHop::pa_head, DistanceVectorHop::pa_tail, pending_acks, PendingAcknowledgement::pm, pm, q, queue(), PendingAcknowledgement::queue, and AcknowledgementUUIDP::value.

Referenced by free_pending_ack_cb(), and handle_acknowledged().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ free_fragment_tree()

static void free_fragment_tree ( struct PendingMessage root)
static

Free fragment tree below root, excluding root itself.

FIXME: this does NOT seem to have the intended semantics based on how this is called. Seems we generally DO expect root to be free'ed itself as well!

Parameters
rootroot of the tree to free

Definition at line 2930 of file gnunet-service-tng.c.

2931 {
2932  struct PendingMessage *frag;
2933 
2934  while (NULL != (frag = root->head_frag))
2935  {
2936  struct PendingAcknowledgement *pa;
2937 
2938  free_fragment_tree (frag);
2939  while (NULL != (pa = frag->pa_head))
2940  {
2941  GNUNET_CONTAINER_MDLL_remove (pm, frag->pa_head, frag->pa_tail, pa);
2942  pa->pm = NULL;
2943  }
2944  GNUNET_CONTAINER_MDLL_remove (frag, root->head_frag, root->tail_frag, frag);
2945  if (NULL != frag->qe)
2946  {
2947  GNUNET_assert (frag == frag->qe->pm);
2948  frag->qe->pm = NULL;
2950  frag->qe->queue->queue_tail,
2951  frag->qe);
2953  "Removing QueueEntry MID %llu from queue\n",
2954  frag->qe->mid);
2955  GNUNET_free (frag->qe);
2956  }
2958  "Free frag %p\n",
2959  frag);
2960  GNUNET_free (frag);
2961  }
2962 }
static void free_fragment_tree(struct PendingMessage *root)
Free fragment tree below root, excluding root itself.
Data structure kept when we are waiting for an acknowledgement.
struct PendingMessage * tail_frag
Tail of a MDLL of fragments created for this core message.
struct QueueEntry * qe
Set to non-NULL value if this message is currently being given to a communicator and we are awaiting ...
struct PendingMessage * head_frag
Head of a MDLL of fragments created for this core message.
struct PendingAcknowledgement * pa_tail
Tail of DLL of PAs for this pending message.
struct PendingAcknowledgement * pa_head
Head of DLL of PAs for this pending message.
uint64_t mid
Message ID used for this message with the queue used for transmission.
struct PendingMessage * pm
Pending message this entry is for, or NULL for none.
struct Queue * queue
Queue this entry is queued with.
struct QueueEntry * queue_tail
End of DLL of unacked transmission requests.
struct QueueEntry * queue_head
Head of DLL of unacked transmission requests.

References GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_MDLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, PendingMessage::head_frag, QueueEntry::mid, PendingMessage::pa_head, PendingMessage::pa_tail, PendingAcknowledgement::pm, QueueEntry::pm, pm, PendingMessage::qe, QueueEntry::queue, Queue::queue_head, Queue::queue_tail, and PendingMessage::tail_frag.

Referenced by free_pending_message().

Here is the caller graph for this function:

◆ free_pending_message()

static void free_pending_message ( struct PendingMessage pm)
static

Release memory associated with pm and remove pm from associated data structures.

pm must be a top-level pending message and not a fragment in the tree. The entire tree is freed (if applicable).

Parameters
pmthe pending message to free

Definition at line 2973 of file gnunet-service-tng.c.

2974 {
2975  struct TransportClient *tc = pm->client;
2976  struct VirtualLink *vl = pm->vl;
2977  struct PendingAcknowledgement *pa;
2978 
2980  "Freeing pm %p\n",
2981  pm);
2982  if (NULL != tc)
2983  {
2985  tc->details.core.pending_msg_head,
2986  tc->details.core.pending_msg_tail,
2987  pm);
2988  }
2989  if ((NULL != vl) && (NULL == pm->frag_parent))
2990  {
2992  "Removing pm %lu\n",
2993  pm->logging_uuid);
2995  vl->pending_msg_head,
2996  vl->pending_msg_tail,
2997  pm);
2998  }
2999  while (NULL != (pa = pm->pa_head))
3000  {
3001  if (NULL == pa)
3003  "free pending pa null\n");
3004  if (NULL == pm->pa_tail)
3006  "free pending pa_tail null\n");
3007  if (NULL == pa->prev_pa)
3009  "free pending pa prev null\n");
3010  if (NULL == pa->next_pa)
3012  "free pending pa next null\n");
3013  GNUNET_CONTAINER_MDLL_remove (pm, pm->pa_head, pm->pa_tail, pa);
3014  pa->pm = NULL;
3015  }
3016 
3018  if (NULL != pm->qe)
3019  {
3020  GNUNET_assert (pm == pm->qe->pm);
3021  pm->qe->pm = NULL;
3022  GNUNET_CONTAINER_DLL_remove (pm->qe->queue->queue_head,
3023  pm->qe->queue->queue_tail,
3024  pm->qe);
3026  "Removing QueueEntry MID %llu from queue\n",
3027  pm->qe->mid);
3028  GNUNET_free (pm->qe);
3029  }
3030  if (NULL != pm->bpm)
3031  {
3032  free_fragment_tree (pm->bpm);
3033  GNUNET_free (pm->bpm);
3034  }
3035  if (NULL == pm)
3037  "free pending pm null\n");
3038  GNUNET_free (pm);
3039 }
static struct GNUNET_SCHEDULER_TaskContext tc
Task context of the current task.
Definition: scheduler.c:423
struct PendingAcknowledgement * next_pa
Pointers for the DLL of all pending acknowledgements.
struct PendingAcknowledgement * prev_pa
Pointers for the DLL of all pending acknowledgements.
Client connected to the transport service.

References free_fragment_tree(), GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_MDLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, PendingAcknowledgement::next_pa, VirtualLink::pending_msg_head, VirtualLink::pending_msg_tail, PendingAcknowledgement::pm, pm, PendingAcknowledgement::prev_pa, and tc.

Referenced by client_send_response(), completed_pending_message(), free_virtual_link(), and transmit_on_queue().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ free_reassembly_context()

static void free_reassembly_context ( struct ReassemblyContext rc)
static

Free rc.

Parameters
rcdata structure to free

Definition at line 3048 of file gnunet-service-tng.c.

3049 {
3050  struct VirtualLink *vl = rc->virtual_link;
3051 
3055  rc->msg_uuid.uuid,
3056  rc));
3057  GNUNET_free (rc);
3058 }
@ GNUNET_OK
Definition: gnunet_common.h:95
int GNUNET_CONTAINER_multihashmap32_remove(struct GNUNET_CONTAINER_MultiHashMap32 *map, uint32_t key, const void *value)
Remove the given key-value pair from the map.
void * GNUNET_CONTAINER_heap_remove_node(struct GNUNET_CONTAINER_HeapNode *node)
Removes a node from the heap.
uint64_t uuid
Unique value, generated by incrementing the message_uuid_ctr of struct Neighbour.
struct GNUNET_CONTAINER_HeapNode * hn
Entry in the reassembly heap (sorted by expiration).
struct MessageUUIDP msg_uuid
Original message ID for of the message that all the fragments belong to.
struct VirtualLink * virtual_link
Which neighbour is this context for?

References GNUNET_assert, GNUNET_CONTAINER_heap_remove_node(), GNUNET_CONTAINER_multihashmap32_remove(), GNUNET_free, GNUNET_OK, ReassemblyContext::hn, ReassemblyContext::msg_uuid, VirtualLink::reassembly_map, MessageUUIDP::uuid, and ReassemblyContext::virtual_link.

Referenced by free_reassembly_cb(), handle_fragment_box(), and reassembly_cleanup_task().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ reassembly_cleanup_task()

static void reassembly_cleanup_task ( void *  cls)
static

Task run to clean up reassembly context of a neighbour that have expired.

Parameters
clsa struct Neighbour

Definition at line 3067 of file gnunet-service-tng.c.

3068 {
3069  struct VirtualLink *vl = cls;
3070  struct ReassemblyContext *rc;
3071 
3072  vl->reassembly_timeout_task = NULL;
3073  while (NULL != (rc = GNUNET_CONTAINER_heap_peek (vl->reassembly_heap)))
3074  {
3076  .rel_value_us)
3077  {
3079  continue;
3080  }
3081  GNUNET_assert (NULL == vl->reassembly_timeout_task);
3085  vl);
3086  return;
3087  }
3088 }
static void reassembly_cleanup_task(void *cls)
Task run to clean up reassembly context of a neighbour that have expired.
static void free_reassembly_context(struct ReassemblyContext *rc)
Free rc.
void * GNUNET_CONTAINER_heap_peek(const struct GNUNET_CONTAINER_Heap *heap)
Get element stored at the root of heap.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_at(struct GNUNET_TIME_Absolute at, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run at the specified time.
Definition: scheduler.c:1231
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:404
uint64_t rel_value_us
The actual value.
Information we keep for a message that we are reassembling.
struct GNUNET_TIME_Absolute reassembly_timeout
At what time will we give up reassembly of this message?

References free_reassembly_context(), GNUNET_assert, GNUNET_CONTAINER_heap_peek(), GNUNET_SCHEDULER_add_at(), GNUNET_TIME_absolute_get_remaining(), VirtualLink::reassembly_heap, ReassemblyContext::reassembly_timeout, VirtualLink::reassembly_timeout_task, and GNUNET_TIME_Relative::rel_value_us.

Referenced by handle_fragment_box().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ free_reassembly_cb()

static int free_reassembly_cb ( void *  cls,
uint32_t  key,
void *  value 
)
static

function called to free_reassembly_context().

Parameters
clsNULL
keyunused
valuea struct ReassemblyContext to free
Returns
GNUNET_OK (continue iteration)

Definition at line 3100 of file gnunet-service-tng.c.

3101 {
3102  struct ReassemblyContext *rc = value;
3103 
3104  (void) cls;
3105  (void) key;
3107  return GNUNET_OK;
3108 }
struct GNUNET_HashCode key
The key used in the DHT.
static char * value
Value of the record to add/remove.

References free_reassembly_context(), GNUNET_OK, key, and value.

Referenced by free_virtual_link().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ free_virtual_link()

static void free_virtual_link ( struct VirtualLink vl)
static

Free virtual link.

Parameters
vllink data to free

Definition at line 3117 of file gnunet-service-tng.c.

3118 {
3119  struct PendingMessage *pm;
3120  struct CoreSentContext *csc;
3121 
3123  "free virtual link %p\n",
3124  vl);
3125 
3126  if (NULL != vl->reassembly_map)
3127  {
3130  NULL);
3132  vl->reassembly_map = NULL;
3134  vl->reassembly_heap = NULL;
3135  }
3136  if (NULL != vl->reassembly_timeout_task)
3137  {
3139  vl->reassembly_timeout_task = NULL;
3140  }
3141  while (NULL != (pm = vl->pending_msg_head))
3145  if (NULL != vl->visibility_task)
3146  {
3148  vl->visibility_task = NULL;
3149  }
3150  if (NULL != vl->fc_retransmit_task)
3151  {
3153  vl->fc_retransmit_task = NULL;
3154  }
3155  while (NULL != (csc = vl->csc_head))
3156  {
3158  GNUNET_assert (vl == csc->vl);
3159  csc->vl = NULL;
3160  }
3161  GNUNET_break (NULL == vl->n);
3162  GNUNET_break (NULL == vl->dv);
3163  GNUNET_free (vl);
3164 }
static void free_pending_message(struct PendingMessage *pm)
Release memory associated with pm and remove pm from associated data structures.
static int free_reassembly_cb(void *cls, uint32_t key, void *value)
function called to free_reassembly_context().
static struct GNUNET_CONTAINER_MultiPeerMap * links
Map from PIDs to struct VirtualLink entries describing links CORE knows to exist.
int GNUNET_CONTAINER_multihashmap32_iterate(struct GNUNET_CONTAINER_MultiHashMap32 *map, GNUNET_CONTAINER_MulitHashMapIterator32Callback it, void *it_cls)
Iterate over all entries in the map.
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.
void GNUNET_CONTAINER_multihashmap32_destroy(struct GNUNET_CONTAINER_MultiHashMap32 *map)
Destroy a 32-bit key hash map.
void GNUNET_CONTAINER_heap_destroy(struct GNUNET_CONTAINER_Heap *heap)
Destroys the heap.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:957
Closure for core_env_sent_cb.
struct VirtualLink * vl
Virtual link this is about.

References VirtualLink::csc_head, VirtualLink::csc_tail, VirtualLink::dv, VirtualLink::fc_retransmit_task, free_pending_message(), free_reassembly_cb(), GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_heap_destroy(), GNUNET_CONTAINER_multihashmap32_destroy(), GNUNET_CONTAINER_multihashmap32_iterate(), GNUNET_CONTAINER_multipeermap_remove(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_SCHEDULER_cancel(), GNUNET_YES, links, VirtualLink::n, VirtualLink::pending_msg_head, pm, VirtualLink::reassembly_heap, VirtualLink::reassembly_map, VirtualLink::reassembly_timeout_task, VirtualLink::target, VirtualLink::visibility_task, and CoreSentContext::vl.

Referenced by check_link_down(), free_dv_route(), and free_neighbour().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ free_validation_state()

static void free_validation_state ( struct ValidationState vs)
static

Free validation state.

Parameters
vsvalidation state to free

Definition at line 3173 of file gnunet-service-tng.c.

3174 {
3175  GNUNET_assert (
3176  GNUNET_YES ==
3179  vs->hn = NULL;
3180  if (NULL != vs->sc)
3181  {
3183  "store cancel\n");
3185  vs->sc = NULL;
3186  }
3187  GNUNET_free (vs->address);
3188  GNUNET_free (vs);
3189 }
static struct GNUNET_CONTAINER_MultiPeerMap * validation_map
Map from PIDs to struct ValidationState entries describing addresses we are aware of and their validi...
void GNUNET_PEERSTORE_store_cancel(struct GNUNET_PEERSTORE_StoreContext *sc)
Cancel a store request.
struct GNUNET_PeerIdentity pid
For which peer is address to be validated (or possibly valid)? Serves as key in the validation_map.

References GNUNET_assert, GNUNET_CONTAINER_heap_remove_node(), GNUNET_CONTAINER_multipeermap_remove(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_PEERSTORE_store_cancel(), GNUNET_YES, ValidationState::pid, and validation_map.

Referenced by free_validation_state_cb(), and validation_start_cb().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ lookup_neighbour()

static struct Neighbour* lookup_neighbour ( const struct GNUNET_PeerIdentity pid)
static

Lookup neighbour for peer pid.

Parameters
pidneighbour to look for
Returns
NULL if we do not have this peer as a neighbour

Definition at line 3199 of file gnunet-service-tng.c.

3200 {
3202 }
static struct GNUNET_CONTAINER_MultiPeerMap * neighbours
Map from PIDs to struct Neighbour entries.
static struct GNUNET_PeerIdentity pid
Identity of the peer we transmit to / connect to.
void * GNUNET_CONTAINER_multipeermap_get(const struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key)
Given a key find a value in the map matching the key.

References GNUNET_CONTAINER_multipeermap_get(), neighbours, and pid.

Referenced by find_queue(), forward_dv_learn(), handle_add_queue_message(), handle_communicator_backchannel(), handle_dv_box(), handle_dv_learn(), handle_validation_challenge(), learn_dv_path(), and transmit_cummulative_ack_cb().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ lookup_virtual_link()

static struct VirtualLink* lookup_virtual_link ( const struct GNUNET_PeerIdentity pid)
static

Lookup virtual link for peer pid.

Parameters
pidvirtual link to look for
Returns
NULL if we do not have this peer as a virtual link

Definition at line 3212 of file gnunet-service-tng.c.

3213 {
3215 }

References GNUNET_CONTAINER_multipeermap_get(), links, and pid.

Referenced by activate_core_visible_dv_path(), check_vl_transmission(), forward_dv_learn(), free_queue(), handle_client_recv_ok(), handle_client_send(), handle_communicator_backchannel(), handle_flow_control(), handle_fragment_box(), handle_raw_message(), handle_validation_challenge(), handle_validation_response(), and transmit_cummulative_ack_cb().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ free_distance_vector_hop()

static void free_distance_vector_hop ( struct DistanceVectorHop dvh)
static

Free a @dvh.

Callers MAY want to check if this was the last path to the target, and if so call free_dv_route to also free the associated DV entry in dv_routes (if not, the associated scheduler job should eventually take care of it).

Parameters
dvhhop to free

Definition at line 3261 of file gnunet-service-tng.c.

3262 {
3263  struct Neighbour *n = dvh->next_hop;
3264  struct DistanceVector *dv = dvh->dv;
3265  struct PendingAcknowledgement *pa;
3266 
3267  while (NULL != (pa = dvh->pa_head))
3268  {
3270  pa->dvh = NULL;
3271  }
3272  GNUNET_CONTAINER_MDLL_remove (neighbour, n->dv_head, n->dv_tail, dvh);
3274  GNUNET_free (dvh);
3275 }
struct Neighbour * next_hop
What would be the next hop to target?
struct DistanceVector * dv
Distance vector entry this hop belongs with.
Entry in our dv_routes table, representing a (set of) distance vector routes to a particular peer.
struct DistanceVectorHop * dv_head
Known paths to target.
struct DistanceVectorHop * dv_tail
Known paths to target.
A connected controller which is not our child.
struct DistanceVectorHop * dv_tail
Tail of MDLL of DV hops that have this neighbour as next hop.
struct DistanceVectorHop * dv_head
Head of MDLL of DV hops that have this neighbour as next hop.

References DistanceVectorHop::dv, DistanceVector::dv_head, Neighbour::dv_head, DistanceVector::dv_tail, Neighbour::dv_tail, PendingAcknowledgement::dvh, GNUNET_CONTAINER_MDLL_remove, GNUNET_free, DistanceVectorHop::next_hop, DistanceVectorHop::pa_head, and DistanceVectorHop::pa_tail.

Referenced by free_dv_route(), free_neighbour(), and path_cleanup_cb().

Here is the caller graph for this function:

◆ check_link_down()

static void check_link_down ( void *  cls)
static

Task run to check whether the hops of the cls still are validated, or if we need to core about disconnection.

Parameters
clsa struct VirtualLink

Definition at line 3672 of file gnunet-service-tng.c.

3673 {
3674  struct VirtualLink *vl = cls;
3675  struct DistanceVector *dv = vl->dv;
3676  struct Neighbour *n = vl->n;
3677  struct GNUNET_TIME_Absolute dvh_timeout;
3678  struct GNUNET_TIME_Absolute q_timeout;
3679 
3681  "Checking if link is down\n");
3682  vl->visibility_task = NULL;
3683  dvh_timeout = GNUNET_TIME_UNIT_ZERO_ABS;
3684  if (NULL != dv)
3685  {
3686  for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos;
3687  pos = pos->next_dv)
3688  dvh_timeout = GNUNET_TIME_absolute_max (dvh_timeout,
3689  pos->path_valid_until);
3690  if (0 == GNUNET_TIME_absolute_get_remaining (dvh_timeout).rel_value_us)
3691  {
3692  vl->dv->vl = NULL;
3693  vl->dv = NULL;
3694  }
3695  }
3696  q_timeout = GNUNET_TIME_UNIT_ZERO_ABS;
3697  for (struct Queue *q = n->queue_head; NULL != q; q = q->next_neighbour)
3698  q_timeout = GNUNET_TIME_absolute_max (q_timeout, q->validated_until);
3699  if (0 == GNUNET_TIME_absolute_get_remaining (q_timeout).rel_value_us)
3700  {
3701  vl->n->vl = NULL;
3702  vl->n = NULL;
3703  }
3704  if ((NULL == vl->n) && (NULL == vl->dv))
3705  {
3707  free_virtual_link (vl);
3708  return;
3709  }
3710  vl->visibility_task =
3711  GNUNET_SCHEDULER_add_at (GNUNET_TIME_absolute_max (q_timeout, dvh_timeout),
3712  &check_link_down,
3713  vl);
3714 }
static void cores_send_disconnect_info(const struct GNUNET_PeerIdentity *pid)
Send message to CORE clients that we lost a connection.
static void free_virtual_link(struct VirtualLink *vl)
Free virtual link.
static void check_link_down(void *cls)
Task run to check whether the hops of the cls still are validated, or if we need to core about discon...
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_max(struct GNUNET_TIME_Absolute t1, struct GNUNET_TIME_Absolute t2)
Return the maximum of two absolute time values.
Definition: time.c:366
#define GNUNET_TIME_UNIT_ZERO_ABS
Absolute time zero.
struct DistanceVectorHop * next_dv
Kept in a MDLL, sorted by timeout.
struct VirtualLink * vl
Do we have a confirmed working queue and are thus visible to CORE? If so, this is the virtual link,...
struct VirtualLink * vl
Do we have a confirmed working queue and are thus visible to CORE? If so, this is the virtual link,...
struct Queue * queue_head
Head of DLL of queues to this peer.

References cores_send_disconnect_info(), VirtualLink::dv, DistanceVector::dv_head, free_virtual_link(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_SCHEDULER_add_at(), GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_absolute_max(), GNUNET_TIME_UNIT_ZERO_ABS, VirtualLink::n, DistanceVectorHop::next_dv, q, Neighbour::queue_head, VirtualLink::target, VirtualLink::visibility_task, DistanceVector::vl, and Neighbour::vl.

Referenced by activate_core_visible_dv_path(), free_dv_route(), free_neighbour(), free_queue(), and handle_validation_response().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ cores_send_disconnect_info()

static void cores_send_disconnect_info ( const struct GNUNET_PeerIdentity pid)
static

Send message to CORE clients that we lost a connection.

Parameters
pidpeer the connection was for

Definition at line 3294 of file gnunet-service-tng.c.

3295 {
3297  "Informing CORE clients about disconnect from %s\n",
3298  GNUNET_i2s (pid));
3299  for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next)
3300  {
3301  struct GNUNET_MQ_Envelope *env;
3302  struct DisconnectInfoMessage *dim;
3303 
3304  if (CT_CORE != tc->type)
3305  continue;
3307  dim->peer = *pid;
3308  GNUNET_MQ_send (tc->mq, env);
3309  }
3310 }
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
static struct TransportClient * clients_head
Head of linked list of all clients to this service.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:302
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
#define GNUNET_MESSAGE_TYPE_TRANSPORT_DISCONNECT
Message from TRANSPORT notifying about a client that disconnected from us.
Message from the transport service to the library informing about disconnects.
Definition: transport.h:150
struct GNUNET_PeerIdentity peer
Who got disconnected?
Definition: transport.h:164

References clients_head, CT_CORE, env, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_TRANSPORT_DISCONNECT, GNUNET_MQ_msg, GNUNET_MQ_send(), DisconnectInfoMessage::peer, pid, and tc.

Referenced by check_link_down(), free_dv_route(), and free_neighbour().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ free_dv_route()

static void free_dv_route ( struct DistanceVector dv)
static

Free entry in dv_routes.

First frees all hops to the target, and if there are no entries left, frees dv as well.

Parameters
dvroute to free

Definition at line 3320 of file gnunet-service-tng.c.

3321 {
3322  struct DistanceVectorHop *dvh;
3323 
3324  while (NULL != (dvh = dv->dv_head))
3326  if (NULL == dv->dv_head)
3327  {
3328  struct VirtualLink *vl;
3329 
3330  GNUNET_assert (
3331  GNUNET_YES ==
3333  if (NULL != (vl = dv->vl))
3334  {
3335  GNUNET_assert (dv == vl->dv);
3336  vl->dv = NULL;
3337  if (NULL == vl->n)
3338  {
3340  free_virtual_link (vl);
3341  }
3342  else
3343  {
3346  }
3347  dv->vl = NULL;
3348  }
3349 
3350  if (NULL != dv->timeout_task)
3351  {
3353  dv->timeout_task = NULL;
3354  }
3355  GNUNET_free (dv);
3356  }
3357 }
static void free_distance_vector_hop(struct DistanceVectorHop *dvh)
Free a @dvh.
static struct GNUNET_CONTAINER_MultiPeerMap * dv_routes
Map from PIDs to struct DistanceVector entries describing known paths to the peer.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1281
struct GNUNET_PeerIdentity target
To which peer is this a route?
struct GNUNET_SCHEDULER_Task * timeout_task
Task scheduled to purge expired paths from dv_head MDLL.

References check_link_down(), cores_send_disconnect_info(), VirtualLink::dv, DistanceVectorHop::dv, DistanceVector::dv_head, dv_routes, free_distance_vector_hop(), free_virtual_link(), GNUNET_assert, GNUNET_CONTAINER_multipeermap_remove(), GNUNET_free, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), GNUNET_YES, VirtualLink::n, DistanceVector::target, DistanceVector::timeout_task, VirtualLink::visibility_task, and DistanceVector::vl.

Referenced by free_dv_routes_cb(), free_neighbour(), and path_cleanup_cb().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ notify_monitor()

static void notify_monitor ( struct TransportClient tc,
const struct GNUNET_PeerIdentity peer,
const char *  address,
enum GNUNET_NetworkType  nt,
const struct MonitorEvent me 
)
static

Notify monitor tc about an event.

That tc cares about the event has already been checked.

Send tc information in me about a peer's status with respect to some address to all monitors that care.

Parameters
tcmonitor to inform
peerpeer the information is about
addressaddress the information is about
ntnetwork type associated with address
medetailed information to transmit

Definition at line 3374 of file gnunet-service-tng.c.

3379 {
3380  struct GNUNET_MQ_Envelope *env;
3381  struct GNUNET_TRANSPORT_MonitorData *md;
3382  size_t addr_len = strlen (address) + 1;
3383 
3384  env = GNUNET_MQ_msg_extra (md,
3385  addr_len,
3387  md->nt = htonl ((uint32_t) nt);
3388  md->peer = *peer;
3389  md->last_validation = GNUNET_TIME_absolute_hton (me->last_validation);
3390  md->valid_until = GNUNET_TIME_absolute_hton (me->valid_until);
3391  md->next_validation = GNUNET_TIME_absolute_hton (me->next_validation);
3392  md->rtt = GNUNET_TIME_relative_hton (me->rtt);
3393  md->cs = htonl ((uint32_t) me->cs);
3394  md->num_msg_pending = htonl (me->num_msg_pending);
3395  md->num_bytes_pending = htonl (me->num_bytes_pending);
3396  memcpy (&md[1], address, addr_len);
3397  GNUNET_MQ_send (tc->mq, env);
3398 }
static char * address
GNS address for this phone.
static GNUNET_NETWORK_STRUCT_END struct GNUNET_PeerIdentity me
Our own peer identity.
static struct GNUNET_NAT_AUTO_Test * nt
Handle to a NAT test operation.
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct.
Definition: gnunet_mq_lib.h:52
#define GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_DATA
Message sent to indicate to a monitor about events.
struct GNUNET_TIME_RelativeNBO GNUNET_TIME_relative_hton(struct GNUNET_TIME_Relative a)
Convert relative time to network byte order.
Definition: time.c:617
struct GNUNET_TIME_AbsoluteNBO GNUNET_TIME_absolute_hton(struct GNUNET_TIME_Absolute a)
Convert absolute time to network byte order.
Definition: time.c:637
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.

References address, env, GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_DATA, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_TIME_absolute_hton(), GNUNET_TIME_relative_hton(), me, nt, peer, and tc.

Referenced by notify_client_queues(), and notify_monitors().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ notify_monitors()

static void notify_monitors ( const struct GNUNET_PeerIdentity peer,
const char *  address,
enum GNUNET_NetworkType  nt,
const struct MonitorEvent me 
)
static

Send information in me about a peer's status with respect to some address to all monitors that care.

Parameters
peerpeer the information is about
addressaddress the information is about
ntnetwork type associated with address
medetailed information to transmit

Definition at line 3411 of file gnunet-service-tng.c.

3415 {
3416  for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next)
3417  {
3418  if (CT_MONITOR != tc->type)
3419  continue;
3420  if (tc->details.monitor.one_shot)
3421  continue;
3422  if ((GNUNET_NO == GNUNET_is_zero (&tc->details.monitor.peer)) &&
3423  (0 != GNUNET_memcmp (&tc->details.monitor.peer, peer)))
3424  continue;
3426  }
3427 }
static void notify_monitor(struct TransportClient *tc, const struct GNUNET_PeerIdentity *peer, const char *address, enum GNUNET_NetworkType nt, const struct MonitorEvent *me)
Notify monitor tc about an event.
#define GNUNET_is_zero(a)
Check that memory in a is all zeros.
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
@ GNUNET_NO
Definition: gnunet_common.h:94

References address, clients_head, CT_MONITOR, GNUNET_is_zero, GNUNET_memcmp, GNUNET_NO, me, notify_monitor(), nt, peer, and tc.

Referenced by free_queue(), and handle_add_queue_message().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ client_connect_cb()

static void* client_connect_cb ( void *  cls,
struct GNUNET_SERVICE_Client client,
struct GNUNET_MQ_Handle mq 
)
static

Called whenever a client connects.

Allocates our data structures associated with that client.

Parameters
clsclosure, NULL
clientidentification of the client
mqmessage queue for the client
Returns
our struct TransportClient

Definition at line 3440 of file gnunet-service-tng.c.

3443 {
3444  struct TransportClient *tc;
3445 
3446  (void) cls;
3447  tc = GNUNET_new (struct TransportClient);
3448  tc->client = client;
3449  tc->mq = mq;
3452  "Client %p of type %u connected\n",
3453  tc,
3454  tc->type);
3455  return tc;
3456 }
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
static struct TransportClient * clients_tail
Tail of linked list of all clients to this service.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_SERVICE_Client * client
Handle to the client.

References TransportClient::client, clients_head, clients_tail, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_new, mq, and tc.

◆ free_neighbour()

static void free_neighbour ( struct Neighbour neighbour)
static

Release memory used by neighbour.

Parameters
neighbourneighbour entry to free

Definition at line 3465 of file gnunet-service-tng.c.

3466 {
3467  struct DistanceVectorHop *dvh;
3468  struct VirtualLink *vl;
3469 
3470  GNUNET_assert (NULL == neighbour->queue_head);
3473  &neighbour->pid,
3474  neighbour));
3476  "Freeing neighbour\n");
3477  while (NULL != (dvh = neighbour->dv_head))
3478  {
3479  struct DistanceVector *dv = dvh->dv;
3480 
3482  if (NULL == dv->dv_head)
3483  free_dv_route (dv);
3484  }
3485  if (NULL != neighbour->get)
3486  {
3487  GNUNET_PEERSTORE_iterate_cancel (neighbour->get);
3488  neighbour->get = NULL;
3489  }
3490  if (NULL != neighbour->sc)
3491  {
3493  "store cancel\n");
3494  GNUNET_PEERSTORE_store_cancel (neighbour->sc);
3495  neighbour->sc = NULL;
3496  }
3497  if (NULL != (vl = neighbour->vl))
3498  {
3499  GNUNET_assert (neighbour == vl->n);
3500  vl->n = NULL;
3501  if (NULL == vl->dv)
3502  {
3505  }
3506  else
3507  {
3510  }
3511  neighbour->vl = NULL;
3512  }
3513  GNUNET_free (neighbour);
3514 }
static void free_dv_route(struct DistanceVector *dv)
Free entry in dv_routes.
void GNUNET_PEERSTORE_iterate_cancel(struct GNUNET_PEERSTORE_IterateContext *ic)
Cancel an iterate request Please do not call after the iterate request is done.
struct GNUNET_PEERSTORE_StoreContext * sc
Handle to a PEERSTORE store operation to store this pid's last_dv_learn_monotime.
struct GNUNET_PeerIdentity pid
Which peer is this about?
struct GNUNET_PEERSTORE_IterateContext * get
Handle for an operation to fetch last_dv_learn_monotime information from the PEERSTORE,...

References check_link_down(), cores_send_disconnect_info(), VirtualLink::dv, DistanceVectorHop::dv, DistanceVector::dv_head, Neighbour::dv_head, free_distance_vector_hop(), free_dv_route(), free_virtual_link(), Neighbour::get, GNUNET_assert, GNUNET_CONTAINER_multipeermap_remove(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_PEERSTORE_iterate_cancel(), GNUNET_PEERSTORE_store_cancel(), GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), GNUNET_YES, VirtualLink::n, neighbours, Neighbour::pid, Neighbour::queue_head, Neighbour::sc, VirtualLink::target, VirtualLink::visibility_task, DistanceVector::vl, and Neighbour::vl.

Referenced by free_neighbour_cb(), and free_queue().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ core_send_connect_info()

static void core_send_connect_info ( struct TransportClient tc,
const struct GNUNET_PeerIdentity pid 
)
static

Send message to CORE clients that we lost a connection.

Parameters
tcclient to inform (must be CORE client)
pidpeer the connection is for

Definition at line 3524 of file gnunet-service-tng.c.

3526 {
3527  struct GNUNET_MQ_Envelope *env;
3528  struct ConnectInfoMessage *cim;
3529 
3530  GNUNET_assert (CT_CORE == tc->type);
3532  cim->id = *pid;
3533  GNUNET_MQ_send (tc->mq, env);
3534 }
#define GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT
Message from TRANSPORT notifying about a client that connected to us.
Message from the transport service to the library informing about neighbors.
Definition: transport.h:118
struct GNUNET_PeerIdentity id
Identity of the new neighbour.
Definition: transport.h:141

References CT_CORE, env, GNUNET_assert, GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT, GNUNET_MQ_msg, GNUNET_MQ_send(), ConnectInfoMessage::id, pid, and tc.

Referenced by cores_send_connect_info(), and notify_client_connect_info().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ cores_send_connect_info()

static void cores_send_connect_info ( const struct GNUNET_PeerIdentity pid)
static

Send message to CORE clients that we gained a connection.

Parameters
pidpeer the queue was for

Definition at line 3543 of file gnunet-service-tng.c.

3544 {
3546  "Informing CORE clients about connection to %s\n",
3547  GNUNET_i2s (pid));
3548  for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next)
3549  {
3550  if (CT_CORE != tc->type)
3551  continue;
3553  }
3554 }
static void core_send_connect_info(struct TransportClient *tc, const struct GNUNET_PeerIdentity *pid)
Send message to CORE clients that we lost a connection.

References clients_head, core_send_connect_info(), CT_CORE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, pid, and tc.

Referenced by activate_core_visible_dv_path(), and handle_validation_response().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ transmit_on_queue()

static void transmit_on_queue ( void *  cls)
static

We believe we are ready to transmit a message on a queue.

We believe we are ready to transmit a struct PendingMessage on a queue, the big question is which one! We need to see if there is one pending that is allowed by flow control and congestion control and (ideally) matches our queue's performance profile.

Gives the message to the communicator for transmission (updating the tracker, and re-scheduling itself if applicable).

Parameters
clsthe struct Queue to process transmissions for

If such a message is found, we give the message to the communicator for transmission (updating the tracker, and re-scheduling ourselves if applicable).

If no such message is found, the queue's idle field must be set to GNUNET_YES.

Parameters
clsthe struct Queue to process transmissions for

Definition at line 9528 of file gnunet-service-tng.c.

9529 {
9530  struct Queue *queue = cls;
9531  struct Neighbour *n = queue->neighbour;
9533  struct PendingMessage *pm;
9534 
9535  queue->transmit_task = NULL;
9536  if (NULL == n->vl)
9537  {
9539  "Virtual link `%s' is down, cannot have PM for queue `%s'\n",
9540  GNUNET_i2s (&n->pid),
9541  queue->address);
9542  queue->idle = GNUNET_YES;
9543  return;
9544  }
9545  memset (&sc, 0, sizeof(sc));
9546  select_best_pending_from_link (&sc, queue, n->vl, NULL, 0);
9547  if (NULL == sc.best)
9548  {
9549  /* Also look at DVH that have the n as first hop! */
9550  for (struct DistanceVectorHop *dvh = n->dv_head; NULL != dvh;
9551  dvh = dvh->next_neighbour)
9552  {
9554  queue,
9555  dvh->dv->vl,
9556  dvh,
9557  sizeof(struct GNUNET_PeerIdentity)
9558  * (1 + dvh->distance)
9559  + sizeof(struct TransportDVBoxMessage)
9560  + sizeof(struct TransportDVBoxPayloadP));
9561  }
9562  }
9563  if (NULL == sc.best)
9564  {
9565  /* no message pending, nothing to do here! */
9567  "No pending messages, queue `%s' to %s now idle\n",
9568  queue->address,
9569  GNUNET_i2s (&n->pid));
9570  if (GNUNET_YES == sc.to_early)
9571  schedule_transmit_on_queue (sc.to_early_retry_delay,
9572  queue,
9574  queue->idle = GNUNET_YES;
9575  return;
9576  }
9577  /* There is a message pending, we are certainly not idle */
9578  queue->idle = GNUNET_NO;
9579 
9580  /* Given selection in `sc`, do transmission */
9581  pm = sc.best;
9583  "Selected message <%llu>\n",
9584  pm->logging_uuid);
9585  if (NULL != sc.dvh)
9586  {
9588  "Is this %u a DV box?\n",
9589  pm->pmt);
9590  GNUNET_assert (PMT_DV_BOX != pm->pmt);
9591  if ((NULL != sc.best->bpm) && (sc.best->bpm->used_dvh != sc.dvh))
9592  {
9594  "Discard old box, because we have a new DV path.\n");
9595  free_pending_message (sc.best->bpm);
9596  sc.best->bpm = NULL;
9597  }
9598 
9599  if (NULL == sc.best->bpm)
9600  {
9602  "encapsulate_for_dv 2\n");
9603  encapsulate_for_dv (sc.dvh->dv,
9604  1,
9605  &sc.dvh,
9606  (const struct GNUNET_MessageHeader *) &sc.best[1],
9607  &extract_box_cb,
9608  &sc,
9609  RMO_NONE,
9610  GNUNET_NO);
9611  GNUNET_assert (NULL != sc.best->bpm);
9613  "%u %u %u %u %u\n",
9614  sizeof(struct GNUNET_PeerIdentity),
9615  sizeof(struct TransportDVBoxMessage),
9616  sizeof(struct TransportDVBoxPayloadP),
9617  sizeof(struct TransportFragmentBoxMessage),
9618  ((const struct GNUNET_MessageHeader *) &sc.best[1])->size);
9619  sc.best->bpm->used_dvh = sc.dvh;
9620  }
9621  pm = sc.best->bpm;
9622  }
9623  if (GNUNET_YES == sc.frag)
9624  {
9625  pm = fragment_message (queue, sc.dvh, pm);
9626  if (NULL == pm)
9627  {
9629  "Fragmentation failed queue %s to %s for <%llu>, trying again\n",
9630  queue->address,
9631  GNUNET_i2s (&n->pid),
9632  sc.best->logging_uuid);
9634  queue,
9636  return;
9637  }
9638  }
9639  else if (GNUNET_YES == sc.relb)
9640  {
9641  pm = reliability_box_message (queue, sc.dvh, pm);
9642  if (NULL == pm)
9643  {
9644  /* Reliability boxing failed, try next message... */
9645  GNUNET_log (
9647  "Reliability boxing failed queue %s to %s for <%llu>, trying again\n",
9648  queue->address,
9649  GNUNET_i2s (&n->pid),
9650  sc.best->logging_uuid);
9652  queue,
9654  return;
9655  }
9656  }
9657 
9658  /* Pass 'pm' for transission to the communicator */
9659  GNUNET_log (
9661  "Passing message <%llu> to queue %s for peer %s (considered %u others)\n",
9662  pm->logging_uuid,
9663  queue->address,
9664  GNUNET_i2s (&n->pid),
9665  sc.consideration_counter);
9666 
9667  /* Flow control: increment amount of traffic sent; if we are routing
9668  via DV (and thus the ultimate target of the pending message is for
9669  a different virtual link than the one of the queue), then we need
9670  to use up not only the window of the direct link but also the
9671  flow control window for the DV link! */
9672  pm->vl->outbound_fc_window_size_used += pm->bytes_msg;
9673 
9674  if (pm->vl != queue->neighbour->vl)
9675  {
9676  /* If the virtual link of the queue differs, this better be distance
9677  vector routing! */
9678  GNUNET_assert (NULL != sc.dvh);
9679  /* If we do distance vector routing, we better not do this for a
9680  message that was itself DV-routed */
9681  GNUNET_assert (PMT_DV_BOX != sc.best->pmt);
9682  /* We use the size of the unboxed message here, to avoid counting
9683  the DV-Box header which is eaten up on the way by intermediaries */
9684  queue->neighbour->vl->outbound_fc_window_size_used += sc.best->bytes_msg;
9685  }
9686  else
9687  {
9688  GNUNET_assert (NULL == sc.dvh);
9689  }
9690 
9691  queue_send_msg (queue, pm, &pm[1], pm->bytes_msg);
9692 
9693  /* Check if this transmission somehow conclusively finished handing 'pm'
9694  even without any explicit ACKs */
9695  if ((PMT_CORE == pm->pmt) ||
9696  (GNUNET_TRANSPORT_CC_RELIABLE == queue->tc->details.communicator.cc))
9697  {
9699  }
9700  else
9701  {
9702  struct GNUNET_TIME_Relative wait_duration;
9703 
9704  /* Message not finished, waiting for acknowledgement.
9705  Update time by which we might retransmit 's' based on queue
9706  characteristics (i.e. RTT); it takes one RTT for the message to
9707  arrive and the ACK to come back in the best case; but the other
9708  side is allowed to delay ACKs by 2 RTTs, so we use 4 RTT before
9709  retransmitting.
9710 
9711  OPTIMIZE: Note that in the future this heuristic should likely
9712  be improved further (measure RTT stability, consider message
9713  urgency and size when delaying ACKs, etc.) */
9714 
9715  if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us !=
9716  queue->pd.aged_rtt.rel_value_us)
9717  wait_duration = queue->pd.aged_rtt;
9718  else
9719  wait_duration = DEFAULT_ACK_WAIT_DURATION;
9722  wait_duration, 4));
9724  wait_duration, 4);
9726  "Waiting %s (%llu) for ACK until %llu\n",
9729  queue->pd.aged_rtt, 4), GNUNET_NO),
9730  plus,
9731  next);
9734  GNUNET_TIME_relative_multiply (wait_duration,
9735  4)));
9736  }
9737  /* finally, re-schedule queue transmission task itself */
9739  queue,
9741 }
static struct GNUNET_FS_SearchContext * sc
Definition: gnunet-search.c:84
static struct PendingMessage * reliability_box_message(struct Queue *queue, struct DistanceVectorHop *dvh, struct PendingMessage *pm)
Reliability-box the given pm.
static void completed_pending_message(struct PendingMessage *pm)
We have completed transmission of pm, remove it from the transmission queues (and if it is a fragment...
static void extract_box_cb(void *cls, struct Neighbour *next_hop, const struct GNUNET_MessageHeader *hdr, enum RouteMessageOptions options)
Function to call to further operate on the now DV encapsulated message hdr, forwarding it via next_ho...
static void select_best_pending_from_link(struct PendingMessageScoreContext *sc, struct Queue *queue, struct VirtualLink *vl, struct DistanceVectorHop *dvh, size_t overhead)
Select the best pending message from vl for transmission via queue.
static void schedule_transmit_on_queue(struct GNUNET_TIME_Relative delay, struct Queue *queue, enum GNUNET_SCHEDULER_Priority p)
Called whenever something changed that might effect when we try to do the next transmission on queue ...
static struct PendingMessage * fragment_message(struct Queue *queue, struct DistanceVectorHop *dvh, struct PendingMessage *pm)
Fragment the given pm to the given mtu.
#define DEFAULT_ACK_WAIT_DURATION
Default value for how long we wait for reliability ack.
static struct GNUNET_TIME_Relative encapsulate_for_dv(struct DistanceVector *dv, unsigned int num_dvhs, struct DistanceVectorHop **dvhs, const struct GNUNET_MessageHeader *hdr, DVMessageHandler use, void *use_cls, enum RouteMessageOptions options, enum GNUNET_GenericReturnValue without_fc)
Pick a path of dv under constraints options and schedule transmission of hdr.
static void queue_send_msg(struct Queue *queue, struct PendingMessage *pm, const void *payload, size_t payload_size)
Send the message payload on queue.
static void update_pm_next_attempt(struct PendingMessage *pm, struct GNUNET_TIME_Absolute next_attempt)
Change the value of the next_attempt field of pm to next_attempt and re-order pm in the transmission ...
@ GNUNET_SCHEDULER_PRIORITY_DEFAULT
Run with the default priority (normal P2P operations).
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
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:315
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:483
#define GNUNET_TIME_UNIT_ZERO
Relative time zero.
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:570
@ GNUNET_TRANSPORT_CC_RELIABLE
Transmission is reliabile (with ACKs), e.g.
struct DistanceVectorHop * next_neighbour
Kept in a MDLL.
Header for all communications.
The identity of the host (wraps the signing key of the peer).
Time for relative time used by GNUnet, in microseconds.
Context for select_best_pending_from_link().
Outer layer of an encapsulated message send over multiple hops.
Plaintext of the variable-size payload that is encrypted within a struct TransportBackchannelEncapsul...
Outer layer of an encapsulated fragmented application message.

References completed_pending_message(), DEFAULT_ACK_WAIT_DURATION, Neighbour::dv_head, encapsulate_for_dv(), extract_box_cb(), fragment_message(), free_pending_message(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_PRIORITY_DEFAULT, GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_relative_to_absolute(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_TIME_UNIT_ZERO, GNUNET_TRANSPORT_CC_RELIABLE, GNUNET_YES, DistanceVectorHop::next_neighbour, Neighbour::pid, pm, PMT_CORE, PMT_DV_BOX, queue(), queue_send_msg(), reliability_box_message(), RMO_NONE, sc, schedule_transmit_on_queue(), select_best_pending_from_link(), update_pm_next_attempt(), and Neighbour::vl.

Referenced by schedule_transmit_on_queue().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ check_for_queue_with_higher_prio()

static unsigned int check_for_queue_with_higher_prio ( struct Queue queue,
struct Queue queue_head 
)
static

Check if the communicator has another queue with higher prio ready for sending.

Definition at line 3572 of file gnunet-service-tng.c.

3573 {
3574  for (struct Queue *s = queue_head; NULL != s;
3575  s = s->next_client)
3576  {
3577  if (s->tc->details.communicator.address_prefix !=
3578  queue->tc->details.communicator.address_prefix)
3579  {
3581  "queue address %s qid %u compare with queue: address %s qid %u\n",
3582  queue->address,
3583  queue->qid,
3584  s->address,
3585  s->qid);
3586  if ((s->priority > queue->priority) && (0 < s->q_capacity) &&
3587  (QUEUE_LENGTH_LIMIT > s->queue_length) )
3588  return GNUNET_YES;
3590  "Lower prio\n");
3591  }
3592  }
3593  return GNUNET_NO;
3594 }
static struct Queue * queue_head
Head of queue of messages to transmit.
#define QUEUE_LENGTH_LIMIT
How many messages can we have pending for a given queue (queue to a particular peer via a communicato...
struct Queue * next_client
Kept in a MDLL.

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_YES, Queue::next_client, queue(), queue_head, and QUEUE_LENGTH_LIMIT.

Referenced by schedule_transmit_on_queue().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ schedule_transmit_on_queue()

static void schedule_transmit_on_queue ( struct GNUNET_TIME_Relative  delay,
struct Queue queue,
enum GNUNET_SCHEDULER_Priority  p 
)
static

Called whenever something changed that might effect when we try to do the next transmission on queue using transmit_on_queue().

Parameters
queuethe queue to do scheduling for
ptask priority to use, if queue is scheduled

Definition at line 3605 of file gnunet-service-tng.c.

3608 {
3610  queue->tc->details.communicator.
3611  queue_head))
3612  return;
3613 
3614  if (queue->tc->details.communicator.total_queue_length >=
3616  {
3618  "Transmission throttled due to communicator queue limit\n");
3620  GST_stats,
3621  "# Transmission throttled due to communicator queue limit",
3622  1,
3623  GNUNET_NO);
3624  queue->idle = GNUNET_NO;
3625  return;
3626  }
3627  if (queue->queue_length >= QUEUE_LENGTH_LIMIT)
3628  {
3630  "Transmission throttled due to communicator queue length limit\n");
3632  "# Transmission throttled due to queue queue limit",
3633  1,
3634  GNUNET_NO);
3635  queue->idle = GNUNET_NO;
3636  return;
3637  }
3638  if (0 == queue->q_capacity)
3639  {
3641  "Transmission throttled due to communicator message queue qid %u has capacity %lu.\n",
3642  queue->qid,
3643  queue->q_capacity);
3645  "# Transmission throttled due to message queue capacity",
3646  1,
3647  GNUNET_NO);
3648  queue->idle = GNUNET_NO;
3649  return;
3650  }
3651  /* queue might indeed be ready, schedule it */
3652  if (NULL != queue->transmit_task)
3653  GNUNET_SCHEDULER_cancel (queue->transmit_task);
3654  queue->transmit_task =
3656  queue);
3658  "Considering transmission on queue `%s' QID %llu to %s\n",
3659  queue->address,
3660  (unsigned long long) queue->qid,
3661  GNUNET_i2s (&queue->neighbour->pid));
3662 }
static struct GNUNET_TIME_Relative delay
When should dkg communication start?
static unsigned int check_for_queue_with_higher_prio(struct Queue *queue, struct Queue *queue_head)
Check if the communicator has another queue with higher prio ready for sending.
#define COMMUNICATOR_TOTAL_QUEUE_LIMIT
How many messages can we have pending for a given communicator process before we start to throttle th...
static void transmit_on_queue(void *cls)
We believe we are ready to transmit a message on a queue.
static struct GNUNET_STATISTICS_Handle * GST_stats
Statistics handle.
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-uri.c:37
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed_with_priority(struct GNUNET_TIME_Relative delay, enum GNUNET_SCHEDULER_Priority priority, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1184
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.

References check_for_queue_with_higher_prio(), COMMUNICATOR_TOTAL_QUEUE_LIMIT, delay, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_add_delayed_with_priority(), GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_update(), GST_stats, p, queue(), queue_head, QUEUE_LENGTH_LIMIT, and transmit_on_queue().

Referenced by check_vl_transmission(), free_queue(), handle_add_queue_message(), handle_send_message_ack(), handle_update_queue_message(), and transmit_on_queue().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ free_queue()

static void free_queue ( struct Queue queue)
static

Free queue.

Parameters
queuethe queue to free

Definition at line 3723 of file gnunet-service-tng.c.

3724 {
3725  struct Neighbour *neighbour = queue->neighbour;
3726  struct TransportClient *tc = queue->tc;
3727  struct MonitorEvent me = { .cs = GNUNET_TRANSPORT_CS_DOWN,
3729  struct QueueEntry *qe;
3730  int maxxed;
3731  struct PendingAcknowledgement *pa;
3732  struct VirtualLink *vl;
3733 
3735  "Cleaning up queue %u\n", queue->qid);
3736  if (NULL != queue->transmit_task)
3737  {
3738  GNUNET_SCHEDULER_cancel (queue->transmit_task);
3739  queue->transmit_task = NULL;
3740  }
3741  while (NULL != (pa = queue->pa_head))
3742  {
3743  GNUNET_CONTAINER_MDLL_remove (queue, queue->pa_head, queue->pa_tail, pa);
3744  pa->queue = NULL;
3745  }
3746 
3747  GNUNET_CONTAINER_MDLL_remove (neighbour,
3748  neighbour->queue_head,
3749  neighbour->queue_tail,
3750  queue);
3752  tc->details.communicator.queue_head,
3753  tc->details.communicator.queue_tail,
3754  queue);
3755  maxxed = (COMMUNICATOR_TOTAL_QUEUE_LIMIT <=
3756  tc->details.communicator.
3757  total_queue_length);
3758  while (NULL != (qe = queue->queue_head))
3759  {
3760  GNUNET_CONTAINER_DLL_remove (queue->queue_head, queue->queue_tail, qe);
3761  queue->queue_length--;
3762  tc->details.communicator.total_queue_length--;
3763  if (NULL != qe->pm)
3764  {
3765  GNUNET_assert (qe == qe->pm->qe);
3766  qe->pm->qe = NULL;
3767  }
3768  GNUNET_free (qe);
3769  }
3770  GNUNET_assert (0 == queue->queue_length);
3771  if ((maxxed) && (COMMUNICATOR_TOTAL_QUEUE_LIMIT >
3772  tc->details.communicator.total_queue_length))
3773  {
3774  /* Communicator dropped below threshold, resume all _other_ queues */
3776  GST_stats,
3777  "# Transmission throttled due to communicator queue limit",
3778  -1,
3779  GNUNET_NO);
3780  for (struct Queue *s = tc->details.communicator.queue_head; NULL != s;
3781  s = s->next_client)
3783  s,
3785  }
3786  notify_monitors (&neighbour->pid, queue->address, queue->nt, &me);
3787  GNUNET_free (queue);
3788 
3789  vl = lookup_virtual_link (&neighbour->pid);
3790  if ((NULL != vl) && (GNUNET_YES == vl->confirmed) && (neighbour == vl->n))
3791  {
3793  check_link_down (vl);
3794  }
3795  if (NULL == neighbour->queue_head)
3796  {
3797  free_neighbour (neighbour);
3798  }
3799 }
static struct GNUNET_DATASTORE_QueueEntry * qe
Current operation.
static void free_neighbour(struct Neighbour *neighbour)
Release memory used by neighbour.
static void notify_monitors(const struct GNUNET_PeerIdentity *peer, const char *address, enum GNUNET_NetworkType nt, const struct MonitorEvent *me)
Send information in me about a peer's status with respect to some address to all monitors that care.
static struct VirtualLink * lookup_virtual_link(const struct GNUNET_PeerIdentity *pid)
Lookup virtual link for peer pid.
@ GNUNET_TRANSPORT_CS_DOWN
Connection is down.
Details about what to notify monitors about.
struct Queue * queue_tail
Tail of DLL of queues to this peer.
An entry in the operation queue.

References check_link_down(), COMMUNICATOR_TOTAL_QUEUE_LIMIT, VirtualLink::confirmed, free_neighbour(), GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_MDLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_cancel(), GNUNET_SCHEDULER_PRIORITY_DEFAULT, GNUNET_STATISTICS_update(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_TIME_UNIT_ZERO, GNUNET_TRANSPORT_CS_DOWN, GNUNET_YES, GST_stats, lookup_virtual_link(), me, VirtualLink::n, notify_monitors(), Neighbour::pid, qe, queue(), PendingAcknowledgement::queue, Neighbour::queue_head, Neighbour::queue_tail, schedule_transmit_on_queue(), tc, and VirtualLink::visibility_task.

Referenced by client_disconnect_cb(), and handle_del_queue_message().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ free_address_list_entry()

static void free_address_list_entry ( struct AddressListEntry ale)
static

Free ale.

Parameters
aleaddress list entry to free

Definition at line 3808 of file gnunet-service-tng.c.

3809 {
3810  struct TransportClient *tc = ale->tc;
3811 
3812  GNUNET_CONTAINER_DLL_remove (tc->details.communicator.addr_head,
3813  tc->details.communicator.addr_tail,
3814  ale);
3815  if (NULL != ale->sc)
3816  {
3818  "store cancel\n");
3820  ale->sc = NULL;
3821  }
3822  if (NULL != ale->st)
3823  {
3824  GNUNET_SCHEDULER_cancel (ale->st);
3825  ale->st = NULL;
3826  }
3827  GNUNET_free (ale);
3828 }
struct TransportClient * tc
Which communicator provides this address?
struct GNUNET_SCHEDULER_Task * st
Task to periodically do st operation.
struct GNUNET_PEERSTORE_StoreContext * sc
Current context for storing this address in the peerstore.

References GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_PEERSTORE_store_cancel(), GNUNET_SCHEDULER_cancel(), AddressListEntry::sc, AddressListEntry::st, AddressListEntry::tc, and tc.

Referenced by client_disconnect_cb(), and handle_del_address().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ stop_peer_request()

static int stop_peer_request ( void *  cls,
const struct GNUNET_PeerIdentity pid,
void *  value 
)
static

Stop the peer request in value.

Parameters
clsa struct TransportClient that no longer makes the request
pidthe peer's identity
valuea struct PeerRequest
Returns
GNUNET_YES (always)

Definition at line 3840 of file gnunet-service-tng.c.

3843 {
3844  struct TransportClient *tc = cls;
3845  struct PeerRequest *pr = value;
3846 
3848  pr->wc = NULL;
3849  GNUNET_assert (
3850  GNUNET_YES ==
3851  GNUNET_CONTAINER_multipeermap_remove (tc->details.application.requests,
3852  pid,
3853  pr));
3854  GNUNET_free (pr);
3855 
3856  return GNUNET_OK;
3857 }
Information per peer and request.
struct GSF_PendingRequest * pr
Handle to generic request (generic: from peer or local client).

References GNUNET_assert, GNUNET_CONTAINER_multipeermap_remove(), GNUNET_free, GNUNET_OK, GNUNET_PEERSTORE_watch_cancel(), GNUNET_YES, pid, PeerRequest::pr, tc, and value.

Referenced by client_disconnect_cb(), and handle_suggest_cancel().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ do_shutdown()

static void do_shutdown ( void *  cls)
static

Function called when the service shuts down.

Unloads our plugins and cancels pending validations.

Parameters
clsclosure, unused

Definition at line 10903 of file gnunet-service-tng.c.

10904 {
10905  struct LearnLaunchEntry *lle;
10906 
10908  "shutdown logic\n");
10909  (void) cls;
10911  &free_neighbour_cb, NULL);
10912  if (NULL != validation_task)
10913  {
10915  validation_task = NULL;
10916  }
10917  if (NULL != dvlearn_task)
10918  {
10920  dvlearn_task = NULL;
10921  }
10922  if (NULL != GST_stats)
10923  {
10925  GST_stats = NULL;
10926  }
10927  if (NULL != GST_my_private_key)
10928  {
10930  GST_my_private_key = NULL;
10931  }
10934  NULL);
10936  ack_cummulators = NULL;
10939  NULL);
10941  pending_acks = NULL;
10944  neighbours = NULL;
10947  links = NULL;
10950  NULL);
10952  backtalkers = NULL;
10955  NULL);
10957  validation_map = NULL;
10958  while (NULL != ir_head)
10960  GNUNET_assert (0 == ir_total);
10961  while (NULL != (lle = lle_head))
10962  {
10964  GNUNET_free (lle);
10965  }
10966  if (NULL != peerstore)
10967  {
10969  "Disconnecting from PEERSTORE service\n");
10971  peerstore = NULL;
10972  }
10974  dvlearn_map = NULL;
10976  validation_heap = NULL;
10979  dv_routes = NULL;
10981 }
static struct GNUNET_SCHEDULER_Task * dvlearn_task
Task run to initiate DV learning.
static struct LearnLaunchEntry * lle_tail
Tail of a DLL sorted by launch time.
static struct GNUNET_CONTAINER_Heap * validation_heap
MIN Heap sorted by "next_challenge" to struct ValidationState entries sorting addresses we are aware ...
static struct LearnLaunchEntry * lle_head
Head of a DLL sorted by launch time.
static int free_pending_ack_cb(void *cls, const struct GNUNET_Uuid *key, void *value)
Free pending acknowledgement.
static struct GNUNET_SCHEDULER_Task * validation_task
Task to run address validation.
static struct GNUNET_CRYPTO_EddsaPrivateKey * GST_my_private_key
Our private key.
static struct GNUNET_PEERSTORE_Handle * peerstore
Database for peer's HELLOs.
static int free_validation_state_cb(void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
Free validation state.
static int free_neighbour_cb(void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
Free neighbour entry.
static struct GNUNET_CONTAINER_MultiShortmap * dvlearn_map
Map from challenges to struct LearnLaunchEntry values.
static struct GNUNET_CONTAINER_MultiPeerMap * backtalkers
Map from PIDs to struct Backtalker entries.
static int free_backtalker_cb(void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
Callback to free backtalker records.
static struct GNUNET_CONTAINER_MultiPeerMap * ack_cummulators
Map from PIDs to struct AcknowledgementCummulators.
static int free_dv_routes_cb(void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
Free DV route entry.
static int free_ack_cummulator_cb(void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
Free acknowledgement cummulator.
static void free_incoming_request(struct IncomingRequest *ir)
Release ir data structure.
int GNUNET_CONTAINER_multiuuidmap_iterate(struct GNUNET_CONTAINER_MultiUuidmap *map, GNUNET_CONTAINER_MultiUuidmapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
void GNUNET_CONTAINER_multipeermap_destroy(struct GNUNET_CONTAINER_MultiPeerMap *map)
Destroy a hash map.
int GNUNET_CONTAINER_multipeermap_iterate(struct GNUNET_CONTAINER_MultiPeerMap *map, GNUNET_CONTAINER_PeerMapIterator it, void *it_cls)
Iterate over all entries in the map.
void GNUNET_CONTAINER_multiuuidmap_destroy(struct GNUNET_CONTAINER_MultiUuidmap *map)
Destroy a hash map.
void GNUNET_CONTAINER_multishortmap_destroy(struct GNUNET_CONTAINER_MultiShortmap *map)
Destroy a hash map.
unsigned int GNUNET_CONTAINER_multipeermap_size(const struct GNUNET_CONTAINER_MultiPeerMap *map)
Get the number of key-value pairs in the map.
void GNUNET_PEERSTORE_disconnect(struct GNUNET_PEERSTORE_Handle *h, int sync_first)
Disconnect from the PEERSTORE service.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:533
void GNUNET_STATISTICS_destroy(struct GNUNET_STATISTICS_Handle *h, int sync_first)
Destroy a handle (free all state associated with it).
When did we launch this DV learning activity?

References ack_cummulators, backtalkers, dv_routes, dvlearn_map, dvlearn_task, free_ack_cummulator_cb(), free_backtalker_cb(), free_dv_routes_cb(), free_incoming_request(), free_neighbour_cb(), free_pending_ack_cb(), free_validation_state_cb(), GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_heap_destroy(), GNUNET_CONTAINER_multipeermap_destroy(), GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_CONTAINER_multipeermap_size(), GNUNET_CONTAINER_multishortmap_destroy(), GNUNET_CONTAINER_multiuuidmap_destroy(), GNUNET_CONTAINER_multiuuidmap_iterate(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_NO, GNUNET_PEERSTORE_disconnect(), GNUNET_SCHEDULER_cancel(), GNUNET_SCHEDULER_shutdown(), GNUNET_STATISTICS_destroy(), GST_my_private_key, GST_stats, ir_head, ir_total, links, lle_head, lle_tail, neighbours, peerstore, pending_acks, validation_heap, validation_map, and validation_task.

Referenced by client_disconnect_cb(), and shutdown_task().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ client_disconnect_cb()

static void client_disconnect_cb ( void *  cls,
struct GNUNET_SERVICE_Client client,
void *  app_ctx 
)
static

Called whenever a client is disconnected.

Frees our resources associated with that client.

Parameters
clsclosure, NULL
clientidentification of the client
app_ctxour struct TransportClient

Definition at line 3872 of file gnunet-service-tng.c.

3875 {
3876  struct TransportClient *tc = app_ctx;
3877 
3878  (void) cls;
3879  (void) client;
3881  switch (tc->type)
3882  {
3883  case CT_NONE:
3885  "Unknown Client %p disconnected, cleaning up.\n",
3886  tc);
3887  break;
3888 
3889  case CT_CORE: {
3891  "CORE Client %p disconnected, cleaning up.\n",
3892  tc);
3893 
3894  struct PendingMessage *pm;
3895 
3896  while (NULL != (pm = tc->details.core.pending_msg_head))
3897  {
3899  tc->details.core.pending_msg_head,
3900  tc->details.core.pending_msg_tail,
3901  pm);
3902  pm->client = NULL;
3903  }
3904  }
3905  break;
3906 
3907  case CT_MONITOR:
3909  "MONITOR Client %p disconnected, cleaning up.\n",
3910  tc);
3911 
3912  break;
3913 
3914  case CT_COMMUNICATOR: {
3916  "COMMUNICATOR Client %p disconnected, cleaning up.\n",
3917  tc);
3918 
3919  struct Queue *q;
3920  struct AddressListEntry *ale;
3921 
3922  while (NULL != (q = tc->details.communicator.queue_head))
3923  free_queue (q);
3924  while (NULL != (ale = tc->details.communicator.addr_head))
3926  GNUNET_free (tc->details.communicator.address_prefix);
3927  }
3928  break;
3929 
3930  case CT_APPLICATION:
3932  "APPLICATION Client %p disconnected, cleaning up.\n",
3933  tc);
3934 
3935  GNUNET_CONTAINER_multipeermap_iterate (tc->details.application.requests,
3937  tc);
3938  GNUNET_CONTAINER_multipeermap_destroy (tc->details.application.requests);
3939  break;
3940  }
3941  GNUNET_free (tc);
3942  if ((GNUNET_YES == in_shutdown) && (NULL == clients_head))
3943  {
3945  "Our last client disconnected\n");
3946  do_shutdown (cls);
3947  }
3948 }
static void free_queue(struct Queue *queue)
Free queue.
static int stop_peer_request(void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
Stop the peer request in value.
static int in_shutdown
Indication if we have received a shutdown signal and are in the process of cleaning up.
static void do_shutdown(void *cls)
Function called when the service shuts down.
static void free_address_list_entry(struct AddressListEntry *ale)
Free ale.
@ GNUNET_ERROR_TYPE_ERROR
One of the addresses of this peer.
struct TransportClient * client
Client that issued the transmission request, if pmt is PMT_CORE.

References PendingMessage::client, TransportClient::client, clients_head, clients_tail, CT_APPLICATION, CT_COMMUNICATOR, CT_CORE, CT_MONITOR, CT_NONE, do_shutdown(), free_address_list_entry(), free_queue(), GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_MDLL_remove, GNUNET_CONTAINER_multipeermap_destroy(), GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_YES, in_shutdown, pm, q, stop_peer_request(), and tc.

Here is the call graph for this function:

◆ notify_client_connect_info()

static int notify_client_connect_info ( void *  cls,
const struct GNUNET_PeerIdentity pid,
void *  value 
)
static

Iterator telling new CORE client about all existing connections to peers.

Parameters
clsthe new struct TransportClient
pida connected peer
valuethe struct Neighbour with more information
Returns
GNUNET_OK (continue to iterate)

Definition at line 3961 of file gnunet-service-tng.c.

3964 {
3965  struct TransportClient *tc = cls;
3966 
3967  (void) value;
3969  "Telling new CORE client about existing connection to %s\n",
3970  GNUNET_i2s (pid));
3972  return GNUNET_OK;
3973 }

References core_send_connect_info(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_OK, pid, tc, and value.

Referenced by handle_client_start().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ handle_client_start()

static void handle_client_start ( void *  cls,
const struct StartMessage start 
)
static

Initialize a "CORE" client.

We got a start message from this client, so add it to the list of clients for broadcasting of inbound messages.

Parameters
clsthe client
startthe start message that was sent

Definition at line 3985 of file gnunet-service-tng.c.

3986 {
3987  struct TransportClient *tc = cls;
3988  uint32_t options;
3989 
3990  options = ntohl (start->options);
3991  if ((0 != (1 & options)) &&
3992  (0 != GNUNET_memcmp (&start->self, &GST_my_identity)))
3993  {
3994  /* client thinks this is a different peer, reject */
3995  GNUNET_break (0);
3996  GNUNET_SERVICE_client_drop (tc->client);
3997  return;
3998  }
3999  if (CT_NONE != tc->type)
4000  {
4001  GNUNET_break (0);
4002  GNUNET_SERVICE_client_drop (tc->client);
4003  return;
4004  }
4005  tc->type = CT_CORE;
4007  "New CORE client with PID %s registered\n",
4008  GNUNET_i2s (&start->self));
4011  tc);
4013 }
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
static int start
Set if we are to start default services (including ARM).
Definition: gnunet-arm.c:39
static struct GNUNET_PeerIdentity GST_my_identity
Our public key.
static int notify_client_connect_info(void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
Iterator telling new CORE client about all existing connections to peers.
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2329
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2248

References CT_CORE, CT_NONE, GNUNET_break, GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_memcmp, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GST_my_identity, neighbours, notify_client_connect_info(), options, start, and tc.

Here is the call graph for this function:

◆ check_client_send()

static int check_client_send ( void *  cls,
const struct OutboundMessage obm 
)
static

Client asked for transmission to a peer.

Process the request.

Parameters
clsthe client
obmthe send message that was sent

Definition at line 4023 of file gnunet-service-tng.c.

4024 {
4025  struct TransportClient *tc = cls;
4026  uint16_t size;
4027  const struct GNUNET_MessageHeader *obmm;
4028 
4029  if (CT_CORE != tc->type)
4030  {
4031  GNUNET_break (0);
4032  return GNUNET_SYSERR;
4033  }
4034  size = ntohs (obm->header.size) - sizeof(struct OutboundMessage);
4035  if (size < sizeof(struct GNUNET_MessageHeader))
4036  {
4037  GNUNET_break (0);
4038  return GNUNET_SYSERR;
4039  }
4040  obmm = (const struct GNUNET_MessageHeader *) &obm[1];
4041  if (size != ntohs (obmm->size))
4042  {
4043  GNUNET_break (0);
4044  return GNUNET_SYSERR;
4045  }
4046  return GNUNET_OK;
4047 }
@ GNUNET_SYSERR
Definition: gnunet_common.h:93
static unsigned int size
Size of the "table".
Definition: peer.c:67
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
Message used to notify the transport service about a message to be transmitted to another peer.
Definition: transport.h:285
struct GNUNET_MessageHeader header
Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_SEND.
Definition: transport.h:289

References CT_CORE, GNUNET_break, GNUNET_OK, GNUNET_SYSERR, OutboundMessage::header, GNUNET_MessageHeader::size, size, and tc.

◆ client_send_response()

static void client_send_response ( struct PendingMessage pm)
static

Send a response to the pm that we have processed a "send" request.

Sends a confirmation to the "core" client responsible for the original request and free's pm.

Parameters
pmhandle to the original pending message

Definition at line 4058 of file gnunet-service-tng.c.

4059 {
4060  struct TransportClient *tc = pm->client;
4061  struct VirtualLink *vl = pm->vl;
4062 
4064  "client send response\n");
4065  if (NULL != tc)
4066  {
4067  struct GNUNET_MQ_Envelope *env;
4068  struct SendOkMessage *so_msg;
4069 
4071  so_msg->peer = vl->target;
4073  "Confirming transmission of <%llu> to %s\n",
4074  pm->logging_uuid,
4075  GNUNET_i2s (&vl->target));
4076  GNUNET_MQ_send (tc->mq, env);
4077  }
4079 }
#define GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK
Confirmation from TRANSPORT that message for transmission has been queued (and that the next message ...
Message used to notify the transport API that it can send another message to the transport service.
Definition: transport.h:217
struct GNUNET_PeerIdentity peer
Which peer can send more now?
Definition: transport.h:251

References env, free_pending_message(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK, GNUNET_MQ_msg, GNUNET_MQ_send(), SendOkMessage::peer, pm, VirtualLink::target, and tc.

Referenced by completed_pending_message(), and reliability_box_message().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ pick_random_dv_hops()

static unsigned int pick_random_dv_hops ( const struct DistanceVector dv,
enum RouteMessageOptions  options,
struct DistanceVectorHop **  hops_array,
unsigned int  hops_array_length 
)
static

Pick hops_array_length random DV paths satisfying options.

Parameters
dvdata structure to pick paths from
optionsconstraints to satisfy
hops_array[out]set to the result
hops_array_lengthlength of the hops_array
Returns
number of entries set in hops_array

Definition at line 4092 of file gnunet-service-tng.c.

4096 {
4097  uint64_t choices[hops_array_length];
4098  uint64_t num_dv;
4099  unsigned int dv_count;
4100 
4101  /* Pick random vectors, but weighted by distance, giving more weight
4102  to shorter vectors */
4103  num_dv = 0;
4104  dv_count = 0;
4105  for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos;
4106  pos = pos->next_dv)
4107  {
4108  if ((0 == (options & RMO_UNCONFIRMED_ALLOWED)) &&
4109  (GNUNET_TIME_absolute_get_remaining (pos->path_valid_until)
4110  .rel_value_us == 0))
4111  continue; /* pos unconfirmed and confirmed required */
4112  num_dv += MAX_DV_HOPS_ALLOWED - pos->distance;
4113  dv_count++;
4114  }
4115  if (0 == dv_count)
4116  return 0;
4117  if (dv_count <= hops_array_length)
4118  {
4119  dv_count = 0;
4120  for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos;
4121  pos = pos->next_dv)
4122  hops_array[dv_count++] = pos;
4123  return dv_count;
4124  }
4125  for (unsigned int i = 0; i < hops_array_length; i++)
4126  {
4127  int ok = GNUNET_NO;
4128  while (GNUNET_NO == ok)
4129  {
4130  choices[i] =
4132  ok = GNUNET_YES;
4133  for (unsigned int j = 0; j < i; j++)
4134  if (choices[i] == choices[j])
4135  {
4136  ok = GNUNET_NO;
4137  break;
4138  }
4139  }
4140  }
4141  dv_count = 0;
4142  num_dv = 0;
4143  for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos;
4144  pos = pos->next_dv)
4145  {
4146  uint32_t delta = MAX_DV_HOPS_ALLOWED - pos->distance;
4147 
4148  if ((0 == (options & RMO_UNCONFIRMED_ALLOWED)) &&
4149  (GNUNET_TIME_absolute_get_remaining (pos->path_valid_until)
4150  .rel_value_us == 0))
4151  continue; /* pos unconfirmed and confirmed required */
4152  for (unsigned int i = 0; i < hops_array_length; i++)
4153  if ((num_dv <= choices[i]) && (num_dv + delta > choices[i]))
4154  hops_array[dv_count++] = pos;
4155  num_dv += delta;
4156  }
4157  return dv_count;
4158 }
static int ok
Return value from 'main' (0 == success)
#define MAX_DV_HOPS_ALLOWED
Maximum DV distance allowed ever.
uint64_t GNUNET_CRYPTO_random_u64(enum GNUNET_CRYPTO_Quality mode, uint64_t max)
Random on unsigned 64-bit values.
@ GNUNET_CRYPTO_QUALITY_WEAK
No good quality of the operation is needed (i.e., random numbers can be pseudo-random).
static struct GNUNET_TIME_Relative delta
Definition: speedup.c:35

References delta, DistanceVector::dv_head, GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u64(), GNUNET_NO, GNUNET_TIME_absolute_get_remaining(), GNUNET_YES, MAX_DV_HOPS_ALLOWED, DistanceVectorHop::next_dv, ok, options, GNUNET_TIME_Relative::rel_value_us, and RMO_UNCONFIRMED_ALLOWED.

Here is the call graph for this function:

◆ check_communicator_available()

static int check_communicator_available ( void *  cls,
const struct GNUNET_TRANSPORT_CommunicatorAvailableMessage *  cam 
)
static

Communicator started.

Test message is well-formed.

Parameters
clsthe client
camthe send message that was sent

Definition at line 4168 of file gnunet-service-tng.c.

4171 {
4172  struct TransportClient *tc = cls;
4173  uint16_t size;
4174 
4175  if (CT_NONE != tc->type)
4176  {
4177  GNUNET_break (0);
4178  return GNUNET_SYSERR;
4179  }
4180  tc->type = CT_COMMUNICATOR;
4181  size = ntohs (cam->header.size) - sizeof(*cam);
4182  if (0 == size)
4183  return GNUNET_OK; /* receive-only communicator */
4185  return GNUNET_OK;
4186 }
#define GNUNET_MQ_check_zero_termination(m)
Insert code for a "check_" function that verifies that a given variable-length message received over ...

References CT_COMMUNICATOR, CT_NONE, GNUNET_break, GNUNET_MQ_check_zero_termination, GNUNET_OK, GNUNET_SYSERR, size, and tc.

◆ finish_cmc_handling()

static void finish_cmc_handling ( struct CommunicatorMessageContext cmc)
static

Send ACK to communicator (if requested) and free cmc.

Parameters
cmccontext for which we are done handling the message

Definition at line 4195 of file gnunet-service-tng.c.

4196 {
4197  if (0 != ntohl (cmc->im.fc_on))
4198  {
4199  /* send ACK when done to communicator for flow control! */
4200  struct GNUNET_MQ_Envelope *env;
4201  struct GNUNET_TRANSPORT_IncomingMessageAck *ack;
4202 
4204  ack->reserved = htonl (0);
4205  ack->fc_id = cmc->im.fc_id;
4206  ack->sender = cmc->im.sender;
4207  GNUNET_MQ_send (cmc->tc->mq, env);
4208  }
4210  GNUNET_free (cmc);
4211 }
#define GNUNET_MESSAGE_TYPE_TRANSPORT_INCOMING_MSG_ACK
transport acknowledges processing an incoming message
struct GNUNET_TRANSPORT_IncomingMessage im
Additional information for flow control and about the sender.
struct TransportClient * tc
Which communicator provided us with the message.
struct GNUNET_MQ_Handle * mq
Message queue to the client.

References TransportClient::client, env, GNUNET_free, GNUNET_MESSAGE_TYPE_TRANSPORT_INCOMING_MSG_ACK, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_SERVICE_client_continue(), CommunicatorMessageContext::im, TransportClient::mq, and CommunicatorMessageContext::tc.

Referenced by backtalker_monotime_cb(), free_backtalker(), handle_backchannel_encapsulation(), handle_client_recv_ok(), handle_dv_box(), handle_dv_learn(), handle_flow_control(), handle_fragment_box(), handle_raw_message(), handle_reliability_ack(), handle_validation_challenge(), and handle_validation_response().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ handle_client_recv_ok()

static void handle_client_recv_ok ( void *  cls,
const struct RecvOkMessage rom 
)
static

Client confirms that it is done handling message(s) to a particular peer.

We may now provide more messages to CORE for this peer.

Notifies the respective queues that more messages can now be received.

Parameters
clsthe client
romthe message that was sent

Definition at line 4224 of file gnunet-service-tng.c.

4225 {
4226  struct TransportClient *tc = cls;
4227  struct VirtualLink *vl;
4228  uint32_t delta;
4229  struct CommunicatorMessageContext *cmc;
4230 
4231  if (CT_CORE != tc->type)
4232  {
4233  GNUNET_break (0);
4234  GNUNET_SERVICE_client_drop (tc->client);
4235  return;
4236  }
4237  vl = lookup_virtual_link (&rom->peer);
4238  if ((NULL == vl) || (GNUNET_NO == vl->confirmed))
4239  {
4241  "# RECV_OK dropped: virtual link unknown",
4242  1,
4243  GNUNET_NO);
4245  return;
4246  }
4247  delta = ntohl (rom->increase_window_delta);
4248  vl->core_recv_window += delta;
4249  if (vl->core_recv_window <= 0)
4250  return;
4251  /* resume communicators */
4252  while (NULL != (cmc = vl->cmc_tail))
4253  {
4255  finish_cmc_handling (cmc);
4256  }
4257 }
static void finish_cmc_handling(struct CommunicatorMessageContext *cmc)
Send ACK to communicator (if requested) and free cmc.
Context from handle_incoming_msg().
struct GNUNET_PeerIdentity peer
Which peer can CORE handle more from now?
Definition: transport.h:276
uint32_t increase_window_delta
Number of messages by which to increase the window, greater or equal to one.
Definition: transport.h:271

References VirtualLink::cmc_head, VirtualLink::cmc_tail, VirtualLink::confirmed, VirtualLink::core_recv_window, CT_CORE, delta, finish_cmc_handling(), GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_NO, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_STATISTICS_update(), GST_stats, RecvOkMessage::increase_window_delta, lookup_virtual_link(), RecvOkMessage::peer, and tc.

Here is the call graph for this function:

◆ handle_communicator_available()

static void handle_communicator_available ( void *  cls,
const struct GNUNET_TRANSPORT_CommunicatorAvailableMessage *  cam 
)
static

Communicator started.

Process the request.

Parameters
clsthe client
camthe send message that was sent

Definition at line 4267 of file gnunet-service-tng.c.

4270 {
4271  struct TransportClient *tc = cls;
4272  uint16_t size;
4273 
4274  size = ntohs (cam->header.size) - sizeof(*cam);
4275  if (0 == size)
4276  {
4278  "Receive-only communicator connected\n");
4279  return; /* receive-only communicator */
4280  }
4281  tc->details.communicator.address_prefix =
4282  GNUNET_strdup ((const char *) &cam[1]);
4283  tc->details.communicator.cc =
4284  (enum GNUNET_TRANSPORT_CommunicatorCharacteristics) ntohl (cam->cc);
4286  "Communicator with prefix `%s' connected\n",
4287  tc->details.communicator.address_prefix);
4289 }
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
GNUNET_TRANSPORT_CommunicatorCharacteristics
What characteristics does this communicator have?

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_SERVICE_client_continue(), GNUNET_strdup, size, and tc.

Here is the call graph for this function:

◆ check_communicator_backchannel()

static int check_communicator_backchannel ( void *  cls,
const struct GNUNET_TRANSPORT_CommunicatorBackchannel *  cb 
)
static

Communicator requests backchannel transmission.

Check the request.

Parameters
clsthe client
cbthe send message that was sent
Returns
GNUNET_OK if message is well-formed

Definition at line 4300 of file gnunet-service-tng.c.

4303 {
4304  const struct GNUNET_MessageHeader *inbox;
4305  const char *is;
4306  uint16_t msize;
4307  uint16_t isize;
4308 
4309  (void) cls;
4310  msize = ntohs (cb->header.size) - sizeof(*cb);
4311  inbox = (const struct GNUNET_MessageHeader *) &cb[1];
4312  isize = ntohs (inbox->size);
4313  if (isize >= msize)
4314  {
4315  GNUNET_break (0);
4316  return GNUNET_SYSERR;
4317  }
4318  is = (const char *) inbox;
4319  is += isize;
4320  msize -= isize;
4321  GNUNET_assert (0 < msize);
4322  if ('\0' != is[msize - 1])
4323  {
4324  GNUNET_break (0);
4325  return GNUNET_SYSERR;
4326  }
4327  return GNUNET_OK;
4328 }
static struct GNUNET_NT_InterfaceScanner * is
Network scanner to determine network types.

References GNUNET_assert, GNUNET_break, GNUNET_OK, GNUNET_SYSERR, is, and GNUNET_MessageHeader::size.

◆ update_ephemeral()

static void update_ephemeral ( struct DistanceVector dv)
static

Ensure ephemeral keys in our dv are current.

If no current one exists, set it up.

Parameters
dv[in,out]virtual link to update ephemeral for

Definition at line 4338 of file gnunet-service-tng.c.

4339 {
4340  struct EphemeralConfirmationPS ec;
4341 
4342  if (0 !=
4344  return;
4346  dv->ephemeral_validity =
4350  ec.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_EPHEMERAL);
4351  ec.target = dv->target;
4352  ec.ephemeral_key = dv->ephemeral_key;
4353  ec.sender_monotonic_time = GNUNET_TIME_absolute_hton (dv->monotime);
4354  ec.purpose.size = htonl (sizeof(ec));
4356  &ec,
4357  &dv->sender_sig);
4358 }
#define EPHEMERAL_VALIDITY
How long are ephemeral keys valid?
static const struct GNUNET_CONFIGURATION_Handle * GST_cfg
Configuration handle.
#define GNUNET_SIGNATURE_PURPOSE_TRANSPORT_EPHEMERAL
Signature by a peer affirming that the given ephemeral key is currently in use by that peer's transpo...
void GNUNET_CRYPTO_ecdhe_key_create(struct GNUNET_CRYPTO_EcdhePrivateKey *pk)
Create a new private key.
Definition: crypto_ecc.c:435
#define GNUNET_CRYPTO_eddsa_sign(priv, ps, sig)
EdDSA sign a given block.
void GNUNET_CRYPTO_ecdhe_key_get_public(const struct GNUNET_CRYPTO_EcdhePrivateKey *priv, struct GNUNET_CRYPTO_EcdhePublicKey *pub)
Extract the public key for the given private key.
Definition: crypto_ecc.c:213
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:449
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get_monotonic(const struct GNUNET_CONFIGURATION_Handle *cfg)
Obtain the current time and make sure it is monotonically increasing.
Definition: time.c:859
struct GNUNET_TIME_Absolute monotime
What time was sender_sig created.
struct GNUNET_CRYPTO_EddsaSignature sender_sig
Signature affirming ephemeral_key of type GNUNET_SIGNATURE_PURPOSE_TRANSPORT_EPHEMERAL.
struct GNUNET_CRYPTO_EcdhePublicKey ephemeral_key
Our ephemeral key.
struct GNUNET_CRYPTO_EcdhePrivateKey private_key
Our private ephemeral key.
struct GNUNET_TIME_Absolute ephemeral_validity
How long is sender_sig valid.
Body by which a peer confirms that it is using an ephemeral key.

References EphemeralConfirmationPS::ephemeral_key, DistanceVector::ephemeral_key, EPHEMERAL_VALIDITY, DistanceVector::ephemeral_validity, GNUNET_CRYPTO_ecdhe_key_create(), GNUNET_CRYPTO_ecdhe_key_get_public(), GNUNET_CRYPTO_eddsa_sign, GNUNET_SIGNATURE_PURPOSE_TRANSPORT_EPHEMERAL, GNUNET_TIME_absolute_add(), GNUNET_TIME_absolute_get_monotonic(), GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_absolute_hton(), GST_cfg, GST_my_private_key, DistanceVector::monotime, DistanceVector::private_key, GNUNET_CRYPTO_EccSignaturePurpose::purpose, EphemeralConfirmationPS::purpose, GNUNET_TIME_Relative::rel_value_us, EphemeralConfirmationPS::sender_monotonic_time, DistanceVector::sender_sig, GNUNET_CRYPTO_EccSignaturePurpose::size, EphemeralConfirmationPS::target, and DistanceVector::target.

Here is the call graph for this function:

◆ queue_send_msg()

static void queue_send_msg ( struct Queue queue,
struct PendingMessage pm,
const void *  payload,
size_t  payload_size 
)
static

Send the message payload on queue.

Parameters
queuethe queue to use for transmission
pmpending message to update once transmission is done, may be NULL!
payloadthe payload to send (encapsulated in a GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_MSG).
payload_sizenumber of bytes in payload

Definition at line 4371 of file gnunet-service-tng.c.

4375 {
4376  struct Neighbour *n = queue->neighbour;
4377  struct GNUNET_TRANSPORT_SendMessageTo *smt;
4378  struct GNUNET_MQ_Envelope *env;
4379 
4380  GNUNET_log (
4382  "Queueing %u bytes of payload for transmission <%llu> on queue %llu to %s\n",
4383  (unsigned int) payload_size,
4384  (NULL == pm) ? 0 : pm->logging_uuid,
4385  (unsigned long long) queue->qid,
4386  GNUNET_i2s (&queue->neighbour->pid));
4387  env = GNUNET_MQ_msg_extra (smt,
4388  payload_size,
4390  smt->qid = queue->qid;
4391  smt->mid = queue->mid_gen;
4392  smt->receiver = n->pid;
4393  memcpy (&smt[1], payload, payload_size);
4394  {
4395  /* Pass the env to the communicator of queue for transmission. */
4396  struct QueueEntry *qe;
4397 
4398  qe = GNUNET_new (struct QueueEntry);
4399  qe->mid = queue->mid_gen++;
4400  qe->queue = queue;
4401  if (NULL != pm)
4402  {
4403  qe->pm = pm;
4404  // TODO Why do we have a retransmission. When we know, make decision if we still want this.
4405  // GNUNET_assert (NULL == pm->qe);
4406  /*if (NULL != pm->qe)
4407  {
4408  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4409  "Retransmitting message <%llu> remove pm from qe with MID: %llu \n",
4410  pm->logging_uuid,
4411  (unsigned long long) pm->qe->mid);
4412  pm->qe->pm = NULL;
4413  }*/
4414  pm->qe = qe;
4415  }
4416  GNUNET_CONTAINER_DLL_insert (queue->queue_head, queue->queue_tail, qe);
4417  GNUNET_assert (CT_COMMUNICATOR == queue->tc->type);
4418  queue->queue_length++;
4419  queue->tc->details.communicator.total_queue_length++;
4420  if (0 == queue->q_capacity)
4421  return;
4422  if (GNUNET_NO == queue->unlimited_length)
4423  queue->q_capacity--;
4425  "Queue %s with qid %u has capacity %lu\n",
4426  queue->address,
4427  queue->qid,
4428  queue->q_capacity);
4430  queue->tc->details.communicator.total_queue_length)
4431  queue->idle = GNUNET_NO;
4432  if (QUEUE_LENGTH_LIMIT == queue->queue_length)
4433  queue->idle = GNUNET_NO;
4434  if (0 == queue->q_capacity)
4435  queue->idle = GNUNET_NO;
4437  "Sending message MID %llu of type %u (%u) and size %u with MQ %p\n",
4438  smt->mid,
4439  ntohs (((const struct GNUNET_MessageHeader *) payload)->type),
4440  ntohs (smt->header.size),
4441  payload_size,
4442  queue->tc->mq);
4443  GNUNET_MQ_send (queue->tc->mq, env);
4444  }
4445 }
static unsigned long long payload
How much data are we currently storing in the database?
#define GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_MSG
transport tells communicator it wants to transmit
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model

References COMMUNICATOR_TOTAL_QUEUE_LIMIT, CT_COMMUNICATOR, env, GNUNET_assert, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_MSG, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_new, GNUNET_NO, payload, Neighbour::pid, pm, qe, queue(), QUEUE_LENGTH_LIMIT, and type.

Referenced by start_dv_learn(), transmit_on_queue(), and validation_transmit_on_queue().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ route_via_neighbour()

static struct GNUNET_TIME_Relative route_via_neighbour ( const struct Neighbour n,
const struct GNUNET_MessageHeader hdr,
enum RouteMessageOptions  options 
)
static

Pick a queue of n under constraints options and schedule transmission of hdr.

Parameters
nneighbour to send to
hdrmessage to send as payload
optionswhether queues must be confirmed or not, and whether we may pick multiple (2) queues
Returns
expected RTT for transmission, GNUNET_TIME_UNIT_FOREVER_REL if sending failed

Definition at line 4371 of file gnunet-service-tng.c.

4462 {
4463  struct GNUNET_TIME_Absolute now;
4464  unsigned int candidates;
4465  unsigned int sel1;
4466  unsigned int sel2;
4467  struct GNUNET_TIME_Relative rtt;
4468 
4469  /* Pick one or two 'random' queues from n (under constraints of options) */
4470  now = GNUNET_TIME_absolute_get ();
4471  /* FIXME-OPTIMIZE: give queues 'weights' and pick proportional to
4472  weight in the future; weight could be assigned by observed
4473  bandwidth (note: not sure if we should do this for this type
4474  of control traffic though). */
4475  candidates = 0;
4476  for (struct Queue *pos = n->queue_head; NULL != pos;
4477  pos = pos->next_neighbour)
4478  {
4479  if ((0 != (options & RMO_UNCONFIRMED_ALLOWED)) ||
4480  (pos->validated_until.abs_value_us > now.abs_value_us))
4481  candidates++;
4482  }
4483  if (0 == candidates)
4484  {
4485  /* This can happen rarely if the last confirmed queue timed
4486  out just as we were beginning to process this message. */
4488  "Could not route message of type %u to %s: no valid queue\n",
4489  ntohs (hdr->type),
4490  GNUNET_i2s (&n->pid));
4492  "# route selection failed (all no valid queue)",
4493  1,
4494  GNUNET_NO);
4496  }
4497 
4500  if (0 == (options & RMO_REDUNDANT))
4501  sel2 = candidates; /* picks none! */
4502  else
4504  candidates = 0;
4505  for (struct Queue *pos = n->queue_head; NULL != pos;
4506  pos = pos->next_neighbour)
4507  {
4508  if ((0 != (options & RMO_UNCONFIRMED_ALLOWED)) ||
4509  (pos->validated_until.abs_value_us > now.abs_value_us))
4510  {
4511  if ((sel1 == candidates) || (sel2 == candidates))
4512  {
4514  "Routing message of type %u to %s using %s (#%u)\n",
4515  ntohs (hdr->type),
4516  GNUNET_i2s (&n->pid),
4517  pos->address,
4518  (sel1 == candidates) ? 1 : 2);
4519  rtt = GNUNET_TIME_relative_min (rtt, pos->pd.aged_rtt);
4520  queue_send_msg (pos, NULL, hdr, ntohs (hdr->size));
4521  }
4522  candidates++;
4523  }
4524  }
4525  return rtt;
4526 }
uint32_t GNUNET_CRYPTO_random_u32(enum GNUNET_CRYPTO_Quality mode, uint32_t i)
Produce a random value.
@ GNUNET_ERROR_TYPE_INFO
struct GNUNET_TIME_Relative GNUNET_TIME_relative_min(struct GNUNET_TIME_Relative t1, struct GNUNET_TIME_Relative t2)
Return the minimum of two relative time values.
Definition: time.c:342
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
struct Queue * next_neighbour
Kept in a MDLL.

Referenced by forward_dv_box(), forward_dv_learn(), handle_communicator_backchannel(), handle_validation_challenge(), route_control_message_without_fc(), and transmit_cummulative_ack_cb().

Here is the caller graph for this function:

◆ dv_setup_key_state_from_km()

static void dv_setup_key_state_from_km ( const struct GNUNET_HashCode km,
const struct GNUNET_ShortHashCode iv,
struct DVKeyState key 
)
static

Given the key material in km and the initialization vector iv, setup the key material for the backchannel in key.

Parameters
kmraw master secret
ivinitialization vector
key[out]symmetric cipher and HMAC state to generate

Definition at line 4571 of file gnunet-service-tng.c.

4574 {
4575  /* must match #dh_key_derive_eph_pub */
4577  GNUNET_CRYPTO_kdf (&key->material,
4578  sizeof(key->material),
4579  "transport-backchannel-key",
4580  strlen ("transport-backchannel-key"),
4581  km,
4582  sizeof(*km),
4583  iv,
4584  sizeof(*iv),
4585  NULL));
4587  "Deriving backchannel key based on KM %s and IV %s\n",
4588  GNUNET_h2s (km),
4589  GNUNET_sh2s (iv));
4590  GNUNET_assert (0 == gcry_cipher_open (&key->cipher,
4591  GCRY_CIPHER_AES256 /* low level: go for speed */,
4592  GCRY_CIPHER_MODE_CTR,
4593  0 /* flags */));
4594  GNUNET_assert (0 == gcry_cipher_setkey (key->cipher,
4595  &key->material.aes_key,
4596  sizeof(key->material.aes_key)));
4597  gcry_cipher_setctr (key->cipher,
4598  &key->material.aes_ctr,
4599  sizeof(key->material.aes_ctr));
4600 }
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_kdf(void *result, size_t out_len, const void *xts, size_t xts_len, const void *skm, size_t skm_len,...)
Derive key.
Definition: crypto_kdf.c:69
const char * GNUNET_sh2s(const struct GNUNET_ShortHashCode *shc)
Convert a short hash value to a string (for printing debug messages).
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).

References GNUNET_assert, GNUNET_CRYPTO_kdf(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_sh2s(), GNUNET_YES, and key.

Referenced by dh_key_derive_eph_pid(), and dh_key_derive_eph_pub().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ dh_key_derive_eph_pid()

static void dh_key_derive_eph_pid ( const struct GNUNET_CRYPTO_EcdhePrivateKey priv_ephemeral,
const struct GNUNET_PeerIdentity target,
const struct GNUNET_ShortHashCode iv,
struct DVKeyState key 
)
static

Derive backchannel encryption key material from priv_ephemeral and target and iv.

Parameters
priv_ephemeralephemeral private key to use
targetthe target peer to encrypt to
ivunique IV to use
key[out]set to the key material

Definition at line 4613 of file gnunet-service-tng.c.

4618 {
4619  struct GNUNET_HashCode km;
4620 
4622  &target->public_key,
4623  &km));
4624  dv_setup_key_state_from_km (&km, iv, key);
4625 }
static void dv_setup_key_state_from_km(const struct GNUNET_HashCode *km, const struct GNUNET_ShortHashCode *iv, struct DVKeyState *key)
Given the key material in km and the initialization vector iv, setup the key material for the backcha...
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_ecdh_eddsa(const struct GNUNET_CRYPTO_EcdhePrivateKey *priv, const struct GNUNET_CRYPTO_EddsaPublicKey *pub, struct GNUNET_HashCode *key_material)
Derive key material from a EdDSA public key and a private ECDH key.
Definition: crypto_ecc.c:758
A 512-bit hashcode.
struct GNUNET_CRYPTO_EddsaPublicKey public_key

References dv_setup_key_state_from_km(), GNUNET_assert, GNUNET_CRYPTO_ecdh_eddsa(), GNUNET_YES, key, and GNUNET_PeerIdentity::public_key.

Here is the call graph for this function:

◆ dh_key_derive_eph_pub()

static void dh_key_derive_eph_pub ( const struct GNUNET_CRYPTO_EcdhePublicKey pub_ephemeral,
const struct GNUNET_ShortHashCode iv,
struct DVKeyState key 
)
static

Derive backchannel encryption key material from GST_my_private_key and pub_ephemeral and iv.

Parameters
priv_ephemeralephemeral private key to use
targetthe target peer to encrypt to
ivunique IV to use
key[out]set to the key material

Definition at line 4638 of file gnunet-service-tng.c.

4641 {
4642  struct GNUNET_HashCode km;
4643 
4645  pub_ephemeral,
4646  &km));
4647  dv_setup_key_state_from_km (&km, iv, key);
4648 }
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_eddsa_ecdh(const struct GNUNET_CRYPTO_EddsaPrivateKey *priv, const struct GNUNET_CRYPTO_EcdhePublicKey *pub, struct GNUNET_HashCode *key_material)
Derive key material from a ECDH public key and a private EdDSA key.
Definition: crypto_ecc.c:718

References dv_setup_key_state_from_km(), GNUNET_assert, GNUNET_CRYPTO_eddsa_ecdh(), GNUNET_YES, GST_my_private_key, and key.

Referenced by handle_dv_box().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ dv_hmac()

static void dv_hmac ( const struct DVKeyState key,
struct GNUNET_HashCode hmac,
const void *  data,
size_t  data_size 
)
static

Do HMAC calculation for backchannel messages over data using key material from key.

Parameters
keykey material (from DH)
hmac[out]set to the HMAC
datadata to perform HMAC calculation over
data_sizenumber of bytes in data

Definition at line 4661 of file gnunet-service-tng.c.

4665 {
4666  GNUNET_CRYPTO_hmac (&key->material.hmac_key, data, data_size, hmac);
4667 }
static size_t data_size
Number of bytes in data.
Definition: gnunet-abd.c:187
uint32_t data
The data value.
void GNUNET_CRYPTO_hmac(const struct GNUNET_CRYPTO_AuthKey *key, const void *plaintext, size_t plaintext_len, struct GNUNET_HashCode *hmac)
Calculate HMAC of a message (RFC 2104)
Definition: crypto_hash.c:328

References data, data_size, GNUNET_CRYPTO_hmac(), and key.

Referenced by handle_dv_box().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ dv_encrypt()

static void dv_encrypt ( struct DVKeyState key,
const void *  in,
void *  dst,
size_t  in_size 
)
static

Perform backchannel encryption using symmetric secret in key to encrypt data from in to dst.

Parameters
key[in,out]key material to use
dstwhere to write the result
ininput data to encrypt (plaintext)
in_sizenumber of bytes of input in in and available at dst

Definition at line 4680 of file gnunet-service-tng.c.

4681 {
4682  GNUNET_assert (0 ==
4683  gcry_cipher_encrypt (key->cipher, dst, in_size, in, in_size));
4684 }

References GNUNET_assert, and key.

◆ dv_decrypt()

static void dv_decrypt ( struct DVKeyState key,
void *  out,
const void *  ciph,
size_t  out_size 
)
static

Perform backchannel encryption using symmetric secret in key to encrypt data from in to dst.

Parameters
key[in,out]key material to use
ciphcipher text to decrypt
out[out]output data to generate (plaintext)
out_sizenumber of bytes of input in ciph and available in out

Definition at line 4697 of file gnunet-service-tng.c.

4701 {
4702  GNUNET_assert (
4703  0 == gcry_cipher_decrypt (key->cipher, out, out_size, ciph, out_size));
4704 }

References GNUNET_assert, and key.

Referenced by handle_dv_box().

Here is the caller graph for this function:

◆ dv_key_clean()

static void dv_key_clean ( struct DVKeyState key)
static

Clean up key material in key.

Parameters
keykey material to clean up (memory must not be free'd!)

Definition at line 4713 of file gnunet-service-tng.c.

4714 {
4715  gcry_cipher_close (key->cipher);
4716  GNUNET_CRYPTO_zero_keys (&key->material, sizeof(key->material));
4717 }
void GNUNET_CRYPTO_zero_keys(void *buffer, size_t length)
Zero out buffer, securely against compiler optimizations.

References GNUNET_CRYPTO_zero_keys(), and key.

Referenced by handle_dv_box().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ encapsulate_for_dv()

static struct GNUNET_TIME_Relative encapsulate_for_dv ( struct DistanceVector dv,
unsigned int  num_dvhs,
struct DistanceVectorHop **  dvhs,
const struct GNUNET_MessageHeader hdr,
DVMessageHandler  use,
void *  use_cls,
enum RouteMessageOptions  options,
enum GNUNET_GenericReturnValue  without_fc 
)
static

Pick a path of dv under constraints options and schedule transmission of hdr.

Parameters
targetneighbour to ultimately send to
num_dvhslength of the dvhs array
dvhsarray of hops to send the message to
hdrmessage to send as payload
usefunction to call with the encapsulated message
use_clsclosure for use
optionswhether path must be confirmed or not, to be passed to use
shallthis TransportDVBoxMessage be forwarded without flow control.
Returns
expected RTT for transmission, GNUNET_TIME_UNIT_FOREVER_REL if sending failed

Definition at line 4730 of file gnunet-service-tng.c.

4758 {
4759  struct TransportDVBoxMessage box_hdr;
4760  struct TransportDVBoxPayloadP payload_hdr;
4761  uint16_t enc_body_size = ntohs (hdr->size);
4762  char enc[sizeof(struct TransportDVBoxPayloadP) + enc_body_size] GNUNET_ALIGN;
4763  struct TransportDVBoxPayloadP *enc_payload_hdr =
4764  (struct TransportDVBoxPayloadP *) enc;
4765  struct DVKeyState *key;
4766  struct GNUNET_TIME_Relative rtt;
4767 
4768  key = GNUNET_new (struct DVKeyState);
4769  /* Encrypt payload */
4770  box_hdr.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_DV_BOX);
4771  box_hdr.total_hops = htons (0);
4772  box_hdr.without_fc = htons (without_fc);
4773  update_ephemeral (dv);
4774  box_hdr.ephemeral_key = dv->ephemeral_key;
4775  payload_hdr.sender_sig = dv->sender_sig;
4776 
4778  &box_hdr.iv,
4779  sizeof(box_hdr.iv));
4780  dh_key_derive_eph_pid (&dv->private_key, &dv->target, &box_hdr.iv, key);
4781  payload_hdr.sender = GST_my_identity;
4782  payload_hdr.monotonic_time = GNUNET_TIME_absolute_hton (dv->monotime);
4783  dv_encrypt (key, &payload_hdr, enc_payload_hdr, sizeof(payload_hdr));
4784  dv_encrypt (key,
4785  hdr,
4786  &enc[sizeof(struct TransportDVBoxPayloadP)],
4787  enc_body_size);
4788  dv_hmac (key, &box_hdr.hmac, enc, sizeof(enc));
4789  dv_key_clean (key);
4791  /* For each selected path, take the pre-computed header and body
4792  and add the path in the middle of the message; then send it. */
4793  for (unsigned int i = 0; i < num_dvhs; i++)
4794  {
4795  struct DistanceVectorHop *dvh = dvhs[i];
4796  unsigned int num_hops = dvh->distance + 1;
4797  char buf[sizeof(struct TransportDVBoxMessage)
4798  + sizeof(struct GNUNET_PeerIdentity) * num_hops
4799  + sizeof(struct TransportDVBoxPayloadP)
4800  + enc_body_size] GNUNET_ALIGN;
4801  struct GNUNET_PeerIdentity *dhops;
4802 
4803  box_hdr.header.size = htons (sizeof(buf));
4804  box_hdr.orig_size = htons (sizeof(buf));
4805  box_hdr.num_hops = htons (num_hops);
4806  memcpy (buf, &box_hdr, sizeof(box_hdr));
4807  dhops = (struct GNUNET_PeerIdentity *) &buf[sizeof(box_hdr)];
4808  memcpy (dhops,
4809  dvh->path,
4810  dvh->distance * sizeof(struct GNUNET_PeerIdentity));
4811  dhops[dvh->distance] = dv->target;
4812  if (GNUNET_EXTRA_LOGGING > 0)
4813  {
4814  char *path;
4815 
4817  for (unsigned int j = 0; j < num_hops; j++)
4818  {
4819  char *tmp;
4820 
4821  GNUNET_asprintf (&tmp, "%s-%s", path, GNUNET_i2s (&dhops[j]));
4822  GNUNET_free (path);
4823  path = tmp;
4824  }
4826  "Routing message of type %u to %s using DV (#%u/%u) via %s\n",
4827  ntohs (hdr->type),
4828  GNUNET_i2s (&dv->target),
4829  i + 1,
4830  num_dvhs,
4831  path);
4832  GNUNET_free (path);
4833  }
4834  rtt = GNUNET_TIME_relative_min (rtt, dvh->pd.aged_rtt);
4835  memcpy (&dhops[num_hops], enc, sizeof(enc));
4836  use (use_cls,
4837  dvh->next_hop,
4838  (const struct GNUNET_MessageHeader *) buf,
4839  options);
4840  GNUNET_free (key);
4841  }
4842  return rtt;
4843 }
static OpusEncoder * enc
OPUS encoder.
static char buf[2048]
static void dv_key_clean(struct DVKeyState *key)
Clean up key material in key.
static void update_ephemeral(struct DistanceVector *dv)
Ensure ephemeral keys in our dv are current.
static void dv_hmac(const struct DVKeyState *key, struct GNUNET_HashCode *hmac, const void *data, size_t data_size)
Do HMAC calculation for backchannel messages over data using key material from key.
static void dh_key_derive_eph_pid(const struct GNUNET_CRYPTO_EcdhePrivateKey *priv_ephemeral, const struct GNUNET_PeerIdentity *target, const struct GNUNET_ShortHashCode *iv, struct DVKeyState *key)
Derive backchannel encryption key material from priv_ephemeral and target and iv.
static void dv_encrypt(struct DVKeyState *key, const void *in, void *dst, size_t in_size)
Perform backchannel encryption using symmetric secret in key to encrypt data from in to dst.
#define GNUNET_ALIGN
gcc-ism to force alignment; we use this to align char-arrays that may then be cast to 'struct's.
void GNUNET_CRYPTO_random_block(enum GNUNET_CRYPTO_Quality mode, void *buffer, size_t length)
Fill block with a random values.
@ GNUNET_CRYPTO_QUALITY_NONCE
Randomness for IVs etc.
#define GNUNET_EXTRA_LOGGING
define GNUNET_EXTRA_LOGGING if using this header outside the GNUnet source tree where gnunet_config....
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_DV_BOX
Source-routed transport message based DV information gathered.
Structure of the key material used to encrypt backchannel messages.
struct PerformanceData pd
Performance data for this transmission possibility.
unsigned int distance
Number of hops in total to the target (excluding next_hop and target itself).
const struct GNUNET_PeerIdentity * path
Array of distance hops to the target, excluding next_hop.
struct GNUNET_TIME_Relative aged_rtt
Weighted average for the RTT.
uint16_t num_hops
Number of hops this messages includes.

Referenced by transmit_on_queue().

Here is the caller graph for this function:

◆ send_dv_to_neighbour()

static void send_dv_to_neighbour ( void *  cls,
struct Neighbour next_hop,
const struct GNUNET_MessageHeader hdr,
enum RouteMessageOptions  options 
)
static

Wrapper around route_via_neighbour() that matches the DVMessageHandler structure.

Parameters
clsunused
next_hopwhere to send next
hdrheader of the message to send
optionsmessage options for queue selection

Definition at line 4856 of file gnunet-service-tng.c.

4860 {
4861  (void) cls;
4862  (void) route_via_neighbour (next_hop, hdr, RMO_UNCONFIRMED_ALLOWED);
4863 }
static struct GNUNET_TIME_Relative route_via_neighbour(const struct Neighbour *n, const struct GNUNET_MessageHeader *hdr, enum RouteMessageOptions options)
Pick a queue of n under constraints options and schedule transmission of hdr.

◆ route_control_message_without_fc()

static struct GNUNET_TIME_Relative route_control_message_without_fc ( struct VirtualLink vl,
const struct GNUNET_MessageHeader hdr,
enum RouteMessageOptions  options 
)
static

We need to transmit hdr to target.

If necessary, this may involve DV routing. This function routes without applying flow control or congestion control and should only be used for control traffic.

Parameters
targetpeer to receive hdr
hdrheader of the message to route and GNUNET_free()
optionswhich transmission channels are allowed
Returns
expected RTT for transmission, GNUNET_TIME_UNIT_FOREVER_REL if sending failed

Definition at line 4856 of file gnunet-service-tng.c.

4882 {
4883  // struct VirtualLink *vl;
4884  struct Neighbour *n;
4885  struct DistanceVector *dv;
4886  struct GNUNET_TIME_Relative rtt1;
4887  struct GNUNET_TIME_Relative rtt2;
4888  const struct GNUNET_PeerIdentity *target = &vl->target;
4889 
4891  "Trying to route message of type %u to %s without fc\n",
4892  ntohs (hdr->type),
4893  GNUNET_i2s (target));
4894 
4895  // TODO Do this elsewhere. vl should be given as parameter to method.
4896  // vl = lookup_virtual_link (target);
4897  GNUNET_assert (NULL != vl && GNUNET_YES == vl->confirmed);
4898  if (NULL == vl)
4900  n = vl->n;
4901  dv = (0 != (options & RMO_DV_ALLOWED)) ? vl->dv : NULL;
4902  if (0 == (options & RMO_UNCONFIRMED_ALLOWED))
4903  {
4904  /* if confirmed is required, and we do not have anything
4905  confirmed, drop respective options */
4906  if (NULL == n)
4907  n = lookup_neighbour (target);
4908  if ((NULL == dv) && (0 != (options & RMO_DV_ALLOWED)))
4910  }
4911  if ((NULL == n) && (NULL == dv))
4912  {
4914  "Cannot route message of type %u to %s: no route\n",
4915  ntohs (hdr->type),
4916  GNUNET_i2s (target));
4918  "# Messages dropped in routing: no acceptable method",
4919  1,
4920  GNUNET_NO);
4922  }
4924  "Routing message of type %u to %s with options %X\n",
4925  ntohs (hdr->type),
4926  GNUNET_i2s (target),
4927  (unsigned int) options);
4928  /* If both dv and n are possible and we must choose:
4929  flip a coin for the choice between the two; for now 50/50 */
4930  if ((NULL != n) && (NULL != dv) && (0 == (options & RMO_REDUNDANT)))
4931  {
4933  n = NULL;
4934  else
4935  dv = NULL;
4936  }
4937  if ((NULL != n) && (NULL != dv))
4938  options &= ~RMO_REDUNDANT; /* We will do one DV and one direct, that's
4939  enough for redundancy, so clear the flag. */
4942  if (NULL != n)
4943  {
4945  "Try to route message of type %u to %s without fc via neighbour\n",
4946  ntohs (hdr->type),
4947  GNUNET_i2s (target));
4948  rtt1 = route_via_neighbour (n, hdr, options);
4949  }
4950  if (NULL != dv)
4951  {
4952  struct DistanceVectorHop *hops[2];
4953  unsigned int res;
4954 
4956  options,
4957  hops,
4958  (0 == (options & RMO_REDUNDANT)) ? 1 : 2);
4959  if (0 == res)
4960  {
4962  "Failed to route message, could not determine DV path\n");
4963  return rtt1;
4964  }
4966  "encapsulate_for_dv 1\n");
4967  rtt2 = encapsulate_for_dv (dv,
4968