GNUnet  0.10.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  ChallengeNonceP
 Type of a nonce used for challenges. 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  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  ReassemblyContext
 Information we keep for a message that we are reassembling. 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_CUMMULATIVE_ACKS   64
 Maximum number of messages we acknowledge together in one cummulative 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 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_TRANSPORT, CT_APPLICATION, 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_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 . 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_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_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 void schedule_transmit_on_queue (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 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)
 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 (const struct GNUNET_PeerIdentity *target, 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 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 cummulative acknowledgement data structure. More...
 
static void transmit_cummulative_ack_cb (void *cls)
 Do the transmission of a cummulative 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 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, const 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 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 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 timestmap. 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_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 do_shutdown (void *cls)
 Function called when the service shuts down. More...
 
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(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
 Head of a DLL sorted by launch time. More...
 
static struct LearnLaunchEntrylle_tail
 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 incomming 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...
 

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_CUMMULATIVE_ACKS

#define MAX_CUMMULATIVE_ACKS   64

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

Larger values may save a bit of bandwidth.

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

Referenced by cummulative_ack().

◆ 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 102 of file gnunet-service-tng.c.

Referenced by handle_flow_control().

◆ 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 108 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 114 of file gnunet-service-tng.c.

Referenced by update_pd_age(), and update_performance_data().

◆ 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 120 of file gnunet-service-tng.c.

Referenced by activate_core_visible_dv_path(), and handle_validation_response().

◆ 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 130 of file gnunet-service-tng.c.

Referenced by handle_validation_challenge().

◆ 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 136 of file gnunet-service-tng.c.

Referenced by handle_dv_learn().

◆ 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 146 of file gnunet-service-tng.c.

Referenced by activate_core_visible_dv_path(), and handle_validation_response().

◆ 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 155 of file gnunet-service-tng.c.

Referenced by handle_dv_learn().

◆ MAX_DV_HOPS_ALLOWED

#define MAX_DV_HOPS_ALLOWED   16

Maximum DV distance allowed ever.

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

Referenced by check_dv_learn(), forward_dv_learn(), handle_dv_learn(), and pick_random_dv_hops().

◆ 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 166 of file gnunet-service-tng.c.

Referenced by run(), and start_dv_learn().

◆ 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 171 of file gnunet-service-tng.c.

Referenced by learn_dv_path().

◆ 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 178 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 185 of file gnunet-service-tng.c.

Referenced by forward_dv_box().

◆ 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 193 of file gnunet-service-tng.c.

Referenced by check_connection_quality().

◆ 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 200 of file gnunet-service-tng.c.

Referenced by learn_dv_path().

◆ 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 207 of file gnunet-service-tng.c.

Referenced by handle_dv_box().

◆ 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 214 of file gnunet-service-tng.c.

Referenced by learn_dv_path().

◆ EPHEMERAL_VALIDITY

#define EPHEMERAL_VALIDITY   GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 4)

How long are ephemeral keys valid?

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

Referenced by update_ephemeral().

◆ 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 226 of file gnunet-service-tng.c.

Referenced by handle_fragment_box().

◆ 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 233 of file gnunet-service-tng.c.

Referenced by start_address_validation().

◆ 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 239 of file gnunet-service-tng.c.

Referenced by validation_start_cb().

◆ 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 247 of file gnunet-service-tng.c.

Referenced by transmit_cummulative_ack_cb().

◆ 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 254 of file gnunet-service-tng.c.

Referenced by start_dv_learn().

◆ 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 260 of file gnunet-service-tng.c.

Referenced by start_dv_learn().

◆ 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 265 of file gnunet-service-tng.c.

Referenced by handle_validation_response().

◆ 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 271 of file gnunet-service-tng.c.

Referenced by handle_dv_learn(), handle_validation_response(), and start_address_validation().

◆ 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 280 of file gnunet-service-tng.c.

Referenced by update_next_challenge_time().

◆ 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 288 of file gnunet-service-tng.c.

Referenced by handle_validation_response().

◆ 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 296 of file gnunet-service-tng.c.

Referenced by free_queue(), handle_send_message_ack(), queue_send_msg(), and schedule_transmit_on_queue().

◆ 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 303 of file gnunet-service-tng.c.

Referenced by handle_send_message_ack(), queue_send_msg(), and schedule_transmit_on_queue().

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 4516 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 don't know yet.

CT_TRANSPORT 

Transport service.

CT_APPLICATION 

Application.

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 969 of file gnunet-service-tng.c.

970 {
974  CT_NONE = 0,
975 
979  CT_CORE = 1,
980 
984  CT_MONITOR = 2,
985 
989  CT_COMMUNICATOR = 3,
990 
994  CT_APPLICATION = 4
995 };
"Application" telling us where to connect (i.e.
We do not know yet (client is fresh).
Is the CORE service, we need to forward traffic to it.
It is a monitor, forward monitor data.
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 1002 of file gnunet-service-tng.c.

1003 {
1007  RMO_NONE = 0,
1008 
1012  RMO_DV_ALLOWED = 1,
1013 
1018 
1023 
1029  RMO_REDUNDANT = 4
1030 };
We are allowed to use DV routing for this hdr.
Reliable and unreliable, DV and non-DV are all acceptable.
If we have multiple choices, it is OK to send this message over multiple channels at the same time to...
We are allowed to use unconfirmed queues or DV routes for this message.
Only confirmed, non-DV direct neighbours.

◆ 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 2043 of file gnunet-service-tng.c.

2044 {
2045 
2049  PMT_CORE = 0,
2050 
2054  PMT_FRAGMENT_BOX = 1,
2055 
2059  PMT_RELIABILITY_BOX = 2,
2060 
2064  PMT_DV_BOX = 3
2065 
2066 };
Ordinary message received from the CORE service.
Pending message created during forward_dv_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 2825 of file gnunet-service-tng.c.

References GNUNET_TIME_absolute_get(), and GNUNET_TIME_UNIT_MINUTES.

Referenced by update_performance_data().

2826 {
2827  struct GNUNET_TIME_Absolute now;
2828 
2829  now = GNUNET_TIME_absolute_get ();
2830  return now.abs_value_us / GNUNET_TIME_UNIT_MINUTES.rel_value_us / 15;
2831 }
#define GNUNET_TIME_UNIT_MINUTES
One minute.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
Time for absolute times used by GNUnet, in microseconds.
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 2840 of file gnunet-service-tng.c.

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

Referenced by do_shutdown(), and handle_validation_challenge().

2841 {
2843  GNUNET_assert (ir_total > 0);
2844  ir_total--;
2846  GNUNET_free (ir);
2847 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
void GNUNET_PEERSTORE_watch_cancel(struct GNUNET_PEERSTORE_WatchContext *wc)
Cancel a watch request.
static struct IncomingRequest * ir_head
List of incomming connections where we are trying to get a connection back established.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_PEERSTORE_WatchContext * wc
Handle for watching the peerstore for HELLOs for this peer.
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.
#define GNUNET_free(ptr)
Wrapper around free.
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 2856 of file gnunet-service-tng.c.

References PendingAcknowledgement::ack_uuid, PendingAcknowledgement::dvh, GNUNET_assert, GNUNET_CONTAINER_MDLL_remove, GNUNET_CONTAINER_multiuuidmap_remove(), GNUNET_free, GNUNET_YES, pa_count, DistanceVectorHop::pa_head, Queue::pa_head, PendingMessage::pa_head, DistanceVectorHop::pa_tail, Queue::pa_tail, PendingMessage::pa_tail, pm, PendingAcknowledgement::pm, q, queue(), PendingAcknowledgement::queue, and AcknowledgementUUIDP::value.

Referenced by free_pending_ack_cb(), and handle_acknowledged().

2857 {
2858  struct Queue *q = pa->queue;
2859  struct PendingMessage *pm = pa->pm;
2860  struct DistanceVectorHop *dvh = pa->dvh;
2861 
2863  pa_count--;
2864  if (NULL != q)
2865  {
2867  pa->queue = NULL;
2868  }
2869  if (NULL != pm)
2870  {
2871  GNUNET_CONTAINER_MDLL_remove (pm, pm->pa_head, pm->pa_tail, pa);
2872  pa->pm = NULL;
2873  }
2874  if (NULL != dvh)
2875  {
2876  GNUNET_CONTAINER_MDLL_remove (dvh, dvh->pa_head, dvh->pa_tail, pa);
2877  pa->queue = NULL;
2878  }
2881  &pa->ack_uuid.value,
2882  pa));
2883  GNUNET_free (pa);
2884 }
static void queue(const char *hostname)
Add hostname to the list of requests to be made.
struct PendingAcknowledgement * pa_head
Head of DLL of PAs that used our path.
struct PendingAcknowledgement * pa_tail
Tail of DLL of PAs for this pending message.
struct PendingAcknowledgement * pa_tail
Tail of DLL of PAs that used this queue.
struct DistanceVectorHop * dvh
Distance vector path chosen for this transmission, NULL if transmission was to a direct neighbour OR ...
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_Uuid value
The UUID value.
struct PendingAcknowledgement * pa_head
Head of DLL of PAs that used this queue.
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.
Handle for a queue.
#define GNUNET_CONTAINER_MDLL_remove(mdll, head, tail, element)
Remove an element from a MDLL.
static struct GNUNET_REVOCATION_Query * q
Handle for revocation query.
struct PendingAcknowledgement * pa_head
Head of DLL of PAs for this pending message.
static struct GNUNET_CONTAINER_MultiUuidmap * pending_acks
Map of pending acknowledgements, mapping struct AcknowledgementUUID to a struct PendingAcknowledgemen...
static unsigned int pa_count
Number of entries in the pa_head/pa_tail DLL.
struct PendingAcknowledgement * pa_tail
Tail of DLL of PAs that used our path.
static struct PendingAcknowledgement * pa_tail
The oldest PA we have created, tail of DLL.
One possible hop towards a DV target.
struct PendingMessage * pm
Message that was transmitted, may be NULL if the message was ACKed via another channel.
List containing all messages that are yet to be send.
struct Queue * queue
Queue used for transmission, NULL if the queue has been destroyed (which may happen before we get an ...
#define GNUNET_YES
Definition: gnunet_common.h:80
static struct PendingAcknowledgement * pa_head
The most recent PA we have created, head of DLL.
struct AcknowledgementUUIDP ack_uuid
Unique identifier for this transmission operation.
#define GNUNET_free(ptr)
Wrapper around free.
static struct GNUNET_TRANSPORT_PluginMonitor * pm
Handle if we are monitoring plugin session activity.
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 2896 of file gnunet-service-tng.c.

References GNUNET_CONTAINER_MDLL_remove, GNUNET_free, PendingMessage::head_frag, PendingMessage::pa_head, PendingMessage::pa_tail, pm, PendingAcknowledgement::pm, and PendingMessage::tail_frag.

Referenced by completed_pending_message(), and free_pending_message().

2897 {
2898  struct PendingMessage *frag;
2899 
2900  while (NULL != (frag = root->head_frag))
2901  {
2902  struct PendingAcknowledgement *pa;
2903 
2904  free_fragment_tree (frag);
2905  while (NULL != (pa = frag->pa_head))
2906  {
2907  GNUNET_CONTAINER_MDLL_remove (pm, frag->pa_head, frag->pa_tail, pa);
2908  pa->pm = NULL;
2909  }
2910  GNUNET_CONTAINER_MDLL_remove (frag, root->head_frag, root->tail_frag, frag);
2911  GNUNET_free (frag);
2912  }
2913 }
struct PendingAcknowledgement * pa_tail
Tail of DLL of PAs for this pending message.
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.
#define GNUNET_CONTAINER_MDLL_remove(mdll, head, tail, element)
Remove an element from a MDLL.
struct PendingAcknowledgement * pa_head
Head of DLL of PAs for this pending message.
struct PendingMessage * pm
Message that was transmitted, may be NULL if the message was ACKed via another channel.
List containing all messages that are yet to be send.
struct PendingMessage * head_frag
Head of a MDLL of fragments created for this core message.
#define GNUNET_free(ptr)
Wrapper around free.
static struct GNUNET_TRANSPORT_PluginMonitor * pm
Handle if we are monitoring plugin session activity.
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 2924 of file gnunet-service-tng.c.

References PendingMessage::bpm, PendingMessage::client, TransportClient::core, TransportClient::details, free_fragment_tree(), GNUNET_assert, GNUNET_CONTAINER_MDLL_remove, GNUNET_free, PendingMessage::pa_head, PendingMessage::pa_tail, VirtualLink::pending_msg_head, VirtualLink::pending_msg_tail, PendingAcknowledgement::pm, QueueEntry::pm, PendingMessage::qe, tc, and PendingMessage::vl.

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

2925 {
2926  struct TransportClient *tc = pm->client;
2927  struct VirtualLink *vl = pm->vl;
2928  struct PendingAcknowledgement *pa;
2929 
2930  if (NULL != tc)
2931  {
2933  tc->details.core.pending_msg_head,
2934  tc->details.core.pending_msg_tail,
2935  pm);
2936  }
2937  if (NULL != vl)
2938  {
2940  vl->pending_msg_head,
2941  vl->pending_msg_tail,
2942  pm);
2943  }
2944  while (NULL != (pa = pm->pa_head))
2945  {
2946  GNUNET_CONTAINER_MDLL_remove (pm, pm->pa_head, pm->pa_tail, pa);
2947  pa->pm = NULL;
2948  }
2949 
2950  free_fragment_tree (pm);
2951  if (NULL != pm->qe)
2952  {
2953  GNUNET_assert (pm == pm->qe->pm);
2954  pm->qe->pm = NULL;
2955  }
2956  if (NULL != pm->bpm)
2957  {
2958  free_fragment_tree (pm->bpm);
2959  GNUNET_free (pm->bpm);
2960  }
2961  GNUNET_free (pm);
2962 }
struct TransportClient::@75::@76 core
Information for type CT_CORE.
struct PendingAcknowledgement * pa_tail
Tail of DLL of PAs for this pending message.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static struct GNUNET_SCHEDULER_TaskContext tc
Task context of the current task.
Definition: scheduler.c:417
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 QueueEntry * qe
Set to non-NULL value if this message is currently being given to a communicator and we are awaiting ...
struct PendingMessage * bpm
This message, reliability or DV-boxed.
#define GNUNET_CONTAINER_MDLL_remove(mdll, head, tail, element)
Remove an element from a MDLL.
struct PendingMessage * pm
Pending message this entry is for, or NULL for none.
struct TransportClient * client
Client that issued the transmission request, if pmt is PMT_CORE.
struct PendingAcknowledgement * pa_head
Head of DLL of PAs for this pending message.
struct VirtualLink * vl
Target of the request (always the ultimate destination!).
union TransportClient::@75 details
struct PendingMessage * pm
Message that was transmitted, may be NULL if the message was ACKed via another channel.
Client connected to the transport service.
#define GNUNET_free(ptr)
Wrapper around free.
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 2971 of file gnunet-service-tng.c.

References VirtualLink::csc_head, VirtualLink::csc_tail, VirtualLink::dv, VirtualLink::fc_retransmit_task, free_pending_message(), GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multipeermap_remove(), GNUNET_free, GNUNET_SCHEDULER_cancel(), GNUNET_YES, VirtualLink::n, VirtualLink::pending_msg_head, pm, VirtualLink::target, VirtualLink::visibility_task, and CoreSentContext::vl.

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

2972 {
2973  struct PendingMessage *pm;
2974  struct CoreSentContext *csc;
2975 
2976  while (NULL != (pm = vl->pending_msg_head))
2977  free_pending_message (pm);
2980  if (NULL != vl->visibility_task)
2981  {
2983  vl->visibility_task = NULL;
2984  }
2985  if (NULL != vl->fc_retransmit_task)
2986  {
2988  vl->fc_retransmit_task = NULL;
2989  }
2990  while (NULL != (csc = vl->csc_head))
2991  {
2993  GNUNET_assert (vl == csc->vl);
2994  csc->vl = NULL;
2995  }
2996  GNUNET_break (NULL == vl->n);
2997  GNUNET_break (NULL == vl->dv);
2998  GNUNET_free (vl);
2999 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
Closure for core_env_sent_cb.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
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.
struct VirtualLink * vl
Virtual link this is about.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static struct GNUNET_CONTAINER_MultiPeerMap * links
Map from PIDs to struct VirtualLink entries describing links CORE knows to exist. ...
List containing all messages that are yet to be send.
#define GNUNET_YES
Definition: gnunet_common.h:80
static void free_pending_message(struct PendingMessage *pm)
Release memory associated with pm and remove pm from associated data structures.
#define GNUNET_free(ptr)
Wrapper around free.
static struct GNUNET_TRANSPORT_PluginMonitor * pm
Handle if we are monitoring plugin session activity.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965
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 3008 of file gnunet-service-tng.c.

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

Referenced by free_validation_state_cb(), and validation_start_cb().

3009 {
3010  GNUNET_assert (
3011  GNUNET_YES ==
3014  vs->hn = NULL;
3015  if (NULL != vs->sc)
3016  {
3018  vs->sc = NULL;
3019  }
3020  GNUNET_free (vs->address);
3021  GNUNET_free (vs);
3022 }
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
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.
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...
#define GNUNET_YES
Definition: gnunet_common.h:80
void * GNUNET_CONTAINER_heap_remove_node(struct GNUNET_CONTAINER_HeapNode *node)
Removes a node from the heap.
#define GNUNET_free(ptr)
Wrapper around free.
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 3032 of file gnunet-service-tng.c.

References GNUNET_CONTAINER_multipeermap_get().

Referenced by find_queue(), handle_add_queue_message(), handle_dv_box(), handle_dv_learn(), handle_fragment_box(), handle_validation_challenge(), learn_dv_path(), and route_control_message_without_fc().

3033 {
3035 }
static struct GNUNET_CONTAINER_MultiPeerMap * neighbours
Map from PIDs to struct Neighbour entries.
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.
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 3045 of file gnunet-service-tng.c.

References GNUNET_CONTAINER_multipeermap_get().

Referenced by activate_core_visible_dv_path(), free_queue(), handle_client_recv_ok(), handle_client_send(), handle_flow_control(), handle_raw_message(), handle_validation_challenge(), handle_validation_response(), and route_control_message_without_fc().

3046 {
3048 }
static struct GNUNET_CONTAINER_MultiPeerMap * links
Map from PIDs to struct VirtualLink entries describing links CORE knows to exist. ...
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.
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 .

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 3094 of file gnunet-service-tng.c.

References check_link_down(), 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().

3095 {
3096  struct Neighbour *n = dvh->next_hop;
3097  struct DistanceVector *dv = dvh->dv;
3098  struct PendingAcknowledgement *pa;
3099 
3100  while (NULL != (pa = dvh->pa_head))
3101  {
3102  GNUNET_CONTAINER_MDLL_remove (dvh, dvh->pa_head, dvh->pa_tail, pa);
3103  pa->dvh = NULL;
3104  }
3105  GNUNET_CONTAINER_MDLL_remove (neighbour, n->dv_head, n->dv_tail, dvh);
3106  GNUNET_CONTAINER_MDLL_remove (dv, dv->dv_head, dv->dv_tail, dvh);
3107  GNUNET_free (dvh);
3108 }
A connected controller which is not our child.
struct PendingAcknowledgement * pa_head
Head of DLL of PAs that used our path.
Entry in our dv_routes table, representing a (set of) distance vector routes to a particular peer...
struct DistanceVectorHop * dvh
Distance vector path chosen for this transmission, NULL if transmission was to a direct neighbour OR ...
struct DistanceVectorHop * dv_tail
Known paths to target.
struct DistanceVectorHop * dv_head
Head of MDLL of DV hops that have this neighbour as next hop.
struct DistanceVector * dv
Distance vector entry this hop belongs with.
Data structure kept when we are waiting for an acknowledgement.
#define GNUNET_CONTAINER_MDLL_remove(mdll, head, tail, element)
Remove an element from a MDLL.
struct DistanceVectorHop * dv_tail
Tail of MDLL of DV hops that have this neighbour as next hop.
struct Neighbour * next_hop
What would be the next hop to target?
struct PendingAcknowledgement * pa_tail
Tail of DLL of PAs that used our path.
struct DistanceVectorHop * dv_head
Known paths to target.
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
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 3528 of file gnunet-service-tng.c.

References cores_send_disconnect_info(), VirtualLink::dv, DistanceVector::dv_head, free_virtual_link(), 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_distance_vector_hop(), free_dv_route(), free_neighbour(), free_queue(), and handle_validation_response().

3529 {
3530  struct VirtualLink *vl = cls;
3531  struct DistanceVector *dv = vl->dv;
3532  struct Neighbour *n = vl->n;
3533  struct GNUNET_TIME_Absolute dvh_timeout;
3534  struct GNUNET_TIME_Absolute q_timeout;
3535 
3536  vl->visibility_task = NULL;
3537  dvh_timeout = GNUNET_TIME_UNIT_ZERO_ABS;
3538  for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos;
3539  pos = pos->next_dv)
3540  dvh_timeout = GNUNET_TIME_absolute_max (dvh_timeout, pos->path_valid_until);
3541  if (0 == GNUNET_TIME_absolute_get_remaining (dvh_timeout).rel_value_us)
3542  {
3543  vl->dv->vl = NULL;
3544  vl->dv = NULL;
3545  }
3546  q_timeout = GNUNET_TIME_UNIT_ZERO_ABS;
3547  for (struct Queue *q = n->queue_head; NULL != q; q = q->next_neighbour)
3548  q_timeout = GNUNET_TIME_absolute_max (q_timeout, q->validated_until);
3549  if (0 == GNUNET_TIME_absolute_get_remaining (q_timeout).rel_value_us)
3550  {
3551  vl->n->vl = NULL;
3552  vl->n = NULL;
3553  }
3554  if ((NULL == vl->n) && (NULL == vl->dv))
3555  {
3557  free_virtual_link (vl);
3558  return;
3559  }
3560  vl->visibility_task =
3561  GNUNET_SCHEDULER_add_at (GNUNET_TIME_absolute_max (q_timeout, dvh_timeout),
3562  &check_link_down,
3563  vl);
3564 }
A connected controller which is not our child.
#define GNUNET_TIME_UNIT_ZERO_ABS
Absolute time zero.
Entry in our dv_routes table, representing a (set of) distance vector routes to a particular peer...
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...
Handle for a queue.
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:317
static void cores_send_disconnect_info(const struct GNUNET_PeerIdentity *pid)
Send message to CORE clients that we lost a connection.
static struct GNUNET_REVOCATION_Query * q
Handle for revocation query.
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...
One possible hop towards a DV target.
struct DistanceVectorHop * next_dv
Kept in a MDLL, sorted by timeout.
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_remaining(struct GNUNET_TIME_Absolute future)
Given a timestamp in the future, how much time remains until then?
Definition: time.c:331
Time for absolute times used by GNUnet, in microseconds.
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:1223
struct DistanceVectorHop * dv_head
Known paths to target.
struct Queue * queue_head
Head of DLL of queues to this peer.
static void free_virtual_link(struct VirtualLink *vl)
Free virtual link.
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 3127 of file gnunet-service-tng.c.

References 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().

3128 {
3130  "Informing CORE clients about disconnect from %s\n",
3131  GNUNET_i2s (pid));
3132  for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next)
3133  {
3134  struct GNUNET_MQ_Envelope *env;
3135  struct DisconnectInfoMessage *dim;
3136 
3137  if (CT_CORE != tc->type)
3138  continue;
3140  dim->peer = *pid;
3141  GNUNET_MQ_send (tc->mq, env);
3142  }
3143 }
static struct GNUNET_SCHEDULER_TaskContext tc
Task context of the current task.
Definition: scheduler.c:417
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
static struct TransportClient * clients_head
Head of linked list of all clients to this service.
#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:153
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
Is the CORE service, we need to forward traffic to it.
struct GNUNET_PeerIdentity peer
Who got disconnected?
Definition: transport.h:169
Client connected to the transport service.
#define GNUNET_log(kind,...)
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:353
static struct GNUNET_PeerIdentity pid
Identity of the peer we transmit to / connect to.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
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 3153 of file gnunet-service-tng.c.

References check_link_down(), cores_send_disconnect_info(), VirtualLink::dv, DistanceVector::dv_head, 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().

3154 {
3155  struct DistanceVectorHop *dvh;
3156 
3157  while (NULL != (dvh = dv->dv_head))
3159  if (NULL == dv->dv_head)
3160  {
3161  struct VirtualLink *vl;
3162 
3163  GNUNET_assert (
3164  GNUNET_YES ==
3166  if (NULL != (vl = dv->vl))
3167  {
3168  GNUNET_assert (dv == vl->dv);
3169  vl->dv = NULL;
3170  if (NULL == vl->n)
3171  {
3173  free_virtual_link (vl);
3174  }
3175  else
3176  {
3179  }
3180  dv->vl = NULL;
3181  }
3182 
3183  if (NULL != dv->timeout_task)
3184  {
3186  dv->timeout_task = NULL;
3187  }
3188  GNUNET_free (dv);
3189  }
3190 }
struct VirtualLink * vl
Do we have a confirmed working queue and are thus visible to CORE? If so, this is the virtual link...
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
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.
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:1273
static void cores_send_disconnect_info(const struct GNUNET_PeerIdentity *pid)
Send message to CORE clients that we lost a connection.
struct GNUNET_SCHEDULER_Task * timeout_task
Task scheduled to purge expired paths from dv_head MDLL.
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...
static void free_distance_vector_hop(struct DistanceVectorHop *dvh)
Free a .
One possible hop towards a DV target.
#define GNUNET_YES
Definition: gnunet_common.h:80
struct GNUNET_PeerIdentity target
To which peer is this a route?
struct DistanceVectorHop * dv_head
Known paths to target.
static void free_virtual_link(struct VirtualLink *vl)
Free virtual link.
#define GNUNET_free(ptr)
Wrapper around free.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965
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 3207 of file gnunet-service-tng.c.

References MonitorEvent::cs, env, GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_DATA, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_TIME_absolute_hton(), GNUNET_TIME_relative_hton(), MonitorEvent::last_validation, TransportClient::mq, MonitorEvent::next_validation, MonitorEvent::num_bytes_pending, MonitorEvent::num_msg_pending, peer, MonitorEvent::rtt, and MonitorEvent::valid_until.

Referenced by notify_client_queues(), and notify_monitors().

3212 {
3213  struct GNUNET_MQ_Envelope *env;
3214  struct GNUNET_TRANSPORT_MonitorData *md;
3215  size_t addr_len = strlen (address) + 1;
3216 
3217  env = GNUNET_MQ_msg_extra (md,
3218  addr_len,
3220  md->nt = htonl ((uint32_t) nt);
3221  md->peer = *peer;
3222  md->last_validation = GNUNET_TIME_absolute_hton (me->last_validation);
3223  md->valid_until = GNUNET_TIME_absolute_hton (me->valid_until);
3224  md->next_validation = GNUNET_TIME_absolute_hton (me->next_validation);
3225  md->rtt = GNUNET_TIME_relative_hton (me->rtt);
3226  md->cs = htonl ((uint32_t) me->cs);
3227  md->num_msg_pending = htonl (me->num_msg_pending);
3228  md->num_bytes_pending = htonl (me->num_bytes_pending);
3229  memcpy (&md[1], address, addr_len);
3230  GNUNET_MQ_send (tc->mq, env);
3231 }
enum GNUNET_TRANSPORT_ConnectionStatus cs
Connection status.
#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
struct GNUNET_TIME_Absolute next_validation
#define GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_DATA
Message sent to indicate to a monitor about events.
struct GNUNET_TIME_Absolute valid_until
static struct GNUNET_NAT_AUTO_Test * nt
Handle to a NAT test operation.
uint32_t num_msg_pending
Messages pending.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
struct GNUNET_MQ_Handle * mq
Message queue to the client.
struct GNUNET_TIME_RelativeNBO GNUNET_TIME_relative_hton(struct GNUNET_TIME_Relative a)
Convert relative time to network byte order.
Definition: time.c:622
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
struct GNUNET_TIME_Absolute last_validation
uint32_t num_bytes_pending
Bytes pending.
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:353
struct GNUNET_TIME_AbsoluteNBO GNUNET_TIME_absolute_hton(struct GNUNET_TIME_Absolute a)
Convert absolute time to network byte order.
Definition: time.c:654
static char * address
GNS address for this phone.
struct GNUNET_TIME_Relative rtt
Current round-trip time estimate.
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 3244 of file gnunet-service-tng.c.

References CT_MONITOR, GNUNET_is_zero, GNUNET_memcmp, notify_monitor(), and tc.

Referenced by free_queue(), and handle_add_queue_message().

3248 {
3249  for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next)
3250  {
3251  if (CT_MONITOR != tc->type)
3252  continue;
3253  if (tc->details.monitor.one_shot)
3254  continue;
3255  if ((0 != GNUNET_is_zero (&tc->details.monitor.peer)) &&
3256  (0 != GNUNET_memcmp (&tc->details.monitor.peer, peer)))
3257  continue;
3258  notify_monitor (tc, peer, address, nt, me);
3259  }
3260 }
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.
static struct GNUNET_SCHEDULER_TaskContext tc
Task context of the current task.
Definition: scheduler.c:417
static struct TransportClient * clients_head
Head of linked list of all clients to this service.
static struct GNUNET_NAT_AUTO_Test * nt
Handle to a NAT test operation.
#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.
It is a monitor, forward monitor data.
Client connected to the transport service.
static char * address
GNS address for this phone.
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 3273 of file gnunet-service-tng.c.

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

Referenced by run().

3276 {
3277  struct TransportClient *tc;
3278 
3279  (void) cls;
3280  tc = GNUNET_new (struct TransportClient);
3281  tc->client = client;
3282  tc->mq = mq;
3284  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Client %p connected\n", tc);
3285  return tc;
3286 }
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
static struct GNUNET_SCHEDULER_TaskContext tc
Task context of the current task.
Definition: scheduler.c:417
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_SERVICE_Client * client
Handle to the client.
static struct TransportClient * clients_tail
Tail of linked list of all clients to this service.
static struct TransportClient * clients_head
Head of linked list of all clients to this service.
struct GNUNET_MQ_Handle * mq
Message queue to the client.
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
Client connected to the transport service.
#define GNUNET_log(kind,...)
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 3295 of file gnunet-service-tng.c.

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

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

3296 {
3297  struct Neighbour *n = rc->neighbour;
3298 
3302  rc->msg_uuid.uuid,
3303  rc));
3304  GNUNET_free (rc);
3305 }
A connected controller which is not our child.
struct Neighbour * neighbour
Which neighbour is this context for?
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
uint64_t uuid
Unique value, generated by incrementing the message_uuid_ctr of struct Neighbour. ...
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.
struct GNUNET_CONTAINER_MultiHashMap32 * reassembly_map
Map with struct ReassemblyContext structs for fragments under reassembly.
struct GNUNET_CONTAINER_HeapNode * hn
Entry in the reassembly heap (sorted by expiration).
void * GNUNET_CONTAINER_heap_remove_node(struct GNUNET_CONTAINER_HeapNode *node)
Removes a node from the heap.
#define GNUNET_free(ptr)
Wrapper around free.
struct MessageUUIDP msg_uuid
Original message ID for of the message that all the fragments belong to.
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 3314 of file gnunet-service-tng.c.

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

Referenced by handle_fragment_box().

3315 {
3316  struct Neighbour *n = cls;
3317  struct ReassemblyContext *rc;
3318 
3319  n->reassembly_timeout_task = NULL;
3320  while (NULL != (rc = GNUNET_CONTAINER_heap_peek (n->reassembly_heap)))
3321  {
3323  .rel_value_us)
3324  {
3326  continue;
3327  }
3332  n);
3333  return;
3334  }
3335 }
A connected controller which is not our child.
uint64_t rel_value_us
The actual value.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static void reassembly_cleanup_task(void *cls)
Task run to clean up reassembly context of a neighbour that have expired.
Information we keep for a message that we are reassembling.
struct GNUNET_SCHEDULER_Task * reassembly_timeout_task
Task to free old entries from the reassembly_heap and reassembly_map.
void * GNUNET_CONTAINER_heap_peek(const struct GNUNET_CONTAINER_Heap *heap)
Get element stored at the root of heap.
static void free_reassembly_context(struct ReassemblyContext *rc)
Free rc.
struct GNUNET_CONTAINER_Heap * reassembly_heap
Heap with struct ReassemblyContext structs for fragments under reassembly.
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_remaining(struct GNUNET_TIME_Absolute future)
Given a timestamp in the future, how much time remains until then?
Definition: time.c:331
struct GNUNET_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:1223
struct GNUNET_TIME_Absolute reassembly_timeout
At what time will we give up reassembly of this message?
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 3347 of file gnunet-service-tng.c.

References free_reassembly_context(), GNUNET_OK, and value.

Referenced by free_neighbour().

3348 {
3349  struct ReassemblyContext *rc = value;
3350 
3351  (void) cls;
3352  (void) key;
3354  return GNUNET_OK;
3355 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
Information we keep for a message that we are reassembling.
static char * value
Value of the record to add/remove.
struct GNUNET_HashCode key
The key used in the DHT.
static void free_reassembly_context(struct ReassemblyContext *rc)
Free rc.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ free_neighbour()

static void free_neighbour ( struct Neighbour neighbour)
static

Release memory used by neighbour.

Parameters
neighbourneighbour entry to free

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

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_reassembly_cb(), free_virtual_link(), Neighbour::get, GNUNET_assert, GNUNET_CONTAINER_heap_destroy(), GNUNET_CONTAINER_multihashmap32_destroy(), GNUNET_CONTAINER_multihashmap32_iterate(), GNUNET_CONTAINER_multipeermap_remove(), GNUNET_free, GNUNET_PEERSTORE_iterate_cancel(), GNUNET_PEERSTORE_store_cancel(), GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), GNUNET_YES, VirtualLink::n, Neighbour::pid, Neighbour::queue_head, Neighbour::reassembly_heap, Neighbour::reassembly_map, Neighbour::reassembly_timeout_task, Neighbour::sc, VirtualLink::target, VirtualLink::visibility_task, and Neighbour::vl.

Referenced by free_neighbour_cb(), and free_queue().

3365 {
3366  struct DistanceVectorHop *dvh;
3367  struct VirtualLink *vl;
3368 
3369  GNUNET_assert (NULL == neighbour->queue_head);
3372  &neighbour->pid,
3373  neighbour));
3374  if (NULL != neighbour->reassembly_map)
3375  {
3378  NULL);
3380  neighbour->reassembly_map = NULL;
3382  neighbour->reassembly_heap = NULL;
3383  }
3384  while (NULL != (dvh = neighbour->dv_head))
3385  {
3386  struct DistanceVector *dv = dvh->dv;
3387 
3389  if (NULL == dv->dv_head)
3390  free_dv_route (dv);
3391  }
3392  if (NULL != neighbour->reassembly_timeout_task)
3393  {
3395  neighbour->reassembly_timeout_task = NULL;
3396  }
3397  if (NULL != neighbour->get)
3398  {
3399  GNUNET_PEERSTORE_iterate_cancel (neighbour->get);
3400  neighbour->get = NULL;
3401  }
3402  if (NULL != neighbour->sc)
3403  {
3404  GNUNET_PEERSTORE_store_cancel (neighbour->sc);
3405  neighbour->sc = NULL;
3406  }
3407  if (NULL != (vl = neighbour->vl))
3408  {
3409  GNUNET_assert (neighbour == vl->n);
3410  vl->n = NULL;
3411  if (NULL == vl->dv)
3412  {
3414  free_virtual_link (vl);
3415  }
3416  else
3417  {
3420  }
3421  neighbour->vl = NULL;
3422  }
3423  GNUNET_free (neighbour);
3424 }
static struct GNUNET_CONTAINER_MultiPeerMap * neighbours
Map from PIDs to struct Neighbour entries.
Entry in our dv_routes table, representing a (set of) distance vector routes to a particular peer...
static int free_reassembly_cb(void *cls, uint32_t key, void *value)
function called to free_reassembly_context().
int GNUNET_CONTAINER_multihashmap32_iterate(struct GNUNET_CONTAINER_MultiHashMap32 *map, GNUNET_CONTAINER_MulitHashMapIterator32Callback it, void *it_cls)
Iterate over all entries in the map.
struct VirtualLink * vl
Do we have a confirmed working queue and are thus visible to CORE? If so, this is the virtual link...
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_PEERSTORE_StoreContext * sc
Handle to a PEERSTORE store operation to store this pid's last_dv_learn_monotime. ...
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.
struct DistanceVectorHop * dv_head
Head of MDLL of DV hops that have this neighbour as next hop.
struct DistanceVector * dv
Distance vector entry this hop belongs with.
static void free_dv_route(struct DistanceVector *dv)
Free entry in dv_routes.
struct GNUNET_SCHEDULER_Task * reassembly_timeout_task
Task to free old entries from the reassembly_heap and reassembly_map.
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:1273
void GNUNET_PEERSTORE_store_cancel(struct GNUNET_PEERSTORE_StoreContext *sc)
Cancel a store request.
static void cores_send_disconnect_info(const struct GNUNET_PeerIdentity *pid)
Send message to CORE clients that we lost a connection.
void GNUNET_CONTAINER_heap_destroy(struct GNUNET_CONTAINER_Heap *heap)
Destroys the heap.
void GNUNET_CONTAINER_multihashmap32_destroy(struct GNUNET_CONTAINER_MultiHashMap32 *map)
Destroy a 32-bit key hash map.
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_CONTAINER_MultiHashMap32 * reassembly_map
Map with struct ReassemblyContext structs for fragments under reassembly.
static void free_distance_vector_hop(struct DistanceVectorHop *dvh)
Free a .
One possible hop towards a DV target.
struct GNUNET_CONTAINER_Heap * reassembly_heap
Heap with struct ReassemblyContext structs for fragments under reassembly.
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_IterateContext * get
Handle for an operation to fetch last_dv_learn_monotime information from the PEERSTORE, or NULL.
#define GNUNET_YES
Definition: gnunet_common.h:80
struct DistanceVectorHop * dv_head
Known paths to target.
struct Queue * queue_head
Head of DLL of queues to this peer.
static void free_virtual_link(struct VirtualLink *vl)
Free virtual link.
#define GNUNET_free(ptr)
Wrapper around free.
struct GNUNET_PeerIdentity pid
Which peer is this about?
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965
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 3434 of file gnunet-service-tng.c.

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

Referenced by cores_send_connect_info(), and notify_client_connect_info().

3436 {
3437  struct GNUNET_MQ_Envelope *env;
3438  struct ConnectInfoMessage *cim;
3439 
3440  GNUNET_assert (CT_CORE == tc->type);
3442  cim->id = *pid;
3443  GNUNET_MQ_send (tc->mq, env);
3444 }
struct GNUNET_PeerIdentity id
Identity of the new neighbour.
Definition: transport.h:145
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
enum ClientType type
What type of client is this?
#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_MQ_Handle * mq
Message queue to the client.
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
Is the CORE service, we need to forward traffic to it.
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:353
static struct GNUNET_PeerIdentity pid
Identity of the peer we transmit to / connect to.
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 3453 of file gnunet-service-tng.c.

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

Referenced by activate_core_visible_dv_path(), and handle_validation_response().

3454 {
3456  "Informing CORE clients about connection to %s\n",
3457  GNUNET_i2s (pid));
3458  for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next)
3459  {
3460  if (CT_CORE != tc->type)
3461  continue;
3462  core_send_connect_info (tc, pid);
3463  }
3464 }
static struct GNUNET_SCHEDULER_TaskContext tc
Task context of the current task.
Definition: scheduler.c:417
static struct TransportClient * clients_head
Head of linked list of all clients to this service.
Is the CORE service, we need to forward traffic to it.
Client connected to the transport service.
#define GNUNET_log(kind,...)
static void core_send_connect_info(struct TransportClient *tc, const struct GNUNET_PeerIdentity *pid)
Send message to CORE clients that we lost a connection.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
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 8753 of file gnunet-service-tng.c.

References Queue::address, PerformanceData::aged_rtt, PendingMessageScoreContext::best, PendingMessage::bpm, PendingMessage::bytes_msg, TransportClient::communicator, completed_pending_message(), PendingMessageScoreContext::consideration_counter, TransportClient::details, DistanceVectorHop::dv, Neighbour::dv_head, PendingMessageScoreContext::dvh, encapsulate_for_dv(), extract_box_cb(), PendingMessageScoreContext::frag, fragment_message(), free_pending_message(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_SCHEDULER_PRIORITY_DEFAULT, GNUNET_TIME_relative_multiply(), GNUNET_TIME_relative_to_absolute(), GNUNET_TRANSPORT_CC_RELIABLE, GNUNET_YES, Queue::idle, PendingMessage::logging_uuid, Queue::neighbour, DistanceVectorHop::next_neighbour, VirtualLink::outbound_fc_window_size_used, Queue::pd, Neighbour::pid, pm, PendingMessage::pmt, PMT_CORE, PMT_DV_BOX, queue(), queue_send_msg(), PendingMessageScoreContext::relb, reliability_box_message(), RMO_NONE, schedule_transmit_on_queue(), select_best_pending_from_link(), Queue::tc, Queue::transmit_task, update_pm_next_attempt(), Neighbour::vl, and PendingMessage::vl.

Referenced by cores_send_connect_info(), and schedule_transmit_on_queue().

8754 {
8755  struct Queue *queue = cls;
8756  struct Neighbour *n = queue->neighbour;
8758  struct PendingMessage *pm;
8759 
8760  queue->transmit_task = NULL;
8761  if (NULL == n->vl)
8762  {
8764  "Virtual link `%s' is down, cannot have PM for queue `%s'\n",
8765  GNUNET_i2s (&n->pid),
8766  queue->address);
8767  queue->idle = GNUNET_YES;
8768  return;
8769  }
8770  memset (&sc, 0, sizeof (sc));
8771  select_best_pending_from_link (&sc, queue, n->vl, NULL, 0);
8772  if (NULL == sc.best)
8773  {
8774  /* Also look at DVH that have the n as first hop! */
8775  for (struct DistanceVectorHop *dvh = n->dv_head; NULL != dvh;
8776  dvh = dvh->next_neighbour)
8777  {
8779  queue,
8780  dvh->dv->vl,
8781  dvh,
8782  sizeof (struct GNUNET_PeerIdentity) *
8783  (1 + dvh->distance) +
8784  sizeof (struct TransportDVBoxMessage) +
8785  sizeof (struct TransportDVBoxPayloadP));
8786  }
8787  }
8788  if (NULL == sc.best)
8789  {
8790  /* no message pending, nothing to do here! */
8792  "No pending messages, queue `%s' to %s now idle\n",
8793  queue->address,
8794  GNUNET_i2s (&n->pid));
8795  queue->idle = GNUNET_YES;
8796  return;
8797  }
8798 
8799  /* Given selection in `sc`, do transmission */
8800  pm = sc.best;
8801  if (NULL != sc.dvh)
8802  {
8803  GNUNET_assert (PMT_DV_BOX != pm->pmt);
8804  if (NULL != sc.best->bpm)
8805  {
8806  /* We did this boxing before, but possibly for a different path!
8807  Discard old DV box! OPTIMIZE-ME: we might want to check if
8808  it is the same and then not re-build the message... */
8809  free_pending_message (sc.best->bpm);
8810  sc.best->bpm = NULL;
8811  }
8812  encapsulate_for_dv (sc.dvh->dv,
8813  1,
8814  &sc.dvh,
8815  (const struct GNUNET_MessageHeader *) &sc.best[1],
8816  &extract_box_cb,
8817  &sc,
8818  RMO_NONE);
8819  GNUNET_assert (NULL != sc.best->bpm);
8820  pm = sc.best->bpm;
8821  }
8822  if (GNUNET_YES == sc.frag)
8823  {
8824  pm = fragment_message (queue, sc.dvh, pm);
8825  if (NULL == pm)
8826  {
8828  "Fragmentation failed queue %s to %s for <%llu>, trying again\n",
8829  queue->address,
8830  GNUNET_i2s (&n->pid),
8831  sc.best->logging_uuid);
8833  return;
8834  }
8835  }
8836  else if (GNUNET_YES == sc.relb)
8837  {
8838  pm = reliability_box_message (queue, sc.dvh, pm);
8839  if (NULL == pm)
8840  {
8841  /* Reliability boxing failed, try next message... */
8842  GNUNET_log (
8844  "Reliability boxing failed queue %s to %s for <%llu>, trying again\n",
8845  queue->address,
8846  GNUNET_i2s (&n->pid),
8847  sc.best->logging_uuid);
8849  return;
8850  }
8851  }
8852 
8853  /* Pass 'pm' for transission to the communicator */
8854  GNUNET_log (
8856  "Passing message <%llu> to queue %s for peer %s (considered %u others)\n",
8857  pm->logging_uuid,
8858  queue->address,
8859  GNUNET_i2s (&n->pid),
8860  sc.consideration_counter);
8861 
8862  /* Flow control: increment amount of traffic sent; if we are routing
8863  via DV (and thus the ultimate target of the pending message is for
8864  a different virtual link than the one of the queue), then we need
8865  to use up not only the window of the direct link but also the
8866  flow control window for the DV link! */
8868 
8869  if (pm->vl != queue->neighbour->vl)
8870  {
8871  /* If the virtual link of the queue differs, this better be distance
8872  vector routing! */
8873  GNUNET_assert (NULL != sc.dvh);
8874  /* If we do distance vector routing, we better not do this for a
8875  message that was itself DV-routed */
8876  GNUNET_assert (PMT_DV_BOX != sc.best->pmt);
8877  /* We use the size of the unboxed message here, to avoid counting
8878  the DV-Box header which is eaten up on the way by intermediaries */
8879  queue->neighbour->vl->outbound_fc_window_size_used += sc.best->bytes_msg;
8880  }
8881  else
8882  {
8883  GNUNET_assert (NULL == sc.dvh);
8884  }
8885 
8886  queue_send_msg (queue, pm, &pm[1], pm->bytes_msg);
8887 
8888  /* Check if this transmission somehow conclusively finished handing 'pm'
8889  even without any explicit ACKs */
8890  if ((PMT_CORE == pm->pmt) ||
8892  {
8894  }
8895  else
8896  {
8897  /* Message not finished, waiting for acknowledgement.
8898  Update time by which we might retransmit 's' based on queue
8899  characteristics (i.e. RTT); it takes one RTT for the message to
8900  arrive and the ACK to come back in the best case; but the other
8901  side is allowed to delay ACKs by 2 RTTs, so we use 4 RTT before
8902  retransmitting.
8903 
8904  OPTIMIZE: Note that in the future this heuristic should likely
8905  be improved further (measure RTT stability, consider message
8906  urgency and size when delaying ACKs, etc.) */
8910  4)));
8911  }
8912  /* finally, re-schedule queue transmission task itself */
8914 }
A connected controller which is not our child.
static void queue(const char *hostname)
Add hostname to the list of requests to be made.
Transmission is reliabile (with ACKs), i.e.
Context for select_best_pending_from_link().
struct Neighbour * neighbour
Which neighbour is this queue for?
uint16_t bytes_msg
Size of the original message.
int idle
Set to GNUNET_YES if this queue is idle waiting for some virtual link to give it a pending message...
Ordinary message received from the CORE service.
unsigned long long logging_uuid
UUID we use to identify this message in our logs.
Outer layer of an encapsulated message send over multiple hops.
struct VirtualLink * vl
Do we have a confirmed working queue and are thus visible to CORE? If so, this is the virtual link...
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:245
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
Pending message created during forward_dv_box().
struct DistanceVectorHop * dv_head
Head of MDLL of DV hops that have this neighbour as next hop.
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.
struct GNUNET_SCHEDULER_Task * transmit_task
Task scheduled for the time when this queue can (likely) transmit the next message.
Only confirmed, non-DV direct neighbours.
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)
Pick a path of dv under constraints options and schedule transmission of hdr.
struct TransportClient::@75::@78 communicator
Information for type CT_COMMUNICATOR.
struct PerformanceData pd
Performance data for this queue.
Handle for a queue.
enum PendingMessageType pmt
Type of the pending message.
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:439
struct TransportClient * tc
Which communicator offers this queue?
static struct PendingMessage * fragment_message(struct Queue *queue, struct DistanceVectorHop *dvh, struct PendingMessage *pm)
Fragment the given pm to the given mtu.
static struct GNUNET_FS_SearchContext * sc
Definition: gnunet-search.c:37
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 ...
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...
struct GNUNET_TIME_Relative aged_rtt
Weighted average for the RTT.
struct DistanceVectorHop * next_neighbour
Kept in a MDLL.
struct VirtualLink * vl
Target of the request (always the ultimate destination!).
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...
The identity of the host (wraps the signing key of the peer).
struct sockaddr * address
Address of the other peer.
One possible hop towards a DV target.
union TransportClient::@75 details
Plaintext of the variable-size payload that is encrypted within a struct TransportBackchannelEncapsul...
static void schedule_transmit_on_queue(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 ...
#define GNUNET_log(kind,...)
List containing all messages that are yet to be send.
static struct PendingMessage * reliability_box_message(struct Queue *queue, struct DistanceVectorHop *dvh, struct PendingMessage *pm)
Reliability-box the given pm.
static void queue_send_msg(struct Queue *queue, struct PendingMessage *pm, const void *payload, size_t payload_size)
Send the message payload on queue.
Header for all communications.
#define GNUNET_YES
Definition: gnunet_common.h:80
Run with the default priority (normal P2P operations).
static void free_pending_message(struct PendingMessage *pm)
Release memory associated with pm and remove pm from associated data structures.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
static struct GNUNET_TRANSPORT_PluginMonitor * pm
Handle if we are monitoring plugin session activity.
struct GNUNET_PeerIdentity pid
Which peer is this about?
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 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 3486 of file gnunet-service-tng.c.

References Queue::address, TransportClient::communicator, COMMUNICATOR_TOTAL_QUEUE_LIMIT, TransportClient::details, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_add_with_priority(), GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_update(), Queue::idle, Queue::neighbour, Neighbour::pid, Queue::queue_length, QUEUE_LENGTH_LIMIT, Queue::tc, transmit_on_queue(), and Queue::transmit_task.

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

3488 {
3489  if (queue->tc->details.communicator.total_queue_length >=
3491  {
3493  GST_stats,
3494  "# Transmission throttled due to communicator queue limit",
3495  1,
3496  GNUNET_NO);
3497  queue->idle = GNUNET_NO;
3498  return;
3499  }
3500  if (queue->queue_length >= QUEUE_LENGTH_LIMIT)
3501  {
3503  "# Transmission throttled due to queue queue limit",
3504  1,
3505  GNUNET_NO);
3506  queue->idle = GNUNET_NO;
3507  return;
3508  }
3509  /* queue might indeed be ready, schedule it */
3510  if (NULL != queue->transmit_task)
3512  queue->transmit_task =
3515  "Considering transmission on queue `%s' to %s\n",
3516  queue->address,
3517  GNUNET_i2s (&queue->neighbour->pid));
3518 }
#define COMMUNICATOR_TOTAL_QUEUE_LIMIT
How many messages can we have pending for a given communicator process before we start to throttle th...
struct Neighbour * neighbour
Which neighbour is this queue for?
int idle
Set to GNUNET_YES if this queue is idle waiting for some virtual link to give it a pending message...
#define GNUNET_NO
Definition: gnunet_common.h:81
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
struct GNUNET_SCHEDULER_Task * transmit_task
Task scheduled for the time when this queue can (likely) transmit the next message.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_with_priority(enum GNUNET_SCHEDULER_Priority prio, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified priority.
Definition: scheduler.c:1200
static struct GNUNET_STATISTICS_Handle * GST_stats
Statistics handle.
struct TransportClient::@75::@78 communicator
Information for type CT_COMMUNICATOR.
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-qr.c:59
static void transmit_on_queue(void *cls)
We believe we are ready to transmit a message on a queue.
struct TransportClient * tc
Which communicator offers this queue?
unsigned int queue_length
Length of the DLL starting at queue_head.
struct sockaddr * address
Address of the other peer.
union TransportClient::@75 details
#define GNUNET_log(kind,...)
#define QUEUE_LENGTH_LIMIT
How many messages can we have pending for a given queue (queue to a particular peer via a communicato...
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
struct GNUNET_PeerIdentity pid
Which peer is this about?
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965
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 3573 of file gnunet-service-tng.c.

References Queue::address, check_link_down(), TransportClient::communicator, COMMUNICATOR_TOTAL_QUEUE_LIMIT, MonitorEvent::cs, TransportClient::details, free_neighbour(), GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_MDLL_remove, GNUNET_free, GNUNET_NO, GNUNET_SCHEDULER_cancel(), GNUNET_SCHEDULER_PRIORITY_DEFAULT, GNUNET_STATISTICS_update(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_TRANSPORT_CS_DOWN, lookup_virtual_link(), VirtualLink::n, Queue::neighbour, notify_monitors(), Queue::nt, Queue::pa_head, Queue::pa_tail, Neighbour::pid, QueueEntry::pm, qe, PendingMessage::qe, PendingAcknowledgement::queue, Queue::queue_head, Neighbour::queue_head, Queue::queue_length, Queue::queue_tail, Neighbour::queue_tail, schedule_transmit_on_queue(), tc, Queue::tc, Queue::transmit_task, and VirtualLink::visibility_task.

Referenced by client_disconnect_cb(), and handle_del_queue_message().

3574 {
3575  struct Neighbour *neighbour = queue->neighbour;
3576  struct TransportClient *tc = queue->tc;
3577  struct MonitorEvent me = {.cs = GNUNET_TRANSPORT_CS_DOWN,
3579  struct QueueEntry *qe;
3580  int maxxed;
3581  struct PendingAcknowledgement *pa;
3582  struct VirtualLink *vl;
3583 
3584  if (NULL != queue->transmit_task)
3585  {
3587  queue->transmit_task = NULL;
3588  }
3589  while (NULL != (pa = queue->pa_head))
3590  {
3591  GNUNET_CONTAINER_MDLL_remove (queue, queue->pa_head, queue->pa_tail, pa);
3592  pa->queue = NULL;
3593  }
3594 
3595  GNUNET_CONTAINER_MDLL_remove (neighbour,
3596  neighbour->queue_head,
3597  neighbour->queue_tail,
3598  queue);
3600  tc->details.communicator.queue_head,
3601  tc->details.communicator.queue_tail,
3602  queue);
3603  maxxed = (COMMUNICATOR_TOTAL_QUEUE_LIMIT >=
3604  tc->details.communicator.total_queue_length);
3605  while (NULL != (qe = queue->queue_head))
3606  {
3607  GNUNET_CONTAINER_DLL_remove (queue->queue_head, queue->queue_tail, qe);
3608  queue->queue_length--;
3609  tc->details.communicator.total_queue_length--;
3610  if (NULL != qe->pm)
3611  {
3612  GNUNET_assert (qe == qe->pm->qe);
3613  qe->pm->qe = NULL;
3614  }
3615  GNUNET_free (qe);
3616  }
3617  GNUNET_assert (0 == queue->queue_length);
3618  if ((maxxed) && (COMMUNICATOR_TOTAL_QUEUE_LIMIT <
3619  tc->details.communicator.total_queue_length))
3620  {
3621  /* Communicator dropped below threshold, resume all _other_ queues */
3623  GST_stats,
3624  "# Transmission throttled due to communicator queue limit",
3625  -1,
3626  GNUNET_NO);
3627  for (struct Queue *s = tc->details.communicator.queue_head; NULL != s;
3628  s = s->next_client)
3630  }
3631  notify_monitors (&neighbour->pid, queue->address, queue->nt, &me);
3632  GNUNET_free (queue);
3633 
3634  vl = lookup_virtual_link (&neighbour->pid);
3635  if ((NULL != vl) && (neighbour == vl->n))
3636  {
3638  check_link_down (vl);
3639  }
3640  if (NULL == neighbour->queue_head)
3641  {
3642  free_neighbour (neighbour);
3643  }
3644 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
A connected controller which is not our child.
static GNUNET_NETWORK_STRUCT_END struct GNUNET_PeerIdentity me
Our own peer identity.
static struct GNUNET_DATASTORE_QueueEntry * qe
Current operation.
#define COMMUNICATOR_TOTAL_QUEUE_LIMIT
How many messages can we have pending for a given communicator process before we start to throttle th...
struct Neighbour * neighbour
Which neighbour is this queue for?
struct PendingAcknowledgement * pa_tail
Tail of DLL of PAs that used this queue.
struct QueueEntry * queue_head
Head of DLL of unacked transmission requests.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static struct GNUNET_SCHEDULER_TaskContext tc
Task context of the current task.
Definition: scheduler.c:417
#define GNUNET_NO
Definition: gnunet_common.h:81
struct PendingAcknowledgement * pa_head
Head of DLL of PAs that used this queue.
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
struct GNUNET_SCHEDULER_Task * transmit_task
Task scheduled for the time when this queue can (likely) transmit the next message.
static struct VirtualLink * lookup_virtual_link(const struct GNUNET_PeerIdentity *pid)
Lookup virtual link for peer pid.
Data structure kept when we are waiting for an acknowledgement.
static struct GNUNET_STATISTICS_Handle * GST_stats
Statistics handle.
struct TransportClient::@75::@78 communicator
Information for type CT_COMMUNICATOR.
struct QueueEntry * qe
Set to non-NULL value if this message is currently being given to a communicator and we are awaiting ...
Handle for a queue.
struct QueueEntry * queue_tail
End of DLL of unacked transmission requests.
#define GNUNET_CONTAINER_MDLL_remove(mdll, head, tail, element)
Remove an element from a MDLL.
Details about what to notify monitors about.
struct Queue * queue_tail
Tail of DLL of queues to this peer.
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
struct TransportClient * tc
Which communicator offers this queue?
struct PendingMessage * pm
Pending message this entry is for, or NULL for none.
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...
unsigned int queue_length
Length of the DLL starting at queue_head.
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&#39;s status with respect to some address to all monitors that care...
An entry in the operation queue.
struct sockaddr * address
Address of the other peer.
union TransportClient::@75 details
static void schedule_transmit_on_queue(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 ...
Client connected to the transport service.
struct Queue * queue
Queue used for transmission, NULL if the queue has been destroyed (which may happen before we get an ...
static void free_neighbour(struct Neighbour *neighbour)
Release memory used by neighbour.
enum GNUNET_NetworkType nt
Which network type does this queue use?
Run with the default priority (normal P2P operations).
struct Queue * queue_head
Head of DLL of queues to this peer.
#define GNUNET_free(ptr)
Wrapper around free.
struct GNUNET_PeerIdentity pid
Which peer is this about?
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965
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 3653 of file gnunet-service-tng.c.

References TransportClient::communicator, TransportClient::details, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_PEERSTORE_store_cancel(), GNUNET_SCHEDULER_cancel(), AddressListEntry::sc, AddressListEntry::st, tc, and AddressListEntry::tc.

Referenced by client_disconnect_cb(), and handle_del_address().

3654 {
3655  struct TransportClient *tc = ale->tc;
3656 
3658  tc->details.communicator.addr_tail,
3659  ale);
3660  if (NULL != ale->sc)
3661  {
3663  ale->sc = NULL;
3664  }
3665  if (NULL != ale->st)
3666  {
3667  GNUNET_SCHEDULER_cancel (ale->st);
3668  ale->st = NULL;
3669  }
3670  GNUNET_free (ale);
3671 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
static struct GNUNET_SCHEDULER_TaskContext tc
Task context of the current task.
Definition: scheduler.c:417
struct GNUNET_PEERSTORE_StoreContext * sc
Current context for storing this address in the peerstore.
struct GNUNET_SCHEDULER_Task * st
Task to periodically do st operation.
struct TransportClient * tc
Which communicator provides this address?
struct TransportClient::@75::@78 communicator
Information for type CT_COMMUNICATOR.
void GNUNET_PEERSTORE_store_cancel(struct GNUNET_PEERSTORE_StoreContext *sc)
Cancel a store request.
union TransportClient::@75 details
Client connected to the transport service.
#define GNUNET_free(ptr)
Wrapper around free.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965
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 3683 of file gnunet-service-tng.c.

References TransportClient::application, TransportClient::details, GNUNET_assert, GNUNET_CONTAINER_multipeermap_remove(), GNUNET_free, GNUNET_OK, GNUNET_PEERSTORE_watch_cancel(), GNUNET_YES, PeerRequest::pr, tc, value, and PeerRequest::wc.

Referenced by client_disconnect_cb(), and handle_suggest_cancel().

3686 {
3687  struct TransportClient *tc = cls;
3688  struct PeerRequest *pr = value;
3689 
3691  GNUNET_assert (
3692  GNUNET_YES ==
3694  pid,
3695  pr));
3696  GNUNET_free (pr);
3697 
3698  return GNUNET_OK;
3699 }
void GNUNET_PEERSTORE_watch_cancel(struct GNUNET_PEERSTORE_WatchContext *wc)
Cancel a watch request.
Information per peer and request.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static struct GNUNET_SCHEDULER_TaskContext tc
Task context of the current task.
Definition: scheduler.c:417
struct GSF_PendingRequest * pr
Handle to generic request (generic: from peer or local client).
struct TransportClient::@75::@79 application
Information for type CT_APPLICATION.
int GNUNET_CONTAINER_multipeermap_remove(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, const void *value)
Remove the given key-value pair from the map.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
static char * value
Value of the record to add/remove.
struct GNUNET_PEERSTORE_WatchContext * wc
Handle for watching the peerstore for HELLOs for this peer.
union TransportClient::@75 details
Client connected to the transport service.
#define GNUNET_YES
Definition: gnunet_common.h:80
#define GNUNET_free(ptr)
Wrapper around free.
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 3711 of file gnunet-service-tng.c.

References TransportClient::application, PendingMessage::client, TransportClient::communicator, TransportClient::core, CT_APPLICATION, CT_COMMUNICATOR, CT_CORE, CT_MONITOR, CT_NONE, TransportClient::details, 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_free, GNUNET_log, pm, q, stop_peer_request(), tc, and TransportClient::type.

Referenced by run().

3714 {
3715  struct TransportClient *tc = app_ctx;
3716 
3717  (void) cls;
3718  (void) client;
3720  "Client %p disconnected, cleaning up.\n",
3721  tc);
3723  switch (tc->type)
3724  {
3725  case CT_NONE:
3726  break;
3727  case CT_CORE: {
3728  struct PendingMessage *pm;
3729 
3730  while (NULL != (pm = tc->details.core.pending_msg_head))
3731  {
3733  tc->details.core.pending_msg_head,
3734  tc->details.core.pending_msg_tail,
3735  pm);
3736  pm->client = NULL;
3737  }
3738  }
3739  break;
3740  case CT_MONITOR:
3741  break;
3742  case CT_COMMUNICATOR: {
3743  struct Queue *q;
3744  struct AddressListEntry *ale;
3745 
3746  while (NULL != (q = tc->details.communicator.queue_head))
3747  free_queue (q);
3748  while (NULL != (ale = tc->details.communicator.addr_head))
3750  GNUNET_free (tc->details.communicator.address_prefix);
3751  }
3752  break;
3753  case CT_APPLICATION:
3756  tc);
3758  break;
3759  }
3760  GNUNET_free (tc);
3761 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
struct TransportClient::@75::@76 core
Information for type CT_CORE.
"Application" telling us where to connect (i.e.
static struct GNUNET_SCHEDULER_TaskContext tc
Task context of the current task.
Definition: scheduler.c:417
struct TransportClient::@75::@79 application
Information for type CT_APPLICATION.
static void free_address_list_entry(struct AddressListEntry *ale)
Free ale.
enum ClientType type
What type of client is this?
void GNUNET_CONTAINER_multipeermap_destroy(struct GNUNET_CONTAINER_MultiPeerMap *map)
Destroy a hash map.
struct TransportClient::@75::@78 communicator
Information for type CT_COMMUNICATOR.
Handle for a queue.
static struct TransportClient * clients_tail
Tail of linked list of all clients to this service.
#define GNUNET_CONTAINER_MDLL_remove(mdll, head, tail, element)
Remove an element from a MDLL.
One of the addresses of this peer.
struct TransportClient * client
Client that issued the transmission request, if pmt is PMT_CORE.
static struct TransportClient * clients_head
Head of linked list of all clients to this service.
static struct GNUNET_REVOCATION_Query * q
Handle for revocation query.
We do not know yet (client is fresh).
Is the CORE service, we need to forward traffic to it.
It is a monitor, forward monitor data.
static int stop_peer_request(void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
Stop the peer request in value.
int GNUNET_CONTAINER_multipeermap_iterate(struct GNUNET_CONTAINER_MultiPeerMap *map, GNUNET_CONTAINER_PeerMapIterator it, void *it_cls)
Iterate over all entries in the map.
union TransportClient::@75 details
Client connected to the transport service.
#define GNUNET_log(kind,...)
List containing all messages that are yet to be send.
It is a communicator, use for communication.
static void free_queue(struct Queue *queue)
Free queue.
#define GNUNET_free(ptr)
Wrapper around free.
static struct GNUNET_TRANSPORT_PluginMonitor * pm
Handle if we are monitoring plugin session activity.
Here is the call graph for this function:
Here is the caller 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 3774 of file gnunet-service-tng.c.

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

Referenced by handle_client_start().

3777 {
3778  struct TransportClient *tc = cls;
3779 
3780  (void) value;
3782  "Telling new CORE client about existing connection to %s\n",
3783  GNUNET_i2s (pid));
3784  core_send_connect_info (tc, pid);
3785  return GNUNET_OK;
3786 }
static struct GNUNET_SCHEDULER_TaskContext tc
Task context of the current task.
Definition: scheduler.c:417
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
static char * value
Value of the record to add/remove.
Client connected to the transport service.
#define GNUNET_log(kind,...)
static void core_send_connect_info(struct TransportClient *tc, const struct GNUNET_PeerIdentity *pid)
Send message to CORE clients that we lost a connection.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
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 3798 of file gnunet-service-tng.c.

References TransportClient::client, 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, notify_client_connect_info(), options, StartMessage::options, StartMessage::self, tc, and TransportClient::type.

3799 {
3800  struct TransportClient *tc = cls;
3801  uint32_t options;
3802 
3803  options = ntohl (start->options);
3804  if ((0 != (1 & options)) &&
3805  (0 != GNUNET_memcmp (&start->self, &GST_my_identity)))
3806  {
3807  /* client thinks this is a different peer, reject */
3808  GNUNET_break (0);
3810  return;
3811  }
3812  if (CT_NONE != tc->type)
3813  {
3814  GNUNET_break (0);
3816  return;
3817  }
3818  tc->type = CT_CORE;
3820  "New CORE client with PID %s registered\n",
3821  GNUNET_i2s (&start->self));
3824  tc);
3826 }
static struct GNUNET_PeerIdentity GST_my_identity
Our public key.
static struct GNUNET_CONTAINER_MultiPeerMap * neighbours
Map from PIDs to struct Neighbour entries.
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
static struct GNUNET_SCHEDULER_TaskContext tc
Task context of the current task.
Definition: scheduler.c:417
struct GNUNET_PeerIdentity self
Identity we think we have.
Definition: transport.h:110
struct GNUNET_SERVICE_Client * client
Handle to the client.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
enum ClientType type
What type of client is this?
uint32_t options
0: no options 1: The self field should be checked 2: this client is interested in payload traffic ...
Definition: transport.h:104
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:2618
We do not know yet (client is fresh).
Is the CORE service, we need to forward traffic to it.
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
int GNUNET_CONTAINER_multipeermap_iterate(struct GNUNET_CONTAINER_MultiPeerMap *map, GNUNET_CONTAINER_PeerMapIterator it, void *it_cls)
Iterate over all entries in the map.
Client connected to the transport service.
#define GNUNET_log(kind,...)
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2533
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 3836 of file gnunet-service-tng.c.

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

3837 {
3838  struct TransportClient *tc = cls;
3839  uint16_t size;
3840  const struct GNUNET_MessageHeader *obmm;
3841 
3842  if (CT_CORE != tc->type)
3843  {
3844  GNUNET_break (0);
3845  return GNUNET_SYSERR;
3846  }
3847  size = ntohs (obm->header.size) - sizeof (struct OutboundMessage);
3848  if (size < sizeof (struct GNUNET_MessageHeader))
3849  {
3850  GNUNET_break (0);
3851  return GNUNET_SYSERR;
3852  }
3853  obmm = (const struct GNUNET_MessageHeader *) &obm[1];
3854  if (size != ntohs (obmm->size))
3855  {
3856  GNUNET_break (0);
3857  return GNUNET_SYSERR;
3858  }
3859  return GNUNET_OK;
3860 }
struct GNUNET_MessageHeader header
Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_SEND.
Definition: transport.h:302
static struct GNUNET_SCHEDULER_TaskContext tc
Task context of the current task.
Definition: scheduler.c:417
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
enum ClientType type
What type of client is this?
Message used to notify the transport service about a message to be transmitted to another peer...
Definition: transport.h:296
#define GNUNET_SYSERR
Definition: gnunet_common.h:79
static unsigned int size
Size of the "table".
Definition: peer.c:67
Is the CORE service, we need to forward traffic to it.
Client connected to the transport service.
Header for all communications.

◆ 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 3871 of file gnunet-service-tng.c.

References PendingMessage::client, env, free_pending_message(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK, GNUNET_MQ_msg, GNUNET_MQ_send(), PendingMessage::logging_uuid, TransportClient::mq, SendOkMessage::peer, VirtualLink::target, tc, and PendingMessage::vl.

Referenced by completed_pending_message(), and reliability_box_message().

3872 {
3873  struct TransportClient *tc = pm->client;
3874  struct VirtualLink *vl = pm->vl;
3875 
3876  if (NULL != tc)
3877  {
3878  struct GNUNET_MQ_Envelope *env;
3879  struct SendOkMessage *som;
3880 
3882  som->peer = vl->target;
3884  "Confirming transmission of <%llu> to %s\n",
3885  pm->logging_uuid,
3886  GNUNET_i2s (&vl->target));
3887  GNUNET_MQ_send (tc->mq, env);
3888  }
3889  free_pending_message (pm);
3890 }
unsigned long long logging_uuid
UUID we use to identify this message in our logs.
static struct GNUNET_SCHEDULER_TaskContext tc
Task context of the current task.
Definition: scheduler.c:417
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
struct TransportClient * client
Client that issued the transmission request, if pmt is PMT_CORE.
struct GNUNET_MQ_Handle * mq
Message queue to the client.
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
#define GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK
Confirmation from TRANSPORT that message for transmission has been queued (and that the next message ...
struct VirtualLink * vl
Target of the request (always the ultimate destination!).
Message used to notify the transport API that it can send another message to the transport service...
Definition: transport.h:223
struct GNUNET_PeerIdentity peer
Which peer can send more now?
Definition: transport.h:262
Client connected to the transport service.
#define GNUNET_log(kind,...)
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:353
static void free_pending_message(struct PendingMessage *pm)
Release memory associated with pm and remove pm from associated data structures.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
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 3903 of file gnunet-service-tng.c.

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, GNUNET_TIME_Relative::rel_value_us, and RMO_UNCONFIRMED_ALLOWED.

Referenced by route_control_message_without_fc().

3907 {
3908  uint64_t choices[hops_array_length];
3909  uint64_t num_dv;
3910  unsigned int dv_count;
3911 
3912  /* Pick random vectors, but weighted by distance, giving more weight
3913  to shorter vectors */
3914  num_dv = 0;
3915  dv_count = 0;
3916  for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos;
3917  pos = pos->next_dv)
3918  {
3919  if ((0 == (options & RMO_UNCONFIRMED_ALLOWED)) &&
3920  (GNUNET_TIME_absolute_get_remaining (pos->path_valid_until)
3921  .rel_value_us == 0))
3922  continue; /* pos unconfirmed and confirmed required */
3923  num_dv += MAX_DV_HOPS_ALLOWED - pos->distance;
3924  dv_count++;
3925  }
3926  if (0 == dv_count)
3927  return 0;
3928  if (dv_count <= hops_array_length)
3929  {
3930  dv_count = 0;
3931  for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos;
3932  pos = pos->next_dv)
3933  hops_array[dv_count++] = pos;
3934  return dv_count;
3935  }
3936  for (unsigned int i = 0; i < hops_array_length; i++)
3937  {
3938  int ok = GNUNET_NO;
3939  while (GNUNET_NO == ok)
3940  {
3941  choices[i] =
3943  ok = GNUNET_YES;
3944  for (unsigned int j = 0; j < i; j++)
3945  if (choices[i] == choices[j])
3946  {
3947  ok = GNUNET_NO;
3948  break;
3949  }
3950  }
3951  }
3952  dv_count = 0;
3953  num_dv = 0;
3954  for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos;
3955  pos = pos->next_dv)
3956  {
3957  uint32_t delta = MAX_DV_HOPS_ALLOWED - pos->distance;
3958 
3959  if ((0 == (options & RMO_UNCONFIRMED_ALLOWED)) &&
3960  (GNUNET_TIME_absolute_get_remaining (pos->path_valid_until)
3961  .rel_value_us == 0))
3962  continue; /* pos unconfirmed and confirmed required */
3963  for (unsigned int i = 0; i < hops_array_length; i++)
3964  if ((num_dv <= choices[i]) && (num_dv + delta > choices[i]))
3965  hops_array[dv_count++] = pos;
3966  num_dv += delta;
3967  }
3968  return dv_count;
3969 }
uint64_t rel_value_us
The actual value.
static struct GNUNET_TIME_Relative delta
Definition: speedup.c:35
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
uint64_t GNUNET_CRYPTO_random_u64(enum GNUNET_CRYPTO_Quality mode, uint64_t max)
Random on unsigned 64-bit values.
static int ok
Return value from &#39;main&#39; (0 == success)
#define GNUNET_NO
Definition: gnunet_common.h:81
We are allowed to use unconfirmed queues or DV routes for this message.
#define MAX_DV_HOPS_ALLOWED
Maximum DV distance allowed ever.
One possible hop towards a DV target.
struct DistanceVectorHop * next_dv
Kept in a MDLL, sorted by timeout.
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_remaining(struct GNUNET_TIME_Absolute future)
Given a timestamp in the future, how much time remains until then?
Definition: time.c:331
#define GNUNET_YES
Definition: gnunet_common.h:80
struct DistanceVectorHop * dv_head
Known paths to target.
No good quality of the operation is needed (i.e., random numbers can be pseudo-random).
Here is the call graph for this function:
Here is the caller 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 3979 of file gnunet-service-tng.c.

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

3982 {
3983  struct TransportClient *tc = cls;
3984  uint16_t size;
3985 
3986  if (CT_NONE != tc->type)
3987  {
3988  GNUNET_break (0);
3989  return GNUNET_SYSERR;
3990  }
3991  tc->type = CT_COMMUNICATOR;
3992  size = ntohs (cam->header.size) - sizeof (*cam);
3993  if (0 == size)
3994  return GNUNET_OK; /* receive-only communicator */
3996  return GNUNET_OK;
3997 }
static struct GNUNET_SCHEDULER_TaskContext tc
Task context of the current task.
Definition: scheduler.c:417
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
enum ClientType type
What type of client is this?
#define GNUNET_MQ_check_zero_termination(m)
Insert code for a "check_" function that verifies that a given variable-length message received over ...
#define GNUNET_SYSERR
Definition: gnunet_common.h:79
static unsigned int size
Size of the "table".
Definition: peer.c:67
We do not know yet (client is fresh).
Client connected to the transport service.
It is a communicator, use for communication.

◆ 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 4006 of file gnunet-service-tng.c.

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_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().

4007 {
4008  if (0 != ntohl (cmc->im.fc_on))
4009  {
4010  /* send ACK when done to communicator for flow control! */
4011  struct GNUNET_MQ_Envelope *env;
4012  struct GNUNET_TRANSPORT_IncomingMessageAck *ack;
4013 
4015  ack->reserved = htonl (0);
4016  ack->fc_id = cmc->im.fc_id;
4017  ack->sender = cmc->im.sender;
4018  GNUNET_MQ_send (cmc->tc->mq, env);
4019  }
4021  GNUNET_free (cmc);
4022 }
struct GNUNET_TRANSPORT_IncomingMessage im
Additional information for flow control and about the sender.
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
struct GNUNET_SERVICE_Client * client
Handle to the client.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_INCOMING_MSG_ACK
transport acknowledges processing an incoming message
struct TransportClient * tc
Which communicator provided us with the message.
struct GNUNET_MQ_Handle * mq
Message queue to the client.
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
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:353
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2533
#define GNUNET_free(ptr)
Wrapper around free.
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 4035 of file gnunet-service-tng.c.

References TransportClient::client, VirtualLink::cmc_head, VirtualLink::cmc_tail, 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(), RecvOkMessage::increase_window_delta, lookup_virtual_link(), RecvOkMessage::peer, tc, and TransportClient::type.

4036 {
4037  struct TransportClient *tc = cls;
4038  struct VirtualLink *vl;
4039  uint32_t delta;
4040  struct CommunicatorMessageContext *cmc;
4041 
4042  if (CT_CORE != tc->type)
4043  {
4044  GNUNET_break (0);
4046  return;
4047  }
4048  vl = lookup_virtual_link (&rom->peer);
4049  if (NULL == vl)
4050  {
4052  "# RECV_OK dropped: virtual link unknown",
4053  1,
4054  GNUNET_NO);
4056  return;
4057  }
4058  delta = ntohl (rom->increase_window_delta);
4059  vl->core_recv_window += delta;
4060  if (vl->core_recv_window <= 0)
4061  return;
4062  /* resume communicators */
4063  while (NULL != (cmc = vl->cmc_tail))
4064  {
4066  finish_cmc_handling (cmc);
4067  }
4068 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
static struct GNUNET_TIME_Relative delta
Definition: speedup.c:35
static struct GNUNET_SCHEDULER_TaskContext tc
Task context of the current task.
Definition: scheduler.c:417
struct GNUNET_PeerIdentity peer
Which peer can CORE handle more from now?
Definition: transport.h:288
Context from handle_incoming_msg().
#define GNUNET_NO
Definition: gnunet_common.h:81
uint32_t increase_window_delta
Number of messages by which to increase the window, greater or equal to one.
Definition: transport.h:283
struct GNUNET_SERVICE_Client * client
Handle to the client.
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
enum ClientType type
What type of client is this?
static struct VirtualLink * lookup_virtual_link(const struct GNUNET_PeerIdentity *pid)
Lookup virtual link for peer pid.
static struct GNUNET_STATISTICS_Handle * GST_stats
Statistics handle.
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2618
Is the CORE service, we need to forward traffic to it.
Client connected to the transport service.
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2533
static void finish_cmc_handling(struct CommunicatorMessageContext *cmc)
Send ACK to communicator (if requested) and free cmc.
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 4078 of file gnunet-service-tng.c.

References TransportClient::client, TransportClient::communicator, TransportClient::details, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_SERVICE_client_continue(), GNUNET_strdup, size, and tc.

4081 {
4082  struct TransportClient *tc = cls;
4083  uint16_t size;
4084 
4085  size = ntohs (cam->header.size) - sizeof (*cam);
4086  if (0 == size)
4087  {
4089  "Receive-only communicator connected\n");
4090  return; /* receive-only communicator */
4091  }
4092  tc->details.communicator.address_prefix =
4093  GNUNET_strdup ((const char *) &cam[1]);
4094  tc->details.communicator.cc =
4095  (enum GNUNET_TRANSPORT_CommunicatorCharacteristics) ntohl (cam->cc);
4097  "Communicator with prefix `%s' connected\n",
4098  tc->details.communicator.address_prefix);
4100 }
GNUNET_TRANSPORT_CommunicatorCharacteristics
What characteristics does this communicator have?
static struct GNUNET_SCHEDULER_TaskContext tc
Task context of the current task.
Definition: scheduler.c:417
struct GNUNET_SERVICE_Client * client
Handle to the client.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
struct TransportClient::@75::@78 communicator
Information for type CT_COMMUNICATOR.
static unsigned int size
Size of the "table".
Definition: peer.c:67
union TransportClient::@75 details
Client connected to the transport service.
#define GNUNET_log(kind,...)
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2533
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 4111 of file gnunet-service-tng.c.

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

4114 {
4115  const struct GNUNET_MessageHeader *inbox;
4116  const char *is;
4117  uint16_t msize;
4118  uint16_t isize;
4119 
4120  (void) cls;
4121  msize = ntohs (cb->header.size) - sizeof (*cb);
4122  inbox = (const struct GNUNET_MessageHeader *) &cb[1];
4123  isize = ntohs (inbox->size);
4124  if (isize >= msize)
4125  {
4126  GNUNET_break (0);
4127  return GNUNET_SYSERR;
4128  }
4129  is = (const char *) inbox;
4130  is += isize;
4131  msize -= isize;
4132  GNUNET_assert (0 < msize);
4133  if ('\0' != is[msize - 1])
4134  {
4135  GNUNET_break (0);
4136  return GNUNET_SYSERR;
4137  }
4138  return GNUNET_OK;
4139 }
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
static struct GNUNET_NT_InterfaceScanner * is
Network scanner to determine network types.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
#define GNUNET_SYSERR
Definition: gnunet_common.h:79
Header for all communications.

◆ 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 4149 of file gnunet-service-tng.c.

References EphemeralConfirmationPS::ephemeral_key, DistanceVector::ephemeral_key, EPHEMERAL_VALIDITY, DistanceVector::ephemeral_validity, GNUNET_assert, GNUNET_CRYPTO_ecdhe_key_create2(), GNUNET_CRYPTO_ecdhe_key_get_public(), GNUNET_CRYPTO_eddsa_sign(), GNUNET_OK, GNUNET_SIGNATURE_PURPOSE_TRANSPORT_EPHEMERAL, GNUNET_TIME_absolute_add(), GNUNET_TIME_absolute_get_monotonic(), GNUNET_TIME_absolute_get_remaining(), DistanceVector::monotime, DistanceVector::private_key, GNUNET_CRYPTO_EccSignaturePurpose::purpose, EphemeralConfirmationPS::purpose, GNUNET_TIME_Relative::rel_value_us, DistanceVector::sender_sig, GNUNET_CRYPTO_EccSignaturePurpose::size, EphemeralConfirmationPS::target, and DistanceVector::target.

Referenced by encapsulate_for_dv().

4150 {
4151  struct EphemeralConfirmationPS ec;
4152 
4153  if (0 !=
4155  return;
4157  dv->ephemeral_validity =
4162  ec.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_EPHEMERAL);
4163  ec.purpose.size = htonl (sizeof (ec));
4164  ec.target = dv->target;
4165  ec.ephemeral_key = dv->ephemeral_key;
4167  &ec.purpose,
4168  &dv->sender_sig));
4169 }
int GNUNET_CRYPTO_ecdhe_key_create2(struct GNUNET_CRYPTO_EcdhePrivateKey *pk)
Create a new private key.
Definition: crypto_ecc.c:632
struct GNUNET_TIME_Absolute ephemeral_validity
How long is sender_sig valid.
uint64_t rel_value_us
The actual value.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
int GNUNET_CRYPTO_eddsa_sign(const struct GNUNET_CRYPTO_EddsaPrivateKey *priv, const struct GNUNET_CRYPTO_EccSignaturePurpose *purpose, struct GNUNET_CRYPTO_EddsaSignature *sig)
EdDSA sign a given block.
Definition: crypto_ecc.c:989
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_add(struct GNUNET_TIME_Absolute start, struct GNUNET_TIME_Relative duration)
Add a given relative duration to the given start time.
Definition: time.c:393
struct GNUNET_CRYPTO_EcdhePublicKey ephemeral_key
Our ephemeral key.
struct GNUNET_TIME_Absolute monotime
What time was sender_sig created.
#define EPHEMERAL_VALIDITY
How long are ephemeral keys valid?
Body by which a peer confirms that it is using an ephemeral key.
struct GNUNET_CRYPTO_EcdhePrivateKey private_key
Our private ephemeral key.
#define GNUNET_SIGNATURE_PURPOSE_TRANSPORT_EPHEMERAL
Signature by a peer affirming that the given ephemeral key is currently in use by that peer&#39;s transpo...
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:303
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:807
struct GNUNET_CRYPTO_EddsaSignature sender_sig
Signature affirming ephemeral_key of type GNUNET_SIGNATURE_PURPOSE_TRANSPORT_EPHEMERAL.
static struct GNUNET_CRYPTO_EddsaPrivateKey * GST_my_private_key
Our private key.
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_remaining(struct GNUNET_TIME_Absolute future)
Given a timestamp in the future, how much time remains until then?
Definition: time.c:331
static const struct GNUNET_CONFIGURATION_Handle * GST_cfg
Configuration handle.
struct GNUNET_PeerIdentity target
To which peer is this a route?
Here is the call graph for this function:
Here is the caller 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 4182 of file gnunet-service-tng.c.

References TransportClient::communicator, COMMUNICATOR_TOTAL_QUEUE_LIMIT, CT_COMMUNICATOR, TransportClient::details, 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, Queue::idle, PendingMessage::logging_uuid, QueueEntry::mid, Queue::mid_gen, TransportClient::mq, Queue::neighbour, Neighbour::pid, pm, QueueEntry::pm, qe, PendingMessage::qe, Queue::qid, queue(), QueueEntry::queue, Queue::queue_head, Queue::queue_length, QUEUE_LENGTH_LIMIT, Queue::queue_tail, Queue::tc, and TransportClient::type.

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

4186 {
4187  struct Neighbour *n = queue->neighbour;
4188  struct GNUNET_TRANSPORT_SendMessageTo *smt;
4189  struct GNUNET_MQ_Envelope *env;
4190 
4191  queue->idle = GNUNET_NO;
4192  GNUNET_log (
4194  "Queueing %u bytes of payload for transmission <%llu> on queue %llu to %s\n",
4195  (unsigned int) payload_size,
4196  (NULL == pm) ? 0 : pm->logging_uuid,
4197  (unsigned long long) queue->qid,
4198  GNUNET_i2s (&queue->neighbour->pid));
4199  env = GNUNET_MQ_msg_extra (smt,
4200  payload_size,
4202  smt->qid = queue->qid;
4203  smt->mid = queue->mid_gen;
4204  smt->receiver = n->pid;
4205  memcpy (&smt[1], payload, payload_size);
4206  {
4207  /* Pass the env to the communicator of queue for transmission. */
4208  struct QueueEntry *qe;
4209 
4210  qe = GNUNET_new (struct QueueEntry);
4211  qe->mid = queue->mid_gen++;
4212  qe->queue = queue;
4213  if (NULL != pm)
4214  {
4215  qe->pm = pm;
4216  GNUNET_assert (NULL == pm->qe);
4217  pm->qe = qe;
4218  }
4219  GNUNET_CONTAINER_DLL_insert (queue->queue_head, queue->queue_tail, qe);
4220  GNUNET_assert (CT_COMMUNICATOR == queue->tc->type);
4221  queue->queue_length++;
4222  queue->tc->details.communicator.total_queue_length++;
4224  queue->tc->details.communicator.total_queue_length)
4225  queue->idle = GNUNET_NO;
4226  if (QUEUE_LENGTH_LIMIT == queue->queue_length)
4227  queue->idle = GNUNET_NO;
4228  GNUNET_MQ_send (queue->tc->mq, env);
4229  }
4230 }
A connected controller which is not our child.
static void queue(const char *hostname)
Add hostname to the list of requests to be made.
static struct GNUNET_DATASTORE_QueueEntry * qe
Current operation.
#define COMMUNICATOR_TOTAL_QUEUE_LIMIT
How many messages can we have pending for a given communicator process before we start to throttle th...
#define GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_MSG
transport tells communicator it wants to transmit
struct Neighbour * neighbour
Which neighbour is this queue for?
uint32_t qid
Unique identifier of this queue with the communicator.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
int idle
Set to GNUNET_YES if this queue is idle waiting for some virtual link to give it a pending message...
unsigned long long logging_uuid
UUID we use to identify this message in our logs.
struct QueueEntry * queue_head
Head of DLL of unacked transmission requests.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_NO
Definition: gnunet_common.h:81
#define GNUNET_new(type)
Allocate a struct or union of the given type.
enum ClientType type
What type of client is this?
#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
struct TransportClient::@75::@78 communicator
Information for type CT_COMMUNICATOR.
struct QueueEntry * qe
Set to non-NULL value if this message is currently being given to a communicator and we are awaiting ...
struct QueueEntry * queue_tail
End of DLL of unacked transmission requests.
struct Queue * queue
Queue this entry is queued with.
struct TransportClient * tc
Which communicator offers this queue?
struct PendingMessage * pm
Pending message this entry is for, or NULL for none.
unsigned int queue_length
Length of the DLL starting at queue_head.
struct GNUNET_MQ_Handle * mq
Message queue to the client.
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
static unsigned long long payload
How much data are we currently storing in the database?
uint64_t mid_gen
Message ID generator for transmissions on this queue to the communicator.
An entry in the operation queue.
union TransportClient::@75 details
#define GNUNET_log(kind,...)
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:353
#define QUEUE_LENGTH_LIMIT
How many messages can we have pending for a given queue (queue to a particular peer via a communicato...
It is a communicator, use for communication.
uint64_t mid
Message ID used for this message with the queue used for transmission.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
static struct GNUNET_TRANSPORT_PluginMonitor * pm
Handle if we are monitoring plugin session activity.
struct GNUNET_PeerIdentity pid
Which peer is this about?
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 4244 of file gnunet-service-tng.c.

References GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u32(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_get(), GNUNET_TIME_relative_min(), GNUNET_TIME_UNIT_FOREVER_REL, options, queue_send_msg(), RMO_REDUNDANT, RMO_UNCONFIRMED_ALLOWED, GNUNET_MessageHeader::size, and GNUNET_MessageHeader::type.

Referenced by route_control_message_without_fc(), and send_dv_to_neighbour().

4247 {
4248  struct GNUNET_TIME_Absolute now;
4249  unsigned int candidates;
4250  unsigned int sel1;
4251  unsigned int sel2;
4252  struct GNUNET_TIME_Relative rtt;
4253 
4254  /* Pick one or two 'random' queues from n (under constraints of options) */
4255  now = GNUNET_TIME_absolute_get ();
4256  /* FIXME-OPTIMIZE: give queues 'weights' and pick proportional to
4257  weight in the future; weight could be assigned by observed
4258  bandwidth (note: not sure if we should do this for this type
4259  of control traffic though). */
4260  candidates = 0;
4261  for (struct Queue *pos = n->queue_head; NULL != pos;
4262  pos = pos->next_neighbour)
4263  {
4264  if ((0 == (options & RMO_UNCONFIRMED_ALLOWED)) ||
4265  (pos->validated_until.abs_value_us > now.abs_value_us))
4266  candidates++;
4267  }
4268  if (0 == candidates)
4269  {
4270  /* This can happen rarely if the last confirmed queue timed
4271  out just as we were beginning to process this message. */
4273  "Could not route message of type %u to %s: no valid queue\n",
4274  ntohs (hdr->type),
4275  GNUNET_i2s (&n->pid));
4277  "# route selection failed (all no valid queue)",
4278  1,
4279  GNUNET_NO);
4281  }
4282 
4285  if (0 == (options & RMO_REDUNDANT))
4286  sel2 = candidates; /* picks none! */
4287  else
4289  candidates = 0;
4290  for (struct Queue *pos = n->queue_head; NULL != pos;
4291  pos = pos->next_neighbour)
4292  {
4293  if ((0 == (options & RMO_UNCONFIRMED_ALLOWED)) ||
4294  (pos->validated_until.abs_value_us > now.abs_value_us))
4295  {
4296  if ((sel1 == candidates) || (sel2 == candidates))
4297  {
4299  "Routing message of type %u to %s using %s (#%u)\n",
4300  ntohs (hdr->type),
4301  GNUNET_i2s (&n->pid),
4302  pos->address,
4303  (sel1 == candidates) ? 1 : 2);
4304  rtt = GNUNET_TIME_relative_min (rtt, pos->pd.aged_rtt);
4305  queue_send_msg (pos, NULL, hdr, ntohs (hdr->size));
4306  }
4307  candidates++;
4308  }
4309  }
4310  return rtt;
4311 }
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
uint32_t GNUNET_CRYPTO_random_u32(enum GNUNET_CRYPTO_Quality mode, uint32_t i)
Produce a random value.
#define GNUNET_NO
Definition: gnunet_common.h:81
If we have multiple choices, it is OK to send this message over multiple channels at the same time to...
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
We are allowed to use unconfirmed queues or DV routes for this message.
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
static struct GNUNET_STATISTICS_Handle * GST_stats
Statistics handle.
Handle for a queue.
struct Queue * next_neighbour
Kept in a MDLL.
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
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:271
#define GNUNET_log(kind,...)
static void queue_send_msg(struct Queue *queue, struct PendingMessage *pm, const void *payload, size_t payload_size)
Send the message payload on queue.
Time for absolute times used by GNUnet, in microseconds.
struct Queue * queue_head
Head of DLL of queues to this peer.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
No good quality of the operation is needed (i.e., random numbers can be pseudo-random).
Time for relative time used by GNUnet, in microseconds.
struct GNUNET_PeerIdentity pid
Which peer is this about?
Here is the call graph for this function:
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 4358 of file gnunet-service-tng.c.

References DVKeyState::aes_ctr, DVKeyState::aes_key, DVKeyState::cipher, GNUNET_assert, GNUNET_CRYPTO_kdf(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_sh2s(), GNUNET_YES, and DVKeyState::material.

Referenced by dh_key_derive_eph_pid(), and dh_key_derive_eph_pub().

4361 {
4362  /* must match #dh_key_derive_eph_pub */
4364  GNUNET_CRYPTO_kdf (&key->material,
4365  sizeof (key->material),
4366  "transport-backchannel-key",
4367  strlen ("transport-backchannel-key"),
4368  &km,
4369  sizeof (km),
4370  iv,
4371  sizeof (*iv)));
4373  "Deriving backchannel key based on KM %s and IV %s\n",
4374  GNUNET_h2s (km),
4375  GNUNET_sh2s (iv));
4376  gcry_cipher_open (&key->cipher,
4377  GCRY_CIPHER_AES256 /* low level: go for speed */,
4378  GCRY_CIPHER_MODE_CTR,
4379  0 /* flags */);
4380  gcry_cipher_setkey (key->cipher,
4381  &key->material.aes_key,
4382  sizeof (key->material.aes_key));
4383  gcry_cipher_setctr (key->cipher,
4384  &key->material.aes_ctr,
4385  sizeof (key->material.aes_ctr));
4386 }
const char * GNUNET_sh2s(const struct GNUNET_ShortHashCode *shc)
Convert a short hash value to a string (for printing debug messages).
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
struct DVKeyState::@80 material
Actual key material.
gcry_cipher_hd_t cipher
State of our block cipher.
#define GNUNET_log(kind,...)
char aes_ctr[128/8]
Counter value to use during setup.
#define GNUNET_YES
Definition: gnunet_common.h:80
int 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:91
char aes_key[256/8]
Symmetric key to use for encryption.
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 4399 of file gnunet-service-tng.c.

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

Referenced by encapsulate_for_dv().

4404 {
4405  struct GNUNET_HashCode km;
4406 
4408  &target->public_key,
4409  &km));
4410  dv_setup_key_state_from_km (&km, iv, key);
4411 }
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
A 512-bit hashcode.
int 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:1614
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...
#define GNUNET_YES
Definition: gnunet_common.h:80
struct GNUNET_CRYPTO_EddsaPublicKey public_key
Here is the call graph for this function:
Here is the caller 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 4424 of file gnunet-service-tng.c.

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

Referenced by handle_dv_box().

4427 {
4428  struct GNUNET_HashCode km;
4429 
4431  pub_ephemeral,
4432  &km));
4433  dv_setup_key_state_from_km (&km, iv, key);
443